Restoring authorship annotation for <spuchin@yandex-team.ru>. Commit 1 of 2.

748 files changed, 62573 insertions, 62573 deletions

diff --git a/contrib/tools/ya.make b/contrib/tools/ya.make
index 750911c587..90fe6c00a2 100644
--- a/contrib/tools/ya.make
+++ b/contrib/tools/ya.make
@@ -38,7 +38,7 @@ RECURSE(
     sqlite3
     swig
     tf
-    tpce-benchmark
+    tpce-benchmark 
     tpch-benchmark
     tre
     unbound
diff --git a/library/cpp/actors/core/callstack.cpp b/library/cpp/actors/core/callstack.cpp
index 9297c1a079..491c19a4e6 100644
--- a/library/cpp/actors/core/callstack.cpp
+++ b/library/cpp/actors/core/callstack.cpp
@@ -24,8 +24,8 @@ namespace NActors {
         }
 
         ++ActorBackTraceEnableCounter;
-    }
-
+    } 
+ 
     void DisableActorCallstack() {
         --ActorBackTraceEnableCounter;
 
@@ -35,13 +35,13 @@ namespace NActors {
             PreviousFormatBackTrace = 0;
         }
     }
-
+ 
     TCallstack::TCallstack()
         : BeginIdx(0)
         , Size(0)
         , LinesToSkip(0)
     {
-    }
+    } 
 
     void TCallstack::SetLinesToSkip() {
         TTrace record;
diff --git a/library/cpp/actors/testlib/test_runtime.cpp b/library/cpp/actors/testlib/test_runtime.cpp
index 6fa25b9965..73ba61ed97 100644
--- a/library/cpp/actors/testlib/test_runtime.cpp
+++ b/library/cpp/actors/testlib/test_runtime.cpp
@@ -479,7 +479,7 @@ namespace NActors {
         , EventFilterFunc(&TTestActorRuntimeBase::DefaultFilterFunc)
         , ScheduledEventFilterFunc(&TTestActorRuntimeBase::NopFilterFunc)
         , RegistrationObserver(&TTestActorRuntimeBase::DefaultRegistrationObserver)
-        , CurrentDispatchContext(nullptr)
+        , CurrentDispatchContext(nullptr) 
     {
         SetDispatcherRandomSeed(TInstant::Now(), 0);
         EnableActorCallstack();
@@ -775,19 +775,19 @@ namespace NActors {
 
     void TTestActorRuntimeBase::SetLogBackend(const TAutoPtr<TLogBackend> logBackend) {
         Y_VERIFY(!IsInitialized);
-        TGuard<TMutex> guard(Mutex);
-        LogBackend = logBackend;
-    }
-
+        TGuard<TMutex> guard(Mutex); 
+        LogBackend = logBackend; 
+    } 
+ 
     void TTestActorRuntimeBase::SetLogPriority(NActors::NLog::EComponent component, NActors::NLog::EPriority priority) {
         TGuard<TMutex> guard(Mutex);
         for (ui32 nodeIndex = 0; nodeIndex < NodeCount; ++nodeIndex) {
             TNodeDataBase* node = Nodes[FirstNodeId + nodeIndex].Get();
             TString explanation;
-            auto status = node->LogSettings->SetLevel(priority, component, explanation);
-            if (status) {
-                Y_FAIL("SetLogPriority failed: %s", explanation.c_str());
-            }
+            auto status = node->LogSettings->SetLevel(priority, component, explanation); 
+            if (status) { 
+                Y_FAIL("SetLogPriority failed: %s", explanation.c_str()); 
+            } 
         }
     }
 
@@ -1050,19 +1050,19 @@ namespace NActors {
 
         struct TDispatchContextSetter {
             TDispatchContextSetter(TTestActorRuntimeBase& runtime, TDispatchContext& lastContext)
-                : Runtime(runtime)
+                : Runtime(runtime) 
             {
-                lastContext.PrevContext = Runtime.CurrentDispatchContext;
-                Runtime.CurrentDispatchContext = &lastContext;
+                lastContext.PrevContext = Runtime.CurrentDispatchContext; 
+                Runtime.CurrentDispatchContext = &lastContext; 
             }
 
             ~TDispatchContextSetter() {
-                Runtime.CurrentDispatchContext = Runtime.CurrentDispatchContext->PrevContext;
+                Runtime.CurrentDispatchContext = Runtime.CurrentDispatchContext->PrevContext; 
             }
 
             TTestActorRuntimeBase& Runtime;
-        } DispatchContextSetter(*this, localContext);
-
+        } DispatchContextSetter(*this, localContext); 
+ 
         TInstant dispatchTime = TInstant::MicroSeconds(0);
         TInstant deadline = dispatchTime + DispatchTimeout;
         const TDuration scheduledEventsInspectInterval = TDuration::MilliSeconds(10);
@@ -1781,7 +1781,7 @@ namespace NActors {
             , AdditionalActors(additionalActors)
             , Context(context)
             , HasReply(false)
-            , Runtime(runtime)
+            , Runtime(runtime) 
             , ReplyChecker(createReplyChecker())
         {
             if (IsSync) {
@@ -1835,14 +1835,14 @@ namespace NActors {
                     int count = 100;
                     while (!HasReply && count > 0) {
                         try {
-                            Runtime->DispatchEvents(DelegateeOptions);
+                            Runtime->DispatchEvents(DelegateeOptions); 
                         } catch (TEmptyEventQueueException&) {
                             count--;
                             Cerr << "No reply" << Endl;
                         }
                     }
 
-                    Runtime->UpdateCurrentTime(Runtime->GetCurrentTime() + TDuration::MicroSeconds(1000));
+                    Runtime->UpdateCurrentTime(Runtime->GetCurrentTime() + TDuration::MicroSeconds(1000)); 
                 }
             }
         }
@@ -1877,7 +1877,7 @@ namespace NActors {
         TStrandingDecoratorFactory(TTestActorRuntimeBase* runtime,
             TReplyCheckerCreator createReplyChecker)
             : Context(new TStrandingActorDecoratorContext())
-            , Runtime(runtime)
+            , Runtime(runtime) 
             , CreateReplyChecker(createReplyChecker)
         {
         }
diff --git a/library/cpp/actors/testlib/test_runtime.h b/library/cpp/actors/testlib/test_runtime.h
index 26e3b45c98..e3facb3cd8 100644
--- a/library/cpp/actors/testlib/test_runtime.h
+++ b/library/cpp/actors/testlib/test_runtime.h
@@ -226,7 +226,7 @@ namespace NActors {
             DispatchedEventsLimit = limit;
         }
         TDuration SetReschedulingDelay(TDuration delay);
-        void SetLogBackend(const TAutoPtr<TLogBackend> logBackend);
+        void SetLogBackend(const TAutoPtr<TLogBackend> logBackend); 
         void SetLogPriority(NActors::NLog::EComponent component, NActors::NLog::EPriority priority);
         TIntrusivePtr<ITimeProvider> GetTimeProvider();
         TInstant GetCurrentTime() const;
@@ -466,7 +466,7 @@ namespace NActors {
 
         const TVector<ui64>& GetTxAllocatorTabletIds() const { return TxAllocatorTabletIds; }
         void SetTxAllocatorTabletIds(const TVector<ui64>& ids) { TxAllocatorTabletIds = ids; }
-
+ 
         void SetUseRealInterconnect() {
             UseRealInterconnect = true;
         }
@@ -529,7 +529,7 @@ namespace NActors {
         TActorId CurrentRecipient;
         ui64 DispatcherRandomSeed;
         TIntrusivePtr<IRandomProvider> DispatcherRandomProvider;
-        TAutoPtr<TLogBackend> LogBackend;
+        TAutoPtr<TLogBackend> LogBackend; 
         bool NeedMonitoring;
 
         TIntrusivePtr<IRandomProvider> RandomProvider;
@@ -626,7 +626,7 @@ namespace NActors {
         TSet<TActorId> ScheduleWhiteList;
         THashMap<TActorId, TActorId> ScheduleWhiteListParent;
         THashMap<TActorId, TString> ActorNames;
-        TDispatchContext* CurrentDispatchContext;
+        TDispatchContext* CurrentDispatchContext; 
         TVector<ui64> TxAllocatorTabletIds;
 
         static ui32 NextNodeId;
diff --git a/library/cpp/grpc/server/grpc_counters.h b/library/cpp/grpc/server/grpc_counters.h
index 0b6c36c84c..e8f0ca2179 100644
--- a/library/cpp/grpc/server/grpc_counters.h
+++ b/library/cpp/grpc/server/grpc_counters.h
@@ -97,11 +97,11 @@ public:
         *InflyRequestBytes += requestSize;
     }
 
-    void FinishProcessing(ui32 requestSize, ui32 responseSize, bool ok, ui32 status,
-        TDuration requestDuration) override
-    {
-        Y_UNUSED(status);
-
+    void FinishProcessing(ui32 requestSize, ui32 responseSize, bool ok, ui32 status, 
+        TDuration requestDuration) override 
+    { 
+        Y_UNUSED(status); 
+ 
         InflyCounter->Dec();
         *InflyRequestBytes -= requestSize;
         *ResponseBytes += responseSize;
diff --git a/library/cpp/grpc/server/grpc_request.h b/library/cpp/grpc/server/grpc_request.h
index 5bd8d3902b..851fe11583 100644
--- a/library/cpp/grpc/server/grpc_request.h
+++ b/library/cpp/grpc/server/grpc_request.h
@@ -180,13 +180,13 @@ public:
         return AuthState_;
     }
 
-    void Reply(NProtoBuf::Message* resp, ui32 status) override {
-        ResponseStatus = status;
+    void Reply(NProtoBuf::Message* resp, ui32 status) override { 
+        ResponseStatus = status; 
         WriteDataOk(resp);
     }
 
-    void Reply(grpc::ByteBuffer* resp, ui32 status) override {
-        ResponseStatus = status;
+    void Reply(grpc::ByteBuffer* resp, ui32 status) override { 
+        ResponseStatus = status; 
         WriteByteDataOk(resp);
     }
 
@@ -427,8 +427,8 @@ private:
             ok ? "true" : "false", this->Context.peer().c_str());
         //PrintBackTrace();
         DecRequest();
-        Counters_->FinishProcessing(RequestSize, ResponseSize, ok, ResponseStatus,
-            TDuration::Seconds(RequestTimer.Passed()));
+        Counters_->FinishProcessing(RequestSize, ResponseSize, ok, ResponseStatus, 
+            TDuration::Seconds(RequestTimer.Passed())); 
         return false;
     }
 
@@ -437,8 +437,8 @@ private:
             ok ? "true" : "false", this->Context.peer().c_str());
         if (!SkipUpdateCountersOnError) {
             DecRequest();
-            Counters_->FinishProcessing(RequestSize, ResponseSize, ok, ResponseStatus,
-                TDuration::Seconds(RequestTimer.Passed()));
+            Counters_->FinishProcessing(RequestSize, ResponseSize, ok, ResponseStatus, 
+                TDuration::Seconds(RequestTimer.Passed())); 
         }
         return false;
     }
@@ -498,7 +498,7 @@ private:
     TOnNextReply NextReplyCb_;
     ui32 RequestSize = 0;
     ui32 ResponseSize = 0;
-    ui32 ResponseStatus = 0;
+    ui32 ResponseStatus = 0; 
     THPTimer RequestTimer;
     TAuthState AuthState_ = 0;
     bool RequestRegistered_ = false;
diff --git a/library/cpp/grpc/server/grpc_request_base.h b/library/cpp/grpc/server/grpc_request_base.h
index fcfce1c181..740c3c4fdd 100644
--- a/library/cpp/grpc/server/grpc_request_base.h
+++ b/library/cpp/grpc/server/grpc_request_base.h
@@ -58,11 +58,11 @@ public:
 
     //! Send common response (The request shoult be created for protobuf response type)
     //! Implementation can swap protobuf message
-    virtual void Reply(NProtoBuf::Message* resp, ui32 status = 0) = 0;
+    virtual void Reply(NProtoBuf::Message* resp, ui32 status = 0) = 0; 
 
     //! Send serialised response (The request shoult be created for bytes response type)
     //! Implementation can swap ByteBuffer
-    virtual void Reply(grpc::ByteBuffer* resp, ui32 status = 0) = 0;
+    virtual void Reply(grpc::ByteBuffer* resp, ui32 status = 0) = 0; 
 
     //! Send grpc UNAUTHENTICATED status
     virtual void ReplyUnauthenticated(const TString& in) = 0;
diff --git a/library/cpp/json/easy_parse/json_easy_parser.cpp b/library/cpp/json/easy_parse/json_easy_parser.cpp
index 3c781f544b..e6c898ba15 100644
--- a/library/cpp/json/easy_parse/json_easy_parser.cpp
+++ b/library/cpp/json/easy_parse/json_easy_parser.cpp
@@ -114,7 +114,7 @@ namespace NJson {
             , HasFormatError(false)
         {
             for (size_t n = 0; n < Parent.Fields.size(); ++n) {
-                if (!Parent.Fields[n].Path.empty() && Parent.Fields[n].Path.back().Type == NImpl::ARRAY)
+                if (!Parent.Fields[n].Path.empty() && Parent.Fields[n].Path.back().Type == NImpl::ARRAY) 
                     ShouldUpdateOnArrayChange = true;
             }
         }
diff --git a/ydb/core/base/domain.h b/ydb/core/base/domain.h
index 05346e474a..345af4bf0e 100644
--- a/ydb/core/base/domain.h
+++ b/ydb/core/base/domain.h
@@ -201,7 +201,7 @@ struct TDomainsInfo : public TThrRefBase {
         static TVector<ui64> MakeCoordinatorsIds(TVector<ui64> &&uids, ui32 domainUid) {
             return TransformUids(std::move(uids), [&domainUid](ui32 uid) { return MakeTxCoordinatorID(domainUid, uid); });
         }
-
+ 
         static TVector<ui64> MakeCoordinatorsIds(ui32 count, ui32 domainUid) {
             return MakeCoordinatorsIds(TransformIntoVectorUids(count), domainUid);
         }
@@ -222,13 +222,13 @@ struct TDomainsInfo : public TThrRefBase {
             return MakeAllocatorsIds(TransformIntoVectorUids(count), domainUid);
         }
 
-        ui32 GetHiveUidByIdx(ui32 idx) const {
-            if (idx == Max<ui32>()) {
-                return DefaultHiveUid;
-            }
-
-            return HiveUids.at(idx);
-        }
+        ui32 GetHiveUidByIdx(ui32 idx) const { 
+            if (idx == Max<ui32>()) { 
+                return DefaultHiveUid; 
+            } 
+ 
+            return HiveUids.at(idx); 
+        } 
     };
 
     TMap<ui32, TIntrusivePtr<TDomain>> Domains;
diff --git a/ydb/core/base/kikimr_issue.txt b/ydb/core/base/kikimr_issue.txt
index 56c375080b..8557cf846d 100644
--- a/ydb/core/base/kikimr_issue.txt
+++ b/ydb/core/base/kikimr_issue.txt
@@ -10,7 +10,7 @@ ids { code: PATH_NOT_EXIST severity: S_ERROR }
 ids { code: DATABASE_NOT_EXIST severity: S_ERROR }
 ids { code: GENERIC_DATASHARD_ERROR severity: S_ERROR }
 ids { code: GENERIC_RESOLVE_ERROR severity: S_ERROR }
-ids { code: RESOLVE_LOOKUP_ERROR severity: S_ERROR }
+ids { code: RESOLVE_LOOKUP_ERROR severity: S_ERROR } 
 ids { code: GENERIC_TXPROXY_ERROR severity: S_ERROR }
 ids { code: KEY_PARSE_ERROR severity: S_ERROR }
 ids { code: EMPTY_OP_RANGE severity: S_ERROR }
@@ -20,7 +20,7 @@ ids { code: SHARD_NOT_AVAILABLE severity: S_ERROR }
 ids { code: TX_STATE_UNKNOWN severity: S_ERROR }
 ids { code: TX_DECLINED_BY_COORDINATOR severity: S_ERROR }
 ids { code: TX_DECLINED_IMPLICIT_COORDINATOR severity: S_ERROR }
-ids { code: SHARD_PROGRAM_SIZE_EXCEEDED severity: S_ERROR }
+ids { code: SHARD_PROGRAM_SIZE_EXCEEDED severity: S_ERROR } 
 
 ids { code: SCOPE_REQPROXY severity: S_INFO}
 
diff --git a/ydb/core/client/client_ut.cpp b/ydb/core/client/client_ut.cpp
index b94c722588..59161bc1ea 100644
--- a/ydb/core/client/client_ut.cpp
+++ b/ydb/core/client/client_ut.cpp
@@ -748,8 +748,8 @@ Y_UNIT_TEST_SUITE(TClientTest) {
                 (let result2 (SelectRow '/dc-1/Berkanavt/tables/Simple row2 select __HEAD__))
                 (let entry1 (Coalesce (FlatMap result1 (lambda '(x) (Member x 'uint))) (Uint64 '0)))
                 (let entry2 (Coalesce (FlatMap result2 (lambda '(x) (Member x 'uint))) (Uint64 '0)))
-                (return (AsList (SetResult 'uint1 entry1) (SetResult 'uint2 entry2)
-                    (SetResult 'step (Nth (StepTxId) '0)) (SetResult 'txid (Nth (StepTxId) '1)) ))
+                (return (AsList (SetResult 'uint1 entry1) (SetResult 'uint2 entry2) 
+                    (SetResult 'step (Nth (StepTxId) '0)) (SetResult 'txid (Nth (StepTxId) '1)) )) 
             )
         )___";
 
@@ -763,7 +763,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
             TValue resOpt2 = value["uint2"];
             UNIT_ASSERT(resOpt1.HaveValue() && ui64(resOpt1) == 10);
             UNIT_ASSERT(resOpt2.HaveValue() && ui64(resOpt2) == 10);
-
+ 
             TValue resStep = value["step"];
             UNIT_ASSERT(resStep.HaveValue());
             ui64 stepValue = resStep;
@@ -827,8 +827,8 @@ Y_UNIT_TEST_SUITE(TClientTest) {
                 (let select '('uint))
                 (let read1 (SelectRow table row1 select))
                 (let read2 (SelectRow table row2 select))
-                (let cmp1 (IfPresent read1 (lambda '(x) (Coalesce (Equal (Member x 'uint) (Uint64 '10)) (Bool 'false))) (Bool 'false)))
-                (let cmp2 (IfPresent read2 (lambda '(x) (Coalesce (Equal (Member x 'uint) (Uint64 '10)) (Bool 'false))) (Bool 'false)))
+                (let cmp1 (IfPresent read1 (lambda '(x) (Coalesce (Equal (Member x 'uint) (Uint64 '10)) (Bool 'false))) (Bool 'false))) 
+                (let cmp2 (IfPresent read2 (lambda '(x) (Coalesce (Equal (Member x 'uint) (Uint64 '10)) (Bool 'false))) (Bool 'false))) 
                 (return (Extend (Extend
                     (AsList (SetResult 'cmp1 cmp1) (SetResult 'cmp2 cmp2))
                     (ListIf cmp2 (UpdateRow table row1 '('('uint (Uint64 '50))))))
@@ -1156,8 +1156,8 @@ Y_UNIT_TEST_SUITE(TClientTest) {
             NKikimrMiniKQL::TResult readRes;
             const TString readQuery = R"___(
                 (
-                    (let from (Parameter 'FROM (DataType 'Uint64)))
-                    (let to (Parameter 'TO (DataType 'Uint64)))
+                    (let from (Parameter 'FROM (DataType 'Uint64))) 
+                    (let to (Parameter 'TO (DataType 'Uint64))) 
                     (let table '/dc-1/Berkanavt/tables/Simple)
                     (let range '('IncFrom 'IncTo '('key from to)))
                     (let select '('uint 'key))
@@ -1203,8 +1203,8 @@ Y_UNIT_TEST_SUITE(TClientTest) {
 
             const TString readQuery = R"___(
                 (
-                    (let from (Parameter 'FROM (DataType 'Uint64)))
-                    (let to (Parameter 'TO (DataType 'Uint64)))
+                    (let from (Parameter 'FROM (DataType 'Uint64))) 
+                    (let to (Parameter 'TO (DataType 'Uint64))) 
                     (let table '/dc-1/Berkanavt/tables/Simple)
                     (let range '('ExcFrom 'IncTo '('key from to)))
                     (let select '('uint 'key))
diff --git a/ydb/core/client/flat_ut.cpp b/ydb/core/client/flat_ut.cpp
index 362c052aa1..beb21cb785 100644
--- a/ydb/core/client/flat_ut.cpp
+++ b/ydb/core/client/flat_ut.cpp
@@ -328,54 +328,54 @@ Y_UNIT_TEST_SUITE(TFlatTest) {
     }
 
     Y_UNIT_TEST(SelectRowWithTargetParameter) {
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
-        TServer cleverServer = TServer(TServerSettings(port));
-
-        TFlatMsgBusClient annoyingClient(port);
-        annoyingClient.InitRoot();
-
-        annoyingClient.CreateTable("/dc-1", R"(
-            Name: "TestTable"
-            Columns { Name: "key" Type: "Uint32"}
-            Columns { Name: "value" Type: "String"}
-            KeyColumnNames: ["key"]
-        )");
-
-        annoyingClient.FlatQuery(R"(
-            (
-                (let row '('('key (Uint32 '1))))
-                (let upd '('('value (String 'test1))))
-                (let ret (AsList
-                    (UpdateRow '/dc-1/TestTable row upd)
-                ))
-                (return ret)
-            )
-        )");
-
-        TString query = R"(
-            (
-                (let row '('('key (Uint32 '1))))
-                (let cols '('value))
-                (let select (SelectRow '/dc-1/TestTable row cols (Parameter 'rt (DataType 'Uint32))))
-                (let ret (AsList (SetResult 'result (Member select 'value))))
-                (return ret)
-            )
-        )";
-
-        TString params = R"(
-            (
-                (let params (Parameters))
-                (let params (AddParameter params 'rt (Uint32 '0)))
-                (return params)
-            )
-        )";
-
-        NKikimrMiniKQL::TResult result;
-        annoyingClient.FlatQueryParams(query, params, false, result);
-        UNIT_ASSERT_NO_DIFF(result.GetValue().GetStruct(0).GetOptional().GetOptional().GetBytes(), "test1");
-    }
-
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
+        TServer cleverServer = TServer(TServerSettings(port)); 
+ 
+        TFlatMsgBusClient annoyingClient(port); 
+        annoyingClient.InitRoot(); 
+ 
+        annoyingClient.CreateTable("/dc-1", R"( 
+            Name: "TestTable" 
+            Columns { Name: "key" Type: "Uint32"} 
+            Columns { Name: "value" Type: "String"} 
+            KeyColumnNames: ["key"] 
+        )"); 
+ 
+        annoyingClient.FlatQuery(R"( 
+            ( 
+                (let row '('('key (Uint32 '1)))) 
+                (let upd '('('value (String 'test1)))) 
+                (let ret (AsList 
+                    (UpdateRow '/dc-1/TestTable row upd) 
+                )) 
+                (return ret) 
+            ) 
+        )"); 
+ 
+        TString query = R"( 
+            ( 
+                (let row '('('key (Uint32 '1)))) 
+                (let cols '('value)) 
+                (let select (SelectRow '/dc-1/TestTable row cols (Parameter 'rt (DataType 'Uint32)))) 
+                (let ret (AsList (SetResult 'result (Member select 'value)))) 
+                (return ret) 
+            ) 
+        )"; 
+ 
+        TString params = R"( 
+            ( 
+                (let params (Parameters)) 
+                (let params (AddParameter params 'rt (Uint32 '0))) 
+                (return params) 
+            ) 
+        )"; 
+ 
+        NKikimrMiniKQL::TResult result; 
+        annoyingClient.FlatQueryParams(query, params, false, result); 
+        UNIT_ASSERT_NO_DIFF(result.GetValue().GetStruct(0).GetOptional().GetOptional().GetBytes(), "test1"); 
+    } 
+ 
     Y_UNIT_TEST(ModifyMultipleRowsCrossShardAllToAll) {
         TPortManager pm;
         ui16 port = pm.GetPort(2134);
@@ -1852,7 +1852,7 @@ Y_UNIT_TEST_SUITE(TFlatTest) {
                 "(let select '('Key 'Value 'Large))"
                 "(let options '())"
                 "(let pgmReturn (AsList"
-                "    (SetResult 'range1 (SelectRange '%s range1 select options (Uint32 '%d)))"
+                "    (SetResult 'range1 (SelectRange '%s range1 select options (Uint32 '%d)))" 
                 "))"
                 "(return pgmReturn)"
                 ")";
@@ -3266,234 +3266,234 @@ Y_UNIT_TEST_SUITE(TFlatTest) {
         }
         UNIT_ASSERT_C(found, "DbDataBytes counter not found");
     }
-
-    void LargeDatashardReplyRO(TFlatMsgBusClient& client) {
-        const ui32 TABLE_ROWS = 700;
-        const ui32 BLOB_SIZE = 100 * 1024; // 100 Kb
-
-        for (ui32 i = 0; i < TABLE_ROWS; ++i) {
-            client.FlatQuery(Sprintf(R"(
-                (
-                (let key '('('Key (Uint64 '%d)) ))
-                (let payload '('('Value (String '%s))))
-                (return (AsList (UpdateRow '"/dc-1/test/BlobTable" key payload)))
-                )
-                )", i, TString(BLOB_SIZE, '0' + i % 10).c_str()
-            ));
-        }
-
-        client.FlatQuery(Sprintf(R"(
-            (
-            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void))))
-            (let data (Member (SelectRange '"/dc-1/test/BlobTable" range '('Key 'Value) '()) 'List))
-            (let result (Filter data (lambda '(row)
-                (Coalesce (NotEqual (Member row 'Key) (Uint64 '1)) (Bool 'false))
-            )))
-            (return (AsList (SetResult 'Result result)))
-            )
-            )"
-        ), NMsgBusProxy::MSTATUS_ERROR, TEvTxUserProxy::TResultStatus::ExecResultUnavailable);
-    }
-
-    Y_UNIT_TEST(LargeDatashardReply) {
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
-        TServer cleverServer = TServer(TServerSettings(port));
-        TFlatMsgBusClient annoyingClient(port);
-
-        annoyingClient.InitRoot();
-        annoyingClient.MkDir("/dc-1", "test");
-
-        annoyingClient.CreateTable("/dc-1/test",
-            R"(Name: "BlobTable"
-                Columns { Name: "Key"   Type: "Uint64"}
-                Columns { Name: "Value" Type: "String"}
-                KeyColumnNames: ["Key"]
-            )");
-
-        LargeDatashardReplyRO(annoyingClient);
-    }
-
-    Y_UNIT_TEST(LargeDatashardReplyDistributed) {
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
-        TServer cleverServer = TServer(TServerSettings(port));
-        TFlatMsgBusClient annoyingClient(port);
-
-        annoyingClient.InitRoot();
-        annoyingClient.MkDir("/dc-1", "test");
-
-        annoyingClient.CreateTable("/dc-1/test",
-            R"(Name: "BlobTable"
-                Columns { Name: "Key"   Type: "Uint64"}
-                Columns { Name: "Value" Type: "String"}
-                KeyColumnNames: ["Key"]
-                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } }
-            )");
-
-        LargeDatashardReplyRO(annoyingClient);
-    }
-
+ 
+    void LargeDatashardReplyRO(TFlatMsgBusClient& client) { 
+        const ui32 TABLE_ROWS = 700; 
+        const ui32 BLOB_SIZE = 100 * 1024; // 100 Kb 
+ 
+        for (ui32 i = 0; i < TABLE_ROWS; ++i) { 
+            client.FlatQuery(Sprintf(R"( 
+                ( 
+                (let key '('('Key (Uint64 '%d)) )) 
+                (let payload '('('Value (String '%s)))) 
+                (return (AsList (UpdateRow '"/dc-1/test/BlobTable" key payload))) 
+                ) 
+                )", i, TString(BLOB_SIZE, '0' + i % 10).c_str() 
+            )); 
+        } 
+ 
+        client.FlatQuery(Sprintf(R"( 
+            ( 
+            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void)))) 
+            (let data (Member (SelectRange '"/dc-1/test/BlobTable" range '('Key 'Value) '()) 'List)) 
+            (let result (Filter data (lambda '(row) 
+                (Coalesce (NotEqual (Member row 'Key) (Uint64 '1)) (Bool 'false)) 
+            ))) 
+            (return (AsList (SetResult 'Result result))) 
+            ) 
+            )" 
+        ), NMsgBusProxy::MSTATUS_ERROR, TEvTxUserProxy::TResultStatus::ExecResultUnavailable); 
+    } 
+ 
+    Y_UNIT_TEST(LargeDatashardReply) { 
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
+        TServer cleverServer = TServer(TServerSettings(port)); 
+        TFlatMsgBusClient annoyingClient(port); 
+ 
+        annoyingClient.InitRoot(); 
+        annoyingClient.MkDir("/dc-1", "test"); 
+ 
+        annoyingClient.CreateTable("/dc-1/test", 
+            R"(Name: "BlobTable" 
+                Columns { Name: "Key"   Type: "Uint64"} 
+                Columns { Name: "Value" Type: "String"} 
+                KeyColumnNames: ["Key"] 
+            )"); 
+ 
+        LargeDatashardReplyRO(annoyingClient); 
+    } 
+ 
+    Y_UNIT_TEST(LargeDatashardReplyDistributed) { 
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
+        TServer cleverServer = TServer(TServerSettings(port)); 
+        TFlatMsgBusClient annoyingClient(port); 
+ 
+        annoyingClient.InitRoot(); 
+        annoyingClient.MkDir("/dc-1", "test"); 
+ 
+        annoyingClient.CreateTable("/dc-1/test", 
+            R"(Name: "BlobTable" 
+                Columns { Name: "Key"   Type: "Uint64"} 
+                Columns { Name: "Value" Type: "String"} 
+                KeyColumnNames: ["Key"] 
+                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } } 
+            )"); 
+ 
+        LargeDatashardReplyRO(annoyingClient); 
+    } 
+ 
     Y_UNIT_TEST(LargeDatashardReplyRW) {
-        const ui32 TABLE_ROWS = 700;
-        const ui32 BLOB_SIZE = 100 * 1024; // 100 Kb
-        const ui32 KEY_TO_ERASE = 1;
-
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
-        TServer cleverServer = TServer(TServerSettings(port));
-        TFlatMsgBusClient annoyingClient(port);
-
-        annoyingClient.InitRoot();
-        annoyingClient.MkDir("/dc-1", "test");
-
-        annoyingClient.CreateTable("/dc-1/test",
-            R"(Name: "BlobTable"
-                Columns { Name: "Key"   Type: "Uint64"}
-                Columns { Name: "Value" Type: "String"}
-                KeyColumnNames: ["Key"]
-            )");
-
-        for (ui32 i = 0; i < TABLE_ROWS; ++i) {
-            annoyingClient.FlatQuery(Sprintf(R"(
-                (
-                (let key '('('Key (Uint64 '%d)) ))
-                (let payload '('('Value (String '%s))))
-                (return (AsList (UpdateRow '"/dc-1/test/BlobTable" key payload)))
-                )
-                )", i, TString(BLOB_SIZE, '0' + i % 10).c_str()
-            ));
-        }
-
-        auto selectQuery = Sprintf(R"(
-            (
-            (let read (SelectRow '"/dc-1/test/BlobTable" '('('Key (Uint64 '%d))) '('Key)))
-            (return (AsList (SetResult 'Result read)))
-            )
-        )", KEY_TO_ERASE);
-
-        // Make sure row exists
-        auto res = annoyingClient.FlatQuery(selectQuery);
-        UNIT_ASSERT(res.GetValue().GetStruct(0).GetOptional().HasOptional());
-
-        annoyingClient.FlatQuery(Sprintf(R"(
-            (
-            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void))))
-            (let data (Member (SelectRange '"/dc-1/test/BlobTable" range '('Key 'Value) '()) 'List))
-            (let result (Take (Skip (Filter data (lambda '(row)
-                (Coalesce (NotEqual (Member row 'Key) (Uint64 '1)) (Bool 'false))
-            )) (Uint64 '"15")) (Uint64 '"10")) )
-            (return (AsList (SetResult 'Result result) (EraseRow '"/dc-1/test/BlobTable" '('('Key (Uint64 '%d))))))
-            )
-            )", KEY_TO_ERASE
-        ), NMsgBusProxy::MSTATUS_ERROR, TEvTxUserProxy::TResultStatus::ExecResultUnavailable);
-
-        // Make sure row erased
-        res = annoyingClient.FlatQuery(selectQuery);
-        UNIT_ASSERT(!res.GetValue().GetStruct(0).GetOptional().HasOptional());
-    }
-
+        const ui32 TABLE_ROWS = 700; 
+        const ui32 BLOB_SIZE = 100 * 1024; // 100 Kb 
+        const ui32 KEY_TO_ERASE = 1; 
+ 
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
+        TServer cleverServer = TServer(TServerSettings(port)); 
+        TFlatMsgBusClient annoyingClient(port); 
+ 
+        annoyingClient.InitRoot(); 
+        annoyingClient.MkDir("/dc-1", "test"); 
+ 
+        annoyingClient.CreateTable("/dc-1/test", 
+            R"(Name: "BlobTable" 
+                Columns { Name: "Key"   Type: "Uint64"} 
+                Columns { Name: "Value" Type: "String"} 
+                KeyColumnNames: ["Key"] 
+            )"); 
+ 
+        for (ui32 i = 0; i < TABLE_ROWS; ++i) { 
+            annoyingClient.FlatQuery(Sprintf(R"( 
+                ( 
+                (let key '('('Key (Uint64 '%d)) )) 
+                (let payload '('('Value (String '%s)))) 
+                (return (AsList (UpdateRow '"/dc-1/test/BlobTable" key payload))) 
+                ) 
+                )", i, TString(BLOB_SIZE, '0' + i % 10).c_str() 
+            )); 
+        } 
+ 
+        auto selectQuery = Sprintf(R"( 
+            ( 
+            (let read (SelectRow '"/dc-1/test/BlobTable" '('('Key (Uint64 '%d))) '('Key))) 
+            (return (AsList (SetResult 'Result read))) 
+            ) 
+        )", KEY_TO_ERASE); 
+ 
+        // Make sure row exists 
+        auto res = annoyingClient.FlatQuery(selectQuery); 
+        UNIT_ASSERT(res.GetValue().GetStruct(0).GetOptional().HasOptional()); 
+ 
+        annoyingClient.FlatQuery(Sprintf(R"( 
+            ( 
+            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void)))) 
+            (let data (Member (SelectRange '"/dc-1/test/BlobTable" range '('Key 'Value) '()) 'List)) 
+            (let result (Take (Skip (Filter data (lambda '(row) 
+                (Coalesce (NotEqual (Member row 'Key) (Uint64 '1)) (Bool 'false)) 
+            )) (Uint64 '"15")) (Uint64 '"10")) ) 
+            (return (AsList (SetResult 'Result result) (EraseRow '"/dc-1/test/BlobTable" '('('Key (Uint64 '%d)))))) 
+            ) 
+            )", KEY_TO_ERASE 
+        ), NMsgBusProxy::MSTATUS_ERROR, TEvTxUserProxy::TResultStatus::ExecResultUnavailable); 
+ 
+        // Make sure row erased 
+        res = annoyingClient.FlatQuery(selectQuery); 
+        UNIT_ASSERT(!res.GetValue().GetStruct(0).GetOptional().HasOptional()); 
+    } 
+ 
     Y_UNIT_TEST(LargeProxyReply) {
-        const ui32 TABLE_ROWS = 350;
-        const ui32 BLOB_SIZE = 100 * 1024; // 100 Kb
-
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
+        const ui32 TABLE_ROWS = 350; 
+        const ui32 BLOB_SIZE = 100 * 1024; // 100 Kb 
+ 
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
         TServer cleverServer = TServer(TServerSettings(port));
-        TFlatMsgBusClient annoyingClient(port);
-
-        annoyingClient.InitRoot();
-        annoyingClient.MkDir("/dc-1", "test");
-
-        annoyingClient.CreateTable("/dc-1/test",
-            R"(Name: "BlobTable"
-                Columns { Name: "Key"   Type: "Uint64"}
-                Columns { Name: "Value" Type: "String"}
-                KeyColumnNames: ["Key"]
-            )");
-
-        for (ui32 i = 0; i < TABLE_ROWS; ++i) {
-            annoyingClient.FlatQuery(Sprintf(R"(
-                (
-                (let key '('('Key (Uint64 '%d)) ))
-                (let payload '('('Value (String '%s))))
-                (return (AsList (UpdateRow '"/dc-1/test/BlobTable" key payload)))
-                )
-                )", i, TString(BLOB_SIZE, '0' + i % 10).c_str()
-            ));
-        }
-
-        annoyingClient.FlatQuery(Sprintf(R"(
-            (
-            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void))))
-            (let data (Member (SelectRange '"/dc-1/test/BlobTable" range '('Key 'Value) '()) 'List))
-            (let result (OrderedMap data (lambda '(row)
-                (AddMember row 'Value2 (Member row 'Value))
-            )))
-            (return (AsList (SetResult 'Result result)))
-            )
-            )"
-        ), NMsgBusProxy::MSTATUS_ERROR, TEvTxUserProxy::TResultStatus::ExecResultUnavailable);
-    }
-
+        TFlatMsgBusClient annoyingClient(port); 
+ 
+        annoyingClient.InitRoot(); 
+        annoyingClient.MkDir("/dc-1", "test"); 
+ 
+        annoyingClient.CreateTable("/dc-1/test", 
+            R"(Name: "BlobTable" 
+                Columns { Name: "Key"   Type: "Uint64"} 
+                Columns { Name: "Value" Type: "String"} 
+                KeyColumnNames: ["Key"] 
+            )"); 
+ 
+        for (ui32 i = 0; i < TABLE_ROWS; ++i) { 
+            annoyingClient.FlatQuery(Sprintf(R"( 
+                ( 
+                (let key '('('Key (Uint64 '%d)) )) 
+                (let payload '('('Value (String '%s)))) 
+                (return (AsList (UpdateRow '"/dc-1/test/BlobTable" key payload))) 
+                ) 
+                )", i, TString(BLOB_SIZE, '0' + i % 10).c_str() 
+            )); 
+        } 
+ 
+        annoyingClient.FlatQuery(Sprintf(R"( 
+            ( 
+            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void)))) 
+            (let data (Member (SelectRange '"/dc-1/test/BlobTable" range '('Key 'Value) '()) 'List)) 
+            (let result (OrderedMap data (lambda '(row) 
+                (AddMember row 'Value2 (Member row 'Value)) 
+            ))) 
+            (return (AsList (SetResult 'Result result))) 
+            ) 
+            )" 
+        ), NMsgBusProxy::MSTATUS_ERROR, TEvTxUserProxy::TResultStatus::ExecResultUnavailable); 
+    } 
+ 
     Y_UNIT_TEST(LargeProxyReplyRW) {
-        const ui32 TABLE_ROWS = 350;
-        const ui32 BLOB_SIZE = 100 * 1024; // 100 Kb
-        const ui32 KEY_TO_ERASE = 1;
-
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
-        TServer cleverServer = TServer(TServerSettings(port));
-        TFlatMsgBusClient annoyingClient(port);
-
-        annoyingClient.InitRoot();
-        annoyingClient.MkDir("/dc-1", "test");
-
-        annoyingClient.CreateTable("/dc-1/test",
-            R"(Name: "BlobTable"
-                Columns { Name: "Key"   Type: "Uint64"}
-                Columns { Name: "Value" Type: "String"}
-                KeyColumnNames: ["Key"]
-            )");
-
-        for (ui32 i = 0; i < TABLE_ROWS; ++i) {
-            annoyingClient.FlatQuery(Sprintf(R"(
-                (
-                (let key '('('Key (Uint64 '%d)) ))
-                (let payload '('('Value (String '%s))))
-                (return (AsList (UpdateRow '"/dc-1/test/BlobTable" key payload)))
-                )
-                )", i, TString(BLOB_SIZE, '0' + i % 10).c_str()
-            ));
-        }
-
-        auto selectQuery = Sprintf(R"(
-            (
-            (let read (SelectRow '"/dc-1/test/BlobTable" '('('Key (Uint64 '%d))) '('Key)))
-            (return (AsList (SetResult 'Result read)))
-            )
-        )", KEY_TO_ERASE);
-
-        // Make sure row exists
-        auto res = annoyingClient.FlatQuery(selectQuery);
-        UNIT_ASSERT(res.GetValue().GetStruct(0).GetOptional().HasOptional());
-
-        annoyingClient.FlatQuery(Sprintf(R"(
-            (
-            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void))))
-            (let data (Member (SelectRange '"/dc-1/test/BlobTable" range '('Key 'Value) '()) 'List))
-            (let result (OrderedMap data (lambda '(row)
-                (AddMember row 'Value2 (Member row 'Value))
-            )))
-            (return (AsList (SetResult 'Result result) (EraseRow '"/dc-1/test/BlobTable" '('('Key (Uint64 '%d))))))
-            )
-            )", KEY_TO_ERASE
-        ), NMsgBusProxy::MSTATUS_ERROR, TEvTxUserProxy::TResultStatus::ExecResultUnavailable);
-
-        // Make sure row erased
-        res = annoyingClient.FlatQuery(selectQuery);
-        UNIT_ASSERT(!res.GetValue().GetStruct(0).GetOptional().HasOptional());
-    }
+        const ui32 TABLE_ROWS = 350; 
+        const ui32 BLOB_SIZE = 100 * 1024; // 100 Kb 
+        const ui32 KEY_TO_ERASE = 1; 
+ 
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
+        TServer cleverServer = TServer(TServerSettings(port)); 
+        TFlatMsgBusClient annoyingClient(port); 
+ 
+        annoyingClient.InitRoot(); 
+        annoyingClient.MkDir("/dc-1", "test"); 
+ 
+        annoyingClient.CreateTable("/dc-1/test", 
+            R"(Name: "BlobTable" 
+                Columns { Name: "Key"   Type: "Uint64"} 
+                Columns { Name: "Value" Type: "String"} 
+                KeyColumnNames: ["Key"] 
+            )"); 
+ 
+        for (ui32 i = 0; i < TABLE_ROWS; ++i) { 
+            annoyingClient.FlatQuery(Sprintf(R"( 
+                ( 
+                (let key '('('Key (Uint64 '%d)) )) 
+                (let payload '('('Value (String '%s)))) 
+                (return (AsList (UpdateRow '"/dc-1/test/BlobTable" key payload))) 
+                ) 
+                )", i, TString(BLOB_SIZE, '0' + i % 10).c_str() 
+            )); 
+        } 
+ 
+        auto selectQuery = Sprintf(R"( 
+            ( 
+            (let read (SelectRow '"/dc-1/test/BlobTable" '('('Key (Uint64 '%d))) '('Key))) 
+            (return (AsList (SetResult 'Result read))) 
+            ) 
+        )", KEY_TO_ERASE); 
+ 
+        // Make sure row exists 
+        auto res = annoyingClient.FlatQuery(selectQuery); 
+        UNIT_ASSERT(res.GetValue().GetStruct(0).GetOptional().HasOptional()); 
+ 
+        annoyingClient.FlatQuery(Sprintf(R"( 
+            ( 
+            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void)))) 
+            (let data (Member (SelectRange '"/dc-1/test/BlobTable" range '('Key 'Value) '()) 'List)) 
+            (let result (OrderedMap data (lambda '(row) 
+                (AddMember row 'Value2 (Member row 'Value)) 
+            ))) 
+            (return (AsList (SetResult 'Result result) (EraseRow '"/dc-1/test/BlobTable" '('('Key (Uint64 '%d)))))) 
+            ) 
+            )", KEY_TO_ERASE 
+        ), NMsgBusProxy::MSTATUS_ERROR, TEvTxUserProxy::TResultStatus::ExecResultUnavailable); 
+ 
+        // Make sure row erased 
+        res = annoyingClient.FlatQuery(selectQuery); 
+        UNIT_ASSERT(!res.GetValue().GetStruct(0).GetOptional().HasOptional()); 
+    } 
 
     Y_UNIT_TEST(PartBloomFilter) {
         TPortManager pm;
@@ -3594,262 +3594,262 @@ Y_UNIT_TEST_SUITE(TFlatTest) {
             ui32 val = ret0[0];
             UNIT_ASSERT_VALUES_EQUAL(val, i);
         }
+    } 
+
+    Y_UNIT_TEST(SelectRangeBytesLimit) { 
+        const ui32 TABLE_ROWS = 10; 
+ 
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
+        TServer cleverServer = TServer(TServerSettings(port)); 
+        TFlatMsgBusClient annoyingClient(port); 
+ 
+        annoyingClient.InitRoot(); 
+        annoyingClient.MkDir("/dc-1", "test"); 
+ 
+        annoyingClient.CreateTable("/dc-1/test", 
+            R"(Name: "TestTable" 
+                Columns { Name: "Key"   Type: "Uint64"} 
+                Columns { Name: "Value" Type: "Uint64"} 
+                KeyColumnNames: ["Key"] 
+                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } } 
+                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 200 } } } } 
+            )"); 
+ 
+        for (ui32 shard = 0; shard < 3; ++shard) { 
+            for (ui32 i = 0; i < TABLE_ROWS; ++i) { 
+                auto key = shard * 100 + i; 
+ 
+                annoyingClient.FlatQuery(Sprintf(R"( 
+                    ( 
+                    (let key '('('Key (Uint64 '%d)) )) 
+                    (let payload '('('Value (Uint64 '%d)))) 
+                    (return (AsList (UpdateRow '"/dc-1/test/TestTable" key payload))) 
+                    ) 
+                    )", key, i 
+                )); 
+            } 
+        } 
+ 
+        auto res = annoyingClient.FlatQuery(Sprintf(R"( 
+            ( 
+            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void)))) 
+            (let data (SelectRange 
+                '"/dc-1/test/TestTable" 
+                range 
+                '('Key 'Value) 
+                '( 
+                    '('"BytesLimit" (Uint64 '%d)) 
+                 ) 
+            )) 
+            (return (AsList (SetResult 'Result data))) 
+            ) 
+            )", TABLE_ROWS * 8 
+        )); 
+ 
+        TValue value = TValue::Create(res.GetValue(), res.GetType()); 
+        TValue result = value["Result"]; 
+        UNIT_ASSERT_VALUES_EQUAL((bool)result["Truncated"], true); 
+        auto list = result["List"]; 
+        for (ui32 i = 0; i < list.Size(); ++i) { 
+            auto key = (ui64) list[i]["Key"]; 
+            UNIT_ASSERT(key < 100); 
+        } 
     }
-
-    Y_UNIT_TEST(SelectRangeBytesLimit) {
-        const ui32 TABLE_ROWS = 10;
-
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
-        TServer cleverServer = TServer(TServerSettings(port));
-        TFlatMsgBusClient annoyingClient(port);
-
-        annoyingClient.InitRoot();
-        annoyingClient.MkDir("/dc-1", "test");
-
-        annoyingClient.CreateTable("/dc-1/test",
-            R"(Name: "TestTable"
-                Columns { Name: "Key"   Type: "Uint64"}
-                Columns { Name: "Value" Type: "Uint64"}
-                KeyColumnNames: ["Key"]
-                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } }
-                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 200 } } } }
-            )");
-
-        for (ui32 shard = 0; shard < 3; ++shard) {
-            for (ui32 i = 0; i < TABLE_ROWS; ++i) {
-                auto key = shard * 100 + i;
-
-                annoyingClient.FlatQuery(Sprintf(R"(
-                    (
-                    (let key '('('Key (Uint64 '%d)) ))
-                    (let payload '('('Value (Uint64 '%d))))
-                    (return (AsList (UpdateRow '"/dc-1/test/TestTable" key payload)))
-                    )
-                    )", key, i
-                ));
-            }
-        }
-
-        auto res = annoyingClient.FlatQuery(Sprintf(R"(
-            (
-            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void))))
-            (let data (SelectRange
-                '"/dc-1/test/TestTable"
-                range
-                '('Key 'Value)
-                '(
-                    '('"BytesLimit" (Uint64 '%d))
-                 )
-            ))
-            (return (AsList (SetResult 'Result data)))
-            )
-            )", TABLE_ROWS * 8
-        ));
-
-        TValue value = TValue::Create(res.GetValue(), res.GetType());
-        TValue result = value["Result"];
-        UNIT_ASSERT_VALUES_EQUAL((bool)result["Truncated"], true);
-        auto list = result["List"];
-        for (ui32 i = 0; i < list.Size(); ++i) {
-            auto key = (ui64) list[i]["Key"];
-            UNIT_ASSERT(key < 100);
-        }
-    }
-
-     Y_UNIT_TEST(SelectRangeItemsLimit) {
-        const ui32 TABLE_ROWS = 10;
-
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
-        TServer cleverServer = TServer(TServerSettings(port));
-        TFlatMsgBusClient annoyingClient(port);
-
-        annoyingClient.InitRoot();
-        annoyingClient.MkDir("/dc-1", "test");
-
-        annoyingClient.CreateTable("/dc-1/test",
-            R"(Name: "TestTable"
-                Columns { Name: "Key"   Type: "Uint64"}
-                Columns { Name: "Value" Type: "Uint64"}
-                KeyColumnNames: ["Key"]
-                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } }
-                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 200 } } } }
-            )");
-
-        for (ui32 shard = 0; shard < 3; ++shard) {
-            for (ui32 i = 0; i < TABLE_ROWS; ++i) {
-                auto key = shard * 100 + i;
-
-                annoyingClient.FlatQuery(Sprintf(R"(
-                    (
-                    (let key '('('Key (Uint64 '%d)) ))
-                    (let payload '('('Value (Uint64 '%d))))
-                    (return (AsList (UpdateRow '"/dc-1/test/TestTable" key payload)))
-                    )
-                    )", key, i
-                ));
-            }
-        }
-
-        auto res = annoyingClient.FlatQuery(Sprintf(R"(
-            (
-            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void))))
-            (let data (SelectRange
-                '"/dc-1/test/TestTable"
-                range
-                '('Key 'Value)
-                '(
-                    '('"ItemsLimit" (Uint64 '%d))
-                 )
-            ))
-            (return (AsList (SetResult 'Result data)))
-            )
-            )", 5
-        ));
-
-        TValue value = TValue::Create(res.GetValue(), res.GetType());
-        TValue result = value["Result"];
-        UNIT_ASSERT_VALUES_EQUAL((bool)result["Truncated"], true);
-        auto list = result["List"];
-        for (ui32 i = 0; i < list.Size(); ++i) {
-            auto key = (ui64) list[i]["Key"];
-            UNIT_ASSERT(key < 100);
-        }
-    }
-
-    Y_UNIT_TEST(SelectRangeBothLimit) {
-        const ui32 TABLE_ROWS = 50;
-
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
-        TServer cleverServer = TServer(TServerSettings(port));
-        TFlatMsgBusClient annoyingClient(port);
-
-        annoyingClient.InitRoot();
-        annoyingClient.MkDir("/dc-1", "test");
-
-        annoyingClient.CreateTable("/dc-1/test",
-            R"(Name: "TestTable"
-                Columns { Name: "Key"   Type: "Uint64"}
-                Columns { Name: "Value" Type: "Uint64"}
-                KeyColumnNames: ["Key"]
-                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } }
-                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 200 } } } }
-            )");
-
-        for (ui32 shard = 0; shard < 3; ++shard) {
-            for (ui32 i = 0; i < TABLE_ROWS; ++i) {
-                auto key = shard * 100 + i;
-
-                annoyingClient.FlatQuery(Sprintf(R"(
-                    (
-                    (let key '('('Key (Uint64 '%d)) ))
-                    (let payload '('('Value (Uint64 '%d))))
-                    (return (AsList (UpdateRow '"/dc-1/test/TestTable" key payload)))
-                    )
-                    )", key, i
-                ));
-            }
-        }
-
-        auto res = annoyingClient.FlatQuery(Sprintf(R"(
-            (
-            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void))))
-            (let data (SelectRange
-                '"/dc-1/test/TestTable"
-                range
-                '('Key 'Value)
-                '(
-                    '('"ItemsLimit" (Uint64 '%d))
-                    '('"BytesLimit" (Uint64 '%d))
-                 )
-            ))
-            (return (AsList (SetResult 'Result data)))
-            )
-            )", 30, TABLE_ROWS * 8
-        ));
-
-        TValue value = TValue::Create(res.GetValue(), res.GetType());
-        TValue result = value["Result"];
-        UNIT_ASSERT_VALUES_EQUAL((bool)result["Truncated"], true);
-        auto list = result["List"];
-        for (ui32 i = 0; i < list.Size(); ++i) {
-            auto key = (ui64) list[i]["Key"];
-            UNIT_ASSERT(key < 100);
-        }
-    }
-
+ 
+     Y_UNIT_TEST(SelectRangeItemsLimit) { 
+        const ui32 TABLE_ROWS = 10; 
+ 
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
+        TServer cleverServer = TServer(TServerSettings(port)); 
+        TFlatMsgBusClient annoyingClient(port); 
+ 
+        annoyingClient.InitRoot(); 
+        annoyingClient.MkDir("/dc-1", "test"); 
+ 
+        annoyingClient.CreateTable("/dc-1/test", 
+            R"(Name: "TestTable" 
+                Columns { Name: "Key"   Type: "Uint64"} 
+                Columns { Name: "Value" Type: "Uint64"} 
+                KeyColumnNames: ["Key"] 
+                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } } 
+                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 200 } } } } 
+            )"); 
+ 
+        for (ui32 shard = 0; shard < 3; ++shard) { 
+            for (ui32 i = 0; i < TABLE_ROWS; ++i) { 
+                auto key = shard * 100 + i; 
+ 
+                annoyingClient.FlatQuery(Sprintf(R"( 
+                    ( 
+                    (let key '('('Key (Uint64 '%d)) )) 
+                    (let payload '('('Value (Uint64 '%d)))) 
+                    (return (AsList (UpdateRow '"/dc-1/test/TestTable" key payload))) 
+                    ) 
+                    )", key, i 
+                )); 
+            } 
+        } 
+ 
+        auto res = annoyingClient.FlatQuery(Sprintf(R"( 
+            ( 
+            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void)))) 
+            (let data (SelectRange 
+                '"/dc-1/test/TestTable" 
+                range 
+                '('Key 'Value) 
+                '( 
+                    '('"ItemsLimit" (Uint64 '%d)) 
+                 ) 
+            )) 
+            (return (AsList (SetResult 'Result data))) 
+            ) 
+            )", 5 
+        )); 
+ 
+        TValue value = TValue::Create(res.GetValue(), res.GetType()); 
+        TValue result = value["Result"]; 
+        UNIT_ASSERT_VALUES_EQUAL((bool)result["Truncated"], true); 
+        auto list = result["List"]; 
+        for (ui32 i = 0; i < list.Size(); ++i) { 
+            auto key = (ui64) list[i]["Key"]; 
+            UNIT_ASSERT(key < 100); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST(SelectRangeBothLimit) { 
+        const ui32 TABLE_ROWS = 50; 
+ 
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
+        TServer cleverServer = TServer(TServerSettings(port)); 
+        TFlatMsgBusClient annoyingClient(port); 
+ 
+        annoyingClient.InitRoot(); 
+        annoyingClient.MkDir("/dc-1", "test"); 
+ 
+        annoyingClient.CreateTable("/dc-1/test", 
+            R"(Name: "TestTable" 
+                Columns { Name: "Key"   Type: "Uint64"} 
+                Columns { Name: "Value" Type: "Uint64"} 
+                KeyColumnNames: ["Key"] 
+                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } } 
+                SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 200 } } } } 
+            )"); 
+ 
+        for (ui32 shard = 0; shard < 3; ++shard) { 
+            for (ui32 i = 0; i < TABLE_ROWS; ++i) { 
+                auto key = shard * 100 + i; 
+ 
+                annoyingClient.FlatQuery(Sprintf(R"( 
+                    ( 
+                    (let key '('('Key (Uint64 '%d)) )) 
+                    (let payload '('('Value (Uint64 '%d)))) 
+                    (return (AsList (UpdateRow '"/dc-1/test/TestTable" key payload))) 
+                    ) 
+                    )", key, i 
+                )); 
+            } 
+        } 
+ 
+        auto res = annoyingClient.FlatQuery(Sprintf(R"( 
+            ( 
+            (let range '('ExcFrom 'ExcTo '('Key (Null) (Void)))) 
+            (let data (SelectRange 
+                '"/dc-1/test/TestTable" 
+                range 
+                '('Key 'Value) 
+                '( 
+                    '('"ItemsLimit" (Uint64 '%d)) 
+                    '('"BytesLimit" (Uint64 '%d)) 
+                 ) 
+            )) 
+            (return (AsList (SetResult 'Result data))) 
+            ) 
+            )", 30, TABLE_ROWS * 8 
+        )); 
+ 
+        TValue value = TValue::Create(res.GetValue(), res.GetType()); 
+        TValue result = value["Result"]; 
+        UNIT_ASSERT_VALUES_EQUAL((bool)result["Truncated"], true); 
+        auto list = result["List"]; 
+        for (ui32 i = 0; i < list.Size(); ++i) { 
+            auto key = (ui64) list[i]["Key"]; 
+            UNIT_ASSERT(key < 100); 
+        } 
+    } 
+ 
     static NKikimrMiniKQL::TResult CreateTableAndExecuteMkql(const TString& mkql) {
-        TPortManager pm;
-        ui16 port = pm.GetPort(2134);
-        TServer cleverServer = TServer(TServerSettings(port));
-        TFlatMsgBusClient annoyingClient(port);
-
-        annoyingClient.InitRoot();
-        annoyingClient.MkDir("/dc-1", "test");
-
-        annoyingClient.CreateTable("/dc-1/test",
-            R"(Name: "TestTable"
-                Columns { Name: "Key1"   Type: "Uint64"}
-                Columns { Name: "Key2"   Type: "String"}
-                Columns { Name: "Value"  Type: "String"}
-                KeyColumnNames: ["Key1", "Key2"]
-            )");
-
-        auto fillValues = [&annoyingClient]
-            (const TMaybe<ui64>& key1, const TMaybe<TString>& key2, const TString& value) {
-                TString key1Str = key1
-                    ? "(Uint64 '" + ToString(*key1) + ")"
-                    : "(Null)";
-
-                TString key2Str = key2
-                    ? "(String '" + ToString(*key2) + ")"
-                    : "(Null)";
-
-                annoyingClient.FlatQuery(Sprintf(R"(
-                    (
-                    (let key '('('Key1 %s) '('Key2 %s) ))
-                    (let payload '('('Value (String '%s))))
-                    (return (AsList (UpdateRow '"/dc-1/test/TestTable" key payload)))
-                    )
-                    )", key1Str.c_str(), key2Str.c_str(), value.c_str()
-                ));
-            };
-
-        fillValues({}, {},            "One");
-        fillValues(1,  {},            "Two");
-        fillValues(1,  TString("k1"), "Three");
-        fillValues(2,  {},            "Four");
-        fillValues(2,  TString("k1"), "Five");
-
+        TPortManager pm; 
+        ui16 port = pm.GetPort(2134); 
+        TServer cleverServer = TServer(TServerSettings(port)); 
+        TFlatMsgBusClient annoyingClient(port); 
+ 
+        annoyingClient.InitRoot(); 
+        annoyingClient.MkDir("/dc-1", "test"); 
+ 
+        annoyingClient.CreateTable("/dc-1/test", 
+            R"(Name: "TestTable" 
+                Columns { Name: "Key1"   Type: "Uint64"} 
+                Columns { Name: "Key2"   Type: "String"} 
+                Columns { Name: "Value"  Type: "String"} 
+                KeyColumnNames: ["Key1", "Key2"] 
+            )"); 
+ 
+        auto fillValues = [&annoyingClient] 
+            (const TMaybe<ui64>& key1, const TMaybe<TString>& key2, const TString& value) { 
+                TString key1Str = key1 
+                    ? "(Uint64 '" + ToString(*key1) + ")" 
+                    : "(Null)"; 
+ 
+                TString key2Str = key2 
+                    ? "(String '" + ToString(*key2) + ")" 
+                    : "(Null)"; 
+ 
+                annoyingClient.FlatQuery(Sprintf(R"( 
+                    ( 
+                    (let key '('('Key1 %s) '('Key2 %s) )) 
+                    (let payload '('('Value (String '%s)))) 
+                    (return (AsList (UpdateRow '"/dc-1/test/TestTable" key payload))) 
+                    ) 
+                    )", key1Str.c_str(), key2Str.c_str(), value.c_str() 
+                )); 
+            }; 
+ 
+        fillValues({}, {},            "One"); 
+        fillValues(1,  {},            "Two"); 
+        fillValues(1,  TString("k1"), "Three"); 
+        fillValues(2,  {},            "Four"); 
+        fillValues(2,  TString("k1"), "Five"); 
+ 
         return annoyingClient.FlatQuery(mkql);
     }
 
     Y_UNIT_TEST(SelectRangeSkipNullKeys) {
         auto res = CreateTableAndExecuteMkql(Sprintf(R"(
-            (
-            (let range '('ExcFrom 'ExcTo '('Key1 (Null) (Void)) '('Key2 (Null) (Void))))
-            (let data (SelectRange
-                '"/dc-1/test/TestTable"
-                range
-                '('Value)
-                '(
-                    '('"SkipNullKeys" '('Key2))
-                 )
-            ))
-            (return (AsList (SetResult 'Result data)))
-            )
-            )"
-        ));
-
-        TValue value = TValue::Create(res.GetValue(), res.GetType());
-        TValue result = value["Result"];
-        auto list = result["List"];
-        UNIT_ASSERT_VALUES_EQUAL(list.Size(), 2);
-        UNIT_ASSERT_VALUES_EQUAL((TString)list[0]["Value"], "Three");
-        UNIT_ASSERT_VALUES_EQUAL((TString)list[1]["Value"], "Five");
-    }
+            ( 
+            (let range '('ExcFrom 'ExcTo '('Key1 (Null) (Void)) '('Key2 (Null) (Void)))) 
+            (let data (SelectRange 
+                '"/dc-1/test/TestTable" 
+                range 
+                '('Value) 
+                '( 
+                    '('"SkipNullKeys" '('Key2)) 
+                 ) 
+            )) 
+            (return (AsList (SetResult 'Result data))) 
+            ) 
+            )" 
+        )); 
+ 
+        TValue value = TValue::Create(res.GetValue(), res.GetType()); 
+        TValue result = value["Result"]; 
+        auto list = result["List"]; 
+        UNIT_ASSERT_VALUES_EQUAL(list.Size(), 2); 
+        UNIT_ASSERT_VALUES_EQUAL((TString)list[0]["Value"], "Three"); 
+        UNIT_ASSERT_VALUES_EQUAL((TString)list[1]["Value"], "Five"); 
+    } 
 
     Y_UNIT_TEST(SelectRangeForbidNullArgs1) {
         auto res = CreateTableAndExecuteMkql(Sprintf(R"(
diff --git a/ydb/core/client/flat_ut_client.h b/ydb/core/client/flat_ut_client.h
index 07f5b30cc6..820e54f5ce 100644
--- a/ydb/core/client/flat_ut_client.h
+++ b/ydb/core/client/flat_ut_client.h
@@ -27,15 +27,15 @@ public:
 
     using TClient::FlatQuery;
 
-    NKikimrMiniKQL::TResult FlatQuery(const TString& mkql) {
+    NKikimrMiniKQL::TResult FlatQuery(const TString& mkql) { 
         NKikimrMiniKQL::TResult res;
         TClient::TFlatQueryOptions opts;
         bool success = TClient::FlatQuery(mkql, opts, res, NMsgBusProxy::MSTATUS_OK);
         UNIT_ASSERT(success);
-        return res;
+        return res; 
     }
 
-    NKikimrMiniKQL::TResult FlatQuery(const TString& mkql, ui32 expectedStatus, ui32 expectedProxyErrorCode = TEvTxUserProxy::TResultStatus::Unknown) {
+    NKikimrMiniKQL::TResult FlatQuery(const TString& mkql, ui32 expectedStatus, ui32 expectedProxyErrorCode = TEvTxUserProxy::TResultStatus::Unknown) { 
         NKikimrMiniKQL::TResult res;
         TClient::TFlatQueryOptions opts;
         NKikimrClient::TResponse expectedResponse;
@@ -43,9 +43,9 @@ public:
         if (expectedProxyErrorCode != TEvTxUserProxy::TResultStatus::Unknown) {
             expectedResponse.SetProxyErrorCode(expectedProxyErrorCode);
         }
-        bool success = TClient::FlatQuery(mkql, opts, res, expectedResponse);
+        bool success = TClient::FlatQuery(mkql, opts, res, expectedResponse); 
         UNIT_ASSERT(success == (expectedStatus == NMsgBusProxy::MSTATUS_OK));
-        return res;
+        return res; 
     }
 
     TAutoPtr<NMsgBusProxy::TBusResponse> LsPathId(ui64 schemeshardId, ui64 pathId) {
diff --git a/ydb/core/client/locks_ut.cpp b/ydb/core/client/locks_ut.cpp
index 47b7c3dfdd..ebd90fd213 100644
--- a/ydb/core/client/locks_ut.cpp
+++ b/ydb/core/client/locks_ut.cpp
@@ -147,19 +147,19 @@ struct TLocksV1 {
             << "Counter: " << lock.Counter << Endl;
     }
 };
-
+ 
 ///
 struct TLocksV2 {
     static constexpr const char * TableName() { return "/sys/locks2"; }
     static constexpr const char * Columns() { return "'LockId 'DataShard 'Generation 'Counter 'SchemeShard 'PathId"; }
     static constexpr const char * ResultLabel() { return NMiniKQL::TxLocksResultLabel2.data(); }
-
+ 
     static TString Key(ui64 lockId, ui64 datashard, ui64 schemeshard, ui64 pathId) {
         return Sprintf(
             "'('LockId (Uint64 '%lu)) '('DataShard (Uint64 '%lu)) '('SchemeShard (Uint64 '%lu)) '('PathId (Uint64 '%lu))",
             lockId, datashard, schemeshard, pathId);
     }
-
+ 
     static NMiniKQL::IEngineFlat::TTxLock ExtractLock(TValue l) {
         UNIT_ASSERT_VALUES_EQUAL(l.Size(), 6);
         ui64 lockId = l["LockId"];
@@ -170,7 +170,7 @@ struct TLocksV2 {
         ui64 pathId = l["PathId"];
         return NMiniKQL::IEngineFlat::TTxLock(lockId, dataShard, generation, counter, schemeShard, pathId);
     }
-
+ 
     static void PrintLock(const NMiniKQL::IEngineFlat::TTxLock& lock) {
         Cout << "LockId: " << lock.LockId << ", "
             << "DataShard: " << lock.DataShard << ", "
@@ -178,15 +178,15 @@ struct TLocksV2 {
             << "Counter: " << lock.Counter << ", "
             << "SchemeShard: "<< lock.SchemeShard << ", "
             << "PathId: " << lock.PathId << Endl;
-    }
+    } 
 };
 
 template<typename T>
 static NMiniKQL::IEngineFlat::TTxLock ExtractRowLock(TValue l) {
     UNIT_ASSERT(l.HaveValue());
     return T::ExtractLock(l);
-}
-
+} 
+ 
 template<typename T>
 static void ExtractResultLocks(const NKikimrMiniKQL::TResult& result, TVector<NMiniKQL::IEngineFlat::TTxLock>& txLocks) {
     TValue value = TValue::Create(result.GetValue(), result.GetType());
@@ -295,47 +295,47 @@ void TestLock(const TLocksTestOptions& testOpts) {
     TClientServer cs(testOpts.OutOfOrder, testOpts.SoftUpdates);
     NKikimrMiniKQL::TResult res;
 
-    ui64 txLockId = 0;
-    auto getSetLocks = [&testOpts, &txLockId] () {
-        if (testOpts.TestRange) {
-            const char * setLocksT = R"___((
+    ui64 txLockId = 0; 
+    auto getSetLocks = [&testOpts, &txLockId] () { 
+        if (testOpts.TestRange) { 
+            const char * setLocksT = R"___(( 
                 (let table_ '%s)
                 (let range0_ '(%s '('key %s %s) %s))
                 (let range1_ '(%s '('key %s %s) %s))
-                (let cols_ '('key 'value))
-                (let ret_ (AsList
+                (let cols_ '('key 'value)) 
+                (let ret_ (AsList 
                     (SetResult 'res0 (SelectRange table_ range0_ cols_ '()))
                     (SetResult 'res1 (SelectRange table_ range1_ cols_ '()))
                     (AcquireLocks (Uint64 '%lu))
-                ))
-                (return ret_)
-            ))___";
+                )) 
+                (return ret_) 
+            ))___"; 
             return Sprintf(setLocksT, testOpts.Table,
                            testOpts.Range0Inc, testOpts.Range0Begin, testOpts.Range0End, testOpts.Range0OptKey,
                            testOpts.Range1Inc, testOpts.Range1Begin, testOpts.Range1End, testOpts.Range1OptKey, txLockId);
-        } else {
-            const char * setLocksT = R"___((
+        } else { 
+            const char * setLocksT = R"___(( 
                 (let table_ '%s)
                 (let row0_ '(%s))
                 (let row1_ '(%s))
                 (let row2_ '(%s))
-                (let cols_ '('value))
+                (let cols_ '('value)) 
                 (let select0_ (SelectRow table_ row0_ cols_))
                 (let select1_ (SelectRow table_ row1_ cols_))
                 (let select2_ (SelectRow table_ row2_ cols_))
-                (let ret_ (AsList
-                    (SetResult 'res0 select0_)
-                    (SetResult 'res1 select1_)
+                (let ret_ (AsList 
+                    (SetResult 'res0 select0_) 
+                    (SetResult 'res1 select1_) 
                     (SetResult 'res2 select2_)
-                    (SetResult 'txid (Nth (StepTxId) '1))
+                    (SetResult 'txid (Nth (StepTxId) '1)) 
                     (AcquireLocks (Uint64 '%lu))
-                ))
-                (return ret_)
-            ))___";
+                )) 
+                (return ret_) 
+            ))___"; 
             return Sprintf(setLocksT, testOpts.Table,
                            testOpts.BreakKey, testOpts.NoBreakKey0, testOpts.NoBreakKey1, txLockId);
-        }
-    };
+        } 
+    }; 
 
     TVector<NMiniKQL::IEngineFlat::TTxLock> txLocks;
 
@@ -344,21 +344,21 @@ void TestLock(const TLocksTestOptions& testOpts) {
         ui64 pathId = 3;
         txLocks.emplace_back(NMiniKQL::IEngineFlat::TTxLock{281474976710659, 72075186224037888, 2, 0, ssId, pathId});
         txLocks.emplace_back(NMiniKQL::IEngineFlat::TTxLock{281474976710659, 72075186224037889, 2, 0, ssId, pathId});
-        txLockId = 281474976710659;
+        txLockId = 281474976710659; 
     } else {
-        cs.Client.FlatQuery(getSetLocks(), res);
+        cs.Client.FlatQuery(getSetLocks(), res); 
         ExtractResultLocks<TLocksVer>(res, txLocks);
-        UNIT_ASSERT(txLocks.size() > 0);
-        txLockId = txLocks[0].LockId;
+        UNIT_ASSERT(txLocks.size() > 0); 
+        txLockId = txLocks[0].LockId; 
     }
 
-    for (auto& lock : txLocks)
+    for (auto& lock : txLocks) 
         TLocksVer::PrintLock(lock);
 
     if (testOpts.SetOnly)
         return;
 
-    UNIT_ASSERT_VALUES_EQUAL(txLocks.size(), 2);
+    UNIT_ASSERT_VALUES_EQUAL(txLocks.size(), 2); 
 
     const char * breakLock = nullptr;
     if (!testOpts.TestErase) {
@@ -389,7 +389,7 @@ void TestLock(const TLocksTestOptions& testOpts) {
     cs.Client.FlatQuery(Sprintf(breakLock, testOpts.Table, testOpts.BreakKey, (testOpts.Break ? "true" : "false") ));
 
     if (testOpts.Dup) {
-        cs.Client.FlatQuery(getSetLocks(), res);
+        cs.Client.FlatQuery(getSetLocks(), res); 
         ExtractResultLocks<TLocksVer>(res, txLocks);
     }
 
@@ -1130,11 +1130,11 @@ static void MultipleLocks() {
         (let select0_ (SelectRow '/dc-1/Dir/A row0_ cols_))
         (let ret_ (AsList
             (SetResult 'res0 select0_)
-            (AcquireLocks (Uint64 '0))
+            (AcquireLocks (Uint64 '0)) 
         ))
         (return ret_)
     ))___";
-    cs.Client.FlatQuery(q1, res);
+    cs.Client.FlatQuery(q1, res); 
     TVector<NMiniKQL::IEngineFlat::TTxLock> locks1;
     ExtractResultLocks<TLocksVer>(res, locks1);
 
@@ -1162,11 +1162,11 @@ static void MultipleLocks() {
         (let ret_ (AsList
             (SetResult 'res0 select0_)
             (SetResult 'res1 select1_)
-            (AcquireLocks (Uint64 '0))
+            (AcquireLocks (Uint64 '0)) 
         ))
         (return ret_)
     ))___";
-    cs.Client.FlatQuery(q2, res);
+    cs.Client.FlatQuery(q2, res); 
     TVector<NMiniKQL::IEngineFlat::TTxLock> locks2;
     ExtractResultLocks<TLocksVer>(res, locks2);
 
@@ -1274,7 +1274,7 @@ Y_UNIT_TEST(SetLockFail) {
         (let update_ '('('value (Uint32 '0))))
         (let ret_ (AsList
             (UpdateRow '/dc-1/Dir/A row0_ update_)
-            (AcquireLocks (Uint64 '0))
+            (AcquireLocks (Uint64 '0)) 
         ))
         (return ret_)
     ))___";
@@ -1285,7 +1285,7 @@ Y_UNIT_TEST(SetLockFail) {
         (let row0_ '('('key (Uint32 '42))))
         (let ret_ (AsList
             (EraseRow '/dc-1/Dir/A row0_)
-            (AcquireLocks (Uint64 '0))
+            (AcquireLocks (Uint64 '0)) 
         ))
         (return ret_)
     ))___";
diff --git a/ydb/core/client/minikql_compile/compile_context.cpp b/ydb/core/client/minikql_compile/compile_context.cpp
index 44526ee5aa..7e29261d27 100644
--- a/ydb/core/client/minikql_compile/compile_context.cpp
+++ b/ydb/core/client/minikql_compile/compile_context.cpp
@@ -9,7 +9,7 @@ namespace NYql {
 TContext::TContext(const IFunctionRegistry* funcRegistry,
                    const TTypeEnvironment* typeEnv)
     : FuncRegistry(funcRegistry)
-    , TypeEnv(typeEnv)
+    , TypeEnv(typeEnv) 
     , TypeInfoHelper(new NKikimr::NMiniKQL::TTypeInfoHelper)
     , PgmBuilder(new TKikimrProgramBuilder(*typeEnv, *funcRegistry))
     , WasParams(false)
@@ -29,24 +29,24 @@ TRuntimeNode TContext::NewParam(TStringBuf name, TType* type) {
     return PgmBuilder->Parameter(TString(name), type);
 }
 
-void TContext::AddTableLookup(const IDbSchemeResolver::TTable& request) {
-    auto state = Tables.FindPtr(request.TableName);
-    if (state) {
-        state->Request.ColumnNames.insert(request.ColumnNames.begin(), request.ColumnNames.end());
-    } else {
-        Tables.insert({request.TableName, TTableState{request, TMaybe<IDbSchemeResolver::TTableResult>()}});
-    }
+void TContext::AddTableLookup(const IDbSchemeResolver::TTable& request) { 
+    auto state = Tables.FindPtr(request.TableName); 
+    if (state) { 
+        state->Request.ColumnNames.insert(request.ColumnNames.begin(), request.ColumnNames.end()); 
+    } else { 
+        Tables.insert({request.TableName, TTableState{request, TMaybe<IDbSchemeResolver::TTableResult>()}}); 
+    } 
 }
 
 template<typename TStringType>
 IDbSchemeResolver::TTableResult* TContext::GetTableLookup(const TExprNode& node, const TStringType& tableName) {
-    auto entry = Tables.FindPtr(tableName);
+    auto entry = Tables.FindPtr(tableName); 
     if (!entry) {
-        ythrow TNodeException(node) << "Table is not found: " << tableName;
+        ythrow TNodeException(node) << "Table is not found: " << tableName; 
     }
 
     if (!entry->Response.Defined()) {
-        ythrow TNodeException(node) << "Table is not resolved: " << tableName;
+        ythrow TNodeException(node) << "Table is not resolved: " << tableName; 
     }
 
     return entry->Response.Get();
@@ -72,7 +72,7 @@ TConvertResult TContext::Finish(TRuntimeNode convertedNode) {
         convRes.Node = convertedNode;
     } else {
         // Params with params.
-        convRes.Errors.AddIssue(TPosition(1, 1), "Params program can't contains params.");
+        convRes.Errors.AddIssue(TPosition(1, 1), "Params program can't contains params."); 
     }
     return convRes;
 }
diff --git a/ydb/core/client/minikql_compile/compile_context.h b/ydb/core/client/minikql_compile/compile_context.h
index 22a9ebdf37..249f57bd5a 100644
--- a/ydb/core/client/minikql_compile/compile_context.h
+++ b/ydb/core/client/minikql_compile/compile_context.h
@@ -39,7 +39,7 @@ struct TContext : public TAtomicRefCount<TContext> {
     bool NewParamsBuilder();
     TRuntimeNode NewParam(TStringBuf name, TType* type);
 
-    void AddTableLookup(const IDbSchemeResolver::TTable& request);
+    void AddTableLookup(const IDbSchemeResolver::TTable& request); 
     template<typename TStringType>
     IDbSchemeResolver::TTableResult* GetTableLookup(const TExprNode& node, const TStringType& tableName);
     TTableMap& GetTablesToResolve();
@@ -47,8 +47,8 @@ struct TContext : public TAtomicRefCount<TContext> {
     TConvertResult Finish(TRuntimeNode convertedNode);
 
 public:
-    const IFunctionRegistry* FuncRegistry;
-    const TTypeEnvironment* TypeEnv;
+    const IFunctionRegistry* FuncRegistry; 
+    const TTypeEnvironment* TypeEnv; 
     NKikimr::NUdf::ITypeInfoHelper::TPtr TypeInfoHelper;
     TAutoPtr<TKikimrProgramBuilder> PgmBuilder;
     TMaybe<TParametersBuilder> ParamsBuilder;
diff --git a/ydb/core/client/minikql_compile/compile_result.cpp b/ydb/core/client/minikql_compile/compile_result.cpp
index 9891b7fc6f..37fb9759f5 100644
--- a/ydb/core/client/minikql_compile/compile_result.cpp
+++ b/ydb/core/client/minikql_compile/compile_result.cpp
@@ -4,7 +4,7 @@
 namespace NYql {
 
 TMiniKQLCompileResult::TMiniKQLCompileResult(const TIssue& error) {
-    Errors.AddIssue(error);
+    Errors.AddIssue(error); 
 }
 
 TMiniKQLCompileResult::TMiniKQLCompileResult(const TIssues& errors)
diff --git a/ydb/core/client/minikql_compile/db_key_resolver.h b/ydb/core/client/minikql_compile/db_key_resolver.h
index e748525fa8..0b269676c8 100644
--- a/ydb/core/client/minikql_compile/db_key_resolver.h
+++ b/ydb/core/client/minikql_compile/db_key_resolver.h
@@ -7,11 +7,11 @@
 #include <ydb/core/scheme/tablet_scheme_defs.h>
 #include <ydb/core/scheme/scheme_tabledefs.h>
 
-#include <util/generic/map.h>
-#include <util/generic/set.h>
+#include <util/generic/map.h> 
+#include <util/generic/set.h> 
 #include <util/generic/string.h>
 
-
+ 
 #include <library/cpp/threading/future/future.h>
 
 
diff --git a/ydb/core/client/minikql_compile/mkql_compile_service.cpp b/ydb/core/client/minikql_compile/mkql_compile_service.cpp
index e01d61a22c..30dda74b89 100644
--- a/ydb/core/client/minikql_compile/mkql_compile_service.cpp
+++ b/ydb/core/client/minikql_compile/mkql_compile_service.cpp
@@ -38,7 +38,7 @@ public:
             , ResponseTo(sender)
             , Alloc(allocPoolCounters, functionRegistry->SupportsSizedAllocators())
             , TypeEnv(Alloc)
-            , Cookie(0)
+            , Cookie(0) 
             , Retried(false)
         {
             Alloc.Release();
@@ -53,7 +53,7 @@ public:
         TActorId ResponseTo;
         NMiniKQL::TScopedAlloc Alloc;
         NMiniKQL::TTypeEnvironment TypeEnv;
-        ui64 Cookie;
+        ui64 Cookie; 
         bool Retried;
         THashMap<TString, ui64> CompileResolveCookies;
         bool ForceRefresh;
@@ -101,7 +101,7 @@ private:
     void Handle(TMiniKQLCompileServiceEvents::TEvCompile::TPtr& ev, const TActorContext& ctx) {
         TMiniKQLCompileServiceEvents::TEvCompile *msg = ev->Get();
         TCompileContext::TPtr c(new TCompileContext(msg->Program, ev->Sender, AllocPoolCounters, AppData(ctx)->FunctionRegistry));
-        c->Cookie = ev->Cookie;
+        c->Cookie = ev->Cookie; 
         c->CompileResolveCookies = std::move(msg->CompileResolveCookies);
         c->ForceRefresh = msg->ForceRefresh;
         CompileQueue.push(c);
diff --git a/ydb/core/client/minikql_compile/yql_expr_minikql.cpp b/ydb/core/client/minikql_compile/yql_expr_minikql.cpp
index 76f38bf35c..db2d27eac0 100644
--- a/ydb/core/client/minikql_compile/yql_expr_minikql.cpp
+++ b/ydb/core/client/minikql_compile/yql_expr_minikql.cpp
@@ -11,7 +11,7 @@
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
 #include <ydb/core/protos/issue_id.pb.h>
 #include <ydb/public/lib/scheme_types/scheme_type_id.h>
-
+ 
 #include <ydb/library/yql/minikql/invoke_builtins/mkql_builtins.h>
 #include <ydb/library/yql/minikql/mkql_function_registry.h>
 #include <ydb/library/yql/minikql/mkql_node_cast.h>
@@ -21,7 +21,7 @@
 #include <ydb/library/yql/minikql/mkql_type_builder.h>
 #include <ydb/library/yql/minikql/mkql_utils.h>
 #include <ydb/library/yql/minikql/mkql_type_ops.h>
-
+ 
 #include <ydb/library/yql/core/type_ann/type_ann_expr.h>
 #include <ydb/library/yql/core/type_ann/type_ann_impl.h>
 #include <ydb/library/yql/core/type_ann/type_ann_list.h>
@@ -52,46 +52,46 @@ using namespace NKikimr::NMiniKQL;
 
 using namespace NThreading;
 
-using namespace NYql::NCommon;
-
+using namespace NYql::NCommon; 
+ 
 namespace {
 
-TReadTarget GetReadTarget(TExprNode* node) {
-    Y_ENSURE_EX(node->IsAtom(), TNodeException(node) << "Expected atom");
+TReadTarget GetReadTarget(TExprNode* node) { 
+    Y_ENSURE_EX(node->IsAtom(), TNodeException(node) << "Expected atom"); 
     auto modeStr = node->Content();
-    if (modeStr == "head") {
-        return TReadTarget::Head();
-    }
-    else if (modeStr == "online") {
-        return TReadTarget::Online();
+    if (modeStr == "head") { 
+        return TReadTarget::Head(); 
     }
+    else if (modeStr == "online") { 
+        return TReadTarget::Online(); 
+    } 
     else if (modeStr == "follower") {
         return TReadTarget::Follower();
     }
-    else {
-        ythrow TNodeException(node) << "Unknown read target mode: " << modeStr;
-    }
-}
-
+    else { 
+        ythrow TNodeException(node) << "Unknown read target mode: " << modeStr; 
+    } 
+} 
+ 
 EInplaceUpdateMode ParseUpdateMode(const TStringBuf& name) {
-    EInplaceUpdateMode mode = EInplaceUpdateMode::Unknown;
-
-    if (name == "Sum") {
-        mode = EInplaceUpdateMode::Sum;
-    }
-    else if (name == "Min") {
-        mode = EInplaceUpdateMode::Min;
-    }
-    else if (name == "Max") {
-        mode = EInplaceUpdateMode::Max;
-    }
-    else if (name == "IfNotExistOrEmpty") {
-        mode = EInplaceUpdateMode::IfNotExistOrEmpty;
-    }
-
-    return mode;
-}
-
+    EInplaceUpdateMode mode = EInplaceUpdateMode::Unknown; 
+ 
+    if (name == "Sum") { 
+        mode = EInplaceUpdateMode::Sum; 
+    } 
+    else if (name == "Min") { 
+        mode = EInplaceUpdateMode::Min; 
+    } 
+    else if (name == "Max") { 
+        mode = EInplaceUpdateMode::Max; 
+    } 
+    else if (name == "IfNotExistOrEmpty") { 
+        mode = EInplaceUpdateMode::IfNotExistOrEmpty; 
+    } 
+
+    return mode; 
+} 
+ 
 bool CheckVersionedTable(const TExprNode* list) {
     if (list->ChildrenSize() == 3) {
         const auto name = list->Child(0);
@@ -120,13 +120,13 @@ TStringBuf GetTableName(const TExprNode* node) {
 }
 
 const TTypeAnnotationNode* GetMkqlDataTypeAnnotation(TDataType* dataType, TExprContext& ctx)
-{
+{ 
     return ctx.MakeType<TDataExprType>(*dataType->GetDataSlot());
-}
-
-void CollectEraseRowKey(const TExprNode* child, TContext::TPtr ctx) {
-    IDbSchemeResolver::TTable request;
-
+} 
+ 
+void CollectEraseRowKey(const TExprNode* child, TContext::TPtr ctx) { 
+    IDbSchemeResolver::TTable request; 
+ 
     Y_ENSURE_EX(child->ChildrenSize() == 2, TNodeException(child) << child->Content()
                 << " takes 2 args.");
     request.TableName = GetTableName(child);
@@ -134,22 +134,22 @@ void CollectEraseRowKey(const TExprNode* child, TContext::TPtr ctx) {
     auto rowTuple = child->Child(1);
     Y_ENSURE_EX(rowTuple->IsList() && rowTuple->ChildrenSize() > 0,
         TNodeException(rowTuple) << child->Content() << "Expected non-empty tuple");
-
+ 
     for (auto& tupleItem : rowTuple->Children()) {
         Y_ENSURE_EX(tupleItem->IsList() && tupleItem->ChildrenSize() == 2,
             TNodeException(*tupleItem) << child->Content() << "Expected pair");
-
+ 
         Y_ENSURE_EX(tupleItem->Child(0)->IsAtom() &&
             !tupleItem->Child(0)->Content().empty(), TNodeException(tupleItem->Child(0))
                     << "Expected column name as non-empty atom.");
         request.ColumnNames.insert(TString(tupleItem->Child(0)->Content()));
-    }
+    } 
 
-    ctx->AddTableLookup(request);
+    ctx->AddTableLookup(request); 
 }
 
-void CollectUpdateRowKey(const TExprNode* child, TContext::TPtr ctx) {
-    IDbSchemeResolver::TTable request;
+void CollectUpdateRowKey(const TExprNode* child, TContext::TPtr ctx) { 
+    IDbSchemeResolver::TTable request; 
 
     Y_ENSURE_EX(child->ChildrenSize() == 3, TNodeException(child) << child->Content()
                 << " takes 3 args.");
@@ -167,11 +167,11 @@ void CollectUpdateRowKey(const TExprNode* child, TContext::TPtr ctx) {
             !tupleItem->Child(0)->Content().empty(), TNodeException(tupleItem->Child(0))
                 << "Expected column name as non-empty atom.");
         request.ColumnNames.insert(TString(tupleItem->Child(0)->Content()));
-    }
+    } 
 
     auto updateTuple = child->Child(2);
     Y_ENSURE_EX(updateTuple->IsList(), TNodeException(updateTuple) << child->Content() << "Expected tuple");
-
+ 
     for (auto& tupleItem : updateTuple->Children()) {
         Y_ENSURE_EX(tupleItem->IsList() && tupleItem->ChildrenSize() >= 1 && tupleItem->ChildrenSize() <= 3,
             TNodeException(*tupleItem) << child->Content() << "Expected tuple of size 1..3");
@@ -181,11 +181,11 @@ void CollectUpdateRowKey(const TExprNode* child, TContext::TPtr ctx) {
         request.ColumnNames.insert(TString(tupleItem->Child(0)->Content()));
     }
 
-    ctx->AddTableLookup(request);
+    ctx->AddTableLookup(request); 
 }
 
-void CollectSelectRowKey(const TExprNode* child, TContext::TPtr ctx) {
-    IDbSchemeResolver::TTable request;
+void CollectSelectRowKey(const TExprNode* child, TContext::TPtr ctx) { 
+    IDbSchemeResolver::TTable request; 
 
     Y_ENSURE_EX(child->ChildrenSize() == 3 || child->ChildrenSize() == 4,
         TNodeException(child) << child->Content() << " takes 3 or 4 args.");
@@ -207,19 +207,19 @@ void CollectSelectRowKey(const TExprNode* child, TContext::TPtr ctx) {
 
     auto selectTuple = child->Child(2);
     Y_ENSURE_EX(selectTuple->IsList(), TNodeException(selectTuple) << child->Content() << "Expected tuple");
-
+ 
     for (auto& tupleItem : selectTuple->Children()) {
-        Y_ENSURE_EX(tupleItem->IsAtom() &&
+        Y_ENSURE_EX(tupleItem->IsAtom() && 
             !tupleItem->Content().empty(), TNodeException(*tupleItem) << "Expected column name as non-empty atom.");
         request.ColumnNames.insert(TString(tupleItem->Content()));
     }
 
-    ctx->AddTableLookup(request);
+    ctx->AddTableLookup(request); 
 }
 
-void CollectSelectRangeKey(const TExprNode* child, TContext::TPtr ctx) {
-    IDbSchemeResolver::TTable request;
-
+void CollectSelectRangeKey(const TExprNode* child, TContext::TPtr ctx) { 
+    IDbSchemeResolver::TTable request; 
+ 
     Y_ENSURE_EX(child->ChildrenSize() == 4 || child->ChildrenSize() == 5,
         TNodeException(child) << child->Content() << " takes 4 or 5 args.");
 
@@ -227,42 +227,42 @@ void CollectSelectRangeKey(const TExprNode* child, TContext::TPtr ctx) {
     auto rangeTuple = child->Child(1);
     Y_ENSURE_EX(rangeTuple->IsList() && rangeTuple->ChildrenSize() > 0,
         TNodeException(rangeTuple) << child->Content() << "Expected non-empty tuple");
-
+ 
     for (auto& rangeItem : rangeTuple->Children()) {
-        if (rangeItem->IsAtom()) {
-            continue;
-        }
-        else {
+        if (rangeItem->IsAtom()) { 
+            continue; 
+        } 
+        else { 
             Y_ENSURE_EX(rangeItem->IsList() && rangeItem->ChildrenSize() == 3,
                 TNodeException(*rangeItem) << child->Content() << "Expected 3 items in range item - column/from/to");
 
             Y_ENSURE_EX(rangeItem->Child(0)->IsAtom() &&
                 !rangeItem->Child(0)->Content().empty(), TNodeException(rangeItem->Child(0)) << "Expected column name as non-empty atom.");
             request.ColumnNames.insert(TString(rangeItem->Child(0)->Content()));
-        }
-    }
+        } 
+    } 
 
     auto selectTuple = child->Child(2);
     Y_ENSURE_EX(selectTuple->IsList(), TNodeException(selectTuple) << child->Content() << "Expected tuple");
-
+ 
     for (auto& tupleItem : selectTuple->Children()) {
-        Y_ENSURE_EX(tupleItem->IsAtom() &&
+        Y_ENSURE_EX(tupleItem->IsAtom() && 
             !tupleItem->Content().empty(), TNodeException(*tupleItem) << "Expected column name as non-empty atom.");
         request.ColumnNames.insert(TString(tupleItem->Content()));
     }
 
-    ctx->AddTableLookup(request);
-}
-
-class TKikimrCallableTypeAnnotationTransformer : public TSyncTransformerBase {
-public:
-    TKikimrCallableTypeAnnotationTransformer(
-            TContext::TPtr mkqlCtx,
-            TAutoPtr<IGraphTransformer> callableTransformer)
-        : MkqlCtx(mkqlCtx)
-        , CallableTransformer(callableTransformer) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    ctx->AddTableLookup(request); 
+} 
+ 
+class TKikimrCallableTypeAnnotationTransformer : public TSyncTransformerBase { 
+public: 
+    TKikimrCallableTypeAnnotationTransformer( 
+            TContext::TPtr mkqlCtx, 
+            TAutoPtr<IGraphTransformer> callableTransformer) 
+        : MkqlCtx(mkqlCtx) 
+        , CallableTransformer(callableTransformer) {} 
+
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         output = input;
         {
             auto name = input->Content();
@@ -329,11 +329,11 @@ public:
                 return NTypeAnnImpl::TakeWrapper(input, output, typeAnnCtx);
             }
         }
-
-        return CallableTransformer->Transform(input, output, ctx);
+ 
+        return CallableTransformer->Transform(input, output, ctx); 
     }
 
-private:
+private: 
     static bool CheckKeyColumn(const TStringBuf& columnName, ui32 keyIndex, IDbSchemeResolver::TTableResult* lookup, TExprNode& node, TExprContext& ctx) {
         auto column = lookup->Columns.FindPtr(columnName);
         if (!column) {
@@ -369,20 +369,20 @@ private:
             if (!CheckKeyColumn(columnName, i, lookup, node, ctx)) {
                 return false;
             }
-        }
+        } 
 
         return true;
-    }
+    } 
 
     const TTypeAnnotationNode* GetSelectType(IDbSchemeResolver::TTableResult* lookup, TExprNode& selectTuple,
-        TExprContext& ctx)
-    {
+        TExprContext& ctx) 
+    { 
         TVector<const TItemExprType*> resultItems;
-
+ 
         for (auto& tupleItem : selectTuple.Children()) {
             auto columnName = tupleItem->Content();
             const TTypeAnnotationNode *columnDataType;
-
+ 
             auto systemColumnType = KikimrSystemColumns().find(columnName);
             if (systemColumnType != KikimrSystemColumns().end()) {
                 columnDataType = ctx.MakeType<TDataExprType>(systemColumnType->second);
@@ -403,16 +403,16 @@ private:
                 }
             }
             auto columnOptType = ctx.MakeType<TOptionalExprType>(columnDataType);
-
+ 
             resultItems.push_back(ctx.MakeType<TItemExprType>(columnName, columnOptType));
         }
 
         auto selectType = ctx.MakeType<TStructExprType>(resultItems);
-        return selectType;
+        return selectType; 
     }
 
-private:
-    IGraphTransformer::TStatus SelectRowWrapper(TExprNode& node, TExprContext& ctx) {
+private: 
+    IGraphTransformer::TStatus SelectRowWrapper(TExprNode& node, TExprContext& ctx) { 
         const auto lookup = MkqlCtx->GetTableLookup(node, GetTableName(&node));
         auto rowTuple = node.Child(1);
 
@@ -421,81 +421,81 @@ private:
         }
 
         auto selectTuple = node.Child(2);
-        auto selectType = GetSelectType(lookup, *selectTuple, ctx);
+        auto selectType = GetSelectType(lookup, *selectTuple, ctx); 
         auto optSelectType = ctx.MakeType<TOptionalExprType>(selectType);
 
         node.SetTypeAnn(optSelectType);
-        return TStatus::Ok;
-    }
-
-    IGraphTransformer::TStatus SelectRangeWrapper(TExprNode& node, TExprContext& ctx) {
+        return TStatus::Ok; 
+    } 
+ 
+    IGraphTransformer::TStatus SelectRangeWrapper(TExprNode& node, TExprContext& ctx) { 
         const auto lookup = MkqlCtx->GetTableLookup(node, GetTableName(&node));
         auto rangeTuple = node.Child(1);
-
-        ui32 keyCount = 0;
-        bool finishedFrom = false;
-        bool finishedTo = false;
-        ui32 fromComponents = 0;
+ 
+        ui32 keyCount = 0; 
+        bool finishedFrom = false; 
+        bool finishedTo = false; 
+        ui32 fromComponents = 0; 
 
         for (auto rangeItem : rangeTuple->Children()) {
-            if (rangeItem->IsAtom()) {
+            if (rangeItem->IsAtom()) { 
                 if (rangeItem->Content() != "IncFrom" &&
                     rangeItem->Content() != "ExcFrom" &&
                     rangeItem->Content() != "IncTo" &&
                     rangeItem->Content() != "ExcTo")
-                {
+                { 
                     ythrow TNodeException(node) << "Unsupported range bound: " << rangeItem->Content();
-                }
-
-                continue;
-            }
-
-            if (!EnsureComputable(*rangeItem->Child(1), ctx)) {
-                return TStatus::Error;
-            }
-
-            if (!EnsureComputable(*rangeItem->Child(2), ctx)) {
-                return TStatus::Error;
-            }
-
-            ++keyCount;
+                } 
+
+                continue; 
+            } 
+
+            if (!EnsureComputable(*rangeItem->Child(1), ctx)) { 
+                return TStatus::Error; 
+            } 
+ 
+            if (!EnsureComputable(*rangeItem->Child(2), ctx)) { 
+                return TStatus::Error; 
+            } 
+ 
+            ++keyCount; 
             if (!rangeItem->Child(1)->IsCallable("Void")) {
                 Y_ENSURE_EX(!finishedFrom, TNodeException(rangeItem->Child(1))
-                    << "From tuple is already set to infinity");
-                ++fromComponents;
-            } else {
-                finishedFrom = true;
-            }
+                    << "From tuple is already set to infinity"); 
+                ++fromComponents; 
+            } else { 
+                finishedFrom = true; 
+            } 
 
             if (!rangeItem->Child(2)->IsCallable("Void")) {
                 Y_ENSURE_EX(!finishedTo, TNodeException(rangeItem->Child(2))
-                    << "To tuple is already set to infinity");
-            }
-            else {
-                finishedTo = true;
-            }
-        }
-
-        Y_ENSURE_EX(keyCount <= lookup->KeyColumnCount, TNodeException(node)
+                    << "To tuple is already set to infinity"); 
+            } 
+            else { 
+                finishedTo = true; 
+            } 
+        } 
+
+        Y_ENSURE_EX(keyCount <= lookup->KeyColumnCount, TNodeException(node) 
             << "Too many key columns specified, table [" << lookup->Table.TableName
             << "] has only: " << lookup->KeyColumnCount
             << ", but got " << keyCount << ".");
 
-        Y_ENSURE_EX(fromComponents > 0, TNodeException(node)
-            << "Expected at least one component of key in the 'from' section of the range");
+        Y_ENSURE_EX(fromComponents > 0, TNodeException(node) 
+            << "Expected at least one component of key in the 'from' section of the range"); 
 
-        ui32 keyIndex = 0;
+        ui32 keyIndex = 0; 
         for (auto rangeItem : rangeTuple->Children()) {
-            if (rangeItem->IsAtom()) {
-                continue;
-            }
+            if (rangeItem->IsAtom()) { 
+                continue; 
+            } 
 
             auto columnName = rangeItem->Child(0)->Content();
             if (!CheckKeyColumn(columnName, keyIndex, lookup, node, ctx)) {
                 return TStatus::Error;
             }
-            ++keyIndex;
-        }
+            ++keyIndex; 
+        } 
 
         auto selectTuple = node.Child(2);
 
@@ -515,7 +515,7 @@ private:
         }
 
         auto optionsNode = node.Child(3);
-        Y_ENSURE_EX(optionsNode->IsList(), TNodeException(optionsNode) << "Expected tuple");
+        Y_ENSURE_EX(optionsNode->IsList(), TNodeException(optionsNode) << "Expected tuple"); 
         for (auto optionsItem : optionsNode->Children()) {
             Y_ENSURE_EX(optionsItem->IsList() && optionsItem->ChildrenSize() == 2 && optionsItem->Child(0)->IsAtom(),
                 TNodeException(*optionsItem) << "Expected pair of atom and value");
@@ -528,11 +528,11 @@ private:
                 optionName != "ForbidNullArgsFrom" &&
                 optionName != "ForbidNullArgsTo")
             {
-                ythrow TNodeException(node) << "Unsupported option: " << optionName;
-            }
-        }
+                ythrow TNodeException(node) << "Unsupported option: " << optionName; 
+            } 
+        } 
 
-        auto selectType = GetSelectType(lookup, *selectTuple, ctx);
+        auto selectType = GetSelectType(lookup, *selectTuple, ctx); 
         auto listSelectType = ctx.MakeType<TListExprType>(selectType);
 
         TVector<const TItemExprType*> resultItems;
@@ -543,139 +543,139 @@ private:
         auto resultType = ctx.MakeType<TStructExprType>(resultItems);
 
         node.SetTypeAnn(resultType);
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
-    IGraphTransformer::TStatus UpdateRowWrapper(TExprNode& node, TExprContext& ctx) {
+    IGraphTransformer::TStatus UpdateRowWrapper(TExprNode& node, TExprContext& ctx) { 
         const auto lookup = MkqlCtx->GetTableLookup(node, GetTableName(&node));
         auto rowTuple = node.Child(1);
 
         if (!CheckRowTuple(lookup, node, *rowTuple, ctx)) {
             return TStatus::Error;
         }
-
+ 
         auto updateTuple = node.Child(2);
         for (ui32 i = 0; i < updateTuple->ChildrenSize(); ++i) {
             auto child = updateTuple->Child(i);
             auto columnName = child->Child(0)->Content();
-            auto column = lookup->Columns.FindPtr(columnName);
+            auto column = lookup->Columns.FindPtr(columnName); 
             YQL_ENSURE(column);
-            Y_ENSURE_EX(column->KeyPosition < 0, TNodeException(node)
+            Y_ENSURE_EX(column->KeyPosition < 0, TNodeException(node) 
                 << "Key column cannot be updated: " << child->Child(0)->Content());
-
+ 
             if (child->ChildrenSize() != 1 && child->ChildrenSize() != 2) {
                 Y_ENSURE_EX(child->Child(1)->IsAtom(), TNodeException(child->Child(1))
-                    << "Expected atom");
+                    << "Expected atom"); 
                 auto modeStr = child->Child(1)->Content();
-                auto mode = ParseUpdateMode(modeStr);
-
+                auto mode = ParseUpdateMode(modeStr); 
+ 
                 Y_ENSURE_EX(mode != EInplaceUpdateMode::Unknown, TNodeException(child->Child(1))
-                    << "Unknown inplace update mode: " << modeStr);
-                Y_ENSURE_EX(column->AllowInplaceMode != (ui32)EInplaceUpdateMode::Unknown, TNodeException(child)
+                    << "Unknown inplace update mode: " << modeStr); 
+                Y_ENSURE_EX(column->AllowInplaceMode != (ui32)EInplaceUpdateMode::Unknown, TNodeException(child) 
                     << "Inplace update mode is not allowed for column: " << child->Child(0)->Content());
                 Y_ENSURE_EX((ui32)mode == column->AllowInplaceMode, TNodeException(child->Child(1))
-                    << "Mismatch of column allowed inplace update mode, allowed: " << column->AllowInplaceMode
+                    << "Mismatch of column allowed inplace update mode, allowed: " << column->AllowInplaceMode 
                     << ", but got: " << (ui32)mode << ", column: " << child->Child(0)->Content());
-            }
-        }
-
+            } 
+        } 
+ 
         node.SetTypeAnn(ctx.MakeType<TVoidExprType>());
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
-    IGraphTransformer::TStatus EraseRowWrapper(TExprNode& node, TExprContext& ctx) {
+    IGraphTransformer::TStatus EraseRowWrapper(TExprNode& node, TExprContext& ctx) { 
         const auto lookup = MkqlCtx->GetTableLookup(node, GetTableName(&node));
         auto rowTuple = node.Child(1);
 
         if (!CheckRowTuple(lookup, node, *rowTuple, ctx)) {
             return TStatus::Error;
         }
-
+ 
         node.SetTypeAnn(ctx.MakeType<TVoidExprType>());
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
-    IGraphTransformer::TStatus SetResultWrapper(TExprNode& node, TExprContext& ctx) {
+    IGraphTransformer::TStatus SetResultWrapper(TExprNode& node, TExprContext& ctx) { 
         Y_ENSURE_EX(node.ChildrenSize() == 2, TNodeException(node) << "SetResult expects 2 args.");
         Y_ENSURE_EX(node.Child(0)->Type() == TExprNode::Atom, TNodeException(node) << "First SetResult argument should be Atom.");
 
         node.SetTypeAnn(ctx.MakeType<TVoidExprType>());
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
-    IGraphTransformer::TStatus IncrementWrapper(TExprNode& node, TExprContext& ctx) {
-        if (!EnsureArgsCount(node, 1, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
+    IGraphTransformer::TStatus IncrementWrapper(TExprNode& node, TExprContext& ctx) { 
+        if (!EnsureArgsCount(node, 1, ctx)) { 
+            return IGraphTransformer::TStatus::Error; 
+        } 
 
         node.SetTypeAnn(node.Child(0)->GetTypeAnn());
-        return TStatus::Ok;
-    }
-
-    IGraphTransformer::TStatus StepTxIdWrapper(TExprNode& node, TExprContext& ctx) {
-        if (!EnsureArgsCount(node, 0, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+        return TStatus::Ok; 
+    } 
+ 
+    IGraphTransformer::TStatus StepTxIdWrapper(TExprNode& node, TExprContext& ctx) { 
+        if (!EnsureArgsCount(node, 0, ctx)) { 
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         auto ui64Type = ctx.MakeType<TDataExprType>(EDataSlot::Uint64);
         TVector<const TTypeAnnotationNode*> items;
         items.reserve(2);
-        items.push_back(ui64Type);
-        items.push_back(ui64Type);
+        items.push_back(ui64Type); 
+        items.push_back(ui64Type); 
 
         auto tupleType = ctx.MakeType<TTupleExprType>(items);
 
         node.SetTypeAnn(tupleType);
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
-    IGraphTransformer::TStatus ParameterWrapper(TExprNode& node, TExprContext& ctx) {
-        Y_UNUSED(ctx);
+    IGraphTransformer::TStatus ParameterWrapper(TExprNode& node, TExprContext& ctx) { 
+        Y_UNUSED(ctx); 
 
         Y_ENSURE_EX(node.ChildrenSize() == 2, TNodeException(node) << "Parameter expects 2 args.");
-
+ 
         if (!EnsureType(*node.Child(1), ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         auto parameterType = node.Child(1)->GetTypeAnn()->Cast<TTypeExprType>()->GetType();
-
+ 
         node.SetTypeAnn(parameterType);
-        return TStatus::Ok;
+        return TStatus::Ok; 
     }
 
-    IGraphTransformer::TStatus ParametersWrapper(TExprNode& node, TExprContext& ctx) {
+    IGraphTransformer::TStatus ParametersWrapper(TExprNode& node, TExprContext& ctx) { 
         Y_ENSURE_EX(node.ChildrenSize() == 0, TNodeException(node) << "Parameters expects 0 args.");
 
         auto structType = ctx.MakeType<TStructExprType>(TVector<const TItemExprType*>());
 
         node.SetTypeAnn(structType);
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
-    IGraphTransformer::TStatus AsParametersWrapper(TExprNode& node, TExprContext& ctx) {
+    IGraphTransformer::TStatus AsParametersWrapper(TExprNode& node, TExprContext& ctx) { 
         Y_ENSURE_EX(node.ChildrenSize() > 0, TNodeException(node) << "AsParameters expects > 0 args.");
 
-        // Use AsStruct type annotation
+        // Use AsStruct type annotation 
         auto tmpNode = ctx.RenameNode(node, "AsStruct");
         auto output = tmpNode;
         YQL_ENSURE(CallableTransformer->Transform(tmpNode, output, ctx) == TStatus::Ok);
-
+ 
         node.SetTypeAnn(tmpNode->GetTypeAnn());
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
-    IGraphTransformer::TStatus AddParameterWrapper(TExprNode& node, TExprContext& ctx) {
+    IGraphTransformer::TStatus AddParameterWrapper(TExprNode& node, TExprContext& ctx) { 
         Y_ENSURE_EX(node.ChildrenSize() == 3, TNodeException(node) << "AddParameter expects 3 args.");
 
-        // Use AddMember type annotation
+        // Use AddMember type annotation 
         auto tmpNode = ctx.RenameNode(node, "AddMember");
         auto output = tmpNode;
         YQL_ENSURE(CallableTransformer->Transform(tmpNode, output, ctx) == TStatus::Ok);
 
         node.SetTypeAnn(tmpNode->GetTypeAnn());
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
     IGraphTransformer::TStatus MapParameterWrapper(TExprNode& node, TExprContext& ctx) {
         Y_ENSURE_EX(node.ChildrenSize() == 2, TNodeException(node) << "MapParameter expects 2 args.");
@@ -739,18 +739,18 @@ private:
         return TStatus::Ok;
     }
 
-    IGraphTransformer::TStatus AcquireLocksWrapper(TExprNode& node, TExprContext& ctx) {
-        if (!EnsureArgsCount(node, 1, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
+    IGraphTransformer::TStatus AcquireLocksWrapper(TExprNode& node, TExprContext& ctx) { 
+        if (!EnsureArgsCount(node, 1, ctx)) { 
+            return IGraphTransformer::TStatus::Error; 
+        } 
         if (!EnsureSpecificDataType(*node.Child(0), EDataSlot::Uint64, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         node.SetTypeAnn(ctx.MakeType<TVoidExprType>());
-        return TStatus::Ok;
-    }
-
+        return TStatus::Ok; 
+    } 
+ 
     IGraphTransformer::TStatus DiagnosticsWrapper(TExprNode& node, TExprContext& ctx) {
         if (!EnsureArgsCount(node, 0, ctx)) {
             return IGraphTransformer::TStatus::Error;
@@ -760,22 +760,22 @@ private:
         return TStatus::Ok;
     }
 
-    IGraphTransformer::TStatus DataConstructorWrapper(TExprNode& node, TExprContext& ctx) {
-        Y_UNUSED(ctx);
+    IGraphTransformer::TStatus DataConstructorWrapper(TExprNode& node, TExprContext& ctx) { 
+        Y_UNUSED(ctx); 
 
         if (node.Content() == "ByteString") {
             node.SetTypeAnn(ctx.MakeType<TDataExprType>(EDataSlot::String));
         } else if (node.Content() == "Utf8String") {
             node.SetTypeAnn(ctx.MakeType<TDataExprType>(EDataSlot::Utf8));
-        } else {
+        } else { 
             node.SetTypeAnn(ctx.MakeType<TDataExprType>(NKikimr::NUdf::GetDataSlot(node.Content())));
-        }
+        } 
 
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
-    IGraphTransformer::TStatus DataTypeWrapper(TExprNode& node, TExprContext& ctx)
-    {
+    IGraphTransformer::TStatus DataTypeWrapper(TExprNode& node, TExprContext& ctx) 
+    { 
         switch (node.ChildrenSize()) {
         case 1:
             node.SetTypeAnn(ctx.MakeType<TTypeExprType>(ctx.MakeType<TDataExprType>(NKikimr::NUdf::GetDataSlot(
@@ -788,47 +788,47 @@ private:
         default:
             return TStatus::Error;
         }
-        return TStatus::Ok;
-    }
+        return TStatus::Ok; 
+    } 
 
-private:
-    TContext::TPtr MkqlCtx;
-    TAutoPtr<IGraphTransformer> CallableTransformer;
-};
+private: 
+    TContext::TPtr MkqlCtx; 
+    TAutoPtr<IGraphTransformer> CallableTransformer; 
+}; 
 
 bool PerformTypeAnnotation(TExprNode::TPtr& exprRoot, TExprContext& ctx, TContext::TPtr mkqlContext) {
     TTypeAnnotationContext types;
-    types.DeprecatedSQL = true;
-
+    types.DeprecatedSQL = true; 
+ 
     TAutoPtr<IGraphTransformer> callableTransformer = CreateExtCallableTypeAnnotationTransformer(types);
     types.TimeProvider = CreateDefaultTimeProvider();
     types.RandomProvider = CreateDefaultRandomProvider();
 
-    TAutoPtr<IGraphTransformer> kikimrTransformer = new TKikimrCallableTypeAnnotationTransformer(
-        mkqlContext, callableTransformer);
+    TAutoPtr<IGraphTransformer> kikimrTransformer = new TKikimrCallableTypeAnnotationTransformer( 
+        mkqlContext, callableTransformer); 
 
     auto typeTransformer = CreateTypeAnnotationTransformer(kikimrTransformer, types);
 
-    return InstantTransform(*typeTransformer, exprRoot, ctx) == IGraphTransformer::TStatus::Ok;
-}
+    return InstantTransform(*typeTransformer, exprRoot, ctx) == IGraphTransformer::TStatus::Ok; 
+} 
 
 TRuntimeNode GetReadTargetNode(const TExprNode& callable, ui32 index, TMkqlBuildContext& ctx,
-    TContext::TPtr mkqlContext)
-{
-    TReadTarget readTarget;
-
+    TContext::TPtr mkqlContext) 
+{ 
+    TReadTarget readTarget; 
+ 
     if (callable.ChildrenSize() > index) {
         const auto child = callable.Child(index);
-        if (child->IsAtom()) {
+        if (child->IsAtom()) { 
             readTarget = GetReadTarget(child);
-        } else {
+        } else { 
             return MkqlBuildExpr(*child, ctx);
-        }
-    }
-
-    return mkqlContext->PgmBuilder->ReadTarget(readTarget);
-}
-
+        } 
+    } 
+ 
+    return mkqlContext->PgmBuilder->ReadTarget(readTarget); 
+} 
+ 
 void FillColumnsToRead(IDbSchemeResolver::TTableResult* lookup, TExprNode* selectTuple, TVector<TSelectColumn>& columnsToRead) {
     for (ui32 i = 0; i < selectTuple->ChildrenSize(); ++i) {
         auto columnName = selectTuple->Child(i)->Content();
@@ -848,7 +848,7 @@ void ValidateCompiledTable(const TExprNode& node, const TTableId& tableId) {
     auto programVersion = node.Child(0)->Child(1)->Content();
 
     if (programVersion && programVersion != "0" && programVersion != currentVersion) {
-        throw TErrorException(TIssuesIds::KIKIMR_SCHEME_MISMATCH)
+        throw TErrorException(TIssuesIds::KIKIMR_SCHEME_MISMATCH) 
             << " Schema version missmatch, compiled over: " << programVersion
             << " current: " << currentVersion
             << " for table: " << TString(node.Child(0)->Child(0)->Content());
@@ -889,19 +889,19 @@ static void FillKeyPosition(TVector<bool>& arr, const TExprNode::TPtr& listNode,
     }
 }
 
-TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr mkqlContext) {
-    auto compiler = MakeIntrusive<NCommon::TMkqlCommonCallableCompiler>();
+TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr mkqlContext) { 
+    auto compiler = MakeIntrusive<NCommon::TMkqlCommonCallableCompiler>(); 
 
-    compiler->AddCallable("SetResult",
+    compiler->AddCallable("SetResult", 
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
             auto label = node.Child(0)->Content();
             auto payload = MkqlBuildExpr(*node.Child(1), ctx);
             TRuntimeNode result = mkqlContext->PgmBuilder->SetResult(label, payload);
 
             return result;
-        });
+        }); 
 
-    compiler->AddCallable("SelectRow",
+    compiler->AddCallable("SelectRow", 
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
             YQL_ENSURE(node.Child(0)->IsList() || HasUnversionedTable(node), "expected list or atom as table");
             const auto lookup = GetTableLookup(mkqlContext, node);
@@ -919,24 +919,24 @@ TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr
             TVector<ui32> keyTypes(rowTuple->ChildrenSize());
             for (ui32 i = 0; i < rowTuple->ChildrenSize(); ++i) {
                 auto columnName = rowTuple->Child(i)->Child(0)->Content();
-                auto column = lookup->Columns.FindPtr(columnName);
+                auto column = lookup->Columns.FindPtr(columnName); 
                 YQL_ENSURE(column);
                 auto keyValue = MkqlBuildExpr(*rowTuple->Child(i)->Child(1), ctx);
-                row[i] = keyValue;
-                keyTypes[i] = column->Type;
-            }
+                row[i] = keyValue; 
+                keyTypes[i] = column->Type; 
+            } 
 
             TVector<TSelectColumn> columnsToRead;
             FillColumnsToRead(lookup, node.Child(2), columnsToRead);
 
-            auto readTargetNode = GetReadTargetNode(node, 3, ctx, mkqlContext);
+            auto readTargetNode = GetReadTargetNode(node, 3, ctx, mkqlContext); 
 
-            auto result = mkqlContext->PgmBuilder->SelectRow(*lookup->TableId, keyTypes, columnsToRead, row,
-                readTargetNode);
+            auto result = mkqlContext->PgmBuilder->SelectRow(*lookup->TableId, keyTypes, columnsToRead, row, 
+                readTargetNode); 
             return result;
-        });
+        }); 
 
-    compiler->AddCallable("SelectRange",
+    compiler->AddCallable("SelectRange", 
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
             YQL_ENSURE(node.Child(0)->IsList() || HasUnversionedTable(node), "expected list or atom as table");
             const auto lookup = GetTableLookup(mkqlContext, node);
@@ -949,88 +949,88 @@ TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr
                 lookup->TableId->SchemaVersion = 0;
             }
 
-            bool includeFrom = true;
-            bool includeTo = true;
+            bool includeFrom = true; 
+            bool includeTo = true; 
             auto rangeTuple = node.Child(1);
-            ui32 keyCount = 0;
-            ui32 fromComponents = 0;
-            ui32 toComponents = 0;
+            ui32 keyCount = 0; 
+            ui32 fromComponents = 0; 
+            ui32 toComponents = 0; 
             for (auto rangeItem : rangeTuple->Children()) {
-                if (rangeItem->IsAtom()) {
+                if (rangeItem->IsAtom()) { 
                     if (rangeItem->Content() == "IncFrom") {
-                        includeFrom = true;
-                    }
+                        includeFrom = true; 
+                    } 
                     else if (rangeItem->Content() == "ExcFrom") {
-                        includeFrom = false;
-                    }
+                        includeFrom = false; 
+                    } 
                     else if (rangeItem->Content() == "IncTo") {
-                        includeTo = true;
-                    }
+                        includeTo = true; 
+                    } 
                     else if (rangeItem->Content() == "ExcTo") {
-                        includeTo = false;
-                    }
-                    else {
-                        YQL_ENSURE(false, "Unexpected SelectRange range bound");
-                    }
+                        includeTo = false; 
+                    } 
+                    else { 
+                        YQL_ENSURE(false, "Unexpected SelectRange range bound"); 
+                    } 
 
-                    continue;
-                }
+                    continue; 
+                } 
 
-                ++keyCount;
+                ++keyCount; 
                 if (!rangeItem->Child(1)->IsCallable("Void")) {
-                    ++fromComponents;
-                }
+                    ++fromComponents; 
+                } 
 
                 if (!rangeItem->Child(2)->IsCallable("Void")) {
-                    ++toComponents;
-                }
-            }
+                    ++toComponents; 
+                } 
+            } 
 
             TTableRangeOptions options = mkqlContext->PgmBuilder->GetDefaultTableRangeOptions();
             TVector<ui32> keyTypes(Max(fromComponents, toComponents));
             TVector<TRuntimeNode> from(fromComponents);
             TVector<TRuntimeNode> to(toComponents);
-            ui32 keyIndex = 0;
+            ui32 keyIndex = 0; 
             for (auto rangeItem : rangeTuple->Children()) {
-                if (rangeItem->IsAtom()) {
-                    continue;
-                }
-
-                if (keyIndex >= fromComponents && keyIndex >= toComponents) {
-                    break;
-                }
-
+                if (rangeItem->IsAtom()) { 
+                    continue; 
+                } 
+
+                if (keyIndex >= fromComponents && keyIndex >= toComponents) { 
+                    break; 
+                } 
+ 
                 auto columnName = rangeItem->Child(0)->Content();
-                auto column = lookup->Columns.FindPtr(columnName);
+                auto column = lookup->Columns.FindPtr(columnName); 
                 YQL_ENSURE(column);
 
-                if (keyIndex < fromComponents) {
+                if (keyIndex < fromComponents) { 
                     auto fromKeyValue = MkqlBuildExpr(*rangeItem->Child(1), ctx);
-                    from[keyIndex] = fromKeyValue;
-                }
+                    from[keyIndex] = fromKeyValue; 
+                } 
 
-                if (keyIndex < toComponents) {
+                if (keyIndex < toComponents) { 
                     auto toKeyValue = MkqlBuildExpr(*rangeItem->Child(2), ctx);
-                    to[keyIndex] = toKeyValue;
-                }
+                    to[keyIndex] = toKeyValue; 
+                } 
 
-                keyTypes[keyIndex] = column->Type;
-                ++keyIndex;
-            }
+                keyTypes[keyIndex] = column->Type; 
+                ++keyIndex; 
+            } 
 
-            const ui32 flags = (includeFrom ? TReadRangeOptions::TFlags::IncludeInitValue : TReadRangeOptions::TFlags::ExcludeInitValue) |
-                (includeTo ? TReadRangeOptions::TFlags::IncludeTermValue : TReadRangeOptions::TFlags::ExcludeTermValue);
+            const ui32 flags = (includeFrom ? TReadRangeOptions::TFlags::IncludeInitValue : TReadRangeOptions::TFlags::ExcludeInitValue) | 
+                (includeTo ? TReadRangeOptions::TFlags::IncludeTermValue : TReadRangeOptions::TFlags::ExcludeTermValue); 
             options.Flags = ctx.ProgramBuilder.NewDataLiteral(flags);
-            options.FromColumns = from;
-            options.ToColumns = to;
+            options.FromColumns = from; 
+            options.ToColumns = to; 
 
-            TVector<bool> skipNullKeys(lookup->KeyColumnCount, false);
-            options.SkipNullKeys = skipNullKeys;
+            TVector<bool> skipNullKeys(lookup->KeyColumnCount, false); 
+            options.SkipNullKeys = skipNullKeys; 
             TVector<bool> forbidNullArgsFrom(lookup->KeyColumnCount, false);
             options.ForbidNullArgsFrom = forbidNullArgsFrom;
             TVector<bool> forbidNullArgsTo(lookup->KeyColumnCount, false);
             options.ForbidNullArgsTo = forbidNullArgsTo;
-
+ 
             TVector<TSelectColumn> columnsToRead;
             FillColumnsToRead(lookup, node.Child(2), columnsToRead);
 
@@ -1040,7 +1040,7 @@ TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr
                     options.ItemsLimit = MkqlBuildExpr(*optionsItem->Child(1), ctx);
                 } else if (optionsItem->Child(0)->Content() == "BytesLimit") {
                     options.BytesLimit = MkqlBuildExpr(*optionsItem->Child(1), ctx);
-                } else if (optionsItem->Child(0)->Content() == "SkipNullKeys") {
+                } else if (optionsItem->Child(0)->Content() == "SkipNullKeys") { 
                     FillKeyPosition(skipNullKeys, optionsItem->Child(1), lookup);
                 } else if (optionsItem->Child(0)->Content() == "ForbidNullArgsFrom") {
                     FillKeyPosition(forbidNullArgsFrom, optionsItem->Child(1), lookup);
@@ -1050,17 +1050,17 @@ TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr
                     options.Reverse = MkqlBuildExpr(*optionsItem->Child(1), ctx);
                 } else {
                     YQL_ENSURE(false, "Unexpected SelectRange option.");
-                }
-            }
+                } 
+            } 
 
-            auto readTargetNode = GetReadTargetNode(node, 4, ctx, mkqlContext);
+            auto readTargetNode = GetReadTargetNode(node, 4, ctx, mkqlContext); 
 
             TRuntimeNode result = mkqlContext->PgmBuilder->SelectRange(*lookup->TableId, keyTypes, columnsToRead,
-                options, readTargetNode);
+                options, readTargetNode); 
             return result;
-        });
+        }); 
 
-    compiler->AddCallable("UpdateRow",
+    compiler->AddCallable("UpdateRow", 
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
             YQL_ENSURE(node.Child(0)->IsList() || HasUnversionedTable(node), "expected list or atom as table");
             const auto lookup = GetTableLookup(mkqlContext, node);
@@ -1078,40 +1078,40 @@ TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr
             TVector<ui32> keyTypes(rowTuple->ChildrenSize());
             for (ui32 i = 0; i < rowTuple->ChildrenSize(); ++i) {
                 auto columnName = rowTuple->Child(i)->Child(0)->Content();
-                auto column = lookup->Columns.FindPtr(columnName);
+                auto column = lookup->Columns.FindPtr(columnName); 
                 YQL_ENSURE(column);
                 auto keyValue = MkqlBuildExpr(*rowTuple->Child(i)->Child(1), ctx);
-                row[i] = keyValue;
-                keyTypes[i] = column->Type;
-            }
+                row[i] = keyValue; 
+                keyTypes[i] = column->Type; 
+            } 
 
             auto update = mkqlContext->PgmBuilder->GetUpdateRowBuilder();
             auto updateTuple = node.Child(2);
             for (ui32 i = 0; i < updateTuple->ChildrenSize(); ++i) {
                 auto child = updateTuple->Child(i);
                 auto columnName = child->Child(0)->Content();
-                auto column = lookup->Columns.FindPtr(columnName);
+                auto column = lookup->Columns.FindPtr(columnName); 
                 YQL_ENSURE(column);
 
                 if (child->ChildrenSize() == 1) {
-                    update.EraseColumn(column->Column);
-                }
+                    update.EraseColumn(column->Column); 
+                } 
                 else if (child->ChildrenSize() == 2) {
                     auto setValue = MkqlBuildExpr(*updateTuple->Child(i)->Child(1), ctx);
-                    update.SetColumn(column->Column, column->Type, setValue);
-                } else {
+                    update.SetColumn(column->Column, column->Type, setValue); 
+                } else { 
                     auto modeStr = child->Child(1)->Content();
-                    EInplaceUpdateMode mode = ParseUpdateMode(modeStr);
+                    EInplaceUpdateMode mode = ParseUpdateMode(modeStr); 
                     auto mergeValue = MkqlBuildExpr(*updateTuple->Child(i)->Child(2), ctx);
-                    update.InplaceUpdateColumn(column->Column, column->Type, mergeValue, mode);
-                }
-            }
+                    update.InplaceUpdateColumn(column->Column, column->Type, mergeValue, mode); 
+                } 
+            } 
 
             TRuntimeNode result = mkqlContext->PgmBuilder->UpdateRow(*lookup->TableId, keyTypes, row, update);
             return result;
-        });
+        }); 
 
-    compiler->AddCallable("EraseRow",
+    compiler->AddCallable("EraseRow", 
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
             YQL_ENSURE(node.Child(0)->IsList() || HasUnversionedTable(node), "expected list or atom as table");
             const auto lookup = GetTableLookup(mkqlContext, node);
@@ -1129,70 +1129,70 @@ TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr
             TVector<ui32> keyTypes(rowTuple->ChildrenSize());
             for (ui32 i = 0; i < rowTuple->ChildrenSize(); ++i) {
                 auto columnName = rowTuple->Child(i)->Child(0)->Content();
-                auto column = lookup->Columns.FindPtr(columnName);
+                auto column = lookup->Columns.FindPtr(columnName); 
                 YQL_ENSURE(column);
                 auto keyValue = MkqlBuildExpr(*rowTuple->Child(i)->Child(1), ctx);
-                row[i] = keyValue;
-                keyTypes[i] = column->Type;
-            }
+                row[i] = keyValue; 
+                keyTypes[i] = column->Type; 
+            } 
 
             TRuntimeNode result = mkqlContext->PgmBuilder->EraseRow(*lookup->TableId, keyTypes, row);
             return result;
-        });
+        }); 
 
     compiler->AddCallable("Increment", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         auto arg = MkqlBuildExpr(*node.Child(0), ctx);
 
         return ctx.ProgramBuilder.Increment(arg);
-    });
+    }); 
 
     compiler->AddCallable("StepTxId", [mkqlContext](const TExprNode&, TMkqlBuildContext&) {
         return mkqlContext->PgmBuilder->StepTxId();
-    });
+    }); 
 
     compiler->OverrideCallable("Parameter", [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto& name = node.Child(0)->Content();
         const auto type = BuildType(*node.Child(1), *node.Child(1)->GetTypeAnn()->Cast<TTypeExprType>()->GetType(), ctx.ProgramBuilder);
-        return mkqlContext->NewParam(name, type);
-    });
+        return mkqlContext->NewParam(name, type); 
+    }); 
 
     compiler->AddCallable("Parameters", [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
-        Y_UNUSED(ctx);
+        Y_UNUSED(ctx); 
 
-        if (!mkqlContext->NewParamsBuilder()) {
+        if (!mkqlContext->NewParamsBuilder()) { 
             throw TNodeException(node) << "You can create only one Parameters object.";
-        }
+        } 
 
-        return TRuntimeNode();
-    });
+        return TRuntimeNode(); 
+    }); 
 
     compiler->AddCallable("AsParameters", [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
-        if (!mkqlContext->NewParamsBuilder()) {
+        if (!mkqlContext->NewParamsBuilder()) { 
             throw TNodeException(node) << "You can create only one Parameters object.";
-        }
+        } 
         for (auto child : node.Children()) {
             const auto& name = child->Child(0)->Content();
             auto value = MkqlBuildExpr(*child->Child(1), ctx);
-            mkqlContext->ParamsBuilder->Add(name, value);
-        }
+            mkqlContext->ParamsBuilder->Add(name, value); 
+        } 
 
-        return mkqlContext->ParamsBuilder->Build();
-    });
+        return mkqlContext->ParamsBuilder->Build(); 
+    }); 
 
     compiler->AddCallable("AddParameter", [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
-        if (!mkqlContext->NewParamsBuilder()) {
+        if (!mkqlContext->NewParamsBuilder()) { 
             throw TNodeException(node) << "You can create only one Parameters object.";
-        }
+        } 
 
         for (auto curNode = &node; curNode->Content() != "Parameters"; curNode = curNode->Child(0)) {
             Y_ENSURE_EX(curNode->Content() == "AddParameter", TNodeException(*curNode) << "Only AddParameter func can be in AddParameter func.");
             const auto& name = curNode->Child(1)->Content();
             auto value = MkqlBuildExpr(*curNode->Child(2), ctx);
-            mkqlContext->ParamsBuilder->Add(name, value);
-        }
+            mkqlContext->ParamsBuilder->Add(name, value); 
+        } 
 
-        return mkqlContext->ParamsBuilder->Build();
-    });
+        return mkqlContext->ParamsBuilder->Build(); 
+    }); 
 
     compiler->AddCallable("MapParameter",
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
@@ -1220,18 +1220,18 @@ TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr
         });
     });
 
-    compiler->AddCallable("AcquireLocks",
+    compiler->AddCallable("AcquireLocks", 
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
         auto lockTxId = MkqlBuildExpr(*node.Child(0), ctx);
         return mkqlContext->PgmBuilder->AcquireLocks(lockTxId);
-    });
-
+    }); 
+ 
     compiler->AddCallable("Diagnostics",
         [mkqlContext](const TExprNode&, TMkqlBuildContext&) {
         return mkqlContext->PgmBuilder->Diagnostics();
     });
 
-    compiler->AddCallable("PartialSort",
+    compiler->AddCallable("PartialSort", 
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
         auto list = MkqlBuildExpr(*node.Child(0), ctx);
         auto ascending = MkqlBuildExpr(*node.Child(1), ctx);
@@ -1241,32 +1241,32 @@ TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr
             innerArguments[argItem] = item;
             TMkqlBuildContext innerCtx(ctx, std::move(innerArguments), node.Child(2)->UniqueId());
             auto res = MkqlBuildExpr(*node.Child(2)->Child(1), innerCtx);
-            return res;
+            return res; 
         });
-    });
-
-    compiler->AddCallable("PartialTake",
+    }); 
+ 
+    compiler->AddCallable("PartialTake", 
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
         auto list = MkqlBuildExpr(*node.Child(0), ctx);
         auto len = MkqlBuildExpr(*node.Child(1), ctx);
         return mkqlContext->PgmBuilder->PartialTake(list, len);
-    });
-
-    compiler->OverrideCallable("CombineByKey",
+    }); 
+ 
+    compiler->OverrideCallable("CombineByKey", 
         [mkqlContext](const TExprNode& node, TMkqlBuildContext& ctx) {
-        auto combineByKey = CombineByKeyImpl(node, ctx);
-        auto merge = mkqlContext->PgmBuilder->CombineByKeyMerge(combineByKey);
-        return merge;
-    });
-
-    // TODO: Remove override once we support custom types in YQL type annotaion.
+        auto combineByKey = CombineByKeyImpl(node, ctx); 
+        auto merge = mkqlContext->PgmBuilder->CombineByKeyMerge(combineByKey); 
+        return merge; 
+    }); 
+ 
+    // TODO: Remove override once we support custom types in YQL type annotaion. 
     compiler->OverrideCallable("DataType", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         auto typeName = node.Child(0)->Content();
         typeName = AdaptLegacyYqlType(typeName);
         auto slot = NKikimr::NUdf::FindDataSlot(typeName);
         if (!slot) {
             throw TNodeException(node) << "Unknown type '" << typeName << "'.";
-        }
+        } 
 
         NUdf::TDataTypeId typeId = NKikimr::NUdf::GetDataTypeInfo(*slot).TypeId;
         if (typeId == NUdf::TDataType<NUdf::TDecimal>::Id) {
@@ -1278,18 +1278,18 @@ TIntrusivePtr<NCommon::IMkqlCallableCompiler> CreateMkqlCompiler(TContext::TPtr
             auto type = ctx.ProgramBuilder.NewDataType(typeId);
             return TRuntimeNode(type, true);
         }
-    });
+    }); 
 
-    return compiler;
-}
+    return compiler; 
+} 
 
 TRuntimeNode CompileNode(const TExprNode& node, TExprContext& exprCtx, TContext::TPtr ctx, const IMkqlCallableCompiler* compiler) {
     const auto guard = ctx->TypeEnv->BindAllocator();
     TMkqlBuildContext mkqlCtx(*compiler, *ctx->PgmBuilder, exprCtx);
     return MkqlBuildExpr(node, mkqlCtx);
-}
-
-} // anonymous namespace
+} 
+ 
+} // anonymous namespace 
 
 void CollectKeys(const TExprNode* root, TContext::TPtr ctx) {
     TStack<const TExprNode*> activeNodes;
@@ -1336,7 +1336,7 @@ ConvertToMiniKQL(TExprContainer::TPtr expr,
 
     try {
         TContext::TPtr ctx(new TContext(functionRegistry, typeEnv));
-        auto compiler = CreateMkqlCompiler(ctx);
+        auto compiler = CreateMkqlCompiler(ctx); 
         CollectKeys(expr->Root.Get(), ctx);
         const auto& tablesToResolve = ctx->GetTablesToResolve();
         if (!tablesToResolve.empty()) {
@@ -1345,9 +1345,9 @@ ConvertToMiniKQL(TExprContainer::TPtr expr,
             for (const auto& x : tablesToResolve) {
                 requests.push_back(x.second.Request);
             }
-            Y_VERIFY_DEBUG(dbSchemeResolver);
+            Y_VERIFY_DEBUG(dbSchemeResolver); 
             dbSchemeResolver->ResolveTables(requests).Subscribe(
-                [ctx, promise, expr, compiler](const TFuture<IDbSchemeResolver::TTableResults>& future) mutable {
+                [ctx, promise, expr, compiler](const TFuture<IDbSchemeResolver::TTableResults>& future) mutable { 
                 try {
                     const auto& results = future.GetValue();
                     auto& tablesToResolve = ctx->GetTablesToResolve();
@@ -1356,19 +1356,19 @@ ConvertToMiniKQL(TExprContainer::TPtr expr,
                     for (auto& x : tablesToResolve) {
                         const auto& response = results[i];
                         Y_ENSURE_EX(response.Status == IDbSchemeResolver::TTableResult::Ok,
-                            TNodeException() << "Failed to resolve table " << x.second.Request.TableName
+                            TNodeException() << "Failed to resolve table " << x.second.Request.TableName 
                             << ", error: " << response.Reason);
                         x.second.Response = response;
                         ++i;
                     }
 
-                    if (!PerformTypeAnnotation(expr->Root, expr->Context, ctx)) {
-                        TConvertResult convRes;
-                        convRes.Errors.AddIssues(expr->Context.IssueManager.GetIssues());
-                        promise.SetValue(convRes);
+                    if (!PerformTypeAnnotation(expr->Root, expr->Context, ctx)) { 
+                        TConvertResult convRes; 
+                        convRes.Errors.AddIssues(expr->Context.IssueManager.GetIssues()); 
+                        promise.SetValue(convRes); 
                         return;
-                    }
-
+                    } 
+ 
                     TRuntimeNode convertedNode = CompileNode(*expr->Root, expr->Context, ctx, compiler.Get());
                     TConvertResult convRes = ctx->Finish(convertedNode);
                     promise.SetValue(convRes);
@@ -1388,13 +1388,13 @@ ConvertToMiniKQL(TExprContainer::TPtr expr,
             });
         }
         else {
-            if (!PerformTypeAnnotation(expr->Root, expr->Context, ctx)) {
-                TConvertResult convRes;
-                convRes.Errors.AddIssues(expr->Context.IssueManager.GetIssues());
-                promise.SetValue(convRes);
+            if (!PerformTypeAnnotation(expr->Root, expr->Context, ctx)) { 
+                TConvertResult convRes; 
+                convRes.Errors.AddIssues(expr->Context.IssueManager.GetIssues()); 
+                promise.SetValue(convRes); 
                 return promise.GetFuture();
-            }
-
+            } 
+ 
             TRuntimeNode convertedNode = CompileNode(*expr->Root, expr->Context, ctx, compiler.Get());
             TConvertResult convRes = ctx->Finish(convertedNode);
             promise.SetValue(convRes);
@@ -1449,10 +1449,10 @@ public:
             if (!ParseProgram(result.Errors)) {
                 return SendResponseAndDie(result, {}, ctx);
             }
-
+ 
             CollectKeys(Expr->Root.Get(), CompileCtx);
-
-            Compiler = CreateMkqlCompiler(CompileCtx);
+ 
+            Compiler = CreateMkqlCompiler(CompileCtx); 
             const auto& tablesToResolve = CompileCtx->GetTablesToResolve();
             if (!tablesToResolve.empty()) {
                 TVector<IDbSchemeResolver::TTable> requests;
@@ -1464,11 +1464,11 @@ public:
                 DbSchemeResolver->ResolveTables(requests, ctx.SelfID);
                 Become(&TThis::StateCompileProgram);
             } else {
-                if (!PerformTypeAnnotation(Expr->Root, Expr->Context, CompileCtx)) {
-                    result.Errors.AddIssues(Expr->Context.IssueManager.GetIssues());
+                if (!PerformTypeAnnotation(Expr->Root, Expr->Context, CompileCtx)) { 
+                    result.Errors.AddIssues(Expr->Context.IssueManager.GetIssues()); 
                     return SendResponseAndDie(result, {}, ctx);
-                }
-
+                } 
+ 
                 result.CompiledProgram = CompileProgram();
                 return SendResponseAndDie(result, {}, ctx);
             }
@@ -1500,50 +1500,50 @@ private:
             auto& tablesToResolve = CompileCtx->GetTablesToResolve();
             Y_VERIFY_DEBUG(tablesToResolve.size() == results.size(), "tablesToResolve.size() != results.size()");
 
-            TVector<NYql::TIssue> resolveErrors;
+            TVector<NYql::TIssue> resolveErrors; 
             ui32 i = 0;
             for (auto &xpair : tablesToResolve) {
                 auto &x = xpair.second;
                 auto &response = results[i];
 
-                switch (response.Status) {
-                    case IDbSchemeResolver::TTableResult::Ok:
-                        break;
-
-                    case IDbSchemeResolver::TTableResult::LookupError:
-                        resolveErrors.push_back(
-                            NYql::TIssue(TPosition(), TStringBuilder()
-                                << "Lookup failed for table: " << x.Request.TableName
-                                << ", error: " << response.Reason)
-                            .SetCode(NKikimrIssues::TIssuesIds::RESOLVE_LOOKUP_ERROR, TSeverityIds::S_ERROR));
-                        break;
-
-                    default:
-                        resolveErrors.push_back(
-                            NYql::TIssue(TPosition(), TStringBuilder()
-                                << "Resolve failed for table: " << x.Request.TableName
-                                << ", error: " << response.Reason)
-                            .SetCode(NKikimrIssues::TIssuesIds::GENERIC_RESOLVE_ERROR, TSeverityIds::S_ERROR));
-                        break;
-                }
-
+                switch (response.Status) { 
+                    case IDbSchemeResolver::TTableResult::Ok: 
+                        break; 
+
+                    case IDbSchemeResolver::TTableResult::LookupError: 
+                        resolveErrors.push_back( 
+                            NYql::TIssue(TPosition(), TStringBuilder() 
+                                << "Lookup failed for table: " << x.Request.TableName 
+                                << ", error: " << response.Reason) 
+                            .SetCode(NKikimrIssues::TIssuesIds::RESOLVE_LOOKUP_ERROR, TSeverityIds::S_ERROR)); 
+                        break; 
+ 
+                    default: 
+                        resolveErrors.push_back( 
+                            NYql::TIssue(TPosition(), TStringBuilder() 
+                                << "Resolve failed for table: " << x.Request.TableName 
+                                << ", error: " << response.Reason) 
+                            .SetCode(NKikimrIssues::TIssuesIds::GENERIC_RESOLVE_ERROR, TSeverityIds::S_ERROR)); 
+                        break; 
+                } 
+ 
                 compileResolveCookies[x.Request.TableName] = response.CacheGeneration;
                 x.Response = response;
                 ++i;
             }
 
             if (!resolveErrors.empty()) {
-                TMiniKQLCompileResult result(resolveErrors);
+                TMiniKQLCompileResult result(resolveErrors); 
                 return SendResponseAndDie(result, std::move(compileResolveCookies), ctx);
             }
 
             TMiniKQLCompileResult result;
-
-            if (!PerformTypeAnnotation(Expr->Root, Expr->Context, CompileCtx)) {
-                result.Errors.AddIssues(Expr->Context.IssueManager.GetIssues());
+ 
+            if (!PerformTypeAnnotation(Expr->Root, Expr->Context, CompileCtx)) { 
+                result.Errors.AddIssues(Expr->Context.IssueManager.GetIssues()); 
                 return SendResponseAndDie(result, std::move(compileResolveCookies), ctx);
-            }
-
+            } 
+ 
             result.CompiledProgram = CompileProgram();
             return SendResponseAndDie(result, std::move(compileResolveCookies), ctx);
         }
@@ -1615,7 +1615,7 @@ private:
     IDbSchemeResolver* DbSchemeResolver;
     TActorId ResponseTo;
     TExprContainer::TPtr Expr;
-    TIntrusivePtr<NCommon::IMkqlCallableCompiler> Compiler;
+    TIntrusivePtr<NCommon::IMkqlCallableCompiler> Compiler; 
     THashMap<TString, ui64> ResolveRefreshCookies;
 };
 
diff --git a/ydb/core/client/minikql_compile/yql_expr_minikql_compile_ut.cpp b/ydb/core/client/minikql_compile/yql_expr_minikql_compile_ut.cpp
index 4fcdf735ba..cf1ce8892c 100644
--- a/ydb/core/client/minikql_compile/yql_expr_minikql_compile_ut.cpp
+++ b/ydb/core/client/minikql_compile/yql_expr_minikql_compile_ut.cpp
@@ -45,21 +45,21 @@ namespace {
 
         auto resFuture = ConvertToMiniKQL(expr, services.FunctionRegistry.Get(),
             &services.TypeEnv, &services.DbSchemeResolver);
-        result = resFuture.GetValue(TIME_LIMIT);
-
-        if (!result.Node.GetNode()) {
-            return false;
-        }
-
-        // Cout << PrintNode(result.Node.GetNode()) << Endl;
-
-        return true;
-    }
-
+        result = resFuture.GetValue(TIME_LIMIT); 
+ 
+        if (!result.Node.GetNode()) { 
+            return false; 
+        } 
+ 
+        // Cout << PrintNode(result.Node.GetNode()) << Endl; 
+ 
+        return true; 
+    } 
+ 
     TRuntimeNode ProgramText2Bin(const TString& programText, TServices& services) {
-        TConvertResult res;
-        TryProgramText2Bin(programText, services, res);
-
+        TConvertResult res; 
+        TryProgramText2Bin(programText, services, res); 
+ 
         res.Errors.PrintTo(Cerr);
         UNIT_ASSERT(res.Node.GetNode());
         return res.Node;
@@ -69,7 +69,7 @@ namespace {
         using TColumn = IDbSchemeResolver::TTableResult::TColumn;
         IDbSchemeResolver::TTableResult table(IDbSchemeResolver::TTableResult::Ok);
         table.Table.TableName = "table1";
-        table.Table.ColumnNames = { "key", "value" };
+        table.Table.ColumnNames = { "key", "value" }; 
         table.TableId.Reset(new TTableId(1, 2));
         table.KeyColumnCount = 1;
         table.Columns.insert(std::make_pair("key", TColumn{ 34, 0, NUdf::TDataType<ui32>::Id, 0 }));
@@ -78,7 +78,7 @@ namespace {
 
         IDbSchemeResolver::TTableResult table2(IDbSchemeResolver::TTableResult::Ok);
         table2.Table.TableName = "table2";
-        table2.Table.ColumnNames = { "key", "value" };
+        table2.Table.ColumnNames = { "key", "value" }; 
         table2.TableId.Reset(new TTableId(10, 20));
         table2.KeyColumnCount = 1;
         table2.Columns.insert(std::make_pair("key", TColumn{ 340, 0, NUdf::TDataType<ui32>::Id, 0 }));
@@ -94,7 +94,7 @@ Y_UNIT_TEST_SUITE(TTestYqlToMiniKQLCompile) {
         TVector<IDbSchemeResolver::TTable> tablesToResolve;
         IDbSchemeResolver::TTable tableToResolve;
         tableToResolve.TableName = "table1";
-        tableToResolve.ColumnNames.insert("value");
+        tableToResolve.ColumnNames.insert("value"); 
         tablesToResolve.push_back(tableToResolve);
         auto resolveRes = services.DbSchemeResolver.ResolveTables(tablesToResolve);
         auto res = resolveRes.GetValue(TIME_LIMIT);
@@ -104,9 +104,9 @@ Y_UNIT_TEST_SUITE(TTestYqlToMiniKQLCompile) {
         UNIT_ASSERT(res[0].TableId->HasSamePath(TTableId(1, 2)));
         UNIT_ASSERT_EQUAL(res[0].KeyColumnCount, 1);
         UNIT_ASSERT_VALUES_EQUAL(res[0].Columns.size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(res[0].Columns["value"].Column, 56);
-        UNIT_ASSERT_VALUES_EQUAL(res[0].Columns["value"].KeyPosition, -1);
-        UNIT_ASSERT_VALUES_EQUAL(res[0].Columns["value"].AllowInplaceMode, (ui32)EInplaceUpdateMode::Min);
+        UNIT_ASSERT_VALUES_EQUAL(res[0].Columns["value"].Column, 56); 
+        UNIT_ASSERT_VALUES_EQUAL(res[0].Columns["value"].KeyPosition, -1); 
+        UNIT_ASSERT_VALUES_EQUAL(res[0].Columns["value"].AllowInplaceMode, (ui32)EInplaceUpdateMode::Min); 
         UNIT_ASSERT_VALUES_EQUAL(res[0].Columns["value"].Type, (ui32)NUdf::TDataType<char*>::Id);
     }
 
@@ -255,89 +255,89 @@ Y_UNIT_TEST_SUITE(TTestYqlToMiniKQLCompile) {
         UNIT_ASSERT_VALUES_EQUAL(counters[TKeyDesc::ERowOperation::Read], 1);
         UNIT_ASSERT_VALUES_EQUAL(counters[TKeyDesc::ERowOperation::Update], 1);
     }
-
+ 
     Y_UNIT_TEST(AcquireLocks) {
-        auto programText = R"___(
-(
-(let row '('('key (Uint32 '23))))
-(let select '('value))
-(let pgmReturn (AsList
-    (SetResult 'myRes (Map (SelectRow 'table1 row select) (lambda '(x) (Member x 'value))))
-    (AcquireLocks (Uint64 '0))
-))
-(return pgmReturn)
-)
-)___";
-
-        TServices services;
-        RegisterSampleTables(services);
-        auto pgm = ProgramText2Bin(programText, services);
-        services.ExtractKeys(pgm);
-        UNIT_ASSERT_VALUES_EQUAL(services.DescList.size(), 1);
-        for (ui32 i = 0; i < services.DescList.size(); ++i) {
-            UNIT_ASSERT_EQUAL(services.DescList[i]->RowOperation, TKeyDesc::ERowOperation::Read);
-        }
-    }
-
+        auto programText = R"___( 
+( 
+(let row '('('key (Uint32 '23)))) 
+(let select '('value)) 
+(let pgmReturn (AsList 
+    (SetResult 'myRes (Map (SelectRow 'table1 row select) (lambda '(x) (Member x 'value)))) 
+    (AcquireLocks (Uint64 '0)) 
+)) 
+(return pgmReturn) 
+) 
+)___"; 
+ 
+        TServices services; 
+        RegisterSampleTables(services); 
+        auto pgm = ProgramText2Bin(programText, services); 
+        services.ExtractKeys(pgm); 
+        UNIT_ASSERT_VALUES_EQUAL(services.DescList.size(), 1); 
+        for (ui32 i = 0; i < services.DescList.size(); ++i) { 
+            UNIT_ASSERT_EQUAL(services.DescList[i]->RowOperation, TKeyDesc::ERowOperation::Read); 
+        } 
+    } 
+ 
     Y_UNIT_TEST(StaticMapTypeOf) {
-        auto programText = R"___(
-(
-    (return (AsList
-        (SetResult 'x (StaticMap
-            (AsStruct
-                '('aaa (Just (Uint32 '17)))
+        auto programText = R"___( 
+( 
+    (return (AsList 
+        (SetResult 'x (StaticMap 
+            (AsStruct 
+                '('aaa (Just (Uint32 '17))) 
                 '('bbb (Nothing (OptionalType (DataType 'Utf8))))
-            )
-            (lambda '(field) (block '(
-                (return (Coalesce field (Default (OptionalItemType (TypeOf field)))))
-            )))
-        ))
-    ))
-)
-)___";
-
-        TServices services;
-        RegisterSampleTables(services);
-        auto pgm = ProgramText2Bin(programText, services);
-        services.ExtractKeys(pgm);
-        UNIT_ASSERT_VALUES_EQUAL(services.DescList.size(), 0);
-    }
-
+            ) 
+            (lambda '(field) (block '( 
+                (return (Coalesce field (Default (OptionalItemType (TypeOf field))))) 
+            ))) 
+        )) 
+    )) 
+) 
+)___"; 
+ 
+        TServices services; 
+        RegisterSampleTables(services); 
+        auto pgm = ProgramText2Bin(programText, services); 
+        services.ExtractKeys(pgm); 
+        UNIT_ASSERT_VALUES_EQUAL(services.DescList.size(), 0); 
+    } 
+ 
     Y_UNIT_TEST(SelectRangeAtomInRange) {
-        auto programText = R"___(
-(
-    (let range '('key (Void) 'Void))
-    (let rows (SelectRange 'table1 '(range) '() '()))
-    (return rows)
-)
-)___";
-
-        TServices services;
-        RegisterSampleTables(services);
-        TConvertResult result;
-        UNIT_ASSERT(!TryProgramText2Bin(programText, services, result));
-        UNIT_ASSERT(!result.Errors.Empty());
+        auto programText = R"___( 
+( 
+    (let range '('key (Void) 'Void)) 
+    (let rows (SelectRange 'table1 '(range) '() '())) 
+    (return rows) 
+) 
+)___"; 
+ 
+        TServices services; 
+        RegisterSampleTables(services); 
+        TConvertResult result; 
+        UNIT_ASSERT(!TryProgramText2Bin(programText, services, result)); 
+        UNIT_ASSERT(!result.Errors.Empty()); 
         UNIT_ASSERT_NO_DIFF(result.Errors.begin()->Message, "At function: SelectRange");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(Extract) {
-        auto programText = R"___(
-(
-(let range '('IncFrom 'ExcTo '('key (Uint32 '23) (Void))))
-(let select '('key 'value))
-(let options '('('ItemsLimit (Uint64 '2))))
-(let tupleList (AsList '((Uint32 '1) (Uint32 '2)) '((Uint32 '3) (Uint32 '4))))
-(let pgmReturn (AsList
-    (SetResult 'extractRes (Extract (Member (SelectRange 'table1 range select options) 'List) 'value))
-    (SetResult 'orderedRes (OrderedExtract tupleList '1))
-))
-(return pgmReturn)
-)
-)___";
-
-        TServices services;
-        RegisterSampleTables(services);
-        auto pgm = ProgramText2Bin(programText, services);
-    }
+        auto programText = R"___( 
+( 
+(let range '('IncFrom 'ExcTo '('key (Uint32 '23) (Void)))) 
+(let select '('key 'value)) 
+(let options '('('ItemsLimit (Uint64 '2)))) 
+(let tupleList (AsList '((Uint32 '1) (Uint32 '2)) '((Uint32 '3) (Uint32 '4)))) 
+(let pgmReturn (AsList 
+    (SetResult 'extractRes (Extract (Member (SelectRange 'table1 range select options) 'List) 'value)) 
+    (SetResult 'orderedRes (OrderedExtract tupleList '1)) 
+)) 
+(return pgmReturn) 
+) 
+)___"; 
+ 
+        TServices services; 
+        RegisterSampleTables(services); 
+        auto pgm = ProgramText2Bin(programText, services); 
+    } 
 }
 } // namespace NYql
diff --git a/ydb/core/client/minikql_result_lib/converter_ut.cpp b/ydb/core/client/minikql_result_lib/converter_ut.cpp
index 0fb5eff621..833469b4de 100644
--- a/ydb/core/client/minikql_result_lib/converter_ut.cpp
+++ b/ydb/core/client/minikql_result_lib/converter_ut.cpp
@@ -24,7 +24,7 @@ Y_UNIT_TEST(TTestWithSimpleProgram) {
 (
 (let list (AsList (Uint32 '20) (Uint32 '10) (Uint32 '0)))
 (let opt (Just (String 'i_am_opt)))
-(let tuple '((Double '12) (Float '22)))
+(let tuple '((Double '12) (Float '22))) 
 (return (AsList
     (SetResult 'list list)
     (SetResult 'opt opt)
diff --git a/ydb/core/client/scheme_cache_lib/yql_db_scheme_resolver.cpp b/ydb/core/client/scheme_cache_lib/yql_db_scheme_resolver.cpp
index eb74fa36e9..6aad09b324 100644
--- a/ydb/core/client/scheme_cache_lib/yql_db_scheme_resolver.cpp
+++ b/ydb/core/client/scheme_cache_lib/yql_db_scheme_resolver.cpp
@@ -46,23 +46,23 @@ class TTableProxyActor : public TActorBootstrapped<TTableProxyActor> {
                     reply.TableId = new TTableId(res.TableId);
                     reply.CacheGeneration = 0;
 
-                    TSet<TString> replyColumns;
-
+                    TSet<TString> replyColumns; 
+ 
                     TMap<TString, THashMap<ui32, TSysTables::TTableColumnInfo>::const_iterator> backindex;
                     for (auto it = res.Columns.begin(), eit = res.Columns.end(); it != eit; ++it) {
-                        auto& name = it->second.Name;
-
-                        backindex.insert({name, it});
-
-                        if (it->second.KeyOrder >= 0) {
-                            replyColumns.insert(name);
+                        auto& name = it->second.Name; 
+ 
+                        backindex.insert({name, it}); 
+ 
+                        if (it->second.KeyOrder >= 0) { 
+                            replyColumns.insert(name); 
                             ++reply.KeyColumnCount;
-                        }
+                        } 
                     }
 
-                    replyColumns.insert(reply.Table.ColumnNames.begin(), reply.Table.ColumnNames.end());
-
-                    for (const auto &column : replyColumns) {
+                    replyColumns.insert(reply.Table.ColumnNames.begin(), reply.Table.ColumnNames.end()); 
+ 
+                    for (const auto &column : replyColumns) { 
                         auto systemColumn = GetSystemColumns().find(column);
                         if (systemColumn != GetSystemColumns().end()) {
                             reply.Columns.insert({
diff --git a/ydb/core/client/server/grpc_server.cpp b/ydb/core/client/server/grpc_server.cpp
index aa122da36a..8afe3c35c1 100644
--- a/ydb/core/client/server/grpc_server.cpp
+++ b/ydb/core/client/server/grpc_server.cpp
@@ -74,7 +74,7 @@ public:
         , StateFunc(&TSimpleRequest::RequestDone)
         , RequestSize(0)
         , ResponseSize(0)
-        , ResponseStatus(0)
+        , ResponseStatus(0) 
         , InProgress_(false)
     {
         LOG_DEBUG(ActorSystem, NKikimrServices::GRPC_SERVER, "[%p] created request Name# %s", this, Name);
@@ -86,8 +86,8 @@ public:
             if (!Server->IsShuttingDown()) {
                 LOG_ERROR(ActorSystem, NKikimrServices::GRPC_SERVER, "[%p] request destroyed with InProgress state Name# %s", this, Name);
             }
-            Counters->FinishProcessing(RequestSize, ResponseSize, false, ResponseStatus,
-                TDuration::Seconds(RequestTimer.Passed()));
+            Counters->FinishProcessing(RequestSize, ResponseSize, false, ResponseStatus, 
+                TDuration::Seconds(RequestTimer.Passed())); 
             Server->DecRequest();
         }
     }
@@ -131,7 +131,7 @@ public:
     //! Send reply.
     void Reply(const NKikimrClient::TResponse& resp) override {
         if (const TOut *x = dynamic_cast<const TOut *>(&resp)) {
-            Finish(*x, 0);
+            Finish(*x, 0); 
         } else {
             ReplyError(resp.GetErrorReason());
         }
@@ -139,7 +139,7 @@ public:
 
     void Reply(const NKikimrClient::TBsTestLoadResponse& resp) override {
         if (const TOut *x = dynamic_cast<const TOut *>(&resp)) {
-            Finish(*x, 0);
+            Finish(*x, 0); 
         } else {
             ReplyError("request failed");
         }
@@ -147,7 +147,7 @@ public:
 
     void Reply(const NKikimrClient::TJSON& resp) override {
         try {
-            Finish(dynamic_cast<const TOut&>(resp), 0);
+            Finish(dynamic_cast<const TOut&>(resp), 0); 
         } catch (const std::bad_cast&) {
             Y_FAIL("unexpected response type generated");
         }
@@ -155,7 +155,7 @@ public:
 
     void Reply(const NKikimrClient::TNodeRegistrationResponse& resp) override {
         try {
-            Finish(dynamic_cast<const TOut&>(resp), 0);
+            Finish(dynamic_cast<const TOut&>(resp), 0); 
         } catch (const std::bad_cast&) {
             Y_FAIL("unexpected response type generated");
         }
@@ -163,7 +163,7 @@ public:
 
     void Reply(const NKikimrClient::TCmsResponse& resp) override {
         try {
-            Finish(dynamic_cast<const TOut&>(resp), 0);
+            Finish(dynamic_cast<const TOut&>(resp), 0); 
         } catch (const std::bad_cast&) {
             Y_FAIL("unexpected response type generated");
         }
@@ -171,7 +171,7 @@ public:
 
     void Reply(const NKikimrClient::TSqsResponse& resp) override {
         try {
-            Finish(dynamic_cast<const TOut&>(resp), 0);
+            Finish(dynamic_cast<const TOut&>(resp), 0); 
         } catch (const std::bad_cast&) {
             Y_FAIL("unexpected response type generated");
         }
@@ -179,7 +179,7 @@ public:
 
     void Reply(const NKikimrClient::TS3ListingResponse& resp) override {
         try {
-            Finish(dynamic_cast<const TOut&>(resp), 0);
+            Finish(dynamic_cast<const TOut&>(resp), 0); 
         } catch (const std::bad_cast&) {
             Y_FAIL("unexpected response type generated");
         }
@@ -187,7 +187,7 @@ public:
 
     void Reply(const NKikimrClient::TConsoleResponse& resp) override {
         try {
-            Finish(dynamic_cast<const TOut&>(resp), 0);
+            Finish(dynamic_cast<const TOut&>(resp), 0); 
         } catch (const std::bad_cast&) {
             Y_FAIL("unexpected response type generated");
         }
@@ -197,7 +197,7 @@ public:
     void ReplyError(const TString& reason) override {
         TOut resp;
         GenerateErrorResponse(resp, reason);
-        Finish(resp, 0);
+        Finish(resp, 0); 
     }
 
     static void GenerateErrorResponse(NKikimrClient::TResponse& resp, const TString& reason) {
@@ -232,7 +232,7 @@ public:
     }
 
     static void GenerateErrorResponse(NKikimrClient::TConsoleResponse& resp, const TString& reason) {
-        resp.MutableStatus()->SetCode(Ydb::StatusIds::GENERIC_ERROR);
+        resp.MutableStatus()->SetCode(Ydb::StatusIds::GENERIC_ERROR); 
         resp.MutableStatus()->SetReason(reason);
     }
 
@@ -249,7 +249,7 @@ private:
         return static_cast<IQueueEvent*>(this);
     }
 
-    void Finish(const TOut& resp, ui32 status) {
+    void Finish(const TOut& resp, ui32 status) { 
         auto makeResponseString = [&] {
             TString x;
             google::protobuf::TextFormat::Printer printer;
@@ -260,7 +260,7 @@ private:
         LOG_DEBUG(ActorSystem, NKikimrServices::GRPC_SERVER, "[%p] issuing response Name# %s data# %s peer# %s", this,
             Name, makeResponseString().data(), Context.peer().c_str());
         ResponseSize = resp.ByteSize();
-        ResponseStatus = status;
+        ResponseStatus = status; 
         StateFunc = &TSimpleRequest::FinishDone;
         Writer->Finish(resp, Status::OK, GetGRpcTag());
     }
@@ -328,8 +328,8 @@ private:
     bool FinishDone(bool ok) {
         LOG_DEBUG(ActorSystem, NKikimrServices::GRPC_SERVER, "[%p] finished request Name# %s ok# %s peer# %s", this,
             Name, ok ? "true" : "false", Context.peer().c_str());
-        Counters->FinishProcessing(RequestSize, ResponseSize, ok, ResponseStatus,
-            TDuration::Seconds(RequestTimer.Passed()));
+        Counters->FinishProcessing(RequestSize, ResponseSize, ok, ResponseStatus, 
+            TDuration::Seconds(RequestTimer.Passed())); 
         Server->DecRequest();
         InProgress_ = false;
 
@@ -359,7 +359,7 @@ private:
     TIn Request;
     ui32 RequestSize;
     ui32 ResponseSize;
-    ui32 ResponseStatus;
+    ui32 ResponseStatus; 
     THPTimer RequestTimer;
 
     TMaybe<NMsgBusProxy::TBusMessageContext> BusContext;
@@ -436,7 +436,7 @@ void TGRpcService::SetupIncomingRequests() {
             NGRpcService::ReportGrpcReqToMon(*ActorSystem, ctx->GetPeer()); \
             ACTION; \
         }, &NKikimrClient::TGRpcServer::AsyncService::Request ## NAME, \
-        *ActorSystem, #NAME, getCounterBlock("legacy", #NAME)))->Start();
+        *ActorSystem, #NAME, getCounterBlock("legacy", #NAME)))->Start(); 
 
 #define ADD_ACTOR_REQUEST(NAME, TYPE, MTYPE) \
     ADD_REQUEST(NAME, TYPE, TResponse, { \
diff --git a/ydb/core/client/server/msgbus_server_console.cpp b/ydb/core/client/server/msgbus_server_console.cpp
index 66bc0b02eb..00c54ed1fe 100644
--- a/ydb/core/client/server/msgbus_server_console.cpp
+++ b/ydb/core/client/server/msgbus_server_console.cpp
@@ -192,7 +192,7 @@ public:
     void Handle(TEvConsole::TEvGetConfigResponse::TPtr &ev, const TActorContext &ctx) noexcept
     {
         auto &rec = ev->Get()->Record;
-        Response.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+        Response.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
         Response.MutableGetConfigResponse()->CopyFrom(rec);
         SendReplyAndDie(ctx);
     }
@@ -230,7 +230,7 @@ public:
     void Handle(TEvConsole::TEvListTenantsResponse::TPtr &ev, const TActorContext &ctx) noexcept
     {
         auto &rec = ev->Get()->Record;
-        Response.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+        Response.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
         Response.MutableListTenantsResponse()->CopyFrom(rec);
         SendReplyAndDie(ctx);
     }
@@ -279,7 +279,7 @@ public:
     }
 
     void Undelivered(const TActorContext &ctx) {
-        ReplyWithErrorAndDie(Ydb::StatusIds::UNAVAILABLE, "Console is unavailable", ctx);
+        ReplyWithErrorAndDie(Ydb::StatusIds::UNAVAILABLE, "Console is unavailable", ctx); 
     }
 
     void Handle(TEvTabletPipe::TEvClientConnected::TPtr &ev, const TActorContext &ctx) noexcept
@@ -306,10 +306,10 @@ public:
 
     void ReplyWithErrorAndDie(const TString &error, const TActorContext &ctx)
     {
-        ReplyWithErrorAndDie(Ydb::StatusIds::GENERIC_ERROR, error, ctx);
+        ReplyWithErrorAndDie(Ydb::StatusIds::GENERIC_ERROR, error, ctx); 
     }
 
-    void ReplyWithErrorAndDie(Ydb::StatusIds::StatusCode code, const TString &error,
+    void ReplyWithErrorAndDie(Ydb::StatusIds::StatusCode code, const TString &error, 
                               const TActorContext &ctx)
     {
         Response.MutableStatus()->SetCode(code);
diff --git a/ydb/core/client/server/msgbus_server_request.cpp b/ydb/core/client/server/msgbus_server_request.cpp
index 9223bea9f1..23ae5cf598 100644
--- a/ydb/core/client/server/msgbus_server_request.cpp
+++ b/ydb/core/client/server/msgbus_server_request.cpp
@@ -96,7 +96,7 @@ public:
             if (!mkqlTx.GetFlatMKQL()) {
                 return HandleError(MSTATUS_ERROR, TEvTxUserProxy::TResultStatus::EStatus::NotImplemented, ctx);
             }
-
+ 
             if (mkqlTx.HasProgram() && mkqlTx.GetProgram().HasText()) {
                 TextProgramForCompilation = mkqlTx.GetProgram().GetText();
                 const bool forceRefresh = (mkqlTx.GetMode() == NKikimrTxUserProxy::TMiniKQLTransaction::COMPILE);
@@ -300,8 +300,8 @@ void TMessageBusServerRequest::Handle(TEvTxUserProxy::TEvProposeTransactionStatu
     case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecError:
     case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::AccessDenied:
     case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::DomainLocalityError:
-    case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable:
-    case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecCancelled:
+    case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable: 
+    case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecCancelled: 
     case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::WrongRequest:
         return ReplyWithResult(MSTATUS_ERROR, msg->Record, ctx);
     case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ResolveError:
diff --git a/ydb/core/client/server/msgbus_server_s3_listing.cpp b/ydb/core/client/server/msgbus_server_s3_listing.cpp
index 3626866322..7e27204b6e 100644
--- a/ydb/core/client/server/msgbus_server_s3_listing.cpp
+++ b/ydb/core/client/server/msgbus_server_s3_listing.cpp
@@ -372,19 +372,19 @@ private:
             return ReplyWithError(MSTATUS_ERROR, NTxProxy::TResultStatus::EStatus::AccessDenied, accessCheckError, ctx);
         }
 
-        auto getShardsString = [] (const TVector<TKeyDesc::TPartitionInfo>& partitions) {
-            TVector<ui64> shards;
-            shards.reserve(partitions.size());
-            for (auto& partition : partitions) {
-                shards.push_back(partition.ShardId);
-            }
-
-            return JoinVectorIntoString(shards, ", ");
-        };
-
-        LOG_DEBUG_S(ctx, NKikimrServices::MSGBUS_REQUEST, "Range shards: " << getShardsString(KeyRange->Partitions));
-
-        if (KeyRange->Partitions.size() > 0) {
+        auto getShardsString = [] (const TVector<TKeyDesc::TPartitionInfo>& partitions) { 
+            TVector<ui64> shards; 
+            shards.reserve(partitions.size()); 
+            for (auto& partition : partitions) { 
+                shards.push_back(partition.ShardId); 
+            } 
+
+            return JoinVectorIntoString(shards, ", "); 
+        }; 
+ 
+        LOG_DEBUG_S(ctx, NKikimrServices::MSGBUS_REQUEST, "Range shards: " << getShardsString(KeyRange->Partitions)); 
+ 
+        if (KeyRange->Partitions.size() > 0) { 
             CurrentShardIdx = 0;
             MakeShardRequest(CurrentShardIdx, ctx);
         } else {
@@ -393,7 +393,7 @@ private:
     }
 
     void MakeShardRequest(ui32 idx, const NActors::TActorContext& ctx) {
-        ui64 shardId = KeyRange->Partitions[idx].ShardId;
+        ui64 shardId = KeyRange->Partitions[idx].ShardId; 
 
         THolder<TEvDataShard::TEvS3ListingRequest> ev(new TEvDataShard::TEvS3ListingRequest());
         ev->Record.SetTableId(KeyRange->TableId.PathId.LocalPathId);
@@ -472,7 +472,7 @@ private:
             ContentsRows.emplace_back(shardResponse.GetContentsRows(i));
         }
 
-        if (CurrentShardIdx+1 < KeyRange->Partitions.size() &&
+        if (CurrentShardIdx+1 < KeyRange->Partitions.size() && 
             MaxKeys > ContentsRows.size() + CommonPrefixesRows.size() &&
             shardResponse.GetMoreRows())
         {
@@ -686,11 +686,11 @@ protected:
         ConvertYdbValueToMiniKQLValue(tv.Gettype(), tv.Getvalue(), *params.MutableValue());
     }
 
-    static void ConvertMiniKQLRowsToResultSet(const NKikimrMiniKQL::TType& rowsListType, const NKikimrMiniKQL::TValue& rowsList, Ydb::ResultSet& resultSet) {
+    static void ConvertMiniKQLRowsToResultSet(const NKikimrMiniKQL::TType& rowsListType, const NKikimrMiniKQL::TValue& rowsList, Ydb::ResultSet& resultSet) { 
         TStackVec<NKikimrMiniKQL::TType> columnTypes;
         Y_VERIFY(rowsListType.GetKind() == NKikimrMiniKQL::ETypeKind::List);
         for (const auto& column : rowsListType.GetList().GetItem().GetStruct().GetMember()) {
-            auto columnMeta = resultSet.add_columns();
+            auto columnMeta = resultSet.add_columns(); 
             columnMeta->set_name(column.GetName());
             columnTypes.push_back(column.GetType());
             ConvertMiniKQLTypeToYdbType(column.GetType(), *columnMeta->mutable_type());
diff --git a/ydb/core/cms/console/console__add_config_subscription.cpp b/ydb/core/cms/console/console__add_config_subscription.cpp
index 3bb6422792..c4d309e80e 100644
--- a/ydb/core/cms/console/console__add_config_subscription.cpp
+++ b/ydb/core/cms/console/console__add_config_subscription.cpp
@@ -14,7 +14,7 @@ public:
     {
     }
 
-    bool Error(Ydb::StatusIds::StatusCode code,
+    bool Error(Ydb::StatusIds::StatusCode code, 
                const TString &error,
                const TActorContext &ctx)
     {
@@ -40,7 +40,7 @@ public:
         Response = new TEvConsole::TEvAddConfigSubscriptionResponse;
 
         TSubscription::TPtr subscription = new TSubscription(rec.GetSubscription());
-        Ydb::StatusIds::StatusCode code;
+        Ydb::StatusIds::StatusCode code; 
         TString error;
         if (!Self->MakeNewSubscriptionChecks(subscription, code, error))
             return Error(code, error, ctx);
@@ -60,7 +60,7 @@ public:
 
         subscription->Id = Self->NextSubscriptionId++;
         subscription->Cookie = RandomNumber<ui64>();
-        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
         Response->Record.SetSubscriptionId(subscription->Id);
 
         Self->PendingSubscriptionModifications.AddedSubscriptions.push_back(subscription);
diff --git a/ydb/core/cms/console/console__alter_tenant.cpp b/ydb/core/cms/console/console__alter_tenant.cpp
index dc44c25082..a4323325b4 100644
--- a/ydb/core/cms/console/console__alter_tenant.cpp
+++ b/ydb/core/cms/console/console__alter_tenant.cpp
@@ -14,7 +14,7 @@ public:
     {
     }
 
-    bool Error(Ydb::StatusIds::StatusCode code, const TString &error,
+    bool Error(Ydb::StatusIds::StatusCode code, const TString &error, 
                const TActorContext &ctx)
     {
         LOG_DEBUG_S(ctx, NKikimrServices::CMS_TENANTS, "Cannot alter tenant: " << error);
@@ -34,7 +34,7 @@ public:
     bool Execute(TTransactionContext &txc, const TActorContext &executorCtx) override
     {
         auto ctx = executorCtx.MakeFor(Self->SelfId());
-        Ydb::StatusIds::StatusCode code;
+        Ydb::StatusIds::StatusCode code; 
         TString error;
 
         auto &rec = Request->Get()->Record.GetRequest();
@@ -50,11 +50,11 @@ public:
         auto path = CanonizePath(rec.path());
         Tenant = Self->GetTenant(path);
         if (!Tenant)
-            return Error(Ydb::StatusIds::NOT_FOUND,
+            return Error(Ydb::StatusIds::NOT_FOUND, 
                          Sprintf("Database '%s' doesn't exist", path.data()), ctx);
 
         if (!Tenant->IsRunning() && !Tenant->IsConfiguring())
-            return Error(Ydb::StatusIds::UNAVAILABLE,
+            return Error(Ydb::StatusIds::UNAVAILABLE, 
                          Sprintf("Database '%s' is busy", path.data()), ctx);
 
         // Check idempotency key
@@ -106,7 +106,7 @@ public:
 
             auto key = std::make_pair(kind, zone);
             if (count > NewComputationalUnits[key])
-                return Error(Ydb::StatusIds::BAD_REQUEST,
+                return Error(Ydb::StatusIds::BAD_REQUEST, 
                              Sprintf("Not enough units of kind '%s' in zone '%s' to remove",
                                      kind.data(), zone.data()),
                              ctx);
@@ -147,7 +147,7 @@ public:
             auto key = std::make_pair(unit.host(), unit.port());
             auto it = Tenant->RegisteredComputationalUnits.find(key);
             if (it == Tenant->RegisteredComputationalUnits.end())
-                return Error(Ydb::StatusIds::BAD_REQUEST,
+                return Error(Ydb::StatusIds::BAD_REQUEST, 
                              Sprintf("Cannot deregister unknown unit %s:%" PRIu32,
                                      key.first.data(), key.second),
                              ctx);
diff --git a/ydb/core/cms/console/console__configure.cpp b/ydb/core/cms/console/console__configure.cpp
index f28417e760..970f431e91 100644
--- a/ydb/core/cms/console/console__configure.cpp
+++ b/ydb/core/cms/console/console__configure.cpp
@@ -13,7 +13,7 @@ public:
     {
     }
 
-    bool Error(Ydb::StatusIds::StatusCode code,
+    bool Error(Ydb::StatusIds::StatusCode code, 
                const TString &error,
                const TActorContext &ctx)
     {
@@ -32,7 +32,7 @@ public:
                         const TActorContext &ctx)
     {
         if (item->Generation != generation) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   TStringBuilder() << "wrong generation for config item #" << item->Id,
                   ctx);
             return false;
@@ -46,7 +46,7 @@ public:
                         const TActorContext &ctx)
     {
         if (!kind) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   TStringBuilder() << "zero kind value is not allowed for config items",
                   ctx);
             return false;
@@ -57,7 +57,7 @@ public:
         reflection->ListFields(config, &fields);
         for (auto field : fields) {
             if (field->number() != static_cast<int>(kind)) {
-                Error(Ydb::StatusIds::BAD_REQUEST,
+                Error(Ydb::StatusIds::BAD_REQUEST, 
                       TStringBuilder() << "wrong config item: field '" << field->name()
                       << "' shouldn't be set for confg item "
                       << TConfigItem::KindName(kind) << " (" << kind << ")",
@@ -111,7 +111,7 @@ public:
         auto &item = action.GetConfigItem();
 
         if (item.HasId()) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   "cannot add config item: new items should have empty id",
                   ctx);
             return false;
@@ -135,13 +135,13 @@ public:
                 if (action.GetEnableAutoSplit()) {
                     SplitConfigItem(item, newItems, ctx);
                     if (newItems.empty()) {
-                        Error(Ydb::StatusIds::BAD_REQUEST,
+                        Error(Ydb::StatusIds::BAD_REQUEST, 
                               "cannot detect kind for new item with empty config",
                               ctx);
                         return false;
                     }
                 } else {
-                    Error(Ydb::StatusIds::BAD_REQUEST,
+                    Error(Ydb::StatusIds::BAD_REQUEST, 
                           TStringBuilder() << "cannot detect kind for config item"
                           << " (auto split is disabled): " << item.ShortDebugString(),
                           ctx);
@@ -179,7 +179,7 @@ public:
     {
         TConfigItem::TPtr item = Self->ConfigIndex.GetItem(action.GetConfigItemId().GetId());
         if (!item) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   TStringBuilder() << "cannot remove unknown config item #" << action.GetConfigItemId().GetId(),
                   ctx);
             return false;
@@ -189,7 +189,7 @@ public:
             return false;
 
         if (Self->PendingConfigModifications.ModifiedItems.contains(item->Id)) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   TStringBuilder() << "removal action for config item #"
                   << item->Id << " conflicts with its modification",
                   ctx);
@@ -235,7 +235,7 @@ public:
         auto &newItem = action.GetConfigItem();
         TConfigItem::TPtr item = Self->ConfigIndex.GetItem(newItem.GetId().GetId());
         if (!item) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   TStringBuilder() << "cannot modify unknown config item #" << newItem.GetId().GetId(),
                   ctx);
             return false;
@@ -245,7 +245,7 @@ public:
             return false;
 
         if (newItem.HasKind() && newItem.GetKind() != item->Kind) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   TStringBuilder() << "cannot modify kind for config item #" << item->Id,
                   ctx);
             return false;
@@ -263,13 +263,13 @@ public:
             return false;
 
         if (Self->PendingConfigModifications.ModifiedItems.contains(item->Id)) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   TStringBuilder() << "multiple modification actions for config item #"
                   << item->Id << " are not allowed",
                   ctx);
             return false;
         } else if (Self->PendingConfigModifications.RemovedItems.contains(item->Id)) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   TStringBuilder() << "modification action conflicts with removal action"
                   " for config item #" << item->Id,
                   ctx);
@@ -305,10 +305,10 @@ public:
         case NKikimrConsole::TConfigureAction::kRemoveConfigItems:
             return IsRemoveConfigItemsActionOk(action.GetRemoveConfigItems(), ctx);
         case NKikimrConsole::TConfigureAction::ACTION_NOT_SET:
-            Error(Ydb::StatusIds::BAD_REQUEST, "empty action", ctx);
+            Error(Ydb::StatusIds::BAD_REQUEST, "empty action", ctx); 
             return false;
         default:
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   Sprintf("unsupported configure action (%s)", action.ShortDebugString().data()),
                   ctx);
             return false;
@@ -331,7 +331,7 @@ public:
         for (auto &conflictItem : conflicts) {
             if (!Self->PendingConfigModifications.ModifiedItems.contains(conflictItem->Id)
                 && !Self->PendingConfigModifications.RemovedItems.contains(conflictItem->Id)) {
-                Error(Ydb::StatusIds::BAD_REQUEST,
+                Error(Ydb::StatusIds::BAD_REQUEST, 
                       TStringBuilder() << ItemName(item) << " (scope: " << item->UsageScope.ToString()
                       << ") has order conflict with config item #" << conflictItem->Id
                       << " (scope: " << conflictItem->UsageScope.ToString() << ")",
@@ -345,13 +345,13 @@ public:
                 continue;
 
             if (!conflictItem->Id && !item->Id)
-                Error(Ydb::StatusIds::BAD_REQUEST,
+                Error(Ydb::StatusIds::BAD_REQUEST, 
                       TStringBuilder() << "two added items conflict by order (scope1: "
                       << item->UsageScope.ToString() << " scope2: "
                       << conflictItem->UsageScope.ToString() << ")",
                       ctx);
             else
-                Error(Ydb::StatusIds::BAD_REQUEST,
+                Error(Ydb::StatusIds::BAD_REQUEST, 
                       TStringBuilder() << ItemName(item) << " (scope: " << item->UsageScope.ToString()
                       << ") has order conflict with " << ItemName(conflictItem) << " (scope: "
                       << conflictItem->UsageScope.ToString() << ")",
@@ -389,7 +389,7 @@ public:
                 maxOrder = Max(maxOrder, pr.second->UsageScope.Order);
 
         if (maxOrder == Max<ui32>()) {
-            Error(Ydb::StatusIds::BAD_REQUEST,
+            Error(Ydb::StatusIds::BAD_REQUEST, 
                   TStringBuilder() << "Cannot auto order " << ItemName(item) << " (scope: "
                   << item->UsageScope.ToString() << " because max order value is used"
                   " by one of intersecting usage scopes.",
@@ -462,7 +462,7 @@ public:
         Response = new TEvConsole::TEvConfigureResponse;
 
         if (!rec.ActionsSize())
-            return Error(Ydb::StatusIds::BAD_REQUEST,
+            return Error(Ydb::StatusIds::BAD_REQUEST, 
                          "no actions specified", ctx);
 
         for (auto &action : rec.GetActions()) {
@@ -484,7 +484,7 @@ public:
                          validator.GetErrorMessage(), ctx);
 
         // Now configure command is known to be OK and we start to apply it.
-        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
 
         // Fill affected configs.
         TConfigsConfig config(Self->Config);
diff --git a/ydb/core/cms/console/console__create_tenant.cpp b/ydb/core/cms/console/console__create_tenant.cpp
index 77d8166d54..3156b05cf9 100644
--- a/ydb/core/cms/console/console__create_tenant.cpp
+++ b/ydb/core/cms/console/console__create_tenant.cpp
@@ -25,7 +25,7 @@ public:
     {
     }
 
-    bool Error(Ydb::StatusIds::StatusCode code, const TString &error,
+    bool Error(Ydb::StatusIds::StatusCode code, const TString &error, 
                const TActorContext &ctx)
     {
         LOG_DEBUG_S(ctx, NKikimrServices::CMS_TENANTS, "Cannot create tenant: " << error);
@@ -61,7 +61,7 @@ public:
     bool Execute(TTransactionContext &txc, const TActorContext &executorCtx) override
     {
         auto ctx = executorCtx.MakeFor(Self->SelfId());
-        Ydb::StatusIds::StatusCode code;
+        Ydb::StatusIds::StatusCode code; 
         TString error;
 
         auto &rec = Request->Get()->Record.GetRequest();
diff --git a/ydb/core/cms/console/console__remove_config_subscription.cpp b/ydb/core/cms/console/console__remove_config_subscription.cpp
index ae24deb1a8..e056768a75 100644
--- a/ydb/core/cms/console/console__remove_config_subscription.cpp
+++ b/ydb/core/cms/console/console__remove_config_subscription.cpp
@@ -12,7 +12,7 @@ public:
     {
     }
 
-    bool Error(Ydb::StatusIds::StatusCode code,
+    bool Error(Ydb::StatusIds::StatusCode code, 
                const TString &error,
                const TActorContext &ctx)
     {
@@ -39,10 +39,10 @@ public:
 
         ui64 id = rec.GetSubscriptionId();
         if (!Self->SubscriptionIndex.GetSubscription(id))
-            return Error(Ydb::StatusIds::NOT_FOUND,
+            return Error(Ydb::StatusIds::NOT_FOUND, 
                          Sprintf("cannot find subscription %" PRIu64, id), ctx);
 
-        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
 
         Self->PendingSubscriptionModifications.RemovedSubscriptions.insert(id);
 
diff --git a/ydb/core/cms/console/console__remove_config_subscriptions.cpp b/ydb/core/cms/console/console__remove_config_subscriptions.cpp
index 584b427cdc..89200d49b3 100644
--- a/ydb/core/cms/console/console__remove_config_subscriptions.cpp
+++ b/ydb/core/cms/console/console__remove_config_subscriptions.cpp
@@ -22,7 +22,7 @@ public:
         Y_VERIFY(Self->PendingSubscriptionModifications.IsEmpty());
 
         Response = new TEvConsole::TEvRemoveConfigSubscriptionsResponse;
-        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
 
         TSubscriberId subscriber(rec.GetSubscriber());
         auto &subscriptions = Self->SubscriptionIndex.GetSubscriptions(subscriber);
diff --git a/ydb/core/cms/console/console__remove_tenant.cpp b/ydb/core/cms/console/console__remove_tenant.cpp
index 14bf4e19f3..4ff9a82ff3 100644
--- a/ydb/core/cms/console/console__remove_tenant.cpp
+++ b/ydb/core/cms/console/console__remove_tenant.cpp
@@ -14,7 +14,7 @@ public:
     {
     }
 
-    bool Error(Ydb::StatusIds::StatusCode code, const TString &error,
+    bool Error(Ydb::StatusIds::StatusCode code, const TString &error, 
                const TActorContext &ctx)
     {
         LOG_DEBUG_S(ctx, NKikimrServices::CMS_TENANTS, "Cannot remove tenant: " << error);
@@ -34,7 +34,7 @@ public:
     void FillTenantResponse()
     {
         Y_VERIFY(Tenant);
-        Ydb::TOperationId id = Self->MakeOperationId(Tenant, TTenant::REMOVE);
+        Ydb::TOperationId id = Self->MakeOperationId(Tenant, TTenant::REMOVE); 
         auto &operation = *Response->Record.MutableResponse()->mutable_operation();
         operation.set_ready(false);
         operation.set_id(ProtoToString(id));
@@ -59,7 +59,7 @@ public:
         auto path = CanonizePath(rec.path());
         Tenant = Self->GetTenant(path);
         if (!Tenant)
-            return Error(Ydb::StatusIds::NOT_FOUND,
+            return Error(Ydb::StatusIds::NOT_FOUND, 
                          Sprintf("Database '%s' doesn't exist", path.data()), ctx);
 
         if (Tenant->IsRemoving()) {
@@ -68,7 +68,7 @@ public:
             Tenant = nullptr;
             return true;
         } else if (!Tenant->IsConfiguring() && !Tenant->IsRunning()) {
-            return Error(Ydb::StatusIds::UNAVAILABLE,
+            return Error(Ydb::StatusIds::UNAVAILABLE, 
                          Sprintf("Database '%s' is busy", path.data()), ctx);
         } else if (Tenant->HostedTenants) {
             return Error(Ydb::StatusIds::PRECONDITION_FAILED,
diff --git a/ydb/core/cms/console/console__replace_config_subscriptions.cpp b/ydb/core/cms/console/console__replace_config_subscriptions.cpp
index eabed14288..2251b612c1 100644
--- a/ydb/core/cms/console/console__replace_config_subscriptions.cpp
+++ b/ydb/core/cms/console/console__replace_config_subscriptions.cpp
@@ -14,7 +14,7 @@ public:
     {
     }
 
-    bool Error(Ydb::StatusIds::StatusCode code,
+    bool Error(Ydb::StatusIds::StatusCode code, 
                const TString &error,
                const TActorContext &ctx)
     {
@@ -40,7 +40,7 @@ public:
         Response = new TEvConsole::TEvReplaceConfigSubscriptionsResponse;
 
         TSubscription::TPtr subscription = new TSubscription(rec.GetSubscription());
-        Ydb::StatusIds::StatusCode code;
+        Ydb::StatusIds::StatusCode code; 
         TString error;
         if (!Self->MakeNewSubscriptionChecks(subscription, code, error))
             return Error(code, error, ctx);
@@ -67,7 +67,7 @@ public:
             Self->PendingSubscriptionModifications.AddedSubscriptions.push_back(subscription);
         }
 
-        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
         Response->Record.SetSubscriptionId(subscription->Id);
 
         // Update database.
diff --git a/ydb/core/cms/console/console__set_config.cpp b/ydb/core/cms/console/console__set_config.cpp
index 8cea3abba2..59c6ec9924 100644
--- a/ydb/core/cms/console/console__set_config.cpp
+++ b/ydb/core/cms/console/console__set_config.cpp
@@ -17,7 +17,7 @@ public:
     {
     }
 
-    bool Error(Ydb::StatusIds::StatusCode code, const TString &error,
+    bool Error(Ydb::StatusIds::StatusCode code, const TString &error, 
                const TActorContext &ctx)
     {
         LOG_DEBUG_S(ctx, NKikimrServices::CMS, "Cannot set config: " << error);
@@ -48,7 +48,7 @@ public:
                          "Unsupported merge strategy", ctx);
         }
 
-        Ydb::StatusIds::StatusCode code;
+        Ydb::StatusIds::StatusCode code; 
         TString error;
         if (!Self->TenantsManager->CheckTenantsConfig(NewConfig.GetTenantsConfig(), code, error))
             return Error(code, error, ctx);
@@ -64,7 +64,7 @@ public:
         db.Table<Schema::Config>().Key(ConfigKeyConfig)
             .Update(NIceDb::TUpdate<Schema::Config::Value>(config));
 
-        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+        Response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
 
         return true;
     }
diff --git a/ydb/core/cms/console/console_configs_manager.cpp b/ydb/core/cms/console/console_configs_manager.cpp
index a0415de947..5e65f587ab 100644
--- a/ydb/core/cms/console/console_configs_manager.cpp
+++ b/ydb/core/cms/console/console_configs_manager.cpp
@@ -125,29 +125,29 @@ void TConfigsManager::ApplyPendingSubscriptionModifications(const TActorContext
 }
 
 bool TConfigsManager::MakeNewSubscriptionChecks(TSubscription::TPtr subscription,
-                                                Ydb::StatusIds::StatusCode &code,
+                                                Ydb::StatusIds::StatusCode &code, 
                                                 TString &error)
 {
     if (subscription->Id) {
-        code = Ydb::StatusIds::BAD_REQUEST;
+        code = Ydb::StatusIds::BAD_REQUEST; 
         error = "subscription id shouldn't be defined";
         return false;
     }
 
     if (!subscription->Subscriber.TabletId && !subscription->Subscriber.ServiceId) {
-        code = Ydb::StatusIds::BAD_REQUEST;
+        code = Ydb::StatusIds::BAD_REQUEST; 
         error = "no subscriber specified";
         return false;
     }
 
     if (subscription->Subscriber.ServiceId && !subscription->Subscriber.ServiceId.IsService()) {
-        code = Ydb::StatusIds::BAD_REQUEST;
+        code = Ydb::StatusIds::BAD_REQUEST; 
         error = "wrong service id";
         return false;
     }
 
     if (subscription->ItemKinds.empty()) {
-        code = Ydb::StatusIds::BAD_REQUEST;
+        code = Ydb::StatusIds::BAD_REQUEST; 
         error = "no item kinds specified";
         return false;
     }
diff --git a/ydb/core/cms/console/console_configs_manager.h b/ydb/core/cms/console/console_configs_manager.h
index 2dca13be26..bdcb470287 100644
--- a/ydb/core/cms/console/console_configs_manager.h
+++ b/ydb/core/cms/console/console_configs_manager.h
@@ -56,7 +56,7 @@ public:
                                                TAutoPtr<IEventHandle> ev = nullptr);
 
     bool MakeNewSubscriptionChecks(TSubscription::TPtr subscription,
-                                   Ydb::StatusIds::StatusCode &code,
+                                   Ydb::StatusIds::StatusCode &code, 
                                    TString &error);
 
     bool IsConfigItemScopeAllowed(TConfigItem::TPtr item);
diff --git a/ydb/core/cms/console/console_configs_provider.cpp b/ydb/core/cms/console/console_configs_provider.cpp
index 4ba6f46033..b8e52c53be 100644
--- a/ydb/core/cms/console/console_configs_provider.cpp
+++ b/ydb/core/cms/console/console_configs_provider.cpp
@@ -771,7 +771,7 @@ void TConfigsProvider::Handle(TEvConsole::TEvGetConfigItemsRequest::TPtr &ev, co
     auto &rec = ev->Get()->Record;
 
     auto response = MakeHolder<TEvConsole::TEvGetConfigItemsResponse>();
-    response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+    response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
 
     THashSet<ui32> kinds;
     for (auto &kind : rec.GetItemKinds())
@@ -894,10 +894,10 @@ void TConfigsProvider::Handle(TEvConsole::TEvGetConfigSubscriptionRequest::TPtr
     auto resp = MakeHolder<TEvConsole::TEvGetConfigSubscriptionResponse>();
     auto subscription = SubscriptionIndex.GetSubscription(id);
     if (subscription) {
-        resp->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+        resp->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
         subscription->Serialize(*resp->Record.MutableSubscription());
     } else {
-        resp->Record.MutableStatus()->SetCode(Ydb::StatusIds::NOT_FOUND);
+        resp->Record.MutableStatus()->SetCode(Ydb::StatusIds::NOT_FOUND); 
         resp->Record.MutableSubscription()->SetId(id);
     }
 
@@ -912,7 +912,7 @@ void TConfigsProvider::Handle(TEvConsole::TEvGetNodeConfigItemsRequest::TPtr &ev
     auto &rec = ev->Get()->Record;
 
     auto response = MakeHolder<TEvConsole::TEvGetNodeConfigItemsResponse>();
-    response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+    response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
 
     THashSet<ui32> kinds;
     for (auto &kind : rec.GetItemKinds())
@@ -935,7 +935,7 @@ void TConfigsProvider::Handle(TEvConsole::TEvGetNodeConfigRequest::TPtr &ev, con
     auto &rec = ev->Get()->Record;
 
     auto response = MakeHolder<TEvConsole::TEvGetNodeConfigResponse>();
-    response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+    response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
 
     THashSet<ui32> kinds;
     for (auto &kind : rec.GetItemKinds())
@@ -972,7 +972,7 @@ void TConfigsProvider::Handle(TEvConsole::TEvListConfigSubscriptionsRequest::TPt
     auto &rec = ev->Get()->Record;
 
     auto response = MakeHolder<TEvConsole::TEvListConfigSubscriptionsResponse>();
-    response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS);
+    response->Record.MutableStatus()->SetCode(Ydb::StatusIds::SUCCESS); 
 
     if (rec.HasSubscriber()) {
         TSubscriberId subscriber(rec.GetSubscriber());
diff --git a/ydb/core/cms/console/console_tenants_manager.cpp b/ydb/core/cms/console/console_tenants_manager.cpp
index 0db3f5dced..f5b935422c 100644
--- a/ydb/core/cms/console/console_tenants_manager.cpp
+++ b/ydb/core/cms/console/console_tenants_manager.cpp
@@ -1263,7 +1263,7 @@ bool TTenantsManager::TTenant::CheckComputationalUnitsQuota(const TUnitsCount &u
         for (auto &pr : units)
             total += pr.second;
         if (total > ComputationalUnitsQuota) {
-            code = Ydb::StatusIds::BAD_REQUEST;
+            code = Ydb::StatusIds::BAD_REQUEST; 
             error = Sprintf("Total count of computational units %" PRIu64 " exceeds quota %" PRIu64,
                             total, ComputationalUnitsQuota);
             return false;
@@ -1273,7 +1273,7 @@ bool TTenantsManager::TTenant::CheckComputationalUnitsQuota(const TUnitsCount &u
     return true;
 }
 
-bool TTenantsManager::TTenant::CheckStorageUnitsQuota(Ydb::StatusIds::StatusCode &code, TString &error,
+bool TTenantsManager::TTenant::CheckStorageUnitsQuota(Ydb::StatusIds::StatusCode &code, TString &error, 
                                                       ui64 additionalUnits)
 {
     if (StorageUnitsQuota) {
@@ -1281,7 +1281,7 @@ bool TTenantsManager::TTenant::CheckStorageUnitsQuota(Ydb::StatusIds::StatusCode
         for (auto &pr : StoragePools)
             total += pr.second->Config.GetNumGroups();
         if (total > StorageUnitsQuota) {
-            code = Ydb::StatusIds::BAD_REQUEST;
+            code = Ydb::StatusIds::BAD_REQUEST; 
             error = Sprintf("Total count of storage units %" PRIu64 " exceeds quota %" PRIu64,
                             total, StorageUnitsQuota);
             return false;
@@ -1291,7 +1291,7 @@ bool TTenantsManager::TTenant::CheckStorageUnitsQuota(Ydb::StatusIds::StatusCode
     return true;
 }
 
-bool TTenantsManager::TTenant::CheckQuota(Ydb::StatusIds::StatusCode &code, TString &error)
+bool TTenantsManager::TTenant::CheckQuota(Ydb::StatusIds::StatusCode &code, TString &error) 
 {
     return (CheckStorageUnitsQuota(code, error)
             && CheckComputationalUnitsQuota(ComputationalUnits, code, error));
@@ -1482,16 +1482,16 @@ bool TTenantsManager::CheckTenantSlots(TTenant::TPtr tenant, const NKikimrTenant
     return state.RequiredSlotsSize() == tenant->Slots.size();
 }
 
-bool TTenantsManager::MakeBasicPoolCheck(const TString &kind, ui64 size, Ydb::StatusIds::StatusCode &code, TString &error)
+bool TTenantsManager::MakeBasicPoolCheck(const TString &kind, ui64 size, Ydb::StatusIds::StatusCode &code, TString &error) 
 {
     if (!size) {
-        code = Ydb::StatusIds::BAD_REQUEST;
+        code = Ydb::StatusIds::BAD_REQUEST; 
         error = "Zero count for storage units is not allowed";
         return false;
     }
 
     if (!Domain->StoragePoolTypes.contains(kind)) {
-        code = Ydb::StatusIds::BAD_REQUEST;
+        code = Ydb::StatusIds::BAD_REQUEST; 
         error = Sprintf("Unsupported storage unit kind '%s'.", kind.data());
         return false;
     }
@@ -1500,25 +1500,25 @@ bool TTenantsManager::MakeBasicPoolCheck(const TString &kind, ui64 size, Ydb::St
 }
 
 bool TTenantsManager::MakeBasicComputationalUnitCheck(const TString &kind, const TString &zone,
-                                                      Ydb::StatusIds::StatusCode &code,
+                                                      Ydb::StatusIds::StatusCode &code, 
                                                       TString &error)
 {
     if (!Config.TenantSlotKinds.contains(kind)) {
-        code = Ydb::StatusIds::BAD_REQUEST;
+        code = Ydb::StatusIds::BAD_REQUEST; 
         error = Sprintf("Unknown computational unit kind '%s'", kind.data());
         return false;
     }
 
     if (zone) {
         if (!Config.AvailabilityZones.contains(zone)) {
-            code = Ydb::StatusIds::BAD_REQUEST;
+            code = Ydb::StatusIds::BAD_REQUEST; 
             error = Sprintf("Unknown availability zone '%s'", zone.data());
             return false;
         }
 
         auto &slotKind = Config.TenantSlotKinds.at(kind);
         if (!slotKind.AllowedZones.contains(zone)) {
-            code = Ydb::StatusIds::BAD_REQUEST;
+            code = Ydb::StatusIds::BAD_REQUEST; 
             error = Sprintf("Zone '%s' is unavailable for units of kind '%s'", zone.data(), kind.data());
             return false;
         }
@@ -1597,14 +1597,14 @@ bool TTenantsManager::CheckComputationalUnitsQuota(const TUnitsCount &units,
 }
 
 bool TTenantsManager::CheckTenantsConfig(const NKikimrConsole::TTenantsConfig &config,
-                                         Ydb::StatusIds::StatusCode &code,
+                                         Ydb::StatusIds::StatusCode &code, 
                                          TString &error)
 {
     TTenantsConfig newConfig;
 
     // Check config is consistent.
     if (!newConfig.Parse(config, error)) {
-        code = Ydb::StatusIds::BAD_REQUEST;
+        code = Ydb::StatusIds::BAD_REQUEST; 
         return false;
     }
 
@@ -1614,7 +1614,7 @@ bool TTenantsManager::CheckTenantsConfig(const NKikimrConsole::TTenantsConfig &c
         if (it == newConfig.AvailabilityZones.end() || it->second != pr.second) {
             auto tenant = FindZoneKindUsage(pr.first);
             if (tenant) {
-                code = Ydb::StatusIds::BAD_REQUEST;
+                code = Ydb::StatusIds::BAD_REQUEST; 
                 error = Sprintf("cannot remove or modify availability zone '%s' used by tenant '%s'",
                                 pr.first.data(), tenant->Path.data());
                 return false;
@@ -1630,7 +1630,7 @@ bool TTenantsManager::CheckTenantsConfig(const NKikimrConsole::TTenantsConfig &c
         if (it == newConfig.TenantSlotKinds.end()) {
             auto tenant = FindComputationalUnitKindUsage(pr.first);
             if (tenant) {
-                code = Ydb::StatusIds::BAD_REQUEST;
+                code = Ydb::StatusIds::BAD_REQUEST; 
                 error = Sprintf("cannot remove computational unit kind '%s' used by tenant '%s'",
                                 pr.first.data(), tenant->Path.data());
                 return false;
@@ -1655,7 +1655,7 @@ bool TTenantsManager::CheckTenantsConfig(const NKikimrConsole::TTenantsConfig &c
                 if (!it->second.AllowedZones.contains(zone)) {
                     auto tenant = FindComputationalUnitKindUsage(pr.first, zone);
                     if (tenant) {
-                        code = Ydb::StatusIds::BAD_REQUEST;
+                        code = Ydb::StatusIds::BAD_REQUEST; 
                         error = Sprintf("cannot remove allowed availability zone '%s' from computational"
                                         " unit kind '%s' used by tenant '%s'",
                                         zone.data(), pr.first.data(), tenant->Path.data());
@@ -1703,10 +1703,10 @@ Ydb::TOperationId TTenantsManager::MakeOperationId(const TString &path, ui64 txI
     return id;
 }
 
-Ydb::TOperationId TTenantsManager::MakeOperationId(TTenant::TPtr tenant, TTenant::EAction action)
+Ydb::TOperationId TTenantsManager::MakeOperationId(TTenant::TPtr tenant, TTenant::EAction action) 
 {
-    Ydb::TOperationId id;
-    id.SetKind(Ydb::TOperationId::CMS_REQUEST);
+    Ydb::TOperationId id; 
+    id.SetKind(Ydb::TOperationId::CMS_REQUEST); 
     AddOptionalValue(id, "tenant", tenant->Path);
     AddOptionalValue(id, "cmstid", ToString(Self.TabletID()));
     AddOptionalValue(id, "txid", ToString(tenant->TxId));
diff --git a/ydb/core/cms/console/console_tenants_manager.h b/ydb/core/cms/console/console_tenants_manager.h
index a21615dd62..00ca6741a8 100644
--- a/ydb/core/cms/console/console_tenants_manager.h
+++ b/ydb/core/cms/console/console_tenants_manager.h
@@ -474,8 +474,8 @@ public:
         bool CheckComputationalUnitsQuota(const TUnitsCount &units,
                                           Ydb::StatusIds::StatusCode &code,
                                           TString &error);
-        bool CheckStorageUnitsQuota(Ydb::StatusIds::StatusCode &code, TString &error, ui64 additionalUnits = 0);
-        bool CheckQuota(Ydb::StatusIds::StatusCode &code, TString &error);
+        bool CheckStorageUnitsQuota(Ydb::StatusIds::StatusCode &code, TString &error, ui64 additionalUnits = 0); 
+        bool CheckQuota(Ydb::StatusIds::StatusCode &code, TString &error); 
         void ParseComputationalUnits(const TTenantsConfig &config);
         void RemoveComputationalUnits();
 
@@ -748,9 +748,9 @@ public:
                            const TActorContext &ctx);
     bool CheckTenantSlots(TTenant::TPtr tenant, const NKikimrTenantSlotBroker::TTenantState &state);
     bool HasEnoughPoolIds(ui64 count);
-    bool MakeBasicPoolCheck(const TString &type, ui64 count, Ydb::StatusIds::StatusCode &code, TString &error);
+    bool MakeBasicPoolCheck(const TString &type, ui64 count, Ydb::StatusIds::StatusCode &code, TString &error); 
     bool MakeBasicComputationalUnitCheck(const TString &kind, const TString &zone,
-                                         Ydb::StatusIds::StatusCode &code,
+                                         Ydb::StatusIds::StatusCode &code, 
                                          TString &error);
     // Check we have enough quota to replace computational units
     // of specified tenant with new ones.
@@ -763,14 +763,14 @@ public:
                                       Ydb::StatusIds::StatusCode &code,
                                       TString &error);
     bool CheckTenantsConfig(const NKikimrConsole::TTenantsConfig &config,
-                            Ydb::StatusIds::StatusCode &code,
+                            Ydb::StatusIds::StatusCode &code, 
                             TString &error);
     bool CheckAccess(const TString &token,
                      Ydb::StatusIds::StatusCode &code,
                      TString &error,
                      const TActorContext &ctx);
     Ydb::TOperationId MakeOperationId(const TString &path, ui64 txId, TTenant::EAction action);
-    Ydb::TOperationId MakeOperationId(TTenant::TPtr tenant, TTenant::EAction action);
+    Ydb::TOperationId MakeOperationId(TTenant::TPtr tenant, TTenant::EAction action); 
     TStoragePool::TPtr MakeStoragePool(TTenant::TPtr tenant, const TString &kind, ui64 size);
 
     void CreateSubDomain(TTenant::TPtr tenant, const TActorContext &ctx);
diff --git a/ydb/core/cms/console/console_ut_configs.cpp b/ydb/core/cms/console/console_ut_configs.cpp
index 0cb1655281..43073abd72 100644
--- a/ydb/core/cms/console/console_ut_configs.cpp
+++ b/ydb/core/cms/console/console_ut_configs.cpp
@@ -169,7 +169,7 @@ void CheckGetItems(TTenantTestRuntime &runtime,
     TAutoPtr<IEventHandle> handle;
     runtime.SendToConsole(event);
     auto reply = runtime.GrabEdgeEventRethrow<TResponseEvent>(handle);
-    UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), Ydb::StatusIds::SUCCESS);
+    UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), Ydb::StatusIds::SUCCESS); 
 
     for (auto &item : reply->Record.GetConfigItems()) {
         auto it = items.find(item.GetId().GetId());
@@ -393,7 +393,7 @@ void CheckGetNodeConfig(TTenantTestRuntime &runtime, ui32 nodeId, const TString
     TAutoPtr<IEventHandle> handle;
     runtime.SendToConsole(event);
     auto reply = runtime.GrabEdgeEventRethrow<TEvConsole::TEvGetNodeConfigResponse>(handle);
-    UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), Ydb::StatusIds::SUCCESS);
+    UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), Ydb::StatusIds::SUCCESS); 
     CheckEqualsIgnoringVersion(reply->Record.GetConfig(), config);
 }
 
@@ -428,7 +428,7 @@ void IncGeneration(NKikimrConsole::TConfigItem &item, Ts&... args)
     IncGeneration(args...);
 }
 
-ui64 CheckAddConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code,
+ui64 CheckAddConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code, 
                                 ui32 nodeId, const TString &host, const TString &tenant,
                                 const TString &nodeType, ui64 tabletId, TActorId serviceId,
                                 TVector<ui32> kinds, ui64 id = 0)
@@ -452,11 +452,11 @@ ui64 CheckAddConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::Sta
     UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), code);
 
     ui64 res = reply->Record.GetSubscriptionId();
-    UNIT_ASSERT(code != Ydb::StatusIds::SUCCESS || res);
+    UNIT_ASSERT(code != Ydb::StatusIds::SUCCESS || res); 
     return res;
 }
 
-ui64 CheckReplaceConfigSubscriptions(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code,
+ui64 CheckReplaceConfigSubscriptions(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code, 
                                      ui32 nodeId, const TString &host, const TString &tenant,
                                      const TString &nodeType, ui64 tabletId, TActorId serviceId,
                                      TVector<ui32> kinds, ui64 id = 0)
@@ -480,11 +480,11 @@ ui64 CheckReplaceConfigSubscriptions(TTenantTestRuntime &runtime, Ydb::StatusIds
     UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), code);
 
     ui64 res = reply->Record.GetSubscriptionId();
-    UNIT_ASSERT(code != Ydb::StatusIds::SUCCESS || res);
+    UNIT_ASSERT(code != Ydb::StatusIds::SUCCESS || res); 
     return res;
 }
 
-void CheckGetConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code,
+void CheckGetConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code, 
                                 ui64 id, ui32 nodeId = 0, const TString &host = "", const TString &tenant = "",
                                 const TString &nodeType = "", ui64 tabletId = 0, TActorId serviceId = {},
                                 TVector<ui32> kinds = {})
@@ -497,7 +497,7 @@ void CheckGetConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::Sta
     auto reply = runtime.GrabEdgeEventRethrow<TEvConsole::TEvGetConfigSubscriptionResponse>(handle);
     UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), code);
 
-    if (code == Ydb::StatusIds::SUCCESS) {
+    if (code == Ydb::StatusIds::SUCCESS) { 
         THashSet<ui32> k(kinds.begin(), kinds.end());
         UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetSubscription().GetId(), id);
         UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetSubscription().GetSubscriber().GetTabletId(), tabletId);
@@ -514,7 +514,7 @@ void CheckGetConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::Sta
     }
 }
 
-void CheckRemoveConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code, ui64 id)
+void CheckRemoveConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code, ui64 id) 
 {
     auto *event = new TEvConsole::TEvRemoveConfigSubscriptionRequest;
     event->Record.SetSubscriptionId(id);
@@ -525,7 +525,7 @@ void CheckRemoveConfigSubscription(TTenantTestRuntime &runtime, Ydb::StatusIds::
     UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), code);
 }
 
-void CheckRemoveConfigSubscriptions(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code,
+void CheckRemoveConfigSubscriptions(TTenantTestRuntime &runtime, Ydb::StatusIds::StatusCode code, 
                                     ui64 tabletId, TActorId serviceId)
 {
     auto *event = new TEvConsole::TEvRemoveConfigSubscriptionsRequest;
@@ -913,28 +913,28 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         tmp2.MutableConfig()->MutableLogConfig();
 
         // OK.
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_TENANT_POOL_1));
         AssignIds(id1, ITEM_DOMAIN_TENANT_POOL_1);
         // Error: action has Id specified.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_DOMAIN_TENANT_POOL_1));
         // Error: config doesn't match kind.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(tmp2));
         // Error: order conflict with existing item.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(tmp1));
         // Error: order conflict between new items.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_DOMAIN_LOG_1),
                        MakeAddAction(ITEM_DOMAIN_LOG_1));
         // OK.
-        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_TENANT_POOL_2));
         AssignIds(id2, ITEM_DOMAIN_TENANT_POOL_2);
         // Add several items. Order of ids should match items order.
-        auto id3 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id3 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1),
                                   MakeAddAction(ITEM_DOMAIN_LOG_2),
                                   MakeAddAction(ITEM_HOST12_LOG_1));
@@ -964,7 +964,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         TTenantTestRuntime runtime(DefaultConsoleTestConfig());
         InitializeTestConfigItems();
 
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1),
                                   MakeAddAction(ITEM_DOMAIN_LOG_2),
                                   MakeAddAction(ITEM_DOMAIN_TENANT_POOL_1));
@@ -972,50 +972,50 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
                   ITEM_DOMAIN_TENANT_POOL_1);
         // Error: kind mismatch.
         ITEM_DOMAIN_LOG_1.MutableConfig()->MutableTenantPoolConfig();
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1));
         ITEM_DOMAIN_LOG_1.MutableConfig()->ClearTenantPoolConfig();
         // Error: generation mismatch
         ITEM_DOMAIN_LOG_1.MutableId()->SetGeneration(2);
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1));
         ITEM_DOMAIN_LOG_1.MutableId()->SetGeneration(1);
         // Error: wrong id.
         ITEM_DOMAIN_LOG_1.MutableId()->SetId(987654321);
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1));
         ITEM_DOMAIN_LOG_1.MutableId()->SetId(id1[0]);
         // Error: cannot change kind
         ITEM_DOMAIN_TENANT_POOL_2.MutableId()->CopyFrom(ITEM_DOMAIN_LOG_1.GetId());
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_TENANT_POOL_2));
         ITEM_DOMAIN_TENANT_POOL_2.ClearId();
         // Error: double modification of the same item.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1),
                        MakeModifyAction(ITEM_DOMAIN_LOG_1));
         // Error: order confilict with existing item.
         ITEM_DOMAIN_LOG_1.SetOrder(2);
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1));
         // Error: order confilict with another modification.
         ITEM_DOMAIN_LOG_1.SetOrder(3);
         ITEM_DOMAIN_LOG_2.SetOrder(3);
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1),
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
         // Error: order conflict with added item.
         ITEM_DOMAIN_TENANT_POOL_1.SetOrder(2);
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_TENANT_POOL_1),
                        MakeAddAction(ITEM_DOMAIN_TENANT_POOL_2));
         // OK to modify order.
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_DOMAIN_TENANT_POOL_1));
         IncGeneration(ITEM_DOMAIN_TENANT_POOL_1);
         // OK to modify order and add with the previous value.
         ITEM_DOMAIN_TENANT_POOL_1.SetOrder(3);
-        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeModifyAction(ITEM_DOMAIN_TENANT_POOL_1),
                                   MakeAddAction(ITEM_DOMAIN_TENANT_POOL_2));
         AssignIds(id2, ITEM_DOMAIN_TENANT_POOL_2);
@@ -1023,31 +1023,31 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         // OK to switch orders.
         ITEM_DOMAIN_LOG_1.SetOrder(2);
         ITEM_DOMAIN_LOG_2.SetOrder(1);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1),
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
         IncGeneration(ITEM_DOMAIN_LOG_1, ITEM_DOMAIN_LOG_2);
         // OK to modify scope.
         ITEM_DOMAIN_LOG_1.MutableUsageScope()->MutableNodeFilter()->AddNodes(1);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1));
         IncGeneration(ITEM_DOMAIN_LOG_1);
         // Error: order conflict.
         ITEM_DOMAIN_LOG_2.MutableUsageScope()->MutableNodeFilter()->AddNodes(1);
         ITEM_DOMAIN_LOG_2.MutableUsageScope()->MutableNodeFilter()->AddNodes(2);
         ITEM_DOMAIN_LOG_2.SetOrder(2);
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
         // OK to switch order back because of different scope.
         ITEM_DOMAIN_LOG_2.ClearUsageScope();
         ITEM_DOMAIN_LOG_2.SetOrder(2);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
         IncGeneration(ITEM_DOMAIN_LOG_2);
         // OK to use disjoint scopes.
         ITEM_DOMAIN_LOG_2.MutableUsageScope()->MutableNodeFilter()->AddNodes(2);
         ITEM_DOMAIN_LOG_2.SetOrder(2);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
         IncGeneration(ITEM_DOMAIN_LOG_2);
         // Error: order conflicts in intersecting scopes.
@@ -1057,14 +1057,14 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         ITEM_DOMAIN_LOG_2.ClearUsageScope();
         ITEM_DOMAIN_LOG_2.MutableUsageScope()->MutableHostFilter()->AddHosts("host2");
         ITEM_DOMAIN_LOG_2.MutableUsageScope()->MutableHostFilter()->AddHosts("host3");
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1),
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
         // OK
         ITEM_DOMAIN_LOG_2.ClearUsageScope();
         ITEM_DOMAIN_LOG_2.MutableUsageScope()->MutableHostFilter()->AddHosts("host3");
         ITEM_DOMAIN_LOG_2.MutableUsageScope()->MutableHostFilter()->AddHosts("host4");
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1),
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
         IncGeneration(ITEM_DOMAIN_LOG_1, ITEM_DOMAIN_LOG_2);
@@ -1079,51 +1079,51 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         TTenantTestRuntime runtime(DefaultConsoleTestConfig());
         InitializeTestConfigItems();
 
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1),
                                   MakeAddAction(ITEM_DOMAIN_LOG_2),
                                   MakeAddAction(ITEM_DOMAIN_TENANT_POOL_1));
         AssignIds(id1, ITEM_DOMAIN_LOG_1, ITEM_DOMAIN_LOG_2,
                   ITEM_DOMAIN_TENANT_POOL_1);
         // OK remove
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeRemoveAction(ITEM_DOMAIN_LOG_1));
         // Error: wrong id
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeRemoveAction(ITEM_DOMAIN_LOG_1));
         // Error: wrong generation
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeRemoveAction(ITEM_DOMAIN_LOG_2.GetId().GetId(),
                                         ITEM_DOMAIN_LOG_2.GetId().GetGeneration() + 1));
         // OK to modify order
         ITEM_DOMAIN_LOG_2.SetOrder(1);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
         IncGeneration(ITEM_DOMAIN_LOG_2);
         // Error: conflicting order.
         ITEM_DOMAIN_LOG_1.ClearId();
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_DOMAIN_LOG_1));
         // OK to add item with conflicting order if conflict is removed
         // at the same time.
-        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeRemoveAction(ITEM_DOMAIN_LOG_2),
                                   MakeAddAction(ITEM_DOMAIN_LOG_1));
         AssignIds(id2, ITEM_DOMAIN_LOG_1);
         // Add item back.
         ITEM_DOMAIN_LOG_2.ClearId();
         ITEM_DOMAIN_LOG_2.SetOrder(2);
-        auto id3 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id3 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_2));
         AssignIds(id3, ITEM_DOMAIN_LOG_2);
         // Error: conflicting order.
         ITEM_DOMAIN_LOG_2.SetOrder(1);
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
 
         // OK to add item with conflicting order if conflict is removed
         // at the same time.
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeRemoveAction(ITEM_DOMAIN_LOG_1),
                        MakeModifyAction(ITEM_DOMAIN_LOG_2));
         IncGeneration(ITEM_DOMAIN_LOG_2);
@@ -1167,121 +1167,121 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
 
         // NODE ITEMS
         // Error: order conflict.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_NODE12_LOG_1),
                        MakeAddAction(ITEM_NODE23_LOG_1));
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_NODE23_LOG_1),
                        MakeAddAction(ITEM_NODE34_LOG_1));
         // OK
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_NODE12_LOG_1),
                                   MakeAddAction(ITEM_NODE34_LOG_1));
         AssignIds(id1, ITEM_NODE12_LOG_1, ITEM_NODE34_LOG_1);
         // Error: order conflict.
         ITEM_NODE12_LOG_1.MutableUsageScope()->MutableNodeFilter()->AddNodes(3);
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_NODE12_LOG_1));
         // OK
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeRemoveAction(ITEM_NODE34_LOG_1),
                        MakeModifyAction(ITEM_NODE12_LOG_1));
         IncGeneration(ITEM_NODE12_LOG_1);
 
         // HOST ITEMS
         // Error: order conflict.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_HOST12_LOG_1),
                        MakeAddAction(ITEM_HOST23_LOG_1));
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_HOST23_LOG_1),
                        MakeAddAction(ITEM_HOST34_LOG_1));
         // OK
-        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_HOST12_LOG_1),
                                   MakeAddAction(ITEM_HOST34_LOG_1));
         AssignIds(id2, ITEM_HOST12_LOG_1, ITEM_HOST34_LOG_1);
         // Error: order conflict.
         ITEM_HOST12_LOG_1.MutableUsageScope()->MutableHostFilter()->AddHosts("host3");
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_HOST12_LOG_1));
         // OK
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeRemoveAction(ITEM_HOST34_LOG_1),
                        MakeModifyAction(ITEM_HOST12_LOG_1));
         IncGeneration(ITEM_HOST12_LOG_1);
 
         // TENANT ITEMS
         // Error: order conflict.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_TENANT1_LOG_1),
                        MakeAddAction(ITEM_TENANT1_LOG_1));
         // OK
-        auto id3 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id3 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_TENANT1_LOG_1),
                                   MakeAddAction(ITEM_TENANT2_LOG_1));
         AssignIds(id3, ITEM_TENANT1_LOG_1, ITEM_TENANT2_LOG_1);
         // Error: order conflict.
         ITEM_TENANT2_LOG_1.MutableUsageScope()->MutableTenantAndNodeTypeFilter()->SetTenant("tenant1");
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_TENANT2_LOG_1));
         // Error: order conflict.
         ITEM_TENANT2_LOG_1.MutableUsageScope()->MutableTenantAndNodeTypeFilter()->SetTenant("tenant1");
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_TENANT2_LOG_1));
         // OK
         ITEM_TENANT1_LOG_1.SetOrder(2);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_TENANT1_LOG_1),
                        MakeModifyAction(ITEM_TENANT2_LOG_1));
         IncGeneration(ITEM_TENANT1_LOG_1, ITEM_TENANT2_LOG_1);
         // OK
         ITEM_TENANT1_LOG_1.SetOrder(1);
         ITEM_TENANT2_LOG_1.MutableUsageScope()->MutableTenantAndNodeTypeFilter()->SetTenant("tenant2");
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_TENANT1_LOG_1),
                        MakeModifyAction(ITEM_TENANT2_LOG_1));
         IncGeneration(ITEM_TENANT1_LOG_1, ITEM_TENANT2_LOG_1);
 
         // NODE TYPE ITEMS
         // Error: order conflict.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_TYPE1_LOG_1),
                        MakeAddAction(ITEM_TYPE1_LOG_1));
         // OK
-        auto id4 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id4 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_TYPE1_LOG_1),
                                   MakeAddAction(ITEM_TYPE2_LOG_1));
         AssignIds(id4, ITEM_TYPE1_LOG_1, ITEM_TYPE2_LOG_1);
         // Error: order conflict.
         ITEM_TYPE2_LOG_1.MutableUsageScope()->MutableTenantAndNodeTypeFilter()->SetNodeType("type1");
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_TYPE2_LOG_1));
         // Error: order conflict.
         ITEM_TYPE2_LOG_1.MutableUsageScope()->MutableTenantAndNodeTypeFilter()->SetNodeType("type1");
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_TYPE2_LOG_1));
         // OK
         ITEM_TYPE1_LOG_1.SetOrder(2);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_TYPE1_LOG_1),
                        MakeModifyAction(ITEM_TYPE2_LOG_1));
         IncGeneration(ITEM_TYPE1_LOG_1, ITEM_TYPE2_LOG_1);
         // OK
         ITEM_TYPE1_LOG_1.SetOrder(1);
         ITEM_TYPE2_LOG_1.MutableUsageScope()->MutableTenantAndNodeTypeFilter()->SetNodeType("type2");
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_TYPE1_LOG_1),
                        MakeModifyAction(ITEM_TYPE2_LOG_1));
         IncGeneration(ITEM_TYPE1_LOG_1, ITEM_TYPE2_LOG_1);
 
         // TENANT AND NODE TYPE ITEMS
         // Error: order conflict.
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_TENANT1_TYPE1_LOG_1),
                        MakeAddAction(ITEM_TENANT1_TYPE1_LOG_1));
         // OK
-        auto id5 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id5 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_TENANT1_TYPE1_LOG_1),
                                   MakeAddAction(ITEM_TENANT1_TYPE2_LOG_1),
                                   MakeAddAction(ITEM_TENANT2_TYPE1_LOG_1),
@@ -1290,17 +1290,17 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
                   ITEM_TENANT2_TYPE1_LOG_1, ITEM_TENANT2_TYPE2_LOG_1);
         // Error: order conflict
         ITEM_TENANT1_TYPE1_LOG_1.MutableUsageScope()->MutableTenantAndNodeTypeFilter()->SetNodeType("type2");
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeModifyAction(ITEM_TENANT1_TYPE1_LOG_1));
         // OK
         ITEM_TENANT1_TYPE2_LOG_1.SetOrder(2);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_TENANT1_TYPE1_LOG_1),
                        MakeModifyAction(ITEM_TENANT1_TYPE2_LOG_1));
         IncGeneration(ITEM_TENANT1_TYPE1_LOG_1, ITEM_TENANT1_TYPE2_LOG_1);
         // OK
         ITEM_TENANT1_TYPE2_LOG_1.SetOrder(1);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeRemoveAction(ITEM_TENANT1_TYPE1_LOG_1),
                        MakeModifyAction(ITEM_TENANT1_TYPE2_LOG_1));
         IncGeneration(ITEM_TENANT1_TYPE2_LOG_1);
@@ -1318,7 +1318,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         TTenantTestRuntime runtime(DefaultConsoleTestConfig());
         InitializeTestConfigItems();
 
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1),
                                   MakeAddAction(ITEM_DOMAIN_LOG_2),
                                   MakeAddAction(ITEM_DOMAIN_TENANT_POOL_1),
@@ -1341,7 +1341,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
 
         ITEM_NODE23_LOG_1.SetOrder(2);
         ITEM_HOST23_LOG_1.SetOrder(2);
-        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_NODE12_LOG_1), MakeAddAction(ITEM_NODE23_LOG_1),
                                   MakeAddAction(ITEM_NODE34_LOG_1), MakeAddAction(ITEM_HOST12_LOG_1),
                                   MakeAddAction(ITEM_HOST23_LOG_1), MakeAddAction(ITEM_HOST34_LOG_1),
@@ -1727,7 +1727,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
 
         ITEM_NODE23_LOG_1.SetOrder(2);
         ITEM_HOST23_LOG_1.SetOrder(2);
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1), MakeAddAction(ITEM_DOMAIN_LOG_2),
                                   MakeAddAction(ITEM_NODE12_LOG_1), MakeAddAction(ITEM_NODE23_LOG_1),
                                   MakeAddAction(ITEM_NODE34_LOG_1), MakeAddAction(ITEM_HOST12_LOG_1),
@@ -1814,7 +1814,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
 
         ITEM_DOMAIN_TENANT_POOL_1.MutableConfig()->MutableTenantPoolConfig();
 
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1), MakeAddAction(ITEM_DOMAIN_LOG_2),
                                   MakeAddAction(ITEM_DOMAIN_TENANT_POOL_1), MakeAddAction(ITEM_DOMAIN_TENANT_POOL_2),
                                   MakeAddAction(ITEM_NODE12_LOG_1), MakeAddAction(ITEM_NODE23_LOG_1),
@@ -1881,7 +1881,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         InitializeTestConfigItems();
 
         ITEM_DOMAIN_LOG_1.SetOrder(0);
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1));
         AssignIds(id1, ITEM_DOMAIN_LOG_1);
         ITEM_DOMAIN_LOG_1.SetOrder(10);
@@ -1889,7 +1889,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
                       ITEM_DOMAIN_LOG_1);
 
         ITEM_DOMAIN_LOG_2.SetOrder(0);
-        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_2));
         AssignIds(id2, ITEM_DOMAIN_LOG_2);
         ITEM_DOMAIN_LOG_2.SetOrder(20);
@@ -1897,7 +1897,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
                       ITEM_DOMAIN_LOG_1, ITEM_DOMAIN_LOG_2);
 
         ITEM_DOMAIN_LOG_1.SetOrder(0);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1));
         ITEM_DOMAIN_LOG_1.SetOrder(30);
         IncGeneration(ITEM_DOMAIN_LOG_1);
@@ -1906,7 +1906,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
 
         ITEM_DOMAIN_LOG_1.SetOrder(0);
         ITEM_DOMAIN_LOG_2.SetOrder(0);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeModifyAction(ITEM_DOMAIN_LOG_1), MakeModifyAction(ITEM_DOMAIN_LOG_2));
         ITEM_DOMAIN_LOG_1.SetOrder(10);
         ITEM_DOMAIN_LOG_2.SetOrder(20);
@@ -1915,7 +1915,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
                       ITEM_DOMAIN_LOG_1, ITEM_DOMAIN_LOG_2);
 
         ITEM_DOMAIN_LOG_2.SetOrder(0);
-        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                        MakeRemoveAction(ITEM_DOMAIN_LOG_1), MakeModifyAction(ITEM_DOMAIN_LOG_2));
         ITEM_DOMAIN_LOG_2.SetOrder(10);
         IncGeneration(ITEM_DOMAIN_LOG_2);
@@ -1925,7 +1925,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         ITEM_DOMAIN_LOG_1.SetOrder(0);
         ITEM_DOMAIN_LOG_1.ClearId();
         ITEM_DOMAIN_LOG_2.SetOrder(0);
-        auto id3 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id3 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1), MakeModifyAction(ITEM_DOMAIN_LOG_2));
         AssignIds(id3, ITEM_DOMAIN_LOG_1);
         ITEM_DOMAIN_LOG_1.SetOrder(10);
@@ -1943,7 +1943,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         ITEM_DOMAIN_LOG_1.MutableConfig()->MutableLogConfig();
         ITEM_DOMAIN_TENANT_POOL_1.ClearKind();
         ITEM_DOMAIN_TENANT_POOL_1.MutableConfig()->MutableTenantPoolConfig();
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1), MakeAddAction(ITEM_DOMAIN_TENANT_POOL_1));
         AssignIds(id1, ITEM_DOMAIN_LOG_1, ITEM_DOMAIN_TENANT_POOL_1);
         ITEM_DOMAIN_LOG_1.SetKind(NKikimrConsole::TConfigItem::LogConfigItem);
@@ -1955,7 +1955,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         ITEM_DOMAIN_LOG_2.ClearKind();
         ITEM_DOMAIN_LOG_2.MutableConfig()->MutableLogConfig();
         ITEM_DOMAIN_LOG_2.MutableConfig()->MutableTenantPoolConfig();
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_DOMAIN_LOG_2));
     }
 
@@ -1967,7 +1967,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         ITEM_DOMAIN_LOG_1.MutableConfig()->MutableLogConfig();
         ITEM_DOMAIN_LOG_1.MutableConfig()->MutableTenantPoolConfig();
         ITEM_DOMAIN_LOG_1.SetCookie("cookie3");
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1, true));
         AssignIds(id1, ITEM_DOMAIN_LOG_1, ITEM_DOMAIN_TENANT_POOL_1);
         ITEM_DOMAIN_LOG_1.SetKind(NKikimrConsole::TConfigItem::LogConfigItem);
@@ -1979,7 +1979,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
 
         ITEM_NODE12_LOG_1.ClearKind();
         ITEM_NODE12_LOG_1.MutableConfig()->MutableLogConfig();
-        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id2 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_NODE12_LOG_1, true));
         AssignIds(id2, ITEM_NODE12_LOG_1);
         ITEM_NODE12_LOG_1.SetKind(NKikimrConsole::TConfigItem::LogConfigItem);
@@ -1990,7 +1990,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigTests) {
         // Cannot split empty config.
         ITEM_DOMAIN_LOG_2.ClearKind();
         ITEM_DOMAIN_LOG_2.ClearConfig();
-        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckConfigure(runtime, Ydb::StatusIds::BAD_REQUEST, 
                        MakeAddAction(ITEM_DOMAIN_LOG_2, true));
     }
 
@@ -2457,11 +2457,11 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
 
         // OK subscription for tablet
         ui32 nodeId = runtime.GetNodeId(0);
-        ui64 id1 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id1 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               1, "host1", "tenant-1", "type1",
                                               1, TActorId(), {{1, 2, 3}});
         // OK subscription for service
-        ui64 id2 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id2 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               2, "host2", "tenant-2", "type2",
                                               0, TActorId(nodeId, "service"), {{4, 5, 6}});
 
@@ -2471,34 +2471,34 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
         runtime.DispatchEvents(options);
 
         // OK subscription for service
-        ui64 id3 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id3 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               3, "host3", "tenant-3", "type3",
                                               0, TActorId(nodeId, "service"), {{1, 1, 2}});
 
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id1,
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id1, 
                                    1, "host1", "tenant-1", "type1",
                                    1, TActorId(), {{1, 2, 3}});
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id2,
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id2, 
                                    2, "host2", "tenant-2", "type2",
                                    0, TActorId(nodeId, "service"), {{4, 5, 6}});
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id3,
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id3, 
                                    3, "host3", "tenant-3", "type3",
                                    0, TActorId(nodeId, "service"), {{1, 2}});
 
         // non-zero subscription id
-        CheckAddConfigSubscription(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckAddConfigSubscription(runtime, Ydb::StatusIds::BAD_REQUEST, 
                                    1, "host1", "tenant-1", "type1",
                                    1, TActorId(), {{1, 2, 3}}, 1);
         // no subscriber
-        CheckAddConfigSubscription(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckAddConfigSubscription(runtime, Ydb::StatusIds::BAD_REQUEST, 
                                    1, "host1", "tenant-1", "type1",
                                    0, TActorId(), {{1, 2, 3}});
         // wrong service id
-        CheckAddConfigSubscription(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckAddConfigSubscription(runtime, Ydb::StatusIds::BAD_REQUEST, 
                                    1, "host1", "tenant-1", "type1",
                                    0, TActorId(1, 0, 0, 0), {{1, 2, 3}});
         // no kinds
-        CheckAddConfigSubscription(runtime, Ydb::StatusIds::BAD_REQUEST,
+        CheckAddConfigSubscription(runtime, Ydb::StatusIds::BAD_REQUEST, 
                                    1, "host1", "tenant-1", "type1",
                                    1, TActorId(), {});
     }
@@ -2508,36 +2508,36 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
 
         // OK subscription for tablet
         ui32 nodeId = runtime.GetNodeId(0);
-        ui64 id1 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id1 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               1, "host1", "tenant-1", "type1",
                                               1, TActorId(), {{1, 2, 3}});
         // OK subscription for tablet
-        ui64 id2 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id2 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               2, "host1", "tenant-1", "type1",
                                               1, TActorId(), {{1, 2, 3}});
         // OK subscription for service
-        ui64 id3 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id3 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               2, "host2", "tenant-2", "type2",
                                               0, TActorId(nodeId, "service"), {{4, 5, 6}});
 
-        CheckRemoveConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id2);
-        CheckRemoveConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id2);
+        CheckRemoveConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id2); 
+        CheckRemoveConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id2); 
 
         runtime.Register(CreateTabletKiller(MakeConsoleID(0)));
         TDispatchOptions options;
         options.FinalEvents.emplace_back(&IsTabletActiveEvent, 1);
         runtime.DispatchEvents(options);
 
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id1,
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id1, 
                                    1, "host1", "tenant-1", "type1",
                                    1, TActorId(), {{1, 2, 3}});
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id2);
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id3,
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id2); 
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id3, 
                                    2, "host2", "tenant-2", "type2",
                                    0, TActorId(nodeId, "service"), {{4, 5, 6}});
 
-        CheckRemoveConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id1);
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id1);
+        CheckRemoveConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id1); 
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id1); 
     }
 
     Y_UNIT_TEST(TestRemoveConfigSubscriptions) {
@@ -2545,29 +2545,29 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
 
         // OK subscription for tablet
         ui32 nodeId = runtime.GetNodeId(0);
-        ui64 id1 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id1 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               1, "host1", "tenant-1", "type1",
                                               1, TActorId(), {{1, 2, 3}});
         // OK subscription for tablet
-        ui64 id2 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id2 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               2, "host1", "tenant-1", "type1",
                                               1, TActorId(), {{1, 2, 3}});
         // OK subscription for service
-        ui64 id3 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id3 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               2, "host2", "tenant-2", "type2",
                                               0, TActorId(nodeId, "service"), {{4, 5, 6}});
         // OK subscription for service
-        ui64 id4 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id4 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               3, "host2", "tenant-2", "type2",
                                               0, TActorId(nodeId, "service"), {{4, 5, 6}});
 
-        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                        1, TActorId());
-        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                        1, TActorId());
-        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                        2, TActorId());
-        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                        0, TActorId());
 
         runtime.Register(CreateTabletKiller(MakeConsoleID(0)));
@@ -2575,20 +2575,20 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
         options.FinalEvents.emplace_back(&IsTabletActiveEvent, 1);
         runtime.DispatchEvents(options);
 
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id1);
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id2);
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id3,
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id1); 
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id2); 
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id3, 
                                    2, "host2", "tenant-2", "type2",
                                    0, TActorId(nodeId, "service"), {{4, 5, 6}});
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id4,
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id4, 
                                    3, "host2", "tenant-2", "type2",
                                    0, TActorId(nodeId, "service"), {{4, 5, 6}});
 
-        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                        0, TActorId(nodeId, "service"));
 
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id3);
-        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id4);
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id3); 
+        CheckGetConfigSubscription(runtime, Ydb::StatusIds::NOT_FOUND, id4); 
     }
 
     Y_UNIT_TEST(TestListConfigSubscriptions) {
@@ -2596,19 +2596,19 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
 
         // OK subscription for tablet
         ui32 nodeId = runtime.GetNodeId(0);
-        ui64 id1 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id1 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               1, "host1", "tenant-1", "type1",
                                               1, TActorId(), {{1, 2}});
         // OK subscription for tablet
-        ui64 id2 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id2 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               1, "host1", "tenant-1", "type1",
                                               1, TActorId(), {{3, 4}});
         // OK subscription for service
-        ui64 id3 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id3 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               2, "host2", "tenant-2", "type2",
                                               0, TActorId(nodeId, "service"), {{4, 5}});
         // OK subscription for service
-        ui64 id4 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id4 = CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                               2, "host2", "tenant-2", "type2",
                                               0, TActorId(nodeId, "service"), {{6, 7}});
 
@@ -2642,10 +2642,10 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
         CheckListConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 0, TActorId(nodeId + 1, "service"));
 
         // Remove 1 2
-        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        CheckRemoveConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                        1, TActorId());
         // Remove 3
-        CheckRemoveConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id3);
+        CheckRemoveConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, id3); 
 
         // Empty list
         CheckListConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 1, TActorId());
@@ -2663,10 +2663,10 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
         TTenantTestRuntime runtime(DefaultConsoleTestConfig());
 
         ui32 nodeId = runtime.GetNodeId(0);
-        ui64 id1 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id1 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                                    1, "host1", "tenant-1", "type1",
                                                    1, TActorId(), {{1, 2, 3}});
-        ui64 id2 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id2 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                                    2, "host2", "tenant-2", "type2",
                                                    0, TActorId(nodeId, "service"), {{4, 5, 6}});
 
@@ -2677,18 +2677,18 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
                                      id2, 2, "host2", "tenant-2", "type2",
                                      0, TActorId(nodeId, "service"), TVector<ui32>({4, 5, 6}));
 
-        CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                    1, "host1", "tenant-1", "type1",
                                    1, TActorId(), {{1, 2}});
-        CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                    2, "host2", "tenant-2", "type2",
                                    0, TActorId(nodeId, "service"), {{4, 5}});
 
-        ui64 id5 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id5 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                                    1, "host1", "tenant-1", "type1",
                                                    1, TActorId(), {{1, 2, 3}});
         UNIT_ASSERT_VALUES_EQUAL(id1, id5);
-        ui64 id6 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id6 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                                    2, "host2", "tenant-2", "type2",
                                                    0, TActorId(nodeId, "service"), {{4, 5, 6}});
         UNIT_ASSERT_VALUES_EQUAL(id2, id6);
@@ -2705,11 +2705,11 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
                                      id2, 2, "host2", "tenant-2", "type2",
                                      0, TActorId(nodeId, "service"), TVector<ui32>({4, 5, 6}));
 
-        ui64 id7 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id7 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                                    1, "host1", "tenant-1", "type1",
                                                    1, TActorId(), {{1, 2}});
         UNIT_ASSERT(id1 != id7);
-        ui64 id8 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS,
+        ui64 id8 = CheckReplaceConfigSubscriptions(runtime, Ydb::StatusIds::SUCCESS, 
                                                    2, "host2", "tenant-2", "type2",
                                                    0, TActorId(nodeId, "service"), {{4, 5}});
         UNIT_ASSERT(id2 != id8);
@@ -2736,13 +2736,13 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
         else
             tabletId = CONFIG_PROXY_TABLET_ID;
 
-        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS,
+        auto id1 = CheckConfigure(runtime, Ydb::StatusIds::SUCCESS, 
                                   MakeAddAction(ITEM_DOMAIN_LOG_1),
                                   MakeAddAction(ITEM_DOMAIN_LOG_2));
         AssignIds(id1, ITEM_DOMAIN_LOG_1, ITEM_DOMAIN_LOG_2);
 
         // New subscription should cause notification.
-        CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS,
+        CheckAddConfigSubscription(runtime, Ydb::StatusIds::SUCCESS, 
                                    1, "host1", "tenant1", "type1",
                                    tabletId, serviceId,
                                    TVector<ui32>({(ui32)NKikimrConsole::TConfigItem::LogConfigItem}));
diff --git a/ydb/core/cms/console/console_ut_tenants.cpp b/ydb/core/cms/console/console_ut_tenants.cpp
index 57e4820af7..442ee64f4e 100644
--- a/ydb/core/cms/console/console_ut_tenants.cpp
+++ b/ydb/core/cms/console/console_ut_tenants.cpp
@@ -161,7 +161,7 @@ void CheckAlterTenantSlots(TTenantTestRuntime &runtime, const TString &path,
 }
 
 void CheckAlterRegisteredUnits(TTenantTestRuntime &runtime, const TString &path,
-                               Ydb::StatusIds::StatusCode code,
+                               Ydb::StatusIds::StatusCode code, 
                                TVector<TUnitRegistration> registerUnits,
                                TVector<TUnitRegistration> deregisterUnits)
 {
@@ -206,7 +206,7 @@ void CheckAlterTenantPools(TTenantTestRuntime &runtime,
     TAutoPtr<IEventHandle> handle;
     runtime.SendToConsole(event);
 
-    if (hasModifications && code == Ydb::StatusIds::SUCCESS) {
+    if (hasModifications && code == Ydb::StatusIds::SUCCESS) { 
         TDispatchOptions options;
         options.FinalEvents.emplace_back(NConsole::TTenantsManager::TEvPrivate::EvPoolAllocated);
         runtime.DispatchEvents(options);
@@ -774,19 +774,19 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
 
     void RunTestCreateTenantWrongComputationalUnit(TTenantTestRuntime& runtime) {
         // Unknown unit kind
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST, 
                           {{"hdd", 1}, {"hdd-1", 2}},
                           "wrong", ZONE1, 3);
         // Unknown zone
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST, 
                           {{"hdd", 1}, {"hdd-1", 2}},
                           SLOT1_TYPE, "unknown-zone", 3);
         // Disallowed zone
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST, 
                           {{"hdd", 1}, {"hdd-1", 2}},
                           SLOT1_TYPE, ZONE2, 3);
         // OK
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}, {"hdd-1", 2}},
                           SLOT1_TYPE, ZONE1, 3);
     }
@@ -802,25 +802,25 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
     }
 
     void RunTestCreateTenantAlreadyExists(TTenantTestRuntime& runtime) {
-        CheckCreateTenant(runtime, "/dc-1/users/tenant-1", Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, "/dc-1/users/tenant-1", Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 3,
                           SLOT2_TYPE, ZONE1, 2,
                           SLOT3_TYPE, ZONE1, 1);
 
-        CheckCreateTenant(runtime, "/dc-1/users/tenant-1", Ydb::StatusIds::ALREADY_EXISTS,
+        CheckCreateTenant(runtime, "/dc-1/users/tenant-1", Ydb::StatusIds::ALREADY_EXISTS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 3,
                           SLOT2_TYPE, ZONE1, 2,
                           SLOT3_TYPE, ZONE1, 1);
 
-        CheckCreateTenant(runtime, "dc-1/users/tenant-1", Ydb::StatusIds::ALREADY_EXISTS,
+        CheckCreateTenant(runtime, "dc-1/users/tenant-1", Ydb::StatusIds::ALREADY_EXISTS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 3,
                           SLOT2_TYPE, ZONE1, 2,
                           SLOT3_TYPE, ZONE1, 1);
 
-        CheckCreateTenant(runtime, "//dc-1/users///tenant-1/", Ydb::StatusIds::ALREADY_EXISTS,
+        CheckCreateTenant(runtime, "//dc-1/users///tenant-1/", Ydb::StatusIds::ALREADY_EXISTS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 3,
                           SLOT2_TYPE, ZONE1, 2,
@@ -843,7 +843,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
     }
 
     void RunTestGetUnknownTenantStatus(TTenantTestRuntime& runtime) {
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::NOT_FOUND,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::NOT_FOUND, 
                           Ydb::Cms::GetDatabaseStatusResult::STATE_UNSPECIFIED, {}, {});
 
         CheckCounter(runtime, {}, TTenantsManager::COUNTER_STATUS_REQUESTS, 1);
@@ -871,14 +871,14 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
                                       runtime.Sender,
                                       new TEvents::TEvPoisonPill));
 
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT2_TYPE, ZONE_ANY, 8);
 
         runtime.WaitForHiveState({{{DOMAIN1_NAME, 5, 5, 5},
                                    {TENANT1_1_NAME, 10, 10, 10}}});
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::RUNNING, {{"hdd", 1, 1}}, {},
                           SLOT2_TYPE, ZONE_ANY, 8, 5);
 
@@ -890,7 +890,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         runtime.WaitForHiveState({{{DOMAIN1_NAME, 8, 8, 8},
                                    {TENANT1_1_NAME, 16, 16, 16}}});
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::RUNNING, {{"hdd", 1, 1}}, {},
                           SLOT2_TYPE, ZONE_ANY, 8, 8);
 
@@ -946,13 +946,13 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         runtime.WaitForHiveState({{{DOMAIN1_NAME, 8, 8, 8},
                                    {TENANT1_1_NAME, 45, 45, 45}}});
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::RUNNING, {{"hdd", 1, 1}}, {},
                           SLOT1_TYPE, ZONE1, 5, 5,
                           SLOT2_TYPE, ZONE1, 8, 8,
                           SLOT3_TYPE, ZONE1, 10, 8);
 
-        CheckAlterTenantSlots(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterTenantSlots(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                               {{ {SLOT1_TYPE, ZONE1, 5} }},
                               {{ {SLOT2_TYPE, ZONE1, 3},
                                 {SLOT3_TYPE, ZONE1, 7} }});
@@ -960,13 +960,13 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         runtime.WaitForHiveState({{{DOMAIN1_NAME, 8, 8, 8},
                                    {TENANT1_1_NAME, 27, 27, 27}}});
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::RUNNING, {{"hdd", 1, 1}}, {},
                           SLOT1_TYPE, ZONE1, 10, 8,
                           SLOT2_TYPE, ZONE1, 5, 5,
                           SLOT3_TYPE, ZONE1, 3, 3);
 
-        CheckAlterTenantSlots(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterTenantSlots(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                               {},
                               {{ {SLOT1_TYPE, ZONE1, 10},
                                 {SLOT2_TYPE, ZONE1, 5},
@@ -974,10 +974,10 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
 
         runtime.WaitForHiveState({{{DOMAIN1_NAME, 8, 8, 8}}});
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::RUNNING, {{"hdd", 1, 1}}, {});
 
-        CheckAlterTenantSlots(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterTenantSlots(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                               {{ {SLOT1_TYPE, ZONE1, 1},
                                 {SLOT2_TYPE, ZONE1, 2},
                                 {SLOT3_TYPE, ZONE1, 3} }},
@@ -986,7 +986,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         runtime.WaitForHiveState({{{DOMAIN1_NAME, 8, 8, 8},
                                    {TENANT1_1_NAME, 14, 14, 14}}});
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::RUNNING, {{"hdd", 1, 1}}, {},
                           SLOT1_TYPE, ZONE1, 1, 1,
                           SLOT2_TYPE, ZONE1, 2, 2,
@@ -1015,14 +1015,14 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         CheckCounter(runtime, {{ {"kind", "hdd-1"} }}, TTenantsManager::COUNTER_REQUESTED_STORAGE_UNITS, 3);
         CheckCounter(runtime, {{ {"kind", "hdd-1"} }}, TTenantsManager::COUNTER_ALLOCATED_STORAGE_UNITS, 3);
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::PENDING_RESOURCES,
                           {{"hdd", 1, 1}, {"hdd-1", 3, 3}}, {});
 
         TVector<TAutoPtr<IEventHandle>> captured;
         runtime.SetObserverFunc(CatchPoolEvent(captured));
 
-        CheckAlterTenantPools(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterTenantPools(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                               {{"hdd", 2}, {"hdd-1", 3}}, {});
 
         runtime.SetObserverFunc(TTestActorRuntime::DefaultObserverFunc);
@@ -1034,7 +1034,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
 
         RestartConsole(runtime);
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::PENDING_RESOURCES,
                           {{"hdd", 3, 3}, {"hdd-1", 6, 6}}, {});
 
@@ -1043,10 +1043,10 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         CheckCounter(runtime, {{ {"kind", "hdd-1"} }}, TTenantsManager::COUNTER_REQUESTED_STORAGE_UNITS, 6);
         CheckCounter(runtime, {{ {"kind", "hdd-1"} }}, TTenantsManager::COUNTER_ALLOCATED_STORAGE_UNITS, 6);
 
-        CheckAlterTenantPools(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterTenantPools(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                               {}, false);
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::PENDING_RESOURCES,
                           {{"hdd", 3, 3}, {"hdd-1", 6, 6}}, {});
 
@@ -1119,10 +1119,10 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
                           SLOT1_TYPE, ZONE1, 1, 1);
 
         // Wrong unit kind.
-        CheckAlterTenantPools(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckAlterTenantPools(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST, 
                               {{"unknown", 1}});
         // Zero pool size.
-        CheckAlterTenantPools(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckAlterTenantPools(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST, 
                               {{"hdd-3", 0}});
 
         CheckCounter(runtime, {}, TTenantsManager::COUNTER_ALTER_REQUESTS, 5);
@@ -1212,19 +1212,19 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
     }
 
     void RunTestListTenants(TTenantTestRuntime& runtime) {
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 1);
-        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 1);
-        CheckCreateTenant(runtime, TENANT1_3_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_3_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 1);
-        CheckCreateTenant(runtime, TENANT1_4_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_4_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 1);
-        CheckCreateTenant(runtime, TENANT1_5_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_5_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 1);
 
@@ -1254,19 +1254,19 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
     Y_UNIT_TEST(TestSetDefaultStorageUnitsQuota) {
         TTenantTestRuntime runtime(DefaultConsoleTestConfig());
 
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 3}},
                           SLOT1_TYPE, ZONE1, 1);
 
         NKikimrConsole::TConfig config = GetCurrentConfig(runtime);
         config.MutableTenantsConfig()->SetDefaultStorageUnitsQuota(2);
-        CheckSetConfig(runtime, config, Ydb::StatusIds::SUCCESS);
+        CheckSetConfig(runtime, config, Ydb::StatusIds::SUCCESS); 
 
-        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 2}},
                           SLOT1_TYPE, ZONE1, 1);
 
-        CheckCreateTenant(runtime, TENANT1_3_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckCreateTenant(runtime, TENANT1_3_NAME, Ydb::StatusIds::BAD_REQUEST, 
                           {{"hdd", 3}},
                           SLOT1_TYPE, ZONE1, 1);
     }
@@ -1274,19 +1274,19 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
     Y_UNIT_TEST(TestSetDefaultComputationalUnitsQuota) {
         TTenantTestRuntime runtime(DefaultConsoleTestConfig());
 
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 3);
 
         NKikimrConsole::TConfig config = GetCurrentConfig(runtime);
         config.MutableTenantsConfig()->SetDefaultComputationalUnitsQuota(2);
-        CheckSetConfig(runtime, config, Ydb::StatusIds::SUCCESS);
+        CheckSetConfig(runtime, config, Ydb::StatusIds::SUCCESS); 
 
-        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 2);
 
-        CheckCreateTenant(runtime, TENANT1_3_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckCreateTenant(runtime, TENANT1_3_NAME, Ydb::StatusIds::BAD_REQUEST, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 3);
     }
@@ -1300,38 +1300,38 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         NKikimrConsole::TConfig config1 = config;
         auto kind1 = config1.MutableTenantsConfig()->AddAvailabilityZoneKinds();
         kind1->CopyFrom(config1.GetTenantsConfig().GetAvailabilityZoneKinds(0));
-        CheckSetConfig(runtime, config1, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config1, Ydb::StatusIds::BAD_REQUEST); 
         // Repeated zone kind set.
         NKikimrConsole::TConfig config2 = config;
         auto set2 = config2.MutableTenantsConfig()->AddAvailabilityZoneSets();
         set2->CopyFrom(config2.GetTenantsConfig().GetAvailabilityZoneSets(0));
-        CheckSetConfig(runtime, config2, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config2, Ydb::StatusIds::BAD_REQUEST); 
         // Repeated computational unit kind.
         NKikimrConsole::TConfig config3 = config;
         auto kind3 = config3.MutableTenantsConfig()->AddComputationalUnitKinds();
         kind3->CopyFrom(config1.GetTenantsConfig().GetComputationalUnitKinds(0));
-        CheckSetConfig(runtime, config3, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config3, Ydb::StatusIds::BAD_REQUEST); 
         // Unknown zone kind used.
         NKikimrConsole::TConfig config4 = config;
         config4.MutableTenantsConfig()->MutableAvailabilityZoneSets(0)->AddZoneKinds("unknown");
-        CheckSetConfig(runtime, config4, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config4, Ydb::StatusIds::BAD_REQUEST); 
         // Unknown zone set.
         NKikimrConsole::TConfig config5 = config;
         config5.MutableTenantsConfig()->MutableComputationalUnitKinds(0)->SetAvailabilityZoneSet("unknown");
-        CheckSetConfig(runtime, config5, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config5, Ydb::StatusIds::BAD_REQUEST); 
         // Empty computational unit kind.
         NKikimrConsole::TConfig config6 = config;
         config6.MutableTenantsConfig()->MutableComputationalUnitKinds(0)->ClearTenantSlotType();
-        CheckSetConfig(runtime, config6, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config6, Ydb::StatusIds::BAD_REQUEST); 
 
-        CheckSetConfig(runtime, config, Ydb::StatusIds::SUCCESS);
+        CheckSetConfig(runtime, config, Ydb::StatusIds::SUCCESS); 
         CheckSetConfig(runtime, {}, Ydb::StatusIds::SUCCESS);
     }
 
     Y_UNIT_TEST(TestModifyUsedZoneKind) {
         TTenantTestRuntime runtime(DefaultConsoleTestConfig());
 
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 1);
 
@@ -1343,7 +1343,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
             }
         }
         // Cannot modify used zone1
-        CheckSetConfig(runtime, config1, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config1, Ydb::StatusIds::BAD_REQUEST); 
 
         NKikimrConsole::TConfig config2 = GetCurrentConfig(runtime);
         for (ui64 i = 0; i < config2.GetTenantsConfig().AvailabilityZoneKindsSize(); ++i) {
@@ -1353,9 +1353,9 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
             }
         }
         // OK to modify unused zone2
-        CheckSetConfig(runtime, config2, Ydb::StatusIds::SUCCESS);
+        CheckSetConfig(runtime, config2, Ydb::StatusIds::SUCCESS); 
 
-        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT2_TYPE, ZONE2, 1);
 
@@ -1366,20 +1366,20 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
             }
         }
         // Now zone2 is also used.
-        CheckSetConfig(runtime, config2, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config2, Ydb::StatusIds::BAD_REQUEST); 
 
-        CheckAlterTenantSlots(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterTenantSlots(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS, 
                               {},
                               {{ {SLOT2_TYPE, ZONE2, 1} }});
 
         // Now zone2 is unused again.
-        CheckSetConfig(runtime, config2, Ydb::StatusIds::SUCCESS);
+        CheckSetConfig(runtime, config2, Ydb::StatusIds::SUCCESS); 
     }
 
     Y_UNIT_TEST(TestSetConfig) {
         TTenantTestRuntime runtime(DefaultConsoleTestConfig());
 
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 1);
 
@@ -1391,7 +1391,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
             }
         }
         // Cannot modify tenant slot type for used SLOT1_TYPE
-        CheckSetConfig(runtime, config1, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config1, Ydb::StatusIds::BAD_REQUEST); 
 
         NKikimrConsole::TConfig config2 = GetCurrentConfig(runtime);
         for (ui64 i = 0; i < config2.GetTenantsConfig().ComputationalUnitKindsSize(); ++i) {
@@ -1401,7 +1401,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
             }
         }
         // Cannot remove used zone1 from allowed availability zones of SLOT1_TYPE
-        CheckSetConfig(runtime, config2, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config2, Ydb::StatusIds::BAD_REQUEST); 
 
         // OK to add new allowed zones for SLOT1_TYPE
         NKikimrConsole::TConfig config3 = GetCurrentConfig(runtime);
@@ -1411,7 +1411,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
                 break;
             }
         }
-        CheckSetConfig(runtime, config3, Ydb::StatusIds::SUCCESS);
+        CheckSetConfig(runtime, config3, Ydb::StatusIds::SUCCESS); 
 
         NKikimrConsole::TConfig config4 = GetCurrentConfig(runtime);
         for (ui64 i = 0; i < config4.GetTenantsConfig().ComputationalUnitKindsSize(); ++i) {
@@ -1422,9 +1422,9 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
             }
         }
         // OK to modify unused SLOT2_TYPE
-        CheckSetConfig(runtime, config4, Ydb::StatusIds::SUCCESS);
+        CheckSetConfig(runtime, config4, Ydb::StatusIds::SUCCESS); 
 
-        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}},
                           SLOT2_TYPE, ZONE1, 1);
 
@@ -1436,14 +1436,14 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
             }
         }
         // Now SLOT2_TYPE is also used.
-        CheckSetConfig(runtime, config4, Ydb::StatusIds::BAD_REQUEST);
+        CheckSetConfig(runtime, config4, Ydb::StatusIds::BAD_REQUEST); 
 
-        CheckAlterTenantSlots(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterTenantSlots(runtime, TENANT1_2_NAME, Ydb::StatusIds::SUCCESS, 
                               {},
                               {{ {SLOT2_TYPE, ZONE1, 1} }});
 
         // Now zone2 is unused again.
-        CheckSetConfig(runtime, config4, Ydb::StatusIds::SUCCESS);
+        CheckSetConfig(runtime, config4, Ydb::StatusIds::SUCCESS); 
     }
 
     Y_UNIT_TEST(TestMergeConfig) {
@@ -1513,7 +1513,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
     }
 
     void RunTestRemoveTenant(TTenantTestRuntime& runtime) {
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}, {"hdd-1", 2}},
                           SLOT1_TYPE, ZONE1, 3,
                           SLOT2_TYPE, ZONE1, 2,
@@ -1542,9 +1542,9 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
                           SLOT2_TYPE, ZONE1, 2, 2,
                           SLOT3_TYPE, ZONE1, 1, 1);
 
-        CheckRemoveTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS);
+        CheckRemoveTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS); 
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::NOT_FOUND,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::NOT_FOUND, 
                           Ydb::Cms::GetDatabaseStatusResult::STATE_UNSPECIFIED, {}, {});
 
         CheckRemoveTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::NOT_FOUND);
@@ -1557,7 +1557,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
 
         RestartConsole(runtime);
 
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}, {"hdd-1", 2}},
                           SLOT1_TYPE, ZONE1, 3,
                           SLOT2_TYPE, ZONE1, 2,
@@ -1573,7 +1573,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
                           SLOT2_TYPE, ZONE1, 2, 2,
                           SLOT3_TYPE, ZONE1, 1, 1);
 
-        CheckRemoveTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS);
+        CheckRemoveTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS); 
 
         // Restart to check we don't load any garbage for removed tenant.
         RestartConsole(runtime);
@@ -1667,7 +1667,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
     }
 
     void RunTestCreateSubSubDomain(TTenantTestRuntime& runtime) {
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}, {"hdd-1", 2}},
                           SLOT1_TYPE, ZONE1, 3,
                           SLOT2_TYPE, ZONE1, 2,
@@ -1676,7 +1676,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         runtime.WaitForHiveState({{{DOMAIN1_NAME, 8, 8, 8},
                                    {TENANT1_1_NAME, 10, 10, 10}}});
 
-        CheckCreateTenant(runtime, TENANT1_1_NAME + "/sub", Ydb::StatusIds::GENERIC_ERROR,
+        CheckCreateTenant(runtime, TENANT1_1_NAME + "/sub", Ydb::StatusIds::GENERIC_ERROR, 
                           {{"hdd", 1}},
                           SLOT1_TYPE, ZONE1, 1,
                           SLOT2_TYPE, ZONE1, 2,
@@ -1694,9 +1694,9 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         CheckCounter(runtime, {{ {"kind", "hdd-1"} }}, TTenantsManager::COUNTER_ALLOCATED_STORAGE_UNITS, 2);
         CheckCounter(runtime, {}, TTenantsManager::COUNTER_CONFIGURE_SUBDOMAIN_FAILED, 1);
 
-        CheckRemoveTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS);
+        CheckRemoveTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS); 
 
-        CheckCreateTenant(runtime, TENANT1_1_NAME + "/sub", Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME + "/sub", Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 2}},
                           SLOT1_TYPE, ZONE1, 1,
                           SLOT2_TYPE, ZONE1, 2,
@@ -1725,7 +1725,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
     Y_UNIT_TEST(TestDefaultAvailabilityZone) {
         TTenantTestRuntime runtime(DefaultConsoleTestConfig());
 
-        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckCreateTenant(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           {{"hdd", 1}, {"hdd-1", 2}},
                           SLOT1_TYPE, ZONE1, 3,
                           SLOT2_TYPE, ZONE1, 2,
@@ -1738,7 +1738,7 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
 
         RestartConsole(runtime);
 
-        CheckAlterTenantSlots(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterTenantSlots(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                               {{ {SLOT1_TYPE, "", 1},
                                  {SLOT2_TYPE, "", 2},
                                  {SLOT3_TYPE, "", 3} }},
@@ -1760,12 +1760,12 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
                           Ydb::Cms::GetDatabaseStatusResult::PENDING_RESOURCES,
                           {{"hdd", 1, 1}, {"hdd-1", 1, 1}}, {});
 
-        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                                   {{ {"host1", 1, "kind1"},
                                      {"host2", 2, "kind2"} }},
                                   {});
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::PENDING_RESOURCES,
                           {{"hdd", 1, 1}, {"hdd-1", 1, 1}},
                           {{"host1", 1, "kind1"}, {"host2", 2, "kind2"}});
@@ -1773,14 +1773,14 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
         CheckCounter(runtime, {{ {"kind", "kind1"} }}, TTenantsManager::COUNTER_REGISTERED_UNITS, 1);
         CheckCounter(runtime, {{ {"kind", "kind2"} }}, TTenantsManager::COUNTER_REGISTERED_UNITS, 1);
 
-        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                                   {{ {"host3", 3, "kind2"} }},
                                   {{ {"host1", 1, ""} }});
 
         CheckCounter(runtime, {{ {"kind", "kind1"} }}, TTenantsManager::COUNTER_REGISTERED_UNITS, 0);
         CheckCounter(runtime, {{ {"kind", "kind2"} }}, TTenantsManager::COUNTER_REGISTERED_UNITS, 2);
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::PENDING_RESOURCES,
                           {{"hdd", 1, 1}, {"hdd-1", 1, 1}},
                           {{"host2", 2, "kind2"}, {"host3", 3, "kind2"}});
@@ -1845,24 +1845,24 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
 
         RestartConsole(runtime);
 
-        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST, 
                                   {},
                                   {{ {"host1", 1, "kind1"} }});
 
-        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST, 
                                   {{ {"host2", 2, "kind1"} }},
                                   {});
 
-        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                                   {{ {"host2", 2, "kind2"} }},
                                   {});
 
-        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST,
+        CheckAlterRegisteredUnits(runtime, TENANT1_1_NAME, Ydb::StatusIds::BAD_REQUEST, 
                                   {{ {"host1", 1, "kind1"},
                                      {"host1", 1, "kind2"} }},
                                   {});
 
-        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS,
+        CheckTenantStatus(runtime, TENANT1_1_NAME, Ydb::StatusIds::SUCCESS, 
                           Ydb::Cms::GetDatabaseStatusResult::RUNNING,
                           {{"hdd", 1, 1}, {"hdd-1", 1, 1}},
                           {{"host2", 2, "kind2"}},
diff --git a/ydb/core/driver_lib/cli_base/cli_cmds_db.cpp b/ydb/core/driver_lib/cli_base/cli_cmds_db.cpp
index 450d4135c6..196e59220e 100644
--- a/ydb/core/driver_lib/cli_base/cli_cmds_db.cpp
+++ b/ydb/core/driver_lib/cli_base/cli_cmds_db.cpp
@@ -1286,31 +1286,31 @@ public:
 
     TString MiniKQL;
     TString Params;
-    bool Proto = false;
+    bool Proto = false; 
 
     virtual void Config(TConfig& config) override {
         TClientCommand::Config(config);
         config.SetFreeArgsNum(1, 2);
         SetFreeArgTitle(0, "<MINIKQL>", "Text MiniKQL");
         SetFreeArgTitle(1, "<PARAMS>", "Text MiniKQL parameters");
-        config.Opts->AddLongOption('p', "proto", "MiniKQL parameters are in protobuf format").NoArgument().SetFlag(&Proto);
+        config.Opts->AddLongOption('p', "proto", "MiniKQL parameters are in protobuf format").NoArgument().SetFlag(&Proto); 
     }
 
     virtual void Parse(TConfig& config) override {
         TClientCommand::Parse(config);
         MiniKQL = GetMiniKQL(config.ParseResult->GetFreeArgs()[0]);
         if (config.ParseResult->GetFreeArgsPos() > 1) {
-            auto paramsArg = config.ParseResult->GetFreeArgs()[1];
-            Params = Proto
+            auto paramsArg = config.ParseResult->GetFreeArgs()[1]; 
+            Params = Proto 
                 ? TUnbufferedFileInput(paramsArg).ReadAll()
-                : GetMiniKQL(paramsArg);
+                : GetMiniKQL(paramsArg); 
         }
     }
 
     virtual int Run(TConfig& config) override {
         auto handler = [this](NClient::TKikimr& kikimr) {
             NClient::TTextQuery query(kikimr.Query(MiniKQL));
-
+ 
             NThreading::TFuture<NClient::TQueryResult> future;
             if (Proto) {
                 NKikimrMiniKQL::TParams mkqlParams;
@@ -1319,7 +1319,7 @@ public:
             } else {
                 future = query.AsyncExecute(Params);
             }
-
+ 
             return HandleResponse<NClient::TQueryResult>(future, [](const NClient::TQueryResult& result) -> int {
                 Cout << result.GetValue().GetValueText<NClient::TFormatJSON>() << '\n';
                 return 0;
diff --git a/ydb/core/driver_lib/cli_utils/cli_cmds_console.cpp b/ydb/core/driver_lib/cli_utils/cli_cmds_console.cpp
index 0497d4ea8f..52cf5d6c3c 100644
--- a/ydb/core/driver_lib/cli_utils/cli_cmds_console.cpp
+++ b/ydb/core/driver_lib/cli_utils/cli_cmds_console.cpp
@@ -79,7 +79,7 @@ public:
 
     virtual void PrintResponse(const NKikimrClient::TConsoleResponse &response)
     {
-        if (response.GetStatus().GetCode() == Ydb::StatusIds::SUCCESS)
+        if (response.GetStatus().GetCode() == Ydb::StatusIds::SUCCESS) 
             Cout << response.DebugString();
         else
             Cout << "ERROR: " << response.GetStatus().GetCode()
@@ -357,7 +357,7 @@ public:
 
     void PrintResponse(const NKikimrClient::TConsoleResponse &response) override
     {
-        if (response.GetStatus().GetCode() != Ydb::StatusIds::SUCCESS) {
+        if (response.GetStatus().GetCode() != Ydb::StatusIds::SUCCESS) { 
             TConsoleClientCommand::PrintResponse(response);
         } else {
             Cout << "Curent Console config: " << Endl
@@ -404,7 +404,7 @@ public:
 
     void PrintResponse(const NKikimrClient::TConsoleResponse &response) override
     {
-        if (response.GetStatus().GetCode() != Ydb::StatusIds::SUCCESS) {
+        if (response.GetStatus().GetCode() != Ydb::StatusIds::SUCCESS) { 
             TConsoleClientCommand::PrintResponse(response);
         } else {
             Cout << "OK" << Endl;
diff --git a/ydb/core/driver_lib/cli_utils/cli_cmds_tenant.cpp b/ydb/core/driver_lib/cli_utils/cli_cmds_tenant.cpp
index db44a3a516..24f1de507b 100644
--- a/ydb/core/driver_lib/cli_utils/cli_cmds_tenant.cpp
+++ b/ydb/core/driver_lib/cli_utils/cli_cmds_tenant.cpp
@@ -62,7 +62,7 @@ public:
 
     virtual void PrintResponse(const NKikimrClient::TConsoleResponse &response)
     {
-        if (response.GetStatus().GetCode() == Ydb::StatusIds::SUCCESS)
+        if (response.GetStatus().GetCode() == Ydb::StatusIds::SUCCESS) 
             Cout << response.DebugString();
         else
             Cout << "ERROR: " << response.GetStatus().GetCode()
@@ -71,7 +71,7 @@ public:
 
     virtual void PrintResponse(const Ydb::Operations::Operation &response)
     {
-        if (response.status() == Ydb::StatusIds::SUCCESS)
+        if (response.status() == Ydb::StatusIds::SUCCESS) 
             Cout << "OK" << Endl;
         else {
             Cout << "ERROR: " << response.status() << Endl;
@@ -178,7 +178,7 @@ public:
 
     void PrintResponse(const Ydb::Operations::Operation &response) override
     {
-        if (response.status() != Ydb::StatusIds::SUCCESS) {
+        if (response.status() != Ydb::StatusIds::SUCCESS) { 
             TTenantClientGRpcCommand::PrintResponse(response);
         } else {
             Ydb::Cms::ListDatabasesResult result;
@@ -262,7 +262,7 @@ public:
 
     void PrintResponse(const Ydb::Operations::Operation &response) override
     {
-        if (response.status() != Ydb::StatusIds::SUCCESS) {
+        if (response.status() != Ydb::StatusIds::SUCCESS) { 
             TTenantClientGRpcCommand::PrintResponse(response);
         } else {
             Ydb::Cms::GetDatabaseStatusResult result;
diff --git a/ydb/core/driver_lib/run/config.h b/ydb/core/driver_lib/run/config.h
index faf1797413..6ab6fd1629 100644
--- a/ydb/core/driver_lib/run/config.h
+++ b/ydb/core/driver_lib/run/config.h
@@ -40,7 +40,7 @@ union TBasicKikimrServicesMask {
         bool EnableLoadService:1;
         bool EnableFailureInjectionService:1;
         bool EnablePersQueueL2Cache:1;
-        bool EnableKqp:1;
+        bool EnableKqp:1; 
         bool EnableMemoryLog:1;
         bool EnableGRpcService:1;
         bool EnableNodeIdentifier:1;
diff --git a/ydb/core/driver_lib/run/config_parser.cpp b/ydb/core/driver_lib/run/config_parser.cpp
index bb68656291..a61b690ba9 100644
--- a/ydb/core/driver_lib/run/config_parser.cpp
+++ b/ydb/core/driver_lib/run/config_parser.cpp
@@ -56,7 +56,7 @@ void TRunCommandConfigParser::SetupLastGetOptForConfigFiles(NLastGetopt::TOpts&
     opts.AddLongOption("channels-file", "tablet channel profile config file").OptionalArgument("PATH").Required();
     opts.AddLongOption("vdisk-file", "vdisk kind config file").OptionalArgument("PATH");
     opts.AddLongOption("drivemodel-file", "drive model config file").OptionalArgument("PATH");
-    opts.AddLongOption("kqp-file", "Kikimr Query Processor config file").OptionalArgument("PATH");
+    opts.AddLongOption("kqp-file", "Kikimr Query Processor config file").OptionalArgument("PATH"); 
     opts.AddLongOption("incrhuge-file", "incremental huge blob keeper config file").OptionalArgument("PATH");
     opts.AddLongOption("memorylog-file", "set buffer size for memory log").OptionalArgument("PATH");
     opts.AddLongOption("grpc-file", "gRPC config file").OptionalArgument("PATH");
@@ -116,14 +116,14 @@ void TRunCommandConfigParser::ParseConfigFiles(const NLastGetopt::TOptsParseResu
     if (res.Has("vdisk-file")) {
         Y_VERIFY(ParsePBFromFile(res.Get("vdisk-file"), Config.AppConfig.MutableVDiskConfig()));
     }
-
+ 
     if (res.Has("drivemodel-file")) {
         Y_VERIFY(ParsePBFromFile(res.Get("drivemodel-file"), Config.AppConfig.MutableDriveModelConfig()));
     }
 
-    if (res.Has("kqp-file")) {
-        Y_VERIFY(ParsePBFromFile(res.Get("kqp-file"), Config.AppConfig.MutableKQPConfig()));
-    }
+    if (res.Has("kqp-file")) { 
+        Y_VERIFY(ParsePBFromFile(res.Get("kqp-file"), Config.AppConfig.MutableKQPConfig())); 
+    } 
 
     if (res.Has("incrhuge-file")) {
         Y_VERIFY(ParsePBFromFile(res.Get("incrhuge-file"), Config.AppConfig.MutableIncrHugeConfig()));
diff --git a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
index 819c1478d1..ca7605425d 100644
--- a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
+++ b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
@@ -1455,7 +1455,7 @@ TSecurityServicesInitializer::TSecurityServicesInitializer(const TKikimrRunConfi
 
 void TSecurityServicesInitializer::InitializeServices(NActors::TActorSystemSetup* setup,
                                                       const NKikimr::TAppData* appData) {
-    if (!IsServiceInitialized(setup, MakeTicketParserID())) {
+    if (!IsServiceInitialized(setup, MakeTicketParserID())) { 
         IActor* ticketParser = nullptr;
         if (Factories && Factories->CreateTicketParser) {
             ticketParser = Factories->CreateTicketParser(Config.GetAuthConfig());
@@ -1465,8 +1465,8 @@ void TSecurityServicesInitializer::InitializeServices(NActors::TActorSystemSetup
         if (ticketParser) {
             setup->LocalServices.push_back(std::pair<TActorId, TActorSetupCmd>(MakeTicketParserID(),
                 TActorSetupCmd(ticketParser, TMailboxType::HTSwap, appData->UserPoolId)));
-        }
-    }
+        } 
+    } 
 }
 
 // TGRpcServicesInitializer
@@ -1930,25 +1930,25 @@ void TQuoterServiceInitializer::InitializeServices(NActors::TActorSystemSetup* s
 TKqpServiceInitializer::TKqpServiceInitializer(
         const TKikimrRunConfig& runConfig,
         std::shared_ptr<TModuleFactories> factories)
-    : IKikimrServicesInitializer(runConfig)
+    : IKikimrServicesInitializer(runConfig) 
     , Factories(std::move(factories))
 {}
-
-void TKqpServiceInitializer::InitializeServices(NActors::TActorSystemSetup* setup, const NKikimr::TAppData* appData) {
-    bool enableKqp = true;
+ 
+void TKqpServiceInitializer::InitializeServices(NActors::TActorSystemSetup* setup, const NKikimr::TAppData* appData) { 
+    bool enableKqp = true; 
     TVector<NKikimrKqp::TKqpSetting> settings;
-    if (Config.HasKQPConfig()) {
-        auto& kqpConfig = Config.GetKQPConfig();
-        if (kqpConfig.HasEnable()) {
-            enableKqp = kqpConfig.GetEnable();
-        }
-
-        for (auto& setting : kqpConfig.GetSettings()) {
-            settings.push_back(setting);
-        }
-    }
-
-    if (enableKqp) {
+    if (Config.HasKQPConfig()) { 
+        auto& kqpConfig = Config.GetKQPConfig(); 
+        if (kqpConfig.HasEnable()) { 
+            enableKqp = kqpConfig.GetEnable(); 
+        } 
+ 
+        for (auto& setting : kqpConfig.GetSettings()) { 
+            settings.push_back(setting); 
+        } 
+    } 
+ 
+    if (enableKqp) { 
         NKikimrKqp::TKqpSetting enableSpilling;
         enableSpilling.SetName("_KqpEnableSpilling");
         enableSpilling.SetValue(appData->EnableKqpSpilling ? "true" : "false");
@@ -1966,8 +1966,8 @@ void TKqpServiceInitializer::InitializeServices(NActors::TActorSystemSetup* setu
             NKqp::MakeKqpProxyID(NodeId),
             TActorSetupCmd(proxy, TMailboxType::HTSwap, appData->UserPoolId)));
     }
-}
-
+} 
+ 
 TMemoryLogInitializer::TMemoryLogInitializer(
         const TKikimrRunConfig& runConfig)
     : IKikimrServicesInitializer(runConfig)
diff --git a/ydb/core/driver_lib/run/kikimr_services_initializers.h b/ydb/core/driver_lib/run/kikimr_services_initializers.h
index 407ce1bb7b..6923d68a9e 100644
--- a/ydb/core/driver_lib/run/kikimr_services_initializers.h
+++ b/ydb/core/driver_lib/run/kikimr_services_initializers.h
@@ -378,15 +378,15 @@ public:
     void InitializeServices(NActors::TActorSystemSetup* setup, const NKikimr::TAppData* appData) override;
 };
 
-class TKqpServiceInitializer : public IKikimrServicesInitializer {
-public:
+class TKqpServiceInitializer : public IKikimrServicesInitializer { 
+public: 
     TKqpServiceInitializer(const TKikimrRunConfig& runConfig, std::shared_ptr<TModuleFactories> factories);
-
+ 
     void InitializeServices(NActors::TActorSystemSetup* setup, const NKikimr::TAppData* appData) override;
 private:
     std::shared_ptr<TModuleFactories> Factories;
-};
-
+}; 
+ 
 class TMemoryLogInitializer : public IKikimrServicesInitializer {
     size_t LogBufferSize = 0;
     size_t LogGrainSize = 0;
diff --git a/ydb/core/driver_lib/run/run.cpp b/ydb/core/driver_lib/run/run.cpp
index a4f74aa4e0..118174d869 100644
--- a/ydb/core/driver_lib/run/run.cpp
+++ b/ydb/core/driver_lib/run/run.cpp
@@ -118,7 +118,7 @@
 #include <library/cpp/actors/prof/tag.h>
 #include <ydb/library/yql/minikql/invoke_builtins/mkql_builtins.h>
 
-#include <util/folder/dirut.h>
+#include <util/folder/dirut.h> 
 #include <util/system/file.h>
 #include <util/system/getpid.h>
 #include <util/system/hostname.h>
@@ -626,7 +626,7 @@ void TKikimrRunner::InitializeGRpc(const TKikimrRunConfig& runConfig) {
         }
 
         if (hasTableService) {
-            server.AddService(new NGRpcService::TGRpcYdbTableService(ActorSystem.Get(), Counters, grpcRequestProxyId));
+            server.AddService(new NGRpcService::TGRpcYdbTableService(ActorSystem.Get(), Counters, grpcRequestProxyId)); 
         }
 
         if (hasExperimental) {
@@ -654,7 +654,7 @@ void TKikimrRunner::InitializeGRpc(const TKikimrRunConfig& runConfig) {
         }
 
         if (hasSchemeService) {
-            server.AddService(new NGRpcService::TGRpcYdbSchemeService(ActorSystem.Get(), Counters, grpcRequestProxyId));
+            server.AddService(new NGRpcService::TGRpcYdbSchemeService(ActorSystem.Get(), Counters, grpcRequestProxyId)); 
         }
 
         if (hasOperationService) {
@@ -1268,10 +1268,10 @@ TIntrusivePtr<TServiceInitializersList> TKikimrRunner::CreateServiceInitializers
     sil->AddServiceInitializer(new TMemoryTrackerInitializer(runConfig));
 #endif
 
-    if (serviceMask.EnableKqp) {
+    if (serviceMask.EnableKqp) { 
         sil->AddServiceInitializer(new TKqpServiceInitializer(runConfig, ModuleFactories));
-    }
-
+    } 
+ 
     if (serviceMask.EnableCms) {
         sil->AddServiceInitializer(new TCmsServiceInitializer(runConfig));
     }
@@ -1526,30 +1526,30 @@ void TKikimrRunner::InitializeRegistries(const TKikimrRunConfig& runConfig) {
     TypeRegistry.Reset(new NScheme::TKikimrTypeRegistry());
     TypeRegistry->CalculateMetadataEtag();
 
-    FunctionRegistry.Reset(NMiniKQL::CreateFunctionRegistry(NMiniKQL::CreateBuiltinRegistry())->Clone());
-    FormatFactory.Reset(new TFormatFactory);
-
-#ifdef KIKIMR_UDF_DYNAMIC_LINK
+    FunctionRegistry.Reset(NMiniKQL::CreateFunctionRegistry(NMiniKQL::CreateBuiltinRegistry())->Clone()); 
+    FormatFactory.Reset(new TFormatFactory); 
+ 
+#ifdef KIKIMR_UDF_DYNAMIC_LINK 
     const TString& udfsDir = runConfig.AppConfig.GetUDFsDir();
 
     TVector<TString> udfsPaths;
     if (!udfsDir.empty()) {
-        if (NFs::Exists(udfsDir) && IsDir(udfsDir)) {
-            NMiniKQL::FindUdfsInDir(udfsDir, &udfsPaths);
-        } else {
-            Cout << "UDF directory doesn't exist, no UDFs will be loaded. " << Endl;
-        }
-    }
-
-    NMiniKQL::TUdfModuleRemappings remappings;
-    for (const auto& udfPath : udfsPaths) {
-        FunctionRegistry->LoadUdfs(udfPath, remappings, 0);
-    }
-#else
-    Y_UNUSED(runConfig);
-
-    NKikimr::NMiniKQL::FillStaticModules(*FunctionRegistry);
-#endif
+        if (NFs::Exists(udfsDir) && IsDir(udfsDir)) { 
+            NMiniKQL::FindUdfsInDir(udfsDir, &udfsPaths); 
+        } else { 
+            Cout << "UDF directory doesn't exist, no UDFs will be loaded. " << Endl; 
+        } 
+    } 
+ 
+    NMiniKQL::TUdfModuleRemappings remappings; 
+    for (const auto& udfPath : udfsPaths) { 
+        FunctionRegistry->LoadUdfs(udfPath, remappings, 0); 
+    } 
+#else 
+    Y_UNUSED(runConfig); 
+ 
+    NKikimr::NMiniKQL::FillStaticModules(*FunctionRegistry); 
+#endif 
 
     NKikHouse::RegisterFormat(*FormatFactory);
 }
diff --git a/ydb/core/driver_lib/run/run.h b/ydb/core/driver_lib/run/run.h
index dfd93a24e7..c28022b3a0 100644
--- a/ydb/core/driver_lib/run/run.h
+++ b/ydb/core/driver_lib/run/run.h
@@ -31,7 +31,7 @@ protected:
 
     std::shared_ptr<TModuleFactories> ModuleFactories;
     TIntrusivePtr<NScheme::TTypeRegistry> TypeRegistry;
-    TIntrusivePtr<NMiniKQL::IMutableFunctionRegistry> FunctionRegistry;
+    TIntrusivePtr<NMiniKQL::IMutableFunctionRegistry> FunctionRegistry; 
     TIntrusivePtr<TFormatFactory> FormatFactory;
     NYq::IYqSharedResources::TPtr YqSharedResources;
 
diff --git a/ydb/core/driver_lib/run/ya.make b/ydb/core/driver_lib/run/ya.make
index f410ef42f2..ef01df15d7 100644
--- a/ydb/core/driver_lib/run/ya.make
+++ b/ydb/core/driver_lib/run/ya.make
@@ -11,12 +11,12 @@ IF (PROFILE_MEMORY_ALLOCATIONS)
     )
 ENDIF()
 
-IF (KIKIMR_UDF_DYNAMIC_LINK)
+IF (KIKIMR_UDF_DYNAMIC_LINK) 
     CFLAGS(
         -DKIKIMR_UDF_DYNAMIC_LINK
     )
-ENDIF()
-
+ENDIF() 
+ 
 SRCS(
     config.cpp
     config.h
diff --git a/ydb/core/engine/kikimr_program_builder.cpp b/ydb/core/engine/kikimr_program_builder.cpp
index fd32a772ee..d6a4bcf011 100644
--- a/ydb/core/engine/kikimr_program_builder.cpp
+++ b/ydb/core/engine/kikimr_program_builder.cpp
@@ -212,29 +212,29 @@ TVector<TRuntimeNode> TKikimrProgramBuilder::FixKeysType(
     return tmp;
 }
 
-TRuntimeNode TKikimrProgramBuilder::ReadTarget(const TReadTarget& target) {
-    MKQL_ENSURE(!target.HasSnapshotTime(), "Snapshots are not supported");
-    return NewDataLiteral((ui32)target.GetMode());
-}
-
+TRuntimeNode TKikimrProgramBuilder::ReadTarget(const TReadTarget& target) { 
+    MKQL_ENSURE(!target.HasSnapshotTime(), "Snapshots are not supported"); 
+    return NewDataLiteral((ui32)target.GetMode()); 
+} 
+ 
 TRuntimeNode TKikimrProgramBuilder::SelectRow(
         const TTableId& tableId,
         const TArrayRef<const ui32>& keyTypes,
         const TArrayRef<const TSelectColumn>& columns,
         const TKeyColumnValues& row, const TReadTarget& target)
 {
-    return SelectRow(tableId, keyTypes, columns, row, ReadTarget(target));
-}
-
-TRuntimeNode TKikimrProgramBuilder::SelectRow(
-        const TTableId& tableId,
-        const TArrayRef<const ui32>& keyTypes,
-        const TArrayRef<const TSelectColumn>& columns,
-        const TKeyColumnValues& row, TRuntimeNode readTarget)
-{
-    MKQL_ENSURE(AS_TYPE(TDataType, readTarget)->GetSchemeType() == NUdf::TDataType<ui32>::Id,
-        "Read target must be ui32");
-
+    return SelectRow(tableId, keyTypes, columns, row, ReadTarget(target)); 
+} 
+ 
+TRuntimeNode TKikimrProgramBuilder::SelectRow( 
+        const TTableId& tableId, 
+        const TArrayRef<const ui32>& keyTypes, 
+        const TArrayRef<const TSelectColumn>& columns, 
+        const TKeyColumnValues& row, TRuntimeNode readTarget) 
+{ 
+    MKQL_ENSURE(AS_TYPE(TDataType, readTarget)->GetSchemeType() == NUdf::TDataType<ui32>::Id, 
+        "Read target must be ui32"); 
+ 
     auto rows = FixKeysType(keyTypes, row);
 
     TRuntimeNode tags;
@@ -247,7 +247,7 @@ TRuntimeNode TKikimrProgramBuilder::SelectRow(
     builder.Add(TRuntimeNode(rowType, true));
     builder.Add(tags);
     builder.Add(NewTuple(TKeyColumnValues(rows)));
-    builder.Add(readTarget);
+    builder.Add(readTarget); 
 
     return TRuntimeNode(builder.Build(), false);
 }
@@ -259,9 +259,9 @@ TRuntimeNode TKikimrProgramBuilder::SelectRange(
         const TTableRangeOptions& options,
         const TReadTarget& target)
 {
-    return SelectRange(tableId, keyTypes, columns, options, ReadTarget(target));
-}
-
+    return SelectRange(tableId, keyTypes, columns, options, ReadTarget(target)); 
+} 
+ 
 static TRuntimeNode BuildOptionList(const TArrayRef<bool>& arr, TProgramBuilder& pBuilder) {
     TListLiteralBuilder builder(pBuilder.GetTypeEnvironment(), pBuilder.NewDataType(NUdf::TDataType<bool>::Id));
     for (auto& item : arr) {
@@ -278,14 +278,14 @@ static bool AtLeastOneFlagSet(const TArrayRef<bool>& arr) {
     return false;
 }
 
-TRuntimeNode TKikimrProgramBuilder::SelectRange(
-        const TTableId& tableId,
-        const TArrayRef<const ui32>& keyTypes,
-        const TArrayRef<const TSelectColumn>& columns,
-        const TTableRangeOptions& options,
-        TRuntimeNode readTarget)
-{
-    MKQL_ENSURE(AS_TYPE(TDataType, readTarget)->GetSchemeType() == NUdf::TDataType<ui32>::Id, "Read target must be ui32");
+TRuntimeNode TKikimrProgramBuilder::SelectRange( 
+        const TTableId& tableId, 
+        const TArrayRef<const ui32>& keyTypes, 
+        const TArrayRef<const TSelectColumn>& columns, 
+        const TTableRangeOptions& options, 
+        TRuntimeNode readTarget) 
+{ 
+    MKQL_ENSURE(AS_TYPE(TDataType, readTarget)->GetSchemeType() == NUdf::TDataType<ui32>::Id, "Read target must be ui32"); 
     MKQL_ENSURE(AS_TYPE(TDataType, options.Flags)->GetSchemeType() == NUdf::TDataType<ui32>::Id, "Flags must be ui32");
     MKQL_ENSURE(AS_TYPE(TDataType, options.ItemsLimit)->GetSchemeType() == NUdf::TDataType<ui64>::Id, "ItemsLimit must be ui64");
     MKQL_ENSURE(AS_TYPE(TDataType, options.BytesLimit)->GetSchemeType() == NUdf::TDataType<ui64>::Id, "BytesLimit must be ui64");
@@ -316,8 +316,8 @@ TRuntimeNode TKikimrProgramBuilder::SelectRange(
             dataTo = UnpackOptionalData(to[i], isOptionalTo);
         }
 
-        MKQL_ENSURE(dataFrom || dataTo, "Invalid key tuple values");
-
+        MKQL_ENSURE(dataFrom || dataTo, "Invalid key tuple values"); 
+ 
         if (dataFrom && dataTo) {
             MKQL_ENSURE(dataFrom->IsSameType(*dataTo), "Data types for key column " << i
                 << " don't match From: " << NUdf::GetDataTypeInfo(*dataFrom->GetDataSlot()).Name
@@ -338,7 +338,7 @@ TRuntimeNode TKikimrProgramBuilder::SelectRange(
     TRuntimeNode skipNullKeys = BuildOptionList(options.SkipNullKeys, *this);
     TRuntimeNode forbidNullArgsFrom = BuildOptionList(options.ForbidNullArgsFrom, *this);
     TRuntimeNode forbidNullArgsTo = BuildOptionList(options.ForbidNullArgsTo, *this);
-
+ 
     TStructTypeBuilder returnTypeBuilder(Env);
     returnTypeBuilder.Reserve(2);
     returnTypeBuilder.Add(TStringBuf("List"), listType);
@@ -354,8 +354,8 @@ TRuntimeNode TKikimrProgramBuilder::SelectRange(
     builder.Add(options.Flags);
     builder.Add(options.ItemsLimit);
     builder.Add(options.BytesLimit);
-    builder.Add(readTarget);
-    builder.Add(skipNullKeys);
+    builder.Add(readTarget); 
+    builder.Add(skipNullKeys); 
     builder.Add(options.Reverse);
 
     // Compat with older kikimr
@@ -472,38 +472,38 @@ TRuntimeNode TKikimrProgramBuilder::FlatMapParameter(
     return TRuntimeNode(callableBuilder.Build(), false);
 }
 
-TRuntimeNode TKikimrProgramBuilder::AcquireLocks(TRuntimeNode lockTxId) {
+TRuntimeNode TKikimrProgramBuilder::AcquireLocks(TRuntimeNode lockTxId) { 
     MKQL_ENSURE(AS_TYPE(TDataType, lockTxId)->GetSchemeType() == NUdf::TDataType<ui64>::Id, "LockTxId must be ui64");
-
-    TCallableBuilder callableBuilder(Env, "AcquireLocks", Env.GetTypeOfVoid());
-    callableBuilder.Add(lockTxId);
-    return TRuntimeNode(callableBuilder.Build(), false);
-}
-
-TRuntimeNode TKikimrProgramBuilder::CombineByKeyMerge(TRuntimeNode list) {
-    auto listType = list.GetStaticType();
-    MKQL_ENSURE(listType->IsList(), "Expected list");
-
-    TCallableBuilder callableBuilder(Env, "CombineByKeyMerge", listType);
-    callableBuilder.Add(list);
-    return TRuntimeNode(callableBuilder.Build(), false);
-}
-
+ 
+    TCallableBuilder callableBuilder(Env, "AcquireLocks", Env.GetTypeOfVoid()); 
+    callableBuilder.Add(lockTxId); 
+    return TRuntimeNode(callableBuilder.Build(), false); 
+} 
+ 
+TRuntimeNode TKikimrProgramBuilder::CombineByKeyMerge(TRuntimeNode list) { 
+    auto listType = list.GetStaticType(); 
+    MKQL_ENSURE(listType->IsList(), "Expected list"); 
+ 
+    TCallableBuilder callableBuilder(Env, "CombineByKeyMerge", listType); 
+    callableBuilder.Add(list); 
+    return TRuntimeNode(callableBuilder.Build(), false); 
+} 
+ 
 TRuntimeNode TKikimrProgramBuilder::Diagnostics() {
     TCallableBuilder callableBuilder(Env, "Diagnostics", Env.GetTypeOfVoid());
     return TRuntimeNode(callableBuilder.Build(), false);
 }
 
-TRuntimeNode TKikimrProgramBuilder::PartialSort(TRuntimeNode list, TRuntimeNode ascending,
-    std::function<TRuntimeNode(TRuntimeNode item)> keyExtractor)
-{
-    return BuildSort("PartialSort", list, ascending, keyExtractor);
-}
-
-TRuntimeNode TKikimrProgramBuilder::PartialTake(TRuntimeNode list, TRuntimeNode count) {
-    return BuildTake("PartialTake", list, count);
-}
-
+TRuntimeNode TKikimrProgramBuilder::PartialSort(TRuntimeNode list, TRuntimeNode ascending, 
+    std::function<TRuntimeNode(TRuntimeNode item)> keyExtractor) 
+{ 
+    return BuildSort("PartialSort", list, ascending, keyExtractor); 
+} 
+ 
+TRuntimeNode TKikimrProgramBuilder::PartialTake(TRuntimeNode list, TRuntimeNode count) { 
+    return BuildTake("PartialTake", list, count); 
+} 
+ 
 TRuntimeNode TKikimrProgramBuilder::Bind(TRuntimeNode program, TRuntimeNode parameters, ui32 bindFlags) {
     auto listType = program.GetStaticType();
     AS_TYPE(TListType, listType);
@@ -536,18 +536,18 @@ TRuntimeNode TKikimrProgramBuilder::Bind(TRuntimeNode program, TRuntimeNode para
                 auto structObj = AS_VALUE(NMiniKQL::TStructLiteral, NMiniKQL::TRuntimeNode(callable.GetType()->GetPayload(), true));
                 auto payloadIndex = 1; // fields: Args, Payload
                 const TStringBuf parameterName(AS_VALUE(NMiniKQL::TDataLiteral, structObj->GetValue(payloadIndex))->AsValue().AsStringRef());
-
-                auto parameterIndex = parametersStruct.GetType()->FindMemberIndex(parameterName);
-                MKQL_ENSURE(parameterIndex, "Missing value for parameter: " << parameterName);
-
-                auto value = parametersStruct.GetValue(*parameterIndex);
+ 
+                auto parameterIndex = parametersStruct.GetType()->FindMemberIndex(parameterName); 
+                MKQL_ENSURE(parameterIndex, "Missing value for parameter: " << parameterName); 
+ 
+                auto value = parametersStruct.GetValue(*parameterIndex); 
                 MKQL_ENSURE(value.IsImmediate(), "Parameter value must be immediate");
-
-                MKQL_ENSURE(value.GetStaticType()->IsSameType(*callable.GetType()->GetReturnType()),
-                    "Incorrect type for parameter " << parameterName
+ 
+                MKQL_ENSURE(value.GetStaticType()->IsSameType(*callable.GetType()->GetReturnType()), 
+                    "Incorrect type for parameter " << parameterName 
                     << ", expected: " << PrintNode(callable.GetType()->GetReturnType(), true)
                     << ", actual: " << PrintNode(value.GetStaticType(), true));
-
+ 
                 callable.SetResult(value, Env);
             } else if (callableName == mapParameterFunc || callableName == flatMapParameterFunc) {
                 MKQL_ENSURE(callable.GetInput(0).HasValue(), "Expected parameter value");
@@ -561,7 +561,7 @@ TRuntimeNode TKikimrProgramBuilder::Bind(TRuntimeNode program, TRuntimeNode para
                 }
 
                 TVector<TRuntimeNode> mapResults;
-                mapResults.reserve(list->GetItemsCount());
+                mapResults.reserve(list->GetItemsCount()); 
 
                 TExploringNodeVisitor explorer;
                 auto lambdaArgNode = callable.GetInput(1).GetNode();
@@ -589,20 +589,20 @@ TRuntimeNode TKikimrProgramBuilder::Bind(TRuntimeNode program, TRuntimeNode para
                             };
                         }, Env, false, wereChanges);
 
-                    mapResults.push_back(newValue);
+                    mapResults.push_back(newValue); 
                 }
 
-                TRuntimeNode res;
-                TListLiteralBuilder listBuilder(Env, retItemType);
+                TRuntimeNode res; 
+                TListLiteralBuilder listBuilder(Env, retItemType); 
                 if (callableName == mapParameterFunc) {
-                    for (auto& node : mapResults) {
-                        listBuilder.Add(node);
-                    }
-                    res = TRuntimeNode(listBuilder.Build(), true);
-                } else {
-                    res = mapResults.empty()
-                        ? TRuntimeNode(listBuilder.Build(), true)
-                        : Extend(mapResults);
+                    for (auto& node : mapResults) { 
+                        listBuilder.Add(node); 
+                    } 
+                    res = TRuntimeNode(listBuilder.Build(), true); 
+                } else { 
+                    res = mapResults.empty() 
+                        ? TRuntimeNode(listBuilder.Build(), true) 
+                        : Extend(mapResults); 
                 }
 
                 callable.SetResult(res, Env);
diff --git a/ydb/core/engine/kikimr_program_builder.h b/ydb/core/engine/kikimr_program_builder.h
index 717132c0b9..eb25173654 100644
--- a/ydb/core/engine/kikimr_program_builder.h
+++ b/ydb/core/engine/kikimr_program_builder.h
@@ -63,7 +63,7 @@ struct TTableRangeOptions
     TRuntimeNode Flags; // default = ui64 IncludeInitValue | IncludeTermValue
     TKeyColumnValues FromColumns;
     TKeyColumnValues ToColumns;
-    TArrayRef<bool> SkipNullKeys;
+    TArrayRef<bool> SkipNullKeys; 
     TArrayRef<bool> ForbidNullArgsFrom;
     TArrayRef<bool> ForbidNullArgsTo;
     TRuntimeNode Reverse; // default = <unset>
@@ -142,13 +142,13 @@ public:
             const TKeyColumnValues& row,
             const TReadTarget& target = TReadTarget());
 
-    TRuntimeNode SelectRow(
-            const TTableId& tableId,
-            const TArrayRef<const ui32>& keyTypes,
-            const TArrayRef<const TSelectColumn>& columns,
-            const TKeyColumnValues& row,
-            TRuntimeNode readTarget);
-
+    TRuntimeNode SelectRow( 
+            const TTableId& tableId, 
+            const TArrayRef<const ui32>& keyTypes, 
+            const TArrayRef<const TSelectColumn>& columns, 
+            const TKeyColumnValues& row, 
+            TRuntimeNode readTarget); 
+ 
     TTableRangeOptions GetDefaultTableRangeOptions() const {
         return TTableRangeOptions(Env);
     }
@@ -162,13 +162,13 @@ public:
             const TTableRangeOptions& options,
             const TReadTarget& target = TReadTarget());
 
-    TRuntimeNode SelectRange(
-            const TTableId& tableId,
-            const TArrayRef<const ui32>& keyTypes,
-            const TArrayRef<const TSelectColumn>& columns,
-            const TTableRangeOptions& options,
-            TRuntimeNode readTarget);
-
+    TRuntimeNode SelectRange( 
+            const TTableId& tableId, 
+            const TArrayRef<const ui32>& keyTypes, 
+            const TArrayRef<const TSelectColumn>& columns, 
+            const TTableRangeOptions& options, 
+            TRuntimeNode readTarget); 
+ 
     TUpdateRowBuilder GetUpdateRowBuilder() const {
         return TUpdateRowBuilder(Env);
     }
@@ -199,19 +199,19 @@ public:
             TRuntimeNode list,
             std::function<TRuntimeNode(TRuntimeNode item)> handler);
 
-    TRuntimeNode AcquireLocks(TRuntimeNode lockTxId);
-
-    TRuntimeNode ReadTarget(const TReadTarget& target);
-
-    TRuntimeNode CombineByKeyMerge(TRuntimeNode list);
-
+    TRuntimeNode AcquireLocks(TRuntimeNode lockTxId); 
+ 
+    TRuntimeNode ReadTarget(const TReadTarget& target); 
+ 
+    TRuntimeNode CombineByKeyMerge(TRuntimeNode list); 
+ 
     TRuntimeNode Diagnostics();
 
-    TRuntimeNode PartialSort(TRuntimeNode list, TRuntimeNode ascending,
-        std::function<TRuntimeNode(TRuntimeNode item)> keyExtractor);
-
-    TRuntimeNode PartialTake(TRuntimeNode list, TRuntimeNode count);
-
+    TRuntimeNode PartialSort(TRuntimeNode list, TRuntimeNode ascending, 
+        std::function<TRuntimeNode(TRuntimeNode item)> keyExtractor); 
+ 
+    TRuntimeNode PartialTake(TRuntimeNode list, TRuntimeNode count); 
+ 
     TRuntimeNode Bind(
             TRuntimeNode program,
             TRuntimeNode parameters,
diff --git a/ydb/core/engine/kikimr_program_builder_ut.cpp b/ydb/core/engine/kikimr_program_builder_ut.cpp
index efa073ae2f..9599b5f296 100644
--- a/ydb/core/engine/kikimr_program_builder_ut.cpp
+++ b/ydb/core/engine/kikimr_program_builder_ut.cpp
@@ -682,20 +682,20 @@ Y_UNIT_TEST_SUITE(TMiniKQLProgramBuilderTest) {
         UNIT_ASSERT(tableKeys[0]->Columns[1].Operation == TKeyDesc::EColumnOperation::Read);
         UNIT_ASSERT(tableKeys[0]->Columns[1].ExpectedType == NUdf::TDataType<ui64>::Id);
     }
-
+ 
     Y_UNIT_TEST(TestAcquireLocks) {
         TScopedAlloc alloc;
         TTypeEnvironment env(alloc);
         auto functionRegistry = CreateFunctionRegistry(CreateBuiltinRegistry());
         TKikimrProgramBuilder pgmBuilder(env, *functionRegistry);
-        auto pgmReturn = pgmBuilder.NewEmptyListOfVoid();
-        pgmReturn = pgmBuilder.Append(pgmReturn, pgmBuilder.SetResult("locks",
+        auto pgmReturn = pgmBuilder.NewEmptyListOfVoid(); 
+        pgmReturn = pgmBuilder.Append(pgmReturn, pgmBuilder.SetResult("locks", 
             pgmBuilder.AcquireLocks(pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(0))));
-        auto pgm = pgmBuilder.Build(pgmReturn, TKikimrProgramBuilder::TBindFlags::DisableOptimization).GetNode();
-
-        VerifyProgram(pgm, env);
-    }
-
+        auto pgm = pgmBuilder.Build(pgmReturn, TKikimrProgramBuilder::TBindFlags::DisableOptimization).GetNode(); 
+ 
+        VerifyProgram(pgm, env); 
+    } 
+ 
     Y_UNIT_TEST(TestDiagnostics) {
         TScopedAlloc alloc;
         TTypeEnvironment env(alloc);
@@ -709,46 +709,46 @@ Y_UNIT_TEST_SUITE(TMiniKQLProgramBuilderTest) {
     }
 
     Y_UNIT_TEST(TestInvalidParameterName) {
-        TScopedAlloc alloc;
+        TScopedAlloc alloc; 
         TTypeEnvironment env(alloc);
         auto functionRegistry = CreateFunctionRegistry(CreateBuiltinRegistry());
         TKikimrProgramBuilder pgmBuilder(env, *functionRegistry);
-
-        auto paramsBuilder = pgmBuilder.GetParametersBuilder();
-        paramsBuilder.Add("Param1", pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(10));
-
+ 
+        auto paramsBuilder = pgmBuilder.GetParametersBuilder(); 
+        paramsBuilder.Add("Param1", pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(10)); 
+ 
         auto param = pgmBuilder.Parameter("Param2", pgmBuilder.NewDataType(NUdf::TDataType<ui32>::Id));
-
-        try {
-            pgmBuilder.Bind(pgmBuilder.AsList(pgmBuilder.SetResult("Result", param)), paramsBuilder.Build());
-        } catch (const yexception& ex) {
+ 
+        try { 
+            pgmBuilder.Bind(pgmBuilder.AsList(pgmBuilder.SetResult("Result", param)), paramsBuilder.Build()); 
+        } catch (const yexception& ex) { 
             UNIT_ASSERT(TString(ex.what()).EndsWith("Missing value for parameter: Param2"));
-            return;
-        }
-
-        UNIT_FAIL("Expected exception.");
-    }
-
+            return; 
+        } 
+ 
+        UNIT_FAIL("Expected exception."); 
+    } 
+ 
     Y_UNIT_TEST(TestInvalidParameterType) {
-        TScopedAlloc alloc;
+        TScopedAlloc alloc; 
         TTypeEnvironment env(alloc);
         auto functionRegistry = CreateFunctionRegistry(CreateBuiltinRegistry());
         TKikimrProgramBuilder pgmBuilder(env, *functionRegistry);
-
-        auto paramsBuilder = pgmBuilder.GetParametersBuilder();
-        paramsBuilder.Add("Param1", pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(10));
-
+ 
+        auto paramsBuilder = pgmBuilder.GetParametersBuilder(); 
+        paramsBuilder.Add("Param1", pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(10)); 
+ 
         auto param = pgmBuilder.Parameter("Param1", pgmBuilder.NewDataType(NUdf::TDataType<ui32>::Id));
-
-        try {
-            pgmBuilder.Bind(pgmBuilder.AsList(pgmBuilder.SetResult("Result", param)), paramsBuilder.Build());
-        } catch (const yexception& ex) {
+ 
+        try { 
+            pgmBuilder.Bind(pgmBuilder.AsList(pgmBuilder.SetResult("Result", param)), paramsBuilder.Build()); 
+        } catch (const yexception& ex) { 
             UNIT_ASSERT(TString(ex.what()).Contains("Incorrect type for parameter Param1"));
-            return;
-        }
-
-        UNIT_FAIL("Expected exception.");
-    }
+            return; 
+        } 
+ 
+        UNIT_FAIL("Expected exception."); 
+    } 
 }
 
 } // namespace NMiniKQL
diff --git a/ydb/core/engine/minikql/flat_local_tx_minikql.h b/ydb/core/engine/minikql/flat_local_tx_minikql.h
index 0feabf20e6..6bbc35fb58 100644
--- a/ydb/core/engine/minikql/flat_local_tx_minikql.h
+++ b/ydb/core/engine/minikql/flat_local_tx_minikql.h
@@ -14,62 +14,62 @@
 namespace NKikimr {
 namespace NMiniKQL {
 
-class TLocalDbSchemeResolver : public NYql::IDbSchemeResolver {
-public:
+class TLocalDbSchemeResolver : public NYql::IDbSchemeResolver { 
+public: 
     TLocalDbSchemeResolver(const NTable::TScheme& scheme, ui64 tabletId)
-        : Scheme(scheme)
-        , TabletId(tabletId) {}
-
+        : Scheme(scheme) 
+        , TabletId(tabletId) {} 
+ 
     virtual NThreading::TFuture<TTableResults> ResolveTables(const TVector<TTable>& tables) override {
-        TTableResults results;
-        results.reserve(tables.size());
-
-        for (auto& table : tables) {
+        TTableResults results; 
+        results.reserve(tables.size()); 
+ 
+        for (auto& table : tables) { 
             TTableResult result(TTableResult::Ok);
 
-            const ui32* tableId = Scheme.TableNames.FindPtr(table.TableName);
+            const ui32* tableId = Scheme.TableNames.FindPtr(table.TableName); 
             if (!tableId) {
                 result = TTableResult(TTableResult::Error, "Unknown table " + table.TableName);
             } else {
                 const auto *tableInfo = Scheme.Tables.FindPtr(*tableId);
                 Y_VERIFY(tableInfo);
-
+ 
                 result.KeyColumnCount = tableInfo->KeyColumns.size();
                 result.Table = table;
                 result.TableId = new TTableId(TabletId, *tableId);
-
+ 
                 for (const auto& column : table.ColumnNames) {
                     const ui32* columnId = tableInfo->ColumnNames.FindPtr(column);
                     if (!columnId) {
                         result = TTableResult(TTableResult::Error, "Unknown column " + table.TableName + ":" + column);
                         break;
                     }
-
+ 
                     const auto *columnInfo = tableInfo->Columns.FindPtr(*columnId);
                     Y_VERIFY(columnInfo);
-
+ 
                     auto insertResult = result.Columns.insert(std::make_pair(column, IDbSchemeResolver::TTableResult::TColumn
-                    {*columnId, (i32)columnInfo->KeyOrder, columnInfo->PType, 0}));
+                    {*columnId, (i32)columnInfo->KeyOrder, columnInfo->PType, 0})); 
                     Y_VERIFY(insertResult.second);
                 }
-            }
-
-            results.push_back(result);
-        }
-
-        return NThreading::MakeFuture<TTableResults>(results);
-    }
-
+            } 
+ 
+            results.push_back(result); 
+        } 
+ 
+        return NThreading::MakeFuture<TTableResults>(results); 
+    } 
+ 
     virtual void ResolveTables(const TVector<TTable>& tables, NActors::TActorId responseTo) override {
-        Y_UNUSED(tables);
-        Y_UNUSED(responseTo);
-        Y_FAIL("Not implemented for local resolve.");
-    }
-private:
+        Y_UNUSED(tables); 
+        Y_UNUSED(responseTo); 
+        Y_FAIL("Not implemented for local resolve."); 
+    } 
+private: 
     const NTable::TScheme& Scheme;
-    const ui64 TabletId;
-};
-
+    const ui64 TabletId; 
+}; 
+ 
 class TFlatLocalMiniKQL : public NTabletFlatExecutor::ITransaction {
     ui64 TabletId = Max<ui64>();
     const TActorId Sender;
@@ -109,30 +109,30 @@ class TFlatLocalMiniKQL : public NTabletFlatExecutor::ITransaction {
             return true;
         }
 
-        if (SourceProgram.Params.Text) {
-            ProgramCompileResult = new NYql::TMiniKQLCompileResult();
+        if (SourceProgram.Params.Text) { 
+            ProgramCompileResult = new NYql::TMiniKQLCompileResult(); 
 
-            NYql::TExprContainer::TPtr expr  = new NYql::TExprContainer();
-            NYql::TMiniKQLCompileResult parseResult;
-            if (!ParseProgram(SourceProgram.Params.Text, parseResult.Errors, *expr)) {
-                ProgramCompileResult->Errors.AddIssues(parseResult.Errors);
-                return false;
-            }
+            NYql::TExprContainer::TPtr expr  = new NYql::TExprContainer(); 
+            NYql::TMiniKQLCompileResult parseResult; 
+            if (!ParseProgram(SourceProgram.Params.Text, parseResult.Errors, *expr)) { 
+                ProgramCompileResult->Errors.AddIssues(parseResult.Errors); 
+                return false; 
+            } 
 
             TAlignedPagePoolCounters counters(appData->Counters, "local_tx");
             TScopedAlloc alloc(counters, appData->FunctionRegistry->SupportsSizedAllocators());
             TTypeEnvironment typeEnv(alloc);
             auto future = ConvertToMiniKQL(expr, appData->FunctionRegistry, &typeEnv, nullptr);
-            future.Wait();
-            NYql::TConvertResult compileResult = future.GetValue();
+            future.Wait(); 
+            NYql::TConvertResult compileResult = future.GetValue(); 
 
-            if (!compileResult.Errors.Empty()) {
-                ProgramCompileResult->Errors.AddIssues(compileResult.Errors);
-                return false;
+            if (!compileResult.Errors.Empty()) { 
+                ProgramCompileResult->Errors.AddIssues(compileResult.Errors); 
+                return false; 
             }
-        }
-
-        return true;
+        } 
+ 
+        return true; 
     }
 
     bool PrepareProgram(TTransactionContext &txc, const TAppData *appData) {
@@ -145,29 +145,29 @@ class TFlatLocalMiniKQL : public NTabletFlatExecutor::ITransaction {
         // so we must prepare program
         ProgramCompileResult = new NYql::TMiniKQLCompileResult();
 
-        NYql::TExprContainer::TPtr expr  = new NYql::TExprContainer();
-        NYql::TMiniKQLCompileResult parseResult;
-        if (!ParseProgram(SourceProgram.Program.Text, parseResult.Errors, *expr)) {
-            ProgramCompileResult->Errors.AddIssues(parseResult.Errors);
-            return false;
-        }
-
+        NYql::TExprContainer::TPtr expr  = new NYql::TExprContainer(); 
+        NYql::TMiniKQLCompileResult parseResult; 
+        if (!ParseProgram(SourceProgram.Program.Text, parseResult.Errors, *expr)) { 
+            ProgramCompileResult->Errors.AddIssues(parseResult.Errors); 
+            return false; 
+        } 
+ 
         TAlignedPagePoolCounters counters(appData->Counters, "local_tx");
         TScopedAlloc alloc(counters, appData->FunctionRegistry->SupportsSizedAllocators());
         TTypeEnvironment typeEnv(alloc);
         TLocalDbSchemeResolver dbResolver(txc.DB.GetScheme(), TabletId);
         const auto unguard = Unguard(alloc);
         auto future = ConvertToMiniKQL(expr, appData->FunctionRegistry, &typeEnv, &dbResolver);
-        future.Wait();
-        NYql::TConvertResult compileResult = future.GetValue();
+        future.Wait(); 
+        NYql::TConvertResult compileResult = future.GetValue(); 
         if (!compileResult.Errors.Empty()) {
-            ProgramCompileResult->Errors.AddIssues(compileResult.Errors);
+            ProgramCompileResult->Errors.AddIssues(compileResult.Errors); 
             return false;
         }
-
+ 
         ProgramCompileResult->CompiledProgram = SerializeRuntimeNode(compileResult.Node, typeEnv);
-        SerializedMiniKQLProgram = ProgramCompileResult->CompiledProgram;
-        return true;
+        SerializedMiniKQLProgram = ProgramCompileResult->CompiledProgram; 
+        return true; 
     }
 
     void ClearResponse() {
@@ -261,8 +261,8 @@ class TFlatLocalMiniKQL : public NTabletFlatExecutor::ITransaction {
 
             for (auto &key : proxyEngine->GetDbKeys()) {
                 key->Status = TKeyDesc::EStatus::Ok;
-                key->Partitions.push_back(TKeyDesc::TPartitionInfo(TabletId));
-
+                key->Partitions.push_back(TKeyDesc::TPartitionInfo(TabletId)); 
+ 
                 for (const auto &x : key->Columns) {
                     key->ColumnInfos.push_back({x.Column, x.ExpectedType, 0, TKeyDesc::EStatus::Ok}); // type-check
                 }
@@ -327,7 +327,7 @@ class TFlatLocalMiniKQL : public NTabletFlatExecutor::ITransaction {
                     return MakeResponse(engine.Get(), ctx);
 
                 const TString shardEngineReply = engine->GetShardReply(TabletId);
-                proxyEngine->AddShardReply(TabletId, shardEngineReply);
+                proxyEngine->AddShardReply(TabletId, shardEngineReply); 
                 proxyEngine->FinalizeOriginReplies(TabletId);
             }
 
diff --git a/ydb/core/engine/minikql/minikql_engine_host.cpp b/ydb/core/engine/minikql/minikql_engine_host.cpp
index 36c35f32cc..e057d58593 100644
--- a/ydb/core/engine/minikql/minikql_engine_host.cpp
+++ b/ydb/core/engine/minikql/minikql_engine_host.cpp
@@ -6,7 +6,7 @@
 #include <ydb/library/yql/minikql/computation/mkql_custom_list.h>
 #include <ydb/library/yql/minikql/mkql_string_util.h>
 #include <ydb/core/tx/datashard/sys_tables.h>
-
+ 
 #include <library/cpp/containers/stack_vector/stack_vec.h>
 
 namespace NKikimr {
@@ -14,27 +14,27 @@ namespace NMiniKQL {
 
 using TScheme = NTable::TScheme;
 
-void ConvertTableKeys(const TScheme& scheme, const TScheme::TTableInfo* tableInfo,
+void ConvertTableKeys(const TScheme& scheme, const TScheme::TTableInfo* tableInfo, 
     const TArrayRef<const TCell>& row,  TSmallVec<TRawTypeValue>& key, ui64* keyDataBytes)
-{
+{ 
     ui64 bytes = 0;
     key.reserve(row.size());
     for (size_t keyIdx = 0; keyIdx < row.size(); keyIdx++) {
-        const TCell& cell = row[keyIdx];
-        ui32 keyCol = tableInfo->KeyColumns[keyIdx];
-        NScheme::TTypeId vtype = scheme.GetColumnInfo(tableInfo, keyCol)->PType;
-        if (cell.IsNull()) {
-            key.emplace_back();
+        const TCell& cell = row[keyIdx]; 
+        ui32 keyCol = tableInfo->KeyColumns[keyIdx]; 
+        NScheme::TTypeId vtype = scheme.GetColumnInfo(tableInfo, keyCol)->PType; 
+        if (cell.IsNull()) { 
+            key.emplace_back(); 
             bytes += 1;
-        } else {
-            key.emplace_back(cell.Data(), cell.Size(), vtype);
+        } else { 
+            key.emplace_back(cell.Data(), cell.Size(), vtype); 
             bytes += cell.Size();
-        }
-    }
+        } 
+    } 
     if (keyDataBytes)
         *keyDataBytes = bytes;
-}
-
+} 
+ 
 TEngineHost::TEngineHost(NTable::TDatabase& db, TEngineHostCounters& counters, const TEngineHostSettings& settings)
     : Db(db)
     , Scheme(db.GetScheme())
@@ -260,16 +260,16 @@ void TEngineHost::PinPages(const TVector<THolder<TKeyDesc>>& keys, ui64 pageFaul
 }
 
 NUdf::TUnboxedValue TEngineHost::SelectRow(const TTableId& tableId, const TArrayRef<const TCell>& row,
-    TStructLiteral* columnIds, TOptionalType* returnType, const TReadTarget& readTarget,
-    const THolderFactory& holderFactory)
+    TStructLiteral* columnIds, TOptionalType* returnType, const TReadTarget& readTarget, 
+    const THolderFactory& holderFactory) 
 {
     // It is assumed that returnType has form:
     //  optinal<struct<optional<data>,
     //                 ...
     //                 optional<data>>>
     // And that struct type has column tags stored inside it's member names as numbers
-
-    Y_UNUSED(returnType);
+ 
+    Y_UNUSED(returnType); 
     Y_UNUSED(readTarget);
 
     ui64 localTid = LocalTableId(tableId);
@@ -311,15 +311,15 @@ NUdf::TUnboxedValue TEngineHost::SelectRow(const TTableId& tableId, const TArray
     if (NTable::EReady::Gone == ready) {
         return NUdf::TUnboxedValue();
     }
-
+ 
     NUdf::TUnboxedValue* rowItems = nullptr;
     auto rowResult = holderFactory.CreateDirectArrayHolder(tags.size(), rowItems);
-
+ 
     ui64 rowBytes = 0;
     for (ui32 i = 0; i < tags.size(); ++i) {
         rowItems[i] = GetCellValue(dbRow.Get(i), cellTypes[i]);
         rowBytes += dbRow.Get(i).IsNull() ? 1 : dbRow.Get(i).Size();
-    }
+    } 
     for (ui32 i = 0; i < systemColumnTags.size(); ++i) {
         switch (systemColumnTags[i]) {
         case TKeyDesc::EColumnIdDataShard:
@@ -330,15 +330,15 @@ NUdf::TUnboxedValue TEngineHost::SelectRow(const TTableId& tableId, const TArray
         }
     }
     rowBytes = std::max(rowBytes, (ui64)8);
-
+ 
     Counters.SelectRowBytes += rowBytes;
     Counters.SelectRowRows++;
 
     return std::move(rowResult);
-}
-
-template<class TTableIt>
-class TSelectRangeLazyRow : public TComputationValue<TSelectRangeLazyRow<TTableIt>>{
+} 
+ 
+template<class TTableIt> 
+class TSelectRangeLazyRow : public TComputationValue<TSelectRangeLazyRow<TTableIt>>{ 
     NUdf::TUnboxedValue GetElement(ui32 index) const override {
         BuildValue(index);
         return GetPtr()[index];
@@ -350,7 +350,7 @@ public:
             (GetPtr() + i)->~TUnboxedValue();
         }
     }
-
+ 
     void* operator new(size_t sz) = delete;
     void* operator new[](size_t sz) = delete;
     void operator delete(void *mem, std::size_t sz) {
@@ -364,68 +364,68 @@ public:
     static NUdf::TUnboxedValue Create(const TDbTupleRef& dbData, const THolderFactory& holderFactory,
         const TSmallVec<NTable::TTag>& systemColumnTags, ui64 shardId) {
         ui32 size = dbData.ColumnCount + systemColumnTags.size();
-
-        ui32 maskSize = size > 0 ? (size - 1) / 64 + 1 : 0;
+ 
+        ui32 maskSize = size > 0 ? (size - 1) / 64 + 1 : 0; 
         void* buffer = MKQLAllocWithSize(sizeof(TSelectRangeLazyRow)
-            + size * sizeof(NUdf::TUnboxedValue)
-            + maskSize * sizeof(ui64));
-
+            + size * sizeof(NUdf::TUnboxedValue) 
+            + maskSize * sizeof(ui64)); 
+ 
         return NUdf::TUnboxedValuePod(::new(buffer) TSelectRangeLazyRow(dbData, holderFactory, maskSize, systemColumnTags, shardId));
-    }
+    } 
 
     void InvalidateDb() {
         for (ui32 i = 0; i < Size(); ++i) {
             BuildValue(i);
         }
     }
-
-    void OwnDb(THolder<TTableIt>&& iter) {
-        Iter = std::move(iter);
-    }
-
-    void Reuse(const TDbTupleRef& dbData) {
-        Y_VERIFY_DEBUG(dbData.ColumnCount == Size());
-        DbData = dbData;
-        ClearMask();
-    }
-
-private:
+ 
+    void OwnDb(THolder<TTableIt>&& iter) { 
+        Iter = std::move(iter); 
+    } 
+ 
+    void Reuse(const TDbTupleRef& dbData) { 
+        Y_VERIFY_DEBUG(dbData.ColumnCount == Size()); 
+        DbData = dbData; 
+        ClearMask(); 
+    } 
+ 
+private: 
     TSelectRangeLazyRow(const TDbTupleRef& dbData, const THolderFactory& holderFactory, ui32 maskSize,
         const TSmallVec<NTable::TTag>& systemColumnTags, ui64 shardId)
-        : TComputationValue<TSelectRangeLazyRow<TTableIt>>(&holderFactory.GetMemInfo())
-        , Iter()
-        , DbData(dbData)
-        , MaskSize(maskSize)
+        : TComputationValue<TSelectRangeLazyRow<TTableIt>>(&holderFactory.GetMemInfo()) 
+        , Iter() 
+        , DbData(dbData) 
+        , MaskSize(maskSize) 
         , SystemColumnTags(systemColumnTags)
         , ShardId(shardId)
-    {
-        ClearMask();
-        for (ui32 i = 0; i < Size(); ++i) {
+    { 
+        ClearMask(); 
+        for (ui32 i = 0; i < Size(); ++i) { 
             ::new(GetPtr() + i) NUdf::TUnboxedValue();
-        }
-    }
-
-private:
+        } 
+    } 
+ 
+private: 
     inline NUdf::TUnboxedValue* GetPtr() const {
-        return const_cast<NUdf::TUnboxedValue*>(reinterpret_cast<const NUdf::TUnboxedValue*>(this + 1));
-    }
-
-    inline ui64* GetMaskPtr() const {
+        return const_cast<NUdf::TUnboxedValue*>(reinterpret_cast<const NUdf::TUnboxedValue*>(this + 1)); 
+    } 
+ 
+    inline ui64* GetMaskPtr() const { 
         return reinterpret_cast<ui64*>(GetPtr() + Size());
-    }
-
-    inline ui32 Size() const {
+    } 
+ 
+    inline ui32 Size() const { 
         return DbData.ColumnCount + SystemColumnTags.size();
-    }
-
+    } 
+ 
     inline ui32 GetMaskSize() const {
         return MaskSize;
     }
 
-    inline void BuildValue(ui32 index) const {
-        Y_VERIFY_DEBUG(MaskSize > 0);
-
-        if (!TestMask(index)) {
+    inline void BuildValue(ui32 index) const { 
+        Y_VERIFY_DEBUG(MaskSize > 0); 
+ 
+        if (!TestMask(index)) { 
             if (index < DbData.ColumnCount) {
                 GetPtr()[index] = GetCellValue(DbData.Columns[index], DbData.Types[index]);
             } else {
@@ -437,53 +437,53 @@ private:
                     throw TSchemeErrorTabletException();
                 }
             }
-            SetMask(index);
-        }
-        Y_VERIFY_DEBUG(TestMask(index));
-    }
-
-    inline bool TestMask(ui32 index) const {
-        Y_VERIFY_DEBUG(index / 64 < MaskSize);
-        return GetMaskPtr()[index / 64] & ((ui64)1 << index % 64);
-    }
-
-    inline void SetMask(ui32 index) const {
-        Y_VERIFY_DEBUG(index / 64 < MaskSize);
-        GetMaskPtr()[index / 64] |= ((ui64)1 << index % 64);
-    }
-
-    void ClearMask() {
-        memset(GetMaskPtr(), 0, sizeof(ui64) * MaskSize);
-    }
-
-private:
-    THolder<TTableIt> Iter;
-    TDbTupleRef DbData;
-    ui32 MaskSize;
+            SetMask(index); 
+        } 
+        Y_VERIFY_DEBUG(TestMask(index)); 
+    } 
+ 
+    inline bool TestMask(ui32 index) const { 
+        Y_VERIFY_DEBUG(index / 64 < MaskSize); 
+        return GetMaskPtr()[index / 64] & ((ui64)1 << index % 64); 
+    } 
+ 
+    inline void SetMask(ui32 index) const { 
+        Y_VERIFY_DEBUG(index / 64 < MaskSize); 
+        GetMaskPtr()[index / 64] |= ((ui64)1 << index % 64); 
+    } 
+ 
+    void ClearMask() { 
+        memset(GetMaskPtr(), 0, sizeof(ui64) * MaskSize); 
+    } 
+ 
+private: 
+    THolder<TTableIt> Iter; 
+    TDbTupleRef DbData; 
+    ui32 MaskSize; 
     TSmallVec<NTable::TTag> SystemColumnTags;
     ui64 ShardId;
-};
-
-class TSelectRangeLazyRowsList : public TCustomListValue {
-public:
+}; 
+ 
+class TSelectRangeLazyRowsList : public TCustomListValue { 
+public: 
     template<class>
-    friend class TIterator;
+    friend class TIterator; 
 
     template<class TTableIt>
     class TIterator : public TComputationValue<TIterator<TTableIt>> {
-        static const ui32 PeriodicCallbackIterations = 1000;
-
+        static const ui32 PeriodicCallbackIterations = 1000; 
+ 
         using TBase = TComputationValue<TIterator<TTableIt>>;
 
-    public:
+    public: 
         TIterator(TMemoryUsageInfo* memInfo, const TSelectRangeLazyRowsList& list, TAutoPtr<TTableIt>&& iter,
             const TSmallVec<NTable::TTag>& systemColumnTags, ui64 shardId)
             : TBase(memInfo)
             , List(list)
-            , Iter(iter.Release())
-            , HasCurrent(false)
-            , Iterations(0)
-            , Items(0)
+            , Iter(iter.Release()) 
+            , HasCurrent(false) 
+            , Iterations(0) 
+            , Items(0) 
             , Bytes(0)
             , SystemColumnTags(systemColumnTags)
             , ShardId(shardId) {}
@@ -496,28 +496,28 @@ public:
             while (Iter->Next(NTable::ENext::Data) == NTable::EReady::Data) {
                 TDbTupleRef tuple = Iter->GetKey();
 
-                ++Iterations;
-                if (Iterations % PeriodicCallbackIterations == 0) {
-                    List.EngineHost.ExecPeriodicCallback();
-                }
-
-                List.EngineHost.GetCounters().SelectRangeDeletedRowSkips
-                    += std::exchange(Iter->Stats.DeletedRowSkips, 0);
+                ++Iterations; 
+                if (Iterations % PeriodicCallbackIterations == 0) { 
+                    List.EngineHost.ExecPeriodicCallback(); 
+                } 
 
+                List.EngineHost.GetCounters().SelectRangeDeletedRowSkips 
+                    += std::exchange(Iter->Stats.DeletedRowSkips, 0); 
+ 
                 List.EngineHost.GetCounters().InvisibleRowSkips
                     += std::exchange(Iter->Stats.InvisibleRowSkips, 0);
 
-                // Skip null keys
-                Y_VERIFY(List.SkipNullKeys.size() <= tuple.ColumnCount);
-                bool skipRow = false;
-                for (ui32 i = 0; i < List.SkipNullKeys.size(); ++i) {
-                    if (List.SkipNullKeys[i] && tuple.Columns[i].IsNull()) {
-                        skipRow = true;
-                        break;
-                    }
-                }
-                if (skipRow) {
-                    Clear();
+                // Skip null keys 
+                Y_VERIFY(List.SkipNullKeys.size() <= tuple.ColumnCount); 
+                bool skipRow = false; 
+                for (ui32 i = 0; i < List.SkipNullKeys.size(); ++i) { 
+                    if (List.SkipNullKeys[i] && tuple.Columns[i].IsNull()) { 
+                        skipRow = true; 
+                        break; 
+                    } 
+                } 
+                if (skipRow) { 
+                    Clear(); 
                     continue;
                 }
 
@@ -553,8 +553,8 @@ public:
 
                 Items++;
                 Bytes += rowSize;
-                List.EngineHost.GetCounters().SelectRangeRows++;
-                List.EngineHost.GetCounters().SelectRangeBytes += rowSize;
+                List.EngineHost.GetCounters().SelectRangeRows++; 
+                List.EngineHost.GetCounters().SelectRangeBytes += rowSize; 
                 List.KeyAccessSampler->AddSample(List.TableId, tuple.Cells());
 
                 if (HasCurrent && CurrentRowValue.UniqueBoxed()) {
@@ -568,7 +568,7 @@ public:
                 return true;
             }
 
-            List.EngineHost.GetCounters().SelectRangeDeletedRowSkips += std::exchange(Iter->Stats.DeletedRowSkips, 0);
+            List.EngineHost.GetCounters().SelectRangeDeletedRowSkips += std::exchange(Iter->Stats.DeletedRowSkips, 0); 
             List.EngineHost.GetCounters().InvisibleRowSkips += std::exchange(Iter->Stats.InvisibleRowSkips, 0);
 
             if (Iter->Last() ==  NTable::EReady::Page) {
@@ -594,72 +594,72 @@ public:
         ~TIterator() {
             if (HasCurrent) {
                 if (!CurrentRowValue.UniqueBoxed()) {
-                    CurrentRow()->OwnDb(std::move(Iter));
+                    CurrentRow()->OwnDb(std::move(Iter)); 
                 }
             }
         }
-    private:
-        void Clear() {
-            if (HasCurrent) {
-                if (!CurrentRowValue.UniqueBoxed()) {
-                    CurrentRow()->InvalidateDb();
-                }
-            }
-        }
-
-        TSelectRangeLazyRow<TTableIt>* CurrentRow() const {
-            return static_cast<TSelectRangeLazyRow<TTableIt>*>(CurrentRowValue.AsBoxed().Get());
-        }
-
-    private:
-        const TSelectRangeLazyRowsList& List;
-        THolder<TTableIt> Iter;
-        bool HasCurrent;
-        ui64 Iterations;
-        ui64 Items;
-        ui64 Bytes;
-        NUdf::TUnboxedValue CurrentRowValue;
+    private: 
+        void Clear() { 
+            if (HasCurrent) { 
+                if (!CurrentRowValue.UniqueBoxed()) { 
+                    CurrentRow()->InvalidateDb(); 
+                } 
+            } 
+        } 
+ 
+        TSelectRangeLazyRow<TTableIt>* CurrentRow() const { 
+            return static_cast<TSelectRangeLazyRow<TTableIt>*>(CurrentRowValue.AsBoxed().Get()); 
+        } 
+ 
+    private: 
+        const TSelectRangeLazyRowsList& List; 
+        THolder<TTableIt> Iter; 
+        bool HasCurrent; 
+        ui64 Iterations; 
+        ui64 Items; 
+        ui64 Bytes; 
+        NUdf::TUnboxedValue CurrentRowValue; 
         TSmallVec<NTable::TTag> SystemColumnTags;
         ui64 ShardId;
-    };
-
-public:
-    TSelectRangeLazyRowsList(NTable::TDatabase& db, const TScheme& scheme, const THolderFactory& holderFactory,
+    }; 
+ 
+public: 
+    TSelectRangeLazyRowsList(NTable::TDatabase& db, const TScheme& scheme, const THolderFactory& holderFactory, 
         const TTableId& tableId, ui64 localTid, const TSmallVec<NTable::TTag>& tags, const TSmallVec<bool>& skipNullKeys, const TTableRange& range,
-        ui64 itemsLimit, ui64 bytesLimit, bool reverse, TEngineHost& engineHost
+        ui64 itemsLimit, ui64 bytesLimit, bool reverse, TEngineHost& engineHost 
         , const TSmallVec<NTable::TTag>& systemColumnTags, ui64 shardId, IKeyAccessSampler::TPtr keyAccessSampler)
-        : TCustomListValue(&holderFactory.GetMemInfo())
-        , Db(db)
-        , Scheme(scheme)
-        , HolderFactory(holderFactory)
+        : TCustomListValue(&holderFactory.GetMemInfo()) 
+        , Db(db) 
+        , Scheme(scheme) 
+        , HolderFactory(holderFactory) 
         , TableId(tableId)
-        , LocalTid(localTid)
-        , Tags(tags)
+        , LocalTid(localTid) 
+        , Tags(tags) 
         , SystemColumnTags(systemColumnTags)
         , ShardId(shardId)
-        , SkipNullKeys(skipNullKeys)
-        , ItemsLimit(itemsLimit)
-        , BytesLimit(bytesLimit)
-        , RangeHolder(range)
+        , SkipNullKeys(skipNullKeys) 
+        , ItemsLimit(itemsLimit) 
+        , BytesLimit(bytesLimit) 
+        , RangeHolder(range) 
         , Reverse(reverse)
-        , EngineHost(engineHost)
+        , EngineHost(engineHost) 
         , KeyAccessSampler(keyAccessSampler)
     {}
 
     NUdf::TUnboxedValue GetListIterator() const override {
         const TScheme::TTableInfo* tableInfo = Scheme.GetTableInfo(LocalTid);
-        auto tableRange = RangeHolder.ToTableRange();
-
+        auto tableRange = RangeHolder.ToTableRange(); 
+ 
         TSmallVec<TRawTypeValue> keyFrom;
         TSmallVec<TRawTypeValue> keyTo;
-        ConvertTableKeys(Scheme, tableInfo, tableRange.From, keyFrom, nullptr);
-        ConvertTableKeys(Scheme, tableInfo, tableRange.To, keyTo, nullptr);
+        ConvertTableKeys(Scheme, tableInfo, tableRange.From, keyFrom, nullptr); 
+        ConvertTableKeys(Scheme, tableInfo, tableRange.To, keyTo, nullptr); 
 
         NTable::TKeyRange keyRange;
         keyRange.MinKey = keyFrom;
         keyRange.MaxKey = keyTo;
-        keyRange.MinInclusive = tableRange.InclusiveFrom;
-        keyRange.MaxInclusive = tableRange.InclusiveTo;
+        keyRange.MinInclusive = tableRange.InclusiveFrom; 
+        keyRange.MaxInclusive = tableRange.InclusiveTo; 
         if (Reverse) {
             auto read = Db.IterateRangeReverse(LocalTid, keyRange, Tags, EngineHost.GetReadVersion(TableId));
 
@@ -673,68 +673,68 @@ public:
                 new TIterator<NTable::TTableIt>(GetMemInfo(), *this, std::move(read), SystemColumnTags, ShardId)
             );
         }
-    }
-
+    } 
+ 
     NUdf::TUnboxedValue GetTruncated() const {
-        if (!Truncated) {
+        if (!Truncated) { 
             for (const auto it = GetListIterator(); it.Skip();)
                 continue;
-        }
-
-        Y_VERIFY_DEBUG(Truncated);
+        } 
+ 
+        Y_VERIFY_DEBUG(Truncated); 
         return NUdf::TUnboxedValuePod(*Truncated);
-    }
-
+    } 
+ 
     NUdf::TUnboxedValue GetFirstKey() const {
-        if (!FirstKey) {
+        if (!FirstKey) { 
             GetListIterator().Skip();
-        }
-
+        } 
+ 
         TString key = FirstKey ? *FirstKey : TString();
         return MakeString(key);
-    }
-
+    } 
+ 
     NUdf::TUnboxedValue GetSizeBytes() const {
-        if (!SizeBytes) {
+        if (!SizeBytes) { 
             for (const auto it = GetListIterator(); it.Skip();)
                 continue;
-        }
-
-        Y_VERIFY_DEBUG(SizeBytes);
+        } 
+ 
+        Y_VERIFY_DEBUG(SizeBytes); 
         return NUdf::TUnboxedValuePod(*SizeBytes);
-    }
-
-private:
+    } 
+ 
+private: 
     NTable::TDatabase& Db;
-    const TScheme& Scheme;
-    const THolderFactory& HolderFactory;
+    const TScheme& Scheme; 
+    const THolderFactory& HolderFactory; 
     TTableId TableId;
-    ui64 LocalTid;
+    ui64 LocalTid; 
     TSmallVec<NTable::TTag> Tags;
     TSmallVec<NTable::TTag> SystemColumnTags;
     ui64 ShardId;
-    TSmallVec<bool> SkipNullKeys;
-    ui64 ItemsLimit;
-    ui64 BytesLimit;
-    TSerializedTableRange RangeHolder;
+    TSmallVec<bool> SkipNullKeys; 
+    ui64 ItemsLimit; 
+    ui64 BytesLimit; 
+    TSerializedTableRange RangeHolder; 
     bool Reverse;
-
-    mutable TMaybe<bool> Truncated;
+ 
+    mutable TMaybe<bool> Truncated; 
     mutable TMaybe<TString> FirstKey;
-    mutable TMaybe<ui64> SizeBytes;
-    TEngineHost& EngineHost;
+    mutable TMaybe<ui64> SizeBytes; 
+    TEngineHost& EngineHost; 
     IKeyAccessSampler::TPtr KeyAccessSampler;
-};
-
-class TSelectRangeResult : public TComputationValue<TSelectRangeResult> {
-public:
+}; 
+ 
+class TSelectRangeResult : public TComputationValue<TSelectRangeResult> { 
+public: 
     TSelectRangeResult(NTable::TDatabase& db, const TScheme& scheme, const THolderFactory& holderFactory, const TTableId& tableId, ui64 localTid,
-        const TSmallVec<NTable::TTag>& tags, const TSmallVec<bool>& skipNullKeys, const TTableRange& range,
-        ui64 itemsLimit, ui64 bytesLimit, bool reverse, TEngineHost& engineHost,
+        const TSmallVec<NTable::TTag>& tags, const TSmallVec<bool>& skipNullKeys, const TTableRange& range, 
+        ui64 itemsLimit, ui64 bytesLimit, bool reverse, TEngineHost& engineHost, 
         const TSmallVec<NTable::TTag>& systemColumnTags, ui64 shardId, IKeyAccessSampler::TPtr keyAccessSampler)
         : TComputationValue(&holderFactory.GetMemInfo())
         , List(NUdf::TUnboxedValuePod(new TSelectRangeLazyRowsList(db, scheme, holderFactory, tableId, localTid, tags,
-            skipNullKeys, range, itemsLimit, bytesLimit, reverse, engineHost, systemColumnTags, shardId, keyAccessSampler))) {}
+            skipNullKeys, range, itemsLimit, bytesLimit, reverse, engineHost, systemColumnTags, shardId, keyAccessSampler))) {} 
 
 private:
     NUdf::TUnboxedValue GetElement(ui32 index) const override {
@@ -749,9 +749,9 @@ private:
         Y_FAIL("TSelectRangeResult: Index out of range.");
     }
 
-    NUdf::TUnboxedValue List;
-};
-
+    NUdf::TUnboxedValue List; 
+}; 
+ 
 static NUdf::TUnboxedValue CreateEmptyRange(const THolderFactory& holderFactory) {
     NUdf::TUnboxedValue* itemsPtr = nullptr;
     auto res = holderFactory.CreateDirectArrayHolder(4, itemsPtr);
@@ -784,7 +784,7 @@ static TSmallVec<bool> CreateBoolVec(const TListLiteral* list) {
 }
 
 NUdf::TUnboxedValue TEngineHost::SelectRange(const TTableId& tableId, const TTableRange& range,
-    TStructLiteral* columnIds, TListLiteral* skipNullKeys, TStructType* returnType, const TReadTarget& readTarget,
+    TStructLiteral* columnIds, TListLiteral* skipNullKeys, TStructType* returnType, const TReadTarget& readTarget, 
     ui64 itemsLimit, ui64 bytesLimit, bool reverse, std::pair<const TListLiteral*, const TListLiteral*> forbidNullArgs,
     const THolderFactory& holderFactory)
 {
@@ -798,24 +798,24 @@ NUdf::TUnboxedValue TEngineHost::SelectRange(const TTableId& tableId, const TTab
     //        , data // named 'Truncated' (boolean showing that itemsLimit or bytesLimit striked)
     //        >
     // And that struct type has column tags stored inside it's member names (ugly hack)
-
+ 
     Y_UNUSED(readTarget);
 
-    // TODO[serxa]: support for Point in SelectRange()
-    Y_VERIFY(!range.Point, "point request in TEngineHost::SelectRange");
+    // TODO[serxa]: support for Point in SelectRange() 
+    Y_VERIFY(!range.Point, "point request in TEngineHost::SelectRange"); 
 
     ui64 localTid = LocalTableId(tableId);
     Y_VERIFY(localTid, "table not exist");
 
     // Analyze resultType
     TStructType* outerStructType = AS_TYPE(TStructType, returnType);
-    Y_VERIFY_DEBUG(outerStructType->GetMembersCount() == 2,
-        "Unexpected type structure of returnType in TEngineHost::SelectRange()");
-    Y_VERIFY_DEBUG(outerStructType->GetMemberName(0) == "List",
-        "Unexpected type structure of returnType in TEngineHost::SelectRange()");
-    Y_VERIFY_DEBUG(outerStructType->GetMemberName(1) == "Truncated",
-        "Unexpected type structure of returnType in TEngineHost::SelectRange()");
-
+    Y_VERIFY_DEBUG(outerStructType->GetMembersCount() == 2, 
+        "Unexpected type structure of returnType in TEngineHost::SelectRange()"); 
+    Y_VERIFY_DEBUG(outerStructType->GetMemberName(0) == "List", 
+        "Unexpected type structure of returnType in TEngineHost::SelectRange()"); 
+    Y_VERIFY_DEBUG(outerStructType->GetMemberName(1) == "Truncated", 
+        "Unexpected type structure of returnType in TEngineHost::SelectRange()"); 
+ 
     TSmallVec<NTable::TTag> tags;
     TSmallVec<NTable::TTag> systemColumnTags;
     AnalyzeRowType(columnIds, tags, systemColumnTags);
@@ -830,9 +830,9 @@ NUdf::TUnboxedValue TEngineHost::SelectRange(const TTableId& tableId, const TTab
 
         if (keyIdx < range.From.size() && range.From[keyIdx].IsNull()) {
             return CreateEmptyRange(holderFactory);
-        }
-    }
-
+        } 
+    } 
+ 
     for (size_t keyIdx = 0; keyIdx < forbidNullArgsTo.size(); keyIdx++) {
         if (!forbidNullArgsTo[keyIdx])
             continue;
@@ -840,13 +840,13 @@ NUdf::TUnboxedValue TEngineHost::SelectRange(const TTableId& tableId, const TTab
         if (keyIdx < range.To.size() && range.To[keyIdx].IsNull()) {
             return CreateEmptyRange(holderFactory);
         }
-    }
-
+    } 
+ 
     Counters.NSelectRange++;
 
     return NUdf::TUnboxedValuePod(new TSelectRangeResult(Db, Scheme, holderFactory, tableId, localTid, tags,
-        skipNullKeysFlags, range, itemsLimit, bytesLimit, reverse, *this, systemColumnTags, GetShardId(),
-        Settings.KeyAccessSampler));
+        skipNullKeysFlags, range, itemsLimit, bytesLimit, reverse, *this, systemColumnTags, GetShardId(), 
+        Settings.KeyAccessSampler)); 
 }
 
 // Updates the single row. Column in commands must be unique.
@@ -856,7 +856,7 @@ void TEngineHost::UpdateRow(const TTableId& tableId, const TArrayRef<const TCell
     const TScheme::TTableInfo* tableInfo = Scheme.GetTableInfo(localTid);
     TSmallVec<TRawTypeValue> key;
     ui64 keyBytes = 0;
-    ConvertTableKeys(Scheme, tableInfo, row, key, &keyBytes);
+    ConvertTableKeys(Scheme, tableInfo, row, key, &keyBytes); 
 
     ui64 valueBytes = 0;
     TSmallVec<NTable::TUpdateOp> ops;
@@ -895,7 +895,7 @@ void TEngineHost::EraseRow(const TTableId& tableId, const TArrayRef<const TCell>
     const TScheme::TTableInfo* tableInfo = Scheme.GetTableInfo(localTid);
     TSmallVec<TRawTypeValue> key;
     ui64 keyBytes = 0;
-    ConvertTableKeys(Scheme, tableInfo, row, key, &keyBytes);
+    ConvertTableKeys(Scheme, tableInfo, row, key, &keyBytes); 
 
     if (auto collector = GetChangeCollector(tableId)) {
         collector->SetWriteVersion(GetWriteVersion(tableId));
@@ -939,13 +939,13 @@ ui64 TEngineHost::LocalTableId(const TTableId& tableId) const {
 void TEngineHost::ConvertKeys(const TScheme::TTableInfo* tableInfo, const TArrayRef<const TCell>& row,
     TSmallVec<TRawTypeValue>& key) const
 {
-    ConvertTableKeys(Scheme, tableInfo, row, key, nullptr);
-}
-
-void TEngineHost::SetPeriodicCallback(TPeriodicCallback&& callback) {
-    PeriodicCallback = std::move(callback);
+    ConvertTableKeys(Scheme, tableInfo, row, key, nullptr); 
 }
 
+void TEngineHost::SetPeriodicCallback(TPeriodicCallback&& callback) { 
+    PeriodicCallback = std::move(callback); 
+} 
+ 
 void AnalyzeRowType(TStructLiteral* columnIds, TSmallVec<NTable::TTag>& tags, TSmallVec<NTable::TTag>& systemColumnTags) {
     // Find out tags that should be read in Select*() functions
     tags.reserve(columnIds->GetValuesCount());
@@ -960,10 +960,10 @@ void AnalyzeRowType(TStructLiteral* columnIds, TSmallVec<NTable::TTag>& tags, TS
 }
 
 NUdf::TUnboxedValue GetCellValue(const TCell& cell, NScheme::TTypeId type) {
-    if (cell.IsNull()) {
+    if (cell.IsNull()) { 
         return NUdf::TUnboxedValue();
-    }
-
+    } 
+ 
     switch (type) {
         case NYql::NProto::TypeIds::Bool:
             return NUdf::TUnboxedValuePod(cell.AsValue<bool>());
@@ -1031,6 +1031,6 @@ NUdf::TUnboxedValue GetCellValue(const TCell& cell, NScheme::TTypeId type) {
             Y_VERIFY_DEBUG(false, "Unsupported type: %" PRIu16, type);
             return MakeString(NUdf::TStringRef(cell.Data(), cell.Size()));
     }
-}
-
+} 
+ 
 }}
diff --git a/ydb/core/engine/minikql/minikql_engine_host.h b/ydb/core/engine/minikql/minikql_engine_host.h
index 012ee6891b..4858752e11 100644
--- a/ydb/core/engine/minikql/minikql_engine_host.h
+++ b/ydb/core/engine/minikql/minikql_engine_host.h
@@ -102,28 +102,28 @@ public:
     ui64 CalculateReadSize(const TVector<const TKeyDesc*>& keys) const override;
     ui64 CalculateResultSize(const TKeyDesc& key) const override;
     void PinPages(const TVector<THolder<TKeyDesc>>& keys, ui64 pageFaultCount) override;
-
+ 
     NUdf::TUnboxedValue SelectRow(const TTableId& tableId, const TArrayRef<const TCell>& row,
         TStructLiteral* columnIds, TOptionalType* returnType, const TReadTarget& readTarget,
         const THolderFactory& holderFactory) override;
-
+ 
     NUdf::TUnboxedValue SelectRange(const TTableId& tableId, const TTableRange& range,
-        TStructLiteral* columnIds, TListLiteral* skipNullKeys, TStructType* returnType,
+        TStructLiteral* columnIds, TListLiteral* skipNullKeys, TStructType* returnType, 
         const TReadTarget& readTarget, ui64 itemsLimit, ui64 bytesLimit, bool reverse,
         std::pair<const TListLiteral*, const TListLiteral*> forbidNullArgs, const THolderFactory& holderFactory) override;
-
-    void UpdateRow(const TTableId& tableId, const TArrayRef<const TCell>& row,
-        const TArrayRef<const TUpdateCommand>& commands) override;
+ 
+    void UpdateRow(const TTableId& tableId, const TArrayRef<const TCell>& row, 
+        const TArrayRef<const TUpdateCommand>& commands) override; 
     void EraseRow(const TTableId& tableId, const TArrayRef<const TCell>& row) override;
     bool IsPathErased(const TTableId& tableId) const override;
     bool IsMyKey(const TTableId& tableId, const TArrayRef<const TCell>& row) const override;
     ui64 GetTableSchemaVersion(const TTableId&) const override;
 
-    void SetPeriodicCallback(TPeriodicCallback&& callback) override;
-    void ExecPeriodicCallback() { if (PeriodicCallback) { PeriodicCallback();} }
-
-    TEngineHostCounters& GetCounters() const { return Counters; }
-
+    void SetPeriodicCallback(TPeriodicCallback&& callback) override; 
+    void ExecPeriodicCallback() { if (PeriodicCallback) { PeriodicCallback();} } 
+ 
+    TEngineHostCounters& GetCounters() const { return Counters; } 
+ 
     virtual TRowVersion GetWriteVersion(const TTableId& tableId) const = 0;
     virtual TRowVersion GetReadVersion(const TTableId& tableId) const = 0;
 
@@ -131,16 +131,16 @@ public:
 
 protected:
     virtual ui64 LocalTableId(const TTableId& tableId) const;
-    void ConvertKeys(const TScheme::TTableInfo* tableInfo, const TArrayRef<const TCell>& row,
-        TSmallVec<TRawTypeValue>& key) const;
+    void ConvertKeys(const TScheme::TTableInfo* tableInfo, const TArrayRef<const TCell>& row, 
+        TSmallVec<TRawTypeValue>& key) const; 
     void DoCalculateReadSize(const TKeyDesc& key, NTable::TSizeEnv& env) const;
-
+ 
 protected:
     NTable::TDatabase& Db;
     const TScheme& Scheme;
     const TEngineHostSettings Settings;
     TEngineHostCounters& Counters;
-    TPeriodicCallback PeriodicCallback;
+    TPeriodicCallback PeriodicCallback; 
 };
 
 class TUnversionedEngineHost : public TEngineHost {
@@ -164,13 +164,13 @@ public:
 };
 
 void AnalyzeRowType(TStructLiteral* columnIds, TSmallVec<NTable::TTag>& tags, TSmallVec<NTable::TTag>& systemColumnTags);
-NUdf::TUnboxedValue GetCellValue(const TCell& cell, NScheme::TTypeId type);
-NUdf::TUnboxedValue CreateSelectRangeLazyRowsList(NTable::TDatabase& db, const NTable::TScheme& scheme,
+NUdf::TUnboxedValue GetCellValue(const TCell& cell, NScheme::TTypeId type); 
+NUdf::TUnboxedValue CreateSelectRangeLazyRowsList(NTable::TDatabase& db, const NTable::TScheme& scheme, 
     const THolderFactory& holderFactory, const TTableId& tableId, ui64 localTid, const TSmallVec<NTable::TTag>& tags,
-    const TSmallVec<bool>& skipNullKeys, const TTableRange& range, ui64 itemsLimit, ui64 bytesLimit,
+    const TSmallVec<bool>& skipNullKeys, const TTableRange& range, ui64 itemsLimit, ui64 bytesLimit, 
     bool reverse, TEngineHostCounters& counters, const TSmallVec<NTable::TTag>& systemColumnTags, ui64 shardId);
-
-void ConvertTableKeys(const NTable::TScheme& scheme, const NTable::TScheme::TTableInfo* tableInfo,
-    const TArrayRef<const TCell>& row, TSmallVec<TRawTypeValue>& key, ui64* keyDataBytes);
-
+ 
+void ConvertTableKeys(const NTable::TScheme& scheme, const NTable::TScheme::TTableInfo* tableInfo, 
+    const TArrayRef<const TCell>& row, TSmallVec<TRawTypeValue>& key, ui64* keyDataBytes); 
+ 
 }}
diff --git a/ydb/core/engine/mkql_engine_flat.cpp b/ydb/core/engine/mkql_engine_flat.cpp
index c7fe388eef..a5b7677cbc 100644
--- a/ydb/core/engine/mkql_engine_flat.cpp
+++ b/ydb/core/engine/mkql_engine_flat.cpp
@@ -15,7 +15,7 @@
 #include <ydb/core/tablet/tablet_exception.h>
 
 #include <util/string/printf.h>
-#include <util/string/vector.h>
+#include <util/string/vector.h> 
 #include <util/generic/set.h>
 
 namespace NKikimr {
@@ -23,120 +23,120 @@ namespace NMiniKQL {
 
 namespace {
 
-static const ui32 AllocNotifyCallbackBytes = 1 * 1024 * 1024; // 1 MB
-
-class TDeadlineExceededException: public yexception {
-    const char* what() const noexcept override {
-        return "TDeadlineExceededException";
-    }
-};
-
-TStructLiteral& GetPgmStruct(const TRuntimeNode& pgm) {
-    MKQL_ENSURE(pgm.IsImmediate() && pgm.GetStaticType()->IsStruct(),
-        "Shard program: Expected immediate struct");
-    auto& pgmStruct = static_cast<TStructLiteral&>(*pgm.GetNode());
-    MKQL_ENSURE(pgmStruct.GetValuesCount() == 5, "Shard program: Expected 5 memebers: "
-        << "AllReads, MyKeys, Run, ShardsForRead, ShardsToWrite");
-    return pgmStruct;
-}
-
-TStructLiteral& GetPgmMyKeysStruct(TStructLiteral& pgmStruct) {
-    TRuntimeNode myKeysNode = pgmStruct.GetValue(1);
-    MKQL_ENSURE(myKeysNode.IsImmediate() && myKeysNode.GetNode()->GetType()->IsStruct(),
-        "MyKeys: Expected immediate struct");
-    auto& myKeys = static_cast<TStructLiteral&>(*myKeysNode.GetNode());
-    MKQL_ENSURE(myKeys.GetValuesCount() == 2, "MyKeys: Expected 2 members: MyReads, MyWrites");
-    return myKeys;
-}
-
-TStructLiteral& GetPgmMyReadsStruct(TStructLiteral& pgmStruct) {
-    auto& myKeys = GetPgmMyKeysStruct(pgmStruct);
-    TRuntimeNode myReadsNode = myKeys.GetValue(0);
-    MKQL_ENSURE(myReadsNode.IsImmediate() && myReadsNode.GetNode()->GetType()->IsStruct(),
-        "MyReads: Expected immediate struct");
-    return static_cast<TStructLiteral&>(*myReadsNode.GetNode());
-}
-
+static const ui32 AllocNotifyCallbackBytes = 1 * 1024 * 1024; // 1 MB 
+ 
+class TDeadlineExceededException: public yexception { 
+    const char* what() const noexcept override { 
+        return "TDeadlineExceededException"; 
+    } 
+}; 
+ 
+TStructLiteral& GetPgmStruct(const TRuntimeNode& pgm) { 
+    MKQL_ENSURE(pgm.IsImmediate() && pgm.GetStaticType()->IsStruct(), 
+        "Shard program: Expected immediate struct"); 
+    auto& pgmStruct = static_cast<TStructLiteral&>(*pgm.GetNode()); 
+    MKQL_ENSURE(pgmStruct.GetValuesCount() == 5, "Shard program: Expected 5 memebers: " 
+        << "AllReads, MyKeys, Run, ShardsForRead, ShardsToWrite"); 
+    return pgmStruct; 
+} 
+ 
+TStructLiteral& GetPgmMyKeysStruct(TStructLiteral& pgmStruct) { 
+    TRuntimeNode myKeysNode = pgmStruct.GetValue(1); 
+    MKQL_ENSURE(myKeysNode.IsImmediate() && myKeysNode.GetNode()->GetType()->IsStruct(), 
+        "MyKeys: Expected immediate struct"); 
+    auto& myKeys = static_cast<TStructLiteral&>(*myKeysNode.GetNode()); 
+    MKQL_ENSURE(myKeys.GetValuesCount() == 2, "MyKeys: Expected 2 members: MyReads, MyWrites"); 
+    return myKeys; 
+} 
+ 
+TStructLiteral& GetPgmMyReadsStruct(TStructLiteral& pgmStruct) { 
+    auto& myKeys = GetPgmMyKeysStruct(pgmStruct); 
+    TRuntimeNode myReadsNode = myKeys.GetValue(0); 
+    MKQL_ENSURE(myReadsNode.IsImmediate() && myReadsNode.GetNode()->GetType()->IsStruct(), 
+        "MyReads: Expected immediate struct"); 
+    return static_cast<TStructLiteral&>(*myReadsNode.GetNode()); 
+} 
+ 
 const TStructLiteral& GetPgmShardsForReadStruct(const TStructLiteral& pgmStruct) {
-    TRuntimeNode shardsForReadNode = pgmStruct.GetValue(3);
-    MKQL_ENSURE(shardsForReadNode.IsImmediate() && shardsForReadNode.GetNode()->GetType()->IsStruct(),
-        "ShardsForRead: Expected immediate struct");
-    return static_cast<TStructLiteral&>(*shardsForReadNode.GetNode());
-}
-
-TStructLiteral& GetPgmShardsToWriteStruct(TStructLiteral& pgmStruct) {
-    TRuntimeNode shardsToWriteNode = pgmStruct.GetValue(4);
-    MKQL_ENSURE(shardsToWriteNode.IsImmediate() && shardsToWriteNode.GetNode()->GetType()->IsStruct(),
-        "ShardsToWrite: Expected immediate struct");
-    return static_cast<TStructLiteral&>(*shardsToWriteNode.GetNode());
-}
-
-TRuntimeNode GetPgmRun(TStructLiteral& pgmStruct) {
-    TRuntimeNode runPgm = pgmStruct.GetValue(2);
-    MKQL_ENSURE(runPgm.IsImmediate() && runPgm.GetNode()->GetType()->IsStruct(),
-        "Run: Expected immediate struct");
-    return runPgm;
-}
-
-TStructLiteral& GetPgmRunStruct(TStructLiteral& pgmStruct) {
-    TRuntimeNode runPgm = GetPgmRun(pgmStruct);
-    auto& runStruct = static_cast<TStructLiteral&>(*runPgm.GetNode());
-    MKQL_ENSURE(runStruct.GetValuesCount() == 2, "Run: Expected 2 members: Reply, Write");
-    return runStruct;
-}
-
-TStructLiteral& GetPgmReplyStruct(TStructLiteral& pgmStruct) {
-    auto& runStruct = GetPgmRunStruct(pgmStruct);
-    TRuntimeNode replyNode = runStruct.GetValue(0);
-    MKQL_ENSURE(replyNode.IsImmediate() && replyNode.GetNode()->GetType()->IsStruct(),
-        "Reply: Expected immediate struct");
-    return static_cast<TStructLiteral&>(*replyNode.GetNode());
-}
-
-class TCallableResults {
-public:
+    TRuntimeNode shardsForReadNode = pgmStruct.GetValue(3); 
+    MKQL_ENSURE(shardsForReadNode.IsImmediate() && shardsForReadNode.GetNode()->GetType()->IsStruct(), 
+        "ShardsForRead: Expected immediate struct"); 
+    return static_cast<TStructLiteral&>(*shardsForReadNode.GetNode()); 
+} 
+ 
+TStructLiteral& GetPgmShardsToWriteStruct(TStructLiteral& pgmStruct) { 
+    TRuntimeNode shardsToWriteNode = pgmStruct.GetValue(4); 
+    MKQL_ENSURE(shardsToWriteNode.IsImmediate() && shardsToWriteNode.GetNode()->GetType()->IsStruct(), 
+        "ShardsToWrite: Expected immediate struct"); 
+    return static_cast<TStructLiteral&>(*shardsToWriteNode.GetNode()); 
+} 
+ 
+TRuntimeNode GetPgmRun(TStructLiteral& pgmStruct) { 
+    TRuntimeNode runPgm = pgmStruct.GetValue(2); 
+    MKQL_ENSURE(runPgm.IsImmediate() && runPgm.GetNode()->GetType()->IsStruct(), 
+        "Run: Expected immediate struct"); 
+    return runPgm; 
+} 
+ 
+TStructLiteral& GetPgmRunStruct(TStructLiteral& pgmStruct) { 
+    TRuntimeNode runPgm = GetPgmRun(pgmStruct); 
+    auto& runStruct = static_cast<TStructLiteral&>(*runPgm.GetNode()); 
+    MKQL_ENSURE(runStruct.GetValuesCount() == 2, "Run: Expected 2 members: Reply, Write"); 
+    return runStruct; 
+} 
+ 
+TStructLiteral& GetPgmReplyStruct(TStructLiteral& pgmStruct) { 
+    auto& runStruct = GetPgmRunStruct(pgmStruct); 
+    TRuntimeNode replyNode = runStruct.GetValue(0); 
+    MKQL_ENSURE(replyNode.IsImmediate() && replyNode.GetNode()->GetType()->IsStruct(), 
+        "Reply: Expected immediate struct"); 
+    return static_cast<TStructLiteral&>(*replyNode.GetNode()); 
+} 
+ 
+class TCallableResults { 
+public: 
     void AddResult(ui32 id, const TStringBuf& result, const TTypeEnvironment& env) {
         const auto insertResult = ResultsMap.emplace(id, env.NewStringValue(result));
-        MKQL_ENSURE(insertResult.second, "TCallableResults: duplicate result id: " << id);
-    }
-
+        MKQL_ENSURE(insertResult.second, "TCallableResults: duplicate result id: " << id); 
+    } 
+ 
     typedef std::unordered_map<ui32, NUdf::TUnboxedValue> TResultsMap;
-
+ 
     const TResultsMap& GetMap() const { return ResultsMap; }
 
-public:
+public: 
     TString ToString(const THolderFactory& holderFactory, const TTypeEnvironment& env) const {
         const NUdf::TUnboxedValue value(GetResultsValue(holderFactory));
         return TString(TValuePacker(false, GetResultsType(env)).Pack(value));
-    }
-
-    static TCallableResults FromString(const TStringBuf& valueStr, const THolderFactory& holderFactory,
-        const TTypeEnvironment& env)
-    {
-        TCallableResults callableResults;
-
+    } 
+ 
+    static TCallableResults FromString(const TStringBuf& valueStr, const THolderFactory& holderFactory, 
+        const TTypeEnvironment& env) 
+    { 
+        TCallableResults callableResults; 
+ 
         TValuePacker packer(false, GetResultsType(env));
-        NUdf::TUnboxedValue value = packer.Unpack(valueStr, holderFactory);
+        NUdf::TUnboxedValue value = packer.Unpack(valueStr, holderFactory); 
         const auto it = value.GetListIterator();
         for (NUdf::TUnboxedValue resultStruct; it.Next(resultStruct);) {
             ui32 id = resultStruct.GetElement(0).Get<ui32>();
             NUdf::TUnboxedValue result = resultStruct.GetElement(1);
             callableResults.AddResult(id, result.AsStringRef(), env);
-        }
-
-        return callableResults;
-    }
-
-private:
-    static TListType* GetResultsType(const TTypeEnvironment& env) {
+        } 
+ 
+        return callableResults; 
+    } 
+ 
+private: 
+    static TListType* GetResultsType(const TTypeEnvironment& env) { 
         const std::array<std::pair<TString, TType*>, 2> members = {{
             {"Id", TDataType::Create(NUdf::TDataType<ui32>::Id, env)},
             {"Result", TDataType::Create(NUdf::TDataType<char*>::Id, env)}
         }};
-
+ 
         return TListType::Create(TStructType::Create(members.data(), members.size(), env), env);
-    }
-
+    } 
+ 
     NUdf::TUnboxedValue GetResultsValue(const THolderFactory& holderFactory) const {
         NUdf::TUnboxedValue* items = nullptr;
         auto results = holderFactory.CreateDirectArrayHolder(ResultsMap.size(), items);
@@ -145,29 +145,29 @@ private:
             *items++ = holderFactory.CreateDirectArrayHolder(2, resultItems);
             resultItems[0] = NUdf::TUnboxedValuePod(pair.first);
             resultItems[1] = pair.second;
-        }
-
+        } 
+ 
         return std::move(results);
-    }
-
-private:
+    } 
+ 
+private: 
     TResultsMap ResultsMap;
-};
-
+}; 
+ 
 TRuntimeNode ReplaceAsVoid(TCallable& callable, const TTypeEnvironment& env) {
     Y_UNUSED(callable);
     return TRuntimeNode(env.GetVoid(), true);
 };
 
-TRuntimeNode RenameCallable(TCallable& callable, const TStringBuf& newName, const TTypeEnvironment& env) {
-    TCallableBuilder builder(env, newName, callable.GetType()->GetReturnType());
-    for (ui32 i = 0; i < callable.GetInputsCount(); ++i) {
-        builder.Add(callable.GetInput(i));
-    }
-
-    return TRuntimeNode(builder.Build(), false);
-}
-
+TRuntimeNode RenameCallable(TCallable& callable, const TStringBuf& newName, const TTypeEnvironment& env) { 
+    TCallableBuilder builder(env, newName, callable.GetType()->GetReturnType()); 
+    for (ui32 i = 0; i < callable.GetInputsCount(); ++i) { 
+        builder.Add(callable.GetInput(i)); 
+    } 
+ 
+    return TRuntimeNode(builder.Build(), false); 
+} 
+ 
 void ExtractResultType(TCallable& callable, const TTypeEnvironment& env, TMap<TString, TType*>& resTypes) {
     MKQL_ENSURE(callable.GetInputsCount() == 2, "Expected 2 args");
 
@@ -179,8 +179,8 @@ void ExtractResultType(TCallable& callable, const TTypeEnvironment& env, TMap<TS
 
     TStringBuf label = labelData.AsValue().AsStringRef();
     MKQL_ENSURE(!label.empty(), "Empty result label is not allowed");
-    MKQL_ENSURE(!label.StartsWith(TxInternalResultPrefix),
-        TStringBuilder() << "Label can't be used in SetResult as it's reserved for internal purposes: " << label);
+    MKQL_ENSURE(!label.StartsWith(TxInternalResultPrefix), 
+        TStringBuilder() << "Label can't be used in SetResult as it's reserved for internal purposes: " << label); 
 
     auto payload = callable.GetInput(1);
     MKQL_ENSURE(CanExportType(payload.GetStaticType(), env),
@@ -200,7 +200,7 @@ void ExtractAcquireLocksType(const TTypeEnvironment& env, TMap<TString, TType*>&
     {
         auto lockStructType = GetTxLockType(env, false);
         auto lockListType = TListType::Create(lockStructType, env);
-
+ 
         auto& type = resTypes[TString(TxLocksResultLabel)];
         MKQL_ENSURE(!type, TStringBuilder() << "Duplicate result label: " << TxLocksResultLabel);
         type = lockListType;
@@ -214,28 +214,28 @@ void ExtractAcquireLocksType(const TTypeEnvironment& env, TMap<TString, TType*>&
         MKQL_ENSURE(!type, TStringBuilder() << "Duplicate result label: " << TxLocksResultLabel2);
         type = lockListType;
     }
-}
-
+} 
+ 
 void ExtractDiagnosticsType(const TTypeEnvironment& env, TMap<TString, TType*>& resTypes) {
     auto structType = GetDiagnosticsType(env);
     auto listType = TListType::Create(structType, env);
 
     auto& type = resTypes[TString(TxInfoResultLabel)];
-    MKQL_ENSURE(!type, TStringBuilder() << "Duplicate result label: " << TxInfoResultLabel);
-    type = listType;
+    MKQL_ENSURE(!type, TStringBuilder() << "Duplicate result label: " << TxInfoResultLabel); 
+    type = listType; 
 }
 
-ui64 ExtractAcquireLocksTxId(TCallable& callable) {
-    MKQL_ENSURE(callable.GetInputsCount() == 1, "Expected 1 arg");
-
-    auto lockTxIdInput = callable.GetInput(0);
-    MKQL_ENSURE(lockTxIdInput.IsImmediate() && lockTxIdInput.GetNode()->GetType()->IsData(), "Expected immediate data");
-
-    const auto& lockTxIdData = static_cast<const TDataLiteral&>(*lockTxIdInput.GetNode());
+ui64 ExtractAcquireLocksTxId(TCallable& callable) { 
+    MKQL_ENSURE(callable.GetInputsCount() == 1, "Expected 1 arg"); 
+ 
+    auto lockTxIdInput = callable.GetInput(0); 
+    MKQL_ENSURE(lockTxIdInput.IsImmediate() && lockTxIdInput.GetNode()->GetType()->IsData(), "Expected immediate data"); 
+ 
+    const auto& lockTxIdData = static_cast<const TDataLiteral&>(*lockTxIdInput.GetNode()); 
     MKQL_ENSURE(lockTxIdData.GetType()->GetSchemeType() == NUdf::TDataType<ui64>::Id, "Expected Uint64");
     return lockTxIdData.AsValue().Get<ui64>();
-}
-
+} 
+ 
 class TEngineFlat : public IEngineFlat {
 public:
     TEngineFlat(const TEngineFlatSettings& settings)
@@ -253,7 +253,7 @@ public:
         , AreOutgoingReadSetsExtracted(false)
         , AreIncomingReadsetsPrepared(false)
         , IsExecuted(false)
-        , ReadOnlyOriginPrograms(true)
+        , ReadOnlyOriginPrograms(true) 
         , IsCancelled(false)
     {
         Ui64Type = TDataType::Create(NUdf::TDataType<ui64>::Id, Env);
@@ -276,16 +276,16 @@ public:
 
     void AddTabletInfo(IEngineFlat::TTabletInfo&& info) noexcept override {
         TabletInfos.emplace_back(info);
-    }
-
+    } 
+ 
     void AddTxLock(IEngineFlat::TTxLock&& txLock) noexcept override {
         TxLocks.emplace_back(txLock);
     }
 
-    TMaybe<ui64> GetLockTxId() noexcept override {
-        return LockTxId;
-    }
-
+    TMaybe<ui64> GetLockTxId() noexcept override { 
+        return LockTxId; 
+    } 
+ 
     bool HasDiagnosticsRequest() noexcept override {
         return NeedDiagnostics;
     }
@@ -335,18 +335,18 @@ public:
                     if (desc) {
                         it->second.Key = desc.Get();
                         dbKeys.push_back(std::move(desc));
-                    } else if (callable.GetType()->GetNameStr() == Strings.SetResult) {
+                    } else if (callable.GetType()->GetNameStr() == Strings.SetResult) { 
                         ExtractResultType(callable, Env, resTypes);
-                    } else if (callable.GetType()->GetNameStr() == Strings.AcquireLocks) {
+                    } else if (callable.GetType()->GetNameStr() == Strings.AcquireLocks) { 
                         ExtractAcquireLocksType(Env, resTypes);
-                        ui64 lockTxId = ExtractAcquireLocksTxId(callable);
-
-                        if (LockTxId) {
-                            AddError("SetProgram", __LINE__, "Multiple AcquireLocks calls.");
-                            return EResult::ProgramError;
-                        }
-
-                        LockTxId = lockTxId;
+                        ui64 lockTxId = ExtractAcquireLocksTxId(callable); 
+
+                        if (LockTxId) { 
+                            AddError("SetProgram", __LINE__, "Multiple AcquireLocks calls."); 
+                            return EResult::ProgramError; 
+                        } 
+ 
+                        LockTxId = lockTxId; 
                     } else if (callable.GetType()->GetNameStr() == Strings.Diagnostics) {
                         NeedDiagnostics = true;
                         ExtractDiagnosticsType(Env, resTypes);
@@ -366,7 +366,7 @@ public:
             }
         }
         catch (yexception& e) {
-            Alloc.InvalidateMemInfo();
+            Alloc.InvalidateMemInfo(); 
             HandleException("SetProgram", __LINE__, e);
             return EResult::ProgramError;
         }
@@ -408,23 +408,23 @@ public:
             }
         }
 
-        bool hasWrites = false;
-        const auto& strings = Strings;
-        auto writesCheck = [&hasWrites, &strings](TInternName name) {
+        bool hasWrites = false; 
+        const auto& strings = Strings; 
+        auto writesCheck = [&hasWrites, &strings](TInternName name) { 
             if (strings.DbWrites.contains(name)) {
-                hasWrites = true;
-            }
-
-            return TCallableVisitFunc();
-        };
-
-        bool wereChanges;
-        ProgramExplorer.Walk(Program.GetNode(), Env);
-        SinglePassVisitCallables(Program, ProgramExplorer, writesCheck, Env, true, wereChanges);
-        Y_VERIFY(!wereChanges);
-
-        ReadOnlyProgram = !hasWrites;
-
+                hasWrites = true; 
+            } 
+ 
+            return TCallableVisitFunc(); 
+        }; 
+ 
+        bool wereChanges; 
+        ProgramExplorer.Walk(Program.GetNode(), Env); 
+        SinglePassVisitCallables(Program, ProgramExplorer, writesCheck, Env, true, wereChanges); 
+        Y_VERIFY(!wereChanges); 
+ 
+        ReadOnlyProgram = !hasWrites; 
+ 
         AffectedShards.reserve(affectedShardSet.size());
         ui64 coordinatorRequiresShardCount = 0;
         for (ui64 shard : affectedShardSet) {
@@ -446,22 +446,22 @@ public:
             }
         }
 
-        THashSet<std::pair<ui64, ui64>> readsets;
+        THashSet<std::pair<ui64, ui64>> readsets; 
         if (Settings.EvaluateResultValue) {
             SpecializedParts.resize(AffectedShards.size());
             PrepareProxyProgram();
             PrepareShardsForRead();
-            THashMap<ui32, const TVector<TKeyDesc::TPartitionInfo>*> proxyShards;
+            THashMap<ui32, const TVector<TKeyDesc::TPartitionInfo>*> proxyShards; 
             for (auto& x : ProxyCallables) {
                 auto name = x.second.Node->GetType()->GetNameStr();
                 if (name == Strings.EraseRow || name == Strings.UpdateRow) {
-                    proxyShards[x.first] = &x.second.Key->Partitions;
+                    proxyShards[x.first] = &x.second.Key->Partitions; 
                 }
             }
 
             for (ui32 shardIndex = 0; shardIndex < AffectedShards.size(); ++shardIndex) {
-                PrepareShardProgram(AffectedShards[shardIndex].ShardId, proxyShards, SpecializedParts[shardIndex],
-                    readsets);
+                PrepareShardProgram(AffectedShards[shardIndex].ShardId, proxyShards, SpecializedParts[shardIndex], 
+                    readsets); 
             }
 
             BuildAllReads();
@@ -473,26 +473,26 @@ public:
             ProgramExplorer.Clear();
         }
 
-        if (readsets.size() > limits.RSCount) {
-            THashMap<ui64, TTableId> tableMap;
-            for (auto& key : DbKeys) {
-                for (auto& partition : key->Partitions) {
-                    tableMap[partition.ShardId] = key->TableId;
-                }
-            }
-
+        if (readsets.size() > limits.RSCount) { 
+            THashMap<ui64, TTableId> tableMap; 
+            for (auto& key : DbKeys) { 
+                for (auto& partition : key->Partitions) { 
+                    tableMap[partition.ShardId] = key->TableId; 
+                } 
+            } 
+ 
             TTablePathHashSet srcTables;
             TTablePathHashSet dstTables;
-            for (auto& readset : readsets) {
-                srcTables.emplace(tableMap[readset.first]);
-                dstTables.emplace(tableMap[readset.second]);
-            }
-
+            for (auto& readset : readsets) { 
+                srcTables.emplace(tableMap[readset.first]); 
+                dstTables.emplace(tableMap[readset.second]); 
+            } 
+ 
             AddError("PrepareShardPrograms", __LINE__,
                 Sprintf("too many shard readsets (%u > %u), src tables: %s, dst tables: %s",
-                (ui32)readsets.size(),
-                limits.RSCount,
-                JoinStrings(srcTables.begin(), srcTables.end(), ",").c_str(),
+                (ui32)readsets.size(), 
+                limits.RSCount, 
+                JoinStrings(srcTables.begin(), srcTables.end(), ",").c_str(), 
                 JoinStrings(dstTables.begin(), dstTables.end(), ",").c_str()).data());
             return EResult::TooManyRS;
         }
@@ -501,12 +501,12 @@ public:
         return EResult::Ok;
     }
 
-    bool IsReadOnlyProgram() const noexcept override {
-        Y_VERIFY(AreAffectedShardsPrepared, "PrepareShardPrograms must be called first");
-        Y_VERIFY(ReadOnlyProgram, "Invalid call to IsReadOnlyProgram");
-        return *ReadOnlyProgram;
-    }
-
+    bool IsReadOnlyProgram() const noexcept override { 
+        Y_VERIFY(AreAffectedShardsPrepared, "PrepareShardPrograms must be called first"); 
+        Y_VERIFY(ReadOnlyProgram, "Invalid call to IsReadOnlyProgram"); 
+        return *ReadOnlyProgram; 
+    } 
+ 
     ui32 GetAffectedShardCount() const noexcept override {
         Y_VERIFY(AreAffectedShardsPrepared, "PrepareShardPrograms must be called first");
         Y_VERIFY(!AreShardProgramsExtracted, "AfterShardProgramsExtracted is already called");
@@ -532,7 +532,7 @@ public:
         AreShardProgramsExtracted = true;
     }
 
-    void AddShardReply(ui64 origin, const TStringBuf& reply) noexcept override {
+    void AddShardReply(ui64 origin, const TStringBuf& reply) noexcept override { 
         Y_VERIFY(!IsResultBuilt, "BuildResult is already called");
         TGuard<TScopedAlloc> allocGuard(Alloc);
         if (reply.empty()) {
@@ -541,8 +541,8 @@ public:
             return;
         }
 
-        auto insertResult = ExecutionReplies.insert(std::make_pair(origin, reply));
-        Y_VERIFY(insertResult.second);
+        auto insertResult = ExecutionReplies.insert(std::make_pair(origin, reply)); 
+        Y_VERIFY(insertResult.second); 
     }
 
     void FinalizeOriginReplies(ui64 origin) noexcept override {
@@ -607,13 +607,13 @@ public:
                     TMemoryUsageInfo memInfo("Memory");
                     THolderFactory holderFactory(Alloc.Ref(), memInfo, Settings.FunctionRegistry);
 
-                    for (auto& pair : ExecutionReplies) {
+                    for (auto& pair : ExecutionReplies) { 
                         const TString& reply = pair.second;
-
+ 
                         TCallableResults results = TCallableResults::FromString(reply, holderFactory, Env);
                         for (const auto& pair : results.GetMap()) {
-                            ui32 id = pair.first;
-
+                            ui32 id = pair.first; 
+ 
                             const auto nodeIt = ProxyRepliesCallables.find(id);
                             if (nodeIt == ProxyRepliesCallables.end()) {
                                 AddError("BuildResult", __LINE__, Sprintf(
@@ -625,10 +625,10 @@ public:
                             execData.Results[id].emplace_back(pair.second.AsStringRef());
                         }
                     }
-                }
+                } 
 
-                NUdf::TUnboxedValue value;
-                {
+                NUdf::TUnboxedValue value; 
+                { 
                     TComputationPatternOpts opts(Alloc.Ref(), Env,
                         GetFlatProxyExecutionFactory(execData),
                         Settings.FunctionRegistry,
@@ -636,9 +636,9 @@ public:
                         Settings.LlvmRuntime ? "" : "OFF", EGraphPerProcess::Multi);
                     Pattern = MakeComputationPattern(ProxyProgramExplorer, ProxyProgram, {}, opts);
                     ResultGraph = Pattern->Clone(opts.ToComputationOptions(Settings.RandomProvider, Settings.TimeProvider));
-
+ 
                     const TBindTerminator bind(ResultGraph->GetTerminator());
-
+ 
                     value = ResultGraph->GetValue();
                 }
 
@@ -650,20 +650,20 @@ public:
                     Status = EStatus::Aborted;
                 }
             }
-            catch (const TMemoryLimitExceededException& e) {
-                Alloc.InvalidateMemInfo();
-                AddError("Memory limit exceeded during query result computation");
-                Status = EStatus::Error;
-                return;
-            }
-            catch (TDeadlineExceededException&) {
-                IsCancelled = true;
-                AddError("Deadline exceeded during query result computation");
-                Status = EStatus::Aborted;
-                return;
-            }
+            catch (const TMemoryLimitExceededException& e) { 
+                Alloc.InvalidateMemInfo(); 
+                AddError("Memory limit exceeded during query result computation"); 
+                Status = EStatus::Error; 
+                return; 
+            } 
+            catch (TDeadlineExceededException&) { 
+                IsCancelled = true; 
+                AddError("Deadline exceeded during query result computation"); 
+                Status = EStatus::Aborted; 
+                return; 
+            } 
             catch (yexception& e) {
-                Alloc.InvalidateMemInfo();
+                Alloc.InvalidateMemInfo(); 
                 HandleException("BuildResult", __LINE__, e);
                 Status = EStatus::Error;
                 return;
@@ -680,11 +680,11 @@ public:
         return Status;
     }
 
-    EResult FillResultValue(NKikimrMiniKQL::TResult& result) const noexcept override {
-        if (IsCancelled) {
-            return EResult::Cancelled;
-        }
-
+    EResult FillResultValue(NKikimrMiniKQL::TResult& result) const noexcept override { 
+        if (IsCancelled) { 
+            return EResult::Cancelled; 
+        } 
+ 
         Y_VERIFY(IsResultBuilt, "BuildResult is not called yet");
         TGuard<TScopedAlloc> allocGuard(Alloc);
         if (Settings.EvaluateResultType) {
@@ -692,49 +692,49 @@ public:
         }
 
         if (Settings.EvaluateResultValue) {
-            try {
-                const TBindTerminator bind(ResultGraph->GetTerminator());
-
-                for (ui32 index = 0; index < ResultType->GetMembersCount(); ++index) {
-                    auto memberType = ResultType->GetMemberType(index);
-                    auto itemType = static_cast<TOptionalType*>(memberType)->GetItemType();
-                    auto value = ResultValues.FindPtr(ResultType->GetMemberName(index));
-                    auto resStruct = result.MutableValue()->AddStruct();
-                    if (value) {
-                        ExportValueToProto(itemType, *value, *resStruct->MutableOptional());
-                    }
-
-                    auto resultSize = result.ByteSize();
-                    if (resultSize > (i32)MaxProxyReplySize) {
-                        result = {};
-                        TString error = TStringBuilder() << "Query result size limit exceeded. ("
-                            << resultSize << " > " << MaxProxyReplySize << ")";
-
-                        AddError(error);
-                        return EResult::ResultTooBig;
-                    }
-                }
+            try { 
+                const TBindTerminator bind(ResultGraph->GetTerminator()); 
+ 
+                for (ui32 index = 0; index < ResultType->GetMembersCount(); ++index) { 
+                    auto memberType = ResultType->GetMemberType(index); 
+                    auto itemType = static_cast<TOptionalType*>(memberType)->GetItemType(); 
+                    auto value = ResultValues.FindPtr(ResultType->GetMemberName(index)); 
+                    auto resStruct = result.MutableValue()->AddStruct(); 
+                    if (value) { 
+                        ExportValueToProto(itemType, *value, *resStruct->MutableOptional()); 
+                    } 
+ 
+                    auto resultSize = result.ByteSize(); 
+                    if (resultSize > (i32)MaxProxyReplySize) { 
+                        result = {}; 
+                        TString error = TStringBuilder() << "Query result size limit exceeded. (" 
+                            << resultSize << " > " << MaxProxyReplySize << ")"; 
+ 
+                        AddError(error); 
+                        return EResult::ResultTooBig; 
+                    } 
+                } 
             }
-            catch (const TMemoryLimitExceededException& e) {
-                Alloc.InvalidateMemInfo();
-                AddError("Memory limit exceeded during query result computation");
-                return EResult::ProgramError;
-            }
-            catch (TDeadlineExceededException&) {
-                AddError("Deadline exceeded during query result computation");
-                return EResult::Cancelled;
-            }
-            catch (yexception& e) {
-                Alloc.InvalidateMemInfo();
-                HandleException("FillResultValue", __LINE__, e);
-                return EResult::ProgramError;
-            }
-        }
-
-        return EResult::Ok;
-    }
-
-    EResult AddProgram(ui64 origin, const TStringBuf& program, bool readOnly) noexcept override {
+            catch (const TMemoryLimitExceededException& e) { 
+                Alloc.InvalidateMemInfo(); 
+                AddError("Memory limit exceeded during query result computation"); 
+                return EResult::ProgramError; 
+            } 
+            catch (TDeadlineExceededException&) { 
+                AddError("Deadline exceeded during query result computation"); 
+                return EResult::Cancelled; 
+            } 
+            catch (yexception& e) { 
+                Alloc.InvalidateMemInfo(); 
+                HandleException("FillResultValue", __LINE__, e); 
+                return EResult::ProgramError; 
+            } 
+        }
+ 
+        return EResult::Ok; 
+    }
+
+    EResult AddProgram(ui64 origin, const TStringBuf& program, bool readOnly) noexcept override { 
         Y_VERIFY(ProgramPerOrigin.find(origin) == ProgramPerOrigin.end(), "Program for that origin is already added");
         TGuard<TScopedAlloc> allocGuard(Alloc);
         TRuntimeNode node;
@@ -742,13 +742,13 @@ public:
             node = DeserializeRuntimeNode(program, Env);
         }
         catch (yexception& e) {
-            Alloc.InvalidateMemInfo();
+            Alloc.InvalidateMemInfo(); 
             HandleException("AddProgram", __LINE__, e);
             return EResult::ProgramError;
         }
 
-        ReadOnlyOriginPrograms = ReadOnlyOriginPrograms && readOnly;
-
+        ReadOnlyOriginPrograms = ReadOnlyOriginPrograms && readOnly; 
+ 
         ProgramPerOrigin[origin] = node;
         return EResult::Ok;
     }
@@ -1026,13 +1026,13 @@ public:
                 Settings.LlvmRuntime ? "" : "OFF", EGraphPerProcess::Multi);
             auto pattern = MakeComputationPattern(explorer, runPgm, {}, opts);
             auto graph = pattern->Clone(opts.ToComputationOptions(Settings.RandomProvider, Settings.TimeProvider));
-
+ 
             const TBindTerminator bind(graph->GetTerminator());
-
+ 
             graph->Prepare();
         }
         catch (yexception& e) {
-            Alloc.InvalidateMemInfo();
+            Alloc.InvalidateMemInfo(); 
             HandleException("Validate", __LINE__, e);
             return EResult::ProgramError;
         }
@@ -1103,25 +1103,25 @@ public:
 
             TMemoryUsageInfo memInfo("Memory");
             THolderFactory holderFactory(Alloc.Ref(), memInfo, Settings.FunctionRegistry);
-
+ 
             for (auto pgm : ProgramPerOrigin) {
-                auto& pgmStruct = GetPgmStruct(pgm.second);
-                auto& myReads = GetPgmMyReadsStruct(pgmStruct);
-                auto& shardsToWrite = GetPgmShardsToWriteStruct(pgmStruct);
-
-                ui32 readIdx = 0;
-                ui32 writeIdx = 0;
-                while (readIdx < myReads.GetValuesCount() && writeIdx < shardsToWrite.GetValuesCount()) {
-                    auto readName = myReads.GetType()->GetMemberName(readIdx);
-                    auto writeName = shardsToWrite.GetType()->GetMemberName(writeIdx);
-
-                    if (readName == writeName) {
-                        auto shardsList = AS_VALUE(TListLiteral, shardsToWrite.GetValue(writeIdx));
+                auto& pgmStruct = GetPgmStruct(pgm.second); 
+                auto& myReads = GetPgmMyReadsStruct(pgmStruct); 
+                auto& shardsToWrite = GetPgmShardsToWriteStruct(pgmStruct); 
+
+                ui32 readIdx = 0; 
+                ui32 writeIdx = 0; 
+                while (readIdx < myReads.GetValuesCount() && writeIdx < shardsToWrite.GetValuesCount()) { 
+                    auto readName = myReads.GetType()->GetMemberName(readIdx); 
+                    auto writeName = shardsToWrite.GetType()->GetMemberName(writeIdx); 
+
+                    if (readName == writeName) { 
+                        auto shardsList = AS_VALUE(TListLiteral, shardsToWrite.GetValue(writeIdx)); 
                         auto itemType = shardsList->GetType()->GetItemType();
                         MKQL_ENSURE(itemType->IsData() && static_cast<TDataType*>(itemType)->GetSchemeType()
                             == NUdf::TDataType<ui64>::Id, "Bad shard list type.");
 
-                        if (shardsList->GetItemsCount() > 0) {
+                        if (shardsList->GetItemsCount() > 0) { 
                             if(!IsCancelled) {
                                 TRuntimeNode item = myReads.GetValue(readIdx);
                                 MKQL_ENSURE(item.GetNode()->GetType()->IsCallable(), "Expected callable");
@@ -1139,23 +1139,23 @@ public:
                                     THROW TWithBackTrace<yexception>() << "Unknown callable: "
                                         << callable->GetType()->GetName();
                                 }
-
+ 
                                 ui32 readCallableId = FromString<ui32>(readName);
                                 MKQL_ENSURE(readCallableId == callable->GetUniqueId(),
                                     "Invalid struct member name:" << myReads.GetType()->GetMemberName(readIdx));
-
+ 
                                 auto returnType = GetActualReturnType(*callable, Env, Strings);
                                 TValuePacker packer(false, returnType);
                                 readResults.emplace_back(TString(packer.Pack(readValue)));
                                 const TStringBuf& readValueStr = readResults.back();
-
+ 
                                 for (ui32 shardIndex = 0; shardIndex < shardsList->GetItemsCount(); ++shardIndex) {
                                     ui64 shardId = AS_VALUE(TDataLiteral, shardsList->GetItems()[shardIndex])->AsValue().Get<ui64>();
                                     if (shardId != myShardId) {
                                         auto& results = resultsPerTarget[shardId];
                                         results.AddResult(callable->GetUniqueId(), readValueStr, Env);
                                     }
-                                }
+                                } 
                             } else {
                                 for (ui32 shardIndex = 0; shardIndex < shardsList->GetItemsCount(); ++shardIndex) {
                                     ui64 shardId = AS_VALUE(TDataLiteral, shardsList->GetItems()[shardIndex])->AsValue().Get<ui64>();
@@ -1164,21 +1164,21 @@ public:
                                         resultsPerTarget[shardId];
                                     }
                                 }
-                            }
+                            } 
                         }
 
-                        ++readIdx;
-                        ++writeIdx;
-                    } else if (readName < writeName) {
-                        ++readIdx;
-                    } else {
-                        ++writeIdx;
+                        ++readIdx; 
+                        ++writeIdx; 
+                    } else if (readName < writeName) { 
+                        ++readIdx; 
+                    } else { 
+                        ++writeIdx; 
                     }
                 }
 
-                for (auto& result : resultsPerTarget) {
+                for (auto& result : resultsPerTarget) { 
                     TString resultValue = result.second.ToString(holderFactory, Env);
-                    OutgoingReadsets.push_back(TReadSet(result.first, pgm.first, resultValue));
+                    OutgoingReadsets.push_back(TReadSet(result.first, pgm.first, resultValue)); 
                 }
             }
 
@@ -1192,7 +1192,7 @@ public:
             throw;
         }
         catch (yexception& e) {
-            Alloc.InvalidateMemInfo();
+            Alloc.InvalidateMemInfo(); 
             HandleException("PrepareOutgoingReadsets", __LINE__, e);
             Status = EStatus::Error;
             return EResult::ProgramError;
@@ -1209,7 +1209,7 @@ public:
         Y_VERIFY(AreOutgoingReadSetsPrepared, "PrepareOutgoingReadsets is not called yet");
         Y_VERIFY(!AreOutgoingReadSetsExtracted, "AfterOutgoingReadsetsExtracted is already called");
         Y_VERIFY(index < OutgoingReadsets.size(), "Bad index");
-        return OutgoingReadsets[index];
+        return OutgoingReadsets[index]; 
     }
 
     void AfterOutgoingReadsetsExtracted() noexcept override {
@@ -1233,12 +1233,12 @@ public:
             const ui64 myShardId = Settings.Host->GetShardId();
             THashSet<ui64> shards;
 
-            for (const auto& pgm : ProgramPerOrigin) {
-                auto& pgmStruct = GetPgmStruct(pgm.second);
-                auto& shardForRead = GetPgmShardsForReadStruct(pgmStruct);
-
-                for (ui32 i = 0; i < shardForRead.GetValuesCount(); ++i) {
-                    auto shardsList = AS_VALUE(TListLiteral, shardForRead.GetValue(i));
+            for (const auto& pgm : ProgramPerOrigin) { 
+                auto& pgmStruct = GetPgmStruct(pgm.second); 
+                auto& shardForRead = GetPgmShardsForReadStruct(pgmStruct); 
+ 
+                for (ui32 i = 0; i < shardForRead.GetValuesCount(); ++i) { 
+                    auto shardsList = AS_VALUE(TListLiteral, shardForRead.GetValue(i)); 
                     auto itemType = shardsList->GetType()->GetItemType();
                     MKQL_ENSURE(itemType->IsData() && static_cast<TDataType*>(itemType)->GetSchemeType()
                         == NUdf::TDataType<ui64>::Id, "Bad shard list");
@@ -1257,7 +1257,7 @@ public:
             return EResult::Ok;
         }
         catch (yexception& e) {
-            Alloc.InvalidateMemInfo();
+            Alloc.InvalidateMemInfo(); 
             HandleException("PrepareOutgoingReadsets", __LINE__, e);
             Status = EStatus::Error;
             return EResult::ProgramError;
@@ -1308,7 +1308,7 @@ public:
 
             for (auto pgm : ProgramPerOrigin) {
                 TShardExecData execData(Settings, Strings, StepTxId);
-                for (auto& rs: IncomingReadsets) {
+                for (auto& rs: IncomingReadsets) { 
                     TCallableResults results = TCallableResults::FromString(rs, holderFactory, Env);
                     for (const auto& result : results.GetMap()) {
                         execData.Results[result.first].emplace_back(result.second.AsStringRef());
@@ -1316,38 +1316,38 @@ public:
                 }
 
                 {
-                    auto& pgmStruct = GetPgmStruct(pgm.second);
-                    TRuntimeNode runPgm = GetPgmRun(pgmStruct);
-                    auto& runStruct = GetPgmRunStruct(pgmStruct);
-                    auto& replyStruct = GetPgmReplyStruct(pgmStruct);
-                    auto& myReadsStruct = GetPgmMyReadsStruct(pgmStruct);
-
-                    for (ui32 i = 0; i < myReadsStruct.GetValuesCount(); ++i) {
-                        TRuntimeNode member = myReadsStruct.GetValue(i);
-                        MKQL_ENSURE(member.GetNode()->GetType()->IsCallable(), "Expected callable");
-                        auto callable = static_cast<TCallable*>(member.GetNode());
+                    auto& pgmStruct = GetPgmStruct(pgm.second); 
+                    TRuntimeNode runPgm = GetPgmRun(pgmStruct); 
+                    auto& runStruct = GetPgmRunStruct(pgmStruct); 
+                    auto& replyStruct = GetPgmReplyStruct(pgmStruct); 
+                    auto& myReadsStruct = GetPgmMyReadsStruct(pgmStruct); 
+
+                    for (ui32 i = 0; i < myReadsStruct.GetValuesCount(); ++i) { 
+                        TRuntimeNode member = myReadsStruct.GetValue(i); 
+                        MKQL_ENSURE(member.GetNode()->GetType()->IsCallable(), "Expected callable"); 
+                        auto callable = static_cast<TCallable*>(member.GetNode()); 
                         execData.LocalReadCallables.insert(callable->GetUniqueId());
                     }
 
-                    auto expectedSizeIt = ProgramSizes.find(pgm.first);
-                    if (expectedSizeIt != ProgramSizes.end()) {
-                        MKQL_ENSURE(expectedSizeIt->second != 0,
-                            "Undefined program size on consecutive execute, origin: " << pgm.first);
-                    } else {
-                        expectedSizeIt = ProgramSizes.emplace(pgm.first, 0).first;
-                    }
-
-                    TExploringNodeVisitor runExplorer;
+                    auto expectedSizeIt = ProgramSizes.find(pgm.first); 
+                    if (expectedSizeIt != ProgramSizes.end()) { 
+                        MKQL_ENSURE(expectedSizeIt->second != 0, 
+                            "Undefined program size on consecutive execute, origin: " << pgm.first); 
+                    } else { 
+                        expectedSizeIt = ProgramSizes.emplace(pgm.first, 0).first; 
+                    } 
+ 
+                    TExploringNodeVisitor runExplorer; 
                     runExplorer.Walk(&runStruct, Env);
-
-                    auto nodesCount = runExplorer.GetNodes().size();
-                    if (expectedSizeIt->second == 0) {
-                        expectedSizeIt->second = nodesCount;
-                    } else {
-                        MKQL_ENSURE(expectedSizeIt->second == nodesCount, "Mismatch program size, expected: "
-                            << expectedSizeIt->second << ", got: " << nodesCount << ", origin: " << pgm.first);
-                    }
-
+ 
+                    auto nodesCount = runExplorer.GetNodes().size(); 
+                    if (expectedSizeIt->second == 0) { 
+                        expectedSizeIt->second = nodesCount; 
+                    } else { 
+                        MKQL_ENSURE(expectedSizeIt->second == nodesCount, "Mismatch program size, expected: " 
+                            << expectedSizeIt->second << ", got: " << nodesCount << ", origin: " << pgm.first); 
+                    } 
+ 
                     TComputationPatternOpts opts(Alloc.Ref(), Env,
                         GetFlatShardExecutionFactory(execData, false),
                         Settings.FunctionRegistry,
@@ -1356,47 +1356,47 @@ public:
                     auto pattern = MakeComputationPattern(runExplorer, runPgm, {}, opts);
                     auto compOpts = opts.ToComputationOptions(Settings.RandomProvider, Settings.TimeProvider);
                     THolder<IComputationGraph> runGraph = pattern->Clone(compOpts);
-
+ 
                     const TBindTerminator bind(runGraph->GetTerminator());
 
-                    NUdf::TUnboxedValue runValue = runGraph->GetValue();
+                    NUdf::TUnboxedValue runValue = runGraph->GetValue(); 
                     NUdf::TUnboxedValue replyValue = runValue.GetElement(0);
                     NUdf::TUnboxedValue writeValue = runValue.GetElement(1);
-
-                    TEngineFlatApplyContext applyCtx;
-                    applyCtx.Host = Settings.Host;
-                    applyCtx.Env = &Env;
-                    ApplyChanges(writeValue, applyCtx);
-
-                    TCallableResults replyResults;
-                    for (ui32 i = 0; i < replyStruct.GetValuesCount(); ++i) {
-                        TRuntimeNode item = replyStruct.GetValue(i);
-                        Y_VERIFY(item.GetNode()->GetType()->IsCallable(), "Bad shard program");
-                        auto callable = static_cast<TCallable*>(item.GetNode());
-                        auto memberName = replyStruct.GetType()->GetMemberName(i);
-                        ui32 resultId = FromString<ui32>(memberName);
-
+ 
+                    TEngineFlatApplyContext applyCtx; 
+                    applyCtx.Host = Settings.Host; 
+                    applyCtx.Env = &Env; 
+                    ApplyChanges(writeValue, applyCtx); 
+ 
+                    TCallableResults replyResults; 
+                    for (ui32 i = 0; i < replyStruct.GetValuesCount(); ++i) { 
+                        TRuntimeNode item = replyStruct.GetValue(i); 
+                        Y_VERIFY(item.GetNode()->GetType()->IsCallable(), "Bad shard program"); 
+                        auto callable = static_cast<TCallable*>(item.GetNode()); 
+                        auto memberName = replyStruct.GetType()->GetMemberName(i); 
+                        ui32 resultId = FromString<ui32>(memberName); 
+ 
                         NUdf::TUnboxedValue resultValue = replyValue.GetElement(i);
                         auto returnType = GetActualReturnType(*callable, Env, Strings);
                         TValuePacker packer(false, returnType);
                         replyResults.AddResult(resultId, packer.Pack(resultValue), Env);
-                    }
-
-                    auto replyStr = replyResults.ToString(holderFactory, Env);
-                    if (replyStr.size() > MaxDatashardReplySize) {
-                        TString error = TStringBuilder() << "Datashard " << pgm.first
-                            << ": reply size limit exceeded. ("
-                            << replyStr.size() << " > " << MaxDatashardReplySize << ")";
-
-                        LogError(TStringBuilder() << "Error executing transaction (read-only: "
-                            << ReadOnlyOriginPrograms << "): " << error);
-
-                        AddError(error);
-                        Status = EStatus::Error;
-                        return EResult::ResultTooBig;
-                    }
-
-                    ExecutionReplies[pgm.first] = replyStr;
+                    } 
+ 
+                    auto replyStr = replyResults.ToString(holderFactory, Env); 
+                    if (replyStr.size() > MaxDatashardReplySize) { 
+                        TString error = TStringBuilder() << "Datashard " << pgm.first 
+                            << ": reply size limit exceeded. (" 
+                            << replyStr.size() << " > " << MaxDatashardReplySize << ")"; 
+ 
+                        LogError(TStringBuilder() << "Error executing transaction (read-only: " 
+                            << ReadOnlyOriginPrograms << "): " << error); 
+ 
+                        AddError(error); 
+                        Status = EStatus::Error; 
+                        return EResult::ResultTooBig; 
+                    } 
+ 
+                    ExecutionReplies[pgm.first] = replyStr; 
                 }
             }
         }
@@ -1406,14 +1406,14 @@ public:
         catch (TMemoryLimitExceededException&) {
             throw;
         }
-        catch (TDeadlineExceededException&) {
-            Cancel();
-            IsExecuted = true;
-            Status = EStatus::Error;
-            return EResult::Cancelled;
-        }
+        catch (TDeadlineExceededException&) { 
+            Cancel(); 
+            IsExecuted = true; 
+            Status = EStatus::Error; 
+            return EResult::Cancelled; 
+        } 
         catch (yexception& e) {
-            Alloc.InvalidateMemInfo();
+            Alloc.InvalidateMemInfo(); 
             HandleException("Execute", __LINE__, e);
             Status = EStatus::Error;
             return EResult::ProgramError;
@@ -1421,7 +1421,7 @@ public:
 
         Y_VERIFY(ExecutionReplies.size() == ProgramPerOrigin.size());
         ProgramPerOrigin.clear();
-        ProgramSizes.clear();
+        ProgramSizes.clear(); 
         IsExecuted = true;
         return EResult::Ok;
     }
@@ -1430,7 +1430,7 @@ public:
         Y_VERIFY(IsExecuted, "Execute is not called yet");
         auto it = ExecutionReplies.find(origin);
         Y_VERIFY(it != ExecutionReplies.end(), "Bad origin: %" PRIu64, origin);
-        return it->second;
+        return it->second; 
     }
 
     size_t GetMemoryUsed() const noexcept override {
@@ -1453,24 +1453,24 @@ public:
         Alloc.ReleaseFreePages();
     }
 
-    void SetDeadline(const TInstant& deadline) noexcept override {
-        if (!ReadOnlyOriginPrograms) {
-            return;
-        }
-
-        auto& timeProvider = Settings.TimeProvider;
-        auto checkDeadlineCallback = [&timeProvider, deadline]() {
-            if (timeProvider.Now() > deadline) {
-                throw TDeadlineExceededException();
-            }
-        };
-
-        Alloc.Ref().SetAllocNotifyCallback(checkDeadlineCallback, AllocNotifyCallbackBytes);
-        if (Settings.Host) {
-            Settings.Host->SetPeriodicCallback(checkDeadlineCallback);
-        }
-    }
-
+    void SetDeadline(const TInstant& deadline) noexcept override { 
+        if (!ReadOnlyOriginPrograms) { 
+            return; 
+        } 
+ 
+        auto& timeProvider = Settings.TimeProvider; 
+        auto checkDeadlineCallback = [&timeProvider, deadline]() { 
+            if (timeProvider.Now() > deadline) { 
+                throw TDeadlineExceededException(); 
+            } 
+        }; 
+ 
+        Alloc.Ref().SetAllocNotifyCallback(checkDeadlineCallback, AllocNotifyCallbackBytes); 
+        if (Settings.Host) { 
+            Settings.Host->SetPeriodicCallback(checkDeadlineCallback); 
+        } 
+    } 
+ 
 private:
     struct TCallableContext {
         TCallable* Node;
@@ -1494,9 +1494,9 @@ private:
     };
 
     static void AddShards(TSet<ui64>& set, const TKeyDesc& key) {
-        for (auto& partition : key.Partitions) {
-            Y_VERIFY(partition.ShardId);
-            set.insert(partition.ShardId);
+        for (auto& partition : key.Partitions) { 
+            Y_VERIFY(partition.ShardId); 
+            set.insert(partition.ShardId); 
         }
     }
 
@@ -1516,14 +1516,14 @@ private:
         }
     }
 
-    void PrepareShardProgram(ui64 shard, const THashMap<ui32, const TVector<TKeyDesc::TPartitionInfo>*>& proxyShards,
-        TProgramParts& parts, THashSet<std::pair<ui64, ui64>>& readsets) {
+    void PrepareShardProgram(ui64 shard, const THashMap<ui32, const TVector<TKeyDesc::TPartitionInfo>*>& proxyShards, 
+        TProgramParts& parts, THashSet<std::pair<ui64, ui64>>& readsets) { 
         parts.Write = BuildWriteProgram(shard, proxyShards);
 
         TExploringNodeVisitor writeExplorer;
         writeExplorer.Walk(parts.Write.GetNode(), Env);
 
-        BuildMyKeysAndReplies(shard, writeExplorer, parts, readsets);
+        BuildMyKeysAndReplies(shard, writeExplorer, parts, readsets); 
         ExtractShardsToWrite(shard, writeExplorer);
     }
 
@@ -1544,9 +1544,9 @@ private:
         ShardsToWrite = TRuntimeNode(shardsToWriteBuilder.Build(), true);
     }
 
-    void BuildMyKeysAndReplies(ui64 shard, TExploringNodeVisitor& writeExplorer, TProgramParts& parts,
-        THashSet<std::pair<ui64, ui64>>& readsets)
-    {
+    void BuildMyKeysAndReplies(ui64 shard, TExploringNodeVisitor& writeExplorer, TProgramParts& parts, 
+        THashSet<std::pair<ui64, ui64>>& readsets) 
+    { 
         TStructLiteralBuilder myKeysBuilder(Env);
         TStructLiteralBuilder myReadsBuilder(Env);
         TStructLiteralBuilder myWritesBuilder(Env);
@@ -1571,53 +1571,53 @@ private:
                 auto& ctx = ctxIt->second;
                 auto uniqueName = ToString(callable->GetUniqueId());
                 shardsForReadBuilder.Add(uniqueName, ctx.ShardsForRead);
-
-                for (auto& partition : ctx.Key->Partitions) {
-                    auto shardForRead = partition.ShardId;
+ 
+                for (auto& partition : ctx.Key->Partitions) { 
+                    auto shardForRead = partition.ShardId; 
                     if (shardForRead != shard) {
-                        readsets.insert(std::make_pair(shardForRead, shard));
+                        readsets.insert(std::make_pair(shardForRead, shard)); 
                     }
                 }
             }
         }
 
-        auto checkShard = [shard] (const TCallableContext& ctx) {
-            auto key = ctx.Key;
-            Y_VERIFY(key);
-
-            for (auto& partition : key->Partitions) {
-                if (partition.ShardId == shard) {
-                    return true;
-                }
-            }
-
-            return false;
-        };
-
+        auto checkShard = [shard] (const TCallableContext& ctx) { 
+            auto key = ctx.Key; 
+            Y_VERIFY(key); 
+ 
+            for (auto& partition : key->Partitions) { 
+                if (partition.ShardId == shard) { 
+                    return true; 
+                } 
+            } 
+ 
+            return false; 
+        }; 
+ 
         for (auto& callable : ProxyCallables) {
             auto name = callable.second.Node->GetType()->GetNameStr();
-            auto uniqueName = ToString(callable.first);
-
-            if (name == Strings.SelectRow || name == Strings.SelectRange) {
-                readsBuilder.Add(uniqueName, TRuntimeNode(callable.second.Node, false));
-                if (checkShard(callable.second)) {
-                    myReadsBuilder.Add(uniqueName, TRuntimeNode(callable.second.Node, false));
+            auto uniqueName = ToString(callable.first); 
+ 
+            if (name == Strings.SelectRow || name == Strings.SelectRange) { 
+                readsBuilder.Add(uniqueName, TRuntimeNode(callable.second.Node, false)); 
+                if (checkShard(callable.second)) { 
+                    myReadsBuilder.Add(uniqueName, TRuntimeNode(callable.second.Node, false)); 
                 }
-            }
+            } 
 
             if (ProxyRepliesCallables.contains(callable.first)) {
-                TCallableContext* readCtx = &callable.second;
-
-                auto replyRead = ProxyRepliesReads.FindPtr(callable.first);
-                if (replyRead) {
-                    auto readCtxPtr = ProxyCallables.FindPtr((*replyRead)->GetUniqueId());
-                    Y_VERIFY(readCtxPtr);
-                    readCtx = readCtxPtr;
-                }
-
-                if (checkShard(*readCtx)) {
-                    replyBuilder.Add(uniqueName, TRuntimeNode(callable.second.Node, false));
+                TCallableContext* readCtx = &callable.second; 
+ 
+                auto replyRead = ProxyRepliesReads.FindPtr(callable.first); 
+                if (replyRead) { 
+                    auto readCtxPtr = ProxyCallables.FindPtr((*replyRead)->GetUniqueId()); 
+                    Y_VERIFY(readCtxPtr); 
+                    readCtx = readCtxPtr; 
                 }
+ 
+                if (checkShard(*readCtx)) { 
+                    replyBuilder.Add(uniqueName, TRuntimeNode(callable.second.Node, false)); 
+                } 
             }
         }
 
@@ -1640,39 +1640,39 @@ private:
         builder.Add("ShardsForRead", parts.ShardsForRead);
         builder.Add("ShardsToWrite", ShardsToWrite);
         TRuntimeNode specializedProgram = TRuntimeNode(builder.Build(), true);
-
-        auto lpoProvider = GetLiteralPropagationOptimizationFuncProvider();
+ 
+        auto lpoProvider = GetLiteralPropagationOptimizationFuncProvider(); 
         auto funcProvider = [&](TInternName name) {
-            auto lpoFunc = lpoProvider(name);
-            if (lpoFunc)
-                return lpoFunc;
-
-            if (name == Strings.CombineByKeyMerge) {
+            auto lpoFunc = lpoProvider(name); 
+            if (lpoFunc) 
+                return lpoFunc; 
+ 
+            if (name == Strings.CombineByKeyMerge) { 
                 return TCallableVisitFunc([](TCallable& callable, const TTypeEnvironment& env) {
-                    Y_UNUSED(env);
-                    return callable.GetInput(0);
-                });
-            } else
-            if (name == Strings.PartialSort) {
+                    Y_UNUSED(env); 
+                    return callable.GetInput(0); 
+                }); 
+            } else 
+            if (name == Strings.PartialSort) { 
                 return TCallableVisitFunc([](TCallable& callable, const TTypeEnvironment& env) {
-                    return RenameCallable(callable, "Sort", env);
-                });
-            } else
-            if (name == Strings.PartialTake) {
+                    return RenameCallable(callable, "Sort", env); 
+                }); 
+            } else 
+            if (name == Strings.PartialTake) { 
                 return TCallableVisitFunc([](TCallable& callable, const TTypeEnvironment& env) {
-                    return RenameCallable(callable, "Take", env);
-                });
-            }
-
-            return TCallableVisitFunc();
-        };
-
-        TExploringNodeVisitor explorer;
-        explorer.Walk(specializedProgram.GetNode(), Env);
-        bool wereChanges = false;
-        specializedProgram = SinglePassVisitCallables(specializedProgram, explorer, funcProvider, Env,
-            false, wereChanges);
-
+                    return RenameCallable(callable, "Take", env); 
+                }); 
+            } 
+ 
+            return TCallableVisitFunc(); 
+        }; 
+ 
+        TExploringNodeVisitor explorer; 
+        explorer.Walk(specializedProgram.GetNode(), Env); 
+        bool wereChanges = false; 
+        specializedProgram = SinglePassVisitCallables(specializedProgram, explorer, funcProvider, Env, 
+            false, wereChanges); 
+ 
         parts.Program = specializedProgram;
     }
 
@@ -1684,184 +1684,184 @@ private:
         AddError(operation, line, e.what());
     }
 
-    void LogError(const TString& message) {
-        if (Settings.LogErrorWriter) {
-            Settings.LogErrorWriter(message);
-        }
-    }
-
-    void AddError(const TString& message) const {
+    void LogError(const TString& message) { 
+        if (Settings.LogErrorWriter) { 
+            Settings.LogErrorWriter(message); 
+        } 
+    } 
+ 
+    void AddError(const TString& message) const { 
         if (!Errors.empty())
             Errors += "\n";
 
-        Errors += message;
-    }
-
-    void AddError(const char* operation, ui32 line, const char* text) const {
-        AddError(Sprintf("%s (%" PRIu32 "): %s", operation, line, text));
-    }
-
-    void PrepareProxyProgram() {
-        ui64 nodesCount = ProgramExplorer.GetNodes().size();
-
-        auto lpoProvider = GetLiteralPropagationOptimizationFuncProvider();
-        auto funcProvider = [&](TInternName name) {
-            auto lpoFunc = lpoProvider(name);
-            if (lpoFunc)
-                return lpoFunc;
-
-            return TCallableVisitFunc();
-        };
-
-        bool wereChanges = false;
-        ProxyProgram = SinglePassVisitCallables(Program, const_cast<TExploringNodeVisitor&>(ProgramExplorer), funcProvider, Env, false, wereChanges);
-        ProxyProgramExplorer.Walk(ProxyProgram.GetNode(), Env, {}, true, nodesCount);
-
+        Errors += message; 
+    }
+
+    void AddError(const char* operation, ui32 line, const char* text) const { 
+        AddError(Sprintf("%s (%" PRIu32 "): %s", operation, line, text)); 
+    } 
+ 
+    void PrepareProxyProgram() { 
+        ui64 nodesCount = ProgramExplorer.GetNodes().size(); 
+ 
+        auto lpoProvider = GetLiteralPropagationOptimizationFuncProvider(); 
+        auto funcProvider = [&](TInternName name) { 
+            auto lpoFunc = lpoProvider(name); 
+            if (lpoFunc) 
+                return lpoFunc; 
+ 
+            return TCallableVisitFunc(); 
+        }; 
+ 
+        bool wereChanges = false; 
+        ProxyProgram = SinglePassVisitCallables(Program, const_cast<TExploringNodeVisitor&>(ProgramExplorer), funcProvider, Env, false, wereChanges); 
+        ProxyProgramExplorer.Walk(ProxyProgram.GetNode(), Env, {}, true, nodesCount); 
+ 
         auto isPureLambda = [this] (TVector<TNode*> args, TRuntimeNode value) {
             THashSet<ui32> knownArgIds;
-            for (auto& arg : args) {
-                if (!arg->GetType()->IsCallable()) {
-                    return false;
-                }
-
-                auto argCallable = static_cast<TCallable*>(arg);
-                Y_VERIFY(argCallable);
-
-                knownArgIds.insert(argCallable->GetUniqueId());
-            }
-
+            for (auto& arg : args) { 
+                if (!arg->GetType()->IsCallable()) { 
+                    return false; 
+                } 
+ 
+                auto argCallable = static_cast<TCallable*>(arg); 
+                Y_VERIFY(argCallable); 
+ 
+                knownArgIds.insert(argCallable->GetUniqueId()); 
+            } 
+ 
             TVector<TCallable*> foundArgs;
             THashSet<TNode*> visitedNodes;
-            TExploringNodeVisitor lambdaExplorer;
-            lambdaExplorer.Walk(value.GetNode(), Env, args);
-            for (auto& node : lambdaExplorer.GetNodes()) {
-                visitedNodes.insert(node);
-
-                if (node->GetType()->IsCallable()) {
-                    auto callable = static_cast<TCallable*>(node);
-                    auto name = callable->GetType()->GetNameStr();
-
+            TExploringNodeVisitor lambdaExplorer; 
+            lambdaExplorer.Walk(value.GetNode(), Env, args); 
+            for (auto& node : lambdaExplorer.GetNodes()) { 
+                visitedNodes.insert(node); 
+ 
+                if (node->GetType()->IsCallable()) { 
+                    auto callable = static_cast<TCallable*>(node); 
+                    auto name = callable->GetType()->GetNameStr(); 
+ 
                     if (name == Strings.Builtins.Arg && !knownArgIds.contains(callable->GetUniqueId())) {
-                        foundArgs.push_back(callable);
-                    }
-
+                        foundArgs.push_back(callable); 
+                    } 
+ 
                     if (Strings.All.contains(name)) {
-                        return false;
-                    }
-                }
-            }
-
-            for (TCallable* arg : foundArgs) {
-                auto& consumers = ProxyProgramExplorer.GetConsumerNodes(*arg);
-                for (auto& consumer : consumers) {
+                        return false; 
+                    } 
+                } 
+            } 
+
+            for (TCallable* arg : foundArgs) { 
+                auto& consumers = ProxyProgramExplorer.GetConsumerNodes(*arg); 
+                for (auto& consumer : consumers) { 
                     if (!visitedNodes.contains(consumer)) {
-                        return false;
-                    }
-                }
-            }
-
-            return true;
-        };
-
+                        return false; 
+                    } 
+                } 
+            } 
+ 
+            return true; 
+        }; 
+ 
         THashSet<ui32> pureCallables;
         THashSet<ui32> aggregatedCallables;
         THashMap<ui32, ui32> callableConsumers;
-        for (auto& node : ProxyProgramExplorer.GetNodes()) {
-            if (!node->GetType()->IsCallable()) {
-                continue;
-            }
-
-            auto callable = static_cast<TCallable*>(node);
-            auto id = callable->GetUniqueId();
-            auto name = callable->GetType()->GetNameStr();
-
-            callableConsumers[id] = ProxyProgramExplorer.GetConsumerNodes(*callable).size();
-
-            if (name == Strings.Builtins.DictItems ||
-                name == Strings.Builtins.Member ||
-                name == Strings.Builtins.Take ||
-                name == Strings.Builtins.Length ||
-                name == Strings.Builtins.FilterNullMembers ||
+        for (auto& node : ProxyProgramExplorer.GetNodes()) { 
+            if (!node->GetType()->IsCallable()) { 
+                continue; 
+            } 
+ 
+            auto callable = static_cast<TCallable*>(node); 
+            auto id = callable->GetUniqueId(); 
+            auto name = callable->GetType()->GetNameStr(); 
+ 
+            callableConsumers[id] = ProxyProgramExplorer.GetConsumerNodes(*callable).size(); 
+ 
+            if (name == Strings.Builtins.DictItems || 
+                name == Strings.Builtins.Member || 
+                name == Strings.Builtins.Take || 
+                name == Strings.Builtins.Length || 
+                name == Strings.Builtins.FilterNullMembers || 
                 name == Strings.Builtins.SkipNullMembers ||
-                name == Strings.SelectRange ||
-                name == Strings.CombineByKeyMerge ||
-                name == Strings.PartialTake)
-            {
-                pureCallables.insert(id);
-            } else
-            if (name == Strings.Builtins.Filter ||
-                name == Strings.Builtins.Map ||
-                name == Strings.Builtins.FlatMap)
-            {
-                auto arg = callable->GetInput(1);
-                auto lambda = callable->GetInput(2);
-
-                // Check lambda for IO callables
-                if (isPureLambda({arg.GetNode()}, lambda)) {
-                    pureCallables.insert(id);
-                }
-            } else
-            if (name == Strings.Builtins.ToHashedDict) {
-                auto arg = callable->GetInput(1);
-                auto key = callable->GetInput(2);
-                auto payload = callable->GetInput(3);
-
-                if (isPureLambda({arg.GetNode()}, key) && isPureLambda({arg.GetNode()}, payload)) {
-                    pureCallables.insert(id);
-                }
-            } else
-            if (name == Strings.PartialSort) {
-                auto arg = callable->GetInput(1);
-                auto lambda = callable->GetInput(2);
-                if (isPureLambda({arg.GetNode()}, lambda)) {
-                    pureCallables.insert(id);
-                }
-            }
-        }
-
-        auto firstPass = [&](TInternName name) {
-            if (name == Strings.EraseRow || name == Strings.UpdateRow) {
-                return TCallableVisitFunc(&ReplaceAsVoid);
-            }
-
-            auto lpoFunc = lpoProvider(name);
-            if (lpoFunc)
-                return lpoFunc;
-
-            return TCallableVisitFunc();
-        };
-
-        ProxyProgram = SinglePassVisitCallables(ProxyProgram, const_cast<TExploringNodeVisitor&>(ProxyProgramExplorer),
-            firstPass, Env, false, wereChanges);
-        ProxyProgramExplorer.Walk(ProxyProgram.GetNode(), Env, {});
-
+                name == Strings.SelectRange || 
+                name == Strings.CombineByKeyMerge || 
+                name == Strings.PartialTake) 
+            { 
+                pureCallables.insert(id); 
+            } else 
+            if (name == Strings.Builtins.Filter || 
+                name == Strings.Builtins.Map || 
+                name == Strings.Builtins.FlatMap) 
+            { 
+                auto arg = callable->GetInput(1); 
+                auto lambda = callable->GetInput(2); 
+ 
+                // Check lambda for IO callables 
+                if (isPureLambda({arg.GetNode()}, lambda)) { 
+                    pureCallables.insert(id); 
+                } 
+            } else 
+            if (name == Strings.Builtins.ToHashedDict) { 
+                auto arg = callable->GetInput(1); 
+                auto key = callable->GetInput(2); 
+                auto payload = callable->GetInput(3); 
+ 
+                if (isPureLambda({arg.GetNode()}, key) && isPureLambda({arg.GetNode()}, payload)) { 
+                    pureCallables.insert(id); 
+                } 
+            } else 
+            if (name == Strings.PartialSort) { 
+                auto arg = callable->GetInput(1); 
+                auto lambda = callable->GetInput(2); 
+                if (isPureLambda({arg.GetNode()}, lambda)) { 
+                    pureCallables.insert(id); 
+                } 
+            } 
+        } 
+ 
+        auto firstPass = [&](TInternName name) { 
+            if (name == Strings.EraseRow || name == Strings.UpdateRow) { 
+                return TCallableVisitFunc(&ReplaceAsVoid); 
+            } 
+ 
+            auto lpoFunc = lpoProvider(name); 
+            if (lpoFunc) 
+                return lpoFunc; 
+ 
+            return TCallableVisitFunc(); 
+        }; 
+ 
+        ProxyProgram = SinglePassVisitCallables(ProxyProgram, const_cast<TExploringNodeVisitor&>(ProxyProgramExplorer), 
+            firstPass, Env, false, wereChanges); 
+        ProxyProgramExplorer.Walk(ProxyProgram.GetNode(), Env, {}); 
+ 
         auto getCallableForPushdown = [&pureCallables, &callableConsumers] (TRuntimeNode node,
-            TInternName name) -> TCallable*
-        {
-            if (!node.GetNode()->GetType()->IsCallable()) {
-                return nullptr;
-            }
-
-            auto callable = static_cast<TCallable*>(node.GetNode());
-            if (name && callable->GetType()->GetNameStr() != name) {
-                return nullptr;
-            }
-
-            auto consumersPtr = callableConsumers.FindPtr(callable->GetUniqueId());
-            Y_VERIFY(consumersPtr);
-
-            // Make sure we're an exclusive consumer of the input
-            if (*consumersPtr > 1) {
-                return nullptr;
-            }
-
+            TInternName name) -> TCallable* 
+        { 
+            if (!node.GetNode()->GetType()->IsCallable()) { 
+                return nullptr; 
+            } 
+ 
+            auto callable = static_cast<TCallable*>(node.GetNode()); 
+            if (name && callable->GetType()->GetNameStr() != name) { 
+                return nullptr; 
+            } 
+ 
+            auto consumersPtr = callableConsumers.FindPtr(callable->GetUniqueId()); 
+            Y_VERIFY(consumersPtr); 
+ 
+            // Make sure we're an exclusive consumer of the input 
+            if (*consumersPtr > 1) { 
+                return nullptr; 
+            } 
+ 
             if (!pureCallables.contains(callable->GetUniqueId())) {
-                return nullptr;
-            }
-
-            return callable;
-        };
-
+                return nullptr; 
+            } 
+ 
+            return callable; 
+        }; 
+ 
         for (auto& node : ProxyProgramExplorer.GetNodes()) {
             if (!node->GetType()->IsCallable()) {
                 continue;
@@ -1869,161 +1869,161 @@ private:
 
             auto callable = static_cast<TCallable*>(node);
             auto name = callable->GetType()->GetNameStr();
-
-            auto tryPushdownCallable =
-                [this, callable, &pureCallables, &aggregatedCallables, getCallableForPushdown]
-                (TCallable* input, bool aggregated) {
+ 
+            auto tryPushdownCallable = 
+                [this, callable, &pureCallables, &aggregatedCallables, getCallableForPushdown] 
+                (TCallable* input, bool aggregated) { 
                     if (!pureCallables.contains(callable->GetUniqueId())) {
-                        return;
-                    }
-
-                    // Walk through Member callable, required as SelectRange returns a struct
-                    if (input->GetType()->GetNameStr() == Strings.Builtins.Member) {
+                        return; 
+                    } 
+ 
+                    // Walk through Member callable, required as SelectRange returns a struct 
+                    if (input->GetType()->GetNameStr() == Strings.Builtins.Member) { 
                         input = getCallableForPushdown(input->GetInput(0), TInternName());
-                        if (!input) {
-                            return;
-                        }
-                    }
-
+                        if (!input) { 
+                            return; 
+                        } 
+                    } 
+ 
                     if (ProxyRepliesCallables.contains(input->GetUniqueId()) &&
                         !aggregatedCallables.contains(input->GetUniqueId()))
-                    {
+                    { 
                         if (ProxyRepliesReads.contains(callable->GetUniqueId())) {
-                            return;
-                        }
-
-                        auto inputRead = ProxyRepliesReads.FindPtr(input->GetUniqueId());
-                        Y_VERIFY(ProxyRepliesReads.insert(std::make_pair(callable->GetUniqueId(),
-                            inputRead ? *inputRead : input)).second);
-
-                        // Mark callable as a reply from datashards
-                        ProxyRepliesCallables.erase(input->GetUniqueId());
-                        ProxyRepliesCallables[callable->GetUniqueId()] = callable;
-
-                        if (aggregated) {
-                            aggregatedCallables.insert(callable->GetUniqueId());
-                        }
-                    }
-                };
-
+                            return; 
+                        } 
+ 
+                        auto inputRead = ProxyRepliesReads.FindPtr(input->GetUniqueId()); 
+                        Y_VERIFY(ProxyRepliesReads.insert(std::make_pair(callable->GetUniqueId(), 
+                            inputRead ? *inputRead : input)).second); 
+ 
+                        // Mark callable as a reply from datashards 
+                        ProxyRepliesCallables.erase(input->GetUniqueId()); 
+                        ProxyRepliesCallables[callable->GetUniqueId()] = callable; 
+ 
+                        if (aggregated) { 
+                            aggregatedCallables.insert(callable->GetUniqueId()); 
+                        } 
+                    } 
+                }; 
+ 
             if (name == Strings.SelectRow || name == Strings.SelectRange) {
                 auto ctxIt = ProxyCallables.find(callable->GetUniqueId());
                 Y_VERIFY(ctxIt != ProxyCallables.end());
                 ProxyRepliesCallables[callable->GetUniqueId()] = callable;
-            } else if (name == Strings.Builtins.Filter ||
-                       name == Strings.Builtins.FilterNullMembers ||
+            } else if (name == Strings.Builtins.Filter || 
+                       name == Strings.Builtins.FilterNullMembers || 
                        name == Strings.Builtins.SkipNullMembers ||
-                       name == Strings.Builtins.Map ||
-                       name == Strings.Builtins.FlatMap)
-            {
-                // Push computation of map callables down to datashards
+                       name == Strings.Builtins.Map || 
+                       name == Strings.Builtins.FlatMap) 
+            { 
+                // Push computation of map callables down to datashards 
                 auto input = getCallableForPushdown(callable->GetInput(0), TInternName());
-                if (!input) {
-                    continue;
-                }
-
-                tryPushdownCallable(input, false);
-            } else if (name == Strings.CombineByKeyMerge) {
-                // Push computation of partial aggregations down to datashards
-                auto flatmap = getCallableForPushdown(callable->GetInput(0), Strings.Builtins.FlatMap);
-                if (!flatmap) {
-                    continue;
-                }
-                auto items = getCallableForPushdown(flatmap->GetInput(0), Strings.Builtins.DictItems);
-                if (!items) {
-                    continue;
-                }
-                auto dict = getCallableForPushdown(items->GetInput(0), Strings.Builtins.ToHashedDict);
-                if (!dict) {
-                    continue;
-                }
-                auto preMap = getCallableForPushdown(dict->GetInput(0), Strings.Builtins.FlatMap);
-                if (!preMap) {
-                    continue;
-                }
-
-                tryPushdownCallable(preMap, true);
-            } else if (name == Strings.Builtins.Take || name == Strings.PartialTake) {
-                auto count = callable->GetInput(1);
-                if (name == Strings.Builtins.Take && !count.IsImmediate()) {
-                    continue;
-                }
-
-                if (!callable->GetInput(0).GetStaticType()->IsList()) {
-                    continue;
-                }
-
+                if (!input) { 
+                    continue; 
+                } 
+ 
+                tryPushdownCallable(input, false); 
+            } else if (name == Strings.CombineByKeyMerge) { 
+                // Push computation of partial aggregations down to datashards 
+                auto flatmap = getCallableForPushdown(callable->GetInput(0), Strings.Builtins.FlatMap); 
+                if (!flatmap) { 
+                    continue; 
+                } 
+                auto items = getCallableForPushdown(flatmap->GetInput(0), Strings.Builtins.DictItems); 
+                if (!items) { 
+                    continue; 
+                } 
+                auto dict = getCallableForPushdown(items->GetInput(0), Strings.Builtins.ToHashedDict); 
+                if (!dict) { 
+                    continue; 
+                } 
+                auto preMap = getCallableForPushdown(dict->GetInput(0), Strings.Builtins.FlatMap); 
+                if (!preMap) { 
+                    continue; 
+                } 
+ 
+                tryPushdownCallable(preMap, true); 
+            } else if (name == Strings.Builtins.Take || name == Strings.PartialTake) { 
+                auto count = callable->GetInput(1); 
+                if (name == Strings.Builtins.Take && !count.IsImmediate()) { 
+                    continue; 
+                } 
+ 
+                if (!callable->GetInput(0).GetStaticType()->IsList()) { 
+                    continue; 
+                } 
+ 
                 auto input = getCallableForPushdown(callable->GetInput(0), TInternName());
-                if (!input) {
-                    continue;
-                }
-
-                if (name == Strings.PartialTake && input->GetType()->GetNameStr() == Strings.PartialSort) {
-                    input = getCallableForPushdown(input->GetInput(0), TInternName());
-                    if (!input) {
-                        continue;
-                    }
-                }
-
-                bool aggregated = false;
-                if (name == Strings.Builtins.Take) {
-                    aggregated = true;
-
-                    auto inputName = input->GetType()->GetNameStr();
-                    if (inputName != Strings.Builtins.Filter &&
-                        inputName != Strings.Builtins.Map &&
-                        inputName != Strings.Builtins.FlatMap)
-                    {
-                        // No pushdown of Take over ordered sequence, requires specific merge.
-                        continue;
-                    }
-                }
-
-                tryPushdownCallable(input, aggregated);
-            } else if (name == Strings.Builtins.Length) {
-                if (!callable->GetInput(0).GetStaticType()->IsList()) {
-                    continue;
-                }
-
+                if (!input) { 
+                    continue; 
+                } 
+ 
+                if (name == Strings.PartialTake && input->GetType()->GetNameStr() == Strings.PartialSort) { 
+                    input = getCallableForPushdown(input->GetInput(0), TInternName()); 
+                    if (!input) { 
+                        continue; 
+                    } 
+                } 
+ 
+                bool aggregated = false; 
+                if (name == Strings.Builtins.Take) { 
+                    aggregated = true; 
+ 
+                    auto inputName = input->GetType()->GetNameStr(); 
+                    if (inputName != Strings.Builtins.Filter && 
+                        inputName != Strings.Builtins.Map && 
+                        inputName != Strings.Builtins.FlatMap) 
+                    { 
+                        // No pushdown of Take over ordered sequence, requires specific merge. 
+                        continue; 
+                    } 
+                } 
+ 
+                tryPushdownCallable(input, aggregated); 
+            } else if (name == Strings.Builtins.Length) { 
+                if (!callable->GetInput(0).GetStaticType()->IsList()) { 
+                    continue; 
+                } 
+ 
                 auto input = getCallableForPushdown(callable->GetInput(0), TInternName());
-                if (!input) {
-                    continue;
-                }
-
-                tryPushdownCallable(input, true);
+                if (!input) { 
+                    continue; 
+                } 
+ 
+                tryPushdownCallable(input, true); 
             }
         }
-
+ 
         auto secondPass = [&](TInternName name) {
-            if (name == Strings.CombineByKeyMerge) {
-                return TCallableVisitFunc([this](TCallable& callable, const TTypeEnvironment& env) {
-                    Y_UNUSED(env);
+            if (name == Strings.CombineByKeyMerge) { 
+                return TCallableVisitFunc([this](TCallable& callable, const TTypeEnvironment& env) { 
+                    Y_UNUSED(env); 
                     return ProxyRepliesCallables.contains(callable.GetUniqueId())
-                        ? TRuntimeNode(&callable, false)
-                        : callable.GetInput(0);
-                });
-            } else
-            if (name == Strings.PartialSort) {
-                return TCallableVisitFunc([this](TCallable& callable, const TTypeEnvironment& env) {
+                        ? TRuntimeNode(&callable, false) 
+                        : callable.GetInput(0); 
+                }); 
+            } else 
+            if (name == Strings.PartialSort) { 
+                return TCallableVisitFunc([this](TCallable& callable, const TTypeEnvironment& env) { 
                     return ProxyRepliesCallables.contains(callable.GetUniqueId())
-                        ? TRuntimeNode(&callable, false)
-                        : RenameCallable(callable, "Sort", env);
-                });
-            } else
-            if (name == Strings.PartialTake) {
-                return TCallableVisitFunc([this](TCallable& callable, const TTypeEnvironment& env) {
+                        ? TRuntimeNode(&callable, false) 
+                        : RenameCallable(callable, "Sort", env); 
+                }); 
+            } else 
+            if (name == Strings.PartialTake) { 
+                return TCallableVisitFunc([this](TCallable& callable, const TTypeEnvironment& env) { 
                     return ProxyRepliesCallables.contains(callable.GetUniqueId())
-                        ? TRuntimeNode(&callable, false)
-                        : RenameCallable(callable, "Take", env);
-                });
-            }
-
-            return TCallableVisitFunc();
-        };
-
-        ProxyProgram = SinglePassVisitCallables(ProxyProgram, const_cast<TExploringNodeVisitor&>(ProxyProgramExplorer),
-            secondPass, Env, false, wereChanges);
-        ProxyProgramExplorer.Walk(ProxyProgram.GetNode(), Env, {});
+                        ? TRuntimeNode(&callable, false) 
+                        : RenameCallable(callable, "Take", env); 
+                }); 
+            } 
+ 
+            return TCallableVisitFunc(); 
+        }; 
+ 
+        ProxyProgram = SinglePassVisitCallables(ProxyProgram, const_cast<TExploringNodeVisitor&>(ProxyProgramExplorer), 
+            secondPass, Env, false, wereChanges); 
+        ProxyProgramExplorer.Walk(ProxyProgram.GetNode(), Env, {}); 
     }
 
     void PrepareShardsForRead() {
@@ -2035,9 +2035,9 @@ private:
                 Y_VERIFY(key);
 
                 TListLiteralBuilder listOfShards(Env, Ui64Type);
-                for (auto& partition : key->Partitions) {
-                    listOfShards.Add(TRuntimeNode(BuildDataLiteral(NUdf::TUnboxedValuePod(partition.ShardId),
-                        NUdf::TDataType<ui64>::Id, Env), true));
+                for (auto& partition : key->Partitions) { 
+                    listOfShards.Add(TRuntimeNode(BuildDataLiteral(NUdf::TUnboxedValuePod(partition.ShardId), 
+                        NUdf::TDataType<ui64>::Id, Env), true)); 
                 }
 
                 ctx.ShardsForRead = TRuntimeNode(listOfShards.Build(), true);
@@ -2045,15 +2045,15 @@ private:
         }
     }
 
-    TRuntimeNode BuildWriteProgram(ui64 myShardId, const THashMap<ui32,
-        const TVector<TKeyDesc::TPartitionInfo>*>& proxyShards) const
-    {
+    TRuntimeNode BuildWriteProgram(ui64 myShardId, const THashMap<ui32, 
+        const TVector<TKeyDesc::TPartitionInfo>*>& proxyShards) const 
+    { 
         TCallableVisitFunc checkMyShardForWrite = [&](TCallable& callable, const TTypeEnvironment& env) {
-            auto partitions = proxyShards.FindPtr(callable.GetUniqueId());
-            Y_VERIFY(partitions);
-            for (auto partition : *(*partitions)) {
-                Y_VERIFY(partition.ShardId);
-                if (myShardId == partition.ShardId) {
+            auto partitions = proxyShards.FindPtr(callable.GetUniqueId()); 
+            Y_VERIFY(partitions); 
+            for (auto partition : *(*partitions)) { 
+                Y_VERIFY(partition.ShardId); 
+                if (myShardId == partition.ShardId) { 
                     return TRuntimeNode(&callable, false);
                 }
             }
@@ -2089,7 +2089,7 @@ private:
     TStructType* ResultType;
     std::pair<ui64, ui64> StepTxId;
     TVector<IEngineFlat::TTxLock> TxLocks;
-    TMaybe<ui64> LockTxId;
+    TMaybe<ui64> LockTxId; 
     bool NeedDiagnostics;
     TVector<IEngineFlat::TTabletInfo> TabletInfos;
 
@@ -2101,10 +2101,10 @@ private:
     TExploringNodeVisitor ProxyProgramExplorer;
     TVector<TProgramParts> SpecializedParts;
     TMap<ui64, TRuntimeNode> ProgramPerOrigin;
-    TMap<ui64, ui64> ProgramSizes;
+    TMap<ui64, ui64> ProgramSizes; 
     TVector<THolder<TKeyDesc>> DbKeys;
     TVector<TShardData> AffectedShards;
-    TMaybe<bool> ReadOnlyProgram;
+    TMaybe<bool> ReadOnlyProgram; 
     THashMap<ui32, TCallableContext> ProxyCallables;
     THashMap<ui32, TCallable*> ProxyRepliesCallables;
     THashMap<ui32, TCallable*> ProxyRepliesReads;
@@ -2126,7 +2126,7 @@ private:
     IComputationPattern::TPtr Pattern;
     THolder<IComputationGraph> ResultGraph;
     THashMap<TString, NUdf::TUnboxedValue> ResultValues;
-    bool ReadOnlyOriginPrograms;
+    bool ReadOnlyOriginPrograms; 
     bool IsCancelled;
 };
 
diff --git a/ydb/core/engine/mkql_engine_flat.h b/ydb/core/engine/mkql_engine_flat.h
index 7bee67584b..527fbde32d 100644
--- a/ydb/core/engine/mkql_engine_flat.h
+++ b/ydb/core/engine/mkql_engine_flat.h
@@ -17,11 +17,11 @@ const TStringBuf TxInternalResultPrefix = "__";
 const TStringBuf TxLocksResultLabel = "__tx_locks";
 const TStringBuf TxLocksResultLabel2 = "__tx_locks2";
 const TStringBuf TxInfoResultLabel = "__tx_info";
-
-// Should be strictly less than NActors::TEventPB::MaxByteSize to avoid VERIFY in actorlib
-const ui32 MaxDatashardReplySize = 48 * 1024 * 1024; // 48 MB
-const ui32 MaxProxyReplySize = 48 * 1024 * 1024; // 48 MB
-
+ 
+// Should be strictly less than NActors::TEventPB::MaxByteSize to avoid VERIFY in actorlib 
+const ui32 MaxDatashardReplySize = 48 * 1024 * 1024; // 48 MB 
+const ui32 MaxProxyReplySize = 48 * 1024 * 1024; // 48 MB 
+ 
 class IEngineFlat {
 public:
     virtual ~IEngineFlat() {}
@@ -97,24 +97,24 @@ public:
         {}
     };
 
-    struct TTxLock {
+    struct TTxLock { 
         TTxLock(ui64 lockId, ui64 dataShard, ui32 generation, ui64 counter, ui64 ssId, ui64 pathId)
-            : LockId(lockId)
-            , DataShard(dataShard)
-            , Generation(generation)
+            : LockId(lockId) 
+            , DataShard(dataShard) 
+            , Generation(generation) 
             , Counter(counter)
             , SchemeShard(ssId)
             , PathId(pathId)
         {}
-
+ 
         ui64 LockId;
         ui64 DataShard;
         ui32 Generation;
         ui64 Counter;
         ui64 SchemeShard;
         ui64 PathId;
-    };
-
+    }; 
+ 
     struct TTabletInfo {
         struct TTxInfo {
             std::pair<ui64, ui64> StepTxId = {0,0};
@@ -194,7 +194,7 @@ public:
     virtual void SetStepTxId(const std::pair<ui64, ui64>& stepTxId) noexcept = 0;
     virtual void AddTabletInfo(IEngineFlat::TTabletInfo&& info) noexcept = 0;
     virtual void AddTxLock(IEngineFlat::TTxLock&& txLock) noexcept = 0;
-    virtual TMaybe<ui64> GetLockTxId() noexcept = 0;
+    virtual TMaybe<ui64> GetLockTxId() noexcept = 0; 
     virtual bool HasDiagnosticsRequest() noexcept = 0;
 
     //-- proxy interface
@@ -204,15 +204,15 @@ public:
     virtual ui32 GetAffectedShardCount() const noexcept = 0;
     virtual EResult GetAffectedShard(ui32 index, TShardData& data) const noexcept = 0;
     virtual void AfterShardProgramsExtracted() noexcept = 0;
-    virtual void AddShardReply(ui64 origin, const TStringBuf& reply) noexcept = 0;
+    virtual void AddShardReply(ui64 origin, const TStringBuf& reply) noexcept = 0; 
     virtual void FinalizeOriginReplies(ui64 origin) noexcept = 0;
     virtual void BuildResult() noexcept = 0;
     virtual EStatus GetStatus() const noexcept = 0;
-    virtual EResult FillResultValue(NKikimrMiniKQL::TResult& result) const noexcept = 0;
-    virtual bool IsReadOnlyProgram() const noexcept = 0;
+    virtual EResult FillResultValue(NKikimrMiniKQL::TResult& result) const noexcept = 0; 
+    virtual bool IsReadOnlyProgram() const noexcept = 0; 
 
     //-- datashard interface
-    virtual EResult AddProgram(ui64 origin, const TStringBuf& program, bool readOnly = false) noexcept = 0;
+    virtual EResult AddProgram(ui64 origin, const TStringBuf& program, bool readOnly = false) noexcept = 0; 
     virtual EResult ValidateKeys(TValidationInfo& validationInfo) = 0;
     virtual EResult Validate(TValidationInfo& validationInfo) = 0;
 
@@ -238,8 +238,8 @@ public:
     virtual size_t GetMemoryLimit() const noexcept = 0;
     virtual void SetMemoryLimit(size_t limit) noexcept = 0;
 
-    virtual void SetDeadline(const TInstant& deadline) noexcept = 0;
-
+    virtual void SetDeadline(const TInstant& deadline) noexcept = 0; 
+ 
     virtual void ReleaseUnusedMemory() noexcept = 0;
 };
 
@@ -257,11 +257,11 @@ namespace NMiniKQL {
         IEngineFlatHost* Host;
         TAlignedPagePoolCounters AllocCounters;
         std::function<void(const char* operation, ui32 line, const TBackTrace*)> BacktraceWriter;
-        std::function<void(const TString& message)> LogErrorWriter;
+        std::function<void(const TString& message)> LogErrorWriter; 
         bool ForceOnline;
         bool EvaluateResultType = true;
         bool EvaluateResultValue = true;
-        bool LlvmRuntime = false;
+        bool LlvmRuntime = false; 
 
         TEngineFlatSettings(
                 IEngineFlat::EProtocol protocol,
diff --git a/ydb/core/engine/mkql_engine_flat_extfunc.cpp b/ydb/core/engine/mkql_engine_flat_extfunc.cpp
index 414d3aeeb4..53e4512927 100644
--- a/ydb/core/engine/mkql_engine_flat_extfunc.cpp
+++ b/ydb/core/engine/mkql_engine_flat_extfunc.cpp
@@ -86,7 +86,7 @@ namespace {
 
             MKQL_ENSURE(false, "Wrong index: " << index);
         }
-
+ 
         const NUdf::TUnboxedValue EmptyContainer;
     };
 
@@ -152,9 +152,9 @@ namespace {
         IComputationNode* const Payload;
     };
 
-    class TAcquireLocksWrapper : public TMutableComputationNode<TAcquireLocksWrapper> {
+    class TAcquireLocksWrapper : public TMutableComputationNode<TAcquireLocksWrapper> { 
         typedef TMutableComputationNode<TAcquireLocksWrapper> TBaseComputation;
-    public:
+    public: 
         TAcquireLocksWrapper(TComputationMutables& mutables, NUdf::TUnboxedValue locks, NUdf::TUnboxedValue locks2)
             : TBaseComputation(mutables)
             , Labels({TxLocksResultLabel, TxLocksResultLabel2})
@@ -163,18 +163,18 @@ namespace {
             Locks.push_back(locks);
             Locks.push_back(locks2);
         }
-
+ 
         NUdf::TUnboxedValuePod DoCalculate(TComputationContext& ctx) const {
             return ctx.HolderFactory.Create<TResultWrapper::TResult>(Locks, Labels);
-        }
-
+        } 
+ 
     private:
         void RegisterDependencies() const final {}
-
+ 
         TVector<TStringBuf> Labels;
         TVector<NUdf::TUnboxedValue> Locks;
-    };
-
+    }; 
+ 
     class TDiagnosticsWrapper : public TMutableComputationNode<TDiagnosticsWrapper> {
         typedef TMutableComputationNode<TDiagnosticsWrapper> TBaseComputation;
     public:
@@ -369,30 +369,30 @@ namespace {
         return new TResultWrapper(ctx.Mutables, label, payloadNode);
     }
 
-    IComputationNode* WrapAcquireLocks(TCallable& callable, const TComputationNodeFactoryContext& ctx,
+    IComputationNode* WrapAcquireLocks(TCallable& callable, const TComputationNodeFactoryContext& ctx, 
         const TVector<IEngineFlat::TTxLock>& txLocks)
-    {
-        MKQL_ENSURE(callable.GetInputsCount() == 1, "Expected 1 arg");
-
-        const auto& lockTxIdInput = callable.GetInput(0);
-        MKQL_ENSURE(lockTxIdInput.IsImmediate() && lockTxIdInput.GetNode()->GetType()->IsData(), "Expected immediate data");
-
-        const auto& lockTxIdData = static_cast<const TDataLiteral&>(*lockTxIdInput.GetNode());
+    { 
+        MKQL_ENSURE(callable.GetInputsCount() == 1, "Expected 1 arg"); 
+ 
+        const auto& lockTxIdInput = callable.GetInput(0); 
+        MKQL_ENSURE(lockTxIdInput.IsImmediate() && lockTxIdInput.GetNode()->GetType()->IsData(), "Expected immediate data"); 
+ 
+        const auto& lockTxIdData = static_cast<const TDataLiteral&>(*lockTxIdInput.GetNode()); 
         MKQL_ENSURE(lockTxIdData.GetType()->GetSchemeType() == NUdf::TDataType<ui64>::Id, "Expected Uint64");
-
+ 
         auto structType = GetTxLockType(ctx.Env, false);
-
+ 
         NUdf::TUnboxedValue *listItems = nullptr;
         auto locksList = ctx.HolderFactory.CreateDirectArrayHolder(txLocks.size(), listItems);
-        for (auto& txLock : txLocks) {
+        for (auto& txLock : txLocks) { 
             NUdf::TUnboxedValue *items = nullptr;
             *listItems++ = ctx.HolderFactory.CreateDirectArrayHolder(structType->GetMembersCount(), items);
             items[structType->GetMemberIndex("Counter")] = NUdf::TUnboxedValuePod(txLock.Counter);
             items[structType->GetMemberIndex("DataShard")] = NUdf::TUnboxedValuePod(txLock.DataShard);
             items[structType->GetMemberIndex("Generation")] = NUdf::TUnboxedValuePod(txLock.Generation);
             items[structType->GetMemberIndex("LockId")] = NUdf::TUnboxedValuePod(txLock.LockId);
-        }
-
+        } 
+ 
         auto structType2 = GetTxLockType(ctx.Env, true);
 
         NUdf::TUnboxedValue *listItems2 = nullptr;
@@ -409,15 +409,15 @@ namespace {
         }
 
         return new TAcquireLocksWrapper(ctx.Mutables, std::move(locksList), std::move(locksList2));
-    }
-
+    } 
+ 
     IComputationNode* WrapDiagnostics(TCallable& callable, const TComputationNodeFactoryContext& ctx,
         const TVector<IEngineFlat::TTabletInfo>& tabletInfos)
     {
         MKQL_ENSURE(callable.GetInputsCount() == 0, "Expected zero args");
 
-        auto structType = GetDiagnosticsType(ctx.Env);
-
+        auto structType = GetDiagnosticsType(ctx.Env); 
+ 
         NUdf::TUnboxedValue *listItems = nullptr;
         auto diagList = ctx.HolderFactory.CreateDirectArrayHolder(tabletInfos.size(), listItems);
         for (auto& info : tabletInfos) {
@@ -434,11 +434,11 @@ namespace {
             items[structType->GetMemberIndex("TxStep")] = NUdf::TUnboxedValuePod(info.TxInfo.StepTxId.first);
             items[structType->GetMemberIndex("TxId")] = NUdf::TUnboxedValuePod(info.TxInfo.StepTxId.second);
             items[structType->GetMemberIndex("Status")] = NUdf::TUnboxedValuePod(info.TxInfo.Status);
-            items[structType->GetMemberIndex("PrepareArriveTime")] =
+            items[structType->GetMemberIndex("PrepareArriveTime")] = 
                 NUdf::TUnboxedValuePod(info.TxInfo.PrepareArriveTime.MilliSeconds());
-            items[structType->GetMemberIndex("ProposeLatency")] =
+            items[structType->GetMemberIndex("ProposeLatency")] = 
                 NUdf::TUnboxedValuePod(info.TxInfo.ProposeLatency.MilliSeconds());
-            items[structType->GetMemberIndex("ExecLatency")] =
+            items[structType->GetMemberIndex("ExecLatency")] = 
                 NUdf::TUnboxedValuePod(info.TxInfo.ExecLatency.MilliSeconds());
         }
 
@@ -453,59 +453,59 @@ namespace {
     IComputationNode* WrapStepTxId(TCallable& callable, const TComputationNodeFactoryContext& ctx,
         const std::pair<ui64, ui64>& stepTxId) {
         MKQL_ENSURE(callable.GetInputsCount() == 0, "Expected zero args");
-
+ 
         auto ui64Type = TDataType::Create(NUdf::TDataType<ui64>::Id, ctx.Env);
         TVector<TType*> tupleTypes(2, ui64Type);
-        auto tupleType = TTupleType::Create(tupleTypes.size(), tupleTypes.data(), ctx.Env);
-
+        auto tupleType = TTupleType::Create(tupleTypes.size(), tupleTypes.data(), ctx.Env); 
+ 
         NUdf::TUnboxedValue* items = nullptr;
         auto tuple = ctx.HolderFactory.CreateDirectArrayHolder(tupleType->GetElementsCount(), items);
         items[0] = NUdf::TUnboxedValuePod(stepTxId.first);
         items[1] = NUdf::TUnboxedValuePod(stepTxId.second);
-
+ 
         return ctx.NodeFactory.CreateImmutableNode(std::move(tuple));
     }
 
-    IComputationNode* WrapConcatenatedResults(TCallable& callable, TIncomingResults::const_iterator resultIt,
-        const TComputationNodeFactoryContext& ctx)
-    {
-        auto returnType = callable.GetType()->GetReturnType();
-        MKQL_ENSURE(returnType->IsList(), "Expected list type");
-
-        TUnboxedValueVector lists;
+    IComputationNode* WrapConcatenatedResults(TCallable& callable, TIncomingResults::const_iterator resultIt, 
+        const TComputationNodeFactoryContext& ctx) 
+    { 
+        auto returnType = callable.GetType()->GetReturnType(); 
+        MKQL_ENSURE(returnType->IsList(), "Expected list type"); 
+ 
+        TUnboxedValueVector lists; 
         TValuePacker listPacker(false, returnType);
         for (const auto& result : resultIt->second) {
             lists.emplace_back(listPacker.Unpack(result, ctx.HolderFactory));
-        }
-
+        } 
+ 
         return ctx.NodeFactory.CreateImmutableNode(ctx.HolderFactory.Create<TExtendListValue>(std::move(lists)));
-    }
-
+    } 
+ 
     IComputationNode* WrapMergedSelectRow(TCallable& callable, TIncomingResults& results,
         const THashSet<ui32>& localReadCallables, IEngineFlatHost* host, const TComputationNodeFactoryContext& ctx)
-    {
+    { 
         TUnboxedValueVector values;
         if (localReadCallables.contains(callable.GetUniqueId())) {
             values.push_back(PerformLocalSelectRow(callable, *host, ctx.HolderFactory, ctx.Env));
-        }
-
-        auto returnType = callable.GetType()->GetReturnType();
-        MKQL_ENSURE(returnType->IsOptional(), "Expected optional type");
+        } 
+ 
+        auto returnType = callable.GetType()->GetReturnType(); 
+        MKQL_ENSURE(returnType->IsOptional(), "Expected optional type"); 
         TValuePacker valuePacker(false, returnType);
-
+ 
         auto resultIt = results.find(callable.GetUniqueId());
-        if (resultIt != results.end()) {
-            for (auto& result : resultIt->second) {
-                values.push_back(valuePacker.Unpack(result, ctx.HolderFactory));
-            }
-        }
-
-        if (values.empty()) {
+        if (resultIt != results.end()) { 
+            for (auto& result : resultIt->second) { 
+                values.push_back(valuePacker.Unpack(result, ctx.HolderFactory)); 
+            } 
+        } 
+ 
+        if (values.empty()) { 
             return ctx.NodeFactory.CreateOptionalNode(nullptr);
         }
 
         auto choosenValue = std::move(values.front());
-        for (size_t i = 1; i < values.size(); ++i) {
+        for (size_t i = 1; i < values.size(); ++i) { 
             if (auto& value = values[i]) {
                 MKQL_ENSURE(!choosenValue, "Multiple non-empty results for SelectRow");
                 choosenValue = std::move(value);
@@ -515,16 +515,16 @@ namespace {
         return ctx.NodeFactory.CreateImmutableNode(std::move(choosenValue));
     }
 
-    class TPartialList : public TCustomListValue {
-    public:
+    class TPartialList : public TCustomListValue { 
+    public: 
         class TIterator : public TComputationValue<TIterator> {
-        public:
+        public: 
             TIterator(TMemoryUsageInfo* memInfo, NUdf::TUnboxedValue&& listIterator, ui64 itemsLimit)
                 : TComputationValue(memInfo)
                 , ListIterator(std::move(listIterator))
-                , ItemsLimit(itemsLimit)
-                , ItemsCount(0) {}
-
+                , ItemsLimit(itemsLimit) 
+                , ItemsCount(0) {} 
+ 
         private:
             bool Next(NUdf::TUnboxedValue& value) override {
                 if (ItemsCount >= ItemsLimit) {
@@ -547,54 +547,54 @@ namespace {
             }
 
             const NUdf::TUnboxedValue ListIterator;
-            ui64 ItemsLimit;
-            ui64 ItemsCount;
-        };
-
-    public:
+            ui64 ItemsLimit; 
+            ui64 ItemsCount; 
+        }; 
+ 
+    public: 
         TPartialList(TMemoryUsageInfo* memInfo, NUdf::TUnboxedValue&& list, ui64 itemsLimit)
-            : TCustomListValue(memInfo)
+            : TCustomListValue(memInfo) 
             , List(std::move(list))
-            , ItemsLimit(itemsLimit)
-        {
-            Length = itemsLimit;
-            HasItems = itemsLimit > 0;
-        }
+            , ItemsLimit(itemsLimit) 
+        { 
+            Length = itemsLimit; 
+            HasItems = itemsLimit > 0; 
+        } 
 
     private:
         NUdf::TUnboxedValue GetListIterator() const override {
             return NUdf::TUnboxedValuePod(new TIterator(GetMemInfo(), List.GetListIterator(), ItemsLimit));
         }
 
-        NUdf::TUnboxedValue List;
-        ui64 ItemsLimit;
-    };
-
+        NUdf::TUnboxedValue List; 
+        ui64 ItemsLimit; 
+    }; 
+ 
     IComputationNode* WrapMergedSelectRange(TCallable& callable, TIncomingResults& results,
         const THashSet<ui32>& localReadCallables, IEngineFlatHost* host, const TComputationNodeFactoryContext& ctx,
-        const TFlatEngineStrings& strings)
-    {
-        TUnboxedValueVector values;
+        const TFlatEngineStrings& strings) 
+    { 
+        TUnboxedValueVector values; 
         if (localReadCallables.contains(callable.GetUniqueId())) {
             values.push_back(PerformLocalSelectRange(callable, *host, ctx.HolderFactory, ctx.Env));
-        }
-
-        auto returnType = GetActualReturnType(callable, ctx.Env, strings);
-        MKQL_ENSURE(returnType->IsStruct(), "Expected struct type");
+        } 
+ 
+        auto returnType = GetActualReturnType(callable, ctx.Env, strings); 
+        MKQL_ENSURE(returnType->IsStruct(), "Expected struct type"); 
         TValuePacker valuePacker(false, returnType);
-
+ 
         auto resultIt = results.find(callable.GetUniqueId());
-        if (resultIt != results.end()) {
-            for (auto& result : resultIt->second) {
+        if (resultIt != results.end()) { 
+            for (auto& result : resultIt->second) { 
                 values.push_back(valuePacker.Unpack(result, ctx.HolderFactory));
-            }
-        }
-
-        if (values.empty()) {
+            } 
+        } 
+ 
+        if (values.empty()) { 
             return ctx.NodeFactory.CreateImmutableNode(NUdf::TUnboxedValuePod(new TEmptyRangeHolder(ctx.HolderFactory)));
         }
 
-        if (values.size() == 1) {
+        if (values.size() == 1) { 
             return ctx.NodeFactory.CreateImmutableNode(std::move(values.front()));
         }
 
@@ -602,28 +602,28 @@ namespace {
         ui32 keyColumnsCount = 0;
         TVector<NUdf::TDataTypeId> types;
 
-        using TPartKey = std::tuple<const TCell*, NUdf::TUnboxedValue, ui64, ui64, NUdf::TUnboxedValue, bool>;
+        using TPartKey = std::tuple<const TCell*, NUdf::TUnboxedValue, ui64, ui64, NUdf::TUnboxedValue, bool>; 
 
         std::vector<TPartKey> parts;
         std::vector<TSerializedCellVec> dataBuffers;
-        parts.reserve(values.size());
-        dataBuffers.reserve(values.size());
-
-        for (auto& value : values) {
-            MKQL_ENSURE(value.IsBoxed(), "Expected boxed value");
-
+        parts.reserve(values.size()); 
+        dataBuffers.reserve(values.size()); 
+ 
+        for (auto& value : values) { 
+            MKQL_ENSURE(value.IsBoxed(), "Expected boxed value"); 
+ 
             auto list = value.GetElement(0);
-            MKQL_ENSURE(list.IsBoxed(), "Expected boxed value");
-
+            MKQL_ENSURE(list.IsBoxed(), "Expected boxed value"); 
+ 
             bool truncated = value.GetElement(1).Get<bool>();
             auto firstKeyValue = value.GetElement(2);
             ui64 sizeInBytes = value.GetElement(3).Get<ui64>();
-
+ 
             TString firstKey(firstKeyValue.AsStringRef());
             truncatedAny = truncatedAny || truncated;
-
-            ui64 itemsCount = list.GetListLength();
-            if (itemsCount == 0) {
+ 
+            ui64 itemsCount = list.GetListLength(); 
+            if (itemsCount == 0) { 
                 continue;
             }
 
@@ -647,7 +647,7 @@ namespace {
             }
 
             dataBuffers.emplace_back(firstKey.substr(typesSize, firstKey.size() - typesSize));
-            parts.emplace_back(nullptr, std::move(list), sizeInBytes, itemsCount, std::move(firstKeyValue), truncated);
+            parts.emplace_back(nullptr, std::move(list), sizeInBytes, itemsCount, std::move(firstKeyValue), truncated); 
         }
 
         for (ui32 i = 0; i < dataBuffers.size(); ++i) {
@@ -670,67 +670,67 @@ namespace {
         ui64 itemsLimit = AS_VALUE(TDataLiteral, callable.GetInput(6))->AsValue().Get<ui64>();
         ui64 bytesLimit = AS_VALUE(TDataLiteral, callable.GetInput(7))->AsValue().Get<ui64>();
 
-        TUnboxedValueVector resultLists;
-        bool resultTruncated = false;
+        TUnboxedValueVector resultLists; 
+        bool resultTruncated = false; 
         ui64 totalSize = 0;
-        ui64 totalItems = 0;
+        ui64 totalItems = 0; 
         for (auto& part : parts) {
             ui64 size = std::get<2>(part);
-            bool truncated = std::get<5>(part);
-
-            auto list = std::get<1>(part);
-            ui64 items = std::get<3>(part);
-            if (itemsLimit && itemsLimit < (items + totalItems)) {
-                resultTruncated = true;
-                ui64 itemsToFetch = itemsLimit - totalItems;
-                if (itemsToFetch > 0) {
+            bool truncated = std::get<5>(part); 
+
+            auto list = std::get<1>(part); 
+            ui64 items = std::get<3>(part); 
+            if (itemsLimit && itemsLimit < (items + totalItems)) { 
+                resultTruncated = true; 
+                ui64 itemsToFetch = itemsLimit - totalItems; 
+                if (itemsToFetch > 0) { 
                     NUdf::TUnboxedValuePod listPart(new TPartialList(&ctx.HolderFactory.GetMemInfo(), std::move(list), itemsToFetch));
                     resultLists.emplace_back(std::move(listPart));
-                }
+                } 
 
-                break;
+                break; 
             }
-
+ 
             resultLists.emplace_back(std::move(list));
-            totalSize += size;
-            totalItems += items;
+            totalSize += size; 
+            totalItems += items; 
 
             if (bytesLimit && bytesLimit < totalSize) {
-                resultTruncated = true;
+                resultTruncated = true; 
                 break;
             }
-
-            if (truncated) {
-                if (!bytesLimit) {
-                    if (itemsLimit) {
-                        MKQL_ENSURE(totalItems == itemsLimit, "SelectRange merge: not enough items in truncated part");
-                    } else {
-                        MKQL_ENSURE(false, "SelectRange merge: unexpected truncated part without specified limits");
-                    }
-                }
-
-                resultTruncated = true;
-                break;
-            }
-        }
-
-        if (truncatedAny) {
-            MKQL_ENSURE(resultTruncated, "SelectRange merge: result not truncated while truncated parts are present");
+ 
+            if (truncated) { 
+                if (!bytesLimit) { 
+                    if (itemsLimit) { 
+                        MKQL_ENSURE(totalItems == itemsLimit, "SelectRange merge: not enough items in truncated part"); 
+                    } else { 
+                        MKQL_ENSURE(false, "SelectRange merge: unexpected truncated part without specified limits"); 
+                    } 
+                } 
+ 
+                resultTruncated = true; 
+                break; 
+            } 
         }
 
-        if (resultLists.empty()) {
+        if (truncatedAny) { 
+            MKQL_ENSURE(resultTruncated, "SelectRange merge: result not truncated while truncated parts are present"); 
+        } 
+ 
+        if (resultLists.empty()) { 
             return ctx.NodeFactory.CreateImmutableNode(NUdf::TUnboxedValuePod(new TEmptyRangeHolder(ctx.HolderFactory)));
-        }
-
+        } 
+ 
         auto resultList = ctx.HolderFactory.Create<TExtendListValue>(std::move(resultLists));
 
         NUdf::TUnboxedValue* resultItems = nullptr;
         auto result = ctx.HolderFactory.CreateDirectArrayHolder(4, resultItems);
         resultItems[0] = std::move(resultList);
-        resultItems[1] = NUdf::TUnboxedValuePod(resultTruncated);
+        resultItems[1] = NUdf::TUnboxedValuePod(resultTruncated); 
         resultItems[2] = std::move(std::get<4>(parts.front()));
         resultItems[3] = NUdf::TUnboxedValuePod(totalSize);
-
+ 
         return ctx.NodeFactory.CreateImmutableNode(std::move(result));
     }
 
@@ -787,45 +787,45 @@ namespace {
         return new TUpdateRowWrapper(ctx.Mutables, tableId, tupleType,
             LocateNode(ctx.NodeLocator, callable, 1), structUpdate, LocateNode(ctx.NodeLocator, callable, 2));
     }
-
-    IComputationNode* WrapMergedTakeResults(TCallable& callable, TIncomingResults::const_iterator resultIt,
-        const TComputationNodeFactoryContext& ctx)
-    {
-        auto returnType = callable.GetType()->GetReturnType();
-        MKQL_ENSURE(returnType->IsList(), "Expected list type");
-
-        TUnboxedValueVector lists;
+ 
+    IComputationNode* WrapMergedTakeResults(TCallable& callable, TIncomingResults::const_iterator resultIt, 
+        const TComputationNodeFactoryContext& ctx) 
+    { 
+        auto returnType = callable.GetType()->GetReturnType(); 
+        MKQL_ENSURE(returnType->IsList(), "Expected list type"); 
+ 
+        TUnboxedValueVector lists; 
         TValuePacker listPacker(false, returnType);
         for (const auto& result : resultIt->second) {
             lists.emplace_back(listPacker.Unpack(result, ctx.HolderFactory));
-        }
-
-        auto countNode = callable.GetInput(1);
-        MKQL_ENSURE(countNode.IsImmediate() && countNode.GetStaticType()->IsData(), "Expected immediate data");
-        const auto& countData = static_cast<const TDataLiteral&>(*countNode.GetNode());
+        } 
+ 
+        auto countNode = callable.GetInput(1); 
+        MKQL_ENSURE(countNode.IsImmediate() && countNode.GetStaticType()->IsData(), "Expected immediate data"); 
+        const auto& countData = static_cast<const TDataLiteral&>(*countNode.GetNode()); 
         MKQL_ENSURE(countData.GetType()->GetSchemeType() == NUdf::TDataType<ui64>::Id, "Expected ui64");
         auto takeCount = countData.AsValue().Get<ui64>();
-
+ 
         return ctx.NodeFactory.CreateImmutableNode(ctx.Builder->TakeList(ctx.HolderFactory.Create<TExtendListValue>(std::move(lists)), takeCount));
-    }
-
-    IComputationNode* WrapMergedLength(TCallable& callable, TIncomingResults::const_iterator resultIt,
-        const TComputationNodeFactoryContext& ctx)
-    {
-        auto returnType = callable.GetType()->GetReturnType();
-        MKQL_ENSURE(returnType->IsData(), "Expected list type");
-        const auto& returnDataType = static_cast<const TDataType&>(*returnType);
+    } 
+ 
+    IComputationNode* WrapMergedLength(TCallable& callable, TIncomingResults::const_iterator resultIt, 
+        const TComputationNodeFactoryContext& ctx) 
+    { 
+        auto returnType = callable.GetType()->GetReturnType(); 
+        MKQL_ENSURE(returnType->IsData(), "Expected list type"); 
+        const auto& returnDataType = static_cast<const TDataType&>(*returnType); 
         MKQL_ENSURE(returnDataType.GetSchemeType() == NUdf::TDataType<ui64>::Id, "Expected ui64");
-
-        ui64 totalLength = 0;
+ 
+        ui64 totalLength = 0; 
         TValuePacker listPacker(false, returnType);
-        for (auto& result : resultIt->second) {
+        for (auto& result : resultIt->second) { 
             const auto value = listPacker.Unpack(result, ctx.HolderFactory);
-            totalLength += value.Get<ui64>();
-        }
-
+            totalLength += value.Get<ui64>(); 
+        } 
+ 
         return ctx.NodeFactory.CreateImmutableNode(NUdf::TUnboxedValuePod(totalLength));
-    }
+    } 
 }
 
 TComputationNodeFactory GetFlatShardExecutionFactory(TShardExecData& execData, bool validateOnly) {
@@ -877,10 +877,10 @@ TComputationNodeFactory GetFlatShardExecutionFactory(TShardExecData& execData, b
             return WrapUpdateRow(callable, ctx, settings.Host);
         }
 
-        if (nameStr == strings.AcquireLocks) {
-            return WrapAsVoid(ctx);
-        }
-
+        if (nameStr == strings.AcquireLocks) { 
+            return WrapAsVoid(ctx); 
+        } 
+ 
         if (nameStr == strings.Diagnostics) {
             return WrapAsVoid(ctx);
         }
@@ -890,16 +890,16 @@ TComputationNodeFactory GetFlatShardExecutionFactory(TShardExecData& execData, b
 }
 
 TComputationNodeFactory GetFlatProxyExecutionFactory(TProxyExecData& execData)
-{
+{ 
     auto builtins = GetBuiltinFactory();
     return [builtins, &execData]
-        (TCallable& callable, const TComputationNodeFactoryContext& ctx) -> IComputationNode*
-    {
+        (TCallable& callable, const TComputationNodeFactoryContext& ctx) -> IComputationNode* 
+    { 
         const TFlatEngineStrings& strings = execData.Strings;
         const TEngineFlatSettings& settings = execData.Settings;
         TIncomingResults& results = execData.Results;
 
-        auto nameStr = callable.GetType()->GetNameStr();
+        auto nameStr = callable.GetType()->GetNameStr(); 
 
         if (nameStr == strings.Abort)
             return WrapAbort(callable, ctx);
@@ -919,41 +919,41 @@ TComputationNodeFactory GetFlatProxyExecutionFactory(TProxyExecData& execData)
         if (nameStr == strings.SelectRange)
             return WrapMergedSelectRange(callable, results, {}, settings.Host, ctx, strings);
 
-        if (nameStr == strings.AcquireLocks)
+        if (nameStr == strings.AcquireLocks) 
             return WrapAcquireLocks(callable, ctx, execData.TxLocks);
-
+ 
         if (nameStr == strings.Diagnostics)
             return WrapDiagnostics(callable, ctx, execData.TabletInfos);
 
-        auto resultIt = results.find(callable.GetUniqueId());
-        if (resultIt != results.end()) {
-            // Callable results were computed on datashards, we need to merge them on the proxy in
-            // a callable-specific way.
-            if (nameStr == strings.Builtins.Filter ||
-                nameStr == strings.Builtins.FilterNullMembers ||
+        auto resultIt = results.find(callable.GetUniqueId()); 
+        if (resultIt != results.end()) { 
+            // Callable results were computed on datashards, we need to merge them on the proxy in 
+            // a callable-specific way. 
+            if (nameStr == strings.Builtins.Filter || 
+                nameStr == strings.Builtins.FilterNullMembers || 
                 nameStr == strings.Builtins.SkipNullMembers ||
-                nameStr == strings.Builtins.Map ||
-                nameStr == strings.Builtins.FlatMap ||
-                nameStr == strings.CombineByKeyMerge ||
-                nameStr == strings.PartialTake)
-            {
-                return WrapConcatenatedResults(callable, resultIt, ctx);
-            } else if (nameStr == strings.Builtins.Take) {
-                return WrapMergedTakeResults(callable, resultIt, ctx);
-            } else if (nameStr == strings.Builtins.Length) {
-                return WrapMergedLength(callable, resultIt, ctx);
-            } else {
+                nameStr == strings.Builtins.Map || 
+                nameStr == strings.Builtins.FlatMap || 
+                nameStr == strings.CombineByKeyMerge || 
+                nameStr == strings.PartialTake) 
+            { 
+                return WrapConcatenatedResults(callable, resultIt, ctx); 
+            } else if (nameStr == strings.Builtins.Take) { 
+                return WrapMergedTakeResults(callable, resultIt, ctx); 
+            } else if (nameStr == strings.Builtins.Length) { 
+                return WrapMergedLength(callable, resultIt, ctx); 
+            } else { 
                 Y_FAIL("Don't know how to merge results for callable: %s", TString(nameStr.Str()).data());
-            }
-        }
-
-        return builtins(callable, ctx);
+            } 
+        } 
+ 
+        return builtins(callable, ctx); 
     };
 }
 
 NUdf::TUnboxedValue PerformLocalSelectRow(TCallable& callable, IEngineFlatHost& engineHost,
     const THolderFactory& holderFactory, const TTypeEnvironment& env)
-{
+{ 
     MKQL_ENSURE(callable.GetInputsCount() == 5, "Expected 5 args");
     auto tableNode = callable.GetInput(0);
     const auto tableId = ExtractTableId(tableNode);
@@ -963,15 +963,15 @@ NUdf::TUnboxedValue PerformLocalSelectRow(TCallable& callable, IEngineFlatHost&
 
     auto returnType = callable.GetType()->GetReturnType();
     MKQL_ENSURE(callable.GetInput(1).GetNode()->GetType()->IsType(), "Expected type");
-
+ 
     return engineHost.SelectRow(tableId, row,
-        AS_VALUE(TStructLiteral, callable.GetInput(2)), AS_TYPE(TOptionalType, returnType),
-        ExtractFlatReadTarget(callable.GetInput(4)), holderFactory);
+        AS_VALUE(TStructLiteral, callable.GetInput(2)), AS_TYPE(TOptionalType, returnType), 
+        ExtractFlatReadTarget(callable.GetInput(4)), holderFactory); 
 }
 
 NUdf::TUnboxedValue PerformLocalSelectRange(TCallable& callable, IEngineFlatHost& engineHost,
     const THolderFactory& holderFactory, const TTypeEnvironment& env)
-{
+{ 
     MKQL_ENSURE(callable.GetInputsCount() >= 9 && callable.GetInputsCount() <= 13, "Expected 9 to 13 args");
     auto tableNode = callable.GetInput(0);
     const auto tableId = ExtractTableId(tableNode);
@@ -989,12 +989,12 @@ NUdf::TUnboxedValue PerformLocalSelectRange(TCallable& callable, IEngineFlatHost
     TTableRange range(fromValues, inclusiveFrom, toValues, inclusiveTo);
     auto returnType = callable.GetType()->GetReturnType();
     MKQL_ENSURE(callable.GetInput(1).GetNode()->GetType()->IsType(), "Expected type");
-
-    TListLiteral* skipNullKeys = nullptr;
-    if (callable.GetInputsCount() > 9) {
-        skipNullKeys = AS_VALUE(TListLiteral, callable.GetInput(9));
-    }
-
+ 
+    TListLiteral* skipNullKeys = nullptr; 
+    if (callable.GetInputsCount() > 9) { 
+        skipNullKeys = AS_VALUE(TListLiteral, callable.GetInput(9)); 
+    } 
+ 
     bool reverse = false;
     if (callable.GetInputsCount() > 10) {
         reverse = AS_VALUE(TDataLiteral, callable.GetInput(10))->AsValue().Get<bool>();
@@ -1007,14 +1007,14 @@ NUdf::TUnboxedValue PerformLocalSelectRange(TCallable& callable, IEngineFlatHost
     }
 
     return engineHost.SelectRange(tableId, range,
-        AS_VALUE(TStructLiteral, callable.GetInput(2)), skipNullKeys, AS_TYPE(TStructType, returnType),
+        AS_VALUE(TStructLiteral, callable.GetInput(2)), skipNullKeys, AS_TYPE(TStructType, returnType), 
         ExtractFlatReadTarget(callable.GetInput(8)), itemsLimit, bytesLimit, reverse, forbidNullArgs, holderFactory);
 }
 
 TStructType* GetTxLockType(const TTypeEnvironment& env, bool v2) {
     auto ui32Type = TDataType::Create(NUdf::TDataType<ui32>::Id, env);
     auto ui64Type = TDataType::Create(NUdf::TDataType<ui64>::Id, env);
-
+ 
     if (v2) {
         TVector<std::pair<TString, TType*>> lockStructMembers = {
             std::make_pair("Counter", ui64Type),
@@ -1030,16 +1030,16 @@ TStructType* GetTxLockType(const TTypeEnvironment& env, bool v2) {
     }
 
     TVector<std::pair<TString, TType*>> lockStructMembers = {
-        std::make_pair("Counter", ui64Type),
-        std::make_pair("DataShard", ui64Type),
-        std::make_pair("Generation", ui32Type),
-        std::make_pair("LockId", ui64Type),
-    };
-
-    auto lockStructType = TStructType::Create(lockStructMembers.data(), lockStructMembers.size(), env);
-    return lockStructType;
+        std::make_pair("Counter", ui64Type), 
+        std::make_pair("DataShard", ui64Type), 
+        std::make_pair("Generation", ui32Type), 
+        std::make_pair("LockId", ui64Type), 
+    }; 
+ 
+    auto lockStructType = TStructType::Create(lockStructMembers.data(), lockStructMembers.size(), env); 
+    return lockStructType; 
 }
-
+ 
 TStructType* GetDiagnosticsType(const TTypeEnvironment& env) {
     auto ui32Type = TDataType::Create(NUdf::TDataType<ui32>::Id, env);
     auto ui64Type = TDataType::Create(NUdf::TDataType<ui64>::Id, env);
@@ -1063,33 +1063,33 @@ TStructType* GetDiagnosticsType(const TTypeEnvironment& env) {
     return TStructType::Create(diagStructMembers.data(), diagStructMembers.size(), env);
 }
 
-TType* GetActualReturnType(const TCallable& callable, const TTypeEnvironment& env,
-    const TFlatEngineStrings& strings)
-{
-    auto name = callable.GetType()->GetNameStr();
-    auto returnType = callable.GetType()->GetReturnType();
-
-    if (name == strings.SelectRange) {
-        // SelectRange implementataion use extended return struct (with _FirstKey and _Size)
-        // required for merging purposes.
-        // TODO: Fix SelectRange type, pass this information ouside of the callable result or
-        // recompute during merging phase.
-        MKQL_ENSURE(returnType->GetKind() == TType::EKind::Struct,
-            "Expected struct as SelectRange return type.");
-        auto& structType = static_cast<TStructType&>(*returnType);
-        if (structType.GetMembersCount() == 2) {
-            TStructTypeBuilder extendedStructBuilder(env);
-            extendedStructBuilder.Add(structType.GetMemberName(0), structType.GetMemberType(0));
-            extendedStructBuilder.Add(structType.GetMemberName(1), structType.GetMemberType(1));
+TType* GetActualReturnType(const TCallable& callable, const TTypeEnvironment& env, 
+    const TFlatEngineStrings& strings) 
+{ 
+    auto name = callable.GetType()->GetNameStr(); 
+    auto returnType = callable.GetType()->GetReturnType(); 
+ 
+    if (name == strings.SelectRange) { 
+        // SelectRange implementataion use extended return struct (with _FirstKey and _Size) 
+        // required for merging purposes. 
+        // TODO: Fix SelectRange type, pass this information ouside of the callable result or 
+        // recompute during merging phase. 
+        MKQL_ENSURE(returnType->GetKind() == TType::EKind::Struct, 
+            "Expected struct as SelectRange return type."); 
+        auto& structType = static_cast<TStructType&>(*returnType); 
+        if (structType.GetMembersCount() == 2) { 
+            TStructTypeBuilder extendedStructBuilder(env); 
+            extendedStructBuilder.Add(structType.GetMemberName(0), structType.GetMemberType(0)); 
+            extendedStructBuilder.Add(structType.GetMemberName(1), structType.GetMemberType(1)); 
             extendedStructBuilder.Add("_FirstKey", TDataType::Create(NUdf::TDataType<char*>::Id, env));
             extendedStructBuilder.Add("_Size", TDataType::Create(NUdf::TDataType<ui64>::Id, env));
-
-            return extendedStructBuilder.Build();
-        }
-    }
-
-    return returnType;
-}
-
-}
+ 
+            return extendedStructBuilder.Build(); 
+        } 
+    } 
+ 
+    return returnType; 
 }
+ 
+} 
+} 
diff --git a/ydb/core/engine/mkql_engine_flat_host.h b/ydb/core/engine/mkql_engine_flat_host.h
index 0593fb3a9b..e848619fee 100644
--- a/ydb/core/engine/mkql_engine_flat_host.h
+++ b/ydb/core/engine/mkql_engine_flat_host.h
@@ -16,8 +16,8 @@ public:
         TCell Value;
     };
 
-    using TPeriodicCallback = std::function<void()>;
-
+    using TPeriodicCallback = std::function<void()>; 
+ 
     virtual ~IEngineFlatHost() {}
 
     // Returns shard id of the host.
@@ -43,18 +43,18 @@ public:
 
     // Returns empty optional with type 'returnType' or the filled one.
     virtual NUdf::TUnboxedValue SelectRow(const TTableId& tableId, const TArrayRef<const TCell>& row,
-        TStructLiteral* columnIds, TOptionalType* returnType, const TReadTarget& readTarget,
-        const THolderFactory& holderFactory) = 0;
+        TStructLiteral* columnIds, TOptionalType* returnType, const TReadTarget& readTarget, 
+        const THolderFactory& holderFactory) = 0; 
 
     // Returns struct with type 'returnType' - that should have fields 'List' and 'Truncated'.
     virtual NUdf::TUnboxedValue SelectRange(const TTableId& tableId, const TTableRange& range,
-        TStructLiteral* columnIds, TListLiteral* skipNullKeys, TStructType* returnType,
+        TStructLiteral* columnIds, TListLiteral* skipNullKeys, TStructType* returnType, 
         const TReadTarget& readTarget, ui64 itemsLimit, ui64 bytesLimit, bool reverse,
         std::pair<const TListLiteral*, const TListLiteral*> forbidNullArgs, const THolderFactory& holderFactory) = 0;
 
     // Updates the single row. Column in commands must be unique.
-    virtual void UpdateRow(const TTableId& tableId, const TArrayRef<const TCell>& row,
-        const TArrayRef<const TUpdateCommand>& commands) = 0;
+    virtual void UpdateRow(const TTableId& tableId, const TArrayRef<const TCell>& row, 
+        const TArrayRef<const TUpdateCommand>& commands) = 0; 
 
     // Erases the single row.
     virtual void EraseRow(const TTableId& tableId, const TArrayRef<const TCell>& row) = 0;
@@ -67,9 +67,9 @@ public:
 
     // Returns schema version for given tableId
     virtual ui64 GetTableSchemaVersion(const TTableId& tableId) const = 0;
-
-    // Set callback for periodic execution
-    virtual void SetPeriodicCallback(TPeriodicCallback&& callback) = 0;
+ 
+    // Set callback for periodic execution 
+    virtual void SetPeriodicCallback(TPeriodicCallback&& callback) = 0; 
 };
 
 }
diff --git a/ydb/core/engine/mkql_engine_flat_impl.h b/ydb/core/engine/mkql_engine_flat_impl.h
index bb232a52aa..66b1cab98e 100644
--- a/ydb/core/engine/mkql_engine_flat_impl.h
+++ b/ydb/core/engine/mkql_engine_flat_impl.h
@@ -6,8 +6,8 @@ namespace NKikimr {
 namespace NMiniKQL {
     typedef THashMap<ui32, TVector<TString>> TIncomingResults;
 
-    struct TBuiltinStrings {
-        TBuiltinStrings(const TTypeEnvironment& env)
+    struct TBuiltinStrings { 
+        TBuiltinStrings(const TTypeEnvironment& env) 
             : Filter(env.InternName(TStringBuf("Filter")))
             , FilterNullMembers(env.InternName(TStringBuf("FilterNullMembers")))
             , SkipNullMembers(env.InternName(TStringBuf("SkipNullMembers")))
@@ -19,21 +19,21 @@ namespace NMiniKQL {
             , Take(env.InternName(TStringBuf("Take")))
             , Length(env.InternName(TStringBuf("Length")))
             , Arg(env.InternName(TStringBuf("Arg")))
-        {
+        { 
             All.reserve(20);
-            All.insert(Filter);
-            All.insert(FilterNullMembers);
+            All.insert(Filter); 
+            All.insert(FilterNullMembers); 
             All.insert(SkipNullMembers);
-            All.insert(FlatMap);
-            All.insert(Map);
-            All.insert(Member);
-            All.insert(ToHashedDict);
-            All.insert(DictItems);
-            All.insert(Take);
-            All.insert(Length);
-            All.insert(Arg);
-        }
-
+            All.insert(FlatMap); 
+            All.insert(Map); 
+            All.insert(Member); 
+            All.insert(ToHashedDict); 
+            All.insert(DictItems); 
+            All.insert(Take); 
+            All.insert(Length); 
+            All.insert(Arg); 
+        } 
+ 
         const TInternName Filter;
         const TInternName FilterNullMembers;
         const TInternName SkipNullMembers;
@@ -44,15 +44,15 @@ namespace NMiniKQL {
         const TInternName DictItems;
         const TInternName Take;
         const TInternName Length;
-        const TInternName Arg;
-
+        const TInternName Arg; 
+ 
         THashSet<TInternName> All;
-    };
-
+    }; 
+ 
     struct TFlatEngineStrings : public TTableStrings {
         TFlatEngineStrings(const TTypeEnvironment& env)
             : TTableStrings(env)
-            , Builtins(env)
+            , Builtins(env) 
             , SetResult(env.InternName(TStringBuf("SetResult")))
             , Abort(env.InternName(TStringBuf("Abort")))
             , StepTxId(env.InternName(TStringBuf("StepTxId")))
@@ -61,25 +61,25 @@ namespace NMiniKQL {
             , Diagnostics(env.InternName(TStringBuf("Diagnostics")))
             , PartialTake(env.InternName(TStringBuf("PartialTake")))
             , PartialSort(env.InternName(TStringBuf("PartialSort")))
-        {
-            All.insert(SetResult);
-            All.insert(Abort);
-            All.insert(StepTxId);
-            All.insert(AcquireLocks);
-            All.insert(CombineByKeyMerge);
+        { 
+            All.insert(SetResult); 
+            All.insert(Abort); 
+            All.insert(StepTxId); 
+            All.insert(AcquireLocks); 
+            All.insert(CombineByKeyMerge); 
             All.insert(Diagnostics);
-        }
-
-        TBuiltinStrings Builtins;
+        } 
 
+        TBuiltinStrings Builtins; 
+ 
         const TInternName SetResult;
         const TInternName Abort;
         const TInternName StepTxId;
         const TInternName AcquireLocks;
         const TInternName CombineByKeyMerge;
         const TInternName Diagnostics;
-        const TInternName PartialTake;
-        const TInternName PartialSort;
+        const TInternName PartialTake; 
+        const TInternName PartialSort; 
     };
 
     struct TShardExecData {
@@ -89,7 +89,7 @@ namespace NMiniKQL {
             , Strings(strings)
             , StepTxId(stepTxId)
         {}
-
+ 
         const TEngineFlatSettings& Settings;
         const TFlatEngineStrings& Strings;
         const std::pair<ui64, ui64>& StepTxId;
@@ -130,10 +130,10 @@ namespace NMiniKQL {
         THashMap<TString, NUdf::TUnboxedValue>* ResultValues = nullptr;
         const TTypeEnvironment* Env = nullptr;
     };
-
+ 
     TStructType* GetTxLockType(const TTypeEnvironment& env, bool v2);
     TStructType* GetDiagnosticsType(const TTypeEnvironment& env);
-    TType* GetActualReturnType(const TCallable& callable, const TTypeEnvironment& env,
-        const TFlatEngineStrings& strings);
+    TType* GetActualReturnType(const TCallable& callable, const TTypeEnvironment& env, 
+        const TFlatEngineStrings& strings); 
 }
 }
diff --git a/ydb/core/engine/mkql_engine_flat_ut.cpp b/ydb/core/engine/mkql_engine_flat_ut.cpp
index e2b12e2d7a..8daca82c41 100644
--- a/ydb/core/engine/mkql_engine_flat_ut.cpp
+++ b/ydb/core/engine/mkql_engine_flat_ut.cpp
@@ -1,6 +1,6 @@
 #include "mkql_engine_flat.h"
 #include "mkql_engine_flat_host.h"
-
+ 
 #include <ydb/library/yql/minikql/mkql_function_registry.h>
 #include <ydb/core/tablet_flat/flat_cxx_database.h>
 #include <ydb/library/yql/minikql/mkql_node_serialization.h>
@@ -88,13 +88,13 @@ namespace {
 
     void SingleShardResolver(TKeyDesc& key) {
         key.Status = TKeyDesc::EStatus::Ok;
-        key.Partitions.push_back(TKeyDesc::TPartitionInfo(Shard1));
+        key.Partitions.push_back(TKeyDesc::TPartitionInfo(Shard1)); 
     }
 
     void DoubleShardResolver(TKeyDesc& key) {
         key.Status = TKeyDesc::EStatus::Ok;
-        key.Partitions.push_back(TKeyDesc::TPartitionInfo(Shard1));
-        key.Partitions.push_back(TKeyDesc::TPartitionInfo(Shard2));
+        key.Partitions.push_back(TKeyDesc::TPartitionInfo(Shard1)); 
+        key.Partitions.push_back(TKeyDesc::TPartitionInfo(Shard2)); 
     }
 
     void TwoShardResolver(TKeyDesc& key) {
@@ -138,8 +138,8 @@ namespace {
         IEngineFlat::EStatus Run(
             TRuntimeNode pgm,
             NKikimrMiniKQL::TResult& res,
-            std::function<void(TKeyDesc&)> keyResolver,
-            IEngineFlat::TShardLimits shardLimits = IEngineFlat::TShardLimits()) {
+            std::function<void(TKeyDesc&)> keyResolver, 
+            IEngineFlat::TShardLimits shardLimits = IEngineFlat::TShardLimits()) { 
             TString pgmStr = SerializeRuntimeNode(pgm, Env);
 
             TEngineFlatSettings settings(IEngineFlat::EProtocol::V1, FunctionRegistry.Get(), *RandomProvider, *TimeProvider);
@@ -159,7 +159,7 @@ namespace {
                     return IEngineFlat::EStatus::Error;
             }
 
-            if (proxyEngine->PrepareShardPrograms(shardLimits) != IEngineFlat::EResult::Ok) {
+            if (proxyEngine->PrepareShardPrograms(shardLimits) != IEngineFlat::EResult::Ok) { 
                 Cerr << proxyEngine->GetErrors() << Endl;
                 return IEngineFlat::EStatus::Error;
             }
@@ -263,7 +263,7 @@ namespace {
                 else {
                     const TString reply = dataEngine->GetShardReply(shardPgm.first);
                     ShardReplyInspector(shardPgm.first, reply);
-                    proxyEngine->AddShardReply(shardPgm.first, reply);
+                    proxyEngine->AddShardReply(shardPgm.first, reply); 
                     proxyEngine->FinalizeOriginReplies(shardPgm.first);
                 }
 
@@ -1528,13 +1528,13 @@ Value {
             NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
             db.Table<Schema1::Table1>()
                 .Key(ui32(42))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("loremipsumloremipsum1"));
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("loremipsumloremipsum1")); 
             db.Table<Schema1::Table1>()
                 .Key(ui32(43))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("loremipsumloremipsum2"));
-                db.Table<Schema1::Table1>()
-                .Key(ui32(44))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("loremipsumloremipsum3"));
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("loremipsumloremipsum2")); 
+                db.Table<Schema1::Table1>() 
+                .Key(ui32(44)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("loremipsumloremipsum3")); 
 
             driver.ShardDbState.CommitTransaction(Shard1);
         }
@@ -1550,7 +1550,7 @@ Value {
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
         options.FromColumns = rowFrom;
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        options.BytesLimit = pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(32);
+        options.BytesLimit = pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(32); 
         auto value = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
         auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("myRes", value)));
 
@@ -1618,17 +1618,17 @@ Value {
         List {
           Struct {
             Optional {
-              Text: "loremipsumloremipsum1"
-            }
-          }
-        }
-        List {
-          Struct {
-            Optional {
-              Text: "loremipsumloremipsum2"
+              Text: "loremipsumloremipsum1" 
             }
           }
         }
+        List { 
+          Struct { 
+            Optional { 
+              Text: "loremipsumloremipsum2" 
+            } 
+          } 
+        } 
       }
       Struct {
         Bool: true
@@ -4378,74 +4378,74 @@ Value {
     }
 
     Y_UNIT_TEST(TestAcquireLocks) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        auto& pgmBuilder = driver.PgmBuilder;
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.AcquireLocks(
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.AcquireLocks( 
             pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(0))));
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete);
-        auto resStr = res.DebugString();
-
-        auto expectedStr = R"___(Type {
-  Kind: Struct
-  Struct {
-    Member {
-      Name: "__tx_locks"
-      Type {
-        Kind: Optional
-        Optional {
-          Item {
-            Kind: List
-            List {
-              Item {
-                Kind: Struct
-                Struct {
-                  Member {
-                    Name: "Counter"
-                    Type {
-                      Kind: Data
-                      Data {
-                        Scheme: 4
-                      }
-                    }
-                  }
-                  Member {
-                    Name: "DataShard"
-                    Type {
-                      Kind: Data
-                      Data {
-                        Scheme: 4
-                      }
-                    }
-                  }
-                  Member {
-                    Name: "Generation"
-                    Type {
-                      Kind: Data
-                      Data {
-                        Scheme: 2
-                      }
-                    }
-                  }
-                  Member {
-                    Name: "LockId"
-                    Type {
-                      Kind: Data
-                      Data {
-                        Scheme: 4
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete); 
+        auto resStr = res.DebugString(); 
+ 
+        auto expectedStr = R"___(Type { 
+  Kind: Struct 
+  Struct { 
+    Member { 
+      Name: "__tx_locks" 
+      Type { 
+        Kind: Optional 
+        Optional { 
+          Item { 
+            Kind: List 
+            List { 
+              Item { 
+                Kind: Struct 
+                Struct { 
+                  Member { 
+                    Name: "Counter" 
+                    Type { 
+                      Kind: Data 
+                      Data { 
+                        Scheme: 4 
+                      } 
+                    } 
+                  } 
+                  Member { 
+                    Name: "DataShard" 
+                    Type { 
+                      Kind: Data 
+                      Data { 
+                        Scheme: 4 
+                      } 
+                    } 
+                  } 
+                  Member { 
+                    Name: "Generation" 
+                    Type { 
+                      Kind: Data 
+                      Data { 
+                        Scheme: 2 
+                      } 
+                    } 
+                  } 
+                  Member { 
+                    Name: "LockId" 
+                    Type { 
+                      Kind: Data 
+                      Data { 
+                        Scheme: 4 
+                      } 
+                    } 
+                  } 
+                } 
+              } 
+            } 
+          } 
+        } 
+      } 
+    } 
     Member {
       Name: "__tx_locks2"
       Type {
@@ -4518,21 +4518,21 @@ Value {
         }
       }
     }
-  }
+  } 
 }
-Value {
+Value { 
+  Struct { 
+    Optional { 
+    } 
+  } 
   Struct {
     Optional {
     }
   }
-  Struct {
-    Optional {
-    }
-  }
-}
-)___";
-        UNIT_ASSERT_STRINGS_EQUAL(resStr, expectedStr);
-    }
+} 
+)___"; 
+        UNIT_ASSERT_STRINGS_EQUAL(resStr, expectedStr); 
+    } 
 
     Y_UNIT_TEST(TestDiagnostics) {
         TDriver driver;
@@ -4689,1768 +4689,1768 @@ Value {
 
     Y_UNIT_TEST(TestMapsPushdown) {
         const TString okValue = "Ok";
-
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>(okValue));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>(okValue));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>(okValue));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>(okValue));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+ 
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>(okValue)); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>(okValue)); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>(okValue)); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>(okValue)); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
         TVector<TStringBuf> filterNullColumns {"Value"};
-        auto filterNull = pgmBuilder.FilterNullMembers(list, filterNullColumns);
-        auto filtered = pgmBuilder.Filter(filterNull, [&pgmBuilder, &okValue](TRuntimeNode item) {
+        auto filterNull = pgmBuilder.FilterNullMembers(list, filterNullColumns); 
+        auto filtered = pgmBuilder.Filter(filterNull, [&pgmBuilder, &okValue](TRuntimeNode item) { 
             return pgmBuilder.AggrEquals(
-                pgmBuilder.Member(item, "Value"),
+                pgmBuilder.Member(item, "Value"), 
                 pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(okValue));
-        });
-        auto mapped = pgmBuilder.Map(filtered, [&pgmBuilder](TRuntimeNode item) {
-            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add(
+        }); 
+        auto mapped = pgmBuilder.Map(filtered, [&pgmBuilder](TRuntimeNode item) { 
+            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add( 
                 pgmBuilder.Member(item, "ID"), pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10)));
-        });
-        auto flatmapped = pgmBuilder.FlatMap(mapped, [&pgmBuilder](TRuntimeNode item) {
+        }); 
+        auto flatmapped = pgmBuilder.FlatMap(mapped, [&pgmBuilder](TRuntimeNode item) { 
             TString prefix = "mapped_";
             auto prefixNode = pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::String>(prefix);
-
-            return pgmBuilder.AsList(pgmBuilder.AddMember(item, "RemappedId", pgmBuilder.Concat(
-                prefixNode, pgmBuilder.ToString(pgmBuilder.Coalesce(pgmBuilder.Member(item, "MappedID"),
+ 
+            return pgmBuilder.AsList(pgmBuilder.AddMember(item, "RemappedId", pgmBuilder.Concat( 
+                prefixNode, pgmBuilder.ToString(pgmBuilder.Coalesce(pgmBuilder.Member(item, "MappedID"), 
                     pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(0))))));
-        });
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", flatmapped)));
-
+        }); 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", flatmapped))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(program.Contains("Filter"));
-            UNIT_ASSERT(program.Contains("Map"));
-            UNIT_ASSERT(program.Contains("FlatMap"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(program.Contains("Filter")); 
+            UNIT_ASSERT(program.Contains("Map")); 
+            UNIT_ASSERT(program.Contains("FlatMap")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[ 
             [["1"];["11"];"mapped_11";"Ok"];
             [["5"];["15"];"mapped_15";"Ok"];
             [["4"];["14"];"mapped_14";"Ok"];
             [["6"];["16"];"mapped_16";"Ok"]
-        ]]])___", res);
-    }
-
+        ]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(NoMapPushdownMultipleConsumers) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-        auto mapped = pgmBuilder.Map(list, [&pgmBuilder](TRuntimeNode item) {
-            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add(
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+        auto mapped = pgmBuilder.Map(list, [&pgmBuilder](TRuntimeNode item) { 
+            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add( 
                 pgmBuilder.Member(item, "ID"), pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10)));
-        });
-
+        }); 
+ 
         TRuntimeNode::TList results;
-        results.push_back(pgmBuilder.SetResult("Result1", mapped));
-        results.push_back(pgmBuilder.SetResult("Result2", list));
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(results));
-
+        results.push_back(pgmBuilder.SetResult("Result1", mapped)); 
+        results.push_back(pgmBuilder.SetResult("Result2", list)); 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(results)); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-            UNIT_ASSERT(!program.Contains("Map"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([
-            [[
+            Y_UNUSED(shard); 
+            UNIT_ASSERT(!program.Contains("Map")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([ 
+            [[ 
                 [["1"];["11"];["Ok"]];
                 [["3"];["13"];["Bad"]];
                 [["5"];["15"];["Ok"]]
-            ]];
-            [[
+            ]]; 
+            [[ 
                 [["1"];["Ok"]];
                 [["3"];["Bad"]];
                 [["5"];["Ok"]]
-            ]]
-        ])___", res);
-    }
-
+            ]] 
+        ])___", res); 
+    } 
+ 
     Y_UNIT_TEST(NoMapPushdownNonPureLambda) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-        auto mapped = pgmBuilder.Map(list, [&pgmBuilder, keyTypes, columns](TRuntimeNode item) {
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+        auto mapped = pgmBuilder.Map(list, [&pgmBuilder, keyTypes, columns](TRuntimeNode item) { 
             TRuntimeNode::TList row(1);
             row[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(3);
-
-            return pgmBuilder.AddMember(item, "Fetch",
-                pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row));
-        });
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", mapped)));
-
+ 
+            return pgmBuilder.AddMember(item, "Fetch", 
+                pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row)); 
+        }); 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", mapped))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-            UNIT_ASSERT(!program.Contains("Map"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[
+            Y_UNUSED(shard); 
+            UNIT_ASSERT(!program.Contains("Map")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[ 
             [[[["3"];["Bad"]]];["1"];["Ok"]];
             [[[["3"];["Bad"]]];["3"];["Bad"]];
             [[[["3"];["Bad"]]];["5"];["Ok"]]
-        ]]])___", res);
-    }
-
+        ]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(NoOrderedMapPushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+ 
         const TString okValue = "Ok";
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
-        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-        auto filtered = pgmBuilder.OrderedFilter(list, [&pgmBuilder, &okValue](TRuntimeNode item) {
+        options.FromColumns = rowFrom; 
+        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+        auto filtered = pgmBuilder.OrderedFilter(list, [&pgmBuilder, &okValue](TRuntimeNode item) { 
             return pgmBuilder.AggrEquals(
                 pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
                 pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(okValue));
-        });
-        auto mapped = pgmBuilder.OrderedMap(filtered, [&pgmBuilder](TRuntimeNode item) {
-            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add(
-                pgmBuilder.Member(item, "ID"), pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10)));
-        });
-        auto flatmapped = pgmBuilder.OrderedFlatMap(mapped, [&pgmBuilder](TRuntimeNode item) {
+        }); 
+        auto mapped = pgmBuilder.OrderedMap(filtered, [&pgmBuilder](TRuntimeNode item) { 
+            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add( 
+                pgmBuilder.Member(item, "ID"), pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10))); 
+        }); 
+        auto flatmapped = pgmBuilder.OrderedFlatMap(mapped, [&pgmBuilder](TRuntimeNode item) { 
             TString prefix = "mapped_";
             auto prefixNode = pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::String>(prefix);
-
-            return pgmBuilder.AsList(pgmBuilder.AddMember(item, "RemappedId", pgmBuilder.Concat(
-                prefixNode, pgmBuilder.ToString(pgmBuilder.Coalesce(pgmBuilder.Member(item, "MappedID"),
-                    pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(0))))));
-        });
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", flatmapped)));
-
+ 
+            return pgmBuilder.AsList(pgmBuilder.AddMember(item, "RemappedId", pgmBuilder.Concat( 
+                prefixNode, pgmBuilder.ToString(pgmBuilder.Coalesce(pgmBuilder.Member(item, "MappedID"), 
+                    pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(0)))))); 
+        }); 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", flatmapped))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-            UNIT_ASSERT(!program.Contains("Filter"));
-            UNIT_ASSERT(!program.Contains("OrderedFilter"));
-            UNIT_ASSERT(!program.Contains("Map"));
-            UNIT_ASSERT(!program.Contains("OrderedMap"));
-            UNIT_ASSERT(!program.Contains("FlatMap"));
-            UNIT_ASSERT(!program.Contains("OrderedFlatMap"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[
+            Y_UNUSED(shard); 
+            UNIT_ASSERT(!program.Contains("Filter")); 
+            UNIT_ASSERT(!program.Contains("OrderedFilter")); 
+            UNIT_ASSERT(!program.Contains("Map")); 
+            UNIT_ASSERT(!program.Contains("OrderedMap")); 
+            UNIT_ASSERT(!program.Contains("FlatMap")); 
+            UNIT_ASSERT(!program.Contains("OrderedFlatMap")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[ 
             [["1"];["11"];"mapped_11";["Ok"]];
             [["5"];["15"];"mapped_15";["Ok"]]
-        ]]])___", res);
-    }
-
+        ]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(NoMapPushdownWriteToTable) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema2>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-            db.Table<Schema2::Table2>()
-                .Key(ui64(0))
-                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(0));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema2>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+            db.Table<Schema2::Table2>() 
+                .Key(ui64(0)) 
+                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(0)); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-        auto mapped = pgmBuilder.Map(list, [&pgmBuilder](TRuntimeNode item) {
-            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add(
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+        auto mapped = pgmBuilder.Map(list, [&pgmBuilder](TRuntimeNode item) { 
+            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add( 
                 pgmBuilder.Member(item, "ID"), pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10)));
-        });
-
-        auto write = pgmBuilder.Map(mapped, [&pgmBuilder](TRuntimeNode item) {
+        }); 
+ 
+        auto write = pgmBuilder.Map(mapped, [&pgmBuilder](TRuntimeNode item) { 
             TVector<ui32> keyTypes(1);
             keyTypes[0] = (ui32)NUdf::TDataType<ui64>::Id;
-
+ 
             TRuntimeNode::TList row(1);
             row[0] = pgmBuilder.Convert(pgmBuilder.Member(item, "ID"), pgmBuilder.NewOptionalType(pgmBuilder.NewDataType(NUdf::TDataType<ui64>::Id)));
-
-            auto update = pgmBuilder.GetUpdateRowBuilder();
-            ui32 columnId = (ui32)Schema2::Table2::Value::ColumnId;
+ 
+            auto update = pgmBuilder.GetUpdateRowBuilder(); 
+            ui32 columnId = (ui32)Schema2::Table2::Value::ColumnId; 
             update.SetColumn(columnId, NUdf::TDataType<ui32>::Id, pgmBuilder.Member(item, "ID"));
-            return pgmBuilder.UpdateRow(TTableId(OwnerId, Table2Id), keyTypes, row, update);
-        });
-
-        auto pgm = pgmBuilder.Build(write);
-
+            return pgmBuilder.UpdateRow(TTableId(OwnerId, Table2Id), keyTypes, row, update); 
+        }); 
+ 
+        auto pgm = pgmBuilder.Build(write); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            if (shard == Shard1) {
-                UNIT_ASSERT(!program.Contains("Map"));
-            }
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete);
-
-        {
+            if (shard == Shard1) { 
+                UNIT_ASSERT(!program.Contains("Map")); 
+            } 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        { 
             TVector<TSelectColumn> columns;
-            columns.emplace_back("ID", (ui32)Schema2::Table2::ID::ColumnId, (ui32)Schema2::Table2::ID::ColumnType);
-            columns.emplace_back("Value", (ui32)Schema2::Table2::Value::ColumnId, (ui32)Schema2::Table2::Value::ColumnType);
-
-            auto options = pgmBuilder.GetDefaultTableRangeOptions();
+            columns.emplace_back("ID", (ui32)Schema2::Table2::ID::ColumnId, (ui32)Schema2::Table2::ID::ColumnType); 
+            columns.emplace_back("Value", (ui32)Schema2::Table2::Value::ColumnId, (ui32)Schema2::Table2::Value::ColumnType); 
+ 
+            auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
             TVector<ui32> keyTypes(1);
             keyTypes[0] = (ui32)NUdf::TDataType<ui64>::Id;
             TRuntimeNode::TList rowFrom(1);
             rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui64>::Id);
-            options.FromColumns = rowFrom;
+            options.FromColumns = rowFrom; 
             options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-            auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table2Id), keyTypes, columns, options);
-            auto checkpgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", range)));
-
-            NKikimrMiniKQL::TResult res;
-            UNIT_ASSERT_EQUAL(driver.Run(checkpgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete);
-
-            NKqp::CompareYson(R"___([[[[
+            auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table2Id), keyTypes, columns, options); 
+            auto checkpgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", range))); 
+ 
+            NKikimrMiniKQL::TResult res; 
+            UNIT_ASSERT_EQUAL(driver.Run(checkpgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+            NKqp::CompareYson(R"___([[[[ 
                 [["0"];["0"]];
                 [["1"];["1"]];
                 [["3"];["3"]];
                 [["5"];["5"]]];
-                %false]]])___", res);
-        }
-    }
-
+                %false]]])___", res); 
+        } 
+    } 
+ 
     Y_UNIT_TEST(NoMapPushdownArgClosure) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema2>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema2::Table2>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(20));
-            db.Table<Schema2::Table2>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(40));
-
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema2>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema2::Table2>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(20)); 
+            db.Table<Schema2::Table2>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(40)); 
+ 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns1;
-        columns1.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns1.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-        auto options1 = pgmBuilder.GetDefaultTableRangeOptions();
+        columns1.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns1.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+        auto options1 = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes1(1);
         keyTypes1[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom1(1);
         rowFrom1[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options1.FromColumns = rowFrom1;
-        options1.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range1 = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes1, columns1, options1);
-        auto list1 = pgmBuilder.Member(range1, "List");
-
+        options1.FromColumns = rowFrom1; 
+        options1.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range1 = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes1, columns1, options1); 
+        auto list1 = pgmBuilder.Member(range1, "List"); 
+ 
         TVector<TSelectColumn> columns2;
-        columns2.emplace_back("ID", (ui32)Schema2::Table2::ID::ColumnId, (ui32)Schema2::Table2::ID::ColumnType);
-        columns2.emplace_back("Value", (ui32)Schema2::Table2::Value::ColumnId, (ui32)Schema2::Table2::Value::ColumnType);
-        auto options2 = pgmBuilder.GetDefaultTableRangeOptions();
+        columns2.emplace_back("ID", (ui32)Schema2::Table2::ID::ColumnId, (ui32)Schema2::Table2::ID::ColumnType); 
+        columns2.emplace_back("Value", (ui32)Schema2::Table2::Value::ColumnId, (ui32)Schema2::Table2::Value::ColumnType); 
+        auto options2 = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes2(1);
         keyTypes2[0] = (ui32)NUdf::TDataType<ui64>::Id;
         TRuntimeNode::TList rowFrom2(1);
         rowFrom2[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui64>::Id);
-        options2.FromColumns = rowFrom2;
-        options2.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range2 = pgmBuilder.SelectRange(TTableId(OwnerId, Table2Id), keyTypes2, columns2, options2);
-        auto list2 = pgmBuilder.Member(range2, "List");
-
-        auto flatmapped = pgmBuilder.FlatMap(list1, [&pgmBuilder, &list2](TRuntimeNode item1) {
-            auto mapped = pgmBuilder.Map(list2, [&pgmBuilder, &item1](TRuntimeNode item2) {
-                return pgmBuilder.NewTuple({item1, item2});
-            });
-
-            return mapped;
-        });
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", flatmapped)));
-
-        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(!program.Contains("Map"));
-            UNIT_ASSERT(!program.Contains("FlatMap"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[
+        options2.FromColumns = rowFrom2; 
+        options2.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range2 = pgmBuilder.SelectRange(TTableId(OwnerId, Table2Id), keyTypes2, columns2, options2); 
+        auto list2 = pgmBuilder.Member(range2, "List"); 
+ 
+        auto flatmapped = pgmBuilder.FlatMap(list1, [&pgmBuilder, &list2](TRuntimeNode item1) { 
+            auto mapped = pgmBuilder.Map(list2, [&pgmBuilder, &item1](TRuntimeNode item2) { 
+                return pgmBuilder.NewTuple({item1, item2}); 
+            }); 
+ 
+            return mapped; 
+        }); 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", flatmapped))); 
+ 
+        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) { 
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(!program.Contains("Map")); 
+            UNIT_ASSERT(!program.Contains("FlatMap")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[ 
             [[["1"];["Ok"]];[["2"];["20"]]];
             [[["1"];["Ok"]];[["4"];["40"]]];
             [[["3"];["Bad"]];[["2"];["20"]]];
             [[["3"];["Bad"]];[["4"];["40"]]]
-        ]]])___", res);
-    }
-
+        ]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestSomePushDown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema2>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema2::Table2>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(20));
-            db.Table<Schema2::Table2>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(40));
-
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema2>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema2::Table2>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(20)); 
+            db.Table<Schema2::Table2>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(40)); 
+ 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns1;
-        columns1.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns1.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-        auto options1 = pgmBuilder.GetDefaultTableRangeOptions();
+        columns1.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns1.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+        auto options1 = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes1(1);
         keyTypes1[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom1(1);
         rowFrom1[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options1.FromColumns = rowFrom1;
-        options1.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range1 = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes1, columns1, options1);
-        auto list1 = pgmBuilder.Member(range1, "List");
-
+        options1.FromColumns = rowFrom1; 
+        options1.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range1 = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes1, columns1, options1); 
+        auto list1 = pgmBuilder.Member(range1, "List"); 
+ 
         TVector<TSelectColumn> columns2;
-        columns2.emplace_back("ID", (ui32)Schema2::Table2::ID::ColumnId, (ui32)Schema2::Table2::ID::ColumnType);
-        columns2.emplace_back("Value", (ui32)Schema2::Table2::Value::ColumnId, (ui32)Schema2::Table2::Value::ColumnType);
-        auto options2 = pgmBuilder.GetDefaultTableRangeOptions();
+        columns2.emplace_back("ID", (ui32)Schema2::Table2::ID::ColumnId, (ui32)Schema2::Table2::ID::ColumnType); 
+        columns2.emplace_back("Value", (ui32)Schema2::Table2::Value::ColumnId, (ui32)Schema2::Table2::Value::ColumnType); 
+        auto options2 = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes2(1);
         keyTypes2[0] = (ui32)NUdf::TDataType<ui64>::Id;
         TRuntimeNode::TList rowFrom2(1);
         rowFrom2[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui64>::Id);
-        options2.FromColumns = rowFrom2;
-        options2.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range2 = pgmBuilder.SelectRange(TTableId(OwnerId, Table2Id), keyTypes2, columns2, options2);
-        auto list2 = pgmBuilder.Member(range2, "List");
-
-        auto mapped = pgmBuilder.Map(list2, [&pgmBuilder](TRuntimeNode item2) {
-            return pgmBuilder.Member(item2, "Value");
-        });
-
-        auto flatmapped = pgmBuilder.FlatMap(list1, [&pgmBuilder, &mapped](TRuntimeNode item1) {
-            return pgmBuilder.AsList({
-                pgmBuilder.NewTuple({pgmBuilder.ToString(pgmBuilder.Member(item1, "ID")), mapped}),
-                pgmBuilder.NewTuple({pgmBuilder.ToString(pgmBuilder.Member(item1, "Value")), mapped})
-            });
-        });
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", flatmapped)));
-
-        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            if (shard == Shard1) {
-                UNIT_ASSERT(!program.Contains("Map"));
-                UNIT_ASSERT(!program.Contains("FlatMap"));
-            } else {
-                UNIT_ASSERT(program.Contains("Map"));
-                UNIT_ASSERT(!program.Contains("FlatMap"));
-            }
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[
+        options2.FromColumns = rowFrom2; 
+        options2.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range2 = pgmBuilder.SelectRange(TTableId(OwnerId, Table2Id), keyTypes2, columns2, options2); 
+        auto list2 = pgmBuilder.Member(range2, "List"); 
+ 
+        auto mapped = pgmBuilder.Map(list2, [&pgmBuilder](TRuntimeNode item2) { 
+            return pgmBuilder.Member(item2, "Value"); 
+        }); 
+ 
+        auto flatmapped = pgmBuilder.FlatMap(list1, [&pgmBuilder, &mapped](TRuntimeNode item1) { 
+            return pgmBuilder.AsList({ 
+                pgmBuilder.NewTuple({pgmBuilder.ToString(pgmBuilder.Member(item1, "ID")), mapped}), 
+                pgmBuilder.NewTuple({pgmBuilder.ToString(pgmBuilder.Member(item1, "Value")), mapped}) 
+            }); 
+        }); 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", flatmapped))); 
+ 
+        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) { 
+            Y_UNUSED(shard); 
+ 
+            if (shard == Shard1) { 
+                UNIT_ASSERT(!program.Contains("Map")); 
+                UNIT_ASSERT(!program.Contains("FlatMap")); 
+            } else { 
+                UNIT_ASSERT(program.Contains("Map")); 
+                UNIT_ASSERT(!program.Contains("FlatMap")); 
+            } 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[ 
             [["1"];[["20"];["40"]]];
             [["Ok"];[["20"];["40"]]];
             [["3"];[["20"];["40"]]];
             [["Bad"];[["20"];["40"]]]
-        ]]])___", res);
-    }
-
+        ]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestCombineByKeyPushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
-        auto preMap = pgmBuilder.FlatMap(list, [&](TRuntimeNode item) {
-            return pgmBuilder.NewOptional(item);
-        });
-
-        auto dict = pgmBuilder.ToHashedDict(preMap, true, [&](TRuntimeNode item) {
-            return pgmBuilder.Member(item, "Value");
-        }, [&](TRuntimeNode item) {
-            return item;
-        });
-
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
+        auto preMap = pgmBuilder.FlatMap(list, [&](TRuntimeNode item) { 
+            return pgmBuilder.NewOptional(item); 
+        }); 
+ 
+        auto dict = pgmBuilder.ToHashedDict(preMap, true, [&](TRuntimeNode item) { 
+            return pgmBuilder.Member(item, "Value"); 
+        }, [&](TRuntimeNode item) { 
+            return item; 
+        }); 
+ 
         auto values = pgmBuilder.DictItems(dict);
-
-        auto agg = pgmBuilder.FlatMap(values, [&](TRuntimeNode item) {
-            auto key = pgmBuilder.Nth(item, 0);
-            auto payloadList = pgmBuilder.Nth(item, 1);
-            auto fold1 = pgmBuilder.Fold1(payloadList, [&](TRuntimeNode item2) {
+ 
+        auto agg = pgmBuilder.FlatMap(values, [&](TRuntimeNode item) { 
+            auto key = pgmBuilder.Nth(item, 0); 
+            auto payloadList = pgmBuilder.Nth(item, 1); 
+            auto fold1 = pgmBuilder.Fold1(payloadList, [&](TRuntimeNode item2) { 
                 std::vector<std::pair<std::string_view, TRuntimeNode>> fields {
-                    {"Key", key},
-                    {"Sum", pgmBuilder.Member(item2, "ID")}
-                };
-                return pgmBuilder.NewOptional(pgmBuilder.NewStruct(fields));
-            }, [&](TRuntimeNode item2, TRuntimeNode state) {
+                    {"Key", key}, 
+                    {"Sum", pgmBuilder.Member(item2, "ID")} 
+                }; 
+                return pgmBuilder.NewOptional(pgmBuilder.NewStruct(fields)); 
+            }, [&](TRuntimeNode item2, TRuntimeNode state) { 
                 std::vector<std::pair<std::string_view, TRuntimeNode>> fields {
-                    {"Key", pgmBuilder.Member(state, "Key")},
-                    {"Sum", pgmBuilder.AggrAdd(pgmBuilder.Member(state, "Sum"), pgmBuilder.Member(item2, "ID"))}
-                };
-                return pgmBuilder.NewOptional(pgmBuilder.NewStruct(fields));
-            });
-
-            auto res = pgmBuilder.FlatMap(fold1, [&](TRuntimeNode state) {
-                return state;
-            });
-
-            return res;
-        });
-
-        auto merge = pgmBuilder.CombineByKeyMerge(agg);
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", merge)));
-
+                    {"Key", pgmBuilder.Member(state, "Key")}, 
+                    {"Sum", pgmBuilder.AggrAdd(pgmBuilder.Member(state, "Sum"), pgmBuilder.Member(item2, "ID"))} 
+                }; 
+                return pgmBuilder.NewOptional(pgmBuilder.NewStruct(fields)); 
+            }); 
+ 
+            auto res = pgmBuilder.FlatMap(fold1, [&](TRuntimeNode state) { 
+                return state; 
+            }); 
+ 
+            return res; 
+        }); 
+ 
+        auto merge = pgmBuilder.CombineByKeyMerge(agg); 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", merge))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(program.Contains("FlatMap"));
-            UNIT_ASSERT(program.Contains("ToHashedDict"));
-            UNIT_ASSERT(program.Contains("DictItems"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(program.Contains("FlatMap")); 
+            UNIT_ASSERT(program.Contains("ToHashedDict")); 
+            UNIT_ASSERT(program.Contains("DictItems")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[ 
             [["Value1"];["6"]];
             [["Value2"];["3"]];
             [["Value2"];["8"]];
             [["Value3"];["4"]]
-        ]]])___", res);
-    }
-
+        ]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestCombineByKeyNoPushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
-        auto dict = pgmBuilder.ToHashedDict(list, true, [&](TRuntimeNode item) {
-            return pgmBuilder.Member(item, "Value");
-        }, [&](TRuntimeNode item) {
-            return item;
-        });
-
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
+        auto dict = pgmBuilder.ToHashedDict(list, true, [&](TRuntimeNode item) { 
+            return pgmBuilder.Member(item, "Value"); 
+        }, [&](TRuntimeNode item) { 
+            return item; 
+        }); 
+ 
         auto values = pgmBuilder.DictItems(dict);
-
-        auto agg = pgmBuilder.FlatMap(values, [&](TRuntimeNode item) {
-            auto key = pgmBuilder.Nth(item, 0);
-            auto payloadList = pgmBuilder.Nth(item, 1);
-            auto fold1 = pgmBuilder.Fold1(payloadList, [&](TRuntimeNode item2) {
+ 
+        auto agg = pgmBuilder.FlatMap(values, [&](TRuntimeNode item) { 
+            auto key = pgmBuilder.Nth(item, 0); 
+            auto payloadList = pgmBuilder.Nth(item, 1); 
+            auto fold1 = pgmBuilder.Fold1(payloadList, [&](TRuntimeNode item2) { 
                 std::vector<std::pair<std::string_view, TRuntimeNode>> fields {
-                    {"Key", key},
-                    {"Sum", pgmBuilder.Member(item2, "ID")}
-                };
-                return pgmBuilder.NewOptional(pgmBuilder.NewStruct(fields));
-            }, [&](TRuntimeNode item2, TRuntimeNode state) {
+                    {"Key", key}, 
+                    {"Sum", pgmBuilder.Member(item2, "ID")} 
+                }; 
+                return pgmBuilder.NewOptional(pgmBuilder.NewStruct(fields)); 
+            }, [&](TRuntimeNode item2, TRuntimeNode state) { 
                 std::vector<std::pair<std::string_view, TRuntimeNode>> fields {
-                    {"Key", pgmBuilder.Member(state, "Key")},
-                    {"Sum", pgmBuilder.AggrAdd(pgmBuilder.Member(state, "Sum"), pgmBuilder.Member(item2, "ID"))}
-                };
-                return pgmBuilder.NewOptional(pgmBuilder.NewStruct(fields));
-            });
-
-            auto res = pgmBuilder.FlatMap(fold1, [&](TRuntimeNode state) {
-                return state;
-            });
-
-            return res;
-        });
-
-        auto merge = pgmBuilder.CombineByKeyMerge(agg);
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", merge)));
-
+                    {"Key", pgmBuilder.Member(state, "Key")}, 
+                    {"Sum", pgmBuilder.AggrAdd(pgmBuilder.Member(state, "Sum"), pgmBuilder.Member(item2, "ID"))} 
+                }; 
+                return pgmBuilder.NewOptional(pgmBuilder.NewStruct(fields)); 
+            }); 
+ 
+            auto res = pgmBuilder.FlatMap(fold1, [&](TRuntimeNode state) { 
+                return state; 
+            }); 
+ 
+            return res; 
+        }); 
+ 
+        auto merge = pgmBuilder.CombineByKeyMerge(agg); 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", merge))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(!program.Contains("FlatMap"));
-            UNIT_ASSERT(!program.Contains("ToHashedDict"));
-            UNIT_ASSERT(!program.Contains("DictItems"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(!program.Contains("FlatMap")); 
+            UNIT_ASSERT(!program.Contains("ToHashedDict")); 
+            UNIT_ASSERT(!program.Contains("DictItems")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[ 
             [["Value1"];["6"]];
             [["Value2"];["11"]];
             [["Value3"];["4"]]
-        ]]])___", res);
-    }
-
+        ]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestTakePushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
         const TString filterValue = "Value1";
-        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) {
+        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) { 
             return pgmBuilder.AggrNotEquals(
                 pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
                 pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue));
-        });
-
+        }); 
+ 
         auto take = pgmBuilder.Take(filtered, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2));
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take)));
-
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(program.Contains("Filter"));
-            UNIT_ASSERT(program.Contains("Take"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(program.Contains("Filter")); 
+            UNIT_ASSERT(program.Contains("Take")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[ 
             [["3"];["Value2"]];
             [["2"];["Value2"]]
-        ]]])___", res);
-    }
-
+        ]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestNoOrderedTakePushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
         auto take = pgmBuilder.Take(list, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(4));
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take)));
-
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(!program.Contains("Take"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(!program.Contains("Take")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[ 
             [["1"];["Value1"]];
             [["2"];["Value2"]];
             [["3"];["Value1"]];
             [["4"];["Value2"]]
-        ]]])___", res);
-    }
-
+        ]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestLengthPushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
         const TString filterValue = "Value2";
-        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) {
+        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) { 
             return pgmBuilder.AggrNotEquals(
                 pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
                 pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue));
-        });
-
-        auto length = pgmBuilder.Length(filtered);
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", length)));
-
+        }); 
+ 
+        auto length = pgmBuilder.Length(filtered); 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", length))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(program.Contains("Filter"));
-            UNIT_ASSERT(program.Contains("Length"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([["3"]])___", res);
-    }
-
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(program.Contains("Filter")); 
+            UNIT_ASSERT(program.Contains("Length")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([["3"]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestNoAggregatedPushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
-        auto mapped = pgmBuilder.Map(list, [&pgmBuilder](TRuntimeNode item) {
-            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add(
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
+        auto mapped = pgmBuilder.Map(list, [&pgmBuilder](TRuntimeNode item) { 
+            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add( 
                 pgmBuilder.Member(item, "ID"), pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10)));
-        });
-
+        }); 
+ 
         auto take = pgmBuilder.Take(mapped, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2));
-
+ 
         const TString filterValue = "Value2";
-        auto filtered = pgmBuilder.Filter(take, [&pgmBuilder, &filterValue](TRuntimeNode item) {
+        auto filtered = pgmBuilder.Filter(take, [&pgmBuilder, &filterValue](TRuntimeNode item) { 
             return pgmBuilder.AggrNotEquals(
                 pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
                 pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue));
-        });
-        auto length = pgmBuilder.Length(filtered);
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", length)));
-
+        }); 
+        auto length = pgmBuilder.Length(filtered); 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", length))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(program.Contains("Map"));
-            UNIT_ASSERT(program.Contains("Take"));
-            UNIT_ASSERT(!program.Contains("Filter"));
-            UNIT_ASSERT(!program.Contains("Length"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([["1"]])___", res);
-    }
-
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(program.Contains("Map")); 
+            UNIT_ASSERT(program.Contains("Take")); 
+            UNIT_ASSERT(!program.Contains("Filter")); 
+            UNIT_ASSERT(!program.Contains("Length")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([["1"]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestTopSortPushdownPk) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value4"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value6"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value4")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value6")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
-        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
-        const TString filterValue = "Value1";
-        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) {
+        options.FromColumns = rowFrom; 
+        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
+        const TString filterValue = "Value1"; 
+        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) { 
             return pgmBuilder.AggrNotEquals(
                 pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
                 pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue));
-        });
-
-        auto partialTake = pgmBuilder.PartialTake(filtered, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2));
-        auto sort = pgmBuilder.Sort(partialTake, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(true),
-            [&pgmBuilder] (TRuntimeNode item) {
-                return pgmBuilder.Member(item, "ID");
-            });
-
-        auto take = pgmBuilder.Take(sort, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2));
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take)));
-
-        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(program.Contains("Filter"));
-            UNIT_ASSERT(program.Contains("Take"));
-            UNIT_ASSERT(!program.Contains("Sort"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[[["2"];["Value2"]];[["3"];["Value3"]]]]])___", res);
-    }
-
+        }); 
+ 
+        auto partialTake = pgmBuilder.PartialTake(filtered, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2)); 
+        auto sort = pgmBuilder.Sort(partialTake, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(true), 
+            [&pgmBuilder] (TRuntimeNode item) { 
+                return pgmBuilder.Member(item, "ID"); 
+            }); 
+ 
+        auto take = pgmBuilder.Take(sort, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2)); 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take))); 
+ 
+        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) { 
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(program.Contains("Filter")); 
+            UNIT_ASSERT(program.Contains("Take")); 
+            UNIT_ASSERT(!program.Contains("Sort")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[[["2"];["Value2"]];[["3"];["Value3"]]]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestTopSortPushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value4"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value6"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value4")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value6")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
         TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
-        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
-        const TString filterValue = "Value6";
-        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) {
+        options.FromColumns = rowFrom; 
+        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
+        const TString filterValue = "Value6"; 
+        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) { 
             return pgmBuilder.AggrNotEquals(
                 pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
                 pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue));
-        });
-
-        auto partialSort = pgmBuilder.PartialSort(filtered, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false),
-            [&pgmBuilder] (TRuntimeNode item) {
-                return pgmBuilder.Member(item, "Value");
-            });
-        auto partialTake = pgmBuilder.PartialTake(partialSort, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2));
-        auto sort = pgmBuilder.Sort(partialTake, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false),
-            [&pgmBuilder] (TRuntimeNode item) {
-                return pgmBuilder.Member(item, "Value");
-            });
-
-        auto take = pgmBuilder.Take(sort, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2));
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take)));
-
-        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(program.Contains("Filter"));
-            UNIT_ASSERT(program.Contains("Take"));
-            UNIT_ASSERT(program.Contains("Sort"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[[["5"];["Value5"]];[["4"];["Value4"]]]]])___", res);
-    }
-
-    Y_UNIT_TEST(TestTopSortNonImmediatePushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value4"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value6"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
-        TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
-        TVector<ui32> keyTypes(1);
-        keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
+        }); 
+ 
+        auto partialSort = pgmBuilder.PartialSort(filtered, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false), 
+            [&pgmBuilder] (TRuntimeNode item) { 
+                return pgmBuilder.Member(item, "Value"); 
+            }); 
+        auto partialTake = pgmBuilder.PartialTake(partialSort, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2)); 
+        auto sort = pgmBuilder.Sort(partialTake, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false), 
+            [&pgmBuilder] (TRuntimeNode item) { 
+                return pgmBuilder.Member(item, "Value"); 
+            }); 
+ 
+        auto take = pgmBuilder.Take(sort, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2)); 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take))); 
+ 
+        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) { 
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(program.Contains("Filter")); 
+            UNIT_ASSERT(program.Contains("Take")); 
+            UNIT_ASSERT(program.Contains("Sort")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[[["5"];["Value5"]];[["4"];["Value4"]]]]])___", res); 
+    } 
+ 
+    Y_UNIT_TEST(TestTopSortNonImmediatePushdown) { 
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value4")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value6")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
+        TVector<TSelectColumn> columns; 
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
+        TVector<ui32> keyTypes(1); 
+        keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id; 
         TRuntimeNode::TList rowFrom(1);
-        rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
-        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
-        const TString filterValue = "Value6";
-        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) {
-            return pgmBuilder.AggrNotEquals(
-                pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
-                pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue));
-        });
-
-        auto partialSort = pgmBuilder.PartialSort(filtered, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false),
-            [&pgmBuilder] (TRuntimeNode item) {
-                return pgmBuilder.Member(item, "Value");
-            });
-
-        auto takeCount = pgmBuilder.Add(pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(1),
-            pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(1));
-
-        auto partialTake = pgmBuilder.PartialTake(partialSort, takeCount);
-        auto sort = pgmBuilder.Sort(partialTake, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false),
-            [&pgmBuilder] (TRuntimeNode item) {
-                return pgmBuilder.Member(item, "Value");
-            });
-
-        auto take = pgmBuilder.Take(sort, takeCount);
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take)));
-
-        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(program.Contains("Filter"));
-            UNIT_ASSERT(program.Contains("Take"));
-            UNIT_ASSERT(program.Contains("Sort"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[[["5"];["Value5"]];[["4"];["Value4"]]]]])___", res);
-    }
-
-    Y_UNIT_TEST(TestNoPartialSortPushdown) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(2))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(4))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value4"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(6))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value6"));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
-        TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType);
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
-        TVector<ui32> keyTypes(1);
-        keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
+        rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id); 
+        options.FromColumns = rowFrom; 
+        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
+        const TString filterValue = "Value6"; 
+        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) { 
+            return pgmBuilder.AggrNotEquals( 
+                pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0), 
+                pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue)); 
+        }); 
+ 
+        auto partialSort = pgmBuilder.PartialSort(filtered, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false), 
+            [&pgmBuilder] (TRuntimeNode item) { 
+                return pgmBuilder.Member(item, "Value"); 
+            }); 
+ 
+        auto takeCount = pgmBuilder.Add(pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(1), 
+            pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(1)); 
+ 
+        auto partialTake = pgmBuilder.PartialTake(partialSort, takeCount); 
+        auto sort = pgmBuilder.Sort(partialTake, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false), 
+            [&pgmBuilder] (TRuntimeNode item) { 
+                return pgmBuilder.Member(item, "Value"); 
+            }); 
+ 
+        auto take = pgmBuilder.Take(sort, takeCount); 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take))); 
+ 
+        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) { 
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(program.Contains("Filter")); 
+            UNIT_ASSERT(program.Contains("Take")); 
+            UNIT_ASSERT(program.Contains("Sort")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[[["5"];["Value5"]];[["4"];["Value4"]]]]])___", res); 
+    } 
+ 
+    Y_UNIT_TEST(TestNoPartialSortPushdown) { 
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(2)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value2")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(4)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value4")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(6)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value6")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
+        TVector<TSelectColumn> columns; 
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+        columns.emplace_back("Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType); 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
+        TVector<ui32> keyTypes(1); 
+        keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id; 
         TRuntimeNode::TList rowFrom(1);
-        rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
-        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options);
-        auto list = pgmBuilder.Member(range, "List");
-
-        const TString filterValue = "Value6";
-        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) {
-            return pgmBuilder.AggrNotEquals(
-                pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
-                pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue));
-        });
-
-        auto partialSort = pgmBuilder.PartialSort(filtered, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false),
-            [&pgmBuilder] (TRuntimeNode item) {
-                return pgmBuilder.Member(item, "Value");
-            });
-
-        const TString filter2Value = "Value5";
-        auto filtered2 = pgmBuilder.Filter(partialSort, [&pgmBuilder, &filter2Value](TRuntimeNode item) {
-            return pgmBuilder.AggrNotEquals(
-                pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
-                pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filter2Value));
-        });
-
-        auto take = pgmBuilder.Take(filtered2, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2));
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take)));
-
-        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-
-            UNIT_ASSERT(program.Contains("Filter"));
-            UNIT_ASSERT(!program.Contains("Take"));
-            UNIT_ASSERT(!program.Contains("Sort"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([[[[["4"];["Value4"]];[["3"];["Value3"]]]]])___", res);
-    }
-
+        rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id); 
+        options.FromColumns = rowFrom; 
+        options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, columns, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+ 
+        const TString filterValue = "Value6"; 
+        auto filtered = pgmBuilder.Filter(list, [&pgmBuilder, &filterValue](TRuntimeNode item) { 
+            return pgmBuilder.AggrNotEquals( 
+                pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0), 
+                pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue)); 
+        }); 
+ 
+        auto partialSort = pgmBuilder.PartialSort(filtered, pgmBuilder.TProgramBuilder::NewDataLiteral<bool>(false), 
+            [&pgmBuilder] (TRuntimeNode item) { 
+                return pgmBuilder.Member(item, "Value"); 
+            }); 
+ 
+        const TString filter2Value = "Value5"; 
+        auto filtered2 = pgmBuilder.Filter(partialSort, [&pgmBuilder, &filter2Value](TRuntimeNode item) { 
+            return pgmBuilder.AggrNotEquals( 
+                pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0), 
+                pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filter2Value)); 
+        }); 
+ 
+        auto take = pgmBuilder.Take(filtered2, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2)); 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", take))); 
+ 
+        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) { 
+            Y_UNUSED(shard); 
+ 
+            UNIT_ASSERT(program.Contains("Filter")); 
+            UNIT_ASSERT(!program.Contains("Take")); 
+            UNIT_ASSERT(!program.Contains("Sort")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([[[[["4"];["Value4"]];[["3"];["Value3"]]]]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestSelectRangeNoColumns) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(ui64(1))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(3))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad"));
-            db.Table<Schema1::Table1>()
-                .Key(ui64(5))
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
-        auto options = pgmBuilder.GetDefaultTableRangeOptions();
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(1)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(3)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Bad")); 
+            db.Table<Schema1::Table1>() 
+                .Key(ui64(5)) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Ok")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
+        auto options = pgmBuilder.GetDefaultTableRangeOptions(); 
         TVector<ui32> keyTypes(1);
         keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
         TRuntimeNode::TList rowFrom(1);
         rowFrom[0] = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id);
-        options.FromColumns = rowFrom;
+        options.FromColumns = rowFrom; 
         options.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, {}, options);
-        auto list = pgmBuilder.Member(range, "List");
-        auto length = pgmBuilder.Length(list);
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", length)));
-
+        auto range = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), keyTypes, {}, options); 
+        auto list = pgmBuilder.Member(range, "List"); 
+        auto length = pgmBuilder.Length(list); 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("Result", length))); 
+ 
         driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            Y_UNUSED(shard);
-            UNIT_ASSERT(!program.Contains("Map"));
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([["3"]])___", res);
-    }
-
+            Y_UNUSED(shard); 
+            UNIT_ASSERT(!program.Contains("Map")); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &SingleShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([["3"]])___", res); 
+    } 
+ 
     Y_UNIT_TEST(TestInternalResult) {
-        TDriver driver;
-        auto& pgmBuilder = driver.PgmBuilder;
-        auto value = pgmBuilder.TProgramBuilder::TProgramBuilder::NewDataLiteral<ui32>(42);
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("__cantuse", value)));
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &EmptyShardResolver), IEngineFlat::EStatus::Error);
-
-        Cout << res.DebugString() << Endl;
-    }
-
+        TDriver driver; 
+        auto& pgmBuilder = driver.PgmBuilder; 
+        auto value = pgmBuilder.TProgramBuilder::TProgramBuilder::NewDataLiteral<ui32>(42); 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(pgmBuilder.SetResult("__cantuse", value))); 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &EmptyShardResolver), IEngineFlat::EStatus::Error); 
+ 
+        Cout << res.DebugString() << Endl; 
+    } 
+ 
     Y_UNIT_TEST(TestIndependentSelects) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema2>(Shard2);
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard1);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]);
-
-            db.Table<Schema1::Table1>()
-                .Key(1)
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1"));
-            db.Table<Schema1::Table1>()
-                .Key(3)
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3"));
-            db.Table<Schema1::Table1>()
-                .Key(5)
-                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5"));
-
-            driver.ShardDbState.CommitTransaction(Shard1);
-        }
-
-        {
-            driver.ShardDbState.BeginTransaction(Shard2);
-            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]);
-
-            db.Table<Schema2::Table2>()
-                .Key(2)
-                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(20));
-            db.Table<Schema2::Table2>()
-                .Key(4)
-                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(40));
-            db.Table<Schema2::Table2>()
-                .Key(6)
-                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(50));
-
-            driver.ShardDbState.CommitTransaction(Shard2);
-        }
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
-        TVector<TSelectColumn> columns1 {
-            {"ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType},
-            {"Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType}
-        };
-
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema2>(Shard2); 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard1); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard1]); 
+ 
+            db.Table<Schema1::Table1>() 
+                .Key(1) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value1")); 
+            db.Table<Schema1::Table1>() 
+                .Key(3) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value3")); 
+            db.Table<Schema1::Table1>() 
+                .Key(5) 
+                .Update(NIceDb::TUpdate<Schema1::Table1::Value>("Value5")); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard1); 
+        } 
+ 
+        { 
+            driver.ShardDbState.BeginTransaction(Shard2); 
+            NIceDb::TNiceDb db(*driver.ShardDbState.Dbs[Shard2]); 
+ 
+            db.Table<Schema2::Table2>() 
+                .Key(2) 
+                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(20)); 
+            db.Table<Schema2::Table2>() 
+                .Key(4) 
+                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(40)); 
+            db.Table<Schema2::Table2>() 
+                .Key(6) 
+                .Update(NIceDb::TUpdate<Schema2::Table2::Value>(50)); 
+ 
+            driver.ShardDbState.CommitTransaction(Shard2); 
+        } 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
+        TVector<TSelectColumn> columns1 { 
+            {"ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType}, 
+            {"Value", (ui32)Schema1::Table1::Value::ColumnId, (ui32)Schema1::Table1::Value::ColumnType} 
+        }; 
+ 
         TRuntimeNode::TList fromColumns1{pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui32>::Id)};
-        auto options1 = pgmBuilder.GetDefaultTableRangeOptions();
-        options1.FromColumns = fromColumns1;
-        options1.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range1 = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), {(ui32)NUdf::TDataType<ui32>::Id},
-            columns1, options1);
-        auto list1 = pgmBuilder.Member(range1, "List");
-
-        const TString filterValue = "Value6";
-        auto filtered1 = pgmBuilder.Filter(list1, [&pgmBuilder, &filterValue](TRuntimeNode item) {
+        auto options1 = pgmBuilder.GetDefaultTableRangeOptions(); 
+        options1.FromColumns = fromColumns1; 
+        options1.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range1 = pgmBuilder.SelectRange(TTableId(OwnerId, Table1Id), {(ui32)NUdf::TDataType<ui32>::Id}, 
+            columns1, options1); 
+        auto list1 = pgmBuilder.Member(range1, "List"); 
+ 
+        const TString filterValue = "Value6"; 
+        auto filtered1 = pgmBuilder.Filter(list1, [&pgmBuilder, &filterValue](TRuntimeNode item) { 
             return pgmBuilder.AggrNotEquals(
-                pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"),
-                pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0),
-                pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue));
-        });
-
-        auto take1 = pgmBuilder.Take(filtered1, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2));
-
-        TVector<TSelectColumn> columns2 {
-            {"ID", (ui32)Schema2::Table2::ID::ColumnId, (ui32)Schema2::Table2::ID::ColumnType},
-            {"Value", (ui32)Schema2::Table2::Value::ColumnId, (ui32)Schema2::Table2::Value::ColumnType}
-        };
-
+                pgmBuilder.Unwrap(pgmBuilder.Member(item, "Value"), 
+                pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>(""), "", 0, 0), 
+                pgmBuilder.TProgramBuilder::NewDataLiteral<NUdf::EDataSlot::Utf8>(filterValue)); 
+        }); 
+ 
+        auto take1 = pgmBuilder.Take(filtered1, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2)); 
+ 
+        TVector<TSelectColumn> columns2 { 
+            {"ID", (ui32)Schema2::Table2::ID::ColumnId, (ui32)Schema2::Table2::ID::ColumnType}, 
+            {"Value", (ui32)Schema2::Table2::Value::ColumnId, (ui32)Schema2::Table2::Value::ColumnType} 
+        }; 
+ 
         TRuntimeNode::TList fromColumns2{pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<ui64>::Id)};
-        auto options2 = pgmBuilder.GetDefaultTableRangeOptions();
-        options2.FromColumns = fromColumns2;
-        options2.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue);
-        auto range2 = pgmBuilder.SelectRange(TTableId(OwnerId, Table2Id), {(ui32)NUdf::TDataType<ui64>::Id},
-            columns2, options2);
-        auto list2 = pgmBuilder.Member(range2, "List");
-
-        auto mapped2 = pgmBuilder.Map(list2, [&pgmBuilder](TRuntimeNode item) {
-            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add(
-                pgmBuilder.Member(item, "ID"), pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10)));
-        });
-
-        auto take2 = pgmBuilder.Take(mapped2, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2));
-
-        auto pgm = pgmBuilder.Build(pgmBuilder.AsList(
-            pgmBuilder.SetResult("Result", pgmBuilder.NewTuple({take1, take2}))
-        ));
-
-        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) {
-            if (shard == Shard1) {
-                UNIT_ASSERT(program.Contains("Filter"));
-            }
-        };
-
-        driver.ReadSetsInspector = [] (const TDriver::TOutgoingReadsets& outReadsets,
-            const TDriver::TIncomingReadsets& inReadsets)
-        {
-            UNIT_ASSERT(outReadsets.empty());
-            UNIT_ASSERT(inReadsets.empty());
-        };
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete);
-
-        NKqp::CompareYson(R"___([
+        auto options2 = pgmBuilder.GetDefaultTableRangeOptions(); 
+        options2.FromColumns = fromColumns2; 
+        options2.Flags = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(TReadRangeOptions::TFlags::ExcludeTermValue); 
+        auto range2 = pgmBuilder.SelectRange(TTableId(OwnerId, Table2Id), {(ui32)NUdf::TDataType<ui64>::Id}, 
+            columns2, options2); 
+        auto list2 = pgmBuilder.Member(range2, "List"); 
+ 
+        auto mapped2 = pgmBuilder.Map(list2, [&pgmBuilder](TRuntimeNode item) { 
+            return pgmBuilder.AddMember(item, "MappedID", pgmBuilder.Add( 
+                pgmBuilder.Member(item, "ID"), pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10))); 
+        }); 
+ 
+        auto take2 = pgmBuilder.Take(mapped2, pgmBuilder.TProgramBuilder::NewDataLiteral<ui64>(2)); 
+ 
+        auto pgm = pgmBuilder.Build(pgmBuilder.AsList( 
+            pgmBuilder.SetResult("Result", pgmBuilder.NewTuple({take1, take2})) 
+        )); 
+ 
+        driver.ShardProgramInspector = [] (ui64 shard, const TString& program) { 
+            if (shard == Shard1) { 
+                UNIT_ASSERT(program.Contains("Filter")); 
+            } 
+        }; 
+ 
+        driver.ReadSetsInspector = [] (const TDriver::TOutgoingReadsets& outReadsets, 
+            const TDriver::TIncomingReadsets& inReadsets) 
+        { 
+            UNIT_ASSERT(outReadsets.empty()); 
+            UNIT_ASSERT(inReadsets.empty()); 
+        }; 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver), IEngineFlat::EStatus::Complete); 
+ 
+        NKqp::CompareYson(R"___([ 
             [[[[["1"];["Value1"]];[["3"];["Value3"]]];
             [[["2"];["12"];["20"]];[["4"];["14"];["40"]]]]]
-        ])___", res);
-    }
-
-    Y_UNIT_TEST(TestMultiRSPerDestination) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema1>(Shard2);
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
-        TVector<ui32> keyTypes(1);
-        keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
-        TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-
+        ])___", res); 
+    } 
+ 
+    Y_UNIT_TEST(TestMultiRSPerDestination) { 
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema1>(Shard2); 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
+        TVector<ui32> keyTypes(1); 
+        keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id; 
+        TVector<TSelectColumn> columns; 
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+ 
         TRuntimeNode::TList row1(1);
-        row1[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(1);
-        auto value1 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row1);
-
+        row1[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(1); 
+        auto value1 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row1); 
+ 
         TRuntimeNode::TList row2(1);
-        row2[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(3);
-        auto value2 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row2);
-
+        row2[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(3); 
+        auto value2 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row2); 
+ 
         TRuntimeNode::TList row3(1);
-        row3[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(5);
-        auto value3 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row3);
-
-        auto list = pgmBuilder.AsList({value1, value2, value3});
-
-        auto mapped = pgmBuilder.Map(list, [&pgmBuilder, &keyTypes](TRuntimeNode item) {
-            auto update = pgmBuilder.GetUpdateRowBuilder();
-
+        row3[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(5); 
+        auto value3 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row3); 
+ 
+        auto list = pgmBuilder.AsList({value1, value2, value3}); 
+ 
+        auto mapped = pgmBuilder.Map(list, [&pgmBuilder, &keyTypes](TRuntimeNode item) { 
+            auto update = pgmBuilder.GetUpdateRowBuilder(); 
+ 
             TRuntimeNode::TList row(1);
-            row[0] = pgmBuilder.Add(
-                pgmBuilder.Member(item, "ID"),
-                pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10));
-
-            return pgmBuilder.UpdateRow(TTableId(OwnerId, Table1Id), keyTypes, row, update);
-        });
-
-        auto pgm = pgmBuilder.Build(mapped);
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver,
-            IEngineFlat::TShardLimits(2, 2)), IEngineFlat::EStatus::Complete);
-
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver,
-            IEngineFlat::TShardLimits(2, 1)), IEngineFlat::EStatus::Error);
-        Cerr << res.DebugString() << Endl;
-    }
-
-    Y_UNIT_TEST(TestCrossTableRs) {
-        TDriver driver;
-        driver.ShardDbState.AddShard<Schema1>(Shard1);
-        driver.ShardDbState.AddShard<Schema2>(Shard2);
-
-        auto& pgmBuilder = driver.PgmBuilder;
-
-        TVector<ui32> keyTypes(1);
-        keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id;
-        TVector<TSelectColumn> columns;
-        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType);
-
-        TVector<ui32> key2Types(1);
-        key2Types[0] = (ui32)NUdf::TDataType<ui64>::Id;
-
+            row[0] = pgmBuilder.Add( 
+                pgmBuilder.Member(item, "ID"), 
+                pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10)); 
+ 
+            return pgmBuilder.UpdateRow(TTableId(OwnerId, Table1Id), keyTypes, row, update); 
+        }); 
+ 
+        auto pgm = pgmBuilder.Build(mapped); 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver, 
+            IEngineFlat::TShardLimits(2, 2)), IEngineFlat::EStatus::Complete); 
+ 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &DoubleShardResolver, 
+            IEngineFlat::TShardLimits(2, 1)), IEngineFlat::EStatus::Error); 
+        Cerr << res.DebugString() << Endl; 
+    } 
+ 
+    Y_UNIT_TEST(TestCrossTableRs) { 
+        TDriver driver; 
+        driver.ShardDbState.AddShard<Schema1>(Shard1); 
+        driver.ShardDbState.AddShard<Schema2>(Shard2); 
+ 
+        auto& pgmBuilder = driver.PgmBuilder; 
+ 
+        TVector<ui32> keyTypes(1); 
+        keyTypes[0] = (ui32)NUdf::TDataType<ui32>::Id; 
+        TVector<TSelectColumn> columns; 
+        columns.emplace_back("ID", (ui32)Schema1::Table1::ID::ColumnId, (ui32)Schema1::Table1::ID::ColumnType); 
+ 
+        TVector<ui32> key2Types(1); 
+        key2Types[0] = (ui32)NUdf::TDataType<ui64>::Id; 
+ 
         TRuntimeNode::TList row1(1);
-        row1[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(1);
-        auto value1 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row1);
-
+        row1[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(1); 
+        auto value1 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row1); 
+ 
         TRuntimeNode::TList row2(1);
-        row2[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(3);
-        auto value2 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row2);
-
+        row2[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(3); 
+        auto value2 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row2); 
+ 
         TRuntimeNode::TList row3(1);
-        row3[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(5);
-        auto value3 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row3);
-
-        auto list = pgmBuilder.AsList({value1, value2, value3});
-
-        auto mapped = pgmBuilder.Map(list, [&pgmBuilder, &key2Types](TRuntimeNode item) {
-            auto update = pgmBuilder.GetUpdateRowBuilder();
-
+        row3[0] = pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(5); 
+        auto value3 = pgmBuilder.SelectRow(TTableId(OwnerId, Table1Id), keyTypes, columns, row3); 
+ 
+        auto list = pgmBuilder.AsList({value1, value2, value3}); 
+ 
+        auto mapped = pgmBuilder.Map(list, [&pgmBuilder, &key2Types](TRuntimeNode item) { 
+            auto update = pgmBuilder.GetUpdateRowBuilder(); 
+ 
             TRuntimeNode::TList row(1);
-            row[0] = pgmBuilder.Add(
+            row[0] = pgmBuilder.Add( 
                 pgmBuilder.Convert(pgmBuilder.Member(item, "ID"), pgmBuilder.NewOptionalType(pgmBuilder.NewDataType(NUdf::TDataType<ui64>::Id))),
-                pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10));
-
-            return pgmBuilder.UpdateRow(TTableId(OwnerId, Table2Id), key2Types, row, update);
-        });
-
-        auto pgm = pgmBuilder.Build(mapped);
-
-        NKikimrMiniKQL::TResult res;
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver,
-            IEngineFlat::TShardLimits(2, 1)), IEngineFlat::EStatus::Complete);
-
-        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver,
-            IEngineFlat::TShardLimits(2, 0)), IEngineFlat::EStatus::Error);
-        Cerr << res.DebugString() << Endl;
-    }
-}
-
+                pgmBuilder.TProgramBuilder::NewDataLiteral<ui32>(10)); 
+ 
+            return pgmBuilder.UpdateRow(TTableId(OwnerId, Table2Id), key2Types, row, update); 
+        }); 
+ 
+        auto pgm = pgmBuilder.Build(mapped); 
+ 
+        NKikimrMiniKQL::TResult res; 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver, 
+            IEngineFlat::TShardLimits(2, 1)), IEngineFlat::EStatus::Complete); 
+ 
+        UNIT_ASSERT_EQUAL(driver.Run(pgm, res, &TwoShardResolver, 
+            IEngineFlat::TShardLimits(2, 0)), IEngineFlat::EStatus::Error); 
+        Cerr << res.DebugString() << Endl; 
+    } 
 }
+ 
 }
+} 
diff --git a/ydb/core/engine/mkql_keys.cpp b/ydb/core/engine/mkql_keys.cpp
index 05afb89adc..ed2a93f522 100644
--- a/ydb/core/engine/mkql_keys.cpp
+++ b/ydb/core/engine/mkql_keys.cpp
@@ -130,7 +130,7 @@ THolder<TKeyDesc> ExtractSelectRange(TCallable& callable, const TTypeEnvironment
 
     ui64 itemsLimit = AS_VALUE(TDataLiteral, callable.GetInput(6))->AsValue().Get<ui64>();
     ui64 bytesLimit = AS_VALUE(TDataLiteral, callable.GetInput(7))->AsValue().Get<ui64>();
-
+ 
     TVector<ui32> keyColumnTypes(Max(fromTuple->GetValuesCount(), toTuple->GetValuesCount()));
     TVector<TCell> fromValues(keyColumnTypes.size()); // padded with NULLs
     TVector<TCell> toValues(toTuple->GetValuesCount());
diff --git a/ydb/core/engine/mkql_keys.h b/ydb/core/engine/mkql_keys.h
index 635ad3ce14..f2bc716c40 100644
--- a/ydb/core/engine/mkql_keys.h
+++ b/ydb/core/engine/mkql_keys.h
@@ -23,20 +23,20 @@ struct TTableStrings {
         , EraseRow(env.InternName(TStringBuf("EraseRow")))
     {
         All.reserve(10);
-        All.insert(SelectRow);
-        All.insert(SelectRange);
-        All.insert(UpdateRow);
-        All.insert(EraseRow);
-
-        DbWrites.insert(UpdateRow);
-        DbWrites.insert(EraseRow);
+        All.insert(SelectRow); 
+        All.insert(SelectRange); 
+        All.insert(UpdateRow); 
+        All.insert(EraseRow); 
+ 
+        DbWrites.insert(UpdateRow); 
+        DbWrites.insert(EraseRow); 
     }
 
     const TInternName SelectRow;
     const TInternName SelectRange;
     const TInternName UpdateRow;
     const TInternName EraseRow;
-
+ 
     THashSet<TInternName> All;
     THashSet<TInternName> DbWrites;
 };
diff --git a/ydb/core/engine/mkql_proto.cpp b/ydb/core/engine/mkql_proto.cpp
index 3dd053e372..02f2007d5c 100644
--- a/ydb/core/engine/mkql_proto.cpp
+++ b/ydb/core/engine/mkql_proto.cpp
@@ -8,14 +8,14 @@
 #include <ydb/library/yql/public/decimal/yql_decimal.h>
 
 #include <ydb/core/scheme_types/scheme_types_defs.h>
-
+ 
 namespace NKikimr {
 
 namespace NMiniKQL {
 
 namespace {
 
-    Y_FORCE_INLINE NUdf::TUnboxedValue HandleKindDataImport(TType* type, const Ydb::Value& value) {
+    Y_FORCE_INLINE NUdf::TUnboxedValue HandleKindDataImport(TType* type, const Ydb::Value& value) { 
         auto dataType = static_cast<TDataType*>(type);
         switch (dataType->GetSchemeType()) {
             case NUdf::TDataType<bool>::Id:
@@ -62,7 +62,7 @@ namespace {
 
 }
 
-NUdf::TUnboxedValue ImportValueFromProto(TType* type, const Ydb::Value& value, const THolderFactory& factory) {
+NUdf::TUnboxedValue ImportValueFromProto(TType* type, const Ydb::Value& value, const THolderFactory& factory) { 
     switch (type->GetKind()) {
     case TType::EKind::Void:
         return NUdf::TUnboxedValuePod::Void();
@@ -77,10 +77,10 @@ NUdf::TUnboxedValue ImportValueFromProto(TType* type, const Ydb::Value& value, c
 
     case TType::EKind::Optional: {
         auto optionalType = static_cast<TOptionalType*>(type);
-        switch (value.value_case()) {
-            case Ydb::Value::kNestedValue:
+        switch (value.value_case()) { 
+            case Ydb::Value::kNestedValue: 
                 return ImportValueFromProto(optionalType->GetItemType(), value.nested_value(), factory).MakeOptional();
-            case Ydb::Value::kNullFlagValue:
+            case Ydb::Value::kNullFlagValue: 
                 return NUdf::TUnboxedValue();
             default:
                 return ImportValueFromProto(optionalType->GetItemType(), value, factory).MakeOptional();
@@ -425,6 +425,6 @@ bool CellToValue(NScheme::TTypeId typeId, const TCell& c, NKikimrMiniKQL::TValue
     return true;
 }
 
-
+ 
 } // namspace NMiniKQL
 } // namspace NKikimr
diff --git a/ydb/core/engine/mkql_proto.h b/ydb/core/engine/mkql_proto.h
index 510ff15991..03b83ef3d6 100644
--- a/ydb/core/engine/mkql_proto.h
+++ b/ydb/core/engine/mkql_proto.h
@@ -12,7 +12,7 @@ namespace NMiniKQL {
 
 class THolderFactory;
 
-NUdf::TUnboxedValue ImportValueFromProto(TType* type, const Ydb::Value& value, const THolderFactory& factory);
+NUdf::TUnboxedValue ImportValueFromProto(TType* type, const Ydb::Value& value, const THolderFactory& factory); 
 
 // NOTE: TCell's can reference memomry from tupleValue
 bool CellsFromTuple(const NKikimrMiniKQL::TType* tupleType,
diff --git a/ydb/core/engine/mkql_proto_ut.cpp b/ydb/core/engine/mkql_proto_ut.cpp
index c6e00e947c..01b49921f8 100644
--- a/ydb/core/engine/mkql_proto_ut.cpp
+++ b/ydb/core/engine/mkql_proto_ut.cpp
@@ -18,14 +18,14 @@ namespace NMiniKQL {
 
 Y_UNIT_TEST_SUITE(TMiniKQLProtoTestYdb) {
     Y_UNIT_TEST(TestExportVoidTypeYdb) {
-        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) {
+        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewVoid();
             return pgmReturn;
         }, "void_type: NULL_VALUE\n");
     }
 
     Y_UNIT_TEST(TestExportDataTypeYdb) {
-        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) {
+        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewDataLiteral<i32>(42);
             return pgmReturn;
         },
@@ -56,7 +56,7 @@ Y_UNIT_TEST_SUITE(TMiniKQLProtoTestYdb) {
     }
 
     Y_UNIT_TEST(TestExportOptionalTypeYdb) {
-        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) {
+        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewOptional(pgmBuilder.NewDataLiteral<i32>(42));
             return pgmReturn;
         },
@@ -68,7 +68,7 @@ Y_UNIT_TEST_SUITE(TMiniKQLProtoTestYdb) {
     }
 
     Y_UNIT_TEST(TestExportListTypeYdb) {
-        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) {
+        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.AsList(pgmBuilder.NewDataLiteral<i32>(42));
             return pgmReturn;
         },
@@ -80,7 +80,7 @@ Y_UNIT_TEST_SUITE(TMiniKQLProtoTestYdb) {
     }
 
     Y_UNIT_TEST(TestExportTupleTypeYdb) {
-        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) {
+        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) { 
             TRuntimeNode::TList items;
             items.push_back(pgmBuilder.NewDataLiteral<i32>(42));
             items.push_back(pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("abc"));
@@ -98,7 +98,7 @@ Y_UNIT_TEST_SUITE(TMiniKQLProtoTestYdb) {
     }
 
     Y_UNIT_TEST(TestExportStructTypeYdb) {
-        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) {
+        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) { 
             std::vector<std::pair<std::string_view, TRuntimeNode>> items;
             items.push_back({ "x", pgmBuilder.NewDataLiteral<i32>(42) });
             items.push_back({ "y", pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("abc") });
@@ -122,7 +122,7 @@ Y_UNIT_TEST_SUITE(TMiniKQLProtoTestYdb) {
     }
 
     Y_UNIT_TEST(TestExportDictTypeYdb) {
-        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) {
+        TestExportType<Ydb::Type>([](TProgramBuilder& pgmBuilder) { 
             auto dictType = pgmBuilder.NewDictType(pgmBuilder.NewDataType(NUdf::TDataType<i32>::Id),
                 pgmBuilder.NewDataType(NUdf::TDataType<char*>::Id), false);
             TVector<std::pair<TRuntimeNode, TRuntimeNode>> items;
@@ -200,35 +200,35 @@ Y_UNIT_TEST(TestExportVariantStructTypeYdb) {
     }
 
     Y_UNIT_TEST(TestExportVoidYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewVoid();
             return pgmReturn;
         }, "");
     }
 
     Y_UNIT_TEST(TestExportBoolYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewDataLiteral(true);
             return pgmReturn;
         }, "bool_value: true\n");
     }
 
     Y_UNIT_TEST(TestExportIntegralYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewDataLiteral<i32>(42);
             return pgmReturn;
         }, "int32_value: 42\n");
     }
 
     Y_UNIT_TEST(TestExportDoubleYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewDataLiteral(3.5);
             return pgmReturn;
         }, "double_value: 3.5\n");
     }
 
     Y_UNIT_TEST(TestExportStringYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("abc");
             return pgmReturn;
         }, "bytes_value: \"abc\"\n");
@@ -278,14 +278,14 @@ Y_UNIT_TEST(TestExportVariantStructTypeYdb) {
     }
 
     Y_UNIT_TEST(TestExportEmptyOptionalYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<char*>::Id);
             return pgmReturn;
         }, "null_flag_value: NULL_VALUE\n");
     }
 
     Y_UNIT_TEST(TestExportEmptyOptionalOptionalYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewOptional(
                 pgmBuilder.NewEmptyOptionalDataLiteral(NUdf::TDataType<char*>::Id));
             return pgmReturn;
@@ -296,7 +296,7 @@ Y_UNIT_TEST(TestExportVariantStructTypeYdb) {
     }
 
     Y_UNIT_TEST(TestExportMultipleOptionalNotEmptyYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewOptional(
                 pgmBuilder.NewOptional(pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("abc")));
             return pgmReturn;
@@ -304,14 +304,14 @@ Y_UNIT_TEST(TestExportVariantStructTypeYdb) {
     }
 
     Y_UNIT_TEST(TestExportOptionalYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.NewOptional(pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("abc"));
             return pgmReturn;
         }, "bytes_value: \"abc\"\n");
     }
 
     Y_UNIT_TEST(TestExportListYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto pgmReturn = pgmBuilder.AsList(pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("abc"));
             return pgmReturn;
         },
@@ -321,7 +321,7 @@ Y_UNIT_TEST(TestExportVariantStructTypeYdb) {
     }
 
     Y_UNIT_TEST(TestExportTupleYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             TRuntimeNode::TList items;
             items.push_back(pgmBuilder.NewDataLiteral<i32>(42));
             items.push_back(pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("abc"));
@@ -337,7 +337,7 @@ Y_UNIT_TEST(TestExportVariantStructTypeYdb) {
     }
 
     Y_UNIT_TEST(TestExportStructYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             std::vector<std::pair<std::string_view, TRuntimeNode>> items;
             items.push_back({ "x", pgmBuilder.NewDataLiteral<i32>(42) });
             items.push_back({ "y", pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("abc") });
@@ -353,7 +353,7 @@ Y_UNIT_TEST(TestExportVariantStructTypeYdb) {
     }
 
     Y_UNIT_TEST(TestExportDictYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             auto dictType = pgmBuilder.NewDictType(pgmBuilder.NewDataType(NUdf::TDataType<i32>::Id),
                 pgmBuilder.NewDataType(NUdf::TDataType<char*>::Id), false);
             TVector<std::pair<TRuntimeNode, TRuntimeNode>> items;
@@ -373,7 +373,7 @@ Y_UNIT_TEST(TestExportVariantStructTypeYdb) {
     }
 
     Y_UNIT_TEST(TestExportVariantYdb) {
-        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) {
+        TestExportValue<Ydb::Value>([](TProgramBuilder& pgmBuilder) { 
             std::vector<TType*> tupleElemenTypes;
             tupleElemenTypes.push_back(pgmBuilder.NewDataType(NUdf::TDataType<ui64>::Id));
             tupleElemenTypes.push_back(pgmBuilder.NewDataType(NUdf::TDataType<ui32>::Id));
diff --git a/ydb/core/grpc_services/base/base.h b/ydb/core/grpc_services/base/base.h
index 44b25c4a5f..eed1eec23e 100644
--- a/ydb/core/grpc_services/base/base.h
+++ b/ydb/core/grpc_services/base/base.h
@@ -64,20 +64,20 @@ struct TRpcServices {
         EvGetOperation,
         EvCreateSession,
         EvDeleteSession,
-        EvKeepAlive = EvDeleteSession + 3,
-        EvReadTable = EvKeepAlive + 3,
-        EvGrpcStreamIsReady,
-        EvExplainDataQuery,
-        EvPrepareDataQuery,
-        EvExecuteDataQuery,
-        EvExecuteSchemeQuery,
+        EvKeepAlive = EvDeleteSession + 3, 
+        EvReadTable = EvKeepAlive + 3, 
+        EvGrpcStreamIsReady, 
+        EvExplainDataQuery, 
+        EvPrepareDataQuery, 
+        EvExecuteDataQuery, 
+        EvExecuteSchemeQuery, 
         EvCreateTenant,
         EvAlterTenant,
         EvGetTenantStatus,
         EvListTenants,
         EvRemoveTenant,
-        EvBeginTransaction,
-        EvCommitTransaction,
+        EvBeginTransaction, 
+        EvCommitTransaction, 
         EvRollbackTransaction,
         EvModifyPermissions,
         EvListEndpoints,
@@ -87,18 +87,18 @@ struct TRpcServices {
         EvAlterCoordinationNode,
         EvDropCoordinationNode,
         EvDescribeCoordinationNode,
-        EvCancelOperation,
-        EvForgetOperation,
-        EvExecDataQueryAst,
+        EvCancelOperation, 
+        EvForgetOperation, 
+        EvExecDataQueryAst, 
         EvExecuteYqlScript,
         EvUploadRows,
-        EvS3Listing,
-        EvExplainDataQueryAst,
+        EvS3Listing, 
+        EvExplainDataQueryAst, 
         EvReadColumns,
         EvBiStreamPing,
         EvRefreshTokenRequest, // internal call
-        EvGetShardLocations,
-        EvExperimentalStreamQuery,
+        EvGetShardLocations, 
+        EvExperimentalStreamQuery, 
         EvStreamPQWrite,
         EvStreamPQRead,
         EvPQReadInfo,
@@ -119,7 +119,7 @@ struct TRpcServices {
         EvKikhouseDiscardSnapshot,
         EvExportToS3,
         EvSelfCheck,
-        EvStreamExecuteScanQuery,
+        EvStreamExecuteScanQuery, 
         EvPQDropTopic,
         EvPQCreateTopic,
         EvPQAlterTopic,
@@ -217,9 +217,9 @@ struct TRpcServices {
         {}
         const size_t LeftInQueue;
     };
-
-    struct TEvCancelOperation : public TEventLocal<TEvCancelOperation, TRpcServices::EvCancelOperation> {};
-    struct TEvForgetOperation : public TEventLocal<TEvForgetOperation, TRpcServices::EvForgetOperation> {};
+ 
+    struct TEvCancelOperation : public TEventLocal<TEvCancelOperation, TRpcServices::EvCancelOperation> {}; 
+    struct TEvForgetOperation : public TEventLocal<TEvForgetOperation, TRpcServices::EvForgetOperation> {}; 
 };
 
 // Should be specialized for real responses
@@ -658,10 +658,10 @@ public:
         return GetPeerMetaValues(NYdb::YDB_SDK_BUILD_INFO_HEADER);
     }
 
-    const TMaybe<TString> GetRequestType() const {
+    const TMaybe<TString> GetRequestType() const { 
         return GetPeerMetaValues(NYdb::YDB_REQUEST_TYPE_HEADER);
-    }
-
+    } 
+ 
     TInstant GetDeadline() const override {
         return TInstant::Max();
     }
@@ -912,9 +912,9 @@ public:
 
     const TMaybe<TString> GetRequestType() const override {
         return GetPeerMetaValues(NYdb::YDB_REQUEST_TYPE_HEADER);
-    }
-
-    void SendSerializedResult(TString&& in, Ydb::StatusIds::StatusCode status) {
+    } 
+ 
+    void SendSerializedResult(TString&& in, Ydb::StatusIds::StatusCode status) { 
         // res->data() pointer is used inside grpc code.
         // So this object should be destroyed during grpc_slice destroying routine
         auto res = new TString;
@@ -929,7 +929,7 @@ public:
                     (void*)(res->data()), res->size(), freeResult, res);
         grpc::Slice sl = grpc::Slice(slice, grpc::Slice::STEAL_REF);
         auto data = grpc::ByteBuffer(&sl, 1);
-        Ctx_->Reply(&data, status);
+        Ctx_->Reply(&data, status); 
     }
 
     void SetCostInfo(float consumed_units) override {
diff --git a/ydb/core/grpc_services/grpc_request_proxy.h b/ydb/core/grpc_services/grpc_request_proxy.h
index 97315f6e9f..71d8654731 100644
--- a/ydb/core/grpc_services/grpc_request_proxy.h
+++ b/ydb/core/grpc_services/grpc_request_proxy.h
@@ -86,7 +86,7 @@ protected:
     void Handle(TEvKikhouseDescribeTableRequest::TPtr& ev, const TActorContext& ctx);
     void Handle(TEvS3ListingRequest::TPtr& ev, const TActorContext& ctx);
     void Handle(TEvBiStreamPingRequest::TPtr& ev, const TActorContext& ctx);
-    void Handle(TEvExperimentalStreamQueryRequest::TPtr& ev, const TActorContext& ctx);
+    void Handle(TEvExperimentalStreamQueryRequest::TPtr& ev, const TActorContext& ctx); 
     void Handle(TEvStreamPQWriteRequest::TPtr& ev, const TActorContext& ctx);
     void Handle(TEvStreamPQReadRequest::TPtr& ev, const TActorContext& ctx);
     void Handle(TEvPQReadInfoRequest::TPtr& ev, const TActorContext& ctx);
@@ -114,7 +114,7 @@ protected:
     void Handle(TEvKikhouseDiscardSnapshotRequest::TPtr& ev, const TActorContext& ctx);
     void Handle(TEvSelfCheckRequest::TPtr& ev, const TActorContext& ctx);
     void Handle(TEvLoginRequest::TPtr& ev, const TActorContext& ctx);
-    void Handle(TEvStreamExecuteScanQueryRequest::TPtr& ev, const TActorContext& ctx);
+    void Handle(TEvStreamExecuteScanQueryRequest::TPtr& ev, const TActorContext& ctx); 
     void Handle(TEvCoordinationSessionRequest::TPtr& ev, const TActorContext& ctx);
     void Handle(TEvLongTxBeginRequest::TPtr& ev, const TActorContext& ctx);
     void Handle(TEvLongTxCommitRequest::TPtr& ev, const TActorContext& ctx);
diff --git a/ydb/core/grpc_services/rpc_alter_coordination_node.cpp b/ydb/core/grpc_services/rpc_alter_coordination_node.cpp
index 52cfe8c940..171e50b080 100644
--- a/ydb/core/grpc_services/rpc_alter_coordination_node.cpp
+++ b/ydb/core/grpc_services/rpc_alter_coordination_node.cpp
@@ -1,7 +1,7 @@
 #include "grpc_request_proxy.h"
 
 #include "rpc_calls.h"
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 
 namespace NKikimr {
@@ -10,16 +10,16 @@ namespace NGRpcService {
 using namespace NActors;
 using namespace Ydb;
 
-class TAlterCoordinationNodeRPC : public TRpcSchemeRequestActor<TAlterCoordinationNodeRPC, TEvAlterCoordinationNode> {
-    using TBase = TRpcSchemeRequestActor<TAlterCoordinationNodeRPC, TEvAlterCoordinationNode>;
+class TAlterCoordinationNodeRPC : public TRpcSchemeRequestActor<TAlterCoordinationNodeRPC, TEvAlterCoordinationNode> { 
+    using TBase = TRpcSchemeRequestActor<TAlterCoordinationNodeRPC, TEvAlterCoordinationNode>; 
 
 public:
     TAlterCoordinationNodeRPC(TEvAlterCoordinationNode* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext& ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         Become(&TAlterCoordinationNodeRPC::StateWork);
     }
diff --git a/ydb/core/grpc_services/rpc_alter_table.cpp b/ydb/core/grpc_services/rpc_alter_table.cpp
index d1f2755b66..e94b482845 100644
--- a/ydb/core/grpc_services/rpc_alter_table.cpp
+++ b/ydb/core/grpc_services/rpc_alter_table.cpp
@@ -1,6 +1,6 @@
 #include "grpc_request_proxy.h"
 
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 #include "operation_helpers.h"
 #include "table_settings.h"
@@ -11,7 +11,7 @@
 #include <ydb/core/engine/mkql_proto.h>
 #include <ydb/core/ydb_convert/column_families.h>
 #include <ydb/core/ydb_convert/table_description.h>
-
+ 
 #include <util/generic/hash_set.h>
 
 #define TXLOG_T(stream) LOG_TRACE_S(*TlsActivationContext, NKikimrServices::TX_PROXY, LogPrefix << stream)
@@ -26,7 +26,7 @@ namespace NGRpcService {
 
 using namespace NActors;
 using namespace NConsole;
-using namespace Ydb;
+using namespace Ydb; 
 
 static bool CheckAccess(const NACLib::TUserToken& userToken, const NSchemeCache::TSchemeCacheNavigate* navigate) {
     bool isDatabase = true; // first entry is always database
@@ -77,9 +77,9 @@ static std::pair<StatusIds::StatusCode, TString> CheckAddIndexDesc(const Ydb::Ta
     return {StatusIds::SUCCESS, ""};
 }
 
-class TAlterTableRPC : public TRpcSchemeRequestActor<TAlterTableRPC, TEvAlterTableRequest> {
-    using TBase = TRpcSchemeRequestActor<TAlterTableRPC, TEvAlterTableRequest>;
-
+class TAlterTableRPC : public TRpcSchemeRequestActor<TAlterTableRPC, TEvAlterTableRequest> { 
+    using TBase = TRpcSchemeRequestActor<TAlterTableRPC, TEvAlterTableRequest>; 
+ 
     void PassAway() override {
         if (SSPipeClient) {
             NTabletPipe::CloseClient(SelfId(), SSPipeClient);
@@ -130,11 +130,11 @@ class TAlterTableRPC : public TRpcSchemeRequestActor<TAlterTableRPC, TEvAlterTab
 
 public:
     TAlterTableRPC(IRequestOpCtx* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         const auto& req = GetProtoRequest();
         if (!Request_->GetInternalToken().empty()) {
             UserToken = MakeHolder<NACLib::TUserToken>(Request_->GetInternalToken());
@@ -424,7 +424,7 @@ private:
 
         StatusIds::StatusCode code = StatusIds::SUCCESS;
         TString error;
-
+ 
         if (!FillColumnDescription(*desc, req->add_columns(), code, error)) {
             NYql::TIssues issues;
             issues.AddIssue(NYql::TIssue(error));
diff --git a/ydb/core/grpc_services/rpc_begin_transaction.cpp b/ydb/core/grpc_services/rpc_begin_transaction.cpp
index 9e77fafdd3..6f1a885c7f 100644
--- a/ydb/core/grpc_services/rpc_begin_transaction.cpp
+++ b/ydb/core/grpc_services/rpc_begin_transaction.cpp
@@ -1,112 +1,112 @@
-#include "grpc_request_proxy.h"
-
-#include "rpc_calls.h"
-#include "rpc_kqp_base.h"
+#include "grpc_request_proxy.h" 
+ 
+#include "rpc_calls.h" 
+#include "rpc_kqp_base.h" 
 #include "rpc_common.h"
-
+ 
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
 #include <ydb/library/yql/public/issue/yql_issue.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-using namespace NActors;
-using namespace Ydb;
-using namespace NKqp;
-
-class TBeginTransactionRPC : public TRpcKqpRequestActor<TBeginTransactionRPC, TEvBeginTransactionRequest> {
-    using TBase = TRpcKqpRequestActor<TBeginTransactionRPC, TEvBeginTransactionRequest>;
-
-public:
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+using namespace NActors; 
+using namespace Ydb; 
+using namespace NKqp; 
+ 
+class TBeginTransactionRPC : public TRpcKqpRequestActor<TBeginTransactionRPC, TEvBeginTransactionRequest> { 
+    using TBase = TRpcKqpRequestActor<TBeginTransactionRPC, TEvBeginTransactionRequest>; 
+ 
+public: 
     using TResult = Ydb::Table::BeginTransactionResult;
-
-    TBeginTransactionRPC(TEvBeginTransactionRequest* msg)
-        : TBase(msg) {}
-
-    void Bootstrap(const TActorContext& ctx) {
-        TBase::Bootstrap(ctx);
-
-        BeginTransactionImpl(ctx);
-        Become(&TBeginTransactionRPC::StateWork);
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle);
-            default: TBase::StateWork(ev, ctx);
-        }
-    }
-
-private:
-    void BeginTransactionImpl(const TActorContext &ctx) {
+ 
+    TBeginTransactionRPC(TEvBeginTransactionRequest* msg) 
+        : TBase(msg) {} 
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        TBase::Bootstrap(ctx); 
+ 
+        BeginTransactionImpl(ctx); 
+        Become(&TBeginTransactionRPC::StateWork); 
+    } 
+ 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle); 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
+private: 
+    void BeginTransactionImpl(const TActorContext &ctx) { 
         const auto req = GetProtoRequest();
-        const auto traceId = Request_->GetTraceId();
-
-        TString sessionId;
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
+        const auto traceId = Request_->GetTraceId(); 
+ 
+        TString sessionId; 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>(); 
         SetAuthToken(ev, *Request_);
         SetDatabase(ev, *Request_);
 
-        NYql::TIssues issues;
-        if (CheckSession(req->session_id(), issues)) {
-            ev->Record.MutableRequest()->SetSessionId(req->session_id());
-        } else {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
-        if (!req->has_tx_settings()) {
-            NYql::TIssues issues;
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty tx_settings."));
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        switch (req->tx_settings().tx_mode_case()) {
-            case Table::TransactionSettings::kOnlineReadOnly:
-            case Table::TransactionSettings::kStaleReadOnly: {
-                NYql::TIssues issues;
-                issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, TStringBuilder()
-                    << "Failed to begin transaction: open transactions not supported for transaction mode "
-                    << GetTransactionModeName(req->tx_settings())
-                    << ", use tx_control field in ExecuteDataQueryRequest to begin transaction with this mode."));
-                return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-            }
-            default:
-                break;
-        }
-
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_BEGIN_TX);
-        ev->Record.MutableRequest()->MutableTxControl()->mutable_begin_tx()->CopyFrom(req->tx_settings());
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
-    }
-
-    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record.GetRef();
+        NYql::TIssues issues; 
+        if (CheckSession(req->session_id(), issues)) { 
+            ev->Record.MutableRequest()->SetSessionId(req->session_id()); 
+        } else { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
+ 
+        if (!req->has_tx_settings()) { 
+            NYql::TIssues issues; 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty tx_settings.")); 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        switch (req->tx_settings().tx_mode_case()) { 
+            case Table::TransactionSettings::kOnlineReadOnly: 
+            case Table::TransactionSettings::kStaleReadOnly: { 
+                NYql::TIssues issues; 
+                issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, TStringBuilder() 
+                    << "Failed to begin transaction: open transactions not supported for transaction mode " 
+                    << GetTransactionModeName(req->tx_settings()) 
+                    << ", use tx_control field in ExecuteDataQueryRequest to begin transaction with this mode.")); 
+                return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+            } 
+            default: 
+                break; 
+        } 
+ 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_BEGIN_TX); 
+        ev->Record.MutableRequest()->MutableTxControl()->mutable_begin_tx()->CopyFrom(req->tx_settings()); 
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record.GetRef(); 
         SetCost(record.GetConsumedRu());
         AddServerHintsIfAny(record);
 
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-            const auto& kqpResponse = record.GetResponse();
-            const auto& issueMessage = kqpResponse.GetQueryIssues();
-
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+            const auto& kqpResponse = record.GetResponse(); 
+            const auto& issueMessage = kqpResponse.GetQueryIssues(); 
+ 
             auto beginTxResult = TEvBeginTransactionRequest::AllocateResult<Ydb::Table::BeginTransactionResult>(Request_);
-            if (kqpResponse.HasTxMeta()) {
-                beginTxResult->mutable_tx_meta()->CopyFrom(kqpResponse.GetTxMeta());
-            }
-
-            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, *beginTxResult, ctx);
-        } else {
-            return OnQueryResponseErrorWithTxMeta(record, ctx);
-        }
-    }
-};
-
-void TGRpcRequestProxy::Handle(TEvBeginTransactionRequest::TPtr& ev, const TActorContext& ctx) {
-    ctx.Register(new TBeginTransactionRPC(ev->Release().Release()));
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+            if (kqpResponse.HasTxMeta()) { 
+                beginTxResult->mutable_tx_meta()->CopyFrom(kqpResponse.GetTxMeta()); 
+            } 
+ 
+            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, *beginTxResult, ctx); 
+        } else { 
+            return OnQueryResponseErrorWithTxMeta(record, ctx); 
+        } 
+    } 
+}; 
+ 
+void TGRpcRequestProxy::Handle(TEvBeginTransactionRequest::TPtr& ev, const TActorContext& ctx) { 
+    ctx.Register(new TBeginTransactionRPC(ev->Release().Release())); 
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_calls.h b/ydb/core/grpc_services/rpc_calls.h
index 43136c2f4a..225a1b9700 100644
--- a/ydb/core/grpc_services/rpc_calls.h
+++ b/ydb/core/grpc_services/rpc_calls.h
@@ -84,7 +84,7 @@ using TEvGetShardLocationsRequest = TGRpcRequestWrapper<TRpcServices::EvGetShard
 using TEvKikhouseDescribeTableRequest = TGRpcRequestWrapper<TRpcServices::EvKikhouseDescribeTable, Ydb::ClickhouseInternal::DescribeTableRequest, Ydb::ClickhouseInternal::DescribeTableResponse, true>;
 using TEvS3ListingRequest = TGRpcRequestWrapper<TRpcServices::EvS3Listing, Ydb::S3Internal::S3ListingRequest, Ydb::S3Internal::S3ListingResponse, true>;
 using TEvBiStreamPingRequest = TGRpcRequestBiStreamWrapper<TRpcServices::EvBiStreamPing, Draft::Dummy::PingRequest, Draft::Dummy::PingResponse>;
-using TEvExperimentalStreamQueryRequest = TGRpcRequestWrapper<TRpcServices::EvExperimentalStreamQuery, Ydb::Experimental::ExecuteStreamQueryRequest, Ydb::Experimental::ExecuteStreamQueryResponse, false>;
+using TEvExperimentalStreamQueryRequest = TGRpcRequestWrapper<TRpcServices::EvExperimentalStreamQuery, Ydb::Experimental::ExecuteStreamQueryRequest, Ydb::Experimental::ExecuteStreamQueryResponse, false>; 
 using TEvStreamPQWriteRequest = TGRpcRequestBiStreamWrapper<TRpcServices::EvStreamPQWrite, Ydb::PersQueue::V1::StreamingWriteClientMessage, Ydb::PersQueue::V1::StreamingWriteServerMessage>;
 using TEvStreamPQReadRequest = TGRpcRequestBiStreamWrapper<TRpcServices::EvStreamPQRead, Ydb::PersQueue::V1::MigrationStreamingReadClientMessage, Ydb::PersQueue::V1::MigrationStreamingReadServerMessage>;
 using TEvPQReadInfoRequest = TGRpcRequestWrapper<TRpcServices::EvPQReadInfo, Ydb::PersQueue::V1::ReadInfoRequest, Ydb::PersQueue::V1::ReadInfoResponse, true>;
diff --git a/ydb/core/grpc_services/rpc_cms.cpp b/ydb/core/grpc_services/rpc_cms.cpp
index 7845023306..a58fa0feca 100644
--- a/ydb/core/grpc_services/rpc_cms.cpp
+++ b/ydb/core/grpc_services/rpc_cms.cpp
@@ -12,25 +12,25 @@ namespace NGRpcService {
 
 using namespace NActors;
 using namespace NConsole;
-using namespace Ydb;
+using namespace Ydb; 
 
 template <typename TRequest, typename TCmsRequest, typename TCmsResponse>
-class TCmsRPC : public TRpcOperationRequestActor<TCmsRPC<TRequest, TCmsRequest, TCmsResponse>, TRequest> {
+class TCmsRPC : public TRpcOperationRequestActor<TCmsRPC<TRequest, TCmsRequest, TCmsResponse>, TRequest> { 
     using TThis = TCmsRPC<TRequest, TCmsRequest, TCmsResponse>;
-    using TBase = TRpcOperationRequestActor<TThis, TRequest>;
+    using TBase = TRpcOperationRequestActor<TThis, TRequest>; 
 
     TActorId CmsPipe;
 
 public:
     TCmsRPC(TRequest* msg)
-        : TBase(msg)
+        : TBase(msg) 
     {
     }
 
     void Bootstrap(const TActorContext &ctx)
     {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         auto dinfo = AppData(ctx)->DomainsInfo;
         auto domain = dinfo->Domains.begin()->second;
         ui32 group = dinfo->GetDefaultStateStorageGroup(domain->DomainUid);
@@ -80,7 +80,7 @@ private:
     template<typename T>
     void Handle(T& ev, const TActorContext& ctx)
     {
-        auto& response = ev->Get()->Record.GetResponse();
+        auto& response = ev->Get()->Record.GetResponse(); 
         TProtoResponseHelper::SendProtoResponse(response, response.operation().status(), this->Request_);
         Die(ctx);
     }
@@ -111,14 +111,14 @@ private:
             Undelivered(ctx);
     }
 
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
         switch (ev->GetTypeRewrite()) {
             HFunc(TCmsResponse, Handle);
             CFunc(TEvTabletPipe::EvClientDestroyed, Undelivered);
             HFunc(TEvTabletPipe::TEvClientConnected, Handle);
             HFunc(TEvConsole::TEvOperationCompletionNotification, Handle);
             HFunc(TEvConsole::TEvNotifyOperationCompletionResponse, Handle);
-            default: TBase::StateFuncBase(ev, ctx);
+            default: TBase::StateFuncBase(ev, ctx); 
         }
     }
 
diff --git a/ydb/core/grpc_services/rpc_commit_transaction.cpp b/ydb/core/grpc_services/rpc_commit_transaction.cpp
index 3b85b5ef62..bc50e24ba4 100644
--- a/ydb/core/grpc_services/rpc_commit_transaction.cpp
+++ b/ydb/core/grpc_services/rpc_commit_transaction.cpp
@@ -1,100 +1,100 @@
-#include "grpc_request_proxy.h"
-
-#include "rpc_calls.h"
-#include "rpc_kqp_base.h"
+#include "grpc_request_proxy.h" 
+ 
+#include "rpc_calls.h" 
+#include "rpc_kqp_base.h" 
 #include "rpc_common.h"
-
+ 
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
 #include <ydb/library/yql/public/issue/yql_issue.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-using namespace NActors;
-using namespace Ydb;
-using namespace NKqp;
-
-class TCommitTransactionRPC : public TRpcKqpRequestActor<TCommitTransactionRPC, TEvCommitTransactionRequest> {
-    using TBase = TRpcKqpRequestActor<TCommitTransactionRPC, TEvCommitTransactionRequest>;
-
-public:
-    TCommitTransactionRPC(TEvCommitTransactionRequest* msg)
-        : TBase(msg) {}
-
-    void Bootstrap(const TActorContext& ctx) {
-        TBase::Bootstrap(ctx);
-
-        CommitTransactionImpl(ctx);
-        Become(&TCommitTransactionRPC::StateWork);
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle);
-            default: TBase::StateWork(ev, ctx);
-        }
-    }
-
-private:
-    void CommitTransactionImpl(const TActorContext &ctx) {
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+using namespace NActors; 
+using namespace Ydb; 
+using namespace NKqp; 
+ 
+class TCommitTransactionRPC : public TRpcKqpRequestActor<TCommitTransactionRPC, TEvCommitTransactionRequest> { 
+    using TBase = TRpcKqpRequestActor<TCommitTransactionRPC, TEvCommitTransactionRequest>; 
+ 
+public: 
+    TCommitTransactionRPC(TEvCommitTransactionRequest* msg) 
+        : TBase(msg) {} 
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        TBase::Bootstrap(ctx); 
+ 
+        CommitTransactionImpl(ctx); 
+        Become(&TCommitTransactionRPC::StateWork); 
+    } 
+ 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle); 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
+private: 
+    void CommitTransactionImpl(const TActorContext &ctx) { 
         const auto req = GetProtoRequest();
-        const auto traceId = Request_->GetTraceId();
-
-        TString sessionId;
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
+        const auto traceId = Request_->GetTraceId(); 
+ 
+        TString sessionId; 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>(); 
         SetAuthToken(ev, *Request_);
         SetDatabase(ev, *Request_);
 
-        NYql::TIssues issues;
-        if (CheckSession(req->session_id(), issues)) {
-            ev->Record.MutableRequest()->SetSessionId(req->session_id());
-        } else {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
-        if (!req->tx_id()) {
-            NYql::TIssues issues;
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty transaction id."));
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_COMMIT_TX);
-        ev->Record.MutableRequest()->MutableTxControl()->set_tx_id(req->tx_id());
-        ev->Record.MutableRequest()->MutableTxControl()->set_commit_tx(true);
-        ev->Record.MutableRequest()->SetStatsMode(GetKqpStatsMode(req->collect_stats()));
-
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
-    }
-
-    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record.GetRef();
+        NYql::TIssues issues; 
+        if (CheckSession(req->session_id(), issues)) { 
+            ev->Record.MutableRequest()->SetSessionId(req->session_id()); 
+        } else { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
+ 
+        if (!req->tx_id()) { 
+            NYql::TIssues issues; 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty transaction id.")); 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_COMMIT_TX); 
+        ev->Record.MutableRequest()->MutableTxControl()->set_tx_id(req->tx_id()); 
+        ev->Record.MutableRequest()->MutableTxControl()->set_commit_tx(true); 
+        ev->Record.MutableRequest()->SetStatsMode(GetKqpStatsMode(req->collect_stats())); 
+ 
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record.GetRef(); 
         SetCost(record.GetConsumedRu());
         AddServerHintsIfAny(record);
 
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-            const auto& kqpResponse = record.GetResponse();
-            const auto& issueMessage = kqpResponse.GetQueryIssues();
-
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+            const auto& kqpResponse = record.GetResponse(); 
+            const auto& issueMessage = kqpResponse.GetQueryIssues(); 
+ 
             auto commitResult = TEvCommitTransactionRequest::AllocateResult<Ydb::Table::CommitTransactionResult>(Request_);
-
-            if (kqpResponse.HasQueryStats()) {
+ 
+            if (kqpResponse.HasQueryStats()) { 
                 FillQueryStats(*commitResult->mutable_query_stats(), kqpResponse);
-            }
-
-            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, *commitResult, ctx);
-        } else {
-            return OnGenericQueryResponseError(record, ctx);
-        }
-    }
-};
-
-void TGRpcRequestProxy::Handle(TEvCommitTransactionRequest::TPtr& ev, const TActorContext& ctx) {
-    ctx.Register(new TCommitTransactionRPC(ev->Release().Release()));
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+            } 
+ 
+            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, *commitResult, ctx); 
+        } else { 
+            return OnGenericQueryResponseError(record, ctx); 
+        } 
+    } 
+}; 
+ 
+void TGRpcRequestProxy::Handle(TEvCommitTransactionRequest::TPtr& ev, const TActorContext& ctx) { 
+    ctx.Register(new TCommitTransactionRPC(ev->Release().Release())); 
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_common.h b/ydb/core/grpc_services/rpc_common.h
index 075318037c..d5c9f58a01 100644
--- a/ydb/core/grpc_services/rpc_common.h
+++ b/ydb/core/grpc_services/rpc_common.h
@@ -5,7 +5,7 @@
 #include <ydb/core/base/path.h>
 #include <ydb/core/tx/tx_proxy/proxy.h>
 #include <ydb/core/util/proto_duration.h>
-
+ 
 namespace NKikimr {
 namespace NGRpcService {
 
@@ -28,7 +28,7 @@ inline void SetAuthToken(TEv& ev, const IRequestCtx& ctx) {
 template<typename TEv>
 inline void SetDatabase(TEv& ev, const IRequestCtx& ctx) {
     // Empty database in case of absent header
-    ev->Record.MutableRequest()->SetDatabase(CanonizePath(ctx.GetDatabaseName().GetOrElse("")));
+    ev->Record.MutableRequest()->SetDatabase(CanonizePath(ctx.GetDatabaseName().GetOrElse(""))); 
 }
 
 inline void SetDatabase(TEvTxUserProxy::TEvProposeTransaction* ev, const IRequestCtx& ctx) {
diff --git a/ydb/core/grpc_services/rpc_copy_table.cpp b/ydb/core/grpc_services/rpc_copy_table.cpp
index 74a0c9d9a8..6f248ff38f 100644
--- a/ydb/core/grpc_services/rpc_copy_table.cpp
+++ b/ydb/core/grpc_services/rpc_copy_table.cpp
@@ -1,25 +1,25 @@
 #include "grpc_request_proxy.h"
 
 #include "rpc_calls.h"
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 
 namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
-
-class TCopyTableRPC : public TRpcSchemeRequestActor<TCopyTableRPC, TEvCopyTableRequest> {
-    using TBase = TRpcSchemeRequestActor<TCopyTableRPC, TEvCopyTableRequest>;
+using namespace Ydb; 
 
+class TCopyTableRPC : public TRpcSchemeRequestActor<TCopyTableRPC, TEvCopyTableRequest> { 
+    using TBase = TRpcSchemeRequestActor<TCopyTableRPC, TEvCopyTableRequest>; 
+ 
 public:
     TCopyTableRPC(TEvCopyTableRequest* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         Become(&TCopyTableRPC::StateWork);
     }
diff --git a/ydb/core/grpc_services/rpc_create_coordination_node.cpp b/ydb/core/grpc_services/rpc_create_coordination_node.cpp
index 11c838592c..53724e07b3 100644
--- a/ydb/core/grpc_services/rpc_create_coordination_node.cpp
+++ b/ydb/core/grpc_services/rpc_create_coordination_node.cpp
@@ -1,7 +1,7 @@
 #include "grpc_request_proxy.h"
 
 #include "rpc_calls.h"
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 
 namespace NKikimr {
@@ -10,16 +10,16 @@ namespace NGRpcService {
 using namespace NActors;
 using namespace Ydb;
 
-class TCreateCoordinationNodeRPC : public TRpcSchemeRequestActor<TCreateCoordinationNodeRPC, TEvCreateCoordinationNode> {
-    using TBase = TRpcSchemeRequestActor<TCreateCoordinationNodeRPC, TEvCreateCoordinationNode>;
+class TCreateCoordinationNodeRPC : public TRpcSchemeRequestActor<TCreateCoordinationNodeRPC, TEvCreateCoordinationNode> { 
+    using TBase = TRpcSchemeRequestActor<TCreateCoordinationNodeRPC, TEvCreateCoordinationNode>; 
 
 public:
     TCreateCoordinationNodeRPC(TEvCreateCoordinationNode* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext& ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         Become(&TCreateCoordinationNodeRPC::StateWork);
     }
diff --git a/ydb/core/grpc_services/rpc_create_session.cpp b/ydb/core/grpc_services/rpc_create_session.cpp
index 2f6e9fae26..07f6e522f9 100644
--- a/ydb/core/grpc_services/rpc_create_session.cpp
+++ b/ydb/core/grpc_services/rpc_create_session.cpp
@@ -13,19 +13,19 @@ namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
+using namespace Ydb; 
 using namespace NKqp;
 
-class TCreateSessionRPC : public TRpcKqpRequestActor<TCreateSessionRPC, TEvCreateSessionRequest> {
-    using TBase = TRpcKqpRequestActor<TCreateSessionRPC, TEvCreateSessionRequest>;
-
+class TCreateSessionRPC : public TRpcKqpRequestActor<TCreateSessionRPC, TEvCreateSessionRequest> { 
+    using TBase = TRpcKqpRequestActor<TCreateSessionRPC, TEvCreateSessionRequest>; 
+ 
 public:
     TCreateSessionRPC(IRequestOpCtx* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext& ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         Become(&TCreateSessionRPC::StateWork);
 
         auto now = TInstant::Now();
@@ -47,30 +47,30 @@ public:
 
         CreateSessionImpl();
     }
-
+ 
 private:
     void CreateSessionImpl() {
-        const auto traceId = Request().GetTraceId();
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvCreateSessionRequest>();
+        const auto traceId = Request().GetTraceId(); 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvCreateSessionRequest>(); 
 
         ev->Record.SetDeadlineUs(Request().GetDeadline().MicroSeconds());
 
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
-        SetDatabase(ev, Request());
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
 
+        SetDatabase(ev, Request()); 
+ 
         Send(NKqp::MakeKqpProxyID(SelfId().NodeId()), ev.Release());
-    }
-
+    } 
+ 
     void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
         switch (ev->GetTypeRewrite()) {
             HFunc(NKqp::TEvKqp::TEvCreateSessionResponse, Handle);
             HFunc(TEvents::TEvWakeup, Handle);
             // Overide default forget action which terminate this actor on client disconnect
             hFunc(TRpcServices::TEvForgetOperation, HandleForget);
-            default: TBase::StateWork(ev, ctx);
+            default: TBase::StateWork(ev, ctx); 
         }
     }
 
@@ -108,12 +108,12 @@ private:
     void Handle(NKqp::TEvKqp::TEvCreateSessionResponse::TPtr& ev, const TActorContext& ctx) {
         const auto& record = ev->Get()->Record;
         if (record.GetResourceExhausted()) {
-            Request().ReplyWithRpcStatus(grpc::StatusCode::RESOURCE_EXHAUSTED, record.GetError());
+            Request().ReplyWithRpcStatus(grpc::StatusCode::RESOURCE_EXHAUSTED, record.GetError()); 
             Die(ctx);
             return;
         }
 
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
             const auto& kqpResponse = record.GetResponse();
             Ydb::Table::CreateSessionResult result;
             if (ClientLost) {
@@ -125,7 +125,7 @@ private:
                 return ReplyWithResult(Ydb::StatusIds::SUCCESS, result, ctx);
             }
         } else {
-            return OnQueryResponseError(record, ctx);
+            return OnQueryResponseError(record, ctx); 
         }
     }
 private:
diff --git a/ydb/core/grpc_services/rpc_create_table.cpp b/ydb/core/grpc_services/rpc_create_table.cpp
index 302dfde57a..2c749268e7 100644
--- a/ydb/core/grpc_services/rpc_create_table.cpp
+++ b/ydb/core/grpc_services/rpc_create_table.cpp
@@ -1,7 +1,7 @@
 #include "grpc_request_proxy.h"
 
 #include "rpc_calls.h"
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 #include "table_profiles.h"
 #include "table_settings.h"
@@ -11,28 +11,28 @@
 #include <ydb/core/protos/console_config.pb.h>
 #include <ydb/core/ydb_convert/column_families.h>
 #include <ydb/core/ydb_convert/table_description.h>
-
+ 
 namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NSchemeShard;
 using namespace NActors;
 using namespace NConsole;
-using namespace Ydb;
+using namespace Ydb; 
 using namespace Ydb::Table;
 
-class TCreateTableRPC : public TRpcSchemeRequestActor<TCreateTableRPC, TEvCreateTableRequest> {
-    using TBase = TRpcSchemeRequestActor<TCreateTableRPC, TEvCreateTableRequest>;
-
+class TCreateTableRPC : public TRpcSchemeRequestActor<TCreateTableRPC, TEvCreateTableRequest> { 
+    using TBase = TRpcSchemeRequestActor<TCreateTableRPC, TEvCreateTableRequest>; 
+ 
 public:
     TCreateTableRPC(TEvCreateTableRequest* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendConfigRequest(ctx);
-        ctx.Schedule(TDuration::Seconds(15), new TEvents::TEvWakeup(WakeupTagGetConfig));
+        ctx.Schedule(TDuration::Seconds(15), new TEvents::TEvWakeup(WakeupTagGetConfig)); 
         Become(&TCreateTableRPC::StateGetConfig);
     }
 
@@ -41,17 +41,17 @@ private:
         switch (ev->GetTypeRewrite()) {
             HFunc(TEvConfigsDispatcher::TEvGetConfigResponse, Handle);
             HFunc(TEvents::TEvUndelivered, Handle);
-            HFunc(TEvents::TEvWakeup, HandleWakeup);
-            default: TBase::StateFuncBase(ev, ctx);
-        }
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            default: TBase::StateWork(ev, ctx);
+            HFunc(TEvents::TEvWakeup, HandleWakeup); 
+            default: TBase::StateFuncBase(ev, ctx); 
         }
     }
 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
     void Handle(TEvents::TEvUndelivered::TPtr &/*ev*/, const TActorContext &ctx)
     {
         LOG_CRIT_S(ctx, NKikimrServices::GRPC_PROXY,
@@ -69,17 +69,17 @@ private:
         Become(&TCreateTableRPC::StateWork);
     }
 
-    void HandleWakeup(TEvents::TEvWakeup::TPtr &ev, const TActorContext &ctx) {
-        switch (ev->Get()->Tag) {
-            case WakeupTagGetConfig: {
+    void HandleWakeup(TEvents::TEvWakeup::TPtr &ev, const TActorContext &ctx) { 
+        switch (ev->Get()->Tag) { 
+            case WakeupTagGetConfig: { 
                 LOG_CRIT_S(ctx, NKikimrServices::GRPC_PROXY, "TCreateTableRPC: cannot get table profiles (timeout)");
-                NYql::TIssues issues;
-                issues.AddIssue(NYql::TIssue("Tables profiles config not available."));
-                return Reply(StatusIds::UNAVAILABLE, issues, ctx);
-            }
-            default:
-                TBase::HandleWakeup(ev, ctx);
-        }
+                NYql::TIssues issues; 
+                issues.AddIssue(NYql::TIssue("Tables profiles config not available.")); 
+                return Reply(StatusIds::UNAVAILABLE, issues, ctx); 
+            } 
+            default: 
+                TBase::HandleWakeup(ev, ctx); 
+        } 
     }
 
     void SendConfigRequest(const TActorContext &ctx) {
@@ -136,10 +136,10 @@ private:
         }
 
         tableDesc->SetName(name);
-
+ 
         StatusIds::StatusCode code = StatusIds::SUCCESS;
         TString error;
-
+ 
         if (!FillColumnDescription(*tableDesc, req->columns(), code, error)) {
             NYql::TIssues issues;
             issues.AddIssue(NYql::TIssue(error));
diff --git a/ydb/core/grpc_services/rpc_deferrable.h b/ydb/core/grpc_services/rpc_deferrable.h
index 644e7b84c4..71824ee32c 100644
--- a/ydb/core/grpc_services/rpc_deferrable.h
+++ b/ydb/core/grpc_services/rpc_deferrable.h
@@ -26,23 +26,23 @@ private:
     typedef typename std::conditional<IsOperation, IRequestOpCtx, IRequestNoOpCtx>::type TRequestBase;
 
 public:
-    enum EWakeupTag {
-        WakeupTagTimeout = 10,
-        WakeupTagCancel = 11,
-        WakeupTagGetConfig = 21,
+    enum EWakeupTag { 
+        WakeupTagTimeout = 10, 
+        WakeupTagCancel = 11, 
+        WakeupTagGetConfig = 21, 
         WakeupTagClientLost = 22,
-    };
-
-public:
+    }; 
+ 
+public: 
     TRpcRequestWithOperationParamsActor(TRequestBase* request)
-        : Request_(request)
-    {
+        : Request_(request) 
+    { 
         auto& operationParams = GetProtoRequest()->operation_params();
-        OperationTimeout_ = GetDuration(operationParams.operation_timeout());
-        CancelAfter_ = GetDuration(operationParams.cancel_after());
+        OperationTimeout_ = GetDuration(operationParams.operation_timeout()); 
+        CancelAfter_ = GetDuration(operationParams.cancel_after()); 
         ReportCostInfo_ = operationParams.report_cost_info() == Ydb::FeatureFlag::ENABLED;
-    }
-
+    } 
+ 
     const typename TRequest::TRequest* GetProtoRequest() const {
         return TRequest::GetProtoRequest(Request_);
     }
@@ -51,38 +51,38 @@ public:
         return GetProtoRequest()->operation_params().operation_mode();
     }
 
-    void Bootstrap(const TActorContext &ctx) {
-        HasCancel_ = static_cast<TDerived*>(this)->HasCancelOperation();
-
-        if (OperationTimeout_) {
+    void Bootstrap(const TActorContext &ctx) { 
+        HasCancel_ = static_cast<TDerived*>(this)->HasCancelOperation(); 
+ 
+        if (OperationTimeout_) { 
             OperationTimeoutTimer = CreateLongTimer(ctx, OperationTimeout_,
                 new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(WakeupTagTimeout)),
                 AppData(ctx)->UserPoolId);
-        }
-
-        if (HasCancel_ && CancelAfter_) {
+        } 
+ 
+        if (HasCancel_ && CancelAfter_) { 
             CancelAfterTimer = CreateLongTimer(ctx, CancelAfter_,
                 new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(WakeupTagCancel)),
                 AppData(ctx)->UserPoolId);
         }
 
-        auto selfId = ctx.SelfID;
-        auto* actorSystem = ctx.ExecutorThread.ActorSystem;
-        auto clientLostCb = [selfId, actorSystem]() {
-            actorSystem->Send(selfId, new TRpcServices::TEvForgetOperation());
-        };
-
-        Request_->SetClientLostAction(std::move(clientLostCb));
-    }
-
+        auto selfId = ctx.SelfID; 
+        auto* actorSystem = ctx.ExecutorThread.ActorSystem; 
+        auto clientLostCb = [selfId, actorSystem]() { 
+            actorSystem->Send(selfId, new TRpcServices::TEvForgetOperation()); 
+        }; 
+ 
+        Request_->SetClientLostAction(std::move(clientLostCb)); 
+    } 
+ 
     bool HasCancelOperation() {
         return false;
     }
 
     TRequestBase& Request() const {
-        return *Request_;
-    }
-
+        return *Request_; 
+    } 
+ 
 protected:
     TDuration GetOperationTimeout() {
         return OperationTimeout_;
@@ -137,52 +137,52 @@ public:
         return NKikimrServices::TActivity::DEFERRABLE_RPC;
     }
 
-    void OnCancelOperation(const TActorContext& ctx) {
-        Y_UNUSED(ctx);
-    }
-
-    void OnForgetOperation(const TActorContext& ctx) {
-        // No client is waiting for the reply, but we have to issue fake reply
-        // anyway before dying to make Grpc happy.
-        NYql::TIssues issues;
-        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR,
-            "Closing Grpc request, client should not see this message."));
-        Reply(Ydb::StatusIds::INTERNAL_ERROR, issues, ctx);
+    void OnCancelOperation(const TActorContext& ctx) { 
+        Y_UNUSED(ctx); 
     }
 
-    void OnOperationTimeout(const TActorContext& ctx) {
-        NYql::TIssues issues;
-        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR,
-            "Operation timeout."));
-        Reply(Ydb::StatusIds::TIMEOUT, issues, ctx);
+    void OnForgetOperation(const TActorContext& ctx) { 
+        // No client is waiting for the reply, but we have to issue fake reply 
+        // anyway before dying to make Grpc happy. 
+        NYql::TIssues issues; 
+        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, 
+            "Closing Grpc request, client should not see this message.")); 
+        Reply(Ydb::StatusIds::INTERNAL_ERROR, issues, ctx); 
+    } 
+ 
+    void OnOperationTimeout(const TActorContext& ctx) { 
+        NYql::TIssues issues; 
+        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, 
+            "Operation timeout.")); 
+        Reply(Ydb::StatusIds::TIMEOUT, issues, ctx); 
     }
 
-protected:
-    void StateFuncBase(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TEvents::TEvWakeup, HandleWakeup);
-            HFunc(TRpcServices::TEvForgetOperation, HandleForget);
-            default: {
-                NYql::TIssues issues;
-                issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR,
-                    TStringBuilder() << "Unexpected event received in TRpcOperationRequestActor::StateWork: "
-                        << ev->GetTypeRewrite()));
-                return this->Reply(Ydb::StatusIds::INTERNAL_ERROR, issues, ctx);
-            }
+protected: 
+    void StateFuncBase(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TEvents::TEvWakeup, HandleWakeup); 
+            HFunc(TRpcServices::TEvForgetOperation, HandleForget); 
+            default: { 
+                NYql::TIssues issues; 
+                issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, 
+                    TStringBuilder() << "Unexpected event received in TRpcOperationRequestActor::StateWork: " 
+                        << ev->GetTypeRewrite())); 
+                return this->Reply(Ydb::StatusIds::INTERNAL_ERROR, issues, ctx); 
+            } 
         }
     }
 
-protected:
+protected: 
     using TBase::Request_;
-
-    void Reply(Ydb::StatusIds::StatusCode status,
-        const google::protobuf::RepeatedPtrField<TYdbIssueMessageType>& message, const TActorContext& ctx)
-    {
+ 
+    void Reply(Ydb::StatusIds::StatusCode status, 
+        const google::protobuf::RepeatedPtrField<TYdbIssueMessageType>& message, const TActorContext& ctx) 
+    { 
         Request_->SendResult(status, message);
         this->Die(ctx);
     }
 
-    void Reply(Ydb::StatusIds::StatusCode status, const NYql::TIssues& issues, const TActorContext& ctx) {
+    void Reply(Ydb::StatusIds::StatusCode status, const NYql::TIssues& issues, const TActorContext& ctx) { 
         Request_->RaiseIssues(issues);
         Request_->ReplyWithYdbStatus(status);
         this->Die(ctx);
@@ -199,9 +199,9 @@ protected:
         this->Die(ctx);
     }
 
-    void ReplyWithResult(Ydb::StatusIds::StatusCode status,
-        const google::protobuf::RepeatedPtrField<TYdbIssueMessageType>& message, const TActorContext &ctx)
-    {
+    void ReplyWithResult(Ydb::StatusIds::StatusCode status, 
+        const google::protobuf::RepeatedPtrField<TYdbIssueMessageType>& message, const TActorContext &ctx) 
+    { 
         Request_->SendResult(status, message);
         this->Die(ctx);
     }
@@ -237,24 +237,24 @@ protected:
         }
     }
 
-protected:
-    void HandleWakeup(TEvents::TEvWakeup::TPtr &ev, const TActorContext &ctx) {
-        switch (ev->Get()->Tag) {
+protected: 
+    void HandleWakeup(TEvents::TEvWakeup::TPtr &ev, const TActorContext &ctx) { 
+        switch (ev->Get()->Tag) { 
             case TBase::WakeupTagTimeout:
-                static_cast<TDerived*>(this)->OnOperationTimeout(ctx);
-                break;
+                static_cast<TDerived*>(this)->OnOperationTimeout(ctx); 
+                break; 
             case TBase::WakeupTagCancel:
-                static_cast<TDerived*>(this)->OnCancelOperation(ctx);
-                break;
-            default:
-                break;
-        }
-    }
-
-    void HandleForget(TRpcServices::TEvForgetOperation::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-        static_cast<TDerived*>(this)->OnForgetOperation(ctx);
-    }
+                static_cast<TDerived*>(this)->OnCancelOperation(ctx); 
+                break; 
+            default: 
+                break; 
+        } 
+    } 
+ 
+    void HandleForget(TRpcServices::TEvForgetOperation::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+        static_cast<TDerived*>(this)->OnForgetOperation(ctx); 
+    } 
 };
 
 } // namespace NGRpcService
diff --git a/ydb/core/grpc_services/rpc_delete_session.cpp b/ydb/core/grpc_services/rpc_delete_session.cpp
index a2245af236..2deafcdfde 100644
--- a/ydb/core/grpc_services/rpc_delete_session.cpp
+++ b/ydb/core/grpc_services/rpc_delete_session.cpp
@@ -10,37 +10,37 @@ namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
+using namespace Ydb; 
 using namespace NKqp;
 
-class TDeleteSessionRPC : public TRpcKqpRequestActor<TDeleteSessionRPC, TEvDeleteSessionRequest> {
-    using TBase = TRpcKqpRequestActor<TDeleteSessionRPC, TEvDeleteSessionRequest>;
-
+class TDeleteSessionRPC : public TRpcKqpRequestActor<TDeleteSessionRPC, TEvDeleteSessionRequest> { 
+    using TBase = TRpcKqpRequestActor<TDeleteSessionRPC, TEvDeleteSessionRequest>; 
+ 
 public:
     TDeleteSessionRPC(IRequestOpCtx* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext& ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         DeleteSessionImpl(ctx);
-        Become(&TDeleteSessionRPC::StateWork);
+        Become(&TDeleteSessionRPC::StateWork); 
     }
-
+ 
 private:
     void DeleteSessionImpl(const TActorContext& ctx) {
         const auto req = GetProtoRequest();
-
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvCloseSessionRequest>();
-
-        NYql::TIssues issues;
-        if (CheckSession(req->session_id(), issues)) {
-            ev->Record.MutableRequest()->SetSessionId(req->session_id());
-        } else {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
+ 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvCloseSessionRequest>(); 
+ 
+        NYql::TIssues issues; 
+        if (CheckSession(req->session_id(), issues)) { 
+            ev->Record.MutableRequest()->SetSessionId(req->session_id()); 
+        } else { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
         }
 
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); //no respose will be sended, so don't wait for anything
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); //no respose will be sended, so don't wait for anything 
         Request_->ReplyWithYdbStatus(Ydb::StatusIds::SUCCESS);
         this->Die(ctx);
     }
diff --git a/ydb/core/grpc_services/rpc_describe_coordination_node.cpp b/ydb/core/grpc_services/rpc_describe_coordination_node.cpp
index 04c16bf32e..35532f60ab 100644
--- a/ydb/core/grpc_services/rpc_describe_coordination_node.cpp
+++ b/ydb/core/grpc_services/rpc_describe_coordination_node.cpp
@@ -1,7 +1,7 @@
 #include "grpc_request_proxy.h"
 
 #include "rpc_calls.h"
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 
 #include <ydb/core/protos/flat_tx_scheme.pb.h>
@@ -14,16 +14,16 @@ namespace NGRpcService {
 using namespace NActors;
 using namespace Ydb;
 
-class TDescribeCoordinationNode : public TRpcSchemeRequestActor<TDescribeCoordinationNode, TEvDescribeCoordinationNode> {
-    using TBase = TRpcSchemeRequestActor<TDescribeCoordinationNode, TEvDescribeCoordinationNode>;
+class TDescribeCoordinationNode : public TRpcSchemeRequestActor<TDescribeCoordinationNode, TEvDescribeCoordinationNode> { 
+    using TBase = TRpcSchemeRequestActor<TDescribeCoordinationNode, TEvDescribeCoordinationNode>; 
 
 public:
     TDescribeCoordinationNode(TEvDescribeCoordinationNode* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         Become(&TDescribeCoordinationNode::StateWork);
     }
@@ -32,7 +32,7 @@ private:
     void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
         switch (ev->GetTypeRewrite()) {
             HFunc(NSchemeShard::TEvSchemeShard::TEvDescribeSchemeResult, Handle);
-            default: TBase::StateWork(ev, ctx);
+            default: TBase::StateWork(ev, ctx); 
         }
     }
 
@@ -69,11 +69,11 @@ private:
                 return Reply(Ydb::StatusIds::SCHEME_ERROR, ctx);
             }
             case NKikimrScheme::StatusAccessDenied: {
-                return Reply(Ydb::StatusIds::UNAUTHORIZED, ctx);
-            }
+                return Reply(Ydb::StatusIds::UNAUTHORIZED, ctx); 
+            } 
             case NKikimrScheme::StatusNotAvailable: {
-                return Reply(Ydb::StatusIds::UNAVAILABLE, ctx);
-            }
+                return Reply(Ydb::StatusIds::UNAVAILABLE, ctx); 
+            } 
             default: {
                 return Reply(Ydb::StatusIds::GENERIC_ERROR, ctx);
             }
diff --git a/ydb/core/grpc_services/rpc_describe_path.cpp b/ydb/core/grpc_services/rpc_describe_path.cpp
index 7960f50779..d4250dd821 100644
--- a/ydb/core/grpc_services/rpc_describe_path.cpp
+++ b/ydb/core/grpc_services/rpc_describe_path.cpp
@@ -1,7 +1,7 @@
 #include "service_scheme.h"
 #include <ydb/core/grpc_services/base/base.h>
 
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 #include <ydb/core/protos/flat_tx_scheme.pb.h>
 #include <ydb/core/tx/schemeshard/schemeshard.h>
@@ -11,7 +11,7 @@ namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
+using namespace Ydb; 
 
 using TEvListDirectoryRequest = TGrpcRequestOperationCall<Ydb::Scheme::ListDirectoryRequest,
     Ydb::Scheme::ListDirectoryResponse>;
@@ -22,14 +22,14 @@ using TEvDescribePathRequest = TGrpcRequestOperationCall<Ydb::Scheme::DescribePa
 template <typename TDerived, typename TRequest, typename TResult, bool ListChildren = false>
 class TBaseDescribe : public TRpcSchemeRequestActor<TDerived, TRequest> {
     using TBase = TRpcSchemeRequestActor<TDerived, TRequest>;
-
+ 
 public:
     TBaseDescribe(IRequestOpCtx* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         this->Become(&TDerived::StateWork);
     }
@@ -50,7 +50,7 @@ private:
     void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
         switch (ev->GetTypeRewrite()) {
             HFunc(NSchemeShard::TEvSchemeShard::TEvDescribeSchemeResult, Handle);
-            default: TBase::StateWork(ev, ctx);
+            default: TBase::StateWork(ev, ctx); 
         }
     }
 
@@ -84,7 +84,7 @@ private:
             }
             case NKikimrScheme::StatusNotAvailable: {
                 return this->Reply(Ydb::StatusIds::UNAVAILABLE, ctx);
-            }
+            } 
             default: {
                 return this->Reply(Ydb::StatusIds::GENERIC_ERROR, ctx);
             }
diff --git a/ydb/core/grpc_services/rpc_describe_table.cpp b/ydb/core/grpc_services/rpc_describe_table.cpp
index 261f10d467..b69411af75 100644
--- a/ydb/core/grpc_services/rpc_describe_table.cpp
+++ b/ydb/core/grpc_services/rpc_describe_table.cpp
@@ -1,8 +1,8 @@
 #include "grpc_request_proxy.h"
 
 #include "rpc_calls.h"
-#include "rpc_scheme_base.h"
-
+#include "rpc_scheme_base.h" 
+ 
 #include "rpc_common.h"
 #include <ydb/core/tx/schemeshard/schemeshard.h>
 #include <ydb/core/ydb_convert/table_description.h>
@@ -12,18 +12,18 @@ namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
-
-class TDescribeTableRPC : public TRpcSchemeRequestActor<TDescribeTableRPC, TEvDescribeTableRequest> {
-    using TBase = TRpcSchemeRequestActor<TDescribeTableRPC, TEvDescribeTableRequest>;
+using namespace Ydb; 
 
+class TDescribeTableRPC : public TRpcSchemeRequestActor<TDescribeTableRPC, TEvDescribeTableRequest> { 
+    using TBase = TRpcSchemeRequestActor<TDescribeTableRPC, TEvDescribeTableRequest>; 
+ 
 public:
     TDescribeTableRPC(TEvDescribeTableRequest* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         Become(&TDescribeTableRPC::StateWork);
     }
@@ -32,7 +32,7 @@ private:
     void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
         switch (ev->GetTypeRewrite()) {
             HFunc(NSchemeShard::TEvSchemeShard::TEvDescribeSchemeResult, Handle);
-            default: TBase::StateWork(ev, ctx);
+            default: TBase::StateWork(ev, ctx); 
         }
     }
 
@@ -87,12 +87,12 @@ private:
                 FillKeyBloomFilter(describeTableResult, tableDescription);
                 FillReadReplicasSettings(describeTableResult, tableDescription);
 
-                return ReplyWithResult(Ydb::StatusIds::SUCCESS, describeTableResult, ctx);
+                return ReplyWithResult(Ydb::StatusIds::SUCCESS, describeTableResult, ctx); 
             }
 
             case NKikimrScheme::StatusPathDoesNotExist:
             case NKikimrScheme::StatusSchemeError: {
-                return Reply(Ydb::StatusIds::SCHEME_ERROR, ctx);
+                return Reply(Ydb::StatusIds::SCHEME_ERROR, ctx); 
             }
 
             case NKikimrScheme::StatusAccessDenied: {
@@ -100,11 +100,11 @@ private:
             }
 
             case NKikimrScheme::StatusNotAvailable: {
-                return Reply(Ydb::StatusIds::UNAVAILABLE, ctx);
-            }
-
+                return Reply(Ydb::StatusIds::UNAVAILABLE, ctx); 
+            } 
+ 
             default: {
-                return Reply(Ydb::StatusIds::GENERIC_ERROR, ctx);
+                return Reply(Ydb::StatusIds::GENERIC_ERROR, ctx); 
             }
         }
     }
diff --git a/ydb/core/grpc_services/rpc_describe_table_options.cpp b/ydb/core/grpc_services/rpc_describe_table_options.cpp
index 6d77e3cff7..6a92f64bd6 100644
--- a/ydb/core/grpc_services/rpc_describe_table_options.cpp
+++ b/ydb/core/grpc_services/rpc_describe_table_options.cpp
@@ -1,7 +1,7 @@
 #include "grpc_request_proxy.h"
 
 #include "rpc_calls.h"
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 #include "table_profiles.h"
 
@@ -17,18 +17,18 @@ using namespace NConsole;
 using namespace Ydb;
 using namespace Ydb::Table;
 
-class TDescribeTableOptionsRPC : public TRpcSchemeRequestActor<TDescribeTableOptionsRPC, TEvDescribeTableOptionsRequest> {
-    using TBase = TRpcSchemeRequestActor<TDescribeTableOptionsRPC, TEvDescribeTableOptionsRequest>;
-
+class TDescribeTableOptionsRPC : public TRpcSchemeRequestActor<TDescribeTableOptionsRPC, TEvDescribeTableOptionsRequest> { 
+    using TBase = TRpcSchemeRequestActor<TDescribeTableOptionsRPC, TEvDescribeTableOptionsRequest>; 
+ 
 public:
     TDescribeTableOptionsRPC(TEvDescribeTableOptionsRequest* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendConfigRequest(ctx);
-        ctx.Schedule(TDuration::Seconds(15), new TEvents::TEvWakeup(WakeupTagGetConfig));
+        ctx.Schedule(TDuration::Seconds(15), new TEvents::TEvWakeup(WakeupTagGetConfig)); 
         Become(&TDescribeTableOptionsRPC::StateGetConfig);
     }
 
@@ -37,17 +37,17 @@ private:
         switch (ev->GetTypeRewrite()) {
             HFunc(TEvConfigsDispatcher::TEvGetConfigResponse, Handle);
             HFunc(TEvents::TEvUndelivered, Handle);
-            HFunc(TEvents::TEvWakeup, HandleWakeup);
-            default: TBase::StateFuncBase(ev, ctx);
-        }
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            default: TBase::StateWork(ev, ctx);
+            HFunc(TEvents::TEvWakeup, HandleWakeup); 
+            default: TBase::StateFuncBase(ev, ctx); 
         }
     }
 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
     void Handle(TEvents::TEvUndelivered::TPtr &/*ev*/, const TActorContext &ctx)
     {
         LOG_CRIT_S(ctx, NKikimrServices::GRPC_PROXY,
@@ -176,21 +176,21 @@ private:
         Die(ctx);
     }
 
-    void HandleWakeup(TEvents::TEvWakeup::TPtr &ev, const TActorContext &ctx) {
-        switch (ev->Get()->Tag) {
-            case WakeupTagGetConfig: {
+    void HandleWakeup(TEvents::TEvWakeup::TPtr &ev, const TActorContext &ctx) { 
+        switch (ev->Get()->Tag) { 
+            case WakeupTagGetConfig: { 
                 LOG_CRIT_S(ctx, NKikimrServices::GRPC_PROXY,
                    "TDescribeTableOptionsRPC: cannot get table profiles (timeout)");
-                NYql::TIssues issues;
-                issues.AddIssue(NYql::TIssue("Tables profiles config not available."));
-                return Reply(Ydb::StatusIds::UNAVAILABLE, issues, ctx);
-            }
-
-            default:
-                TBase::HandleWakeup(ev, ctx);
-        }
-    }
-
+                NYql::TIssues issues; 
+                issues.AddIssue(NYql::TIssue("Tables profiles config not available.")); 
+                return Reply(Ydb::StatusIds::UNAVAILABLE, issues, ctx); 
+            } 
+
+            default: 
+                TBase::HandleWakeup(ev, ctx); 
+        } 
+    } 
+ 
     void SendConfigRequest(const TActorContext &ctx) {
         ui32 configKind = (ui32)NKikimrConsole::TConfigItem::TableProfilesConfigItem;
         ctx.Send(MakeConfigsDispatcherID(ctx.SelfID.NodeId()),
diff --git a/ydb/core/grpc_services/rpc_drop_coordination_node.cpp b/ydb/core/grpc_services/rpc_drop_coordination_node.cpp
index 3632ec5872..94597e7a2b 100644
--- a/ydb/core/grpc_services/rpc_drop_coordination_node.cpp
+++ b/ydb/core/grpc_services/rpc_drop_coordination_node.cpp
@@ -1,7 +1,7 @@
 #include "grpc_request_proxy.h"
 
 #include "rpc_calls.h"
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 
 namespace NKikimr {
@@ -10,16 +10,16 @@ namespace NGRpcService {
 using namespace NActors;
 using namespace Ydb;
 
-class TDropCoordinationNodeRPC : public TRpcSchemeRequestActor<TDropCoordinationNodeRPC, TEvDropCoordinationNode> {
-    using TBase = TRpcSchemeRequestActor<TDropCoordinationNodeRPC, TEvDropCoordinationNode>;
-
+class TDropCoordinationNodeRPC : public TRpcSchemeRequestActor<TDropCoordinationNodeRPC, TEvDropCoordinationNode> { 
+    using TBase = TRpcSchemeRequestActor<TDropCoordinationNodeRPC, TEvDropCoordinationNode>; 
+ 
 public:
     TDropCoordinationNodeRPC(TEvDropCoordinationNode* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         Become(&TDropCoordinationNodeRPC::StateWork);
     }
diff --git a/ydb/core/grpc_services/rpc_drop_table.cpp b/ydb/core/grpc_services/rpc_drop_table.cpp
index 27899a9d77..5097db15d4 100644
--- a/ydb/core/grpc_services/rpc_drop_table.cpp
+++ b/ydb/core/grpc_services/rpc_drop_table.cpp
@@ -1,25 +1,25 @@
 #include "grpc_request_proxy.h"
 
 #include "rpc_calls.h"
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 
 namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
-
-class TDropTableRPC : public TRpcSchemeRequestActor<TDropTableRPC, TEvDropTableRequest> {
-    using TBase = TRpcSchemeRequestActor<TDropTableRPC, TEvDropTableRequest>;
+using namespace Ydb; 
 
+class TDropTableRPC : public TRpcSchemeRequestActor<TDropTableRPC, TEvDropTableRequest> { 
+    using TBase = TRpcSchemeRequestActor<TDropTableRPC, TEvDropTableRequest>; 
+ 
 public:
     TDropTableRPC(IRequestOpCtx* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         Become(&TDropTableRPC::StateWork);
     }
diff --git a/ydb/core/grpc_services/rpc_execute_data_query.cpp b/ydb/core/grpc_services/rpc_execute_data_query.cpp
index 317a3488ce..9ec8fc8fbd 100644
--- a/ydb/core/grpc_services/rpc_execute_data_query.cpp
+++ b/ydb/core/grpc_services/rpc_execute_data_query.cpp
@@ -1,164 +1,164 @@
-#include "grpc_request_proxy.h"
-
-#include "rpc_calls.h"
-#include "rpc_kqp_base.h"
+#include "grpc_request_proxy.h" 
+ 
+#include "rpc_calls.h" 
+#include "rpc_kqp_base.h" 
 #include "rpc_common.h"
-
+ 
 #include <ydb/core/base/counters.h>
 #include <ydb/core/protos/console_config.pb.h>
 #include <ydb/core/ydb_convert/ydb_convert.h>
 #include <ydb/public/lib/operation_id/operation_id.h>
-
+ 
 #include <ydb/library/yql/public/issue/yql_issue.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-using namespace NActors;
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+using namespace NActors; 
 using namespace NOperationId;
-using namespace Ydb;
+using namespace Ydb; 
 using namespace Ydb::Table;
-using namespace NKqp;
-
-class TExecuteDataQueryRPC : public TRpcKqpRequestActor<TExecuteDataQueryRPC, TEvExecuteDataQueryRequest> {
-    using TBase = TRpcKqpRequestActor<TExecuteDataQueryRPC, TEvExecuteDataQueryRequest>;
-
-public:
+using namespace NKqp; 
+ 
+class TExecuteDataQueryRPC : public TRpcKqpRequestActor<TExecuteDataQueryRPC, TEvExecuteDataQueryRequest> { 
+    using TBase = TRpcKqpRequestActor<TExecuteDataQueryRPC, TEvExecuteDataQueryRequest>; 
+ 
+public: 
     using TResult = Ydb::Table::ExecuteQueryResult;
-
-    TExecuteDataQueryRPC(TEvExecuteDataQueryRequest* msg)
-        : TBase(msg) {}
-
-    void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
-        this->Become(&TExecuteDataQueryRPC::StateWork);
+ 
+    TExecuteDataQueryRPC(TEvExecuteDataQueryRequest* msg) 
+        : TBase(msg) {} 
+ 
+    void Bootstrap(const TActorContext &ctx) { 
+        TBase::Bootstrap(ctx); 
+ 
+        this->Become(&TExecuteDataQueryRPC::StateWork); 
         Proceed(ctx);
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle);
-            default: TBase::StateWork(ev, ctx);
-        }
-    }
-
+    } 
+ 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle); 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
     void Proceed(const TActorContext& ctx) {
         const auto req = GetProtoRequest();
-        const auto traceId = Request_->GetTraceId();
-        const auto requestType = Request_->GetRequestType();
-
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
+        const auto traceId = Request_->GetTraceId(); 
+        const auto requestType = Request_->GetRequestType(); 
+ 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>(); 
         SetAuthToken(ev, *Request_);
         SetDatabase(ev, *Request_);
 
-        NYql::TIssues issues;
-        if (CheckSession(req->session_id(), issues)) {
-            ev->Record.MutableRequest()->SetSessionId(req->session_id());
-        } else {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
-        if (requestType) {
-            ev->Record.SetRequestType(requestType.GetRef());
-        }
-
-        ev->Record.MutableRequest()->SetCancelAfterMs(GetCancelAfter().MilliSeconds());
-        ev->Record.MutableRequest()->SetTimeoutMs(GetOperationTimeout().MilliSeconds());
-
-        if (req->parametersSize() != 0) {
-            try {
-                NKikimrMiniKQL::TParams params;
-                ConvertYdbParamsToMiniKQLParams(req->parameters(), params);
-                ev->Record.MutableRequest()->MutableParameters()->CopyFrom(params);
-            } catch (const std::exception& ex) {
+        NYql::TIssues issues; 
+        if (CheckSession(req->session_id(), issues)) { 
+            ev->Record.MutableRequest()->SetSessionId(req->session_id()); 
+        } else { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
+ 
+        if (requestType) { 
+            ev->Record.SetRequestType(requestType.GetRef()); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetCancelAfterMs(GetCancelAfter().MilliSeconds()); 
+        ev->Record.MutableRequest()->SetTimeoutMs(GetOperationTimeout().MilliSeconds()); 
+ 
+        if (req->parametersSize() != 0) { 
+            try { 
+                NKikimrMiniKQL::TParams params; 
+                ConvertYdbParamsToMiniKQLParams(req->parameters(), params); 
+                ev->Record.MutableRequest()->MutableParameters()->CopyFrom(params); 
+            } catch (const std::exception& ex) { 
                 auto issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Failed to parse query parameters.");
-                issue.AddSubIssue(MakeIntrusive<NYql::TIssue>(NYql::ExceptionToIssue(ex)));
-
-                NYql::TIssues issues;
-                issues.AddIssue(issue);
-
-                return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-            }
-        }
-
-        if (!req->has_tx_control()) {
-            NYql::TIssues issues;
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty tx_control."));
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        if (req->tx_control().has_begin_tx() && !req->tx_control().commit_tx()) {
-            switch (req->tx_control().begin_tx().tx_mode_case()) {
-                case Table::TransactionSettings::kOnlineReadOnly:
-                case Table::TransactionSettings::kStaleReadOnly: {
-                    NYql::TIssues issues;
-                    issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, TStringBuilder()
-                        << "Failed to execute query: open transactions not supported for transaction mode: "
-                        << GetTransactionModeName(req->tx_control().begin_tx())
-                        << ", use commit_tx flag to explicitely commit transaction."));
-                    return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-                }
-                default:
-                    break;
-            }
-        }
-
-        ev->Record.MutableRequest()->MutableTxControl()->CopyFrom(req->tx_control());
-        ev->Record.MutableRequest()->MutableQueryCachePolicy()->CopyFrom(req->query_cache_policy());
-        ev->Record.MutableRequest()->SetStatsMode(GetKqpStatsMode(req->collect_stats()));
-
-        auto& query = req->query();
-        switch (req->query().query_case()) {
-            case Query::kYqlText: {
-                NYql::TIssues issues;
-                if (!CheckQuery(query.yql_text(), issues)) {
-                    return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-                }
-
-                ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
-                ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DML);
-                ev->Record.MutableRequest()->SetQuery(query.yql_text());
-                break;
-            }
-
-            case Query::kId: {
-                if (query.id().empty()) {
-                    NYql::TIssues issues;
-                    issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty query id"));
-                    return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-                }
-
-                ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED);
-                ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_PREPARED_DML);
-
-                TString preparedQueryId;
-                try {
-                    preparedQueryId = DecodePreparedQueryId(query.id());
-                } catch (const std::exception& ex) {
-                    NYql::TIssues issues;
-                    issues.AddIssue(NYql::ExceptionToIssue(ex));
-                    return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-                }
-
-                ev->Record.MutableRequest()->SetPreparedQuery(preparedQueryId);
-                break;
-            }
-
-            default: {
-                NYql::TIssues issues;
-                issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Unexpected query option"));
-                return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-            }
-        }
-
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
-    }
-
+                issue.AddSubIssue(MakeIntrusive<NYql::TIssue>(NYql::ExceptionToIssue(ex))); 
+ 
+                NYql::TIssues issues; 
+                issues.AddIssue(issue); 
+ 
+                return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+            } 
+        } 
+ 
+        if (!req->has_tx_control()) { 
+            NYql::TIssues issues; 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty tx_control.")); 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        if (req->tx_control().has_begin_tx() && !req->tx_control().commit_tx()) { 
+            switch (req->tx_control().begin_tx().tx_mode_case()) { 
+                case Table::TransactionSettings::kOnlineReadOnly: 
+                case Table::TransactionSettings::kStaleReadOnly: { 
+                    NYql::TIssues issues; 
+                    issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, TStringBuilder() 
+                        << "Failed to execute query: open transactions not supported for transaction mode: " 
+                        << GetTransactionModeName(req->tx_control().begin_tx()) 
+                        << ", use commit_tx flag to explicitely commit transaction.")); 
+                    return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+                } 
+                default: 
+                    break; 
+            } 
+        } 
+ 
+        ev->Record.MutableRequest()->MutableTxControl()->CopyFrom(req->tx_control()); 
+        ev->Record.MutableRequest()->MutableQueryCachePolicy()->CopyFrom(req->query_cache_policy()); 
+        ev->Record.MutableRequest()->SetStatsMode(GetKqpStatsMode(req->collect_stats())); 
+ 
+        auto& query = req->query(); 
+        switch (req->query().query_case()) { 
+            case Query::kYqlText: { 
+                NYql::TIssues issues; 
+                if (!CheckQuery(query.yql_text(), issues)) { 
+                    return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+                } 
+ 
+                ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE); 
+                ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DML); 
+                ev->Record.MutableRequest()->SetQuery(query.yql_text()); 
+                break; 
+            } 
+ 
+            case Query::kId: { 
+                if (query.id().empty()) { 
+                    NYql::TIssues issues; 
+                    issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty query id")); 
+                    return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+                } 
+ 
+                ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED); 
+                ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_PREPARED_DML); 
+ 
+                TString preparedQueryId; 
+                try { 
+                    preparedQueryId = DecodePreparedQueryId(query.id()); 
+                } catch (const std::exception& ex) { 
+                    NYql::TIssues issues; 
+                    issues.AddIssue(NYql::ExceptionToIssue(ex)); 
+                    return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+                } 
+ 
+                ev->Record.MutableRequest()->SetPreparedQuery(preparedQueryId); 
+                break; 
+            } 
+ 
+            default: { 
+                NYql::TIssues issues; 
+                issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Unexpected query option")); 
+                return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+            } 
+        } 
+ 
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
+    } 
+ 
     static void ConvertReadStats(const NKikimrQueryStats::TReadOpStats& from, Ydb::TableStats::OperationStats* to) {
         to->set_rows(to->rows() + from.GetRows());
         to->set_bytes(to->bytes() + from.GetBytes());
@@ -170,13 +170,13 @@ public:
     }
 
     static void ConvertQueryStats(const NKikimrKqp::TQueryResponse& from, Ydb::Table::ExecuteQueryResult* to) {
-        if (from.HasQueryStats()) {
+        if (from.HasQueryStats()) { 
             FillQueryStats(*to->mutable_query_stats(), from);
             to->mutable_query_stats()->set_query_ast(from.GetQueryAst());
-            return;
-        }
-
-        // TODO: For compatibility with old kqp workers, deprecate.
+            return; 
+        } 
+ 
+        // TODO: For compatibility with old kqp workers, deprecate. 
         if (from.GetProfile().KqlProfilesSize() == 1) {
             const auto& kqlProlfile = from.GetProfile().GetKqlProfiles(0);
             const auto& phases = kqlProlfile.GetMkqlProfiles();
@@ -206,46 +206,46 @@ public:
         }
     }
 
-    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record.GetRef();
+    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record.GetRef(); 
         SetCost(record.GetConsumedRu());
         AddServerHintsIfAny(record);
 
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-            const auto& kqpResponse = record.GetResponse();
-            const auto& issueMessage = kqpResponse.GetQueryIssues();
-
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+            const auto& kqpResponse = record.GetResponse(); 
+            const auto& issueMessage = kqpResponse.GetQueryIssues(); 
+ 
             auto queryResult = TEvExecuteDataQueryRequest::AllocateResult<Ydb::Table::ExecuteQueryResult>(Request_);
             ConvertKqpQueryResultsToDbResult(kqpResponse, queryResult);
             ConvertQueryStats(kqpResponse, queryResult);
-            if (kqpResponse.HasTxMeta()) {
-                queryResult->mutable_tx_meta()->CopyFrom(kqpResponse.GetTxMeta());
-            }
-            if (!kqpResponse.GetPreparedQuery().empty()) {
-                auto& queryMeta = *queryResult->mutable_query_meta();
-                Ydb::TOperationId opId;
-                opId.SetKind(TOperationId::PREPARED_QUERY_ID);
-                AddOptionalValue(opId, "id", kqpResponse.GetPreparedQuery());
-                queryMeta.set_id(ProtoToString(opId));
-
-                const auto& queryParameters = kqpResponse.GetQueryParameters();
-                for (const auto& queryParameter: queryParameters) {
-                    Ydb::Type parameterType;
-                    ConvertMiniKQLTypeToYdbType(queryParameter.GetType(), parameterType);
-                    queryMeta.mutable_parameters_types()->insert({queryParameter.GetName(), parameterType});
-                }
-            }
-
-            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, *queryResult, ctx);
-        } else {
+            if (kqpResponse.HasTxMeta()) { 
+                queryResult->mutable_tx_meta()->CopyFrom(kqpResponse.GetTxMeta()); 
+            } 
+            if (!kqpResponse.GetPreparedQuery().empty()) { 
+                auto& queryMeta = *queryResult->mutable_query_meta(); 
+                Ydb::TOperationId opId; 
+                opId.SetKind(TOperationId::PREPARED_QUERY_ID); 
+                AddOptionalValue(opId, "id", kqpResponse.GetPreparedQuery()); 
+                queryMeta.set_id(ProtoToString(opId)); 
+ 
+                const auto& queryParameters = kqpResponse.GetQueryParameters(); 
+                for (const auto& queryParameter: queryParameters) { 
+                    Ydb::Type parameterType; 
+                    ConvertMiniKQLTypeToYdbType(queryParameter.GetType(), parameterType); 
+                    queryMeta.mutable_parameters_types()->insert({queryParameter.GetName(), parameterType}); 
+                } 
+            } 
+ 
+            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, *queryResult, ctx); 
+        } else { 
             return OnQueryResponseErrorWithTxMeta(record, ctx);
-        }
-    }
-};
-
-void TGRpcRequestProxy::Handle(TEvExecuteDataQueryRequest::TPtr& ev, const TActorContext& ctx) {
-    ctx.Register(new TExecuteDataQueryRPC(ev->Release().Release()));
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+        } 
+    } 
+}; 
+ 
+void TGRpcRequestProxy::Handle(TEvExecuteDataQueryRequest::TPtr& ev, const TActorContext& ctx) { 
+    ctx.Register(new TExecuteDataQueryRPC(ev->Release().Release())); 
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_execute_scheme_query.cpp b/ydb/core/grpc_services/rpc_execute_scheme_query.cpp
index 6239bd7798..1e8872e3c1 100644
--- a/ydb/core/grpc_services/rpc_execute_scheme_query.cpp
+++ b/ydb/core/grpc_services/rpc_execute_scheme_query.cpp
@@ -1,100 +1,100 @@
-#include "grpc_request_proxy.h"
-
-#include "rpc_calls.h"
-#include "rpc_kqp_base.h"
+#include "grpc_request_proxy.h" 
+ 
+#include "rpc_calls.h" 
+#include "rpc_kqp_base.h" 
 #include "rpc_common.h"
-
+ 
 #include <ydb/core/protos/console_config.pb.h>
-
+ 
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
 #include <ydb/library/yql/public/issue/yql_issue.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-using namespace NActors;
-using namespace Ydb;
-using namespace NKqp;
-
-class TExecuteSchemeQueryRPC : public TRpcKqpRequestActor<TExecuteSchemeQueryRPC, TEvExecuteSchemeQueryRequest> {
-    using TBase = TRpcKqpRequestActor<TExecuteSchemeQueryRPC, TEvExecuteSchemeQueryRequest>;
-
-public:
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+using namespace NActors; 
+using namespace Ydb; 
+using namespace NKqp; 
+ 
+class TExecuteSchemeQueryRPC : public TRpcKqpRequestActor<TExecuteSchemeQueryRPC, TEvExecuteSchemeQueryRequest> { 
+    using TBase = TRpcKqpRequestActor<TExecuteSchemeQueryRPC, TEvExecuteSchemeQueryRequest>; 
+ 
+public: 
     TExecuteSchemeQueryRPC(IRequestOpCtx* msg)
-        : TBase(msg) {}
-
-    void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
-        this->Become(&TExecuteSchemeQueryRPC::StateWork);
-        Proceed(ctx);
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle);
-            default: TBase::StateWork(ev, ctx);
-        }
-    }
-
-    void Proceed(const TActorContext &ctx) {
+        : TBase(msg) {} 
+ 
+    void Bootstrap(const TActorContext &ctx) { 
+        TBase::Bootstrap(ctx); 
+ 
+        this->Become(&TExecuteSchemeQueryRPC::StateWork); 
+        Proceed(ctx); 
+    } 
+ 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle); 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
+    void Proceed(const TActorContext &ctx) { 
         const auto req = GetProtoRequest();
-        const auto traceId = Request_->GetTraceId();
-        const auto requestType = Request_->GetRequestType();
-
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
+        const auto traceId = Request_->GetTraceId(); 
+        const auto requestType = Request_->GetRequestType(); 
+ 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>(); 
         SetAuthToken(ev, *Request_);
         SetDatabase(ev, *Request_);
 
-        NYql::TIssues issues;
-        if (CheckSession(req->session_id(), issues)) {
-            ev->Record.MutableRequest()->SetSessionId(req->session_id());
-        } else {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
-        if (requestType) {
-            ev->Record.SetRequestType(requestType.GetRef());
-        }
-
-        if (!CheckQuery(req->yql_text(), issues)) {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
-        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DDL);
-        ev->Record.MutableRequest()->SetQuery(req->yql_text());
-
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
-    }
-
-    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record.GetRef();
+        NYql::TIssues issues; 
+        if (CheckSession(req->session_id(), issues)) { 
+            ev->Record.MutableRequest()->SetSessionId(req->session_id()); 
+        } else { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
+ 
+        if (requestType) { 
+            ev->Record.SetRequestType(requestType.GetRef()); 
+        } 
+ 
+        if (!CheckQuery(req->yql_text(), issues)) { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE); 
+        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DDL); 
+        ev->Record.MutableRequest()->SetQuery(req->yql_text()); 
+ 
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record.GetRef(); 
         AddServerHintsIfAny(record);
 
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-            const auto& kqpResponse = record.GetResponse();
-            const auto& issueMessage = kqpResponse.GetQueryIssues();
-
-            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, ctx);
-        } else {
-            return OnGenericQueryResponseError(record, ctx);
-        }
-    }
-};
-
-void TGRpcRequestProxy::Handle(TEvExecuteSchemeQueryRequest::TPtr& ev, const TActorContext& ctx) {
-    ctx.Register(new TExecuteSchemeQueryRPC(ev->Release().Release()));
-}
-
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+            const auto& kqpResponse = record.GetResponse(); 
+            const auto& issueMessage = kqpResponse.GetQueryIssues(); 
+ 
+            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, ctx); 
+        } else { 
+            return OnGenericQueryResponseError(record, ctx); 
+        } 
+    } 
+}; 
+ 
+void TGRpcRequestProxy::Handle(TEvExecuteSchemeQueryRequest::TPtr& ev, const TActorContext& ctx) { 
+    ctx.Register(new TExecuteSchemeQueryRPC(ev->Release().Release())); 
+} 
+ 
 template<>
 IActor* TEvExecuteSchemeQueryRequest::CreateRpcActor(NKikimr::NGRpcService::IRequestOpCtx* msg) {
     return new TExecuteSchemeQueryRPC(msg);
 }
 
-} // namespace NGRpcService
-} // namespace NKikimr
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_execute_yql_script.cpp b/ydb/core/grpc_services/rpc_execute_yql_script.cpp
index 2650d32df5..82e08c7eea 100644
--- a/ydb/core/grpc_services/rpc_execute_yql_script.cpp
+++ b/ydb/core/grpc_services/rpc_execute_yql_script.cpp
@@ -1,117 +1,117 @@
 #include "service_yql_scripting.h"
-#include "rpc_kqp_base.h"
-#include "rpc_common.h"
-
+#include "rpc_kqp_base.h" 
+#include "rpc_common.h" 
+ 
 #include <ydb/public/api/protos/ydb_scripting.pb.h>
 
-namespace NKikimr {
-namespace NGRpcService {
-
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
 using Ydb::Scripting::ExecuteYqlRequest;
 using Ydb::Scripting::ExecuteYqlResponse;
 using TEvExecuteYqlScriptRequest = TGrpcRequestOperationCall<ExecuteYqlRequest, ExecuteYqlResponse>;
 
-using namespace Ydb;
-
-class TExecuteYqlScriptRPC : public TRpcKqpRequestActor<TExecuteYqlScriptRPC, TEvExecuteYqlScriptRequest> {
-    using TBase = TRpcKqpRequestActor<TExecuteYqlScriptRPC, TEvExecuteYqlScriptRequest>;
-
-public:
-    using TResult = Ydb::Scripting::ExecuteYqlResult;
-
+using namespace Ydb; 
+ 
+class TExecuteYqlScriptRPC : public TRpcKqpRequestActor<TExecuteYqlScriptRPC, TEvExecuteYqlScriptRequest> { 
+    using TBase = TRpcKqpRequestActor<TExecuteYqlScriptRPC, TEvExecuteYqlScriptRequest>; 
+ 
+public: 
+    using TResult = Ydb::Scripting::ExecuteYqlResult; 
+ 
     TExecuteYqlScriptRPC(IRequestOpCtx* msg)
-        : TBase(msg) {}
-
-    void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
-        this->Become(&TExecuteYqlScriptRPC::StateWork);
-        Proceed(ctx);
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle);
-            default: TBase::StateWork(ev, ctx);
-        }
-    }
-
-    void Proceed(const TActorContext &ctx) {
+        : TBase(msg) {} 
+ 
+    void Bootstrap(const TActorContext &ctx) { 
+        TBase::Bootstrap(ctx); 
+ 
+        this->Become(&TExecuteYqlScriptRPC::StateWork); 
+        Proceed(ctx); 
+    } 
+ 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle); 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
+    void Proceed(const TActorContext &ctx) { 
         const auto req = GetProtoRequest();
-        const auto traceId = Request_->GetTraceId();
-
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
-        SetAuthToken(ev, *Request_);
-        SetDatabase(ev, *Request_);
-
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
-        ev->Record.MutableRequest()->SetCancelAfterMs(GetCancelAfter().MilliSeconds());
-        ev->Record.MutableRequest()->SetTimeoutMs(GetOperationTimeout().MilliSeconds());
-
-        if (req->parametersSize() != 0) {
-            try {
-                NKikimrMiniKQL::TParams params;
-                ConvertYdbParamsToMiniKQLParams(req->parameters(), params);
-                ev->Record.MutableRequest()->MutableParameters()->CopyFrom(params);
-            } catch (const std::exception& ex) {
-                NYql::TIssue issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, TStringBuilder()
-                    << "Failed to parse script parameters.");
-                issue.AddSubIssue(MakeIntrusive<NYql::TIssue>(NYql::ExceptionToIssue(ex)));
-
-                NYql::TIssues issues;
-                issues.AddIssue(issue);
-
-                return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-            }
-        }
-
-        auto& script = req->script();
-
-        NYql::TIssues issues;
-        if (!CheckQuery(script, issues)) {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
-        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_SCRIPT);
-        ev->Record.MutableRequest()->SetQuery(script);
-        ev->Record.MutableRequest()->SetKeepSession(false);
-        ev->Record.MutableRequest()->SetStatsMode(GetKqpStatsMode(req->collect_stats()));
-
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
-    }
-
-    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record.GetRef();
+        const auto traceId = Request_->GetTraceId(); 
+ 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>(); 
+        SetAuthToken(ev, *Request_); 
+        SetDatabase(ev, *Request_); 
+ 
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetCancelAfterMs(GetCancelAfter().MilliSeconds()); 
+        ev->Record.MutableRequest()->SetTimeoutMs(GetOperationTimeout().MilliSeconds()); 
+ 
+        if (req->parametersSize() != 0) { 
+            try { 
+                NKikimrMiniKQL::TParams params; 
+                ConvertYdbParamsToMiniKQLParams(req->parameters(), params); 
+                ev->Record.MutableRequest()->MutableParameters()->CopyFrom(params); 
+            } catch (const std::exception& ex) { 
+                NYql::TIssue issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, TStringBuilder() 
+                    << "Failed to parse script parameters."); 
+                issue.AddSubIssue(MakeIntrusive<NYql::TIssue>(NYql::ExceptionToIssue(ex))); 
+ 
+                NYql::TIssues issues; 
+                issues.AddIssue(issue); 
+ 
+                return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+            } 
+        } 
+ 
+        auto& script = req->script(); 
+ 
+        NYql::TIssues issues; 
+        if (!CheckQuery(script, issues)) { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE); 
+        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_SCRIPT); 
+        ev->Record.MutableRequest()->SetQuery(script); 
+        ev->Record.MutableRequest()->SetKeepSession(false); 
+        ev->Record.MutableRequest()->SetStatsMode(GetKqpStatsMode(req->collect_stats())); 
+ 
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record.GetRef(); 
         SetCost(record.GetConsumedRu());
         AddServerHintsIfAny(record);
-
-        if (record.GetYdbStatus() != Ydb::StatusIds::SUCCESS) {
-            return OnGenericQueryResponseError(record, ctx);
-        }
-
-        const auto& kqpResponse = record.GetResponse();
-        const auto& issueMessage = kqpResponse.GetQueryIssues();
-
+ 
+        if (record.GetYdbStatus() != Ydb::StatusIds::SUCCESS) { 
+            return OnGenericQueryResponseError(record, ctx); 
+        } 
+ 
+        const auto& kqpResponse = record.GetResponse(); 
+        const auto& issueMessage = kqpResponse.GetQueryIssues(); 
+ 
         auto queryResult = TEvExecuteYqlScriptRequest::AllocateResult<TResult>(Request_);
         ConvertKqpQueryResultsToDbResult(kqpResponse, queryResult);
-
-        if (kqpResponse.HasQueryStats()) {
+ 
+        if (kqpResponse.HasQueryStats()) { 
             FillQueryStats(*queryResult->mutable_query_stats(), kqpResponse);
         } else if (kqpResponse.HasQueryPlan()) {
             queryResult->mutable_query_stats()->set_query_plan(kqpResponse.GetQueryPlan());
-        }
-
-        ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, *queryResult, ctx);
-    }
-};
-
+        } 
+ 
+        ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, *queryResult, ctx); 
+    } 
+}; 
+ 
 void DoExecuteYqlScript(std::unique_ptr<IRequestOpCtx> p, const IFacilityProvider&) {
     TActivationContext::AsActorContext().Register(new TExecuteYqlScriptRPC(p.release()));
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_explain_data_query.cpp b/ydb/core/grpc_services/rpc_explain_data_query.cpp
index cc42fb9235..9115646643 100644
--- a/ydb/core/grpc_services/rpc_explain_data_query.cpp
+++ b/ydb/core/grpc_services/rpc_explain_data_query.cpp
@@ -1,95 +1,95 @@
-#include "grpc_request_proxy.h"
-
-#include "rpc_calls.h"
-#include "rpc_kqp_base.h"
+#include "grpc_request_proxy.h" 
+ 
+#include "rpc_calls.h" 
+#include "rpc_kqp_base.h" 
 #include "rpc_common.h"
-
+ 
 #include <ydb/core/protos/console_config.pb.h>
-
+ 
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
 #include <ydb/library/yql/public/issue/yql_issue.h>
 #include <google/protobuf/text_format.h>
 #include <library/cpp/yson/writer.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-using namespace NActors;
-using namespace Ydb;
-using namespace NKqp;
-
-class TExplainDataQueryRPC : public TRpcKqpRequestActor<TExplainDataQueryRPC, TEvExplainDataQueryRequest> {
-    using TBase = TRpcKqpRequestActor<TExplainDataQueryRPC, TEvExplainDataQueryRequest>;
-
-public:
-    TExplainDataQueryRPC(TEvExplainDataQueryRequest* msg)
-        : TBase(msg) {}
-
-    void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
-        this->Become(&TExplainDataQueryRPC::StateWork);
-        Proceed(ctx);
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle);
-            default: TBase::StateWork(ev, ctx);
-        }
-    }
-
-    void Proceed(const TActorContext &ctx) {
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+using namespace NActors; 
+using namespace Ydb; 
+using namespace NKqp; 
+ 
+class TExplainDataQueryRPC : public TRpcKqpRequestActor<TExplainDataQueryRPC, TEvExplainDataQueryRequest> { 
+    using TBase = TRpcKqpRequestActor<TExplainDataQueryRPC, TEvExplainDataQueryRequest>; 
+ 
+public: 
+    TExplainDataQueryRPC(TEvExplainDataQueryRequest* msg) 
+        : TBase(msg) {} 
+ 
+    void Bootstrap(const TActorContext &ctx) { 
+        TBase::Bootstrap(ctx); 
+ 
+        this->Become(&TExplainDataQueryRPC::StateWork); 
+        Proceed(ctx); 
+    } 
+ 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle); 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
+    void Proceed(const TActorContext &ctx) { 
         const auto req = GetProtoRequest();
-        const auto traceId = Request_->GetTraceId();
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
+        const auto traceId = Request_->GetTraceId(); 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>(); 
         SetAuthToken(ev, *Request_);
         SetDatabase(ev, *Request_);
 
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
-        NYql::TIssues issues;
-        if (CheckSession(req->session_id(), issues)) {
-            ev->Record.MutableRequest()->SetSessionId(req->session_id());
-        } else {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        if (!CheckQuery(req->yql_text(), issues)) {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXPLAIN);
-        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DML);
-        ev->Record.MutableRequest()->SetQuery(req->yql_text());
-
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
-    }
-
-    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record.GetRef();
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
+ 
+        NYql::TIssues issues; 
+        if (CheckSession(req->session_id(), issues)) { 
+            ev->Record.MutableRequest()->SetSessionId(req->session_id()); 
+        } else { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        if (!CheckQuery(req->yql_text(), issues)) { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXPLAIN); 
+        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DML); 
+        ev->Record.MutableRequest()->SetQuery(req->yql_text()); 
+ 
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record.GetRef(); 
         AddServerHintsIfAny(record);
 
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-            const auto& kqpResponse = record.GetResponse();
-            const auto& issueMessage = kqpResponse.GetQueryIssues();
-
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+            const auto& kqpResponse = record.GetResponse(); 
+            const auto& issueMessage = kqpResponse.GetQueryIssues(); 
+ 
             Ydb::Table::ExplainQueryResult queryResult;
-            queryResult.set_query_ast(kqpResponse.GetQueryAst());
-            queryResult.set_query_plan(kqpResponse.GetQueryPlan());
-
-            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, queryResult, ctx);
-        } else {
-            return OnGenericQueryResponseError(record, ctx);
-        }
-    }
-};
-
-void TGRpcRequestProxy::Handle(TEvExplainDataQueryRequest::TPtr& ev, const TActorContext& ctx) {
-    ctx.Register(new TExplainDataQueryRPC(ev->Release().Release()));
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+            queryResult.set_query_ast(kqpResponse.GetQueryAst()); 
+            queryResult.set_query_plan(kqpResponse.GetQueryPlan()); 
+ 
+            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, queryResult, ctx); 
+        } else { 
+            return OnGenericQueryResponseError(record, ctx); 
+        } 
+    } 
+}; 
+ 
+void TGRpcRequestProxy::Handle(TEvExplainDataQueryRequest::TPtr& ev, const TActorContext& ctx) { 
+    ctx.Register(new TExplainDataQueryRPC(ev->Release().Release())); 
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_get_operation.cpp b/ydb/core/grpc_services/rpc_get_operation.cpp
index 6f7a140686..c50a167400 100644
--- a/ydb/core/grpc_services/rpc_get_operation.cpp
+++ b/ydb/core/grpc_services/rpc_get_operation.cpp
@@ -25,7 +25,7 @@ namespace NGRpcService {
 
 using namespace NActors;
 using namespace NOperationId;
-using namespace Ydb;
+using namespace Ydb; 
 
 class TGetOperationRPC : public TRpcOperationRequestActor<TGetOperationRPC, TEvGetOperationRequest, true>,
                          public TExportConv {
diff --git a/ydb/core/grpc_services/rpc_keep_alive.cpp b/ydb/core/grpc_services/rpc_keep_alive.cpp
index e4188c8ab9..a2bbd47ee6 100644
--- a/ydb/core/grpc_services/rpc_keep_alive.cpp
+++ b/ydb/core/grpc_services/rpc_keep_alive.cpp
@@ -11,28 +11,28 @@ namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
+using namespace Ydb; 
 using namespace NKqp;
 
-class TKeepAliveRPC : public TRpcKqpRequestActor<TKeepAliveRPC, TEvKeepAliveRequest> {
-    using TBase = TRpcKqpRequestActor<TKeepAliveRPC, TEvKeepAliveRequest>;
-
+class TKeepAliveRPC : public TRpcKqpRequestActor<TKeepAliveRPC, TEvKeepAliveRequest> { 
+    using TBase = TRpcKqpRequestActor<TKeepAliveRPC, TEvKeepAliveRequest>; 
+ 
 public:
     TKeepAliveRPC(TEvKeepAliveRequest* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext& ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         KeepAliveImpl(ctx);
         Become(&TKeepAliveRPC::StateWork);
     }
 private:
     void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
         switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle);
-            HFunc(NKqp::TEvKqp::TEvPingSessionResponse, Handle);
-            default: TBase::StateWork(ev, ctx);
+            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle); 
+            HFunc(NKqp::TEvKqp::TEvPingSessionResponse, Handle); 
+            default: TBase::StateWork(ev, ctx); 
         }
     }
 
@@ -40,13 +40,13 @@ private:
         const auto req = GetProtoRequest();
         const auto traceId = Request_->GetTraceId();
 
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvPingSessionRequest>();
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvPingSessionRequest>(); 
 
-        NYql::TIssues issues;
-        if (CheckSession(req->session_id(), issues)) {
-            ev->Record.MutableRequest()->SetSessionId(req->session_id());
+        NYql::TIssues issues; 
+        if (CheckSession(req->session_id(), issues)) { 
+            ev->Record.MutableRequest()->SetSessionId(req->session_id()); 
         } else {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
         }
 
         if (traceId) {
@@ -54,35 +54,35 @@ private:
         }
 
         ev->Record.MutableRequest()->SetTimeoutMs(GetOperationTimeout().MilliSeconds());
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
     }
 
-    void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record;
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-            Ydb::Table::KeepAliveResult result;
-            ReplyWithResult(Ydb::StatusIds::SUCCESS, result, ctx);
-        } else {
-            return OnProcessError(record, ctx);
-        }
-    }
-
-    void Handle(NKqp::TEvKqp::TEvPingSessionResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record;
-
-        if (record.GetStatus() == Ydb::StatusIds::SUCCESS) {
-            Ydb::Table::KeepAliveResult result;
-            result.set_session_status(record.GetResponse().GetSessionStatus());
-            ReplyWithResult(Ydb::StatusIds::SUCCESS, result, ctx);
+    void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record; 
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+            Ydb::Table::KeepAliveResult result; 
+            ReplyWithResult(Ydb::StatusIds::SUCCESS, result, ctx); 
         } else {
-            OnKqpError(record, ctx);
+            return OnProcessError(record, ctx); 
         }
     }
 
-    void ReplyWithResult(StatusIds::StatusCode status, const Ydb::Table::KeepAliveResult& result,
-        const TActorContext& ctx)
-    {
-        Request().SendResult(result, status);
+    void Handle(NKqp::TEvKqp::TEvPingSessionResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record; 
+ 
+        if (record.GetStatus() == Ydb::StatusIds::SUCCESS) { 
+            Ydb::Table::KeepAliveResult result; 
+            result.set_session_status(record.GetResponse().GetSessionStatus()); 
+            ReplyWithResult(Ydb::StatusIds::SUCCESS, result, ctx); 
+        } else { 
+            OnKqpError(record, ctx); 
+        } 
+    } 
+ 
+    void ReplyWithResult(StatusIds::StatusCode status, const Ydb::Table::KeepAliveResult& result, 
+        const TActorContext& ctx) 
+    { 
+        Request().SendResult(result, status); 
         Die(ctx);
     }
 };
diff --git a/ydb/core/grpc_services/rpc_kqp_base.cpp b/ydb/core/grpc_services/rpc_kqp_base.cpp
index 414543f574..4c3e9cde37 100644
--- a/ydb/core/grpc_services/rpc_kqp_base.cpp
+++ b/ydb/core/grpc_services/rpc_kqp_base.cpp
@@ -1,48 +1,48 @@
 #include "rpc_kqp_base.h"
-
+ 
 #include <ydb/core/kqp/prepare/kqp_query_plan.h>
 
-namespace NKikimr {
-namespace NGRpcService {
-
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
 void FillQueryStats(Ydb::TableStats::QueryStats& queryStats, const NKikimrKqp::TQueryResponse& kqpResponse) {
     const auto& kqpStats = kqpResponse.GetQueryStats();
 
     uint64_t totalCpuTimeUs = 0;
     uint64_t totalDurationUs = 0;
 
-    for (auto& exec : kqpStats.GetExecutions()) {
+    for (auto& exec : kqpStats.GetExecutions()) { 
         auto durationUs = exec.GetDurationUs();
         auto cpuTimeUs = exec.GetCpuTimeUs();
 
         totalDurationUs += durationUs;
         totalCpuTimeUs += cpuTimeUs;
 
-        auto& toPhase = *queryStats.add_query_phases();
+        auto& toPhase = *queryStats.add_query_phases(); 
         toPhase.set_duration_us(durationUs);
         toPhase.set_cpu_time_us(cpuTimeUs);
-
-        for (auto& table : exec.GetTables()) {
-            auto& toTable = *toPhase.add_table_access();
-            toTable.set_name(table.GetTablePath());
-
-            if (table.GetReadRows() > 0) {
-                toTable.mutable_reads()->set_rows(table.GetReadRows());
-                toTable.mutable_reads()->set_bytes(table.GetReadBytes());
-            }
-
-            if (table.GetWriteRows() > 0) {
-                toTable.mutable_updates()->set_rows(table.GetWriteRows());
-                toTable.mutable_updates()->set_bytes(table.GetWriteBytes());
-            }
-
-            if (table.GetEraseRows() > 0) {
-                toTable.mutable_deletes()->set_rows(table.GetEraseRows());
-            }
-
-            toTable.set_partitions_count(table.GetAffectedPartitions());
-        }
-
+ 
+        for (auto& table : exec.GetTables()) { 
+            auto& toTable = *toPhase.add_table_access(); 
+            toTable.set_name(table.GetTablePath()); 
+ 
+            if (table.GetReadRows() > 0) { 
+                toTable.mutable_reads()->set_rows(table.GetReadRows()); 
+                toTable.mutable_reads()->set_bytes(table.GetReadBytes()); 
+            } 
+ 
+            if (table.GetWriteRows() > 0) { 
+                toTable.mutable_updates()->set_rows(table.GetWriteRows()); 
+                toTable.mutable_updates()->set_bytes(table.GetWriteBytes()); 
+            } 
+ 
+            if (table.GetEraseRows() > 0) { 
+                toTable.mutable_deletes()->set_rows(table.GetEraseRows()); 
+            } 
+ 
+            toTable.set_partitions_count(table.GetAffectedPartitions()); 
+        } 
+ 
         std::sort(toPhase.mutable_table_access()->begin(), toPhase.mutable_table_access()->end(),
             [](const Ydb::TableStats::TableAccessStats& a, const Ydb::TableStats::TableAccessStats& b) {
                 return a.name() < b.name();
@@ -52,22 +52,22 @@ void FillQueryStats(Ydb::TableStats::QueryStats& queryStats, const NKikimrKqp::T
         if (exec.HasExtra() && exec.GetExtra().UnpackTo(&executionExtraStats)) {
             toPhase.set_affected_shards(executionExtraStats.GetAffectedShards());
         }
-    }
-
-    if (kqpStats.HasCompilation()) {
-        auto& compilation = kqpStats.GetCompilation();
-        auto& toCompilation = *queryStats.mutable_compilation();
-        toCompilation.set_from_cache(compilation.GetFromCache());
-        toCompilation.set_duration_us(compilation.GetDurationUs());
-        toCompilation.set_cpu_time_us(compilation.GetCpuTimeUs());
-    }
-
-    queryStats.set_process_cpu_time_us(kqpStats.GetWorkerCpuTimeUs());
+    } 
+ 
+    if (kqpStats.HasCompilation()) { 
+        auto& compilation = kqpStats.GetCompilation(); 
+        auto& toCompilation = *queryStats.mutable_compilation(); 
+        toCompilation.set_from_cache(compilation.GetFromCache()); 
+        toCompilation.set_duration_us(compilation.GetDurationUs()); 
+        toCompilation.set_cpu_time_us(compilation.GetCpuTimeUs()); 
+    } 
+ 
+    queryStats.set_process_cpu_time_us(kqpStats.GetWorkerCpuTimeUs()); 
     queryStats.set_total_cpu_time_us(totalCpuTimeUs);
     queryStats.set_total_duration_us(totalDurationUs);
 
     queryStats.set_query_plan(kqpResponse.GetQueryPlan());
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_kqp_base.h b/ydb/core/grpc_services/rpc_kqp_base.h
index 2811a49e78..3073682dd5 100644
--- a/ydb/core/grpc_services/rpc_kqp_base.h
+++ b/ydb/core/grpc_services/rpc_kqp_base.h
@@ -28,50 +28,50 @@ inline TString DecodePreparedQueryId(const TString& in) {
     return *ids[0];
 }
 
-inline TString GetTransactionModeName(const Ydb::Table::TransactionSettings& settings) {
-    switch (settings.tx_mode_case()) {
-        case Ydb::Table::TransactionSettings::kSerializableReadWrite:
-            return "SerializableReadWrite";
-        case Ydb::Table::TransactionSettings::kOnlineReadOnly:
-            return "OnlineReadOnly";
-        case Ydb::Table::TransactionSettings::kStaleReadOnly:
-            return "StaleReadOnly";
-        default:
-            return "Unknown";
-    }
-}
-
+inline TString GetTransactionModeName(const Ydb::Table::TransactionSettings& settings) { 
+    switch (settings.tx_mode_case()) { 
+        case Ydb::Table::TransactionSettings::kSerializableReadWrite: 
+            return "SerializableReadWrite"; 
+        case Ydb::Table::TransactionSettings::kOnlineReadOnly: 
+            return "OnlineReadOnly"; 
+        case Ydb::Table::TransactionSettings::kStaleReadOnly: 
+            return "StaleReadOnly"; 
+        default: 
+            return "Unknown"; 
+    } 
+} 
+ 
 inline NYql::NDqProto::EDqStatsMode GetKqpStatsMode(Ydb::Table::QueryStatsCollection::Mode mode) {
-    switch (mode) {
-        case Ydb::Table::QueryStatsCollection::STATS_COLLECTION_BASIC:
+    switch (mode) { 
+        case Ydb::Table::QueryStatsCollection::STATS_COLLECTION_BASIC: 
             return NYql::NDqProto::DQ_STATS_MODE_BASIC;
         case Ydb::Table::QueryStatsCollection::STATS_COLLECTION_FULL:
             return NYql::NDqProto::DQ_STATS_MODE_PROFILE;
-        default:
+        default: 
             return NYql::NDqProto::DQ_STATS_MODE_NONE;
-    }
-}
-
-inline bool CheckSession(const TString& sessionId, NYql::TIssues& issues) {
-    if (sessionId.empty()) {
-        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty session id"));
-        return false;
-    }
-
-    return true;
-}
-
-inline bool CheckQuery(const TString& query, NYql::TIssues& issues) {
-    if (query.empty()) {
-        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty query text"));
-        return false;
-    }
-
-    return true;
-}
-
+    } 
+} 
+ 
+inline bool CheckSession(const TString& sessionId, NYql::TIssues& issues) { 
+    if (sessionId.empty()) { 
+        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty session id")); 
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
+inline bool CheckQuery(const TString& query, NYql::TIssues& issues) { 
+    if (query.empty()) { 
+        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty query text")); 
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
 void FillQueryStats(Ydb::TableStats::QueryStats& queryStats, const NKikimrKqp::TQueryResponse& kqpResponse);
-
+ 
 inline void ConvertKqpQueryResultToDbResult(const NKikimrMiniKQL::TResult& from, Ydb::ResultSet* to) {
     const auto& type = from.GetType();
     TStackVec<NKikimrMiniKQL::TType> columnTypes;
@@ -111,25 +111,25 @@ inline void ConvertKqpQueryResultsToDbResult(const TFrom& from, TTo* to) {
 }
 
 template <typename TDerived, typename TRequest>
-class TRpcKqpRequestActor : public TRpcOperationRequestActor<TDerived, TRequest> {
-    using TBase = TRpcOperationRequestActor<TDerived, TRequest>;
+class TRpcKqpRequestActor : public TRpcOperationRequestActor<TDerived, TRequest> { 
+    using TBase = TRpcOperationRequestActor<TDerived, TRequest>; 
 
-public:
+public: 
     TRpcKqpRequestActor(IRequestOpCtx* request)
-        : TBase(request) {}
-
-    void OnOperationTimeout(const TActorContext& ctx) {
-        Y_UNUSED(ctx);
-    }
-
+        : TBase(request) {} 
+ 
+    void OnOperationTimeout(const TActorContext& ctx) { 
+        Y_UNUSED(ctx); 
+    } 
+ 
 protected:
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle);
-            default: TBase::StateFuncBase(ev, ctx);
-        }
-    }
-
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle); 
+            default: TBase::StateFuncBase(ev, ctx); 
+        } 
+    } 
+ 
     template<typename TKqpResponse>
     void AddServerHintsIfAny(const TKqpResponse& kqpResponse) {
         if (kqpResponse.GetWorkerIsClosing()) {
@@ -138,73 +138,73 @@ protected:
     }
 
     template<typename TKqpResponse>
-    void OnGenericQueryResponseError(const TKqpResponse& kqpResponse, const TActorContext& ctx) {
+    void OnGenericQueryResponseError(const TKqpResponse& kqpResponse, const TActorContext& ctx) { 
         RaiseIssuesFromKqp(kqpResponse);
-
+ 
         this->Request_->ReplyWithYdbStatus(kqpResponse.GetYdbStatus());
         this->Die(ctx);
     }
 
     template<typename TKqpResponse>
-    void OnQueryResponseErrorWithTxMeta(const TKqpResponse& kqpResponse, const TActorContext& ctx) {
+    void OnQueryResponseErrorWithTxMeta(const TKqpResponse& kqpResponse, const TActorContext& ctx) { 
         RaiseIssuesFromKqp(kqpResponse);
 
         auto queryResult = TRequest::template AllocateResult<typename TDerived::TResult>(this->Request_);
-        if (kqpResponse.GetResponse().HasTxMeta()) {
-            queryResult->mutable_tx_meta()->CopyFrom(kqpResponse.GetResponse().GetTxMeta());
-        }
-
+        if (kqpResponse.GetResponse().HasTxMeta()) { 
+            queryResult->mutable_tx_meta()->CopyFrom(kqpResponse.GetResponse().GetTxMeta()); 
+        } 
+ 
         this->Request_->SendResult(*queryResult, kqpResponse.GetYdbStatus());
-        this->Die(ctx);
+        this->Die(ctx); 
     }
 
-    void OnQueryResponseError(const NKikimrKqp::TEvCreateSessionResponse& kqpResponse, const TActorContext& ctx) {
-        if (kqpResponse.HasError()) {
+    void OnQueryResponseError(const NKikimrKqp::TEvCreateSessionResponse& kqpResponse, const TActorContext& ctx) { 
+        if (kqpResponse.HasError()) { 
             NYql::TIssues issues;
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, kqpResponse.GetError()));
-            return this->Reply(kqpResponse.GetYdbStatus(), issues, ctx);
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, kqpResponse.GetError())); 
+            return this->Reply(kqpResponse.GetYdbStatus(), issues, ctx); 
         } else {
-            return this->Reply(kqpResponse.GetYdbStatus(), ctx);
+            return this->Reply(kqpResponse.GetYdbStatus(), ctx); 
         }
     }
 
-    template<typename TKqpResponse>
-    void OnKqpError(const TKqpResponse& response, const TActorContext& ctx) {
-        NYql::TIssues issues;
-        NYql::IssuesFromMessage(response.GetIssues(), issues);
-
-        this->Request_->RaiseIssues(issues);
+    template<typename TKqpResponse> 
+    void OnKqpError(const TKqpResponse& response, const TActorContext& ctx) { 
+        NYql::TIssues issues; 
+        NYql::IssuesFromMessage(response.GetIssues(), issues); 
+ 
+        this->Request_->RaiseIssues(issues); 
         this->Request_->ReplyWithYdbStatus(response.GetStatus());
-        this->Die(ctx);
-    }
-
-    void OnProcessError(const NKikimrKqp::TEvProcessResponse& kqpResponse, const TActorContext& ctx) {
-        if (kqpResponse.HasError()) {
-            NYql::TIssues issues;
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, kqpResponse.GetError()));
-            return this->Reply(kqpResponse.GetYdbStatus(), issues, ctx);
-        } else {
-            return this->Reply(kqpResponse.GetYdbStatus(), ctx);
-        }
-    }
-
-private:
+        this->Die(ctx); 
+    } 
+ 
+    void OnProcessError(const NKikimrKqp::TEvProcessResponse& kqpResponse, const TActorContext& ctx) { 
+        if (kqpResponse.HasError()) { 
+            NYql::TIssues issues; 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, kqpResponse.GetError())); 
+            return this->Reply(kqpResponse.GetYdbStatus(), issues, ctx); 
+        } else { 
+            return this->Reply(kqpResponse.GetYdbStatus(), ctx); 
+        } 
+    } 
+ 
+private: 
     void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) {
         auto& record = ev->Get()->Record;
         NYql::TIssues issues;
-        if (record.HasError()) {
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, record.GetError()));
+        if (record.HasError()) { 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, record.GetError())); 
         }
         return this->Reply(record.GetYdbStatus(), issues, ctx);
     }
-
+ 
 private:
     template<typename TKqpResponse>
     void RaiseIssuesFromKqp(const TKqpResponse& kqpResponse) {
-        NYql::TIssues issues;
-        const auto& issueMessage = kqpResponse.GetResponse().GetQueryIssues();
-        NYql::IssuesFromMessage(issueMessage, issues);
-        this->Request_->RaiseIssues(issues);
+        NYql::TIssues issues; 
+        const auto& issueMessage = kqpResponse.GetResponse().GetQueryIssues(); 
+        NYql::IssuesFromMessage(issueMessage, issues); 
+        this->Request_->RaiseIssues(issues); 
     }
 };
 
diff --git a/ydb/core/grpc_services/rpc_make_directory.cpp b/ydb/core/grpc_services/rpc_make_directory.cpp
index f6e6b2d0cd..2aabc80111 100644
--- a/ydb/core/grpc_services/rpc_make_directory.cpp
+++ b/ydb/core/grpc_services/rpc_make_directory.cpp
@@ -1,6 +1,6 @@
 #include "service_scheme.h"
 
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 #include <ydb/core/grpc_services/base/base.h>
 #include <ydb/core/protos/flat_tx_scheme.pb.h>
@@ -10,21 +10,21 @@ namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
+using namespace Ydb; 
 
 using TEvMakeDirectoryRequest = TGrpcRequestOperationCall<Ydb::Scheme::MakeDirectoryRequest,
     Ydb::Scheme::MakeDirectoryResponse>;
 
-class TMakeDirectoryRPC : public TRpcSchemeRequestActor<TMakeDirectoryRPC, TEvMakeDirectoryRequest> {
-    using TBase = TRpcSchemeRequestActor<TMakeDirectoryRPC, TEvMakeDirectoryRequest>;
-
+class TMakeDirectoryRPC : public TRpcSchemeRequestActor<TMakeDirectoryRPC, TEvMakeDirectoryRequest> { 
+    using TBase = TRpcSchemeRequestActor<TMakeDirectoryRPC, TEvMakeDirectoryRequest>; 
+ 
 public:
     TMakeDirectoryRPC(IRequestOpCtx* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         Become(&TMakeDirectoryRPC::StateWork);
     }
diff --git a/ydb/core/grpc_services/rpc_modify_permissions.cpp b/ydb/core/grpc_services/rpc_modify_permissions.cpp
index d9b01887d2..f9abc5db0f 100644
--- a/ydb/core/grpc_services/rpc_modify_permissions.cpp
+++ b/ydb/core/grpc_services/rpc_modify_permissions.cpp
@@ -1,6 +1,6 @@
 #include "service_scheme.h"
 
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 #include <ydb/core/protos/flat_tx_scheme.pb.h>
 #include <ydb/core/tx/schemeshard/schemeshard.h>
@@ -12,21 +12,21 @@ namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
+using namespace Ydb; 
 
 using TEvModifyPermissionsRequest = TGrpcRequestOperationCall<Ydb::Scheme::ModifyPermissionsRequest,
     Ydb::Scheme::ModifyPermissionsResponse>;
 
-class TModifyPermissionsRPC : public TRpcSchemeRequestActor<TModifyPermissionsRPC, TEvModifyPermissionsRequest> {
-    using TBase = TRpcSchemeRequestActor<TModifyPermissionsRPC, TEvModifyPermissionsRequest>;
-
+class TModifyPermissionsRPC : public TRpcSchemeRequestActor<TModifyPermissionsRPC, TEvModifyPermissionsRequest> { 
+    using TBase = TRpcSchemeRequestActor<TModifyPermissionsRPC, TEvModifyPermissionsRequest>; 
+ 
 public:
     TModifyPermissionsRPC(IRequestOpCtx* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         try {
             SendRequest(ctx);
         } catch (const std::exception& ex) {
diff --git a/ydb/core/grpc_services/rpc_prepare_data_query.cpp b/ydb/core/grpc_services/rpc_prepare_data_query.cpp
index eb4c571877..a3f87ee1a7 100644
--- a/ydb/core/grpc_services/rpc_prepare_data_query.cpp
+++ b/ydb/core/grpc_services/rpc_prepare_data_query.cpp
@@ -1,112 +1,112 @@
-#include "grpc_request_proxy.h"
-
-#include "rpc_calls.h"
-#include "rpc_kqp_base.h"
+#include "grpc_request_proxy.h" 
+ 
+#include "rpc_calls.h" 
+#include "rpc_kqp_base.h" 
 #include "rpc_common.h"
-
+ 
 #include <ydb/core/protos/console_config.pb.h>
 #include <ydb/core/ydb_convert/ydb_convert.h>
 #include <ydb/public/lib/operation_id/operation_id.h>
-
+ 
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
 #include <ydb/library/yql/public/issue/yql_issue.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-using namespace NActors;
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+using namespace NActors; 
 using namespace NOperationId;
-using namespace Ydb;
-using namespace NKqp;
-
-class TPrepareDataQueryRPC : public TRpcKqpRequestActor<TPrepareDataQueryRPC, TEvPrepareDataQueryRequest> {
-    using TBase = TRpcKqpRequestActor<TPrepareDataQueryRPC, TEvPrepareDataQueryRequest>;
-
-public:
-    TPrepareDataQueryRPC(TEvPrepareDataQueryRequest* msg)
-        : TBase(msg) {}
-
-    void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
-        this->Become(&TPrepareDataQueryRPC::StateWork);
-        Proceed(ctx);
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle);
-            default: TBase::StateWork(ev, ctx);
-        }
-    }
-
-    void Proceed(const TActorContext &ctx) {
+using namespace Ydb; 
+using namespace NKqp; 
+ 
+class TPrepareDataQueryRPC : public TRpcKqpRequestActor<TPrepareDataQueryRPC, TEvPrepareDataQueryRequest> { 
+    using TBase = TRpcKqpRequestActor<TPrepareDataQueryRPC, TEvPrepareDataQueryRequest>; 
+ 
+public: 
+    TPrepareDataQueryRPC(TEvPrepareDataQueryRequest* msg) 
+        : TBase(msg) {} 
+ 
+    void Bootstrap(const TActorContext &ctx) { 
+        TBase::Bootstrap(ctx); 
+ 
+        this->Become(&TPrepareDataQueryRPC::StateWork); 
+        Proceed(ctx); 
+    } 
+ 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle); 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
+    void Proceed(const TActorContext &ctx) { 
         const auto req = GetProtoRequest();
-        const auto traceId = Request_->GetTraceId();
+        const auto traceId = Request_->GetTraceId(); 
         const auto requestType = Request_->GetRequestType();
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>(); 
         SetAuthToken(ev, *Request_);
         SetDatabase(ev, *Request_);
 
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
+ 
         if (requestType) {
             ev->Record.SetRequestType(requestType.GetRef());
         }
 
-        NYql::TIssues issues;
-        if (CheckSession(req->session_id(), issues)) {
-            ev->Record.MutableRequest()->SetSessionId(req->session_id());
-        } else {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        if (!CheckQuery(req->yql_text(), issues)) {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_PREPARE);
-        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DML);
-        ev->Record.MutableRequest()->SetQuery(req->yql_text());
-
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
-    }
-
-    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record.GetRef();
+        NYql::TIssues issues; 
+        if (CheckSession(req->session_id(), issues)) { 
+            ev->Record.MutableRequest()->SetSessionId(req->session_id()); 
+        } else { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        if (!CheckQuery(req->yql_text(), issues)) { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_PREPARE); 
+        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DML); 
+        ev->Record.MutableRequest()->SetQuery(req->yql_text()); 
+ 
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record.GetRef(); 
         SetCost(record.GetConsumedRu());
         AddServerHintsIfAny(record);
 
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-            const auto& kqpResponse = record.GetResponse();
-            const auto& queryId = kqpResponse.GetPreparedQuery();
-            const auto& issueMessage = kqpResponse.GetQueryIssues();
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+            const auto& kqpResponse = record.GetResponse(); 
+            const auto& queryId = kqpResponse.GetPreparedQuery(); 
+            const auto& issueMessage = kqpResponse.GetQueryIssues(); 
             const auto& queryParameters = kqpResponse.GetQueryParameters();
-
-            Ydb::TOperationId opId;
-            opId.SetKind(TOperationId::PREPARED_QUERY_ID);
-
-            AddOptionalValue(opId, "id", queryId);
-
+ 
+            Ydb::TOperationId opId; 
+            opId.SetKind(TOperationId::PREPARED_QUERY_ID); 
+ 
+            AddOptionalValue(opId, "id", queryId); 
+ 
             Ydb::Table::PrepareQueryResult queryResult;
-            queryResult.set_query_id(ProtoToString(opId));
+            queryResult.set_query_id(ProtoToString(opId)); 
             for (const auto& queryParameter: queryParameters) {
                 Ydb::Type parameterType;
                 ConvertMiniKQLTypeToYdbType(queryParameter.GetType(), parameterType);
                 queryResult.mutable_parameters_types()->insert({queryParameter.GetName(), parameterType});
             }
-            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, queryResult, ctx);
-        } else {
-            return OnGenericQueryResponseError(record, ctx);
-        }
-    }
-};
-
-void TGRpcRequestProxy::Handle(TEvPrepareDataQueryRequest::TPtr& ev, const TActorContext& ctx) {
-    ctx.Register(new TPrepareDataQueryRPC(ev->Release().Release()));
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, queryResult, ctx); 
+        } else { 
+            return OnGenericQueryResponseError(record, ctx); 
+        } 
+    } 
+}; 
+ 
+void TGRpcRequestProxy::Handle(TEvPrepareDataQueryRequest::TPtr& ev, const TActorContext& ctx) { 
+    ctx.Register(new TPrepareDataQueryRPC(ev->Release().Release())); 
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_read_table.cpp b/ydb/core/grpc_services/rpc_read_table.cpp
index bbb8790728..9ca1de5e34 100644
--- a/ydb/core/grpc_services/rpc_read_table.cpp
+++ b/ydb/core/grpc_services/rpc_read_table.cpp
@@ -24,7 +24,7 @@ namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
+using namespace Ydb; 
 using namespace NKqp;
 
 static const TDuration RlMaxDuration = TDuration::Minutes(1);
@@ -138,11 +138,11 @@ public:
 
         auto actorId = SelfId();
         const TActorSystem* const as = ctx.ExecutorThread.ActorSystem;
-        auto clientLostCb = [actorId, as]() {
+        auto clientLostCb = [actorId, as]() { 
             LOG_WARN(*as, NKikimrServices::READ_TABLE_API, "ForgetAction occurred, send TEvPoisonPill");
             as->Send(actorId, new TEvents::TEvPoisonPill());
         };
-        Request_->SetClientLostAction(std::move(clientLostCb));
+        Request_->SetClientLostAction(std::move(clientLostCb)); 
 
     }
 
@@ -213,13 +213,13 @@ private:
                 const NYql::TIssue& issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Got AccessDenied response from TxProxy");
                 auto tmp = issueMessage.Add();
                 NYql::IssueToMessage(issue, tmp);
-                return ReplyFinishStream(Ydb::StatusIds::UNAUTHORIZED, issueMessage, ctx);
+                return ReplyFinishStream(Ydb::StatusIds::UNAUTHORIZED, issueMessage, ctx); 
             }
             case TEvTxUserProxy::TResultStatus::ResolveError: {
                 const NYql::TIssue& issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Got ResolveError response from TxProxy");
                 auto tmp = issueMessage.Add();
                 NYql::IssueToMessage(issue, tmp);
-                return ReplyFinishStream(Ydb::StatusIds::SCHEME_ERROR, issueMessage, ctx);
+                return ReplyFinishStream(Ydb::StatusIds::SCHEME_ERROR, issueMessage, ctx); 
             }
             case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyNotReady:
             case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardTryLater:
@@ -537,14 +537,14 @@ private:
         }
     }
 
-    void ReplyFinishStream(Ydb::StatusIds::StatusCode status,
+    void ReplyFinishStream(Ydb::StatusIds::StatusCode status, 
                          const google::protobuf::RepeatedPtrField<TYdbIssueMessageType>& message,
                          const TActorContext& ctx) {
         // Skip sending empty result in case of success status - simplify client logic
         if (status != Ydb::StatusIds::SUCCESS) {
             TString out;
             NullSerializeReadTableResponse(message, status, &out);
-            Request_->SendSerializedResult(std::move(out), status);
+            Request_->SendSerializedResult(std::move(out), status); 
         }
         Request_->FinishStream();
         LOG_NOTICE_S(ctx, NKikimrServices::READ_TABLE_API,
@@ -710,7 +710,7 @@ private:
                     SelfId() << " Data response has been delayed for " << delay << " seconds");
         }
 
-        Request_->SendSerializedResult(std::move(out), StatusIds::SUCCESS);
+        Request_->SendSerializedResult(std::move(out), StatusIds::SUCCESS); 
 
         LeftInGRpcAdaptorQueue_++;
         if (LeftInGRpcAdaptorQueue_ > QuotaLimit_) {
diff --git a/ydb/core/grpc_services/rpc_remove_directory.cpp b/ydb/core/grpc_services/rpc_remove_directory.cpp
index 9bdc2ad7b2..766af119fa 100644
--- a/ydb/core/grpc_services/rpc_remove_directory.cpp
+++ b/ydb/core/grpc_services/rpc_remove_directory.cpp
@@ -1,6 +1,6 @@
 #include "service_scheme.h"
 
-#include "rpc_scheme_base.h"
+#include "rpc_scheme_base.h" 
 #include "rpc_common.h"
 #include <ydb/core/grpc_services/base/base.h>
 #include <ydb/public/api/protos/ydb_scheme.pb.h>
@@ -9,21 +9,21 @@ namespace NKikimr {
 namespace NGRpcService {
 
 using namespace NActors;
-using namespace Ydb;
+using namespace Ydb; 
 
 using TEvRemoveDirectoryRequest = TGrpcRequestOperationCall<Ydb::Scheme::RemoveDirectoryRequest,
     Ydb::Scheme::RemoveDirectoryResponse>;
 
-class TRemoveDirectoryRPC : public TRpcSchemeRequestActor<TRemoveDirectoryRPC, TEvRemoveDirectoryRequest> {
-    using TBase = TRpcSchemeRequestActor<TRemoveDirectoryRPC, TEvRemoveDirectoryRequest>;
-
+class TRemoveDirectoryRPC : public TRpcSchemeRequestActor<TRemoveDirectoryRPC, TEvRemoveDirectoryRequest> { 
+    using TBase = TRpcSchemeRequestActor<TRemoveDirectoryRPC, TEvRemoveDirectoryRequest>; 
+ 
 public:
     TRemoveDirectoryRPC(IRequestOpCtx* msg)
-        : TBase(msg) {}
+        : TBase(msg) {} 
 
     void Bootstrap(const TActorContext &ctx) {
-        TBase::Bootstrap(ctx);
-
+        TBase::Bootstrap(ctx); 
+ 
         SendProposeRequest(ctx);
         Become(&TRemoveDirectoryRPC::StateWork);
     }
diff --git a/ydb/core/grpc_services/rpc_rollback_transaction.cpp b/ydb/core/grpc_services/rpc_rollback_transaction.cpp
index b6cdfe2817..0bfcee0ea5 100644
--- a/ydb/core/grpc_services/rpc_rollback_transaction.cpp
+++ b/ydb/core/grpc_services/rpc_rollback_transaction.cpp
@@ -1,98 +1,98 @@
-#include "grpc_request_proxy.h"
-
-#include "rpc_calls.h"
-#include "rpc_kqp_base.h"
+#include "grpc_request_proxy.h" 
+ 
+#include "rpc_calls.h" 
+#include "rpc_kqp_base.h" 
 #include "rpc_common.h"
-
+ 
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
 #include <ydb/library/yql/public/issue/yql_issue.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-using namespace NActors;
-using namespace Ydb;
-using namespace NKqp;
-
-class TRollbackTransactionRPC : public TRpcKqpRequestActor<TRollbackTransactionRPC, TEvRollbackTransactionRequest> {
-    using TBase = TRpcKqpRequestActor<TRollbackTransactionRPC, TEvRollbackTransactionRequest>;
-
-public:
-    TRollbackTransactionRPC(TEvRollbackTransactionRequest* msg)
-        : TBase(msg) {}
-
-    void Bootstrap(const TActorContext& ctx) {
-        TBase::Bootstrap(ctx);
-
-        RollbackTransactionImpl(ctx);
-        Become(&TRollbackTransactionRPC::StateWork);
-    }
-
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle);
-            default: TBase::StateWork(ev, ctx);
-        }
-    }
-
-private:
-    void RollbackTransactionImpl(const TActorContext &ctx) {
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+using namespace NActors; 
+using namespace Ydb; 
+using namespace NKqp; 
+ 
+class TRollbackTransactionRPC : public TRpcKqpRequestActor<TRollbackTransactionRPC, TEvRollbackTransactionRequest> { 
+    using TBase = TRpcKqpRequestActor<TRollbackTransactionRPC, TEvRollbackTransactionRequest>; 
+ 
+public: 
+    TRollbackTransactionRPC(TEvRollbackTransactionRequest* msg) 
+        : TBase(msg) {} 
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        TBase::Bootstrap(ctx); 
+ 
+        RollbackTransactionImpl(ctx); 
+        Become(&TRollbackTransactionRPC::StateWork); 
+    } 
+ 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle); 
+            default: TBase::StateWork(ev, ctx); 
+        } 
+    } 
+ 
+private: 
+    void RollbackTransactionImpl(const TActorContext &ctx) { 
         const auto req = GetProtoRequest();
-        const auto traceId = Request_->GetTraceId();
-
-        TString sessionId;
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
+        const auto traceId = Request_->GetTraceId(); 
+ 
+        TString sessionId; 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>(); 
         SetAuthToken(ev, *Request_);
         SetDatabase(ev, *Request_);
 
-        NYql::TIssues issues;
-        if (CheckSession(req->session_id(), issues)) {
-            ev->Record.MutableRequest()->SetSessionId(req->session_id());
-        } else {
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
-        if (!req->tx_id()) {
-            NYql::TIssues issues;
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty transaction id."));
-            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx);
-        }
-
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_ROLLBACK_TX);
-        ev->Record.MutableRequest()->MutableTxControl()->set_tx_id(req->tx_id());
-
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
-    }
-
-    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& record = ev->Get()->Record.GetRef();
+        NYql::TIssues issues; 
+        if (CheckSession(req->session_id(), issues)) { 
+            ev->Record.MutableRequest()->SetSessionId(req->session_id()); 
+        } else { 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
+ 
+        if (!req->tx_id()) { 
+            NYql::TIssues issues; 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Empty transaction id.")); 
+            return Reply(Ydb::StatusIds::BAD_REQUEST, issues, ctx); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_ROLLBACK_TX); 
+        ev->Record.MutableRequest()->MutableTxControl()->set_tx_id(req->tx_id()); 
+ 
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& record = ev->Get()->Record.GetRef(); 
         AddServerHintsIfAny(record);
 
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-            const auto& kqpResponse = record.GetResponse();
-            const auto& issueMessage = kqpResponse.GetQueryIssues();
-
-            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, ctx);
-        } else {
-            return OnGenericQueryResponseError(record, ctx);
-        }
-    }
-
-    void ReplyWithResult(StatusIds::StatusCode status,
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+            const auto& kqpResponse = record.GetResponse(); 
+            const auto& issueMessage = kqpResponse.GetQueryIssues(); 
+ 
+            ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, ctx); 
+        } else { 
+            return OnGenericQueryResponseError(record, ctx); 
+        } 
+    } 
+ 
+    void ReplyWithResult(StatusIds::StatusCode status, 
                          const google::protobuf::RepeatedPtrField<TYdbIssueMessageType>& message,
-                         const TActorContext& ctx) {
-        Request_->SendResult(status, message);
-        Die(ctx);
-    }
-};
-
-void TGRpcRequestProxy::Handle(TEvRollbackTransactionRequest::TPtr& ev, const TActorContext& ctx) {
-    ctx.Register(new TRollbackTransactionRPC(ev->Release().Release()));
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+                         const TActorContext& ctx) { 
+        Request_->SendResult(status, message); 
+        Die(ctx); 
+    } 
+}; 
+ 
+void TGRpcRequestProxy::Handle(TEvRollbackTransactionRequest::TPtr& ev, const TActorContext& ctx) { 
+    ctx.Register(new TRollbackTransactionRPC(ev->Release().Release())); 
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_scheme_base.cpp b/ydb/core/grpc_services/rpc_scheme_base.cpp
index afb7e37d52..a569f33712 100644
--- a/ydb/core/grpc_services/rpc_scheme_base.cpp
+++ b/ydb/core/grpc_services/rpc_scheme_base.cpp
@@ -1,7 +1,7 @@
-#include "rpc_scheme_base.h"
-
-namespace NKikimr {
-namespace NGRpcService {
-
-} // namespace NGRpcService
-} // namespace NKikimr
+#include "rpc_scheme_base.h" 
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_scheme_base.h b/ydb/core/grpc_services/rpc_scheme_base.h
index 0be68e802e..d7c11403d4 100644
--- a/ydb/core/grpc_services/rpc_scheme_base.h
+++ b/ydb/core/grpc_services/rpc_scheme_base.h
@@ -1,34 +1,34 @@
-#pragma once
-#include "defs.h"
-
-#include "rpc_deferrable.h"
-
+#pragma once 
+#include "defs.h" 
+ 
+#include "rpc_deferrable.h" 
+ 
 #include <ydb/library/persqueue/topic_parser/topic_parser.h>
 
-namespace NKikimr {
-namespace NGRpcService {
-
-template <typename TDerived, typename TRequest>
-class TRpcSchemeRequestActor : public TRpcOperationRequestActor<TDerived, TRequest> {
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+template <typename TDerived, typename TRequest> 
+class TRpcSchemeRequestActor : public TRpcOperationRequestActor<TDerived, TRequest> { 
 protected:
-    using TBase = TRpcOperationRequestActor<TDerived, TRequest>;
-
-public:
+    using TBase = TRpcOperationRequestActor<TDerived, TRequest>; 
+ 
+public: 
     TRpcSchemeRequestActor(IRequestOpCtx* request)
-        : TBase(request) {}
-
-protected:
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TEvTabletPipe::TEvClientConnected, Handle);
-            HFunc(TEvTabletPipe::TEvClientDestroyed, Handle);
-            HFunc(TEvTxUserProxy::TEvProposeTransactionStatus, Handle);
+        : TBase(request) {} 
+ 
+protected: 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TEvTabletPipe::TEvClientConnected, Handle); 
+            HFunc(TEvTabletPipe::TEvClientDestroyed, Handle); 
+            HFunc(TEvTxUserProxy::TEvProposeTransactionStatus, Handle); 
             HFunc(NSchemeShard::TEvSchemeShard::TEvNotifyTxCompletionResult, Handle);
             HFunc(NSchemeShard::TEvSchemeShard::TEvNotifyTxCompletionRegistered, Handle);
-            default: TBase::StateFuncBase(ev, ctx);
-        }
-    }
-
+            default: TBase::StateFuncBase(ev, ctx); 
+        } 
+    } 
+ 
     std::unique_ptr<TEvTxUserProxy::TEvProposeTransaction> CreateProposeTransaction() {
         std::unique_ptr<TEvTxUserProxy::TEvProposeTransaction> proposeRequest(new TEvTxUserProxy::TEvProposeTransaction());
         SetAuthToken(proposeRequest, *this->Request_);
@@ -37,65 +37,65 @@ protected:
         return proposeRequest;
     }
 
-    void Handle(TEvTabletPipe::TEvClientConnected::TPtr &ev, const TActorContext &ctx) {
-        if (ev->Get()->Status != NKikimrProto::OK) {
-            NYql::TIssues issues;
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR,
-                TStringBuilder() << "Tablet not available, status: " << (ui32)ev->Get()->Status));
-            return this->Reply(Ydb::StatusIds::UNAVAILABLE, issues, ctx);
-        }
-    }
-
-    void Handle(TEvTabletPipe::TEvClientDestroyed::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-
-        NYql::TIssues issues;
-        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR,
-            TStringBuilder() << "Connection to tablet was lost."));
-        return this->Reply(Ydb::StatusIds::UNAVAILABLE, issues, ctx);
-    }
-
-    void Handle(TEvTxUserProxy::TEvProposeTransactionStatus::TPtr& ev, const TActorContext& ctx) {
-        const TEvTxUserProxy::TEvProposeTransactionStatus* msg = ev->Get();
-        const auto status = static_cast<TEvTxUserProxy::TEvProposeTransactionStatus::EStatus>(msg->Record.GetStatus());
-        auto issueMessage = msg->Record.GetIssues();
-        switch (status) {
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecComplete: {
+    void Handle(TEvTabletPipe::TEvClientConnected::TPtr &ev, const TActorContext &ctx) { 
+        if (ev->Get()->Status != NKikimrProto::OK) { 
+            NYql::TIssues issues; 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, 
+                TStringBuilder() << "Tablet not available, status: " << (ui32)ev->Get()->Status)); 
+            return this->Reply(Ydb::StatusIds::UNAVAILABLE, issues, ctx); 
+        } 
+    } 
+ 
+    void Handle(TEvTabletPipe::TEvClientDestroyed::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+ 
+        NYql::TIssues issues; 
+        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, 
+            TStringBuilder() << "Connection to tablet was lost.")); 
+        return this->Reply(Ydb::StatusIds::UNAVAILABLE, issues, ctx); 
+    } 
+ 
+    void Handle(TEvTxUserProxy::TEvProposeTransactionStatus::TPtr& ev, const TActorContext& ctx) { 
+        const TEvTxUserProxy::TEvProposeTransactionStatus* msg = ev->Get(); 
+        const auto status = static_cast<TEvTxUserProxy::TEvProposeTransactionStatus::EStatus>(msg->Record.GetStatus()); 
+        auto issueMessage = msg->Record.GetIssues(); 
+        switch (status) { 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecComplete: { 
                 if (msg->Record.GetSchemeShardStatus() == NKikimrScheme::EStatus::StatusSuccess ||
                     msg->Record.GetSchemeShardStatus() == NKikimrScheme::EStatus::StatusAlreadyExists)
-                {
-                    return this->ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, ctx);
-                }
+                { 
+                    return this->ReplyWithResult(Ydb::StatusIds::SUCCESS, issueMessage, ctx); 
+                } 
                 break;
-            }
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecInProgress: {
+            } 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecInProgress: { 
                 ui64 schemeShardTabletId = msg->Record.GetSchemeShardTabletId();
                 IActor* pipeActor = NTabletPipe::CreateClient(ctx.SelfID, schemeShardTabletId);
                 Y_VERIFY(pipeActor);
                 SchemePipeActorId_ = ctx.ExecutorThread.RegisterActor(pipeActor);
-
+ 
                 auto request = MakeHolder<NSchemeShard::TEvSchemeShard::TEvNotifyTxCompletion>();
                 request->Record.SetTxId(msg->Record.GetTxId());
                 NTabletPipe::SendData(ctx, SchemePipeActorId_, request.Release());
                 return;
-            }
+            } 
             case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::WrongRequest: {
                 return this->ReplyWithResult(Ydb::StatusIds::BAD_REQUEST, issueMessage, ctx);
             }
-            case TEvTxUserProxy::TResultStatus::AccessDenied: {
-                return this->ReplyWithResult(Ydb::StatusIds::UNAUTHORIZED, issueMessage, ctx);
-            }
+            case TEvTxUserProxy::TResultStatus::AccessDenied: { 
+                return this->ReplyWithResult(Ydb::StatusIds::UNAUTHORIZED, issueMessage, ctx); 
+            } 
             case TEvTxUserProxy::TResultStatus::ProxyShardNotAvailable: {
                 return this->ReplyWithResult(Ydb::StatusIds::UNAVAILABLE, issueMessage, ctx);
             }
-            case TEvTxUserProxy::TResultStatus::ResolveError: {
-                return this->ReplyWithResult(Ydb::StatusIds::SCHEME_ERROR, issueMessage, ctx);
-            }
-            case TEvTxUserProxy::TResultStatus::ExecError: {
-                switch (msg->Record.GetSchemeShardStatus()) {
+            case TEvTxUserProxy::TResultStatus::ResolveError: { 
+                return this->ReplyWithResult(Ydb::StatusIds::SCHEME_ERROR, issueMessage, ctx); 
+            } 
+            case TEvTxUserProxy::TResultStatus::ExecError: { 
+                switch (msg->Record.GetSchemeShardStatus()) { 
                     case NKikimrScheme::EStatus::StatusMultipleModifications: {
-                        return this->ReplyWithResult(Ydb::StatusIds::OVERLOADED, issueMessage, ctx);
-                    }
+                        return this->ReplyWithResult(Ydb::StatusIds::OVERLOADED, issueMessage, ctx); 
+                    } 
                     case NKikimrScheme::EStatus::StatusSchemeError:
                     case NKikimrScheme::EStatus::StatusNameConflict:
                     case NKikimrScheme::EStatus::StatusPathDoesNotExist: {
@@ -109,39 +109,39 @@ protected:
                     case NKikimrScheme::EStatus::StatusPreconditionFailed: {
                         return this->ReplyWithResult(Ydb::StatusIds::PRECONDITION_FAILED, issueMessage, ctx);
                     }
-                    default: {
-                        return this->ReplyWithResult(Ydb::StatusIds::GENERIC_ERROR, issueMessage, ctx);
-                    }
-                }
-            }
-            default: {
-                TStringStream str;
-                str << "Got unknown TEvProposeTransactionStatus (" << status << ") response from TxProxy";
-                const NYql::TIssue& issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, str.Str());
-                auto tmp = issueMessage.Add();
-                NYql::IssueToMessage(issue, tmp);
-                return this->ReplyWithResult(Ydb::StatusIds::INTERNAL_ERROR, issueMessage, ctx);
-            }
-        }
-        return this->ReplyWithResult(Ydb::StatusIds::INTERNAL_ERROR, issueMessage, ctx);
-    }
-
+                    default: { 
+                        return this->ReplyWithResult(Ydb::StatusIds::GENERIC_ERROR, issueMessage, ctx); 
+                    } 
+                } 
+            } 
+            default: { 
+                TStringStream str; 
+                str << "Got unknown TEvProposeTransactionStatus (" << status << ") response from TxProxy"; 
+                const NYql::TIssue& issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, str.Str()); 
+                auto tmp = issueMessage.Add(); 
+                NYql::IssueToMessage(issue, tmp); 
+                return this->ReplyWithResult(Ydb::StatusIds::INTERNAL_ERROR, issueMessage, ctx); 
+            } 
+        } 
+        return this->ReplyWithResult(Ydb::StatusIds::INTERNAL_ERROR, issueMessage, ctx); 
+    } 
+ 
     void Handle(NSchemeShard::TEvSchemeShard::TEvNotifyTxCompletionResult::TPtr& ev, const TActorContext& ctx) {
-        NTabletPipe::CloseClient(ctx, SchemePipeActorId_);
+        NTabletPipe::CloseClient(ctx, SchemePipeActorId_); 
         return this->ReplyNotifyTxCompletionResult(ev, ctx);
-    }
-
+    } 
+ 
     void Handle(NSchemeShard::TEvSchemeShard::TEvNotifyTxCompletionRegistered::TPtr&, const TActorContext&) {
-    }
-
+    } 
+ 
     virtual void ReplyNotifyTxCompletionResult(NSchemeShard::TEvSchemeShard::TEvNotifyTxCompletionResult::TPtr& ev, const TActorContext& ctx) {
         Y_UNUSED(ev);
         return this->Reply(Ydb::StatusIds::SUCCESS, ctx);
     }
 
-private:
+private: 
     TActorId SchemePipeActorId_;
-};
-
-} // namespace NGRpcService
-} // namespace NKikimr
+}; 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/rpc_stream_execute_scan_query.cpp b/ydb/core/grpc_services/rpc_stream_execute_scan_query.cpp
index 5f95f263c6..535fa331f8 100644
--- a/ydb/core/grpc_services/rpc_stream_execute_scan_query.cpp
+++ b/ydb/core/grpc_services/rpc_stream_execute_scan_query.cpp
@@ -1,44 +1,44 @@
-#include "grpc_request_proxy.h"
-
+#include "grpc_request_proxy.h" 
+ 
 #include "rpc_common.h"
-#include "rpc_kqp_base.h"
-
+#include "rpc_kqp_base.h" 
+ 
 #include <ydb/core/actorlib_impl/long_timer.h>
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/base/kikimr_issue.h>
 #include <ydb/core/kqp/executer/kqp_executer.h>
 #include <ydb/core/kqp/prepare/kqp_query_plan.h>
-
+ 
 #include <ydb/core/protos/services.pb.h>
 #include <ydb/core/protos/ydb_table_impl.pb.h>
 #include <ydb/core/ydb_convert/ydb_convert.h>
-
+ 
 #include <library/cpp/actors/core/actor_bootstrapped.h>
 
-namespace NKikimr {
-namespace NGRpcService {
-
-namespace {
-
-using namespace NActors;
-using namespace Ydb;
-using namespace Ydb::Table;
-using namespace NKqp;
-
-struct TParseRequestError {
-    Ydb::StatusIds::StatusCode Status;
-    NYql::TIssues Issues;
-
-    TParseRequestError()
-        : Status(Ydb::StatusIds::INTERNAL_ERROR)
-        , Issues({MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR,
-            "Unexpected error while parsing request.")}) {}
-
-    TParseRequestError(const Ydb::StatusIds::StatusCode& status, const NYql::TIssues& issues)
-        : Status(status)
-        , Issues(issues) {}
-};
-
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+namespace { 
+ 
+using namespace NActors; 
+using namespace Ydb; 
+using namespace Ydb::Table; 
+using namespace NKqp; 
+ 
+struct TParseRequestError { 
+    Ydb::StatusIds::StatusCode Status; 
+    NYql::TIssues Issues; 
+ 
+    TParseRequestError() 
+        : Status(Ydb::StatusIds::INTERNAL_ERROR) 
+        , Issues({MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, 
+            "Unexpected error while parsing request.")}) {} 
+ 
+    TParseRequestError(const Ydb::StatusIds::StatusCode& status, const NYql::TIssues& issues) 
+        : Status(status) 
+        , Issues(issues) {} 
+}; 
+ 
 bool NeedReportStats(const Ydb::Experimental::ExecuteStreamQueryRequest& req) {
     switch (req.profile_mode()) {
         case Experimental::ExecuteStreamQueryRequest_ProfileMode_PROFILE_MODE_UNSPECIFIED:
@@ -61,119 +61,119 @@ bool NeedReportStats(const Ydb::Table::ExecuteScanQueryRequest& req) {
             return false;
 
         case ExecuteScanQueryRequest_Mode_MODE_EXPLAIN:
-            return true;
-
+            return true; 
+ 
         case ExecuteScanQueryRequest_Mode_MODE_EXEC:
-            switch (req.collect_stats()) {
-                case Ydb::Table::QueryStatsCollection::STATS_COLLECTION_BASIC:
-                case Ydb::Table::QueryStatsCollection::STATS_COLLECTION_FULL:
-                    return true;
-
-                default:
-                    break;
-            }
-
-            return false;
-
-        case ExecuteScanQueryRequest_Mode_ExecuteScanQueryRequest_Mode_INT_MIN_SENTINEL_DO_NOT_USE_:
-        case ExecuteScanQueryRequest_Mode_ExecuteScanQueryRequest_Mode_INT_MAX_SENTINEL_DO_NOT_USE_:
-            YQL_ENSURE(false);
-    }
-}
-
-bool NeedReportPlan(const Ydb::Table::ExecuteScanQueryRequest& req) {
-    switch (req.mode()) {
-        case ExecuteScanQueryRequest_Mode_MODE_UNSPECIFIED:
-            return false;
-
-        case ExecuteScanQueryRequest_Mode_MODE_EXPLAIN:
+            switch (req.collect_stats()) { 
+                case Ydb::Table::QueryStatsCollection::STATS_COLLECTION_BASIC: 
+                case Ydb::Table::QueryStatsCollection::STATS_COLLECTION_FULL: 
+                    return true; 
+ 
+                default: 
+                    break; 
+            } 
+ 
+            return false; 
+ 
+        case ExecuteScanQueryRequest_Mode_ExecuteScanQueryRequest_Mode_INT_MIN_SENTINEL_DO_NOT_USE_: 
+        case ExecuteScanQueryRequest_Mode_ExecuteScanQueryRequest_Mode_INT_MAX_SENTINEL_DO_NOT_USE_: 
+            YQL_ENSURE(false); 
+    } 
+} 
+ 
+bool NeedReportPlan(const Ydb::Table::ExecuteScanQueryRequest& req) { 
+    switch (req.mode()) { 
+        case ExecuteScanQueryRequest_Mode_MODE_UNSPECIFIED: 
+            return false; 
+ 
+        case ExecuteScanQueryRequest_Mode_MODE_EXPLAIN: 
             return true;
 
-        case ExecuteScanQueryRequest_Mode_MODE_EXEC:
-            switch (req.collect_stats()) {
-                case Ydb::Table::QueryStatsCollection::STATS_COLLECTION_FULL:
-                    return true;
-
-                default:
-                    break;
-            }
-
-            return false;
-
+        case ExecuteScanQueryRequest_Mode_MODE_EXEC: 
+            switch (req.collect_stats()) { 
+                case Ydb::Table::QueryStatsCollection::STATS_COLLECTION_FULL: 
+                    return true; 
+ 
+                default: 
+                    break; 
+            } 
+ 
+            return false; 
+ 
         case ExecuteScanQueryRequest_Mode_ExecuteScanQueryRequest_Mode_INT_MIN_SENTINEL_DO_NOT_USE_:
         case ExecuteScanQueryRequest_Mode_ExecuteScanQueryRequest_Mode_INT_MAX_SENTINEL_DO_NOT_USE_:
             YQL_ENSURE(false);
     }
 }
 
-bool FillKqpParameters(const ::google::protobuf::Map<TString, Ydb::TypedValue>& input,
-    NKikimrMiniKQL::TParams& output, TParseRequestError& error)
-{
-    if (input.size() != 0) {
-        try {
-            ConvertYdbParamsToMiniKQLParams(input, output);
-        } catch (const std::exception& ex) {
-            auto issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Failed to parse query parameters.");
-            issue.AddSubIssue(MakeIntrusive<NYql::TIssue>(NYql::ExceptionToIssue(ex)));
-
-            error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, {issue});
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool FillKqpRequest(const Ydb::Experimental::ExecuteStreamQueryRequest& req, NKikimrKqp::TEvQueryRequest& kqpRequest,
-    TParseRequestError& error)
-{
-    if (!FillKqpParameters(req.parameters(), *kqpRequest.MutableRequest()->MutableParameters(), error)) {
-        return false;
-    }
-
-    auto& query = req.yql_text();
-
-    NYql::TIssues issues;
-    if (!CheckQuery(query, issues)) {
-        error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, issues);
-        return false;
-    }
-
+bool FillKqpParameters(const ::google::protobuf::Map<TString, Ydb::TypedValue>& input, 
+    NKikimrMiniKQL::TParams& output, TParseRequestError& error) 
+{ 
+    if (input.size() != 0) { 
+        try { 
+            ConvertYdbParamsToMiniKQLParams(input, output); 
+        } catch (const std::exception& ex) { 
+            auto issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Failed to parse query parameters."); 
+            issue.AddSubIssue(MakeIntrusive<NYql::TIssue>(NYql::ExceptionToIssue(ex))); 
+ 
+            error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, {issue}); 
+            return false; 
+        } 
+    } 
+ 
+    return true; 
+} 
+ 
+bool FillKqpRequest(const Ydb::Experimental::ExecuteStreamQueryRequest& req, NKikimrKqp::TEvQueryRequest& kqpRequest, 
+    TParseRequestError& error) 
+{ 
+    if (!FillKqpParameters(req.parameters(), *kqpRequest.MutableRequest()->MutableParameters(), error)) { 
+        return false; 
+    } 
+ 
+    auto& query = req.yql_text(); 
+ 
+    NYql::TIssues issues; 
+    if (!CheckQuery(query, issues)) { 
+        error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, issues); 
+        return false; 
+    } 
+ 
     if (req.explain()) {
         kqpRequest.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXPLAIN);
     } else {
         kqpRequest.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
     }
 
-    kqpRequest.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_SCAN);
-    kqpRequest.MutableRequest()->SetQuery(query);
-    kqpRequest.MutableRequest()->SetKeepSession(false);
-    switch (req.profile_mode()) {
-        case Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_PROFILE_MODE_UNSPECIFIED:
-        case Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_NONE:
+    kqpRequest.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_SCAN); 
+    kqpRequest.MutableRequest()->SetQuery(query); 
+    kqpRequest.MutableRequest()->SetKeepSession(false); 
+    switch (req.profile_mode()) { 
+        case Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_PROFILE_MODE_UNSPECIFIED: 
+        case Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_NONE: 
             kqpRequest.MutableRequest()->SetStatsMode(NYql::NDqProto::DQ_STATS_MODE_NONE);
-            break;
-        case Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_BASIC:
+            break; 
+        case Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_BASIC: 
             kqpRequest.MutableRequest()->SetStatsMode(NYql::NDqProto::DQ_STATS_MODE_BASIC);
-            break;
-        case Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_FULL:
+            break; 
+        case Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_FULL: 
             kqpRequest.MutableRequest()->SetStatsMode(NYql::NDqProto::DQ_STATS_MODE_PROFILE);
-            break;
-        default:
-            YQL_ENSURE(false, "Unknown profile_mode "
-                << Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_Name(req.profile_mode()));
-    }
-
-    return true;
-}
-
-bool FillKqpRequest(const Ydb::Table::ExecuteScanQueryRequest& req, NKikimrKqp::TEvQueryRequest& kqpRequest,
-    TParseRequestError& error)
-{
-    if (!FillKqpParameters(req.parameters(), *kqpRequest.MutableRequest()->MutableParameters(), error)) {
-        return false;
-    }
-
+            break; 
+        default: 
+            YQL_ENSURE(false, "Unknown profile_mode " 
+                << Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_Name(req.profile_mode())); 
+    } 
+ 
+    return true; 
+} 
+ 
+bool FillKqpRequest(const Ydb::Table::ExecuteScanQueryRequest& req, NKikimrKqp::TEvQueryRequest& kqpRequest, 
+    TParseRequestError& error) 
+{ 
+    if (!FillKqpParameters(req.parameters(), *kqpRequest.MutableRequest()->MutableParameters(), error)) { 
+        return false; 
+    } 
+ 
     switch (req.mode()) {
         case Ydb::Table::ExecuteScanQueryRequest::MODE_EXEC:
             kqpRequest.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
@@ -189,76 +189,76 @@ bool FillKqpRequest(const Ydb::Table::ExecuteScanQueryRequest& req, NKikimrKqp::
             return false;
         }
     }
-    kqpRequest.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_SCAN);
-    kqpRequest.MutableRequest()->SetKeepSession(false);
-
-    auto& query = req.query();
-    switch (query.query_case()) {
-        case Query::kYqlText: {
-            NYql::TIssues issues;
-            if (!CheckQuery(query.yql_text(), issues)) {
-                error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, issues);
-                return false;
-            }
-
-            kqpRequest.MutableRequest()->SetQuery(query.yql_text());
-            break;
-        }
-
-        case Query::kId: {
-            NYql::TIssues issues;
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR,
+    kqpRequest.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_SCAN); 
+    kqpRequest.MutableRequest()->SetKeepSession(false); 
+ 
+    auto& query = req.query(); 
+    switch (query.query_case()) { 
+        case Query::kYqlText: { 
+            NYql::TIssues issues; 
+            if (!CheckQuery(query.yql_text(), issues)) { 
+                error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, issues); 
+                return false; 
+            } 
+ 
+            kqpRequest.MutableRequest()->SetQuery(query.yql_text()); 
+            break; 
+        } 
+ 
+        case Query::kId: { 
+            NYql::TIssues issues; 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, 
                 "Specifying query by ID not supported in scan execution."));
-            error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, issues);
-            return false;
-        }
-
-        default: {
-            NYql::TIssues issues;
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Unexpected query option"));
-            error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, issues);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool FillProfile(Ydb::Experimental::ExecuteStreamQueryResponse& response,
+            error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, issues); 
+            return false; 
+        } 
+ 
+        default: { 
+            NYql::TIssues issues; 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Unexpected query option")); 
+            error = TParseRequestError(Ydb::StatusIds::BAD_REQUEST, issues); 
+            return false; 
+        } 
+    } 
+ 
+    return true; 
+} 
+ 
+bool FillProfile(Ydb::Experimental::ExecuteStreamQueryResponse& response, 
     const NYql::NDqProto::TDqExecutionStats& profile)
-{
-    response.set_status(Ydb::StatusIds::SUCCESS);
-    response.mutable_result()->set_profile(profile.Utf8DebugString());
-    return true;
-}
-
-bool FillProfile(Ydb::Table::ExecuteScanQueryPartialResponse& response,
+{ 
+    response.set_status(Ydb::StatusIds::SUCCESS); 
+    response.mutable_result()->set_profile(profile.Utf8DebugString()); 
+    return true; 
+} 
+ 
+bool FillProfile(Ydb::Table::ExecuteScanQueryPartialResponse& response, 
     const NYql::NDqProto::TDqExecutionStats& profile)
-{
-    Y_UNUSED(response);
-    Y_UNUSED(profile);
-    return false;
-}
-
-template<typename TRequestEv, typename TResponse>
-class TStreamExecuteScanQueryRPC : public TActorBootstrapped<TStreamExecuteScanQueryRPC<TRequestEv, TResponse>> {
+{ 
+    Y_UNUSED(response); 
+    Y_UNUSED(profile); 
+    return false; 
+} 
+ 
+template<typename TRequestEv, typename TResponse> 
+class TStreamExecuteScanQueryRPC : public TActorBootstrapped<TStreamExecuteScanQueryRPC<TRequestEv, TResponse>> { 
 private:
     enum EWakeupTag : ui64 {
         ClientLostTag = 1,
         TimeoutTag = 2
     };
-
-public:
+ 
+public: 
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
         return NKikimrServices::TActivity::GRPC_STREAM_REQ;
-    }
-
-    TStreamExecuteScanQueryRPC(TRequestEv* request, ui64 rpcBufferSize)
+    } 
+ 
+    TStreamExecuteScanQueryRPC(TRequestEv* request, ui64 rpcBufferSize) 
         : Request_(request)
-        , RpcBufferSize_(rpcBufferSize) {}
-
-    void Bootstrap(const TActorContext &ctx) {
-        this->Become(&TStreamExecuteScanQueryRPC::StateWork);
+        , RpcBufferSize_(rpcBufferSize) {} 
+ 
+    void Bootstrap(const TActorContext &ctx) { 
+        this->Become(&TStreamExecuteScanQueryRPC::StateWork); 
 
         const auto& cfg = AppData(ctx)->StreamingConfig.GetOutputStreamConfig();
 
@@ -269,7 +269,7 @@ public:
 
         LastDataStreamTimestamp_ = TAppData::TimeProvider->Now();
 
-        auto selfId = this->SelfId();
+        auto selfId = this->SelfId(); 
         auto as = TActivationContext::ActorSystem();
 
         Request_->SetClientLostAction([selfId, as]() {
@@ -280,55 +280,55 @@ public:
             as->Send(selfId, new TRpcServices::TEvGrpcNextReply(left));
         });
 
-        Proceed(ctx);
-    }
-
+        Proceed(ctx); 
+    } 
+ 
 private:
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
             HFunc(TEvents::TEvWakeup, Handle);
             HFunc(TRpcServices::TEvGrpcNextReply, Handle);
-            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle);
-            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle);
+            HFunc(NKqp::TEvKqp::TEvQueryResponse, Handle); 
+            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle); 
             HFunc(NKqp::TEvKqp::TEvAbortExecution, Handle);
-            HFunc(NKqp::TEvKqpExecuter::TEvStreamData, Handle);
+            HFunc(NKqp::TEvKqpExecuter::TEvStreamData, Handle); 
             HFunc(NKqp::TEvKqpExecuter::TEvStreamProfile, Handle);
             HFunc(NKqp::TEvKqpExecuter::TEvExecuterProgress, Handle);
-            default: {
+            default: { 
                 auto issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, TStringBuilder()
-                    << "Unexpected event received in TStreamExecuteScanQueryRPC::StateWork: " << ev->GetTypeRewrite());
+                    << "Unexpected event received in TStreamExecuteScanQueryRPC::StateWork: " << ev->GetTypeRewrite()); 
                 return ReplyFinishStream(Ydb::StatusIds::INTERNAL_ERROR, issue, ctx);
-            }
-        }
-    }
-
-    void Proceed(const TActorContext &ctx) {
-        const auto req = Request_->GetProtoRequest();
-        const auto traceId = Request_->GetTraceId();
-
-        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
-        SetAuthToken(ev, *Request_);
-        SetDatabase(ev, *Request_);
+            } 
+        } 
+    } 
+ 
+    void Proceed(const TActorContext &ctx) { 
+        const auto req = Request_->GetProtoRequest(); 
+        const auto traceId = Request_->GetTraceId(); 
+ 
+        auto ev = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>(); 
+        SetAuthToken(ev, *Request_); 
+        SetDatabase(ev, *Request_); 
         SetRlPath(ev, *Request_);
-
-        if (traceId) {
-            ev->Record.SetTraceId(traceId.GetRef());
-        }
-
+ 
+        if (traceId) { 
+            ev->Record.SetTraceId(traceId.GetRef()); 
+        } 
+ 
         ActorIdToProto(this->SelfId(), ev->Record.MutableRequestActorId());
-
-        TParseRequestError parseError;
-        if (!FillKqpRequest(*req, ev->Record, parseError)) {
-            return ReplyFinishStream(parseError.Status, parseError.Issues, ctx);
-        }
-
+ 
+        TParseRequestError parseError; 
+        if (!FillKqpRequest(*req, ev->Record, parseError)) { 
+            return ReplyFinishStream(parseError.Status, parseError.Issues, ctx); 
+        } 
+ 
         if (!ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release())) {
-            NYql::TIssues issues;
+            NYql::TIssues issues; 
             issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, "Internal error"));
             ReplyFinishStream(Ydb::StatusIds::INTERNAL_ERROR, issues, ctx);
         }
-    }
-
+    } 
+ 
     void Handle(TEvents::TEvWakeup::TPtr& ev, const TActorContext& ctx) {
         switch ((EWakeupTag) ev->Get()->Tag) {
             case EWakeupTag::ClientLostTag:
@@ -339,7 +339,7 @@ private:
     }
 
     void Handle(TRpcServices::TEvGrpcNextReply::TPtr& ev, const TActorContext& ctx) {
-        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " NextReply"
+        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " NextReply" 
             << ", left: " << ev->Get()->LeftInQueue
             << ", queue: " << GRpcResponsesSizeQueue_.size()
             << ", used memory: " << GRpcResponsesSize_
@@ -355,7 +355,7 @@ private:
         if (WaitOnSeqNo_ && RpcBufferSize_ > GRpcResponsesSize_) {
             ui64 freeSpace = RpcBufferSize_ - GRpcResponsesSize_;
 
-            LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Send stream data ack"
+            LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Send stream data ack" 
                 << ", seqNo: " << *WaitOnSeqNo_
                 << ", freeSpace: " << freeSpace
                 << ", to: " << ExecuterActorId_);
@@ -364,18 +364,18 @@ private:
             resp->Record.SetSeqNo(*WaitOnSeqNo_);
             resp->Record.SetFreeSpace(freeSpace);
 
-            ctx.Send(ExecuterActorId_, resp.Release());
+            ctx.Send(ExecuterActorId_, resp.Release()); 
 
             WaitOnSeqNo_.Clear();
         }
     }
 
-    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
+    void Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) { 
         auto& record = ev->Get()->Record.GetRef();
-
-        NYql::TIssues issues;
+ 
+        NYql::TIssues issues; 
         const auto& issueMessage = record.GetResponse().GetQueryIssues();
-        NYql::IssuesFromMessage(issueMessage, issues);
+        NYql::IssuesFromMessage(issueMessage, issues); 
 
         if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
             TResponse response;
@@ -384,31 +384,31 @@ private:
             response.set_status(Ydb::StatusIds::SUCCESS);
 
             if constexpr (std::is_same_v<TResponse, Ydb::Table::ExecuteScanQueryPartialResponse>) {
-                bool reportStats = NeedReportStats(*Request_->GetProtoRequest());
-                bool reportPlan = reportStats && NeedReportPlan(*Request_->GetProtoRequest());
-
-                if (reportStats) {
-                    if (kqpResponse.HasQueryStats()) {
-                        for (const auto& execStats: ExecutionProfiles_) {
+                bool reportStats = NeedReportStats(*Request_->GetProtoRequest()); 
+                bool reportPlan = reportStats && NeedReportPlan(*Request_->GetProtoRequest()); 
+ 
+                if (reportStats) { 
+                    if (kqpResponse.HasQueryStats()) { 
+                        for (const auto& execStats: ExecutionProfiles_) { 
                             record.MutableResponse()->MutableQueryStats()->AddExecutions()->Swap(execStats.get());
-                        }
-
-                        record.MutableResponse()->SetQueryPlan(reportPlan
-                            ? SerializeAnalyzePlan(kqpResponse.GetQueryStats())
-                            : "");
-
-                        FillQueryStats(*response.mutable_result()->mutable_query_stats(), kqpResponse);
-                        ExecutionProfiles_.clear();
-                    } else if (reportPlan) {
-                        response.mutable_result()->mutable_query_stats()->set_query_plan(kqpResponse.GetQueryPlan());
-                    }
-
-                    if (reportPlan) {
-                        response.mutable_result()->mutable_query_stats()->set_query_ast(kqpResponse.GetQueryAst());
+                        } 
+ 
+                        record.MutableResponse()->SetQueryPlan(reportPlan 
+                            ? SerializeAnalyzePlan(kqpResponse.GetQueryStats()) 
+                            : ""); 
+ 
+                        FillQueryStats(*response.mutable_result()->mutable_query_stats(), kqpResponse); 
+                        ExecutionProfiles_.clear(); 
+                    } else if (reportPlan) { 
+                        response.mutable_result()->mutable_query_stats()->set_query_plan(kqpResponse.GetQueryPlan()); 
                     }
 
+                    if (reportPlan) { 
+                        response.mutable_result()->mutable_query_stats()->set_query_ast(kqpResponse.GetQueryAst()); 
+                    } 
+ 
                     Y_PROTOBUF_SUPPRESS_NODISCARD response.SerializeToString(&out);
-                    Request_->SendSerializedResult(std::move(out), record.GetYdbStatus());
+                    Request_->SendSerializedResult(std::move(out), record.GetYdbStatus()); 
                 }
             } else {
                 if (kqpResponse.HasQueryStats()) {
@@ -421,48 +421,48 @@ private:
                 } else {
                     response.mutable_result()->set_query_plan(kqpResponse.GetQueryPlan());
                 }
-
+ 
                 Y_PROTOBUF_SUPPRESS_NODISCARD response.SerializeToString(&out);
-                Request_->SendSerializedResult(std::move(out), record.GetYdbStatus());
+                Request_->SendSerializedResult(std::move(out), record.GetYdbStatus()); 
             }
         }
 
         ReplyFinishStream(record.GetYdbStatus(), issues, ctx);
-    }
-
-    void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& kqpResponse = ev->Get()->Record;
-        NYql::TIssues issues;
-        if (kqpResponse.HasError()) {
-            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, kqpResponse.GetError()));
-        }
-
-        ReplyFinishStream(kqpResponse.GetYdbStatus(), issues, ctx);
-    }
-
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& kqpResponse = ev->Get()->Record; 
+        NYql::TIssues issues; 
+        if (kqpResponse.HasError()) { 
+            issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, kqpResponse.GetError())); 
+        } 
+ 
+        ReplyFinishStream(kqpResponse.GetYdbStatus(), issues, ctx); 
+    } 
+ 
     void Handle(NKqp::TEvKqp::TEvAbortExecution::TPtr& ev, const TActorContext& ctx) {
-        auto& record = ev->Get()->Record;
+        auto& record = ev->Get()->Record; 
 
-        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Got abort execution event, from: "
+        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Got abort execution event, from: " 
             << ev->Sender << ", code: " << Ydb::StatusIds::StatusCode_Name(record.GetStatusCode())
             << ", message: " << record.GetMessage());
 
         NYql::TIssue issue(record.GetMessage());
         ReplyFinishStream(record.GetStatusCode(), issue, ctx);
     }
-
+ 
     void Handle(NKqp::TEvKqpExecuter::TEvStreamData::TPtr& ev, const TActorContext& ctx) {
-        TResponse response;
-        response.set_status(StatusIds::SUCCESS);
+        TResponse response; 
+        response.set_status(StatusIds::SUCCESS); 
         response.mutable_result()->mutable_result_set()->Swap(ev->Get()->Record.MutableResultSet());
-
-        TString out;
+ 
+        TString out; 
         Y_PROTOBUF_SUPPRESS_NODISCARD response.SerializeToString(&out);
-
+ 
         GRpcResponsesSizeQueue_.push(out.size());
         GRpcResponsesSize_ += out.size();
 
-        Request_->SendSerializedResult(std::move(out), StatusIds::SUCCESS);
+        Request_->SendSerializedResult(std::move(out), StatusIds::SUCCESS); 
 
         ui64 freeSpace = GRpcResponsesSize_ < RpcBufferSize_
             ? RpcBufferSize_ - GRpcResponsesSize_
@@ -472,7 +472,7 @@ private:
             WaitOnSeqNo_ = ev->Get()->Record.GetSeqNo();
         }
 
-        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Send stream data ack"
+        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Send stream data ack" 
             << ", seqNo: " << ev->Get()->Record.GetSeqNo()
             << ", freeSpace: " << freeSpace
             << ", to: " << ev->Sender
@@ -482,9 +482,9 @@ private:
         resp->Record.SetSeqNo(ev->Get()->Record.GetSeqNo());
         resp->Record.SetFreeSpace(freeSpace);
 
-        ctx.Send(ev->Sender, resp.Release());
-    }
-
+        ctx.Send(ev->Sender, resp.Release()); 
+    } 
+ 
     void Handle(NKqp::TEvKqpExecuter::TEvStreamProfile::TPtr& ev, const TActorContext&) {
         auto req = Request_->GetProtoRequest();
         if (!NeedReportStats(*req)) {
@@ -499,14 +499,14 @@ private:
 
     void Handle(NKqp::TEvKqpExecuter::TEvExecuterProgress::TPtr& ev, const TActorContext& ctx) {
         ExecuterActorId_ = ActorIdFromProto(ev->Get()->Record.GetExecuterActorId());
-        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " ExecuterActorId: " << ExecuterActorId_);
+        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " ExecuterActorId: " << ExecuterActorId_); 
     }
 
 private:
     void SetTimeoutTimer(TDuration timeout, const TActorContext& ctx) {
-        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Set stream timeout timer for " << timeout);
+        LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Set stream timeout timer for " << timeout); 
 
-        auto *ev = new IEventHandle(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup(EWakeupTag::TimeoutTag));
+        auto *ev = new IEventHandle(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup(EWakeupTag::TimeoutTag)); 
         TimeoutTimerCookieHolder_.Reset(ISchedulerCookie::Make2Way());
         CreateLongTimer(ctx, timeout, ev, 0, TimeoutTimerCookieHolder_.Get());
     }
@@ -517,7 +517,7 @@ private:
         if (ExecuterActorId_) {
             auto abortEv = TEvKqp::TEvAbortExecution::Aborted("Client lost"); // any status code can be here
 
-            ctx.Send(ExecuterActorId_, abortEv.Release());
+            ctx.Send(ExecuterActorId_, abortEv.Release()); 
         }
 
         // We must try to finish stream otherwise grpc will not free allocated memory
@@ -535,14 +535,14 @@ private:
         if (InactiveClientTimeout_ && GRpcResponsesSizeQueue_.size() > 0) {
             TDuration processTime = now - LastDataStreamTimestamp_;
             if (processTime >= InactiveClientTimeout_) {
-                auto message = TStringBuilder() << this->SelfId() << " Client cannot process data in " << processTime
+                auto message = TStringBuilder() << this->SelfId() << " Client cannot process data in " << processTime 
                    << " which exceeds client timeout " << InactiveClientTimeout_;
                 LOG_WARN_S(ctx, NKikimrServices::RPC_REQUEST, message);
 
                 if (ExecuterActorId_) {
                     auto timeoutEv = MakeHolder<TEvKqp::TEvAbortExecution>(Ydb::StatusIds::TIMEOUT, "Client timeout");
 
-                    ctx.Send(ExecuterActorId_, timeoutEv.Release());
+                    ctx.Send(ExecuterActorId_, timeoutEv.Release()); 
                 }
 
                 auto issue = MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, message);
@@ -564,49 +564,49 @@ private:
         ReplyFinishStream(status, issuesMessage, ctx);
     }
 
-    void ReplyFinishStream(Ydb::StatusIds::StatusCode status, const NYql::TIssues& issues, const TActorContext& ctx) {
-        google::protobuf::RepeatedPtrField<TYdbIssueMessageType> issuesMessage;
-        for (auto& issue : issues) {
-            auto item = issuesMessage.Add();
-            NYql::IssueToMessage(issue, item);
-        }
-
-        ReplyFinishStream(status, issuesMessage, ctx);
-    }
-
-    void ReplyFinishStream(Ydb::StatusIds::StatusCode status,
+    void ReplyFinishStream(Ydb::StatusIds::StatusCode status, const NYql::TIssues& issues, const TActorContext& ctx) { 
+        google::protobuf::RepeatedPtrField<TYdbIssueMessageType> issuesMessage; 
+        for (auto& issue : issues) { 
+            auto item = issuesMessage.Add(); 
+            NYql::IssueToMessage(issue, item); 
+        } 
+ 
+        ReplyFinishStream(status, issuesMessage, ctx); 
+    } 
+ 
+    void ReplyFinishStream(Ydb::StatusIds::StatusCode status, 
         const google::protobuf::RepeatedPtrField<TYdbIssueMessageType>& message, const TActorContext& ctx)
-    {
+    { 
         LOG_INFO_S(ctx, NKikimrServices::RPC_REQUEST, "Finish grpc stream, status: "
             << Ydb::StatusIds::StatusCode_Name(status));
 
-        // Skip sending empty result in case of success status - simplify client logic
-        if (status != Ydb::StatusIds::SUCCESS) {
-            TString out;
-            TResponse response;
-            response.set_status(status);
-            response.mutable_issues()->CopyFrom(message);
+        // Skip sending empty result in case of success status - simplify client logic 
+        if (status != Ydb::StatusIds::SUCCESS) { 
+            TString out; 
+            TResponse response; 
+            response.set_status(status); 
+            response.mutable_issues()->CopyFrom(message); 
             Y_PROTOBUF_SUPPRESS_NODISCARD response.SerializeToString(&out);
-            Request_->SendSerializedResult(std::move(out), status);
+            Request_->SendSerializedResult(std::move(out), status); 
         } else {
             for (auto& profile : ExecutionProfiles_) {
-                TResponse response;
-                if (!FillProfile(response, *profile)) {
-                    break;
-                }
+                TResponse response; 
+                if (!FillProfile(response, *profile)) { 
+                    break; 
+                } 
 
                 TString out;
                 Y_PROTOBUF_SUPPRESS_NODISCARD response.SerializeToString(&out);
                 Request_->SendSerializedResult(std::move(out), status);
             }
-        }
-
-        Request_->FinishStream();
-        this->PassAway();
+        } 
+ 
+        Request_->FinishStream(); 
+        this->PassAway(); 
     }
-
-private:
-    std::unique_ptr<TRequestEv> Request_;
+ 
+private: 
+    std::unique_ptr<TRequestEv> Request_; 
     const ui64 RpcBufferSize_;
 
     TDuration InactiveClientTimeout_;
@@ -619,21 +619,21 @@ private:
 
     TVector<std::unique_ptr<NYql::NDqProto::TDqExecutionStats>> ExecutionProfiles_;
     TActorId ExecuterActorId_;
-};
-
-} // namespace
-
-void TGRpcRequestProxy::Handle(TEvExperimentalStreamQueryRequest::TPtr& ev, const TActorContext& ctx) {
-    ui64 rpcBufferSize = GetAppConfig().GetTableServiceConfig().GetResourceManager().GetChannelBufferSize();
-    ctx.Register(new TStreamExecuteScanQueryRPC<TEvExperimentalStreamQueryRequest,
-        Ydb::Experimental::ExecuteStreamQueryResponse>(ev->Release().Release(), rpcBufferSize));
-}
-
-void TGRpcRequestProxy::Handle(TEvStreamExecuteScanQueryRequest::TPtr& ev, const TActorContext& ctx) {
+}; 
+ 
+} // namespace 
+ 
+void TGRpcRequestProxy::Handle(TEvExperimentalStreamQueryRequest::TPtr& ev, const TActorContext& ctx) { 
+    ui64 rpcBufferSize = GetAppConfig().GetTableServiceConfig().GetResourceManager().GetChannelBufferSize(); 
+    ctx.Register(new TStreamExecuteScanQueryRPC<TEvExperimentalStreamQueryRequest, 
+        Ydb::Experimental::ExecuteStreamQueryResponse>(ev->Release().Release(), rpcBufferSize)); 
+} 
+ 
+void TGRpcRequestProxy::Handle(TEvStreamExecuteScanQueryRequest::TPtr& ev, const TActorContext& ctx) { 
     ui64 rpcBufferSize = GetAppConfig().GetTableServiceConfig().GetResourceManager().GetChannelBufferSize();
-    ctx.Register(new TStreamExecuteScanQueryRPC<TEvStreamExecuteScanQueryRequest,
-        Ydb::Table::ExecuteScanQueryPartialResponse>(ev->Release().Release(), rpcBufferSize));
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+    ctx.Register(new TStreamExecuteScanQueryRPC<TEvStreamExecuteScanQueryRequest, 
+        Ydb::Table::ExecuteScanQueryPartialResponse>(ev->Release().Release(), rpcBufferSize)); 
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/core/grpc_services/ya.make b/ydb/core/grpc_services/ya.make
index 05b156bf04..352eae04ee 100644
--- a/ydb/core/grpc_services/ya.make
+++ b/ydb/core/grpc_services/ya.make
@@ -16,11 +16,11 @@ SRCS(
     resolve_local_db_table.cpp
     rpc_alter_coordination_node.cpp
     rpc_alter_table.cpp
-    rpc_begin_transaction.cpp
+    rpc_begin_transaction.cpp 
     rpc_calls.cpp
     rpc_cancel_operation.cpp
     rpc_cms.cpp
-    rpc_commit_transaction.cpp
+    rpc_commit_transaction.cpp 
     rpc_copy_table.cpp
     rpc_copy_tables.cpp
     rpc_export.cpp
@@ -35,11 +35,11 @@ SRCS(
     rpc_drop_coordination_node.cpp
     rpc_drop_table.cpp
     rpc_discovery.cpp
-    rpc_execute_data_query.cpp
-    rpc_execute_scheme_query.cpp
-    rpc_execute_yql_script.cpp
+    rpc_execute_data_query.cpp 
+    rpc_execute_scheme_query.cpp 
+    rpc_execute_yql_script.cpp 
     rpc_explain_yql_script.cpp
-    rpc_explain_data_query.cpp
+    rpc_explain_data_query.cpp 
     rpc_forget_operation.cpp
     rpc_get_operation.cpp
     rpc_get_shard_locations.cpp
@@ -57,16 +57,16 @@ SRCS(
     rpc_make_directory.cpp
     rpc_modify_permissions.cpp
     rpc_monitoring.cpp
-    rpc_prepare_data_query.cpp
+    rpc_prepare_data_query.cpp 
     rpc_rate_limiter_api.cpp
     rpc_read_columns.cpp
     rpc_read_table.cpp
     rpc_remove_directory.cpp
     rpc_rename_tables.cpp
-    rpc_rollback_transaction.cpp
+    rpc_rollback_transaction.cpp 
     rpc_s3_listing.cpp
-    rpc_scheme_base.cpp
-    rpc_stream_execute_scan_query.cpp
+    rpc_scheme_base.cpp 
+    rpc_stream_execute_scan_query.cpp 
     rpc_stream_execute_yql_script.cpp
     rpc_whoami.cpp
     rpc_yq.cpp
diff --git a/ydb/core/grpc_streaming/grpc_streaming.h b/ydb/core/grpc_streaming/grpc_streaming.h
index ecac6fcf17..0d69f1ea90 100644
--- a/ydb/core/grpc_streaming/grpc_streaming.h
+++ b/ydb/core/grpc_streaming/grpc_streaming.h
@@ -589,7 +589,7 @@ private:
         if (flags & FlagStarted) {
             Y_VERIFY(Status);
             if (Counters) {
-                Counters->FinishProcessing(0, 0, Status->ok(), 0, TDuration::Seconds(RequestTimer.Passed()));
+                Counters->FinishProcessing(0, 0, Status->ok(), 0, TDuration::Seconds(RequestTimer.Passed())); 
             }
             DecRequest();
             flags = Flags.load(std::memory_order_acquire);
diff --git a/ydb/core/grpc_streaming/grpc_streaming_ut.cpp b/ydb/core/grpc_streaming/grpc_streaming_ut.cpp
index fe0b6aec6a..cf7e2bb641 100644
--- a/ydb/core/grpc_streaming/grpc_streaming_ut.cpp
+++ b/ydb/core/grpc_streaming/grpc_streaming_ut.cpp
@@ -61,7 +61,7 @@ public:
             acceptCallback,
             ActorSystem,
             "Session",
-            getCounterBlock("streaming", "Session"));
+            getCounterBlock("streaming", "Session")); 
     }
 
     void SetGlobalLimiterHandle(NGrpc::TGlobalLimiter* limiter) override {
diff --git a/ydb/core/kesus/proxy/events.h b/ydb/core/kesus/proxy/events.h
index 2062661bf6..01bcb4a715 100644
--- a/ydb/core/kesus/proxy/events.h
+++ b/ydb/core/kesus/proxy/events.h
@@ -54,7 +54,7 @@ struct TEvKesusProxy {
             : Error(error)
         {}
 
-        TEvProxyError(Ydb::StatusIds::StatusCode status, const TString& reason) {
+        TEvProxyError(Ydb::StatusIds::StatusCode status, const TString& reason) { 
             Error.SetStatus(status);
             Error.AddIssues()->set_message(reason);
         }
diff --git a/ydb/core/kesus/proxy/proxy.cpp b/ydb/core/kesus/proxy/proxy.cpp
index 9633816e60..814e4e2902 100644
--- a/ydb/core/kesus/proxy/proxy.cpp
+++ b/ydb/core/kesus/proxy/proxy.cpp
@@ -89,7 +89,7 @@ private:
                         "Not allowing requests with an empty KesusPath");
                     Send(ev->Sender,
                         new TEvKesusProxy::TEvProxyError(
-                            Ydb::StatusIds::BAD_REQUEST,
+                            Ydb::StatusIds::BAD_REQUEST, 
                             "KesusPath cannot be empty"),
                         0, ev->Cookie);
                     Cache.erase(msg->KesusPath);
@@ -134,7 +134,7 @@ private:
                     LOG_DEBUG_S(ctx, NKikimrServices::KESUS_PROXY,
                         "Received an OK result for " << msg->KesusPath.Quote()
                         << " without KesusInfo: not found");
-                    entry.LastError.SetStatus(Ydb::StatusIds::NOT_FOUND);
+                    entry.LastError.SetStatus(Ydb::StatusIds::NOT_FOUND); 
                     entry.LastError.AddIssues()->set_message("Kesus not found");
                     break;
                 }
@@ -148,7 +148,7 @@ private:
                     entry.LastError.AddIssues()->set_message("Kesus not found");
                     break;
                 }
-                entry.LastError.SetStatus(Ydb::StatusIds::SUCCESS);
+                entry.LastError.SetStatus(Ydb::StatusIds::SUCCESS); 
                 entry.SecurityObject = result.SecurityObject;
                 if (entry.ProxyActor && entry.TabletId != tabletId) {
                     // Kill the old proxy
@@ -175,17 +175,17 @@ private:
                 LOG_TRACE_S(ctx, NKikimrServices::KESUS_PROXY,
                     "Resolve did not find path " << msg->KesusPath.Quote()
                     << ": " << result.Status);
-                entry.LastError.SetStatus(Ydb::StatusIds::NOT_FOUND);
+                entry.LastError.SetStatus(Ydb::StatusIds::NOT_FOUND); 
                 entry.LastError.AddIssues()->set_message("Kesus not found");
                 break;
             default:
                 LOG_ERROR_S(ctx, NKikimrServices::KESUS_PROXY,
                     "Kesus resolve failed: " << result.Status);
-                entry.LastError.SetStatus(Ydb::StatusIds::INTERNAL_ERROR);
+                entry.LastError.SetStatus(Ydb::StatusIds::INTERNAL_ERROR); 
                 entry.LastError.AddIssues()->set_message(ToString(result.Status));
                 break;
         }
-        if (entry.ProxyActor && entry.LastError.GetStatus() != Ydb::StatusIds::SUCCESS) {
+        if (entry.ProxyActor && entry.LastError.GetStatus() != Ydb::StatusIds::SUCCESS) { 
             // Entry expired, kill the proxy
             LOG_INFO_S(ctx, NKikimrServices::KESUS_PROXY,
                 "Destroying kesus proxy for path " << msg->KesusPath.Quote());
@@ -193,7 +193,7 @@ private:
             entry.ProxyActor = {};
         }
         for (const auto& subscriber : entry.ResolveSubscribers) {
-            if (entry.LastError.GetStatus() != Ydb::StatusIds::SUCCESS) {
+            if (entry.LastError.GetStatus() != Ydb::StatusIds::SUCCESS) { 
                 Send(subscriber.Sender,
                     new TEvKesusProxy::TEvProxyError(entry.LastError),
                     0, subscriber.Cookie);
diff --git a/ydb/core/kesus/proxy/proxy_actor.cpp b/ydb/core/kesus/proxy/proxy_actor.cpp
index e93d90355f..c14dc75c2e 100644
--- a/ydb/core/kesus/proxy/proxy_actor.cpp
+++ b/ydb/core/kesus/proxy/proxy_actor.cpp
@@ -253,7 +253,7 @@ private:
 
     void HandleLinkFailure() {
         NKikimrKesus::TKesusError error;
-        error.SetStatus(Ydb::StatusIds::UNAVAILABLE);
+        error.SetStatus(Ydb::StatusIds::UNAVAILABLE); 
         error.AddIssues()->set_message("Link failure");
         HandleLinkError(error);
     }
@@ -358,7 +358,7 @@ private:
             return;
         }
 
-        if (record.GetError().GetStatus() != Ydb::StatusIds::SUCCESS) {
+        if (record.GetError().GetStatus() != Ydb::StatusIds::SUCCESS) { 
             Y_FAIL("Unexpected proxy registration error");
         }
 
@@ -544,7 +544,7 @@ private:
                     new TEvKesus::TEvAttachSessionResult(
                         ProxyGeneration,
                         record.GetSessionId(),
-                        Ydb::StatusIds::BAD_SESSION,
+                        Ydb::StatusIds::BAD_SESSION, 
                         "Attach request is out of sequence"),
                     0, ev->Cookie);
                 return;
@@ -555,7 +555,7 @@ private:
                     new TEvKesus::TEvAttachSessionResult(
                         ProxyGeneration,
                         record.GetSessionId(),
-                        Ydb::StatusIds::SESSION_EXPIRED,
+                        Ydb::StatusIds::SESSION_EXPIRED, 
                         "Session is already being destroyed"),
                     0, ev->Cookie);
                 return;
@@ -564,7 +564,7 @@ private:
                 KPROXY_LOG_TRACE_S("Sending BAD_SESSION to " << data->Owner);
                 Send(data->Owner,
                     new TEvKesusProxy::TEvProxyError(
-                        Ydb::StatusIds::BAD_SESSION,
+                        Ydb::StatusIds::BAD_SESSION, 
                         "Session stolen by another local client"),
                     0, data->OwnerCookie);
             }
@@ -600,7 +600,7 @@ private:
             return;
         }
 
-        bool isError = record.GetError().GetStatus() != Ydb::StatusIds::SUCCESS;
+        bool isError = record.GetError().GetStatus() != Ydb::StatusIds::SUCCESS; 
         if (auto* data = FindSession(ev->Cookie)) {
             if (!data->SessionId) {
                 // New session and we finally know its id
@@ -649,7 +649,7 @@ private:
         KPROXY_LOG_TRACE_S("Received TEvProxyExpired with ProxyGeneration=" << ProxyGeneration);
 
         NKikimrKesus::TKesusError error;
-        error.SetStatus(Ydb::StatusIds::BAD_SESSION);
+        error.SetStatus(Ydb::StatusIds::BAD_SESSION); 
         error.AddIssues()->set_message("Proxy session expired");
         HandleSessionError(error);
 
@@ -668,7 +668,7 @@ private:
                 KPROXY_LOG_TRACE_S("Sending SESSION_EXPIRED to " << data->Owner);
                 Send(data->Owner,
                     new TEvKesusProxy::TEvProxyError(
-                        Ydb::StatusIds::SESSION_EXPIRED,
+                        Ydb::StatusIds::SESSION_EXPIRED, 
                         "Session has expired"),
                     0, data->OwnerCookie);
             }
@@ -688,7 +688,7 @@ private:
                 KPROXY_LOG_TRACE_S("Sending BAD_SESSION to " << data->Owner);
                 Send(data->Owner,
                     new TEvKesusProxy::TEvProxyError(
-                        Ydb::StatusIds::BAD_SESSION,
+                        Ydb::StatusIds::BAD_SESSION, 
                         "Session stolen by another remote client"),
                     0, data->OwnerCookie);
             }
@@ -723,7 +723,7 @@ private:
         KPROXY_LOG_TRACE_S("Sending BAD_SESSION to " << ev->Sender);
         Send(ev->Sender,
             new TEvKesusProxy::TEvProxyError(
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 "Session is not attached"),
             0, ev->Cookie);
     }
@@ -769,7 +769,7 @@ private:
         KPROXY_LOG_TRACE_S("Sending BAD_SESSION to " << sender);
         Send(sender,
             new TEvKesusProxy::TEvProxyError(
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 "Session is not attached"),
             0, cookie);
     }
diff --git a/ydb/core/kesus/proxy/proxy_actor_ut.cpp b/ydb/core/kesus/proxy/proxy_actor_ut.cpp
index 98c8a95574..91a01d5e23 100644
--- a/ydb/core/kesus/proxy/proxy_actor_ut.cpp
+++ b/ydb/core/kesus/proxy/proxy_actor_ut.cpp
@@ -22,7 +22,7 @@ Y_UNIT_TEST_SUITE(TProxyActorTest) {
         auto edge = ctx.Runtime->AllocateEdgeActor(1);
         ctx.SendFromEdge(42, edge, new TEvKesus::TEvCreateSemaphore("", "Sem2", 2), cookie);
         ctx.RebootTablet();
-        ctx.ExpectProxyError(edge, cookie, Ydb::StatusIds::UNAVAILABLE);
+        ctx.ExpectProxyError(edge, cookie, Ydb::StatusIds::UNAVAILABLE); 
     }
 
     Y_UNIT_TEST(TestAttachSession) {
@@ -38,23 +38,23 @@ Y_UNIT_TEST_SUITE(TProxyActorTest) {
         auto req2 = ctx.Runtime->AllocateEdgeActor(1);
         auto req2cookie = ctx.SendAttachSession(42, req2, 1, 0, "", 222);
         UNIT_ASSERT_VALUES_EQUAL(ctx.ExpectAttachSessionResult(req2, req2cookie), 1);
-        ctx.ExpectProxyError(req1, req1cookie, Ydb::StatusIds::BAD_SESSION);
+        ctx.ExpectProxyError(req1, req1cookie, Ydb::StatusIds::BAD_SESSION); 
 
         // Reattach session 1 from a different proxy
         auto req3 = ctx.Runtime->AllocateEdgeActor(1);
         auto req3cookie = ctx.SendAttachSession(43, req3, 1, 0, "", 333);
         UNIT_ASSERT_VALUES_EQUAL(ctx.ExpectAttachSessionResult(req3, req3cookie), 1);
-        ctx.ExpectProxyError(req2, req2cookie, Ydb::StatusIds::BAD_SESSION);
+        ctx.ExpectProxyError(req2, req2cookie, Ydb::StatusIds::BAD_SESSION); 
 
         // Test out of sequence on the owner proxy
         auto req4 = ctx.Runtime->AllocateEdgeActor(1);
         auto req4cookie = ctx.SendAttachSession(43, req4, 1, 0, "", 42);
-        ctx.ExpectAttachSessionResult(req4, req4cookie, Ydb::StatusIds::BAD_SESSION);
+        ctx.ExpectAttachSessionResult(req4, req4cookie, Ydb::StatusIds::BAD_SESSION); 
 
         // Test out of sequence on the non-owner proxy
         auto req5 = ctx.Runtime->AllocateEdgeActor(1);
         auto req5cookie = ctx.SendAttachSession(42, req5, 1, 0, "", 42);
-        ctx.ExpectAttachSessionResult(req5, req5cookie, Ydb::StatusIds::BAD_SESSION);
+        ctx.ExpectAttachSessionResult(req5, req5cookie, Ydb::StatusIds::BAD_SESSION); 
     }
 }
 
diff --git a/ydb/core/kesus/proxy/ut_helpers.cpp b/ydb/core/kesus/proxy/ut_helpers.cpp
index 74580d10f7..2c246de3c4 100644
--- a/ydb/core/kesus/proxy/ut_helpers.cpp
+++ b/ydb/core/kesus/proxy/ut_helpers.cpp
@@ -82,7 +82,7 @@ void TTestContext::ExpectProxyError(const TActorId& edge, ui64 cookie, Ydb::Stat
 }
 
 void TTestContext::CreateSemaphore(
-    ui64 proxyId, const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status)
+    ui64 proxyId, const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status) 
 {
     ui64 cookie = RandomNumber<ui64>();
     auto edge = Runtime->AllocateEdgeActor(1);
@@ -91,7 +91,7 @@ void TTestContext::CreateSemaphore(
     UNIT_ASSERT_VALUES_EQUAL(result->Record.GetError().GetStatus(), status);
 }
 
-void TTestContext::DeleteSemaphore(ui64 proxyId, const TString& name, Ydb::StatusIds::StatusCode status) {
+void TTestContext::DeleteSemaphore(ui64 proxyId, const TString& name, Ydb::StatusIds::StatusCode status) { 
     ui64 cookie = RandomNumber<ui64>();
     auto edge = Runtime->AllocateEdgeActor(1);
     SendFromEdge(proxyId, edge, new TEvKesus::TEvDeleteSemaphore("", name), cookie);
@@ -121,7 +121,7 @@ TTestContext::TSimpleSemaphoreDescription TTestContext::DescribeSemaphore(ui64 p
     request->Record.SetIncludeWaiters(includeWaiters);
     SendFromEdge(proxyId, edge, request, cookie);
     auto event = ExpectEdgeEvent<TEvKesus::TEvDescribeSemaphoreResult>(edge, cookie);
-    UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::SUCCESS);
+    UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::SUCCESS); 
     const auto& desc = event->Record.GetSemaphoreDescription();
 
     TSimpleSemaphoreDescription result;
@@ -142,7 +142,7 @@ void TTestContext::VerifySemaphoreNotFound(ui64 proxyId, const TString& name) {
     TActorId edge = Runtime->AllocateEdgeActor(1);
     SendFromEdge(proxyId, edge, new TEvKesus::TEvDescribeSemaphore("", name), cookie);
     auto event = ExpectEdgeEvent<TEvKesus::TEvDescribeSemaphoreResult>(edge, cookie);
-    UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::NOT_FOUND);
+    UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::NOT_FOUND); 
 }
 
 void TTestContext::VerifySemaphoreParams(ui64 proxyId, const TString& name, ui64 limit, const TString& data, bool ephemeral) {
diff --git a/ydb/core/kesus/proxy/ut_helpers.h b/ydb/core/kesus/proxy/ut_helpers.h
index 20bcbac73f..4ce4939aef 100644
--- a/ydb/core/kesus/proxy/ut_helpers.h
+++ b/ydb/core/kesus/proxy/ut_helpers.h
@@ -60,13 +60,13 @@ struct TTestContext {
     void ExpectProxyError(const TActorId& edge, ui64 cookie, Ydb::StatusIds::StatusCode status);
 
     void CreateSemaphore(ui64 proxyId, const TString& name, ui64 limit, const TString& data,
-        Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS);
+        Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS); 
 
-    void CreateSemaphore(ui64 proxyId, const TString& name, ui64 limit, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS) {
+    void CreateSemaphore(ui64 proxyId, const TString& name, ui64 limit, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS) { 
         CreateSemaphore(proxyId, name, limit, TString(), status);
     }
 
-    void DeleteSemaphore(ui64 proxyId, const TString& name, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS);
+    void DeleteSemaphore(ui64 proxyId, const TString& name, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS); 
 
     // Returns a cookie used for the session
     ui64 SendAttachSession(
diff --git a/ydb/core/kesus/tablet/events.h b/ydb/core/kesus/tablet/events.h
index 872f0149c9..c0b6ac030c 100644
--- a/ydb/core/kesus/tablet/events.h
+++ b/ydb/core/kesus/tablet/events.h
@@ -96,8 +96,8 @@ struct TEvKesus {
     static_assert(EvEnd <= EventSpaceEnd(TKikimrEvents::ES_KESUS),
         "expected EvEnd <= EventSpaceEnd(TKikimrEvents::ES_KESUS)");
 
-    inline static void FillError(NKikimrKesus::TKesusError* error, Ydb::StatusIds::StatusCode status, const TString& reason) {
-        Y_VERIFY(status != Ydb::StatusIds::SUCCESS, "Attempting to set error to SUCCESS");
+    inline static void FillError(NKikimrKesus::TKesusError* error, Ydb::StatusIds::StatusCode status, const TString& reason) { 
+        Y_VERIFY(status != Ydb::StatusIds::SUCCESS, "Attempting to set error to SUCCESS"); 
         error->SetStatus(status);
         error->AddIssues()->set_message(reason);
     }
@@ -147,7 +147,7 @@ struct TEvKesus {
         TEvSetConfigResult(ui64 txId, ui64 tabletId) {
             Record.SetTxId(txId);
             Record.SetTabletId(tabletId);
-            Record.MutableError()->SetStatus(Ydb::StatusIds::SUCCESS);
+            Record.MutableError()->SetStatus(Ydb::StatusIds::SUCCESS); 
         }
 
         void SetError(Ydb::StatusIds::StatusCode status, const TString& reason) {
@@ -300,7 +300,7 @@ struct TEvKesus {
             Record.SetSessionId(sessionId);
         }
 
-        TEvAttachSessionResult(ui64 generation, ui64 sessionId, Ydb::StatusIds::StatusCode status, const TString& reason)
+        TEvAttachSessionResult(ui64 generation, ui64 sessionId, Ydb::StatusIds::StatusCode status, const TString& reason) 
             : TResultBase(generation, status, reason)
         {
             Record.SetSessionId(sessionId);
@@ -370,7 +370,7 @@ struct TEvKesus {
             Record.SetAcquired(acquired);
         }
 
-        TEvAcquireSemaphoreResult(ui64 generation, Ydb::StatusIds::StatusCode status, const TString& reason)
+        TEvAcquireSemaphoreResult(ui64 generation, Ydb::StatusIds::StatusCode status, const TString& reason) 
             : TResultBase(generation, status, reason)
         {
         }
@@ -396,7 +396,7 @@ struct TEvKesus {
             Record.SetReleased(released);
         }
 
-        TEvReleaseSemaphoreResult(ui64 generation, Ydb::StatusIds::StatusCode status, const TString& reason)
+        TEvReleaseSemaphoreResult(ui64 generation, Ydb::StatusIds::StatusCode status, const TString& reason) 
             : TResultBase(generation, status, reason)
         {
         }
diff --git a/ydb/core/kesus/tablet/tablet_db.cpp b/ydb/core/kesus/tablet/tablet_db.cpp
index e4d9a1e276..67f0c88286 100644
--- a/ydb/core/kesus/tablet/tablet_db.cpp
+++ b/ydb/core/kesus/tablet/tablet_db.cpp
@@ -73,7 +73,7 @@ void TKesusTablet::DoDeleteSemaphore(
                     cookie,
                     new TEvKesus::TEvAcquireSemaphoreResult(
                         proxy->Generation,
-                        Ydb::StatusIds::ABORTED,
+                        Ydb::StatusIds::ABORTED, 
                         "Semaphore destroyed"));
             });
         }
diff --git a/ydb/core/kesus/tablet/tablet_impl.cpp b/ydb/core/kesus/tablet/tablet_impl.cpp
index 245c4b91b8..14aa7b1e15 100644
--- a/ydb/core/kesus/tablet/tablet_impl.cpp
+++ b/ydb/core/kesus/tablet/tablet_impl.cpp
@@ -182,7 +182,7 @@ void TKesusTablet::Handle(TEvKesus::TEvRegisterProxy::TPtr& ev) {
         Send(ev->Sender,
             new TEvKesus::TEvRegisterProxyResult(
                 record.GetProxyGeneration(),
-                Ydb::StatusIds::BAD_REQUEST,
+                Ydb::StatusIds::BAD_REQUEST, 
                 "ProxyGeneration must be greater than zero"),
             0, ev->Cookie);
         return;
@@ -193,7 +193,7 @@ void TKesusTablet::Handle(TEvKesus::TEvRegisterProxy::TPtr& ev) {
         Send(ev->Sender,
             new TEvKesus::TEvRegisterProxyResult(
                 record.GetProxyGeneration(),
-                Ydb::StatusIds::BAD_REQUEST,
+                Ydb::StatusIds::BAD_REQUEST, 
                 "ProxyGeneration is expected to always increase"),
             0, ev->Cookie);
         return;
@@ -223,7 +223,7 @@ void TKesusTablet::Handle(TEvKesus::TEvUnregisterProxy::TPtr& ev) {
         Send(ev->Sender,
             new TEvKesus::TEvUnregisterProxyResult(
                 record.GetProxyGeneration(),
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 proxy ? "ProxyGeneration mismatch" : "Proxy is not registered"),
             0, ev->Cookie);
         return;
diff --git a/ydb/core/kesus/tablet/tablet_ut.cpp b/ydb/core/kesus/tablet/tablet_ut.cpp
index 1cf1a80ca8..0ba74a3cbf 100644
--- a/ydb/core/kesus/tablet/tablet_ut.cpp
+++ b/ydb/core/kesus/tablet/tablet_ut.cpp
@@ -92,10 +92,10 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.Setup();
         auto proxy = ctx.Runtime->AllocateEdgeActor();
         // cannot use generation 0
-        ctx.MustRegisterProxy(proxy, 0, Ydb::StatusIds::BAD_REQUEST);
+        ctx.MustRegisterProxy(proxy, 0, Ydb::StatusIds::BAD_REQUEST); 
         ctx.MustRegisterProxy(proxy, 2);
         // cannot reuse the same generation
-        ctx.MustRegisterProxy(proxy, 2, Ydb::StatusIds::BAD_REQUEST);
+        ctx.MustRegisterProxy(proxy, 2, Ydb::StatusIds::BAD_REQUEST); 
     }
 
     Y_UNIT_TEST(TestRegisterProxyFromDeadActor) {
@@ -148,7 +148,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         auto proxy = ctx.Runtime->AllocateEdgeActor();
         ctx.MustRegisterProxy(proxy, 1);
         ctx.MustRegisterProxy(proxy, 2);
-        ctx.MustUnregisterProxy(proxy, 1, Ydb::StatusIds::BAD_SESSION);
+        ctx.MustUnregisterProxy(proxy, 1, Ydb::StatusIds::BAD_SESSION); 
     }
 
     Y_UNIT_TEST(TestAttachNewSessions) {
@@ -167,7 +167,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         auto proxy = ctx.Runtime->AllocateEdgeActor();
         ctx.MustRegisterProxy(proxy, 1);
         auto result = ctx.AttachSession(proxy, 1, 1);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetError().GetStatus(), Ydb::StatusIds::SESSION_EXPIRED);
+        UNIT_ASSERT_VALUES_EQUAL(result.GetError().GetStatus(), Ydb::StatusIds::SESSION_EXPIRED); 
     }
 
     Y_UNIT_TEST(TestAttachOldGeneration) {
@@ -176,7 +176,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         auto proxy = ctx.Runtime->AllocateEdgeActor();
         ctx.RegisterProxy(proxy, 2); // register with generation 2
         auto result1 = ctx.AttachSession(proxy, 1, 0); // attach with generation 1
-        UNIT_ASSERT_VALUES_EQUAL(result1.GetError().GetStatus(), Ydb::StatusIds::BAD_SESSION);
+        UNIT_ASSERT_VALUES_EQUAL(result1.GetError().GetStatus(), Ydb::StatusIds::BAD_SESSION); 
         ui64 sessionId = ctx.MustAttachSession(proxy, 2, 0); // retry with generation 2
         UNIT_ASSERT_VALUES_EQUAL(sessionId, 1);
         ctx.VerifyProxyHasSessions(proxy, 2, {1});
@@ -191,7 +191,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.RegisterProxy(proxy2, 1);
         ctx.MustAttachSession(proxy1, 1, 0, 0, "", 222);
         auto result = ctx.AttachSession(proxy2, 1, 1, 0, "", 111);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetError().GetStatus(), Ydb::StatusIds::BAD_SESSION);
+        UNIT_ASSERT_VALUES_EQUAL(result.GetError().GetStatus(), Ydb::StatusIds::BAD_SESSION); 
 
         // verify proxy2 did not steal the session
         ctx.VerifyProxyHasSessions(proxy1, 1, {1});
@@ -205,7 +205,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.SendAttachSession(111, proxy, 1, 0, 0, "", 42);
         ctx.SendAttachSession(222, proxy, 1, 1, 0, "", 41);
         ctx.ExpectAttachSessionResult(111, proxy, 1);
-        ctx.ExpectAttachSessionResult(222, proxy, 1, Ydb::StatusIds::BAD_SESSION);
+        ctx.ExpectAttachSessionResult(222, proxy, 1, Ydb::StatusIds::BAD_SESSION); 
         ctx.VerifyProxyHasSessions(proxy, 1, {1});
     }
 
@@ -271,21 +271,21 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.MustAttachSession(proxy1, 1, 0, 1000);
         ctx.VerifyProxyHasSessions(proxy1, 1, {1});
         // Cannot detach using wrong generation
-        ctx.MustDetachSession(proxy1, 2, 1, Ydb::StatusIds::BAD_SESSION);
+        ctx.MustDetachSession(proxy1, 2, 1, Ydb::StatusIds::BAD_SESSION); 
         // Cannot detach from unregistered proxy
         auto proxy2 = ctx.Runtime->AllocateEdgeActor();
-        ctx.MustDetachSession(proxy2, 1, 1, Ydb::StatusIds::BAD_SESSION);
+        ctx.MustDetachSession(proxy2, 1, 1, Ydb::StatusIds::BAD_SESSION); 
         // Cannot detach from registered non-owner proxy
         ctx.MustRegisterProxy(proxy2, 1);
-        ctx.MustDetachSession(proxy2, 1, 1, Ydb::StatusIds::BAD_SESSION);
+        ctx.MustDetachSession(proxy2, 1, 1, Ydb::StatusIds::BAD_SESSION); 
         // Cannot detach sessions that don't exist
-        ctx.MustDetachSession(proxy1, 1, 2, Ydb::StatusIds::SESSION_EXPIRED);
+        ctx.MustDetachSession(proxy1, 1, 2, Ydb::StatusIds::SESSION_EXPIRED); 
         // OK to detach if everything checks out
         ctx.VerifyProxyHasSessions(proxy1, 1, {1});
         ctx.MustDetachSession(proxy1, 1, 1);
         ctx.VerifyProxyHasSessions(proxy1, 1, {});
         // Cannot detach it twice in a row
-        ctx.MustDetachSession(proxy1, 1, 1, Ydb::StatusIds::BAD_SESSION);
+        ctx.MustDetachSession(proxy1, 1, 1, Ydb::StatusIds::BAD_SESSION); 
         // Attach it again and make sure it works with in-flight transactions
         ctx.MustAttachSession(proxy1, 1, 1);
         ctx.SendAcquireLock(111, proxy1, 1, 1, "Lock1", LOCK_MODE_EXCLUSIVE);
@@ -336,7 +336,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         auto proxy = ctx.Runtime->AllocateEdgeActor();
         ctx.RegisterProxy(proxy, 1);
         auto result = ctx.AttachSession(proxy, 1, 0, TDuration::Days(2).MilliSeconds());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetError().GetStatus(), Ydb::StatusIds::BAD_REQUEST);
+        UNIT_ASSERT_VALUES_EQUAL(result.GetError().GetStatus(), Ydb::StatusIds::BAD_REQUEST); 
     }
 
     Y_UNIT_TEST(TestSessionTimeoutAfterDetach) {
@@ -547,7 +547,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.SendAcquireLock(111, proxy, 1, 1, "Lock1", LOCK_MODE_SHARED);
         ctx.ExpectAcquireLockResult(111, proxy, 1);
         ctx.SendAcquireLock(222, proxy, 1, 1, "Lock1", LOCK_MODE_EXCLUSIVE);
-        ctx.ExpectAcquireLockResult(222, proxy, 1, Ydb::StatusIds::BAD_REQUEST);
+        ctx.ExpectAcquireLockResult(222, proxy, 1, Ydb::StatusIds::BAD_REQUEST); 
         ctx.VerifyLockShared("Lock1", {1}); // still locked in shared mode
     }
 
@@ -691,7 +691,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.VerifyLockWaiters("Lock2", {2}); // verify session2 still waiting for Lock2
         // now session2 changes mode to shared, old request is dropped, new request succeeds
         ctx.SendAcquireLock(444, proxy2, 1, 2, "Lock2", LOCK_MODE_SHARED);
-        ctx.ExpectAcquireLockResult(223, proxy2, 1, Ydb::StatusIds::ABORTED);
+        ctx.ExpectAcquireLockResult(223, proxy2, 1, Ydb::StatusIds::ABORTED); 
         ctx.ExpectAcquireLockResult(444, proxy2, 1);
         ctx.VerifyLockShared("Lock2", {1, 2});
         ctx.VerifyLockWaiters("Lock2", {});
@@ -775,7 +775,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         // now it immediately changes mode to shared
         ctx.SendAcquireLock(333, proxy, 1, 2, "Lock1", LOCK_MODE_SHARED, 30000);
         // first request gets cancelled, second succeeds
-        ctx.ExpectAcquireLockResult(222, proxy, 1, Ydb::StatusIds::ABORTED);
+        ctx.ExpectAcquireLockResult(222, proxy, 1, Ydb::StatusIds::ABORTED); 
         ctx.ExpectAcquireLockResult(333, proxy, 1);
         ctx.VerifyLockShared("Lock1", {1, 2});
     }
@@ -794,7 +794,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.SendAcquireLock(222, proxy, 1, 2, "Lock1", LOCK_MODE_SHARED, 30000);
         // now it immediately changes mode to exclusive
         ctx.SendAcquireLock(333, proxy, 1, 2, "Lock1", LOCK_MODE_EXCLUSIVE, 30000);
-        ctx.ExpectAcquireLockResult(333, proxy, 1, Ydb::StatusIds::BAD_REQUEST);
+        ctx.ExpectAcquireLockResult(333, proxy, 1, Ydb::StatusIds::BAD_REQUEST); 
         // the old request must still be waiting
         ctx.VerifyLockExclusive("Lock1", 1);
         ctx.VerifyLockWaiters("Lock1", {2});
@@ -817,7 +817,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         // now it immediately changes timeout to zero
         ctx.SendAcquireLock(333, proxy, 1, 2, "Lock1", LOCK_MODE_SHARED, 0);
         // it must receive correct replies
-        ctx.ExpectAcquireLockResult(222, proxy, 1, Ydb::StatusIds::ABORTED);
+        ctx.ExpectAcquireLockResult(222, proxy, 1, Ydb::StatusIds::ABORTED); 
         ctx.ExpectAcquireLockResult(333, proxy, 1, false);
         // there must be no waiters
         ctx.VerifyLockExclusive("Lock1", 1);
@@ -843,7 +843,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.SendAcquireLock(222, proxy, 1, 2, "Lock1", LOCK_MODE_SHARED, 30000);
         // now it immediately tries to release it
         ctx.MustReleaseLock(333, proxy, 1, 2, "Lock1");
-        ctx.ExpectAcquireLockResult(222, proxy, 1, Ydb::StatusIds::ABORTED);
+        ctx.ExpectAcquireLockResult(222, proxy, 1, Ydb::StatusIds::ABORTED); 
     }
 
     Y_UNIT_TEST(TestReleaseLockFailure) {
@@ -871,12 +871,12 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.SendAcquireLock(111, proxy, 1, 1, "Lock1", LOCK_MODE_EXCLUSIVE);
         ctx.ExpectAcquireLockResult(111, proxy, 1);
 
-        ctx.CreateSemaphore("Sem1", 0, Ydb::StatusIds::BAD_REQUEST);
+        ctx.CreateSemaphore("Sem1", 0, Ydb::StatusIds::BAD_REQUEST); 
         ctx.CreateSemaphore("Sem1", 42);
-        ctx.CreateSemaphore("Sem1", 42, Ydb::StatusIds::ALREADY_EXISTS);
-        ctx.CreateSemaphore("Sem1", 51, Ydb::StatusIds::ALREADY_EXISTS);
-        ctx.CreateSemaphore("Lock1", 42, Ydb::StatusIds::PRECONDITION_FAILED);
-        ctx.CreateSemaphore("Lock1", -1, Ydb::StatusIds::PRECONDITION_FAILED);
+        ctx.CreateSemaphore("Sem1", 42, Ydb::StatusIds::ALREADY_EXISTS); 
+        ctx.CreateSemaphore("Sem1", 51, Ydb::StatusIds::ALREADY_EXISTS); 
+        ctx.CreateSemaphore("Lock1", 42, Ydb::StatusIds::PRECONDITION_FAILED); 
+        ctx.CreateSemaphore("Lock1", -1, Ydb::StatusIds::PRECONDITION_FAILED); 
         ctx.VerifySemaphoreOwners("Sem1", {});
         ctx.VerifySemaphoreNotFound("Sem2");
 
@@ -894,11 +894,11 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.SendAcquireLock(111, proxy, 1, 1, "Lock1", LOCK_MODE_EXCLUSIVE);
         ctx.ExpectAcquireLockResult(111, proxy, 1);
 
-        ctx.DeleteSemaphore("Lock1", Ydb::StatusIds::PRECONDITION_FAILED);
-        ctx.DeleteSemaphore("Sem1", Ydb::StatusIds::NOT_FOUND);
+        ctx.DeleteSemaphore("Lock1", Ydb::StatusIds::PRECONDITION_FAILED); 
+        ctx.DeleteSemaphore("Sem1", Ydb::StatusIds::NOT_FOUND); 
         ctx.CreateSemaphore("Sem1", 42);
         ctx.DeleteSemaphore("Sem1");
-        ctx.DeleteSemaphore("Sem1", Ydb::StatusIds::NOT_FOUND);
+        ctx.DeleteSemaphore("Sem1", Ydb::StatusIds::NOT_FOUND); 
     }
 
     Y_UNIT_TEST(TestAcquireSemaphore) {
@@ -910,17 +910,17 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.MustAttachSession(proxy, 1, 0, 30000);
 
         ctx.SendAcquireSemaphore(111, proxy, 1, 1, "Sem1", 1);
-        ctx.ExpectAcquireSemaphoreResult(111, proxy, 1, Ydb::StatusIds::NOT_FOUND);
+        ctx.ExpectAcquireSemaphoreResult(111, proxy, 1, Ydb::StatusIds::NOT_FOUND); 
 
         ctx.CreateSemaphore("Sem1", 1);
 
         // cannot acquire 0 tokens
         ctx.SendAcquireSemaphore(222, proxy, 1, 1, "Sem1", 0);
-        ctx.ExpectAcquireSemaphoreResult(222, proxy, 1, Ydb::StatusIds::BAD_REQUEST);
+        ctx.ExpectAcquireSemaphoreResult(222, proxy, 1, Ydb::StatusIds::BAD_REQUEST); 
 
         // cannot acquire more tokens than available
         ctx.SendAcquireSemaphore(333, proxy, 1, 1, "Sem1", 100500);
-        ctx.ExpectAcquireSemaphoreResult(333, proxy, 1, Ydb::StatusIds::BAD_REQUEST);
+        ctx.ExpectAcquireSemaphoreResult(333, proxy, 1, Ydb::StatusIds::BAD_REQUEST); 
 
         ctx.SendAcquireSemaphore(222, proxy, 1, 1, "Sem1", 1);
         ctx.SendAcquireSemaphore(333, proxy, 1, 2, "Sem1", 1, 60000);
@@ -930,11 +930,11 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.VerifySemaphoreWaiters("Sem1", {2});
 
         // Cannot destroy semaphore unless forced
-        ctx.DeleteSemaphore("Sem1", Ydb::StatusIds::PRECONDITION_FAILED);
+        ctx.DeleteSemaphore("Sem1", Ydb::StatusIds::PRECONDITION_FAILED); 
         ctx.DeleteSemaphore("Sem1", true);
 
         // Forced destruction aborts the request
-        ctx.ExpectAcquireSemaphoreResult(333, proxy, 1, Ydb::StatusIds::ABORTED);
+        ctx.ExpectAcquireSemaphoreResult(333, proxy, 1, Ydb::StatusIds::ABORTED); 
     }
 
     Y_UNIT_TEST(TestReleaseSemaphore) {
@@ -994,7 +994,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
 
         ctx.CreateSemaphore("Sem1", 1);
         ctx.SendAcquireSemaphore(111, proxy, 1, 1, "Sem1", 1, TDuration::Days(2).MilliSeconds());
-        ctx.ExpectAcquireSemaphoreResult(111, proxy, 1, Ydb::StatusIds::BAD_REQUEST);
+        ctx.ExpectAcquireSemaphoreResult(111, proxy, 1, Ydb::StatusIds::BAD_REQUEST); 
     }
 
     Y_UNIT_TEST(TestAcquireSemaphoreTimeoutInfinite) {
@@ -1106,14 +1106,14 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         UNIT_ASSERT_VALUES_EQUAL(ctx.DescribeSemaphore("Sem2").Data, "\x81\x82\x83\x84");
 
         // ALREADY_EXISTS should not update the data
-        ctx.CreateSemaphore("Sem1", 1, "\x81\x82\x83\x84", Ydb::StatusIds::ALREADY_EXISTS);
-        ctx.CreateSemaphore("Sem2", 1, "", Ydb::StatusIds::ALREADY_EXISTS);
+        ctx.CreateSemaphore("Sem1", 1, "\x81\x82\x83\x84", Ydb::StatusIds::ALREADY_EXISTS); 
+        ctx.CreateSemaphore("Sem2", 1, "", Ydb::StatusIds::ALREADY_EXISTS); 
         UNIT_ASSERT_VALUES_EQUAL(ctx.DescribeSemaphore("Sem1").Data, "");
         UNIT_ASSERT_VALUES_EQUAL(ctx.DescribeSemaphore("Sem2").Data, "\x81\x82\x83\x84");
 
         ctx.UpdateSemaphore("Sem1", "\x85\x86\x87\x88");
         ctx.UpdateSemaphore("Sem2", "foobar");
-        ctx.UpdateSemaphore("Sem3", "foobarbaz", Ydb::StatusIds::NOT_FOUND);
+        ctx.UpdateSemaphore("Sem3", "foobarbaz", Ydb::StatusIds::NOT_FOUND); 
         UNIT_ASSERT_VALUES_EQUAL(ctx.DescribeSemaphore("Sem1").Data, "\x85\x86\x87\x88");
         UNIT_ASSERT_VALUES_EQUAL(ctx.DescribeSemaphore("Sem2").Data, "foobar");
         ctx.VerifySemaphoreNotFound("Sem3");
@@ -1140,7 +1140,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.SendSessionDescribeSemaphore(++reqId, proxy, 1, 1, "Sem1");
         ctx.ExpectDescribeSemaphoreResult(reqId, proxy, 1);
         ctx.SendSessionDescribeSemaphore(++reqId, proxy, 1, 2, "Sem1");
-        ctx.ExpectDescribeSemaphoreResult(reqId, proxy, 1, Ydb::StatusIds::BAD_SESSION);
+        ctx.ExpectDescribeSemaphoreResult(reqId, proxy, 1, Ydb::StatusIds::BAD_SESSION); 
 
         ctx.MustAttachSession(proxy, 1, 2, 30000);
 
@@ -1196,7 +1196,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
 
         // Changing acquire3 data shouldn't trigger a change notification
         ctx.SendAcquireSemaphore(++reqId, proxy, 1, 3, "Sem1", 1, 30000, "waiter3");
-        ctx.ExpectAcquireSemaphoreResult(acquire3, proxy, 1, Ydb::StatusIds::ABORTED);
+        ctx.ExpectAcquireSemaphoreResult(acquire3, proxy, 1, Ydb::StatusIds::ABORTED); 
         ctx.ExpectAcquireSemaphorePending(reqId, proxy, 1);
         acquire3 = reqId;
         ctx.ExpectNoEdgeEvent<TEvKesus::TEvDescribeSemaphoreChanged>(proxy, TDuration::Seconds(1));
@@ -1292,7 +1292,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         ctx.SessionUpdateSemaphore(++reqId, proxy, 1, 1, "Sem1", "other data");
         ctx.SessionDeleteSemaphore(++reqId, proxy, 1, 1, "Sem1");
 
-        auto testAllFailures = [&](Ydb::StatusIds::StatusCode status) {
+        auto testAllFailures = [&](Ydb::StatusIds::StatusCode status) { 
             ctx.SessionCreateSemaphore(++reqId, proxy, 1, 1, "Sem1", 5, "some data", status);
             ctx.SessionUpdateSemaphore(++reqId, proxy, 1, 1, "Sem1", "other data", status);
             ctx.SessionDeleteSemaphore(++reqId, proxy, 1, 1, "Sem1", status);
@@ -1304,11 +1304,11 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         };
 
         ctx.MustDetachSession(proxy, 1, 1);
-        testAllFailures(Ydb::StatusIds::BAD_SESSION);
+        testAllFailures(Ydb::StatusIds::BAD_SESSION); 
         ctx.MustDestroySession(proxy, 1, 1);
-        testAllFailures(Ydb::StatusIds::SESSION_EXPIRED);
+        testAllFailures(Ydb::StatusIds::SESSION_EXPIRED); 
         ctx.MustRegisterProxy(proxy, 2);
-        testAllFailures(Ydb::StatusIds::BAD_SESSION);
+        testAllFailures(Ydb::StatusIds::BAD_SESSION); 
     }
 
     Y_UNIT_TEST(TestQuoterResourceDescribe) {
diff --git a/ydb/core/kesus/tablet/tx_semaphore_acquire.cpp b/ydb/core/kesus/tablet/tx_semaphore_acquire.cpp
index 996dca18bf..bc19f507ff 100644
--- a/ydb/core/kesus/tablet/tx_semaphore_acquire.cpp
+++ b/ydb/core/kesus/tablet/tx_semaphore_acquire.cpp
@@ -36,7 +36,7 @@ struct TKesusTablet::TTxSemaphoreAcquire : public TTxBase {
             new TEvKesus::TEvAcquireSemaphorePending(Record.GetProxyGeneration()));
     }
 
-    void ReplyError(Ydb::StatusIds::StatusCode status, const TString& reason) {
+    void ReplyError(Ydb::StatusIds::StatusCode status, const TString& reason) { 
         Events.emplace_back(Sender, Cookie,
             new TEvKesus::TEvAcquireSemaphoreResult(Record.GetProxyGeneration(), status, reason));
     }
@@ -51,7 +51,7 @@ struct TKesusTablet::TTxSemaphoreAcquire : public TTxBase {
         if (!proxy || proxy->Generation != Record.GetProxyGeneration()) {
             // World has changed by the time we executed
             ReplyError(
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 proxy ? "ProxyGeneration mismatch" : "Proxy is not registered");
             return true;
         }
@@ -64,7 +64,7 @@ struct TKesusTablet::TTxSemaphoreAcquire : public TTxBase {
         if (!session || session->OwnerProxy != proxy) {
             // Session destroyed or stolen by the time we executed
             ReplyError(
-                session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED,
+                session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED, 
                 session ? "Session not attached" : "Session does not exist");
             return true;
         }
@@ -73,7 +73,7 @@ struct TKesusTablet::TTxSemaphoreAcquire : public TTxBase {
         if (!semaphore && !Record.GetEphemeral()) {
             // Semaphore does not exist
             ReplyError(
-                Ydb::StatusIds::NOT_FOUND,
+                Ydb::StatusIds::NOT_FOUND, 
                 "Semaphore does not exist");
             return true;
         }
@@ -81,7 +81,7 @@ struct TKesusTablet::TTxSemaphoreAcquire : public TTxBase {
         if (semaphore && semaphore->Ephemeral != Record.GetEphemeral()) {
             // Semaphore ephemeral mode mismatch
             ReplyError(
-                Ydb::StatusIds::PRECONDITION_FAILED,
+                Ydb::StatusIds::PRECONDITION_FAILED, 
                 "Semaphore ephemeral mode mismatch");
             return true;
         }
@@ -89,7 +89,7 @@ struct TKesusTablet::TTxSemaphoreAcquire : public TTxBase {
         if (semaphore && Record.GetCount() > semaphore->Limit) {
             // This acquire will never succeed
             ReplyError(
-                Ydb::StatusIds::BAD_REQUEST,
+                Ydb::StatusIds::BAD_REQUEST, 
                 "Cannot acquire more than allowed by the semaphore");
             return true;
         }
@@ -132,7 +132,7 @@ struct TKesusTablet::TTxSemaphoreAcquire : public TTxBase {
             if (Record.GetCount() > owner->Count) {
                 // Increasing count is not allowed
                 ReplyError(
-                    Ydb::StatusIds::BAD_REQUEST,
+                    Ydb::StatusIds::BAD_REQUEST, 
                     "Increasing count is not allowed");
                 return true;
             }
@@ -177,7 +177,7 @@ struct TKesusTablet::TTxSemaphoreAcquire : public TTxBase {
             if (Record.GetCount() > waiter->Count) {
                 // Increasing count is not allowed
                 ReplyError(
-                    Ydb::StatusIds::BAD_REQUEST,
+                    Ydb::StatusIds::BAD_REQUEST, 
                     "Increasing count is not allowed");
                 return true;
             }
@@ -187,7 +187,7 @@ struct TKesusTablet::TTxSemaphoreAcquire : public TTxBase {
                 Events.emplace_back(proxy->ActorID, cookie,
                     new TEvKesus::TEvAcquireSemaphoreResult(
                         proxy->Generation,
-                        Ydb::StatusIds::ABORTED,
+                        Ydb::StatusIds::ABORTED, 
                         "Operation superseded by another request"));
             });
             if (Record.GetTimeoutMillis() == 0 && !(semaphore->GetFirstOrderId() == waiter->OrderId && semaphore->CanAcquire(Record.GetCount()))) {
@@ -278,7 +278,7 @@ void TKesusTablet::Handle(TEvKesus::TEvAcquireSemaphore::TPtr& ev) {
         Send(ev->Sender,
             new TEvKesus::TEvAcquireSemaphoreResult(
                 record.GetProxyGeneration(),
-                Ydb::StatusIds::BAD_REQUEST,
+                Ydb::StatusIds::BAD_REQUEST, 
                 "Acquire must have count > 0"),
             0, ev->Cookie);
         return;
@@ -288,7 +288,7 @@ void TKesusTablet::Handle(TEvKesus::TEvAcquireSemaphore::TPtr& ev) {
         Send(ev->Sender,
             new TEvKesus::TEvAcquireSemaphoreResult(
                 record.GetProxyGeneration(),
-                Ydb::StatusIds::BAD_REQUEST,
+                Ydb::StatusIds::BAD_REQUEST, 
                 "Acquire timeout is out of range"),
             0, ev->Cookie);
         return;
diff --git a/ydb/core/kesus/tablet/tx_semaphore_create.cpp b/ydb/core/kesus/tablet/tx_semaphore_create.cpp
index 100cf550b3..fb2ca19fda 100644
--- a/ydb/core/kesus/tablet/tx_semaphore_create.cpp
+++ b/ydb/core/kesus/tablet/tx_semaphore_create.cpp
@@ -38,7 +38,7 @@ struct TKesusTablet::TTxSemaphoreCreate : public TTxBase {
             if (!proxy || proxy->Generation != Record.GetProxyGeneration()) {
                 Reply.Reset(new TEvKesus::TEvCreateSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    Ydb::StatusIds::BAD_SESSION,
+                    Ydb::StatusIds::BAD_SESSION, 
                     proxy ? "ProxyGeneration mismatch" : "Proxy is not registered"));
                 return true;
             }
@@ -49,7 +49,7 @@ struct TKesusTablet::TTxSemaphoreCreate : public TTxBase {
             if (!session || session->OwnerProxy != proxy) {
                 Reply.Reset(new TEvKesus::TEvCreateSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED,
+                    session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED, 
                     session ? "Session not attached" : "Session does not exist"));
                 return true;
             }
@@ -62,12 +62,12 @@ struct TKesusTablet::TTxSemaphoreCreate : public TTxBase {
             if (semaphore->Ephemeral) {
                 Reply.Reset(new TEvKesus::TEvCreateSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    Ydb::StatusIds::PRECONDITION_FAILED,
+                    Ydb::StatusIds::PRECONDITION_FAILED, 
                     "Cannot create semaphore due to ephemeral locks"));
             } else {
                 Reply.Reset(new TEvKesus::TEvCreateSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    Ydb::StatusIds::ALREADY_EXISTS,
+                    Ydb::StatusIds::ALREADY_EXISTS, 
                     "Semaphore already exists"));
             }
             return true;
diff --git a/ydb/core/kesus/tablet/tx_semaphore_delete.cpp b/ydb/core/kesus/tablet/tx_semaphore_delete.cpp
index bdd94a6511..d1a582951b 100644
--- a/ydb/core/kesus/tablet/tx_semaphore_delete.cpp
+++ b/ydb/core/kesus/tablet/tx_semaphore_delete.cpp
@@ -35,7 +35,7 @@ struct TKesusTablet::TTxSemaphoreDelete : public TTxBase {
                 Events.emplace_back(Sender, Cookie,
                     new TEvKesus::TEvDeleteSemaphoreResult(
                         Record.GetProxyGeneration(),
-                        Ydb::StatusIds::BAD_SESSION,
+                        Ydb::StatusIds::BAD_SESSION, 
                         proxy ? "ProxyGeneration mismatch" : "Proxy is not registered"));
                 return true;
             }
@@ -47,7 +47,7 @@ struct TKesusTablet::TTxSemaphoreDelete : public TTxBase {
                 Events.emplace_back(Sender, Cookie,
                     new TEvKesus::TEvDeleteSemaphoreResult(
                         Record.GetProxyGeneration(),
-                        session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED,
+                        session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED, 
                         session ? "Session not attached" : "Session does not exist"));
                 return true;
             }
@@ -60,7 +60,7 @@ struct TKesusTablet::TTxSemaphoreDelete : public TTxBase {
             Events.emplace_back(Sender, Cookie,
                 new TEvKesus::TEvDeleteSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    Ydb::StatusIds::NOT_FOUND,
+                    Ydb::StatusIds::NOT_FOUND, 
                     "Semaphore does not exist"));
             return true;
         }
@@ -69,7 +69,7 @@ struct TKesusTablet::TTxSemaphoreDelete : public TTxBase {
             Events.emplace_back(Sender, Cookie,
                 new TEvKesus::TEvDeleteSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    Ydb::StatusIds::PRECONDITION_FAILED,
+                    Ydb::StatusIds::PRECONDITION_FAILED, 
                     "Cannot delete ephemeral semaphores"));
             return true;
         }
@@ -78,7 +78,7 @@ struct TKesusTablet::TTxSemaphoreDelete : public TTxBase {
             Events.emplace_back(Sender, Cookie,
                 new TEvKesus::TEvDeleteSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    Ydb::StatusIds::PRECONDITION_FAILED,
+                    Ydb::StatusIds::PRECONDITION_FAILED, 
                     "Semaphore not empty"));
             return true;
         }
diff --git a/ydb/core/kesus/tablet/tx_semaphore_describe.cpp b/ydb/core/kesus/tablet/tx_semaphore_describe.cpp
index d6595232f1..020a0f3221 100644
--- a/ydb/core/kesus/tablet/tx_semaphore_describe.cpp
+++ b/ydb/core/kesus/tablet/tx_semaphore_describe.cpp
@@ -38,7 +38,7 @@ struct TKesusTablet::TTxSemaphoreDescribe : public TTxBase {
             if (!proxy || proxy->Generation != Record.GetProxyGeneration()) {
                 Reply.Reset(new TEvKesus::TEvDescribeSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    Ydb::StatusIds::BAD_SESSION,
+                    Ydb::StatusIds::BAD_SESSION, 
                     proxy ? "ProxyGeneration mismatch" : "Proxy is not registered"));
                 return true;
             }
@@ -51,14 +51,14 @@ struct TKesusTablet::TTxSemaphoreDescribe : public TTxBase {
             if (!session || session->OwnerProxy != proxy) {
                 Reply.Reset(new TEvKesus::TEvDescribeSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED,
+                    session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED, 
                     session ? "Session not attached" : "Session does not exist"));
                 return true;
             }
         } else if (Record.GetWatchData() || Record.GetWatchOwners()) {
             Reply.Reset(new TEvKesus::TEvDescribeSemaphoreResult(
                 Record.GetProxyGeneration(),
-                Ydb::StatusIds::BAD_REQUEST,
+                Ydb::StatusIds::BAD_REQUEST, 
                 "Watches cannot be used without an active session"));
             return true;
         } else {
@@ -71,7 +71,7 @@ struct TKesusTablet::TTxSemaphoreDescribe : public TTxBase {
         if (!semaphore) {
             Reply.Reset(new TEvKesus::TEvDescribeSemaphoreResult(
                 Record.GetProxyGeneration(),
-                Ydb::StatusIds::NOT_FOUND,
+                Ydb::StatusIds::NOT_FOUND, 
                 TStringBuilder() << "Semaphore not found"));
             return true;
         }
diff --git a/ydb/core/kesus/tablet/tx_semaphore_release.cpp b/ydb/core/kesus/tablet/tx_semaphore_release.cpp
index 326a331861..5cddddf407 100644
--- a/ydb/core/kesus/tablet/tx_semaphore_release.cpp
+++ b/ydb/core/kesus/tablet/tx_semaphore_release.cpp
@@ -26,7 +26,7 @@ struct TKesusTablet::TTxSemaphoreRelease : public TTxBase {
             new TEvKesus::TEvReleaseSemaphoreResult(Record.GetProxyGeneration(), released));
     }
 
-    void ReplyError(Ydb::StatusIds::StatusCode status, const TString& reason) {
+    void ReplyError(Ydb::StatusIds::StatusCode status, const TString& reason) { 
         Events.emplace_back(Sender, Cookie,
             new TEvKesus::TEvReleaseSemaphoreResult(Record.GetProxyGeneration(), status, reason));
     }
@@ -40,7 +40,7 @@ struct TKesusTablet::TTxSemaphoreRelease : public TTxBase {
         if (!proxy || proxy->Generation != Record.GetProxyGeneration()) {
             // World has changed by the time we executed
             ReplyError(
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 proxy ? "ProxyGeneration mismatch" : "Proxy is not registered");
             return true;
         }
@@ -53,7 +53,7 @@ struct TKesusTablet::TTxSemaphoreRelease : public TTxBase {
         if (!session || session->OwnerProxy != proxy) {
             // Session destroyed or stolen by the time we executed
             ReplyError(
-                session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED,
+                session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED, 
                 session ? "Session not attached" : "Session does not exist");
             return true;
         }
@@ -73,7 +73,7 @@ struct TKesusTablet::TTxSemaphoreRelease : public TTxBase {
                     Events.emplace_back(proxy->ActorID, cookie,
                         new TEvKesus::TEvAcquireSemaphoreResult(
                             proxy->Generation,
-                            Ydb::StatusIds::ABORTED,
+                            Ydb::StatusIds::ABORTED, 
                             "Operation superseded by another request"));
                 });
                 ReplyOk();
diff --git a/ydb/core/kesus/tablet/tx_semaphore_update.cpp b/ydb/core/kesus/tablet/tx_semaphore_update.cpp
index 08d595555e..95a397881a 100644
--- a/ydb/core/kesus/tablet/tx_semaphore_update.cpp
+++ b/ydb/core/kesus/tablet/tx_semaphore_update.cpp
@@ -35,7 +35,7 @@ struct TKesusTablet::TTxSemaphoreUpdate : public TTxBase {
                 Events.emplace_back(Sender, Cookie,
                     new TEvKesus::TEvUpdateSemaphoreResult(
                         Record.GetProxyGeneration(),
-                        Ydb::StatusIds::BAD_SESSION,
+                        Ydb::StatusIds::BAD_SESSION, 
                         proxy ? "ProxyGeneration mismatch" : "Proxy is not registered"));
                 return true;
             }
@@ -47,7 +47,7 @@ struct TKesusTablet::TTxSemaphoreUpdate : public TTxBase {
                 Events.emplace_back(Sender, Cookie,
                     new TEvKesus::TEvUpdateSemaphoreResult(
                         Record.GetProxyGeneration(),
-                        session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED,
+                        session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED, 
                         session ? "Session not attached" : "Session does not exist"));
                 return true;
             }
@@ -60,7 +60,7 @@ struct TKesusTablet::TTxSemaphoreUpdate : public TTxBase {
             Events.emplace_back(Sender, Cookie,
                 new TEvKesus::TEvUpdateSemaphoreResult(
                     Record.GetProxyGeneration(),
-                    Ydb::StatusIds::NOT_FOUND,
+                    Ydb::StatusIds::NOT_FOUND, 
                     "Semaphore does not exist"));
             return true;
         }
diff --git a/ydb/core/kesus/tablet/tx_session_attach.cpp b/ydb/core/kesus/tablet/tx_session_attach.cpp
index ca5f4191f2..cef79327bc 100644
--- a/ydb/core/kesus/tablet/tx_session_attach.cpp
+++ b/ydb/core/kesus/tablet/tx_session_attach.cpp
@@ -40,7 +40,7 @@ struct TKesusTablet::TTxSessionAttach : public TTxBase {
             Reply.Reset(new TEvKesus::TEvAttachSessionResult(
                 Record.GetProxyGeneration(),
                 Record.GetSessionId(),
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 proxy ? "ProxyGeneration mismatch" : "Proxy is not registered"));
             return true;
         }
@@ -57,7 +57,7 @@ struct TKesusTablet::TTxSessionAttach : public TTxBase {
                 Reply.Reset(new TEvKesus::TEvAttachSessionResult(
                     Record.GetProxyGeneration(),
                     Record.GetSessionId(),
-                    Ydb::StatusIds::SESSION_EXPIRED,
+                    Ydb::StatusIds::SESSION_EXPIRED, 
                     "Session does not exist"));
                 return true;
             }
@@ -66,7 +66,7 @@ struct TKesusTablet::TTxSessionAttach : public TTxBase {
                 Reply.Reset(new TEvKesus::TEvAttachSessionResult(
                     Record.GetProxyGeneration(),
                     Record.GetSessionId(),
-                    Ydb::StatusIds::BAD_SESSION,
+                    Ydb::StatusIds::BAD_SESSION, 
                     "Attach request is out of sequence"));
                 return true;
             }
@@ -165,7 +165,7 @@ void TKesusTablet::Handle(TEvKesus::TEvAttachSession::TPtr& ev) {
             new TEvKesus::TEvAttachSessionResult(
                 record.GetProxyGeneration(),
                 record.GetSessionId(),
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 proxy ? "ProxyGeneration mismatch" : "Proxy is not registered"),
             0, ev->Cookie);
         return;
@@ -176,7 +176,7 @@ void TKesusTablet::Handle(TEvKesus::TEvAttachSession::TPtr& ev) {
             new TEvKesus::TEvAttachSessionResult(
                 record.GetProxyGeneration(),
                 record.GetSessionId(),
-                Ydb::StatusIds::BAD_REQUEST,
+                Ydb::StatusIds::BAD_REQUEST, 
                 "Session timeout is out of range"),
             0, ev->Cookie);
         return;
@@ -213,7 +213,7 @@ void TKesusTablet::Handle(TEvKesus::TEvAttachSession::TPtr& ev) {
                 new TEvKesus::TEvAttachSessionResult(
                     record.GetProxyGeneration(),
                     record.GetSessionId(),
-                    Ydb::StatusIds::SESSION_EXPIRED,
+                    Ydb::StatusIds::SESSION_EXPIRED, 
                     "Session does not exist"),
                 0, ev->Cookie);
             return;
@@ -224,7 +224,7 @@ void TKesusTablet::Handle(TEvKesus::TEvAttachSession::TPtr& ev) {
                 new TEvKesus::TEvAttachSessionResult(
                     record.GetProxyGeneration(),
                     record.GetSessionId(),
-                    Ydb::StatusIds::BAD_SESSION,
+                    Ydb::StatusIds::BAD_SESSION, 
                     "Attach request is out of sequence"),
                 0, ev->Cookie);
             return;
diff --git a/ydb/core/kesus/tablet/tx_session_destroy.cpp b/ydb/core/kesus/tablet/tx_session_destroy.cpp
index 45c81456c8..3cc8d233c8 100644
--- a/ydb/core/kesus/tablet/tx_session_destroy.cpp
+++ b/ydb/core/kesus/tablet/tx_session_destroy.cpp
@@ -26,7 +26,7 @@ struct TKesusTablet::TTxSessionDestroy : public TTxBase {
             new TEvKesus::TEvDestroySessionResult(Record.GetProxyGeneration()));
     }
 
-    void ReplyError(Ydb::StatusIds::StatusCode status, const TString& reason) {
+    void ReplyError(Ydb::StatusIds::StatusCode status, const TString& reason) { 
         Events.emplace_back(Sender, Cookie,
             new TEvKesus::TEvDestroySessionResult(Record.GetProxyGeneration(), status, reason));
     }
@@ -40,7 +40,7 @@ struct TKesusTablet::TTxSessionDestroy : public TTxBase {
         if (!proxy || proxy->Generation != Record.GetProxyGeneration()) {
             // World has changed by the time we executed
             ReplyError(
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 proxy ? "ProxyGeneration mismatch" : "Proxy is not registered");
             return true;
         }
@@ -53,7 +53,7 @@ struct TKesusTablet::TTxSessionDestroy : public TTxBase {
         if (!session) {
             // Session destroyed by the time we executed
             ReplyError(
-                Ydb::StatusIds::SESSION_EXPIRED,
+                Ydb::StatusIds::SESSION_EXPIRED, 
                 "Session does not exist");
             return true;
         }
diff --git a/ydb/core/kesus/tablet/tx_session_detach.cpp b/ydb/core/kesus/tablet/tx_session_detach.cpp
index 1fb85da73c..7914c2487a 100644
--- a/ydb/core/kesus/tablet/tx_session_detach.cpp
+++ b/ydb/core/kesus/tablet/tx_session_detach.cpp
@@ -32,7 +32,7 @@ struct TKesusTablet::TTxSessionDetach : public TTxBase {
             // World has changed by the time we executed
             Reply.Reset(new TEvKesus::TEvDetachSessionResult(
                 Record.GetProxyGeneration(),
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 proxy ? "ProxyGeneration mismatch" : "Proxy is not registered"));
             return true;
         }
@@ -43,7 +43,7 @@ struct TKesusTablet::TTxSessionDetach : public TTxBase {
             // Session destroyed or stolen by the time we executed
             Reply.Reset(new TEvKesus::TEvDetachSessionResult(
                 Record.GetProxyGeneration(),
-                session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED,
+                session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED, 
                 session ? "Session not attached" : "Session does not exist"));
             return true;
         }
@@ -75,7 +75,7 @@ void TKesusTablet::Handle(TEvKesus::TEvDetachSession::TPtr& ev) {
         Send(ev->Sender,
             new TEvKesus::TEvDetachSessionResult(
                 record.GetProxyGeneration(),
-                Ydb::StatusIds::BAD_SESSION,
+                Ydb::StatusIds::BAD_SESSION, 
                 proxy ? "ProxyGeneration mismatch" : "Proxy is not registered"),
             0, ev->Cookie);
         return;
@@ -88,7 +88,7 @@ void TKesusTablet::Handle(TEvKesus::TEvDetachSession::TPtr& ev) {
             Send(ev->Sender,
                 new TEvKesus::TEvDetachSessionResult(
                     record.GetProxyGeneration(),
-                    session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED,
+                    session ? Ydb::StatusIds::BAD_SESSION : Ydb::StatusIds::SESSION_EXPIRED, 
                     session ? "Session not attached" : "Session does not exist"),
                 0, ev->Cookie);
             return;
diff --git a/ydb/core/kesus/tablet/ut_helpers.cpp b/ydb/core/kesus/tablet/ut_helpers.cpp
index f559800a76..3579a17212 100644
--- a/ydb/core/kesus/tablet/ut_helpers.cpp
+++ b/ydb/core/kesus/tablet/ut_helpers.cpp
@@ -313,7 +313,7 @@ bool TTestContext::ExpectAcquireLockResult(ui64 reqId, const TActorId& proxy, ui
 }
 
 void TTestContext::ExpectAcquireLockResult(ui64 reqId, const TActorId& proxy, ui64 generation, bool acquired) {
-    UNIT_ASSERT_VALUES_EQUAL(ExpectAcquireLockResult(reqId, proxy, generation, Ydb::StatusIds::SUCCESS), acquired);
+    UNIT_ASSERT_VALUES_EQUAL(ExpectAcquireLockResult(reqId, proxy, generation, Ydb::StatusIds::SUCCESS), acquired); 
 }
 
 bool TTestContext::MustReleaseLock(ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId, const TString& lockName, Ydb::StatusIds::StatusCode status) {
@@ -325,10 +325,10 @@ bool TTestContext::MustReleaseLock(ui64 reqId, const TActorId& proxy, ui64 gener
 }
 
 void TTestContext::MustReleaseLock(ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId, const TString& lockName, bool released) {
-    UNIT_ASSERT_VALUES_EQUAL(MustReleaseLock(reqId, proxy, generation, sessionId, lockName, Ydb::StatusIds::SUCCESS), released);
+    UNIT_ASSERT_VALUES_EQUAL(MustReleaseLock(reqId, proxy, generation, sessionId, lockName, Ydb::StatusIds::SUCCESS), released); 
 }
 
-void TTestContext::CreateSemaphore(const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status) {
+void TTestContext::CreateSemaphore(const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status) { 
     ui64 cookie = RandomNumber<ui64>();
     auto edge = Runtime->AllocateEdgeActor();
     SendFromEdge(edge, new TEvKesus::TEvCreateSemaphore("", name, limit, data), cookie);
@@ -338,7 +338,7 @@ void TTestContext::CreateSemaphore(const TString& name, ui64 limit, const TStrin
 
 void TTestContext::SessionCreateSemaphore(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId,
-        const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status)
+        const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status) 
 {
     auto event = new TEvKesus::TEvCreateSemaphore("", name, limit, data);
     event->Record.SetProxyGeneration(generation);
@@ -349,7 +349,7 @@ void TTestContext::SessionCreateSemaphore(
     UNIT_ASSERT_VALUES_EQUAL(result->Record.GetError().GetStatus(), status);
 }
 
-void TTestContext::UpdateSemaphore(const TString& name, const TString& data, Ydb::StatusIds::StatusCode status) {
+void TTestContext::UpdateSemaphore(const TString& name, const TString& data, Ydb::StatusIds::StatusCode status) { 
     ui64 cookie = RandomNumber<ui64>();
     auto edge = Runtime->AllocateEdgeActor();
     SendFromEdge(edge, new TEvKesus::TEvUpdateSemaphore("", name, data), cookie);
@@ -359,7 +359,7 @@ void TTestContext::UpdateSemaphore(const TString& name, const TString& data, Ydb
 
 void TTestContext::SessionUpdateSemaphore(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId,
-        const TString& name, const TString& data, Ydb::StatusIds::StatusCode status)
+        const TString& name, const TString& data, Ydb::StatusIds::StatusCode status) 
 {
     auto event = new TEvKesus::TEvUpdateSemaphore("", name, data);
     event->Record.SetProxyGeneration(generation);
@@ -370,7 +370,7 @@ void TTestContext::SessionUpdateSemaphore(
     UNIT_ASSERT_VALUES_EQUAL(result->Record.GetError().GetStatus(), status);
 }
 
-void TTestContext::DeleteSemaphore(const TString& name, bool force, Ydb::StatusIds::StatusCode status) {
+void TTestContext::DeleteSemaphore(const TString& name, bool force, Ydb::StatusIds::StatusCode status) { 
     ui64 cookie = RandomNumber<ui64>();
     auto edge = Runtime->AllocateEdgeActor();
     SendFromEdge(edge, new TEvKesus::TEvDeleteSemaphore("", name, force), cookie);
@@ -380,7 +380,7 @@ void TTestContext::DeleteSemaphore(const TString& name, bool force, Ydb::StatusI
 
 void TTestContext::SessionDeleteSemaphore(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId,
-        const TString& name, Ydb::StatusIds::StatusCode status)
+        const TString& name, Ydb::StatusIds::StatusCode status) 
 {
     auto event = new TEvKesus::TEvDeleteSemaphore("", name, false);
     event->Record.SetProxyGeneration(generation);
@@ -407,7 +407,7 @@ bool TTestContext::ExpectAcquireSemaphoreResult(ui64 reqId, const TActorId& prox
 }
 
 void TTestContext::ExpectAcquireSemaphoreResult(ui64 reqId, const TActorId& proxy, ui64 generation, bool acquired) {
-    UNIT_ASSERT_VALUES_EQUAL(ExpectAcquireSemaphoreResult(reqId, proxy, generation, Ydb::StatusIds::SUCCESS), acquired);
+    UNIT_ASSERT_VALUES_EQUAL(ExpectAcquireSemaphoreResult(reqId, proxy, generation, Ydb::StatusIds::SUCCESS), acquired); 
 }
 
 void TTestContext::ExpectAcquireSemaphorePending(ui64 reqId, const TActorId& proxy, ui64 generation) {
@@ -417,7 +417,7 @@ void TTestContext::ExpectAcquireSemaphorePending(ui64 reqId, const TActorId& pro
 
 bool TTestContext::MustReleaseSemaphore(
     ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId, const TString& name,
-    Ydb::StatusIds::StatusCode status)
+    Ydb::StatusIds::StatusCode status) 
 {
     SendFromProxy(proxy, generation, new TEvKesus::TEvReleaseSemaphore("", generation, sessionId, name), reqId);
     auto result = ExpectEdgeEvent<TEvKesus::TEvReleaseSemaphoreResult>(proxy, reqId);
@@ -429,7 +429,7 @@ bool TTestContext::MustReleaseSemaphore(
 void TTestContext::MustReleaseSemaphore(
     ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId, const TString& name, bool released)
 {
-    UNIT_ASSERT_VALUES_EQUAL(MustReleaseSemaphore(reqId, proxy, generation, sessionId, name, Ydb::StatusIds::SUCCESS), released);
+    UNIT_ASSERT_VALUES_EQUAL(MustReleaseSemaphore(reqId, proxy, generation, sessionId, name, Ydb::StatusIds::SUCCESS), released); 
 }
 
 THashMap<TActorId, TTestContext::TSimpleProxyInfo> TTestContext::DescribeProxies() {
@@ -509,8 +509,8 @@ TTestContext::TSimpleLockDescription TTestContext::DescribeLock(const TString& l
     SendFromEdge(edge, request, cookie);
     auto event = ExpectEdgeEvent<TEvKesus::TEvDescribeSemaphoreResult>(edge, cookie);
     TSimpleLockDescription result;
-    if (event->Record.GetError().GetStatus() != Ydb::StatusIds::NOT_FOUND) {
-        UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::SUCCESS);
+    if (event->Record.GetError().GetStatus() != Ydb::StatusIds::NOT_FOUND) { 
+        UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::SUCCESS); 
         const auto& desc = event->Record.GetSemaphoreDescription();
         UNIT_ASSERT_C(desc.ephemeral(), "Lock " << lockName << " is not ephemeral");
         for (const auto& owner : desc.owners()) {
@@ -600,7 +600,7 @@ TTestContext::TSimpleSemaphoreDescription TTestContext::DescribeSemaphore(const
     request->Record.SetIncludeWaiters(includeWaiters);
     SendFromEdge(edge, request, cookie);
     auto event = ExpectEdgeEvent<TEvKesus::TEvDescribeSemaphoreResult>(edge, cookie);
-    UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::SUCCESS);
+    UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::SUCCESS); 
     const auto& desc = event->Record.GetSemaphoreDescription();
     return MakeSimpleSemaphoreDescription(desc);
 }
@@ -610,7 +610,7 @@ void TTestContext::VerifySemaphoreNotFound(const TString& name) {
     TActorId edge = Runtime->AllocateEdgeActor();
     SendFromEdge(edge, new TEvKesus::TEvDescribeSemaphore("", name), cookie);
     auto event = ExpectEdgeEvent<TEvKesus::TEvDescribeSemaphoreResult>(edge, cookie);
-    UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::NOT_FOUND);
+    UNIT_ASSERT_VALUES_EQUAL(event->Record.GetError().GetStatus(), Ydb::StatusIds::NOT_FOUND); 
 }
 
 void TTestContext::VerifySemaphoreOwners(const TString& name, const THashSet<ui64>& sessionIds, bool ephemeral) {
@@ -651,7 +651,7 @@ void TTestContext::SendSessionDescribeSemaphore(
 
 TTestContext::TSimpleSemaphoreDescription TTestContext::ExpectDescribeSemaphoreResult(
         ui64 reqId, const TActorId& proxy, ui64 generation,
-        Ydb::StatusIds::StatusCode status)
+        Ydb::StatusIds::StatusCode status) 
 {
     auto event = ExpectEdgeEvent<TEvKesus::TEvDescribeSemaphoreResult>(proxy, reqId);
     UNIT_ASSERT_VALUES_EQUAL(event->Record.GetProxyGeneration(), generation);
diff --git a/ydb/core/kesus/tablet/ut_helpers.h b/ydb/core/kesus/tablet/ut_helpers.h
index 8f487a3033..6418e7416f 100644
--- a/ydb/core/kesus/tablet/ut_helpers.h
+++ b/ydb/core/kesus/tablet/ut_helpers.h
@@ -121,42 +121,42 @@ struct TTestContext {
         const TString& lockName, ELockMode mode,
         ui64 timeoutMillis = 0, const TString& data = TString());
     bool ExpectAcquireLockResult(ui64 reqId, const TActorId& proxy, ui64 generation,
-        Ydb::StatusIds::StatusCode status);
+        Ydb::StatusIds::StatusCode status); 
     void ExpectAcquireLockResult(ui64 reqId, const TActorId& proxy, ui64 generation, bool acquired = true);
 
     // Lock release helpers
     bool MustReleaseLock(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId, const TString& lockName,
-        Ydb::StatusIds::StatusCode status);
+        Ydb::StatusIds::StatusCode status); 
     void MustReleaseLock(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId, const TString& lockName, bool released = true);
 
     // Semaphore helpers
     void CreateSemaphore(
-        const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS);
-    void CreateSemaphore(const TString& name, ui64 limit, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS) {
+        const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS); 
+    void CreateSemaphore(const TString& name, ui64 limit, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS) { 
         CreateSemaphore(name, limit, TString(), status);
     }
 
     void UpdateSemaphore(
-        const TString& name, const TString& data, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS);
+        const TString& name, const TString& data, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS); 
 
-    void DeleteSemaphore(const TString& name, bool force, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS);
-    void DeleteSemaphore(const TString& name, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS) {
+    void DeleteSemaphore(const TString& name, bool force, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS); 
+    void DeleteSemaphore(const TString& name, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS) { 
         DeleteSemaphore(name, false, status);
     }
 
     void SessionCreateSemaphore(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId,
-        const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS);
+        const TString& name, ui64 limit, const TString& data, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS); 
 
     void SessionUpdateSemaphore(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId,
-        const TString& name, const TString& data, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS);
+        const TString& name, const TString& data, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS); 
 
     void SessionDeleteSemaphore(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId,
-        const TString& name, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS);
+        const TString& name, Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS); 
 
     // Semaphore acquire helpers
     void SendAcquireSemaphore(
@@ -164,14 +164,14 @@ struct TTestContext {
         const TString& name, ui64 count,
         ui64 timeoutMillis = 0, const TString& data = TString());
     bool ExpectAcquireSemaphoreResult(ui64 reqId, const TActorId& proxy, ui64 generation,
-        Ydb::StatusIds::StatusCode status);
+        Ydb::StatusIds::StatusCode status); 
     void ExpectAcquireSemaphoreResult(ui64 reqId, const TActorId& proxy, ui64 generation, bool acquired = true);
     void ExpectAcquireSemaphorePending(ui64 reqId, const TActorId& proxy, ui64 generation);
 
     // Semaphore release helpers
     bool MustReleaseSemaphore(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId, const TString& name,
-        Ydb::StatusIds::StatusCode status);
+        Ydb::StatusIds::StatusCode status); 
     void MustReleaseSemaphore(
         ui64 reqId, const TActorId& proxy, ui64 generation, ui64 sessionId, const TString& name, bool released = true);
 
@@ -239,7 +239,7 @@ struct TTestContext {
         const TString& name, bool watchData = false, bool watchOwners = false);
     TSimpleSemaphoreDescription ExpectDescribeSemaphoreResult(
         ui64 reqId, const TActorId& proxy, ui64 generation,
-        Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS);
+        Ydb::StatusIds::StatusCode status = Ydb::StatusIds::SUCCESS); 
     TDescribeSemaphoreChanges ExpectDescribeSemaphoreChanged(ui64 reqId, const TActorId& proxy, ui64 generation);
 
     // Quoter
diff --git a/ydb/core/kqp/common/kqp_common.cpp b/ydb/core/kqp/common/kqp_common.cpp
index da61b23c66..773bb919be 100644
--- a/ydb/core/kqp/common/kqp_common.cpp
+++ b/ydb/core/kqp/common/kqp_common.cpp
@@ -1 +1 @@
-#include "kqp_common.h"
+#include "kqp_common.h" 
diff --git a/ydb/core/kqp/common/kqp_common.h b/ydb/core/kqp/common/kqp_common.h
index f9379ad129..8e2b7b115c 100644
--- a/ydb/core/kqp/common/kqp_common.h
+++ b/ydb/core/kqp/common/kqp_common.h
@@ -1,28 +1,28 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/base/events.h>
 #include <ydb/library/yql/dq/actors/dq_events_ids.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-struct TKqpEvents {
-    enum EKqpEvents {
-        EvQueryRequest = EventSpaceBegin(TKikimrEvents::ES_KQP),
-        EvQueryResponse,
-        EvContinueProcess,
-        EvQueryTimeout,
-        EvIdleTimeout,
-        EvCloseSessionRequest,
-        EvProcessResponse,
-        EvCreateSessionRequest,
-        EvCreateSessionResponse,
-        EvPingSessionRequest,
-        EvCloseSessionResponse,
-        EvPingSessionResponse,
-        EvCompileRequest,
-        EvCompileResponse,
-        EvCompileInvalidateRequest,
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+struct TKqpEvents { 
+    enum EKqpEvents { 
+        EvQueryRequest = EventSpaceBegin(TKikimrEvents::ES_KQP), 
+        EvQueryResponse, 
+        EvContinueProcess, 
+        EvQueryTimeout, 
+        EvIdleTimeout, 
+        EvCloseSessionRequest, 
+        EvProcessResponse, 
+        EvCreateSessionRequest, 
+        EvCreateSessionResponse, 
+        EvPingSessionRequest, 
+        EvCloseSessionResponse, 
+        EvPingSessionResponse, 
+        EvCompileRequest, 
+        EvCompileResponse, 
+        EvCompileInvalidateRequest, 
         EvAbortExecution = NYql::NDq::TDqEvents::EDqEvents::EvAbortExecution,
         EvInitiateShutdownRequest,
         EvInitiateSessionShutdown,
@@ -30,25 +30,25 @@ struct TKqpEvents {
         EvDataQueryStreamPart,
         EvDataQueryStreamPartAck,
         EvRecompileRequest,
-    };
+    }; 
 
     static_assert (EvCompileInvalidateRequest + 1 == EvAbortExecution);
-};
+}; 
+ 
 
-
-struct TKqpExecuterEvents {
-    enum EKqpExecuterEvents {
-        EvTxRequest = EventSpaceBegin(TKikimrEvents::ES_KQP) + 100,
-        EvTxResponse,
+struct TKqpExecuterEvents { 
+    enum EKqpExecuterEvents { 
+        EvTxRequest = EventSpaceBegin(TKikimrEvents::ES_KQP) + 100, 
+        EvTxResponse, 
         EvStreamData,
         EvStreamProfile,
         EvProgress,
         EvStreamDataAck,
-        EvTableResolveStatus,
-        EvShardsResolveStatus
-    };
-};
-
+        EvTableResolveStatus, 
+        EvShardsResolveStatus 
+    }; 
+}; 
+ 
 struct TKqpSnapshotEvents {
     enum EKqpSnapshotEvents {
         EvCreateSnapshotRequest = EventSpaceBegin(TKikimrEvents::ES_KQP) + 150,
@@ -118,4 +118,4 @@ struct TKqpSpillingEvents {
 };
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/common/kqp_gateway.h b/ydb/core/kqp/common/kqp_gateway.h
index 1e06beca39..a10fa8040f 100644
--- a/ydb/core/kqp/common/kqp_gateway.h
+++ b/ydb/core/kqp/common/kqp_gateway.h
@@ -1,73 +1,73 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/protos/kqp_physical.pb.h>
 #include <ydb/core/protos/tx_proxy.pb.h>
-
+ 
 #include <ydb/library/yql/ast/yql_expr.h>
 #include <ydb/library/yql/dq/common/dq_value.h>
 #include <ydb/core/kqp/provider/yql_kikimr_gateway.h>
-
+ 
 #include <library/cpp/actors/core/actorid.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-struct TKqpParamsMap {
-    TKqpParamsMap() {}
-
-    TKqpParamsMap(std::shared_ptr<void> owner)
-        : Owner(owner) {}
-
-    std::shared_ptr<void> Owner;
-    TMap<TString, NYql::NDq::TMkqlValueRef> Values;
-};
-
-class IKqpGateway : public NYql::IKikimrGateway {
-public:
-    struct TMkqlResult : public TGenericResult {
-        TString CompiledProgram;
-        NKikimrMiniKQL::TResult Result;
-        NKikimrQueryStats::TTxStats TxStats;
-    };
-
-    struct TMkqlSettings {
-        bool LlvmRuntime = false;
-        bool CollectStats = false;
-        TMaybe<ui64> PerShardKeysSizeLimitBytes;
-        ui64 CancelAfterMs = 0;
-        ui64 TimeoutMs = 0;
-        NYql::TKikimrQueryPhaseLimits Limits;
-    };
-
-    struct TRunResponse {
-        bool HasProxyError;
-        ui32 ProxyStatus;
-        TString ProxyStatusName;
-        TString ProxyStatusDesc;
-
-        bool HasExecutionEngineError;
-        TString ExecutionEngineStatusName;
-        TString ExecutionEngineStatusDesc;
-
-        NYql::TIssues Issues;
-
-        TString MiniKQLErrors;
-        TString DataShardErrors;
-        NKikimrTxUserProxy::TMiniKQLCompileResults MiniKQLCompileResults;
-
-        NKikimrMiniKQL::TResult ExecutionEngineEvaluatedResponse;
-        NKikimrQueryStats::TTxStats TxStats;
-    };
-
-    struct TPhysicalTxData : private TMoveOnly {
-        const NKqpProto::TKqpPhyTx& Body;
-        TKqpParamsMap Params;
-
-        TPhysicalTxData(const NKqpProto::TKqpPhyTx& body, TKqpParamsMap&& params)
-            : Body(body)
-            , Params(std::move(params)) {}
-    };
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+struct TKqpParamsMap { 
+    TKqpParamsMap() {} 
+ 
+    TKqpParamsMap(std::shared_ptr<void> owner) 
+        : Owner(owner) {} 
+ 
+    std::shared_ptr<void> Owner; 
+    TMap<TString, NYql::NDq::TMkqlValueRef> Values; 
+}; 
+ 
+class IKqpGateway : public NYql::IKikimrGateway { 
+public: 
+    struct TMkqlResult : public TGenericResult { 
+        TString CompiledProgram; 
+        NKikimrMiniKQL::TResult Result; 
+        NKikimrQueryStats::TTxStats TxStats; 
+    }; 
+ 
+    struct TMkqlSettings { 
+        bool LlvmRuntime = false; 
+        bool CollectStats = false; 
+        TMaybe<ui64> PerShardKeysSizeLimitBytes; 
+        ui64 CancelAfterMs = 0; 
+        ui64 TimeoutMs = 0; 
+        NYql::TKikimrQueryPhaseLimits Limits; 
+    }; 
+ 
+    struct TRunResponse { 
+        bool HasProxyError; 
+        ui32 ProxyStatus; 
+        TString ProxyStatusName; 
+        TString ProxyStatusDesc; 
+ 
+        bool HasExecutionEngineError; 
+        TString ExecutionEngineStatusName; 
+        TString ExecutionEngineStatusDesc; 
+ 
+        NYql::TIssues Issues; 
+ 
+        TString MiniKQLErrors; 
+        TString DataShardErrors; 
+        NKikimrTxUserProxy::TMiniKQLCompileResults MiniKQLCompileResults; 
+ 
+        NKikimrMiniKQL::TResult ExecutionEngineEvaluatedResponse; 
+        NKikimrQueryStats::TTxStats TxStats; 
+    }; 
+ 
+    struct TPhysicalTxData : private TMoveOnly { 
+        const NKqpProto::TKqpPhyTx& Body; 
+        TKqpParamsMap Params; 
+ 
+        TPhysicalTxData(const NKqpProto::TKqpPhyTx& body, TKqpParamsMap&& params) 
+            : Body(body) 
+            , Params(std::move(params)) {} 
+    }; 
+ 
     struct TKqpSnapshot {
         ui64 Step;
         ui64 TxId;
@@ -104,12 +104,12 @@ public:
         NKikimrIssues::TStatusIds::EStatusCode Status =  NKikimrIssues::TStatusIds::UNKNOWN;
     };
 
-    struct TExecPhysicalRequest : private TMoveOnly {
-        TVector<TPhysicalTxData> Transactions;
+    struct TExecPhysicalRequest : private TMoveOnly { 
+        TVector<TPhysicalTxData> Transactions; 
         TVector<NYql::NDq::TMkqlValueRef> Locks;
         bool ValidateLocks = false;
         bool EraseLocks = false;
-        TMaybe<ui64> AcquireLocksTxId;
+        TMaybe<ui64> AcquireLocksTxId; 
         TDuration Timeout;
         TMaybe<TDuration> CancelAfter;
         ui32 MaxComputeActors = 10'000;
@@ -121,28 +121,28 @@ public:
         bool DisableLlvmForUdfStages = false;
         bool LlvmEnabled = true;
         TKqpSnapshot Snapshot = TKqpSnapshot();
-        NKikimrKqp::EIsolationLevel IsolationLevel = NKikimrKqp::ISOLATION_LEVEL_UNDEFINED;
+        NKikimrKqp::EIsolationLevel IsolationLevel = NKikimrKqp::ISOLATION_LEVEL_UNDEFINED; 
         TMaybe<NKikimrKqp::TRlPath> RlPath;
-    };
-
-    struct TExecPhysicalResult : public TGenericResult {
-        NKikimrKqp::TExecuterTxResult ExecuterResult;
-    };
-
-    struct TAstQuerySettings {
+    }; 
+ 
+    struct TExecPhysicalResult : public TGenericResult { 
+        NKikimrKqp::TExecuterTxResult ExecuterResult; 
+    }; 
+ 
+    struct TAstQuerySettings { 
         NYql::NDqProto::EDqStatsMode StatsMode = NYql::NDqProto::DQ_STATS_MODE_NONE;
-    };
-
-public:
-    /* Mkql */
-    virtual NThreading::TFuture<TMkqlResult> ExecuteMkql(const TString& cluster, const TString& program,
-        TKqpParamsMap&& params, const TMkqlSettings& settings, const TKqpSnapshot& snapshot) = 0;
-
-    virtual NThreading::TFuture<TMkqlResult> ExecuteMkqlPrepared(const TString& cluster, const TString& program,
-        TKqpParamsMap&& params, const TMkqlSettings& settings, const TKqpSnapshot& snapshot) = 0;
-
-    virtual NThreading::TFuture<TMkqlResult> PrepareMkql(const TString& cluster, const TString& program) = 0;
-
+    }; 
+ 
+public: 
+    /* Mkql */ 
+    virtual NThreading::TFuture<TMkqlResult> ExecuteMkql(const TString& cluster, const TString& program, 
+        TKqpParamsMap&& params, const TMkqlSettings& settings, const TKqpSnapshot& snapshot) = 0; 
+ 
+    virtual NThreading::TFuture<TMkqlResult> ExecuteMkqlPrepared(const TString& cluster, const TString& program, 
+        TKqpParamsMap&& params, const TMkqlSettings& settings, const TKqpSnapshot& snapshot) = 0; 
+ 
+    virtual NThreading::TFuture<TMkqlResult> PrepareMkql(const TString& cluster, const TString& program) = 0; 
+ 
     /* Snapshots */
     virtual NThreading::TFuture<TKqpSnapshotHandle> CreatePersistentSnapshot(const TVector<TString>& tablePaths,
         TDuration queryTimeout) = 0;
@@ -151,41 +151,41 @@ public:
 
     virtual NThreading::TFuture<TKqpSnapshotHandle> AcquireMvccSnapshot(TDuration queryTimeout) = 0;
 
-    /* Physical */
+    /* Physical */ 
     virtual NThreading::TFuture<TExecPhysicalResult> ExecutePhysical(TExecPhysicalRequest&& request,
         const NActors::TActorId& target) = 0;
-
-    virtual NThreading::TFuture<TExecPhysicalResult> ExecuteScanQuery(TExecPhysicalRequest&& request,
+ 
+    virtual NThreading::TFuture<TExecPhysicalResult> ExecuteScanQuery(TExecPhysicalRequest&& request, 
         const NActors::TActorId& target) = 0;
-
+ 
     virtual NThreading::TFuture<TExecPhysicalResult> ExecutePure(TExecPhysicalRequest&& request,
         const NActors::TActorId& target) = 0;
 
-    /* Scripting */
-    virtual NThreading::TFuture<TQueryResult> ExplainDataQueryAst(const TString& cluster, const TString& query) = 0;
-
-    virtual NThreading::TFuture<TQueryResult> ExecDataQueryAst(const TString& cluster, const TString& query,
-        TKqpParamsMap&& params, const TAstQuerySettings& settings,
-        const Ydb::Table::TransactionSettings& txSettings) = 0;
-
+    /* Scripting */ 
+    virtual NThreading::TFuture<TQueryResult> ExplainDataQueryAst(const TString& cluster, const TString& query) = 0; 
+ 
+    virtual NThreading::TFuture<TQueryResult> ExecDataQueryAst(const TString& cluster, const TString& query, 
+        TKqpParamsMap&& params, const TAstQuerySettings& settings, 
+        const Ydb::Table::TransactionSettings& txSettings) = 0; 
+ 
     virtual NThreading::TFuture<TQueryResult> ExplainScanQueryAst(const TString& cluster, const TString& query) = 0;
 
-    virtual NThreading::TFuture<TQueryResult> ExecScanQueryAst(const TString& cluster, const TString& query,
-        TKqpParamsMap&& params, const TAstQuerySettings& settings, ui64 rowsLimit) = 0;
-
+    virtual NThreading::TFuture<TQueryResult> ExecScanQueryAst(const TString& cluster, const TString& query, 
+        TKqpParamsMap&& params, const TAstQuerySettings& settings, ui64 rowsLimit) = 0; 
+ 
     virtual NThreading::TFuture<TQueryResult> StreamExecDataQueryAst(const TString& cluster, const TString& query,
-        TKqpParamsMap&& params, const TAstQuerySettings& settings,
+        TKqpParamsMap&& params, const TAstQuerySettings& settings, 
         const Ydb::Table::TransactionSettings& txSettings, const NActors::TActorId& target) = 0;
 
     virtual NThreading::TFuture<TQueryResult> StreamExecScanQueryAst(const TString& cluster, const TString& query,
-        TKqpParamsMap&& params, const TAstQuerySettings& settings, const NActors::TActorId& target) = 0;
+        TKqpParamsMap&& params, const TAstQuerySettings& settings, const NActors::TActorId& target) = 0; 
 
 public:
     virtual TInstant GetCurrentTime() const = 0;
-};
-
+}; 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
 
 template<>
 struct THash<NKikimr::NKqp::IKqpGateway::TKqpSnapshot> {
diff --git a/ydb/core/kqp/common/kqp_resolve.cpp b/ydb/core/kqp/common/kqp_resolve.cpp
index b4abafc86c..10b355df32 100644
--- a/ydb/core/kqp/common/kqp_resolve.cpp
+++ b/ydb/core/kqp/common/kqp_resolve.cpp
@@ -1,7 +1,7 @@
-#include "kqp_resolve.h"
-
+#include "kqp_resolve.h" 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_gateway.h>
-
+ 
 // #define DBG_TRACE
 
 #ifdef DBG_TRACE
@@ -9,43 +9,43 @@
 #include <ydb/core/tx/datashard/range_ops.h>
 #endif
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NMiniKQL;
-using namespace NYql;
-using namespace NYql::NNodes;
-
-TVector<TCell> MakeKeyCells(const NKikimr::NUdf::TUnboxedValue& value, const TVector<NUdf::TDataTypeId>& keyColumnTypes,
-    const TVector<ui32>& keyColumnIndices, const NMiniKQL::TTypeEnvironment& typeEnv, bool copyValues)
-{
-    TVector<TCell> key(keyColumnTypes.size());
-    for (ui32 i = 0; i < key.size(); ++i) {
-        auto columnValue = value.GetElement(keyColumnIndices[i]);
-        key[i] = NMiniKQL::MakeCell(keyColumnTypes[i], columnValue, typeEnv, copyValues);
-    }
-
-    return key;
-}
-
-TTableId MakeTableId(const TKqpTable& node) {
-    auto nodePathId = TKikimrPathId::Parse(node.PathId());
-
-    TTableId tableId;
-    tableId.PathId = TPathId(nodePathId.OwnerId(), nodePathId.TableId());
-    tableId.SysViewInfo = node.SysView();
-    tableId.SchemaVersion = FromString<ui64>(node.Version());
-    return tableId;
-}
-
-TTableId MakeTableId(const NKqpProto::TKqpPhyTable& table) {
-    TTableId tableId;
-    tableId.PathId = TPathId(table.GetOwnerId(), table.GetTableId());
-    tableId.SysViewInfo = table.GetSysView();
-    tableId.SchemaVersion = table.GetVersion();
-    return tableId;
-}
-
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NMiniKQL; 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+TVector<TCell> MakeKeyCells(const NKikimr::NUdf::TUnboxedValue& value, const TVector<NUdf::TDataTypeId>& keyColumnTypes, 
+    const TVector<ui32>& keyColumnIndices, const NMiniKQL::TTypeEnvironment& typeEnv, bool copyValues) 
+{ 
+    TVector<TCell> key(keyColumnTypes.size()); 
+    for (ui32 i = 0; i < key.size(); ++i) { 
+        auto columnValue = value.GetElement(keyColumnIndices[i]); 
+        key[i] = NMiniKQL::MakeCell(keyColumnTypes[i], columnValue, typeEnv, copyValues); 
+    } 
+ 
+    return key; 
+} 
+ 
+TTableId MakeTableId(const TKqpTable& node) { 
+    auto nodePathId = TKikimrPathId::Parse(node.PathId()); 
+ 
+    TTableId tableId; 
+    tableId.PathId = TPathId(nodePathId.OwnerId(), nodePathId.TableId()); 
+    tableId.SysViewInfo = node.SysView(); 
+    tableId.SchemaVersion = FromString<ui64>(node.Version()); 
+    return tableId; 
+} 
+ 
+TTableId MakeTableId(const NKqpProto::TKqpPhyTable& table) { 
+    TTableId tableId; 
+    tableId.PathId = TPathId(table.GetOwnerId(), table.GetTableId()); 
+    tableId.SysViewInfo = table.GetSysView(); 
+    tableId.SchemaVersion = table.GetVersion(); 
+    return tableId; 
+} 
+ 
 TVector<TPartitionWithRange> GetKeyRangePartitions(const TTableRange& range,
     const TVector<TKeyDesc::TPartitionInfo>& partitions, const TVector<NUdf::TDataTypeId>& keyColumnTypes)
 {
@@ -186,4 +186,4 @@ TVector<TPartitionWithRange> GetKeyRangePartitions(const TTableRange& range,
 
 #undef DBG_TRACE
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/common/kqp_resolve.h b/ydb/core/kqp/common/kqp_resolve.h
index 517d1bc451..32b742b8a9 100644
--- a/ydb/core/kqp/common/kqp_resolve.h
+++ b/ydb/core/kqp/common/kqp_resolve.h
@@ -1,17 +1,17 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/engine/mkql_keys.h>
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.h>
 #include <ydb/core/protos/kqp_physical.pb.h>
 #include <ydb/core/scheme/scheme_tabledefs.h>
-
+ 
 #include <ydb/library/yql/minikql/mkql_node.h>
-
-#include <util/generic/map.h>
-
-namespace NKikimr {
-namespace NKqp {
-
+ 
+#include <util/generic/map.h> 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
 enum class ETableKind {
     Unknown = 0,
     Datashard,
@@ -21,21 +21,21 @@ enum class ETableKind {
 
 class TKqpTableKeys {
 public:
-    struct TColumn {
-        ui32 Id;
-        ui32 Type;
-    };
-
-    struct TTable {
-        TString Path;
-        TMap<TString, TColumn> Columns;
-        TVector<TString> KeyColumns;
+    struct TColumn { 
+        ui32 Id; 
+        ui32 Type; 
+    }; 
+ 
+    struct TTable { 
+        TString Path; 
+        TMap<TString, TColumn> Columns; 
+        TVector<TString> KeyColumns; 
         TVector<NUdf::TDataTypeId> KeyColumnTypes;
         ETableKind TableKind = ETableKind::Unknown;
-    };
-
-    TTable* FindTablePtr(const TTableId& id) {
-        return TablesById.FindPtr(id);
+    }; 
+ 
+    TTable* FindTablePtr(const TTableId& id) { 
+        return TablesById.FindPtr(id); 
     }
 
     const TTable* FindTablePtr(const TTableId& id) const {
@@ -43,66 +43,66 @@ public:
     }
 
     TTable& GetOrAddTable(const TTableId& id, const TStringBuf path) {
-        auto& table = TablesById[id];
-
-        if (table.Path.empty()) {
-            table.Path = path;
-        } else {
-            MKQL_ENSURE_S(table.Path == path);
-        }
-
-        return table;
-    }
-
-    const TTable& GetTable(const TTableId& id) const {
-        auto table = TablesById.FindPtr(id);
-        MKQL_ENSURE_S(table);
-        return *table;
+        auto& table = TablesById[id]; 
+ 
+        if (table.Path.empty()) { 
+            table.Path = path; 
+        } else { 
+            MKQL_ENSURE_S(table.Path == path); 
+        } 
+ 
+        return table; 
     }
 
+    const TTable& GetTable(const TTableId& id) const { 
+        auto table = TablesById.FindPtr(id); 
+        MKQL_ENSURE_S(table); 
+        return *table; 
+    } 
+ 
     size_t Size() const {
-        return TablesById.size();
+        return TablesById.size(); 
     }
 
-    const THashMap<TTableId, TTable>& Get() const {
-        return TablesById;
+    const THashMap<TTableId, TTable>& Get() const { 
+        return TablesById; 
     }
-
+ 
 private:
-    THashMap<TTableId, TTable> TablesById;
-};
-
-TVector<TCell> MakeKeyCells(const NKikimr::NUdf::TUnboxedValue& value, const TVector<NUdf::TDataTypeId>& keyColumnTypes,
-    const TVector<ui32>& keyColumnIndices, const NMiniKQL::TTypeEnvironment& typeEnv, bool copyValues);
-
-template<typename TList, typename TRangeFunc>
+    THashMap<TTableId, TTable> TablesById; 
+}; 
+ 
+TVector<TCell> MakeKeyCells(const NKikimr::NUdf::TUnboxedValue& value, const TVector<NUdf::TDataTypeId>& keyColumnTypes, 
+    const TVector<ui32>& keyColumnIndices, const NMiniKQL::TTypeEnvironment& typeEnv, bool copyValues); 
+ 
+template<typename TList, typename TRangeFunc> 
 size_t FindKeyPartitionIndex(const TVector<TCell>& key, const TList& partitions,
     const TVector<NUdf::TDataTypeId>& keyColumnTypes, const TRangeFunc& rangeFunc)
-{
-    auto it = std::lower_bound(partitions.begin(), partitions.end(), key,
-        [&keyColumnTypes, &rangeFunc](const auto& partition, const auto& key) {
-            const auto& range = rangeFunc(partition);
-            const int cmp = CompareBorders<true, false>(range.EndKeyPrefix.GetCells(), key,
-                range.IsInclusive || range.IsPoint, true, keyColumnTypes);
-
-            return (cmp < 0);
-        });
-
-    MKQL_ENSURE_S(it != partitions.end());
-
+{ 
+    auto it = std::lower_bound(partitions.begin(), partitions.end(), key, 
+        [&keyColumnTypes, &rangeFunc](const auto& partition, const auto& key) { 
+            const auto& range = rangeFunc(partition); 
+            const int cmp = CompareBorders<true, false>(range.EndKeyPrefix.GetCells(), key, 
+                range.IsInclusive || range.IsPoint, true, keyColumnTypes); 
+ 
+            return (cmp < 0); 
+        }); 
+ 
+    MKQL_ENSURE_S(it != partitions.end()); 
+ 
     return std::distance(partitions.begin(), it);
-}
-
+} 
+ 
 template<typename TList, typename TRangeFunc>
 size_t FindKeyPartitionIndex(const NMiniKQL::TTypeEnvironment& typeEnv, const NKikimr::NUdf::TUnboxedValue& value,
      const TList& partitions, const TVector<NUdf::TDataTypeId>& keyColumnTypes, const TVector<ui32>& keyColumnIndices,
      const TRangeFunc& rangeFunc)
-{
+{ 
     auto key = MakeKeyCells(value, keyColumnTypes, keyColumnIndices, typeEnv, /* copyValues */ true);
-
+ 
     return FindKeyPartitionIndex(key, partitions, keyColumnTypes, rangeFunc);
 }
-
+ 
 using TSerializedPointOrRange = std::variant<TSerializedCellVec, TSerializedTableRange>;
 
 struct TPartitionWithRange {
@@ -113,27 +113,27 @@ struct TPartitionWithRange {
     TPartitionWithRange(const TKeyDesc::TPartitionInfo* partitionInfo)
         : PartitionInfo(partitionInfo) {}
 };
-
+ 
 TVector<TPartitionWithRange> GetKeyRangePartitions(const TTableRange& range,
     const TVector<TKeyDesc::TPartitionInfo>& partitions, const TVector<NUdf::TDataTypeId>& keyColumnTypes);
-
-template<typename TList, typename TRangeFunc>
-void SortPartitions(TList& partitions, const TVector<NUdf::TDataTypeId>& keyColumnTypes, const TRangeFunc& rangeFunc) {
-    std::sort(partitions.begin(), partitions.end(),
-        [&keyColumnTypes, &rangeFunc](const auto& left, const auto& right) {
-            const auto& leftRange = rangeFunc(left);
-            const auto& rightRange = rangeFunc(right);
-
-            const int cmp = CompareBorders<true, true>(leftRange.EndKeyPrefix.GetCells(),
-                rightRange.EndKeyPrefix.GetCells(), leftRange.IsInclusive || leftRange.IsPoint,
-                rightRange.IsInclusive || rightRange.IsPoint, keyColumnTypes);
-
-            return (cmp < 0);
-        });
-}
-
-TTableId MakeTableId(const NYql::NNodes::TKqpTable& node);
-TTableId MakeTableId(const NKqpProto::TKqpPhyTable& table);
-
+ 
+template<typename TList, typename TRangeFunc> 
+void SortPartitions(TList& partitions, const TVector<NUdf::TDataTypeId>& keyColumnTypes, const TRangeFunc& rangeFunc) { 
+    std::sort(partitions.begin(), partitions.end(), 
+        [&keyColumnTypes, &rangeFunc](const auto& left, const auto& right) { 
+            const auto& leftRange = rangeFunc(left); 
+            const auto& rightRange = rangeFunc(right); 
+ 
+            const int cmp = CompareBorders<true, true>(leftRange.EndKeyPrefix.GetCells(), 
+                rightRange.EndKeyPrefix.GetCells(), leftRange.IsInclusive || leftRange.IsPoint, 
+                rightRange.IsInclusive || rightRange.IsPoint, keyColumnTypes); 
+ 
+            return (cmp < 0); 
+        }); 
+} 
+ 
+TTableId MakeTableId(const NYql::NNodes::TKqpTable& node); 
+TTableId MakeTableId(const NKqpProto::TKqpPhyTable& table); 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/common/kqp_transform.cpp b/ydb/core/kqp/common/kqp_transform.cpp
index 3653c78d67..cd6ff81f90 100644
--- a/ydb/core/kqp/common/kqp_transform.cpp
+++ b/ydb/core/kqp/common/kqp_transform.cpp
@@ -1,34 +1,34 @@
-#include "kqp_transform.h"
-#include "kqp_yql.h"
-
+#include "kqp_transform.h" 
+#include "kqp_yql.h" 
+ 
 #include <ydb/library/yql/providers/common/provider/yql_provider.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-
-IGraphTransformer::TStatus TLogExprTransformer::operator()(const TExprNode::TPtr& input, TExprNode::TPtr& output,
-    TExprContext& ctx)
-{
-    Y_UNUSED(ctx);
-
-    output = input;
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+ 
+IGraphTransformer::TStatus TLogExprTransformer::operator()(const TExprNode::TPtr& input, TExprNode::TPtr& output, 
+    TExprContext& ctx) 
+{ 
+    Y_UNUSED(ctx); 
+ 
+    output = input; 
     LogExpr(*input, ctx, Description, Component, Level);
-    return IGraphTransformer::TStatus::Ok;
-}
-
-TAutoPtr<IGraphTransformer> TLogExprTransformer::Sync(const TString& description, NLog::EComponent component,
-    NLog::ELevel level)
-{
-    return CreateFunctorTransformer(TLogExprTransformer(description, component, level));
-}
-
+    return IGraphTransformer::TStatus::Ok; 
+} 
+ 
+TAutoPtr<IGraphTransformer> TLogExprTransformer::Sync(const TString& description, NLog::EComponent component, 
+    NLog::ELevel level) 
+{ 
+    return CreateFunctorTransformer(TLogExprTransformer(description, component, level)); 
+} 
+ 
 void TLogExprTransformer::LogExpr(const TExprNode& input, TExprContext& ctx, const TString& description, NLog::EComponent component,
-    NLog::ELevel level)
-{
-    YQL_CVLOG(level, component) << description << ":\n" << KqpExprToPrettyString(input, ctx);
-}
-
+    NLog::ELevel level) 
+{ 
+    YQL_CVLOG(level, component) << description << ":\n" << KqpExprToPrettyString(input, ctx); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/common/kqp_transform.h b/ydb/core/kqp/common/kqp_transform.h
index 457c424801..80fc66d14e 100644
--- a/ydb/core/kqp/common/kqp_transform.h
+++ b/ydb/core/kqp/common/kqp_transform.h
@@ -1,23 +1,23 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.h>
 #include <ydb/core/kqp/common/kqp_gateway.h>
 #include <ydb/core/kqp/common/kqp_tx_info.h>
-
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider.h>
-
+ 
 #include <ydb/library/yql/utils/log/log.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-const TStringBuf ParamNamePrefix = "%kqp%";
-const TStringBuf LocksAcquireParamName = "%kqp%locks_acquire";
-const TStringBuf LocksTxIdParamName = "%kqp%locks_txid";
-const TStringBuf LocksListParamName = "%kqp%locks_list";
-const TStringBuf ReadTargetParamName = "%kqp%read_target";
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+const TStringBuf ParamNamePrefix = "%kqp%"; 
+const TStringBuf LocksAcquireParamName = "%kqp%locks_acquire"; 
+const TStringBuf LocksTxIdParamName = "%kqp%locks_txid"; 
+const TStringBuf LocksListParamName = "%kqp%locks_list"; 
+const TStringBuf ReadTargetParamName = "%kqp%read_target"; 
+ 
 /* Non-deterministic internal params */
 const std::string_view NowParamName = "%kqp%now";
 const std::string_view CurrentDateParamName = "%kqp%current_utc_date";
@@ -27,46 +27,46 @@ const std::string_view RandomParamName = "%kqp%random";
 const std::string_view RandomNumberParamName = "%kqp%random_number";
 const std::string_view RandomUuidParamName = "%kqp%random_uuid";
 
-class TKqpTxLock {
-public:
-    using TKey = std::tuple<ui64, ui64, ui64, ui64>;
-
-    TKqpTxLock(const NKikimrMiniKQL::TValue& lockValue)
-        : LockValue(lockValue) {}
-
-    ui64 GetLockId() const { return LockValue.GetStruct(3).GetUint64(); }
-    ui64 GetDataShard() const { return LockValue.GetStruct(1).GetUint64(); }
-    ui64 GetSchemeShard() const { return LockValue.GetStruct(5).GetUint64(); }
-    ui64 GetPathId() const { return LockValue.GetStruct(4).GetUint64(); }
-    ui32 GetGeneration() const { return LockValue.GetStruct(2).GetUint32(); }
-    ui64 GetCounter() const { return LockValue.GetStruct(0).GetUint64(); }
-
-    TKey GetKey() const { return std::make_tuple(GetLockId(), GetDataShard(), GetSchemeShard(), GetPathId()); }
-    NKikimrMiniKQL::TValue GetValue() const { return LockValue; }
+class TKqpTxLock { 
+public: 
+    using TKey = std::tuple<ui64, ui64, ui64, ui64>; 
+ 
+    TKqpTxLock(const NKikimrMiniKQL::TValue& lockValue) 
+        : LockValue(lockValue) {} 
+ 
+    ui64 GetLockId() const { return LockValue.GetStruct(3).GetUint64(); } 
+    ui64 GetDataShard() const { return LockValue.GetStruct(1).GetUint64(); } 
+    ui64 GetSchemeShard() const { return LockValue.GetStruct(5).GetUint64(); } 
+    ui64 GetPathId() const { return LockValue.GetStruct(4).GetUint64(); } 
+    ui32 GetGeneration() const { return LockValue.GetStruct(2).GetUint32(); } 
+    ui64 GetCounter() const { return LockValue.GetStruct(0).GetUint64(); } 
+ 
+    TKey GetKey() const { return std::make_tuple(GetLockId(), GetDataShard(), GetSchemeShard(), GetPathId()); } 
+    NKikimrMiniKQL::TValue GetValue() const { return LockValue; } 
     NYql::NDq::TMkqlValueRef GetValueRef(const NKikimrMiniKQL::TType& type) const { return NYql::NDq::TMkqlValueRef(type, LockValue); }
-
-    bool Invalidated(const TKqpTxLock& newLock) const {
-        YQL_ENSURE(GetKey() == newLock.GetKey());
-        return GetGeneration() != newLock.GetGeneration() || GetCounter() != newLock.GetCounter();
-    }
-
-private:
-    NKikimrMiniKQL::TValue LockValue;
-};
-
-struct TKqpTxLocks {
-    NKikimrMiniKQL::TType LockType;
-    NKikimrMiniKQL::TListType LocksListType;
-    THashMap<TKqpTxLock::TKey, TKqpTxLock> LocksMap;
-
+ 
+    bool Invalidated(const TKqpTxLock& newLock) const { 
+        YQL_ENSURE(GetKey() == newLock.GetKey()); 
+        return GetGeneration() != newLock.GetGeneration() || GetCounter() != newLock.GetCounter(); 
+    } 
+ 
+private: 
+    NKikimrMiniKQL::TValue LockValue; 
+}; 
+ 
+struct TKqpTxLocks { 
+    NKikimrMiniKQL::TType LockType; 
+    NKikimrMiniKQL::TListType LocksListType; 
+    THashMap<TKqpTxLock::TKey, TKqpTxLock> LocksMap; 
+ 
     TMaybe<NYql::TIssue> LockIssue;
 
-    bool HasLocks() const { return !LocksMap.empty(); }
+    bool HasLocks() const { return !LocksMap.empty(); } 
     bool Broken() const { return LockIssue.Defined(); }
     void MarkBroken(NYql::TIssue lockIssue) { LockIssue.ConstructInPlace(std::move(lockIssue)); }
-    ui64 GetLockTxId() const { return HasLocks() ? LocksMap.begin()->second.GetLockId() : 0; }
-    size_t Size() const { return LocksMap.size(); }
-
+    ui64 GetLockTxId() const { return HasLocks() ? LocksMap.begin()->second.GetLockId() : 0; } 
+    size_t Size() const { return LocksMap.size(); } 
+ 
     void ReportIssues(NYql::TExprContext& ctx) {
         if (LockIssue)
             ctx.AddError(*LockIssue);
@@ -76,22 +76,22 @@ struct TKqpTxLocks {
         LocksMap.clear();
         LockIssue.Clear();
     }
-};
-
-using TParamValueMap = THashMap<TString, NKikimrMiniKQL::TParams>;
-
-struct TDeferredEffect {
-    NYql::NNodes::TMaybeNode<NYql::NNodes::TExprBase> Node;
-    NKqpProto::TKqpPhyTx PhysicalTx;
-    TParamValueMap Params;
-
-    explicit TDeferredEffect(const NYql::NNodes::TExprBase& node)
-        : Node(node) {}
-
-    explicit TDeferredEffect(const NKqpProto::TKqpPhyTx& physicalTx)
-        : PhysicalTx(physicalTx) {}
-};
-
+}; 
+ 
+using TParamValueMap = THashMap<TString, NKikimrMiniKQL::TParams>; 
+ 
+struct TDeferredEffect { 
+    NYql::NNodes::TMaybeNode<NYql::NNodes::TExprBase> Node; 
+    NKqpProto::TKqpPhyTx PhysicalTx; 
+    TParamValueMap Params; 
+ 
+    explicit TDeferredEffect(const NYql::NNodes::TExprBase& node) 
+        : Node(node) {} 
+ 
+    explicit TDeferredEffect(const NKqpProto::TKqpPhyTx& physicalTx) 
+        : PhysicalTx(physicalTx) {} 
+}; 
+ 
 class TKqpTransactionContext;
 
 struct TDeferredEffects {
@@ -150,20 +150,20 @@ private:
     friend class TKqpTransactionContext;
 };
 
-class TKqpTransactionContext : public NYql::TKikimrTransactionContextBase {
-public:
+class TKqpTransactionContext : public NYql::TKikimrTransactionContextBase { 
+public: 
     explicit TKqpTransactionContext(bool implicit)
-        : Implicit(implicit)
-        , ParamsState(MakeIntrusive<TParamsState>())
-    {
-        CreationTime = TInstant::Now();
-        Touch();
-    }
-
-    TString NewParamName() {
-        return TStringBuilder() << ParamNamePrefix << (++ParamsState->LastIndex);
-    }
-
+        : Implicit(implicit) 
+        , ParamsState(MakeIntrusive<TParamsState>()) 
+    { 
+        CreationTime = TInstant::Now(); 
+        Touch(); 
+    } 
+ 
+    TString NewParamName() { 
+        return TStringBuilder() << ParamNamePrefix << (++ParamsState->LastIndex); 
+    } 
+ 
     void ClearDeferredEffects() {
         DeferredEffects.Clear();
     }
@@ -182,43 +182,43 @@ public:
         return SnapshotHandle.Snapshot;
     }
 
-    void Finish() final {
+    void Finish() final { 
         YQL_ENSURE(DeferredEffects.Empty());
-        YQL_ENSURE(!Locks.HasLocks());
-
-        FinishTime = TInstant::Now();
-
-        if (Implicit) {
-            Reset();
-        } else {
-            Closed = true;
-        }
-    }
-
-    void Touch() {
-        LastAccessTime = TInstant::Now();
-    }
-
-    void OnBeginQuery() {
-        ++QueriesCount;
-        BeginQueryTime = TInstant::Now();
-    }
-
-    void OnEndQuery() {
-        QueriesDuration += TInstant::Now() - BeginQueryTime;
-    }
-
-    void Reset() {
-        TKikimrTransactionContextBase::Reset();
-
+        YQL_ENSURE(!Locks.HasLocks()); 
+ 
+        FinishTime = TInstant::Now(); 
+ 
+        if (Implicit) { 
+            Reset(); 
+        } else { 
+            Closed = true; 
+        } 
+    } 
+ 
+    void Touch() { 
+        LastAccessTime = TInstant::Now(); 
+    } 
+ 
+    void OnBeginQuery() { 
+        ++QueriesCount; 
+        BeginQueryTime = TInstant::Now(); 
+    } 
+ 
+    void OnEndQuery() { 
+        QueriesDuration += TInstant::Now() - BeginQueryTime; 
+    } 
+ 
+    void Reset() { 
+        TKikimrTransactionContextBase::Reset(); 
+ 
         DeferredEffects.Clear();
-        ParamsState = MakeIntrusive<TParamsState>();
+        ParamsState = MakeIntrusive<TParamsState>(); 
         SnapshotHandle.Snapshot = IKqpGateway::TKqpSnapshot::InvalidSnapshot;
         ForceNewEngineSettings = {};
-    }
-
+    } 
+ 
     TKqpTransactionInfo GetInfo() const;
-
+ 
     void ForceOldEngine() {
         YQL_ENSURE(DeferredEffects.Empty());
         YQL_ENSURE(!ForceNewEngineSettings.ForcedNewEngine.has_value());
@@ -233,56 +233,56 @@ public:
         ForceNewEngineSettings.ForceNewEngineLevel = level;
     }
 
-public:
-    struct TParamsState : public TThrRefBase {
-        TParamValueMap Values;
-        ui32 LastIndex = 0;
-    };
-
-public:
-    const bool Implicit;
-
-    TInstant CreationTime;
-    TInstant LastAccessTime;
-    TInstant FinishTime;
-
-    TInstant BeginQueryTime;
-    TDuration QueriesDuration;
-    ui32 QueriesCount = 0;
-
-    TKqpTxLocks Locks;
-
+public: 
+    struct TParamsState : public TThrRefBase { 
+        TParamValueMap Values; 
+        ui32 LastIndex = 0; 
+    }; 
+ 
+public: 
+    const bool Implicit; 
+ 
+    TInstant CreationTime; 
+    TInstant LastAccessTime; 
+    TInstant FinishTime; 
+ 
+    TInstant BeginQueryTime; 
+    TDuration QueriesDuration; 
+    ui32 QueriesCount = 0; 
+ 
+    TKqpTxLocks Locks; 
+ 
     TDeferredEffects DeferredEffects;
-    TIntrusivePtr<TParamsState> ParamsState;
-
+    TIntrusivePtr<TParamsState> ParamsState; 
+ 
     IKqpGateway::TKqpSnapshotHandle SnapshotHandle;
 
     TKqpForceNewEngineState ForceNewEngineSettings;
-};
-
-class TLogExprTransformer {
-public:
-    TLogExprTransformer(const TString& description, NYql::NLog::EComponent component, NYql::NLog::ELevel level)
-        : Description(description)
-        , Component(component)
-        , Level(level) {}
-
-    NYql::IGraphTransformer::TStatus operator()(const NYql::TExprNode::TPtr& input, NYql::TExprNode::TPtr& output,
-        NYql::TExprContext& ctx);
-
-    static TAutoPtr<NYql::IGraphTransformer> Sync(const TString& description,
-        NYql::NLog::EComponent component = NYql::NLog::EComponent::ProviderKqp,
-        NYql::NLog::ELevel level = NYql::NLog::ELevel::INFO);
-
+}; 
+ 
+class TLogExprTransformer { 
+public: 
+    TLogExprTransformer(const TString& description, NYql::NLog::EComponent component, NYql::NLog::ELevel level) 
+        : Description(description) 
+        , Component(component) 
+        , Level(level) {} 
+ 
+    NYql::IGraphTransformer::TStatus operator()(const NYql::TExprNode::TPtr& input, NYql::TExprNode::TPtr& output, 
+        NYql::TExprContext& ctx); 
+ 
+    static TAutoPtr<NYql::IGraphTransformer> Sync(const TString& description, 
+        NYql::NLog::EComponent component = NYql::NLog::EComponent::ProviderKqp, 
+        NYql::NLog::ELevel level = NYql::NLog::ELevel::INFO); 
+ 
     static void LogExpr(const NYql::TExprNode& input, NYql::TExprContext& ctx, const TString& description,
-        NYql::NLog::EComponent component = NYql::NLog::EComponent::ProviderKqp,
-        NYql::NLog::ELevel level = NYql::NLog::ELevel::INFO);
-
-private:
-    TString Description;
-    NYql::NLog::EComponent Component;
-    NYql::NLog::ELevel Level;
-};
-
+        NYql::NLog::EComponent component = NYql::NLog::EComponent::ProviderKqp, 
+        NYql::NLog::ELevel level = NYql::NLog::ELevel::INFO); 
+ 
+private: 
+    TString Description; 
+    NYql::NLog::EComponent Component; 
+    NYql::NLog::ELevel Level; 
+}; 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/common/kqp_yql.cpp b/ydb/core/kqp/common/kqp_yql.cpp
index 4cd92ee10e..f3b415b38f 100644
--- a/ydb/core/kqp/common/kqp_yql.cpp
+++ b/ydb/core/kqp/common/kqp_yql.cpp
@@ -1,130 +1,130 @@
-#include "kqp_yql.h"
-
+#include "kqp_yql.h" 
+ 
 #include <ydb/library/yql/core/yql_expr_type_annotation.h>
 
-namespace NYql {
-
-using namespace NKikimr;
-using namespace NKikimr::NKqp;
-using namespace NNodes;
-
-static EPhysicalQueryType GetPhysicalQueryType(const TStringBuf& value) {
-    if (value == "data_query") {
-        return EPhysicalQueryType::Data;
-    } else if (value == "scan_query") {
-        return EPhysicalQueryType::Scan;
-    } else {
-        YQL_ENSURE(false, "Unknown physical query type: " << value);
-    }
-}
-
-static TStringBuf PhysicalQueryTypeToString(EPhysicalQueryType type) {
-    switch (type) {
-        case EPhysicalQueryType::Unspecified:
-            break;
-        case EPhysicalQueryType::Data:
-            return "data_query";
-        case EPhysicalQueryType::Scan:
-            return "scan_query";
-    }
-
-    YQL_ENSURE(false, "Unexpected physical query type: " << type);
-}
-
-TKqpPhyQuerySettings TKqpPhyQuerySettings::Parse(const TKqpPhysicalQuery& node) {
-    TKqpPhyQuerySettings settings;
-
-    for (const auto& tuple : node.Settings()) {
-        auto name = tuple.Name().Value();
-        if (name == TypeSettingName) {
-            YQL_ENSURE(tuple.Value().Maybe<TCoAtom>());
-            settings.Type = GetPhysicalQueryType(tuple.Value().Cast<TCoAtom>().Value());
-        }
-    }
-
-    return settings;
-}
-
-NNodes::TCoNameValueTupleList TKqpPhyQuerySettings::BuildNode(TExprContext& ctx, TPositionHandle pos) const {
-    TVector<TCoNameValueTuple> settings;
-
-    if (Type) {
-        settings.push_back(Build<TCoNameValueTuple>(ctx, pos)
-            .Name().Build(TypeSettingName)
-            .Value<TCoAtom>().Build(PhysicalQueryTypeToString(*Type))
-            .Done());
-    }
-
-    return Build<TCoNameValueTupleList>(ctx, pos)
-        .Add(settings)
-        .Done();
-}
-
-static EPhysicalTxType GetPhysicalTxType(const TStringBuf& value) {
-    if (value == "compute") {
-        return EPhysicalTxType::Compute;
-    } else if (value == "data") {
-        return EPhysicalTxType::Data;
-    } else if (value == "scan") {
-        return EPhysicalTxType::Scan;
-    } else {
-        YQL_ENSURE(false, "Unknown physical tx type: " << value);
-    }
-}
-
-static TStringBuf PhysicalTxTypeToString(EPhysicalTxType type) {
-    switch (type) {
-        case EPhysicalTxType::Unspecified:
-            break;
-        case EPhysicalTxType::Compute:
-            return "compute";
-        case EPhysicalTxType::Data:
-            return "data";
-        case EPhysicalTxType::Scan:
-            return "scan";
-    }
-
-    YQL_ENSURE(false, "Unexpected physical tx type: " << type);
-}
-
-TKqpPhyTxSettings TKqpPhyTxSettings::Parse(const TKqpPhysicalTx& node) {
-    TKqpPhyTxSettings settings;
-
-    for (const auto& tuple : node.Settings()) {
-        auto name = tuple.Name().Value();
-        if (name == TypeSettingName) {
-            YQL_ENSURE(tuple.Value().Maybe<TCoAtom>());
-            settings.Type = GetPhysicalTxType(tuple.Value().Cast<TCoAtom>().Value());
+namespace NYql { 
+ 
+using namespace NKikimr; 
+using namespace NKikimr::NKqp; 
+using namespace NNodes; 
+ 
+static EPhysicalQueryType GetPhysicalQueryType(const TStringBuf& value) { 
+    if (value == "data_query") { 
+        return EPhysicalQueryType::Data; 
+    } else if (value == "scan_query") { 
+        return EPhysicalQueryType::Scan; 
+    } else { 
+        YQL_ENSURE(false, "Unknown physical query type: " << value); 
+    } 
+} 
+ 
+static TStringBuf PhysicalQueryTypeToString(EPhysicalQueryType type) { 
+    switch (type) { 
+        case EPhysicalQueryType::Unspecified: 
+            break; 
+        case EPhysicalQueryType::Data: 
+            return "data_query"; 
+        case EPhysicalQueryType::Scan: 
+            return "scan_query"; 
+    } 
+ 
+    YQL_ENSURE(false, "Unexpected physical query type: " << type); 
+} 
+ 
+TKqpPhyQuerySettings TKqpPhyQuerySettings::Parse(const TKqpPhysicalQuery& node) { 
+    TKqpPhyQuerySettings settings; 
+ 
+    for (const auto& tuple : node.Settings()) { 
+        auto name = tuple.Name().Value(); 
+        if (name == TypeSettingName) { 
+            YQL_ENSURE(tuple.Value().Maybe<TCoAtom>()); 
+            settings.Type = GetPhysicalQueryType(tuple.Value().Cast<TCoAtom>().Value()); 
+        } 
+    } 
+ 
+    return settings; 
+} 
+ 
+NNodes::TCoNameValueTupleList TKqpPhyQuerySettings::BuildNode(TExprContext& ctx, TPositionHandle pos) const { 
+    TVector<TCoNameValueTuple> settings; 
+ 
+    if (Type) { 
+        settings.push_back(Build<TCoNameValueTuple>(ctx, pos) 
+            .Name().Build(TypeSettingName) 
+            .Value<TCoAtom>().Build(PhysicalQueryTypeToString(*Type)) 
+            .Done()); 
+    } 
+ 
+    return Build<TCoNameValueTupleList>(ctx, pos) 
+        .Add(settings) 
+        .Done(); 
+} 
+ 
+static EPhysicalTxType GetPhysicalTxType(const TStringBuf& value) { 
+    if (value == "compute") { 
+        return EPhysicalTxType::Compute; 
+    } else if (value == "data") { 
+        return EPhysicalTxType::Data; 
+    } else if (value == "scan") { 
+        return EPhysicalTxType::Scan; 
+    } else { 
+        YQL_ENSURE(false, "Unknown physical tx type: " << value); 
+    } 
+} 
+ 
+static TStringBuf PhysicalTxTypeToString(EPhysicalTxType type) { 
+    switch (type) { 
+        case EPhysicalTxType::Unspecified: 
+            break; 
+        case EPhysicalTxType::Compute: 
+            return "compute"; 
+        case EPhysicalTxType::Data: 
+            return "data"; 
+        case EPhysicalTxType::Scan: 
+            return "scan"; 
+    } 
+ 
+    YQL_ENSURE(false, "Unexpected physical tx type: " << type); 
+} 
+ 
+TKqpPhyTxSettings TKqpPhyTxSettings::Parse(const TKqpPhysicalTx& node) { 
+    TKqpPhyTxSettings settings; 
+ 
+    for (const auto& tuple : node.Settings()) { 
+        auto name = tuple.Name().Value(); 
+        if (name == TypeSettingName) { 
+            YQL_ENSURE(tuple.Value().Maybe<TCoAtom>()); 
+            settings.Type = GetPhysicalTxType(tuple.Value().Cast<TCoAtom>().Value()); 
         } else if (name == WithEffectsSettingName) {
             settings.WithEffects = true;
-        }
-    }
-
-    return settings;
-}
-
-NNodes::TCoNameValueTupleList TKqpPhyTxSettings::BuildNode(TExprContext& ctx, TPositionHandle pos) const {
-    TVector<TCoNameValueTuple> settings;
+        } 
+    } 
+ 
+    return settings; 
+} 
+ 
+NNodes::TCoNameValueTupleList TKqpPhyTxSettings::BuildNode(TExprContext& ctx, TPositionHandle pos) const { 
+    TVector<TCoNameValueTuple> settings; 
     settings.reserve(2);
-
-    if (Type) {
+ 
+    if (Type) { 
         settings.emplace_back(Build<TCoNameValueTuple>(ctx, pos)
-            .Name().Build(TypeSettingName)
-            .Value<TCoAtom>().Build(PhysicalTxTypeToString(*Type))
-            .Done());
-    }
-
+            .Name().Build(TypeSettingName) 
+            .Value<TCoAtom>().Build(PhysicalTxTypeToString(*Type)) 
+            .Done()); 
+    } 
+ 
     if (WithEffects) {
         settings.emplace_back(Build<TCoNameValueTuple>(ctx, pos)
             .Name().Build(WithEffectsSettingName)
             .Done());
     }
 
-    return Build<TCoNameValueTupleList>(ctx, pos)
-        .Add(settings)
-        .Done();
-}
-
+    return Build<TCoNameValueTupleList>(ctx, pos) 
+        .Add(settings) 
+        .Done(); 
+} 
+ 
 namespace {
 
 template <typename TKqlReadOperation>
@@ -215,39 +215,39 @@ void TKqpReadTableSettings::AddSkipNullKey(const TString& key) {
     SkipNullKeys.emplace_back(key);
 }
 
-TKqpUpsertRowsSettings TKqpUpsertRowsSettings::Parse(const TKqpUpsertRows& node) {
-    TKqpUpsertRowsSettings settings;
-
-    for (const auto& tuple : node.Settings()) {
-        TStringBuf name = tuple.Name().Value();
-
-        if (name == TKqpUpsertRowsSettings::InplaceSettingName) {
-            YQL_ENSURE(tuple.Ref().ChildrenSize() == 1);
-            settings.Inplace = true;
-        } else {
-            YQL_ENSURE(false, "Unknown KqpUpsertRows setting name '" << name << "'");
-        }
-    }
-
-    return settings;
-}
-
-NNodes::TCoNameValueTupleList TKqpUpsertRowsSettings::BuildNode(TExprContext& ctx, TPositionHandle pos) const {
-    TVector<TCoNameValueTuple> settings;
-    settings.reserve(1);
-
-    if (Inplace) {
-        settings.emplace_back(
-            Build<TCoNameValueTuple>(ctx, pos)
-                .Name().Build(InplaceSettingName)
-                .Done());
-    }
-
-    return Build<TCoNameValueTupleList>(ctx, pos)
-        .Add(settings)
-        .Done();
-}
-
+TKqpUpsertRowsSettings TKqpUpsertRowsSettings::Parse(const TKqpUpsertRows& node) { 
+    TKqpUpsertRowsSettings settings; 
+ 
+    for (const auto& tuple : node.Settings()) { 
+        TStringBuf name = tuple.Name().Value(); 
+ 
+        if (name == TKqpUpsertRowsSettings::InplaceSettingName) { 
+            YQL_ENSURE(tuple.Ref().ChildrenSize() == 1); 
+            settings.Inplace = true; 
+        } else { 
+            YQL_ENSURE(false, "Unknown KqpUpsertRows setting name '" << name << "'"); 
+        } 
+    } 
+ 
+    return settings; 
+} 
+ 
+NNodes::TCoNameValueTupleList TKqpUpsertRowsSettings::BuildNode(TExprContext& ctx, TPositionHandle pos) const { 
+    TVector<TCoNameValueTuple> settings; 
+    settings.reserve(1); 
+ 
+    if (Inplace) { 
+        settings.emplace_back( 
+            Build<TCoNameValueTuple>(ctx, pos) 
+                .Name().Build(InplaceSettingName) 
+                .Done()); 
+    } 
+ 
+    return Build<TCoNameValueTupleList>(ctx, pos) 
+        .Add(settings) 
+        .Done(); 
+} 
+ 
 TCoNameValueTupleList TKqpReadTableExplainPrompt::BuildNode(TExprContext& ctx, TPositionHandle pos) const {
     TVector<TCoNameValueTuple> prompt;
     prompt.reserve(2);
@@ -310,47 +310,47 @@ TKqpReadTableExplainPrompt TKqpReadTableExplainPrompt::Parse(const NNodes::TKqlR
     return prompt;
 }
 
-TString KqpExprToPrettyString(const TExprNode& expr, TExprContext& ctx) {
+TString KqpExprToPrettyString(const TExprNode& expr, TExprContext& ctx) { 
     try {
         TConvertToAstSettings settings;
         settings.NoInlineFunc = [] (const TExprNode& exprNode) {
             TExprBase node(&exprNode);
-
+ 
             if (node.Maybe<TDqStageBase>()) {
                 return true;
             }
-
+ 
             if (node.Maybe<TDqConnection>()) {
                 return true;
             }
-
+ 
             if (node.Maybe<TKqlReadTableBase>()) {
                 return true;
             }
-
+ 
             if (node.Maybe<TKqlReadTableRangesBase>()) {
                 return true;
             }
 
             return false;
         };
-
+ 
         auto ast = ConvertToAst(expr, ctx, settings);
         TStringStream exprStream;
         YQL_ENSURE(ast.Root);
         ast.Root->PrettyPrintTo(exprStream, NYql::TAstPrintFlags::PerLine | NYql::TAstPrintFlags::ShortQuote);
         TString exprText = exprStream.Str();
-
+ 
         return exprText;
     } catch (const std::exception& e) {
         return TStringBuilder() << "Failed to render expression to pretty string: " << e.what();
     }
-}
-
-TString KqpExprToPrettyString(const TExprBase& expr, TExprContext& ctx) {
-    return KqpExprToPrettyString(expr.Ref(), ctx);
-}
-
+} 
+ 
+TString KqpExprToPrettyString(const TExprBase& expr, TExprContext& ctx) { 
+    return KqpExprToPrettyString(expr.Ref(), ctx); 
+} 
+ 
 TString PrintKqpStageOnly(const TDqStageBase& stage, TExprContext& ctx) {
     if (stage.Inputs().Empty()) {
         return KqpExprToPrettyString(stage, ctx);
@@ -371,4 +371,4 @@ TString PrintKqpStageOnly(const TDqStageBase& stage, TExprContext& ctx) {
     return KqpExprToPrettyString(TExprBase(newStage), ctx);
 }
 
-} // namespace NYql
+} // namespace NYql 
diff --git a/ydb/core/kqp/common/kqp_yql.h b/ydb/core/kqp/common/kqp_yql.h
index 7de6cffe39..069630cba9 100644
--- a/ydb/core/kqp/common/kqp_yql.h
+++ b/ydb/core/kqp/common/kqp_yql.h
@@ -1,45 +1,45 @@
-#pragma once
-
-#include "kqp_gateway.h"
-
+#pragma once 
+ 
+#include "kqp_gateway.h" 
+ 
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.h>
-
-namespace NYql {
-
-const TStringBuf KqpEffectTag = "KqpEffect";
-
-enum class EPhysicalQueryType {
-    Unspecified,
-    Data,
-    Scan
-};
-
-struct TKqpPhyQuerySettings {
+ 
+namespace NYql { 
+ 
+const TStringBuf KqpEffectTag = "KqpEffect"; 
+ 
+enum class EPhysicalQueryType { 
+    Unspecified, 
+    Data, 
+    Scan 
+}; 
+ 
+struct TKqpPhyQuerySettings { 
     static constexpr std::string_view TypeSettingName = "type"sv;
     std::optional<EPhysicalQueryType> Type;
-
-    static TKqpPhyQuerySettings Parse(const NNodes::TKqpPhysicalQuery& node);
-    NNodes::TCoNameValueTupleList BuildNode(TExprContext& ctx, TPositionHandle pos) const;
-};
-
-enum class EPhysicalTxType {
-    Unspecified,
-    Compute,
-    Data,
-    Scan
-};
-
-struct TKqpPhyTxSettings {
+ 
+    static TKqpPhyQuerySettings Parse(const NNodes::TKqpPhysicalQuery& node); 
+    NNodes::TCoNameValueTupleList BuildNode(TExprContext& ctx, TPositionHandle pos) const; 
+}; 
+ 
+enum class EPhysicalTxType { 
+    Unspecified, 
+    Compute, 
+    Data, 
+    Scan 
+}; 
+ 
+struct TKqpPhyTxSettings { 
     static constexpr TStringBuf TypeSettingName = "type";
     std::optional<EPhysicalTxType> Type;
-
+ 
     static constexpr std::string_view WithEffectsSettingName = "with_effects"sv;
     bool WithEffects = false;
 
-    static TKqpPhyTxSettings Parse(const NNodes::TKqpPhysicalTx& node);
-    NNodes::TCoNameValueTupleList BuildNode(TExprContext& ctx, TPositionHandle pos) const;
-};
-
+    static TKqpPhyTxSettings Parse(const NNodes::TKqpPhysicalTx& node); 
+    NNodes::TCoNameValueTupleList BuildNode(TExprContext& ctx, TPositionHandle pos) const; 
+}; 
+ 
 struct TKqpReadTableSettings {
     static constexpr TStringBuf SkipNullKeysSettingName = "SkipNullKeys";
     static constexpr TStringBuf ItemsLimitSettingName = "ItemsLimit";
@@ -58,17 +58,17 @@ struct TKqpReadTableSettings {
     NNodes::TCoNameValueTupleList BuildNode(TExprContext& ctx, TPositionHandle pos) const;
 };
 
-struct TKqpUpsertRowsSettings {
-    static constexpr TStringBuf InplaceSettingName = "Inplace";
-
-    bool Inplace = false;
-
-    void SetInplace() { Inplace = true; }
-
-    static TKqpUpsertRowsSettings Parse(const NNodes::TKqpUpsertRows& node);
-    NNodes::TCoNameValueTupleList BuildNode(TExprContext& ctx, TPositionHandle pos) const;
-};
-
+struct TKqpUpsertRowsSettings { 
+    static constexpr TStringBuf InplaceSettingName = "Inplace"; 
+ 
+    bool Inplace = false; 
+ 
+    void SetInplace() { Inplace = true; } 
+ 
+    static TKqpUpsertRowsSettings Parse(const NNodes::TKqpUpsertRows& node); 
+    NNodes::TCoNameValueTupleList BuildNode(TExprContext& ctx, TPositionHandle pos) const; 
+}; 
+ 
 struct TKqpReadTableExplainPrompt {
     static constexpr TStringBuf UsedKeyColumnsName = "UsedKeyColumns";
     static constexpr TStringBuf ExpectedMaxRangesName = "ExpectedMaxRanges";
@@ -88,9 +88,9 @@ struct TKqpReadTableExplainPrompt {
     static TKqpReadTableExplainPrompt Parse(const NNodes::TKqlReadTableRangesBase& node);
 };
 
-TString KqpExprToPrettyString(const TExprNode& expr, TExprContext& ctx);
-TString KqpExprToPrettyString(const NNodes::TExprBase& expr, TExprContext& ctx);
-
+TString KqpExprToPrettyString(const TExprNode& expr, TExprContext& ctx); 
+TString KqpExprToPrettyString(const NNodes::TExprBase& expr, TExprContext& ctx); 
+ 
 TString PrintKqpStageOnly(const NNodes::TDqStageBase& stage, TExprContext& ctx);
 
-} // namespace NYql
+} // namespace NYql 
diff --git a/ydb/core/kqp/common/ya.make b/ydb/core/kqp/common/ya.make
index 1e694fda12..fb0e360950 100644
--- a/ydb/core/kqp/common/ya.make
+++ b/ydb/core/kqp/common/ya.make
@@ -1,25 +1,25 @@
-LIBRARY()
-
-OWNER(
-    spuchin
-    g:kikimr
-)
-
-SRCS(
-    kqp_common.cpp
-    kqp_common.h
-    kqp_resolve.cpp
-    kqp_resolve.h
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
+    g:kikimr 
+) 
+ 
+SRCS( 
+    kqp_common.cpp 
+    kqp_common.h 
+    kqp_resolve.cpp 
+    kqp_resolve.h 
     kqp_ru_calc.cpp
-    kqp_transform.cpp
-    kqp_transform.h
-    kqp_yql.cpp
-    kqp_yql.h
+    kqp_transform.cpp 
+    kqp_transform.h 
+    kqp_yql.cpp 
+    kqp_yql.h 
     kqp_timeouts.h
     kqp_timeouts.cpp
-)
-
-PEERDIR(
+) 
+ 
+PEERDIR( 
     ydb/core/base
     ydb/core/engine
     ydb/core/kqp/expr_nodes
@@ -28,10 +28,10 @@ PEERDIR(
     ydb/library/yql/core/issue
     ydb/library/yql/dq/actors
     ydb/library/yql/dq/common
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-GENERATE_ENUM_SERIALIZATION(kqp_yql.h)
-
-END()
+GENERATE_ENUM_SERIALIZATION(kqp_yql.h) 
+ 
+END() 
diff --git a/ydb/core/kqp/compile/kqp_compile.cpp b/ydb/core/kqp/compile/kqp_compile.cpp
index c7d305ab46..ad2bfc9eb6 100644
--- a/ydb/core/kqp/compile/kqp_compile.cpp
+++ b/ydb/core/kqp/compile/kqp_compile.cpp
@@ -1,52 +1,52 @@
-#include "kqp_compile.h"
-
+#include "kqp_compile.h" 
+ 
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/compile/kqp_mkql_compiler.h>
 #include <ydb/core/kqp/compile/kqp_olap_compiler.h>
 #include <ydb/core/kqp/opt/kqp_opt.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
-
+ 
 #include <ydb/core/tx/schemeshard/schemeshard_utils.h>
 #include <ydb/library/mkql_proto/mkql_proto.h>
-
+ 
 #include <ydb/library/yql/dq/opt/dq_opt.h>
 #include <ydb/library/yql/dq/tasks/dq_task_program.h>
 #include <ydb/library/yql/providers/common/mkql/yql_type_mkql.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NKikimr::NMiniKQL;
-using namespace NYql;
-using namespace NYql::NNodes;
-
-namespace {
-
-NKqpProto::TKqpPhyTx::EType GetPhyTxType(const EPhysicalTxType& type) {
-    switch (type) {
-        case EPhysicalTxType::Compute: return NKqpProto::TKqpPhyTx::TYPE_COMPUTE;
-        case EPhysicalTxType::Data: return NKqpProto::TKqpPhyTx::TYPE_DATA;
-        case EPhysicalTxType::Scan: return NKqpProto::TKqpPhyTx::TYPE_SCAN;
-
-        case EPhysicalTxType::Unspecified:
-            break;
-    }
-
-    YQL_ENSURE(false, "Unexpected physical transaction type: " << type);
-}
-
-NKqpProto::TKqpPhyQuery::EType GetPhyQueryType(const EPhysicalQueryType& type) {
-    switch (type) {
-        case EPhysicalQueryType::Data: return NKqpProto::TKqpPhyQuery::TYPE_DATA;
-        case EPhysicalQueryType::Scan: return NKqpProto::TKqpPhyQuery::TYPE_SCAN;
-
-        case EPhysicalQueryType::Unspecified:
-            break;
-    }
-
-    YQL_ENSURE(false, "Unexpected physical query type: " << type);
-}
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NKikimr::NMiniKQL; 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+NKqpProto::TKqpPhyTx::EType GetPhyTxType(const EPhysicalTxType& type) { 
+    switch (type) { 
+        case EPhysicalTxType::Compute: return NKqpProto::TKqpPhyTx::TYPE_COMPUTE; 
+        case EPhysicalTxType::Data: return NKqpProto::TKqpPhyTx::TYPE_DATA; 
+        case EPhysicalTxType::Scan: return NKqpProto::TKqpPhyTx::TYPE_SCAN; 
+ 
+        case EPhysicalTxType::Unspecified: 
+            break; 
+    } 
+ 
+    YQL_ENSURE(false, "Unexpected physical transaction type: " << type); 
+} 
+ 
+NKqpProto::TKqpPhyQuery::EType GetPhyQueryType(const EPhysicalQueryType& type) { 
+    switch (type) { 
+        case EPhysicalQueryType::Data: return NKqpProto::TKqpPhyQuery::TYPE_DATA; 
+        case EPhysicalQueryType::Scan: return NKqpProto::TKqpPhyQuery::TYPE_SCAN; 
+ 
+        case EPhysicalQueryType::Unspecified: 
+            break; 
+    } 
+ 
+    YQL_ENSURE(false, "Unexpected physical query type: " << type); 
+} 
+ 
 NKqpProto::TKqpPhyInternalBinding::EType GetPhyInternalBindingType(const std::string_view type) {
     NKqpProto::TKqpPhyInternalBinding::EType bindingType = NKqpProto::TKqpPhyInternalBinding::PARAM_UNSPECIFIED;
 
@@ -71,77 +71,77 @@ NKqpProto::TKqpPhyInternalBinding::EType GetPhyInternalBindingType(const std::st
     return bindingType;
 }
 
-void FillTable(const TKqpTable& table, NKqpProto::TKqpPhyTable& tableProto) {
-    auto pathId = TKikimrPathId::Parse(table.PathId());
-
-    tableProto.SetPath(TString(table.Path()));
-    tableProto.SetOwnerId(pathId.OwnerId());
-    tableProto.SetTableId(pathId.TableId());
-    tableProto.SetSysView(TString(table.SysView()));
-    tableProto.SetVersion(FromString<ui64>(table.Version()));
-}
-
-void FillColumns(const TCoAtomList& columns, const TKikimrTableMetadata& tableMeta,
-    NKqpProto::TKqpPhyTableOperation& opProto, bool allowSystemColumns)
-{
-    for (const auto& columnNode : columns) {
-        TString columnName(columnNode);
-
-        ui32 columnId = 0;
-        auto columnMeta = tableMeta.Columns.FindPtr(columnName);
-        if (columnMeta) {
-            columnId = columnMeta->Id;
-        } else if (allowSystemColumns) {
-            auto systemColumn = GetSystemColumns().find(columnName);
-            YQL_ENSURE(systemColumn != GetSystemColumns().end());
-            columnId = systemColumn->second.ColumnId;
-        }
-
-        YQL_ENSURE(columnId, "Unknown column: " << columnName);
-        auto& columnProto = *opProto.AddColumns();
-        columnProto.SetId(columnId);
-        columnProto.SetName(columnName);
-    }
-}
-
-void FillKeyBound(const TVarArgCallable<TExprBase>& bound, NKqpProto::TKqpPhyKeyBound& boundProto) {
-    if (bound.Maybe<TKqlKeyInc>()) {
-        boundProto.SetIsInclusive(true);
-    } else if (bound.Maybe<TKqlKeyExc>()) {
+void FillTable(const TKqpTable& table, NKqpProto::TKqpPhyTable& tableProto) { 
+    auto pathId = TKikimrPathId::Parse(table.PathId()); 
+ 
+    tableProto.SetPath(TString(table.Path())); 
+    tableProto.SetOwnerId(pathId.OwnerId()); 
+    tableProto.SetTableId(pathId.TableId()); 
+    tableProto.SetSysView(TString(table.SysView())); 
+    tableProto.SetVersion(FromString<ui64>(table.Version())); 
+} 
+ 
+void FillColumns(const TCoAtomList& columns, const TKikimrTableMetadata& tableMeta, 
+    NKqpProto::TKqpPhyTableOperation& opProto, bool allowSystemColumns) 
+{ 
+    for (const auto& columnNode : columns) { 
+        TString columnName(columnNode); 
+ 
+        ui32 columnId = 0; 
+        auto columnMeta = tableMeta.Columns.FindPtr(columnName); 
+        if (columnMeta) { 
+            columnId = columnMeta->Id; 
+        } else if (allowSystemColumns) { 
+            auto systemColumn = GetSystemColumns().find(columnName); 
+            YQL_ENSURE(systemColumn != GetSystemColumns().end()); 
+            columnId = systemColumn->second.ColumnId; 
+        } 
+ 
+        YQL_ENSURE(columnId, "Unknown column: " << columnName); 
+        auto& columnProto = *opProto.AddColumns(); 
+        columnProto.SetId(columnId); 
+        columnProto.SetName(columnName); 
+    } 
+} 
+ 
+void FillKeyBound(const TVarArgCallable<TExprBase>& bound, NKqpProto::TKqpPhyKeyBound& boundProto) { 
+    if (bound.Maybe<TKqlKeyInc>()) { 
+        boundProto.SetIsInclusive(true); 
+    } else if (bound.Maybe<TKqlKeyExc>()) { 
         boundProto.SetIsInclusive(false);
-    } else {
-        YQL_ENSURE(false, "Unexpected key bound type: " << bound.CallableName());
-    }
-
-    for (ui32 i = 0; i < bound.ArgCount(); ++i) {
-        const auto& key = bound.Arg(i);
-
-        auto& protoValue = *boundProto.AddValues();
-
-        if (auto maybeParam = key.Maybe<TCoParameter>()) {
-            auto& paramProto = *protoValue.MutableParamValue();
-            paramProto.SetParamName(TString(maybeParam.Cast().Name()));
-        } else if (auto maybeParam = key.Maybe<TCoNth>().Tuple().Maybe<TCoParameter>()) {
-            auto& paramElementProto = *protoValue.MutableParamElementValue();
-            paramElementProto.SetParamName(TString(maybeParam.Cast().Name()));
-            paramElementProto.SetElementIndex(FromString<ui32>(key.Cast<TCoNth>().Index().Value()));
-        } else {
-            YQL_ENSURE(false, "Unexpected key bound: " << key.Ref().Content());
-        }
-    }
-}
-
-void FillKeyRange(const TKqlKeyRange& range, NKqpProto::TKqpPhyKeyRange& rangeProto) {
-    rangeProto.MutableFrom()->SetIsInclusive(true);
-    rangeProto.MutableTo()->SetIsInclusive(true);
-
-    FillKeyBound(range.From(), *rangeProto.MutableFrom());
-    FillKeyBound(range.To(), *rangeProto.MutableTo());
-}
-
-template <typename TReader, typename TProto>
+    } else { 
+        YQL_ENSURE(false, "Unexpected key bound type: " << bound.CallableName()); 
+    } 
+ 
+    for (ui32 i = 0; i < bound.ArgCount(); ++i) { 
+        const auto& key = bound.Arg(i); 
+ 
+        auto& protoValue = *boundProto.AddValues(); 
+ 
+        if (auto maybeParam = key.Maybe<TCoParameter>()) { 
+            auto& paramProto = *protoValue.MutableParamValue(); 
+            paramProto.SetParamName(TString(maybeParam.Cast().Name())); 
+        } else if (auto maybeParam = key.Maybe<TCoNth>().Tuple().Maybe<TCoParameter>()) { 
+            auto& paramElementProto = *protoValue.MutableParamElementValue(); 
+            paramElementProto.SetParamName(TString(maybeParam.Cast().Name())); 
+            paramElementProto.SetElementIndex(FromString<ui32>(key.Cast<TCoNth>().Index().Value())); 
+        } else { 
+            YQL_ENSURE(false, "Unexpected key bound: " << key.Ref().Content()); 
+        } 
+    } 
+} 
+ 
+void FillKeyRange(const TKqlKeyRange& range, NKqpProto::TKqpPhyKeyRange& rangeProto) { 
+    rangeProto.MutableFrom()->SetIsInclusive(true); 
+    rangeProto.MutableTo()->SetIsInclusive(true); 
+ 
+    FillKeyBound(range.From(), *rangeProto.MutableFrom()); 
+    FillKeyBound(range.To(), *rangeProto.MutableTo()); 
+} 
+ 
+template <typename TReader, typename TProto> 
 void FillReadRange(const TReader& read, const TKikimrTableMetadata& tableMeta, TProto& readProto) {
-    FillKeyRange(read.Range(), *readProto.MutableKeyRange());
+    FillKeyRange(read.Range(), *readProto.MutableKeyRange()); 
 
     auto settings = TKqpReadTableSettings::Parse(read);
 
@@ -162,8 +162,8 @@ void FillReadRange(const TReader& read, const TKikimrTableMetadata& tableMeta, T
     }
 
     readProto.SetReverse(settings.Reverse);
-}
-
+} 
+ 
 template <typename TReader, typename TProto>
 void FillReadRanges(const TReader& read, const TKikimrTableMetadata& tableMeta, TProto& readProto)
 {
@@ -177,7 +177,7 @@ void FillReadRanges(const TReader& read, const TKikimrTableMetadata& tableMeta,
     } else {
         YQL_ENSURE(
             TCoVoid::Match(read.Ranges().Raw()),
-            "Read ranges should be parameter or void, got: " << read.Ranges().Ptr()->Content()
+            "Read ranges should be parameter or void, got: " << read.Ranges().Ptr()->Content() 
         );
     }
 
@@ -197,26 +197,26 @@ void FillReadRanges(const TReader& read, const TKikimrTableMetadata& tableMeta,
 }
 
 template <typename TEffectCallable, typename TEffectProto>
-void FillEffectRows(const TEffectCallable& callable, TEffectProto& proto, bool inplace) {
-    if (auto maybeList = callable.Input().template Maybe<TCoIterator>().List()) {
-        if (auto maybeParam = maybeList.Cast().template Maybe<TCoParameter>()) {
-            const auto name = TString(maybeParam.Cast().Name());
-            proto.MutableRowsValue()->MutableParamValue()->SetParamName(name);
-        } else {
-            YQL_ENSURE(false, "Unexpected effect input: " << maybeList.Cast().Ref().Content());
-        }
-    } else {
-        YQL_ENSURE(inplace, "Expected iterator as effect input, got: " << callable.Input().Ref().Content());
-    }
-}
-
-void FillLookup(const TKqpLookupTable& lookup, NKqpProto::TKqpPhyOpLookup& lookupProto) {
+void FillEffectRows(const TEffectCallable& callable, TEffectProto& proto, bool inplace) { 
+    if (auto maybeList = callable.Input().template Maybe<TCoIterator>().List()) { 
+        if (auto maybeParam = maybeList.Cast().template Maybe<TCoParameter>()) { 
+            const auto name = TString(maybeParam.Cast().Name()); 
+            proto.MutableRowsValue()->MutableParamValue()->SetParamName(name); 
+        } else { 
+            YQL_ENSURE(false, "Unexpected effect input: " << maybeList.Cast().Ref().Content()); 
+        } 
+    } else { 
+        YQL_ENSURE(inplace, "Expected iterator as effect input, got: " << callable.Input().Ref().Content()); 
+    } 
+} 
+ 
+void FillLookup(const TKqpLookupTable& lookup, NKqpProto::TKqpPhyOpLookup& lookupProto) { 
     auto maybeList = lookup.LookupKeys().Maybe<TCoIterator>().List();
-    YQL_ENSURE(maybeList, "Expected iterator as lookup input, got: " << lookup.LookupKeys().Ref().Content());
+    YQL_ENSURE(maybeList, "Expected iterator as lookup input, got: " << lookup.LookupKeys().Ref().Content()); 
 
     if (auto maybeParam = maybeList.Cast().Maybe<TCoParameter>()) {
          lookupProto.MutableKeysValue()->MutableParamValue()->SetParamName(maybeParam.Cast().Name().StringValue());
-    } else if (auto maybeAsList = maybeList.Cast().Maybe<TCoAsList>()) {
+    } else if (auto maybeAsList = maybeList.Cast().Maybe<TCoAsList>()) { 
         auto asList = maybeAsList.Cast();
         auto proto = lookupProto.MutableKeysValue()->MutableRowsList();
 
@@ -301,72 +301,72 @@ void FillLookup(const TKqpLookupTable& lookup, NKqpProto::TKqpPhyOpLookup& looku
                 }
             }
         }
-    } else {
-        YQL_ENSURE(false, "Unexpected lookup input: " << maybeList.Cast().Ref().Content());
+    } else { 
+        YQL_ENSURE(false, "Unexpected lookup input: " << maybeList.Cast().Ref().Content()); 
     }
-}
-
+} 
+ 
 void FillOlapProgram(const TCoLambda& process, const TKikimrTableMetadata& tableMeta,
     NKqpProto::TKqpPhyOpReadOlapRanges& readProto)
-{
+{ 
     CompileOlapProgram(process, tableMeta, readProto);
-}
-
-void FillConnection(const TDqConnection& connection, const TMap<ui64, ui32>& stagesMap,
+} 
+ 
+void FillConnection(const TDqConnection& connection, const TMap<ui64, ui32>& stagesMap, 
     NKqpProto::TKqpPhyConnection& connectionProto, TExprContext& ctx)
-{
-    auto inputStageIndex = stagesMap.FindPtr(connection.Output().Stage().Ref().UniqueId());
+{ 
+    auto inputStageIndex = stagesMap.FindPtr(connection.Output().Stage().Ref().UniqueId()); 
     YQL_ENSURE(inputStageIndex, "stage #" << connection.Output().Stage().Ref().UniqueId() << " not found in stages map: "
         << PrintKqpStageOnly(connection.Output().Stage(), ctx));
-
-    auto outputIndex = FromString<ui32>(connection.Output().Index().Value());
-
-    connectionProto.SetStageIndex(*inputStageIndex);
-    connectionProto.SetOutputIndex(outputIndex);
-
-    if (connection.Maybe<TDqCnUnionAll>()) {
-        connectionProto.MutableUnionAll();
-        return;
-    }
-
+ 
+    auto outputIndex = FromString<ui32>(connection.Output().Index().Value()); 
+ 
+    connectionProto.SetStageIndex(*inputStageIndex); 
+    connectionProto.SetOutputIndex(outputIndex); 
+ 
+    if (connection.Maybe<TDqCnUnionAll>()) { 
+        connectionProto.MutableUnionAll(); 
+        return; 
+    } 
+ 
     if (auto maybeShuffle = connection.Maybe<TDqCnHashShuffle>()) {
         auto& shuffleProto = *connectionProto.MutableHashShuffle();
-        for (const auto& keyColumn : maybeShuffle.Cast().KeyColumns()) {
-            shuffleProto.AddKeyColumns(TString(keyColumn));
-        }
-        return;
-    }
-
-    if (connection.Maybe<TDqCnMap>()) {
-        connectionProto.MutableMap();
-        return;
-    }
-
-    if (connection.Maybe<TDqCnBroadcast>()) {
-        connectionProto.MutableBroadcast();
-        return;
-    }
-
-    if (connection.Maybe<TDqCnResult>()) {
-        connectionProto.MutableResult();
-        return;
-    }
-
-    if (connection.Maybe<TDqCnValue>()) {
-        connectionProto.MutableValue();
-        return;
-    }
-
-    if (connection.Maybe<TKqpCnMapShard>()) {
-        connectionProto.MutableMapShard();
-        return;
-    }
-
-    if (connection.Maybe<TKqpCnShuffleShard>()) {
-        connectionProto.MutableShuffleShard();
-        return;
-    }
-
+        for (const auto& keyColumn : maybeShuffle.Cast().KeyColumns()) { 
+            shuffleProto.AddKeyColumns(TString(keyColumn)); 
+        } 
+        return; 
+    } 
+ 
+    if (connection.Maybe<TDqCnMap>()) { 
+        connectionProto.MutableMap(); 
+        return; 
+    } 
+ 
+    if (connection.Maybe<TDqCnBroadcast>()) { 
+        connectionProto.MutableBroadcast(); 
+        return; 
+    } 
+ 
+    if (connection.Maybe<TDqCnResult>()) { 
+        connectionProto.MutableResult(); 
+        return; 
+    } 
+ 
+    if (connection.Maybe<TDqCnValue>()) { 
+        connectionProto.MutableValue(); 
+        return; 
+    } 
+ 
+    if (connection.Maybe<TKqpCnMapShard>()) { 
+        connectionProto.MutableMapShard(); 
+        return; 
+    } 
+ 
+    if (connection.Maybe<TKqpCnShuffleShard>()) { 
+        connectionProto.MutableShuffleShard(); 
+        return; 
+    } 
+ 
     if (auto maybeMerge = connection.Maybe<TDqCnMerge>()) {
         auto& mergeProto = *connectionProto.MutableMerge();
         for (const auto& sortColumn : maybeMerge.Cast().SortColumns()) {
@@ -377,120 +377,120 @@ void FillConnection(const TDqConnection& connection, const TMap<ui64, ui32>& sta
         return;
     }
 
-    YQL_ENSURE(false, "Unexpected connection type: " << connection.CallableName());
-}
-
-class TKqpQueryCompiler : public IKqpQueryCompiler {
-public:
-    TKqpQueryCompiler(const TString& cluster, const TIntrusivePtr<TKikimrTablesData> tablesData,
-        const NMiniKQL::IFunctionRegistry& funcRegistry)
-        : Cluster(cluster)
-        , TablesData(tablesData)
-        , FuncRegistry(funcRegistry)
-        , Alloc(TAlignedPagePoolCounters(), funcRegistry.SupportsSizedAllocators())
-        , TypeEnv(Alloc)
-        , KqlCtx(cluster, tablesData, TypeEnv, FuncRegistry)
-        , KqlCompiler(CreateKqlCompiler(KqlCtx))
-    {
-        Alloc.Release();
-    }
-
-    ~TKqpQueryCompiler() {
-        Alloc.Acquire();
-    }
-
-    bool CompilePhysicalQuery(const TKqpPhysicalQuery& query, const TKiOperationList& tableOps,
-        NKqpProto::TKqpPhyQuery& queryProto, TExprContext& ctx) final
-    {
-        TGuard<TScopedAlloc> allocGuard(Alloc);
-
-        auto querySettings = TKqpPhyQuerySettings::Parse(query);
-        YQL_ENSURE(querySettings.Type);
-        queryProto.SetType(GetPhyQueryType(*querySettings.Type));
-
-        auto ops = TableOperationsToProto(tableOps, ctx);
-        for (auto& op : ops) {
-            const auto& tableName = op.GetTable();
-
-            queryProto.AddTableOps()->Swap(&op);
-
-            const auto& desc = TablesData->GetTable(Cluster, tableName);
-            TableDescriptionToTableInfo(desc, queryProto.AddTableInfos());
-        }
-
-        for (const auto& tx : query.Transactions()) {
-            CompileTransaction(tx, *queryProto.AddTransactions(), ctx);
-        }
-
-        for (const auto& result : query.Results()) {
-            YQL_ENSURE(result.Maybe<TKqpTxResultBinding>());
-            auto binding = result.Cast<TKqpTxResultBinding>();
-
-            auto txIndex = FromString<ui32>(binding.TxIndex().Value());
-            auto resultIndex = FromString<ui32>(binding.ResultIndex());
-
-            YQL_ENSURE(txIndex < queryProto.TransactionsSize());
-            YQL_ENSURE(resultIndex < queryProto.GetTransactions(txIndex).ResultsSize());
-
-            auto& bindingProto = *queryProto.AddResultBindings();
-            auto& txResultProto = *bindingProto.MutableTxResultBinding();
-            txResultProto.SetTxIndex(txIndex);
-            txResultProto.SetResultIndex(resultIndex);
-        }
-
-        return true;
-    }
-
-private:
-    void CompileStage(const TDqPhyStage& stage, NKqpProto::TKqpPhyStage& stageProto, TExprContext& ctx,
-        const TMap<ui64, ui32>& stagesMap)
-    {
-        stageProto.SetIsEffectsStage(NOpt::IsKqpEffectsStage(stage));
-
-        for (ui32 inputIndex = 0; inputIndex < stage.Inputs().Size(); ++inputIndex) {
-            const auto& input = stage.Inputs().Item(inputIndex);
-            YQL_ENSURE(input.Maybe<TDqConnection>());
-            auto connection = input.Cast<TDqConnection>();
-
-            auto& protoInput = *stageProto.AddInputs();
+    YQL_ENSURE(false, "Unexpected connection type: " << connection.CallableName()); 
+} 
+ 
+class TKqpQueryCompiler : public IKqpQueryCompiler { 
+public: 
+    TKqpQueryCompiler(const TString& cluster, const TIntrusivePtr<TKikimrTablesData> tablesData, 
+        const NMiniKQL::IFunctionRegistry& funcRegistry) 
+        : Cluster(cluster) 
+        , TablesData(tablesData) 
+        , FuncRegistry(funcRegistry) 
+        , Alloc(TAlignedPagePoolCounters(), funcRegistry.SupportsSizedAllocators()) 
+        , TypeEnv(Alloc) 
+        , KqlCtx(cluster, tablesData, TypeEnv, FuncRegistry) 
+        , KqlCompiler(CreateKqlCompiler(KqlCtx)) 
+    { 
+        Alloc.Release(); 
+    } 
+ 
+    ~TKqpQueryCompiler() { 
+        Alloc.Acquire(); 
+    } 
+ 
+    bool CompilePhysicalQuery(const TKqpPhysicalQuery& query, const TKiOperationList& tableOps, 
+        NKqpProto::TKqpPhyQuery& queryProto, TExprContext& ctx) final 
+    { 
+        TGuard<TScopedAlloc> allocGuard(Alloc); 
+ 
+        auto querySettings = TKqpPhyQuerySettings::Parse(query); 
+        YQL_ENSURE(querySettings.Type); 
+        queryProto.SetType(GetPhyQueryType(*querySettings.Type)); 
+ 
+        auto ops = TableOperationsToProto(tableOps, ctx); 
+        for (auto& op : ops) { 
+            const auto& tableName = op.GetTable(); 
+ 
+            queryProto.AddTableOps()->Swap(&op); 
+ 
+            const auto& desc = TablesData->GetTable(Cluster, tableName); 
+            TableDescriptionToTableInfo(desc, queryProto.AddTableInfos()); 
+        } 
+ 
+        for (const auto& tx : query.Transactions()) { 
+            CompileTransaction(tx, *queryProto.AddTransactions(), ctx); 
+        } 
+ 
+        for (const auto& result : query.Results()) { 
+            YQL_ENSURE(result.Maybe<TKqpTxResultBinding>()); 
+            auto binding = result.Cast<TKqpTxResultBinding>(); 
+ 
+            auto txIndex = FromString<ui32>(binding.TxIndex().Value()); 
+            auto resultIndex = FromString<ui32>(binding.ResultIndex()); 
+ 
+            YQL_ENSURE(txIndex < queryProto.TransactionsSize()); 
+            YQL_ENSURE(resultIndex < queryProto.GetTransactions(txIndex).ResultsSize()); 
+ 
+            auto& bindingProto = *queryProto.AddResultBindings(); 
+            auto& txResultProto = *bindingProto.MutableTxResultBinding(); 
+            txResultProto.SetTxIndex(txIndex); 
+            txResultProto.SetResultIndex(resultIndex); 
+        } 
+ 
+        return true; 
+    } 
+ 
+private: 
+    void CompileStage(const TDqPhyStage& stage, NKqpProto::TKqpPhyStage& stageProto, TExprContext& ctx, 
+        const TMap<ui64, ui32>& stagesMap) 
+    { 
+        stageProto.SetIsEffectsStage(NOpt::IsKqpEffectsStage(stage)); 
+ 
+        for (ui32 inputIndex = 0; inputIndex < stage.Inputs().Size(); ++inputIndex) { 
+            const auto& input = stage.Inputs().Item(inputIndex); 
+            YQL_ENSURE(input.Maybe<TDqConnection>()); 
+            auto connection = input.Cast<TDqConnection>(); 
+ 
+            auto& protoInput = *stageProto.AddInputs(); 
             FillConnection(connection, stagesMap, protoInput, ctx);
-        }
-
-        bool hasSort = false;
-        bool hasMapJoin = false;
+        } 
+ 
+        bool hasSort = false; 
+        bool hasMapJoin = false; 
         bool hasUdf = false;
-        VisitExpr(stage.Program().Ptr(), [&](const TExprNode::TPtr& exprNode) {
-            TExprBase node(exprNode);
+        VisitExpr(stage.Program().Ptr(), [&](const TExprNode::TPtr& exprNode) { 
+            TExprBase node(exprNode); 
             if (auto maybeReadTable = node.Maybe<TKqpWideReadTable>()) {
-                auto readTable = maybeReadTable.Cast();
-                auto tableMeta = TablesData->ExistingTable(Cluster, readTable.Table().Path()).Metadata;
-                YQL_ENSURE(tableMeta);
-
-                auto& tableOp = *stageProto.AddTableOps();
-                FillTable(readTable.Table(), *tableOp.MutableTable());
-                FillColumns(readTable.Columns(), *tableMeta, tableOp, true);
+                auto readTable = maybeReadTable.Cast(); 
+                auto tableMeta = TablesData->ExistingTable(Cluster, readTable.Table().Path()).Metadata; 
+                YQL_ENSURE(tableMeta); 
+ 
+                auto& tableOp = *stageProto.AddTableOps(); 
+                FillTable(readTable.Table(), *tableOp.MutableTable()); 
+                FillColumns(readTable.Columns(), *tableMeta, tableOp, true); 
                 FillReadRange(readTable, *tableMeta, *tableOp.MutableReadRange());
-            } else if (auto maybeLookupTable = node.Maybe<TKqpLookupTable>()) {
-                auto lookupTable = maybeLookupTable.Cast();
-                auto tableMeta = TablesData->ExistingTable(Cluster, lookupTable.Table().Path()).Metadata;
-                YQL_ENSURE(tableMeta);
-
-                auto& tableOp = *stageProto.AddTableOps();
-                FillTable(lookupTable.Table(), *tableOp.MutableTable());
-                FillColumns(lookupTable.Columns(), *tableMeta, tableOp, true);
-                FillLookup(lookupTable, *tableOp.MutableLookup());
-            } else if (auto maybeUpsertRows = node.Maybe<TKqpUpsertRows>()) {
-                auto upsertRows = maybeUpsertRows.Cast();
-                auto tableMeta = TablesData->ExistingTable(Cluster, upsertRows.Table().Path()).Metadata;
-                YQL_ENSURE(tableMeta);
-                YQL_ENSURE(stageProto.GetIsEffectsStage());
-
-                auto settings = TKqpUpsertRowsSettings::Parse(upsertRows);
-
-                auto& tableOp = *stageProto.AddTableOps();
-                FillTable(upsertRows.Table(), *tableOp.MutableTable());
-                FillColumns(upsertRows.Columns(), *tableMeta, tableOp, false);
-                FillEffectRows(upsertRows, *tableOp.MutableUpsertRows(), settings.Inplace);
+            } else if (auto maybeLookupTable = node.Maybe<TKqpLookupTable>()) { 
+                auto lookupTable = maybeLookupTable.Cast(); 
+                auto tableMeta = TablesData->ExistingTable(Cluster, lookupTable.Table().Path()).Metadata; 
+                YQL_ENSURE(tableMeta); 
+ 
+                auto& tableOp = *stageProto.AddTableOps(); 
+                FillTable(lookupTable.Table(), *tableOp.MutableTable()); 
+                FillColumns(lookupTable.Columns(), *tableMeta, tableOp, true); 
+                FillLookup(lookupTable, *tableOp.MutableLookup()); 
+            } else if (auto maybeUpsertRows = node.Maybe<TKqpUpsertRows>()) { 
+                auto upsertRows = maybeUpsertRows.Cast(); 
+                auto tableMeta = TablesData->ExistingTable(Cluster, upsertRows.Table().Path()).Metadata; 
+                YQL_ENSURE(tableMeta); 
+                YQL_ENSURE(stageProto.GetIsEffectsStage()); 
+ 
+                auto settings = TKqpUpsertRowsSettings::Parse(upsertRows); 
+ 
+                auto& tableOp = *stageProto.AddTableOps(); 
+                FillTable(upsertRows.Table(), *tableOp.MutableTable()); 
+                FillColumns(upsertRows.Columns(), *tableMeta, tableOp, false); 
+                FillEffectRows(upsertRows, *tableOp.MutableUpsertRows(), settings.Inplace); 
             } else if (auto maybeDeleteRows = node.Maybe<TKqpDeleteRows>()) {
                 auto deleteRows = maybeDeleteRows.Cast();
                 auto tableMeta = TablesData->ExistingTable(Cluster, deleteRows.Table().Path()).Metadata;
@@ -500,12 +500,12 @@ private:
 
                 auto& tableOp = *stageProto.AddTableOps();
                 FillTable(deleteRows.Table(), *tableOp.MutableTable());
-                FillEffectRows(deleteRows, *tableOp.MutableDeleteRows(), false);
+                FillEffectRows(deleteRows, *tableOp.MutableDeleteRows(), false); 
             } else if (auto maybeWideReadTableRanges = node.Maybe<TKqpWideReadTableRanges>()) {
                 auto readTableRanges = maybeWideReadTableRanges.Cast();
                 auto tableMeta = TablesData->ExistingTable(Cluster, readTableRanges.Table().Path()).Metadata;
                 YQL_ENSURE(tableMeta);
-
+ 
                 auto& tableOp = *stageProto.AddTableOps();
                 FillTable(readTableRanges.Table(), *tableOp.MutableTable());
                 FillColumns(readTableRanges.Columns(), *tableMeta, tableOp, true);
@@ -521,133 +521,133 @@ private:
                 FillReadRanges(readTableRanges, *tableMeta, *tableOp.MutableReadOlapRange());
                 FillOlapProgram(readTableRanges.Process(), *tableMeta, *tableOp.MutableReadOlapRange());
             } else if (node.Maybe<TCoSort>()) {
-                hasSort = true;
+                hasSort = true; 
             } else if (node.Maybe<TCoMapJoinCore>()) {
-                hasMapJoin = true;
+                hasMapJoin = true; 
             } else if (node.Maybe<TCoUdf>()) {
                 hasUdf = true;
             } else {
                 YQL_ENSURE(!node.Maybe<TKqpReadTable>());
             }
 
-            return true;
-        });
-
-        auto result = stage.Program().Body();
-        auto resultType = result.Ref().GetTypeAnn();
-        ui32 outputsCount = 0;
-        if (resultType->GetKind() == ETypeAnnotationKind::Stream) {
-            auto resultItemType = resultType->Cast<TStreamExprType>()->GetItemType();
-            if (resultItemType->GetKind() == ETypeAnnotationKind::Variant) {
-                auto underlyingType = resultItemType->Cast<TVariantExprType>()->GetUnderlyingType();
-                YQL_ENSURE(underlyingType->GetKind() == ETypeAnnotationKind::Tuple);
-                outputsCount = underlyingType->Cast<TTupleExprType>()->GetSize();
-                YQL_ENSURE(outputsCount > 1);
-            } else {
-                outputsCount = 1;
-            }
-        } else {
-            YQL_ENSURE(resultType->GetKind() == ETypeAnnotationKind::Void, "got " << *resultType);
-        }
-
-        stageProto.SetOutputsCount(outputsCount);
-
-        auto paramsType = NDq::CollectParameters(stage.Program(), ctx);
-        auto programBytecode = NDq::BuildProgram(stage.Program(), *paramsType, *KqlCompiler, TypeEnv, FuncRegistry,
+            return true; 
+        }); 
+ 
+        auto result = stage.Program().Body(); 
+        auto resultType = result.Ref().GetTypeAnn(); 
+        ui32 outputsCount = 0; 
+        if (resultType->GetKind() == ETypeAnnotationKind::Stream) { 
+            auto resultItemType = resultType->Cast<TStreamExprType>()->GetItemType(); 
+            if (resultItemType->GetKind() == ETypeAnnotationKind::Variant) { 
+                auto underlyingType = resultItemType->Cast<TVariantExprType>()->GetUnderlyingType(); 
+                YQL_ENSURE(underlyingType->GetKind() == ETypeAnnotationKind::Tuple); 
+                outputsCount = underlyingType->Cast<TTupleExprType>()->GetSize(); 
+                YQL_ENSURE(outputsCount > 1); 
+            } else { 
+                outputsCount = 1; 
+            } 
+        } else { 
+            YQL_ENSURE(resultType->GetKind() == ETypeAnnotationKind::Void, "got " << *resultType); 
+        } 
+ 
+        stageProto.SetOutputsCount(outputsCount); 
+ 
+        auto paramsType = NDq::CollectParameters(stage.Program(), ctx); 
+        auto programBytecode = NDq::BuildProgram(stage.Program(), *paramsType, *KqlCompiler, TypeEnv, FuncRegistry, 
             ctx, {});
-
-        auto& programProto = *stageProto.MutableProgram();
-        programProto.SetRuntimeVersion(NYql::NDqProto::ERuntimeVersion::RUNTIME_VERSION_YQL_1_0);
-        programProto.SetRaw(programBytecode);
-        programProto.MutableSettings()->SetHasMapJoin(hasMapJoin);
-        programProto.MutableSettings()->SetHasSort(hasSort);
+ 
+        auto& programProto = *stageProto.MutableProgram(); 
+        programProto.SetRuntimeVersion(NYql::NDqProto::ERuntimeVersion::RUNTIME_VERSION_YQL_1_0); 
+        programProto.SetRaw(programBytecode); 
+        programProto.MutableSettings()->SetHasMapJoin(hasMapJoin); 
+        programProto.MutableSettings()->SetHasSort(hasSort); 
         programProto.MutableSettings()->SetHasUdf(hasUdf);
-
-        for (auto member : paramsType->GetItems()) {
-            auto paramName = TString(member->GetName());
-            stageProto.AddProgramParameters(paramName);
-        }
-
-        stageProto.SetProgramAst(KqpExprToPrettyString(stage.Program(), ctx));
+ 
+        for (auto member : paramsType->GetItems()) { 
+            auto paramName = TString(member->GetName()); 
+            stageProto.AddProgramParameters(paramName); 
+        } 
+ 
+        stageProto.SetProgramAst(KqpExprToPrettyString(stage.Program(), ctx)); 
         stageProto.SetStageGuid(NDq::TDqStageSettings::Parse(stage).Id);
-    }
-
-    void CompileTransaction(const TKqpPhysicalTx& tx, NKqpProto::TKqpPhyTx& txProto, TExprContext& ctx) {
-        auto txSettings = TKqpPhyTxSettings::Parse(tx);
-        YQL_ENSURE(txSettings.Type);
-        txProto.SetType(GetPhyTxType(*txSettings.Type));
-
+    } 
+ 
+    void CompileTransaction(const TKqpPhysicalTx& tx, NKqpProto::TKqpPhyTx& txProto, TExprContext& ctx) { 
+        auto txSettings = TKqpPhyTxSettings::Parse(tx); 
+        YQL_ENSURE(txSettings.Type); 
+        txProto.SetType(GetPhyTxType(*txSettings.Type)); 
+ 
         bool hasEffectStage = false;
 
-        TMap<ui64, ui32> stagesMap;
-        for (const auto& stage : tx.Stages()) {
+        TMap<ui64, ui32> stagesMap; 
+        for (const auto& stage : tx.Stages()) { 
             auto* protoStage = txProto.AddStages();
             CompileStage(stage, *protoStage, ctx, stagesMap);
             hasEffectStage |= protoStage->GetIsEffectsStage();
-            stagesMap[stage.Ref().UniqueId()] = txProto.StagesSize() - 1;
-        }
-
+            stagesMap[stage.Ref().UniqueId()] = txProto.StagesSize() - 1; 
+        } 
+ 
         YQL_ENSURE(hasEffectStage == txSettings.WithEffects);
 
         txProto.SetHasEffects(txSettings.WithEffects);
 
-        for (const auto& paramBinding : tx.ParamBindings()) {
-            TString paramName(paramBinding.Name().Value());
-            const auto& binding = paramBinding.Binding();
-
-            auto& bindingProto = *txProto.AddParamBindings();
-            bindingProto.SetName(paramName);
-
-            if (!binding) {
-                bindingProto.MutableExternalBinding();
-            } else if (auto maybeResultBinding = binding.Maybe<TKqpTxResultBinding>()) {
-                auto resultBinding = maybeResultBinding.Cast();
-                auto txIndex = FromString<ui32>(resultBinding.TxIndex());
-                auto resultIndex = FromString<ui32>(resultBinding.ResultIndex());
-
-                auto& txResultProto = *bindingProto.MutableTxResultBinding();
-                txResultProto.SetTxIndex(txIndex);
-                txResultProto.SetResultIndex(resultIndex);
+        for (const auto& paramBinding : tx.ParamBindings()) { 
+            TString paramName(paramBinding.Name().Value()); 
+            const auto& binding = paramBinding.Binding(); 
+ 
+            auto& bindingProto = *txProto.AddParamBindings(); 
+            bindingProto.SetName(paramName); 
+ 
+            if (!binding) { 
+                bindingProto.MutableExternalBinding(); 
+            } else if (auto maybeResultBinding = binding.Maybe<TKqpTxResultBinding>()) { 
+                auto resultBinding = maybeResultBinding.Cast(); 
+                auto txIndex = FromString<ui32>(resultBinding.TxIndex()); 
+                auto resultIndex = FromString<ui32>(resultBinding.ResultIndex()); 
+ 
+                auto& txResultProto = *bindingProto.MutableTxResultBinding(); 
+                txResultProto.SetTxIndex(txIndex); 
+                txResultProto.SetResultIndex(resultIndex); 
             } else if (auto maybeInternalBinding = binding.Maybe<TKqpTxInternalBinding>()) {
                 auto internalBinding = maybeInternalBinding.Cast();
                 auto& internalBindingProto = *bindingProto.MutableInternalBinding();
                 internalBindingProto.SetType(GetPhyInternalBindingType(internalBinding.Kind().Value()));
-            } else {
-                YQL_ENSURE(false, "Unknown parameter binding type: " << binding.Cast().CallableName());
-            }
-        }
-
-        TProgramBuilder pgmBuilder(TypeEnv, FuncRegistry);
-        for (const auto& resultNode : tx.Results()) {
+            } else { 
+                YQL_ENSURE(false, "Unknown parameter binding type: " << binding.Cast().CallableName()); 
+            } 
+        } 
+ 
+        TProgramBuilder pgmBuilder(TypeEnv, FuncRegistry); 
+        for (const auto& resultNode : tx.Results()) { 
             YQL_ENSURE(resultNode.Maybe<TDqConnection>(), "" << NCommon::ExprToPrettyString(ctx, tx.Ref()));
-            auto connection = resultNode.Cast<TDqConnection>();
-
-            auto& resultProto = *txProto.AddResults();
-            auto& connectionProto = *resultProto.MutableConnection();
+            auto connection = resultNode.Cast<TDqConnection>(); 
+ 
+            auto& resultProto = *txProto.AddResults(); 
+            auto& connectionProto = *resultProto.MutableConnection(); 
             FillConnection(connection, stagesMap, connectionProto, ctx);
-
-            const TTypeAnnotationNode* itemType = nullptr;
-            switch (connectionProto.GetTypeCase()) {
-                case NKqpProto::TKqpPhyConnection::kValue:
-                    resultProto.SetIsStream(false);
-                    itemType = resultNode.Ref().GetTypeAnn();
-                    break;
-
-                case NKqpProto::TKqpPhyConnection::kResult:
-                    resultProto.SetIsStream(true);
-                    itemType = resultNode.Ref().GetTypeAnn()->Cast<TListExprType>()->GetItemType();
-                    break;
-
-                default:
-                    YQL_ENSURE(false, "Unexpected result connection type: " << (ui32)connectionProto.GetTypeCase());
-            }
-
-            YQL_ENSURE(itemType);
-            TStringStream errorStream;
-            auto type = NCommon::BuildType(*itemType, pgmBuilder, errorStream);
-            YQL_ENSURE(type);
-
-            ExportTypeToProto(type, *resultProto.MutableItemType());
+ 
+            const TTypeAnnotationNode* itemType = nullptr; 
+            switch (connectionProto.GetTypeCase()) { 
+                case NKqpProto::TKqpPhyConnection::kValue: 
+                    resultProto.SetIsStream(false); 
+                    itemType = resultNode.Ref().GetTypeAnn(); 
+                    break; 
+ 
+                case NKqpProto::TKqpPhyConnection::kResult: 
+                    resultProto.SetIsStream(true); 
+                    itemType = resultNode.Ref().GetTypeAnn()->Cast<TListExprType>()->GetItemType(); 
+                    break; 
+ 
+                default: 
+                    YQL_ENSURE(false, "Unexpected result connection type: " << (ui32)connectionProto.GetTypeCase()); 
+            } 
+ 
+            YQL_ENSURE(itemType); 
+            TStringStream errorStream; 
+            auto type = NCommon::BuildType(*itemType, pgmBuilder, errorStream); 
+            YQL_ENSURE(type); 
+ 
+            ExportTypeToProto(type, *resultProto.MutableItemType()); 
 
             TMaybeNode<TCoAtomList> maybeColumnHints;
             if (connection.Maybe<TDqCnResult>()) {
@@ -666,26 +666,26 @@ private:
                     columnHintsProto.Add(TString(columnHint.Value()));
                 }
             }
-        }
-    }
-
-private:
-    TString Cluster;
-    const TIntrusivePtr<TKikimrTablesData> TablesData;
-    const IFunctionRegistry& FuncRegistry;
-    NMiniKQL::TScopedAlloc Alloc;
-    NMiniKQL::TTypeEnvironment TypeEnv;
-    TKqlCompileContext KqlCtx;
-    TIntrusivePtr<NCommon::IMkqlCallableCompiler> KqlCompiler;
-};
-
-} // namespace
-
-TIntrusivePtr<IKqpQueryCompiler> CreateKqpQueryCompiler(const TString& cluster,
-    const TIntrusivePtr<TKikimrTablesData> tablesData, const IFunctionRegistry& funcRegistry)
-{
-    return MakeIntrusive<TKqpQueryCompiler>(cluster, tablesData, funcRegistry);
-}
-
+        } 
+    } 
+ 
+private: 
+    TString Cluster; 
+    const TIntrusivePtr<TKikimrTablesData> TablesData; 
+    const IFunctionRegistry& FuncRegistry; 
+    NMiniKQL::TScopedAlloc Alloc; 
+    NMiniKQL::TTypeEnvironment TypeEnv; 
+    TKqlCompileContext KqlCtx; 
+    TIntrusivePtr<NCommon::IMkqlCallableCompiler> KqlCompiler; 
+}; 
+ 
+} // namespace 
+ 
+TIntrusivePtr<IKqpQueryCompiler> CreateKqpQueryCompiler(const TString& cluster, 
+    const TIntrusivePtr<TKikimrTablesData> tablesData, const IFunctionRegistry& funcRegistry) 
+{ 
+    return MakeIntrusive<TKqpQueryCompiler>(cluster, tablesData, funcRegistry); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/compile/kqp_compile.h b/ydb/core/kqp/compile/kqp_compile.h
index 774bb3cc53..37297a1ea0 100644
--- a/ydb/core/kqp/compile/kqp_compile.h
+++ b/ydb/core/kqp/compile/kqp_compile.h
@@ -1,23 +1,23 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.h>
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.h>
 #include <ydb/core/protos/kqp_physical.pb.h>
-
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_provider.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-class IKqpQueryCompiler : public TThrRefBase {
-public:
-    virtual bool CompilePhysicalQuery(const NYql::NNodes::TKqpPhysicalQuery& query,
-        const NYql::NNodes::TKiOperationList& tableOps, NKqpProto::TKqpPhyQuery& queryProto,
-        NYql::TExprContext& ctx) = 0;
-};
-
-TIntrusivePtr<IKqpQueryCompiler> CreateKqpQueryCompiler(const TString& cluster,
-    const TIntrusivePtr<NYql::TKikimrTablesData> tablesData, const NMiniKQL::IFunctionRegistry& funcRegistry);
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+class IKqpQueryCompiler : public TThrRefBase { 
+public: 
+    virtual bool CompilePhysicalQuery(const NYql::NNodes::TKqpPhysicalQuery& query, 
+        const NYql::NNodes::TKiOperationList& tableOps, NKqpProto::TKqpPhyQuery& queryProto, 
+        NYql::TExprContext& ctx) = 0; 
+}; 
+ 
+TIntrusivePtr<IKqpQueryCompiler> CreateKqpQueryCompiler(const TString& cluster, 
+    const TIntrusivePtr<NYql::TKikimrTablesData> tablesData, const NMiniKQL::IFunctionRegistry& funcRegistry); 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/compile/kqp_mkql_compiler.cpp b/ydb/core/kqp/compile/kqp_mkql_compiler.cpp
index 0413044698..5bc9d22322 100644
--- a/ydb/core/kqp/compile/kqp_mkql_compiler.cpp
+++ b/ydb/core/kqp/compile/kqp_mkql_compiler.cpp
@@ -1,59 +1,59 @@
-#include "kqp_mkql_compiler.h"
-
+#include "kqp_mkql_compiler.h" 
+ 
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/scheme/scheme_tabledefs.h>
-
+ 
 #include <ydb/library/yql/providers/common/mkql/yql_type_mkql.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NCommon;
-using namespace NYql::NNodes;
-using namespace NKikimr::NMiniKQL;
-
-namespace {
-
-TVector<TKqpTableColumn> GetKqpColumns(const TKikimrTableMetadata& table, const TVector<TStringBuf>& columnNames,
-    bool allowSystemColumns)
-{
-    TVector<TKqpTableColumn> pgmColumns;
-    for (const auto& name : columnNames) {
-        ui32 columnId = 0;
-        ui32 columnType = 0;
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NCommon; 
+using namespace NYql::NNodes; 
+using namespace NKikimr::NMiniKQL; 
+ 
+namespace { 
+ 
+TVector<TKqpTableColumn> GetKqpColumns(const TKikimrTableMetadata& table, const TVector<TStringBuf>& columnNames, 
+    bool allowSystemColumns) 
+{ 
+    TVector<TKqpTableColumn> pgmColumns; 
+    for (const auto& name : columnNames) { 
+        ui32 columnId = 0; 
+        ui32 columnType = 0; 
         bool notNull = false;
-
-        auto columnData = table.Columns.FindPtr(name);
-        if (columnData) {
-            columnId = columnData->Id;
-            columnType = columnData->TypeId;
+ 
+        auto columnData = table.Columns.FindPtr(name); 
+        if (columnData) { 
+            columnId = columnData->Id; 
+            columnType = columnData->TypeId; 
             notNull = columnData->NotNull;
-        } else if (allowSystemColumns) {
-            auto systemColumn = GetSystemColumns().find(name);
-            YQL_ENSURE(systemColumn != GetSystemColumns().end());
-            columnId = systemColumn->second.ColumnId;
-            columnType = systemColumn->second.TypeId;
-        }
-
-        YQL_ENSURE(columnId, "Unknown column: " << name);
+        } else if (allowSystemColumns) { 
+            auto systemColumn = GetSystemColumns().find(name); 
+            YQL_ENSURE(systemColumn != GetSystemColumns().end()); 
+            columnId = systemColumn->second.ColumnId; 
+            columnType = systemColumn->second.TypeId; 
+        } 
+ 
+        YQL_ENSURE(columnId, "Unknown column: " << name); 
         pgmColumns.emplace_back(columnId, name, columnType, notNull);
-    }
-
-    return pgmColumns;
-}
-
-TVector<TKqpTableColumn> GetKqpColumns(const TKikimrTableMetadata& table, const TCoAtomList& columns,
-    bool allowSystemColumns)
-{
-    TVector<TStringBuf> columnNames(columns.Size());
-    for (ui32 i = 0; i < columnNames.size(); ++i) {
-        columnNames[i] = columns.Item(i).Value();
-    }
-
-    return GetKqpColumns(table, columnNames, allowSystemColumns);
-}
-
+    } 
+ 
+    return pgmColumns; 
+} 
+ 
+TVector<TKqpTableColumn> GetKqpColumns(const TKikimrTableMetadata& table, const TCoAtomList& columns, 
+    bool allowSystemColumns) 
+{ 
+    TVector<TStringBuf> columnNames(columns.Size()); 
+    for (ui32 i = 0; i < columnNames.size(); ++i) { 
+        columnNames[i] = columns.Item(i).Value(); 
+    } 
+ 
+    return GetKqpColumns(table, columnNames, allowSystemColumns); 
+} 
+ 
 TSmallVec<bool> GetSkipNullKeys(const TKqpReadTableSettings& settings, const TKikimrTableMetadata& tableMeta) {
     TSmallVec<bool> skipNullKeys(tableMeta.KeyColumnNames.size(), false);
 
@@ -74,112 +74,112 @@ NMiniKQL::TType* CreateColumnType(NUdf::TDataTypeId typeId, const TKqlCompileCon
     }
 }
 
-void ValidateColumnType(const TTypeAnnotationNode* type, NUdf::TDataTypeId columnTypeId) {
-    YQL_ENSURE(type);
-    bool isOptional;
-    const TDataExprType* dataType = nullptr;
-    YQL_ENSURE(IsDataOrOptionalOfData(type, isOptional, dataType));
-    auto schemeType = NUdf::GetDataTypeInfo(dataType->GetSlot()).TypeId;
-    YQL_ENSURE(schemeType == columnTypeId);
-}
-
-void ValidateColumnsType(const TStreamExprType* streamType, const TKikimrTableMetadata& tableMeta) {
-    YQL_ENSURE(streamType);
-    auto rowType = streamType->GetItemType()->Cast<TStructExprType>();
-
-    for (auto* member : rowType->GetItems()) {
-        auto columnData = tableMeta.Columns.FindPtr(member->GetName());
-        YQL_ENSURE(columnData);
-        YQL_ENSURE(columnData->TypeId);
-
-        ValidateColumnType(member->GetItemType(), columnData->TypeId);
-    }
-}
-
-void ValidateRangeBoundType(const TTupleExprType* keyTupleType, const TKikimrTableMetadata& tableMeta) {
-    YQL_ENSURE(keyTupleType);
-    YQL_ENSURE(keyTupleType->GetSize() == tableMeta.KeyColumnNames.size() + 1);
-
-    for (ui32 i = 0; i < tableMeta.KeyColumnNames.size(); ++i) {
-        auto columnData = tableMeta.Columns.FindPtr(tableMeta.KeyColumnNames[i]);
-        YQL_ENSURE(columnData);
-        YQL_ENSURE(columnData->TypeId);
-
-        ValidateColumnType(keyTupleType->GetItems()[i]->Cast<TOptionalExprType>()->GetItemType(), columnData->TypeId);
-    }
-}
-
-void ValidateRangesType(const TTypeAnnotationNode* rangesType, const TKikimrTableMetadata& tableMeta) {
-    YQL_ENSURE(rangesType);
-    if (rangesType->GetKind() == ETypeAnnotationKind::Void) {
-        return;
-    }
-
-    auto tupleType = rangesType->Cast<TTupleExprType>();
-    YQL_ENSURE(tupleType->GetSize() == 1);
-
-    auto rangeType = tupleType->GetItems()[0]->Cast<TListExprType>()->GetItemType()->Cast<TTupleExprType>();
-    YQL_ENSURE(rangeType->GetSize() == 2);
-
-    ValidateRangeBoundType(rangeType->GetItems()[0]->Cast<TTupleExprType>(), tableMeta);
-    ValidateRangeBoundType(rangeType->GetItems()[1]->Cast<TTupleExprType>(), tableMeta);
-}
-
-TKqpKeyRange MakeKeyRange(const TKqlReadTableBase& readTable, const TKqlCompileContext& ctx,
-    TMkqlBuildContext& buildCtx)
-{
-    const auto& fromTuple = readTable.Range().From();
-    const auto& toTuple = readTable.Range().To();
-
-    bool fromInclusive = readTable.Range().From().Maybe<TKqlKeyInc>().IsValid();
-    bool toInclusive = readTable.Range().To().Maybe<TKqlKeyInc>().IsValid();
-
-    const auto& tableMeta = ctx.GetTableMeta(readTable.Table());
-
-    TVector<TRuntimeNode> fromValues;
-    TVector<TRuntimeNode> toValues;
-    for (ui32 i = 0; i < tableMeta.KeyColumnNames.size(); ++i) {
-        auto keyColumn = tableMeta.KeyColumnNames[i];
-
-        auto columnData = tableMeta.Columns.FindPtr(keyColumn);
-        YQL_ENSURE(columnData);
-        YQL_ENSURE(columnData->TypeId);
-
-        auto columnType = CreateColumnType(columnData->TypeId, ctx);
-
-        if (fromTuple.ArgCount() > i) {
-            ValidateColumnType(fromTuple.Arg(i).Ref().GetTypeAnn(), columnData->TypeId);
-            fromValues.push_back(MkqlBuildExpr(fromTuple.Arg(i).Ref(), buildCtx));
-        } else if (fromInclusive) {
-            fromValues.push_back(ctx.PgmBuilder().NewEmptyOptional(
-                ctx.PgmBuilder().NewOptionalType(columnType)));
-        }
-
-        if (toTuple.ArgCount() > i) {
-            ValidateColumnType(toTuple.Arg(i).Ref().GetTypeAnn(), columnData->TypeId);
-            toValues.push_back(MkqlBuildExpr(toTuple.Arg(i).Ref(), buildCtx));
-        } else if (!toInclusive) {
-            toValues.push_back(ctx.PgmBuilder().NewEmptyOptional(
-                ctx.PgmBuilder().NewOptionalType(columnType)));
-        }
-    }
-
-    auto settings = TKqpReadTableSettings::Parse(readTable);
-
-    TKqpKeyRange keyRange;
-    keyRange.FromInclusive = fromInclusive;
-    keyRange.ToInclusive = toInclusive;
-    keyRange.FromTuple = fromValues;
-    keyRange.ToTuple = toValues;
-    keyRange.SkipNullKeys = GetSkipNullKeys(settings, tableMeta);
-    if (settings.ItemsLimit) {
-        keyRange.ItemsLimit = MkqlBuildExpr(*settings.ItemsLimit, buildCtx);
-    }
-    keyRange.Reverse = settings.Reverse;
-
-    return keyRange;
-}
-
+void ValidateColumnType(const TTypeAnnotationNode* type, NUdf::TDataTypeId columnTypeId) { 
+    YQL_ENSURE(type); 
+    bool isOptional; 
+    const TDataExprType* dataType = nullptr; 
+    YQL_ENSURE(IsDataOrOptionalOfData(type, isOptional, dataType)); 
+    auto schemeType = NUdf::GetDataTypeInfo(dataType->GetSlot()).TypeId; 
+    YQL_ENSURE(schemeType == columnTypeId); 
+} 
+ 
+void ValidateColumnsType(const TStreamExprType* streamType, const TKikimrTableMetadata& tableMeta) { 
+    YQL_ENSURE(streamType); 
+    auto rowType = streamType->GetItemType()->Cast<TStructExprType>(); 
+ 
+    for (auto* member : rowType->GetItems()) { 
+        auto columnData = tableMeta.Columns.FindPtr(member->GetName()); 
+        YQL_ENSURE(columnData); 
+        YQL_ENSURE(columnData->TypeId); 
+ 
+        ValidateColumnType(member->GetItemType(), columnData->TypeId); 
+    } 
+} 
+ 
+void ValidateRangeBoundType(const TTupleExprType* keyTupleType, const TKikimrTableMetadata& tableMeta) { 
+    YQL_ENSURE(keyTupleType); 
+    YQL_ENSURE(keyTupleType->GetSize() == tableMeta.KeyColumnNames.size() + 1); 
+ 
+    for (ui32 i = 0; i < tableMeta.KeyColumnNames.size(); ++i) { 
+        auto columnData = tableMeta.Columns.FindPtr(tableMeta.KeyColumnNames[i]); 
+        YQL_ENSURE(columnData); 
+        YQL_ENSURE(columnData->TypeId); 
+ 
+        ValidateColumnType(keyTupleType->GetItems()[i]->Cast<TOptionalExprType>()->GetItemType(), columnData->TypeId); 
+    } 
+} 
+ 
+void ValidateRangesType(const TTypeAnnotationNode* rangesType, const TKikimrTableMetadata& tableMeta) { 
+    YQL_ENSURE(rangesType); 
+    if (rangesType->GetKind() == ETypeAnnotationKind::Void) { 
+        return; 
+    } 
+ 
+    auto tupleType = rangesType->Cast<TTupleExprType>(); 
+    YQL_ENSURE(tupleType->GetSize() == 1); 
+ 
+    auto rangeType = tupleType->GetItems()[0]->Cast<TListExprType>()->GetItemType()->Cast<TTupleExprType>(); 
+    YQL_ENSURE(rangeType->GetSize() == 2); 
+ 
+    ValidateRangeBoundType(rangeType->GetItems()[0]->Cast<TTupleExprType>(), tableMeta); 
+    ValidateRangeBoundType(rangeType->GetItems()[1]->Cast<TTupleExprType>(), tableMeta); 
+} 
+ 
+TKqpKeyRange MakeKeyRange(const TKqlReadTableBase& readTable, const TKqlCompileContext& ctx, 
+    TMkqlBuildContext& buildCtx) 
+{ 
+    const auto& fromTuple = readTable.Range().From(); 
+    const auto& toTuple = readTable.Range().To(); 
+ 
+    bool fromInclusive = readTable.Range().From().Maybe<TKqlKeyInc>().IsValid(); 
+    bool toInclusive = readTable.Range().To().Maybe<TKqlKeyInc>().IsValid(); 
+ 
+    const auto& tableMeta = ctx.GetTableMeta(readTable.Table()); 
+ 
+    TVector<TRuntimeNode> fromValues; 
+    TVector<TRuntimeNode> toValues; 
+    for (ui32 i = 0; i < tableMeta.KeyColumnNames.size(); ++i) { 
+        auto keyColumn = tableMeta.KeyColumnNames[i]; 
+ 
+        auto columnData = tableMeta.Columns.FindPtr(keyColumn); 
+        YQL_ENSURE(columnData); 
+        YQL_ENSURE(columnData->TypeId); 
+ 
+        auto columnType = CreateColumnType(columnData->TypeId, ctx); 
+ 
+        if (fromTuple.ArgCount() > i) { 
+            ValidateColumnType(fromTuple.Arg(i).Ref().GetTypeAnn(), columnData->TypeId); 
+            fromValues.push_back(MkqlBuildExpr(fromTuple.Arg(i).Ref(), buildCtx)); 
+        } else if (fromInclusive) { 
+            fromValues.push_back(ctx.PgmBuilder().NewEmptyOptional( 
+                ctx.PgmBuilder().NewOptionalType(columnType))); 
+        } 
+ 
+        if (toTuple.ArgCount() > i) { 
+            ValidateColumnType(toTuple.Arg(i).Ref().GetTypeAnn(), columnData->TypeId); 
+            toValues.push_back(MkqlBuildExpr(toTuple.Arg(i).Ref(), buildCtx)); 
+        } else if (!toInclusive) { 
+            toValues.push_back(ctx.PgmBuilder().NewEmptyOptional( 
+                ctx.PgmBuilder().NewOptionalType(columnType))); 
+        } 
+    } 
+ 
+    auto settings = TKqpReadTableSettings::Parse(readTable); 
+ 
+    TKqpKeyRange keyRange; 
+    keyRange.FromInclusive = fromInclusive; 
+    keyRange.ToInclusive = toInclusive; 
+    keyRange.FromTuple = fromValues; 
+    keyRange.ToTuple = toValues; 
+    keyRange.SkipNullKeys = GetSkipNullKeys(settings, tableMeta); 
+    if (settings.ItemsLimit) { 
+        keyRange.ItemsLimit = MkqlBuildExpr(*settings.ItemsLimit, buildCtx); 
+    } 
+    keyRange.Reverse = settings.Reverse; 
+ 
+    return keyRange; 
+} 
+ 
 TKqpKeyRanges MakeComputedKeyRanges(const TKqlReadTableRangesBase& readTable, const TKqlCompileContext& ctx,
     TMkqlBuildContext& buildCtx)
 {
@@ -194,43 +194,43 @@ TKqpKeyRanges MakeComputedKeyRanges(const TKqlReadTableRangesBase& readTable, co
     return ranges;
 }
 
-} // namespace
-
-const TKikimrTableMetadata& TKqlCompileContext::GetTableMeta(const TKqpTable& table) const {
-    auto& tableData = TablesData_->ExistingTable(Cluster_, table.Path());
-    YQL_ENSURE(tableData.Metadata);
-    auto& meta = *tableData.Metadata;
-    YQL_ENSURE(meta.PathId.ToString() == table.PathId().Value());
-    YQL_ENSURE(meta.SysView == table.SysView().Value());
-    YQL_ENSURE(meta.SchemaVersion == FromString<ui64>(table.Version()));
-    return meta;
-}
-
-TIntrusivePtr<IMkqlCallableCompiler> CreateKqlCompiler(const TKqlCompileContext& ctx) {
-    auto compiler = MakeIntrusive<NCommon::TMkqlCommonCallableCompiler>();
-
+} // namespace 
+ 
+const TKikimrTableMetadata& TKqlCompileContext::GetTableMeta(const TKqpTable& table) const { 
+    auto& tableData = TablesData_->ExistingTable(Cluster_, table.Path()); 
+    YQL_ENSURE(tableData.Metadata); 
+    auto& meta = *tableData.Metadata; 
+    YQL_ENSURE(meta.PathId.ToString() == table.PathId().Value()); 
+    YQL_ENSURE(meta.SysView == table.SysView().Value()); 
+    YQL_ENSURE(meta.SchemaVersion == FromString<ui64>(table.Version())); 
+    return meta; 
+} 
+ 
+TIntrusivePtr<IMkqlCallableCompiler> CreateKqlCompiler(const TKqlCompileContext& ctx) { 
+    auto compiler = MakeIntrusive<NCommon::TMkqlCommonCallableCompiler>(); 
+ 
     compiler->AddCallable(TKqpWideReadTable::CallableName(),
         [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) {
             TKqpWideReadTable readTable(&node);
 
             const auto& tableMeta = ctx.GetTableMeta(readTable.Table());
-            auto keyRange = MakeKeyRange(readTable, ctx, buildCtx);
+            auto keyRange = MakeKeyRange(readTable, ctx, buildCtx); 
 
-            auto result = ctx.PgmBuilder().KqpWideReadTable(MakeTableId(readTable.Table()), keyRange,
-                GetKqpColumns(tableMeta, readTable.Columns(), true));
+            auto result = ctx.PgmBuilder().KqpWideReadTable(MakeTableId(readTable.Table()), keyRange, 
+                GetKqpColumns(tableMeta, readTable.Columns(), true)); 
 
-            return result;
-        });
+            return result; 
+        }); 
 
     compiler->AddCallable(TKqpWideReadTableRanges::CallableName(),
-        [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) {
+        [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) { 
             TKqpWideReadTableRanges readTableRanges(&node);
 
             const auto& tableMeta = ctx.GetTableMeta(readTableRanges.Table());
-            ValidateRangesType(readTableRanges.Ranges().Ref().GetTypeAnn(), tableMeta);
-
-            TKqpKeyRanges ranges = MakeComputedKeyRanges(readTableRanges, ctx, buildCtx);
+            ValidateRangesType(readTableRanges.Ranges().Ref().GetTypeAnn(), tableMeta); 
 
+            TKqpKeyRanges ranges = MakeComputedKeyRanges(readTableRanges, ctx, buildCtx); 
+ 
             return ctx.PgmBuilder().KqpWideReadTableRanges(
                 MakeTableId(readTableRanges.Table()),
                 ranges,
@@ -243,22 +243,22 @@ TIntrusivePtr<IMkqlCallableCompiler> CreateKqlCompiler(const TKqlCompileContext&
         [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) {
             TKqpWideReadOlapTableRanges readTable(&node);
 
-            const auto& tableMeta = ctx.GetTableMeta(readTable.Table());
-            ValidateRangesType(readTable.Ranges().Ref().GetTypeAnn(), tableMeta);
-
+            const auto& tableMeta = ctx.GetTableMeta(readTable.Table()); 
+            ValidateRangesType(readTable.Ranges().Ref().GetTypeAnn(), tableMeta); 
+ 
             TKqpKeyRanges ranges = MakeComputedKeyRanges(readTable, ctx, buildCtx);
 
             // Return type depends on the process program, so it is built explicitly.
-            TStringStream errorStream;
-            auto returnType = NCommon::BuildType(*readTable.Ref().GetTypeAnn(), ctx.PgmBuilder(), errorStream);
-            YQL_ENSURE(returnType, "Failed to build type: " << errorStream.Str());
-
-            // Process program for OLAP read is not present in MKQL, it is passed in range description
-            // in physical plan directly to executer. Read callables in MKQL only used to associate
-            // input stream of the graph with the external scans, so it doesn't make much sense to pass
-            // the process program through callable.
+            TStringStream errorStream; 
+            auto returnType = NCommon::BuildType(*readTable.Ref().GetTypeAnn(), ctx.PgmBuilder(), errorStream); 
+            YQL_ENSURE(returnType, "Failed to build type: " << errorStream.Str()); 
+
+            // Process program for OLAP read is not present in MKQL, it is passed in range description 
+            // in physical plan directly to executer. Read callables in MKQL only used to associate 
+            // input stream of the graph with the external scans, so it doesn't make much sense to pass 
+            // the process program through callable. 
             // We anyway move to explicit sources as external nodes in KQP program, so all the information
-            // about read settings will be passed in a side channel, not the program.
+            // about read settings will be passed in a side channel, not the program. 
             auto result = ctx.PgmBuilder().KqpWideReadTableRanges(
                 MakeTableId(readTable.Table()),
                 ranges,
@@ -269,84 +269,84 @@ TIntrusivePtr<IMkqlCallableCompiler> CreateKqlCompiler(const TKqlCompileContext&
             return result;
         });
 
-    compiler->AddCallable(TKqpLookupTable::CallableName(),
+    compiler->AddCallable(TKqpLookupTable::CallableName(), 
+        [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) { 
+            TKqpLookupTable lookupTable(&node); 
+            const auto& tableMeta = ctx.GetTableMeta(lookupTable.Table()); 
+            auto lookupKeys = MkqlBuildExpr(lookupTable.LookupKeys().Ref(), buildCtx); 
+ 
+            auto keysType = lookupTable.LookupKeys().Ref().GetTypeAnn()->Cast<TStreamExprType>(); 
+            ValidateColumnsType(keysType, tableMeta); 
+ 
+            TVector<TStringBuf> keyColumns(tableMeta.KeyColumnNames.begin(), tableMeta.KeyColumnNames.end()); 
+            auto result = ctx.PgmBuilder().KqpLookupTable(MakeTableId(lookupTable.Table()), lookupKeys, 
+                GetKqpColumns(tableMeta, keyColumns, false), 
+                GetKqpColumns(tableMeta, lookupTable.Columns(), true)); 
+ 
+            return result; 
+        }); 
+ 
+    compiler->AddCallable(TKqpUpsertRows::CallableName(), 
         [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) {
-            TKqpLookupTable lookupTable(&node);
-            const auto& tableMeta = ctx.GetTableMeta(lookupTable.Table());
-            auto lookupKeys = MkqlBuildExpr(lookupTable.LookupKeys().Ref(), buildCtx);
-
-            auto keysType = lookupTable.LookupKeys().Ref().GetTypeAnn()->Cast<TStreamExprType>();
-            ValidateColumnsType(keysType, tableMeta);
-
-            TVector<TStringBuf> keyColumns(tableMeta.KeyColumnNames.begin(), tableMeta.KeyColumnNames.end());
-            auto result = ctx.PgmBuilder().KqpLookupTable(MakeTableId(lookupTable.Table()), lookupKeys,
-                GetKqpColumns(tableMeta, keyColumns, false),
-                GetKqpColumns(tableMeta, lookupTable.Columns(), true));
-
-            return result;
-        });
-
-    compiler->AddCallable(TKqpUpsertRows::CallableName(),
-        [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) {
-            TKqpUpsertRows upsertRows(&node);
-
-            const auto& tableMeta = ctx.GetTableMeta(upsertRows.Table());
-
-            auto rows = MkqlBuildExpr(upsertRows.Input().Ref(), buildCtx);
-
-            auto rowsType = upsertRows.Input().Ref().GetTypeAnn()->Cast<TStreamExprType>();
-            ValidateColumnsType(rowsType, tableMeta);
-
-            auto rowType = rowsType->GetItemType()->Cast<TStructExprType>();
-            YQL_ENSURE(rowType->GetItems().size() == upsertRows.Columns().Size());
-
-            THashSet<TStringBuf> keySet(tableMeta.KeyColumnNames.begin(), tableMeta.KeyColumnNames.end());
-            THashSet<TStringBuf> upsertSet;
-            for (const auto& column : upsertRows.Columns()) {
+            TKqpUpsertRows upsertRows(&node); 
+ 
+            const auto& tableMeta = ctx.GetTableMeta(upsertRows.Table()); 
+ 
+            auto rows = MkqlBuildExpr(upsertRows.Input().Ref(), buildCtx); 
+ 
+            auto rowsType = upsertRows.Input().Ref().GetTypeAnn()->Cast<TStreamExprType>(); 
+            ValidateColumnsType(rowsType, tableMeta); 
+ 
+            auto rowType = rowsType->GetItemType()->Cast<TStructExprType>(); 
+            YQL_ENSURE(rowType->GetItems().size() == upsertRows.Columns().Size()); 
+ 
+            THashSet<TStringBuf> keySet(tableMeta.KeyColumnNames.begin(), tableMeta.KeyColumnNames.end()); 
+            THashSet<TStringBuf> upsertSet; 
+            for (const auto& column : upsertRows.Columns()) { 
                 if (keySet.contains(column)) {
-                    keySet.erase(column);
-                } else {
-                    upsertSet.insert(column);
-                }
-            }
-
-            YQL_ENSURE(keySet.empty());
+                    keySet.erase(column); 
+                } else { 
+                    upsertSet.insert(column); 
+                } 
+            } 
+ 
+            YQL_ENSURE(keySet.empty()); 
             YQL_ENSURE(tableMeta.KeyColumnNames.size() + upsertSet.size() == upsertRows.Columns().Size());
-            TVector<TStringBuf> upsertColumns(upsertSet.begin(), upsertSet.end());
-
-            auto result = ctx.PgmBuilder().KqpUpsertRows(MakeTableId(upsertRows.Table()), rows,
-                GetKqpColumns(tableMeta, upsertColumns, false));
-
+            TVector<TStringBuf> upsertColumns(upsertSet.begin(), upsertSet.end()); 
+ 
+            auto result = ctx.PgmBuilder().KqpUpsertRows(MakeTableId(upsertRows.Table()), rows, 
+                GetKqpColumns(tableMeta, upsertColumns, false)); 
+ 
             return result;
-        });
-
+        }); 
+ 
     compiler->AddCallable(TKqpDeleteRows::CallableName(),
         [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) {
             TKqpDeleteRows deleteRows(&node);
 
-            const auto& tableMeta = ctx.GetTableMeta(deleteRows.Table());
-
-            auto rowsType = deleteRows.Input().Ref().GetTypeAnn()->Cast<TStreamExprType>();
-            ValidateColumnsType(rowsType, tableMeta);
-
+            const auto& tableMeta = ctx.GetTableMeta(deleteRows.Table()); 
+ 
+            auto rowsType = deleteRows.Input().Ref().GetTypeAnn()->Cast<TStreamExprType>(); 
+            ValidateColumnsType(rowsType, tableMeta); 
+ 
             const auto tableId = MakeTableId(deleteRows.Table());
             const auto rows = MkqlBuildExpr(deleteRows.Input().Ref(), buildCtx);
 
             return ctx.PgmBuilder().KqpDeleteRows(tableId, rows);
         });
 
-    compiler->AddCallable(TKqpEffects::CallableName(),
-        [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) {
-            std::vector<TRuntimeNode> args;
-            args.reserve(node.ChildrenSize());
-            node.ForEachChild([&](const TExprNode& child){
-                args.emplace_back(MkqlBuildExpr(child, buildCtx));
-            });
-
-            auto result = ctx.PgmBuilder().KqpEffects(args);
-            return result;
-        });
-
+    compiler->AddCallable(TKqpEffects::CallableName(), 
+        [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) { 
+            std::vector<TRuntimeNode> args; 
+            args.reserve(node.ChildrenSize()); 
+            node.ForEachChild([&](const TExprNode& child){ 
+                args.emplace_back(MkqlBuildExpr(child, buildCtx)); 
+            }); 
+ 
+            auto result = ctx.PgmBuilder().KqpEffects(args); 
+            return result; 
+        }); 
+ 
     compiler->AddCallable(TKqpEnsure::CallableName(),
         [&ctx](const TExprNode& node, TMkqlBuildContext& buildCtx) {
             TKqpEnsure ensure(&node);
@@ -359,8 +359,8 @@ TIntrusivePtr<IMkqlCallableCompiler> CreateKqlCompiler(const TKqlCompileContext&
             return ctx.PgmBuilder().KqpEnsure(value, predicate, issueCode, message);
         });
 
-    return compiler;
-}
-
+    return compiler; 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/compile/kqp_mkql_compiler.h b/ydb/core/kqp/compile/kqp_mkql_compiler.h
index 9d89a0188d..07807559e3 100644
--- a/ydb/core/kqp/compile/kqp_mkql_compiler.h
+++ b/ydb/core/kqp/compile/kqp_mkql_compiler.h
@@ -1,37 +1,37 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/common/kqp_resolve.h>
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.h>
 #include <ydb/core/kqp/runtime/kqp_program_builder.h>
-
+ 
 #include <ydb/library/yql/providers/common/mkql/yql_provider_mkql.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider.h>
-
-#include <util/generic/ptr.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-class TKqlCompileContext {
-public:
-    TKqlCompileContext(const TString& cluster,
-        const TIntrusivePtr<NYql::TKikimrTablesData>& tablesData,
-        const NMiniKQL::TTypeEnvironment& typeEnv,
-        const NMiniKQL::IFunctionRegistry& funcRegistry)
-        : Cluster_(cluster)
-        , TablesData_(tablesData)
-        , PgmBuilder_(MakeHolder<NMiniKQL::TKqpProgramBuilder>(typeEnv, funcRegistry)) {}
-
-    NMiniKQL::TKqpProgramBuilder& PgmBuilder() const { return *PgmBuilder_; }
-    const NYql::TKikimrTableMetadata& GetTableMeta(const NYql::NNodes::TKqpTable& table) const;
-
-private:
-    TString Cluster_;
-    TIntrusivePtr<NYql::TKikimrTablesData> TablesData_;
-    THolder<NMiniKQL::TKqpProgramBuilder> PgmBuilder_;
-};
-
-TIntrusivePtr<NYql::NCommon::IMkqlCallableCompiler> CreateKqlCompiler(const TKqlCompileContext& ctx);
-
+ 
+#include <util/generic/ptr.h> 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+class TKqlCompileContext { 
+public: 
+    TKqlCompileContext(const TString& cluster, 
+        const TIntrusivePtr<NYql::TKikimrTablesData>& tablesData, 
+        const NMiniKQL::TTypeEnvironment& typeEnv, 
+        const NMiniKQL::IFunctionRegistry& funcRegistry) 
+        : Cluster_(cluster) 
+        , TablesData_(tablesData) 
+        , PgmBuilder_(MakeHolder<NMiniKQL::TKqpProgramBuilder>(typeEnv, funcRegistry)) {} 
+ 
+    NMiniKQL::TKqpProgramBuilder& PgmBuilder() const { return *PgmBuilder_; } 
+    const NYql::TKikimrTableMetadata& GetTableMeta(const NYql::NNodes::TKqpTable& table) const; 
+ 
+private: 
+    TString Cluster_; 
+    TIntrusivePtr<NYql::TKikimrTablesData> TablesData_; 
+    THolder<NMiniKQL::TKqpProgramBuilder> PgmBuilder_; 
+}; 
+ 
+TIntrusivePtr<NYql::NCommon::IMkqlCallableCompiler> CreateKqlCompiler(const TKqlCompileContext& ctx); 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/compile/kqp_olap_compiler.cpp b/ydb/core/kqp/compile/kqp_olap_compiler.cpp
index 8f16b9345c..7024941e82 100644
--- a/ydb/core/kqp/compile/kqp_olap_compiler.cpp
+++ b/ydb/core/kqp/compile/kqp_olap_compiler.cpp
@@ -1,49 +1,49 @@
-#include "kqp_olap_compiler.h"
-
+#include "kqp_olap_compiler.h" 
+ 
 #include <ydb/core/formats/arrow_helpers.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
 using namespace NKikimrSSA;
-
+ 
 constexpr ui32 OLAP_PROGRAM_VERSION = 1;
 
-namespace {
-
-class TKqpOlapCompileContext {
-public:
+namespace { 
+ 
+class TKqpOlapCompileContext { 
+public: 
     TKqpOlapCompileContext(const TCoArgument& row, const TKikimrTableMetadata& tableMeta,
         NKqpProto::TKqpPhyOpReadOlapRanges& readProto)
-        : Row(row)
-        , MaxColumnId(0)
+        : Row(row) 
+        , MaxColumnId(0) 
         , ReadProto(readProto)
-    {
-        for (const auto& [_, columnMeta] : tableMeta.Columns) {
-            YQL_ENSURE(ReadColumns.emplace(columnMeta.Name, columnMeta.Id).second);
-            MaxColumnId = std::max(MaxColumnId, columnMeta.Id);
-        }
+    { 
+        for (const auto& [_, columnMeta] : tableMeta.Columns) { 
+            YQL_ENSURE(ReadColumns.emplace(columnMeta.Name, columnMeta.Id).second); 
+            MaxColumnId = std::max(MaxColumnId, columnMeta.Id); 
+        } 
 
         Program.SetVersion(OLAP_PROGRAM_VERSION);
-    }
-
-    ui32 GetColumnId(const TStringBuf& name) const {
-        auto column = ReadColumns.FindPtr(name);
-        YQL_ENSURE(column);
-
-        return *column;
-    }
-
-    ui32 NewColumnId() {
-        return ++MaxColumnId;
-    }
-
-    const TExprNode* GetRowExpr() const {
-        return Row.Raw();
-    }
-
+    } 
+ 
+    ui32 GetColumnId(const TStringBuf& name) const { 
+        auto column = ReadColumns.FindPtr(name); 
+        YQL_ENSURE(column); 
+ 
+        return *column; 
+    } 
+ 
+    ui32 NewColumnId() { 
+        return ++MaxColumnId; 
+    } 
+ 
+    const TExprNode* GetRowExpr() const { 
+        return Row.Raw(); 
+    } 
+ 
     TProgram::TAssignment* CreateAssignCmd() {
         auto* cmd = Program.AddCommand();
         auto* assign = cmd->MutableAssign();
@@ -67,17 +67,17 @@ public:
         ReadProto.SetOlapProgram(programBytes);
     }
 
-private:
-    TCoArgument Row;
-    TMap<TString, ui32> ReadColumns;
-    ui32 MaxColumnId;
+private: 
+    TCoArgument Row; 
+    TMap<TString, ui32> ReadColumns; 
+    ui32 MaxColumnId; 
     TProgram Program;
     NKqpProto::TKqpPhyOpReadOlapRanges& ReadProto;
-};
-
+}; 
+ 
 
 TProgram::TAssignment* CompileCondition(const TExprBase& condition, TKqpOlapCompileContext& ctx);
-
+ 
 ui32 ConvertValueToColumn(const TCoDataCtor& value, TKqpOlapCompileContext& ctx)
 {
     TProgram::TAssignment* ssaValue = ctx.CreateAssignCmd();
@@ -162,12 +162,12 @@ ui64 GetOrCreateColumnId(const TExprBase& node, TKqpOlapCompileContext& ctx) {
 }
 
 TProgram::TAssignment* CompileComparison(const TKqpOlapFilterCompare& comparison,
-    TKqpOlapCompileContext& ctx)
-{
+    TKqpOlapCompileContext& ctx) 
+{ 
     // Columns should be created before comparison, otherwise comparison fail to find columns
     ui32 leftColumnId = GetOrCreateColumnId(comparison.Left(), ctx);
     ui32 rightColumnId = GetOrCreateColumnId(comparison.Right(), ctx);
-
+ 
     TProgram::TAssignment* command = ctx.CreateAssignCmd();
     auto* cmpFunc = command->MutableFunction();
 
@@ -188,10 +188,10 @@ TProgram::TAssignment* CompileComparison(const TKqpOlapFilterCompare& comparison
     cmpFunc->SetId(function);
     cmpFunc->AddArguments()->SetId(leftColumnId);
     cmpFunc->AddArguments()->SetId(rightColumnId);
-
+ 
     return command;
-}
-
+} 
+ 
 TProgram::TAssignment* CompileExists(const TKqpOlapFilterExists& exists,
     TKqpOlapCompileContext& ctx)
 {
@@ -213,8 +213,8 @@ TProgram::TAssignment* CompileExists(const TKqpOlapFilterExists& exists,
 }
 
 TProgram::TAssignment* BuildLogicalProgram(const TExprNode::TChildrenType& args, ui32 function,
-    TKqpOlapCompileContext& ctx)
-{
+    TKqpOlapCompileContext& ctx) 
+{ 
     ui32 childrenCount = args.size();
 
     if (childrenCount == 1) {
@@ -298,32 +298,32 @@ void CompileFilter(const TKqpOlapFilter& filterNode, TKqpOlapCompileContext& ctx
 }
 
 void CompileOlapProgramImpl(TExprBase operation, TKqpOlapCompileContext& ctx) {
-    if (operation.Raw() == ctx.GetRowExpr()) {
-        return;
-    }
-
+    if (operation.Raw() == ctx.GetRowExpr()) { 
+        return; 
+    } 
+ 
     if (auto maybeFilter = operation.Maybe<TKqpOlapFilter>()) {
         CompileOlapProgramImpl(maybeFilter.Cast().Input(), ctx);
         CompileFilter(maybeFilter.Cast(), ctx);
-        return;
-    }
-
-    YQL_ENSURE(operation.Maybe<TCallable>(), "Unexpected OLAP operation node type: " << operation.Ref().Type());
-    YQL_ENSURE(false, "Unexpected OLAP operation: " << operation.Cast<TCallable>().CallableName());
-}
-
-} // namespace
-
+        return; 
+    } 
+ 
+    YQL_ENSURE(operation.Maybe<TCallable>(), "Unexpected OLAP operation node type: " << operation.Ref().Type()); 
+    YQL_ENSURE(false, "Unexpected OLAP operation: " << operation.Cast<TCallable>().CallableName()); 
+} 
+ 
+} // namespace 
+ 
 void CompileOlapProgram(const TCoLambda& lambda, const TKikimrTableMetadata& tableMeta,
     NKqpProto::TKqpPhyOpReadOlapRanges& readProto)
 {
-    YQL_ENSURE(lambda.Args().Size() == 1);
-
+    YQL_ENSURE(lambda.Args().Size() == 1); 
+ 
     TKqpOlapCompileContext ctx(lambda.Args().Arg(0), tableMeta, readProto);
-
+ 
     CompileOlapProgramImpl(lambda.Body(), ctx);
     ctx.SerializeToProto();
-}
-
-} // namespace NKqp
-} // namespace NKikimr
+} 
+ 
+} // namespace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/compile/kqp_olap_compiler.h b/ydb/core/kqp/compile/kqp_olap_compiler.h
index 17ca3d0b3c..12758d03f9 100644
--- a/ydb/core/kqp/compile/kqp_olap_compiler.h
+++ b/ydb/core/kqp/compile/kqp_olap_compiler.h
@@ -1,15 +1,15 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.h>
 #include <ydb/core/protos/ssa.pb.h>
-
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_gateway.h>
-
-namespace NKikimr {
-namespace NKqp {
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
 void CompileOlapProgram(const NYql::NNodes::TCoLambda& lambda, const NYql::TKikimrTableMetadata& tableMeta,
     NKqpProto::TKqpPhyOpReadOlapRanges& readProto);
-
-} // namespace NKqp
-} // namespace NKikimr
+ 
+} // namespace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/compile/ya.make b/ydb/core/kqp/compile/ya.make
index a49bd82674..524770458a 100644
--- a/ydb/core/kqp/compile/ya.make
+++ b/ydb/core/kqp/compile/ya.make
@@ -1,23 +1,23 @@
-LIBRARY()
-
-OWNER(
-    spuchin
-    g:kikimr
-)
-
-SRCS(
-    kqp_compile.cpp
-    kqp_mkql_compiler.cpp
-    kqp_olap_compiler.cpp
-)
-
-PEERDIR(
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
+    g:kikimr 
+) 
+ 
+SRCS( 
+    kqp_compile.cpp 
+    kqp_mkql_compiler.cpp 
+    kqp_olap_compiler.cpp 
+) 
+ 
+PEERDIR( 
     ydb/core/formats
     ydb/core/kqp/common
     ydb/core/protos
     ydb/library/mkql_proto
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-END()
+END() 
diff --git a/ydb/core/kqp/compute_actor/kqp_scan_compute_actor.cpp b/ydb/core/kqp/compute_actor/kqp_scan_compute_actor.cpp
index f8e3cd0c77..4cf5e73da3 100644
--- a/ydb/core/kqp/compute_actor/kqp_scan_compute_actor.cpp
+++ b/ydb/core/kqp/compute_actor/kqp_scan_compute_actor.cpp
@@ -838,7 +838,7 @@ private:
 
         ev->Record.SetReverse(Meta.GetReverse());
         ev->Record.SetItemsLimit(Meta.GetItemsLimit());
-
+ 
         if (Meta.HasOlapProgram()) {
             TString programBytes;
             TStringOutput stream(programBytes);
diff --git a/ydb/core/kqp/counters/kqp_counters.cpp b/ydb/core/kqp/counters/kqp_counters.cpp
index 26a28a0249..8ba11d76f3 100644
--- a/ydb/core/kqp/counters/kqp_counters.cpp
+++ b/ydb/core/kqp/counters/kqp_counters.cpp
@@ -1,5 +1,5 @@
-#include "kqp_counters.h"
-
+#include "kqp_counters.h" 
+ 
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/base/counters.h>
 #include <ydb/core/protos/issue_id.pb.h>
@@ -9,22 +9,22 @@
 #include <library/cpp/actors/core/log.h>
 
 #include <util/generic/size_literals.h>
-
+ 
 #include <ydb/library/yql/core/issue/protos/issue_id.pb.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-
-
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+ 
+ 
 NMonitoring::TDynamicCounterPtr TKqpCountersBase::GetQueryReplayCounters() const {
     return QueryReplayGroup;
 }
 
 void TKqpCountersBase::CreateYdbTxKindCounters(TKqpTransactionInfo::EKind kind, const TString& name) {
     auto txKindGroup = YdbGroup->GetSubgroup("tx_kind", name);
-
+ 
     auto& ydbTxCounters = YdbTxByKind[kind];
     ydbTxCounters.TotalDuration = txKindGroup->GetNamedHistogram("name",
         "table.transaction.total_duration_milliseconds", NMonitoring::ExponentialHistogram(20, 2, 1));
@@ -32,8 +32,8 @@ void TKqpCountersBase::CreateYdbTxKindCounters(TKqpTransactionInfo::EKind kind,
         "table.transaction.server_duration_milliseconds", NMonitoring::ExponentialHistogram(20, 2, 1));
     ydbTxCounters.ClientDuration = txKindGroup->GetNamedHistogram("name",
         "table.transaction.client_duration_milliseconds", NMonitoring::ExponentialHistogram(20, 2, 1));
-}
-
+} 
+ 
 void TKqpCountersBase::UpdateYdbTxCounters(const TKqpTransactionInfo& txInfo,
     THashMap<TKqpTransactionInfo::EKind, TYdbTxByKindCounters>& txCounters)
 {
@@ -49,41 +49,41 @@ void TKqpCountersBase::UpdateYdbTxCounters(const TKqpTransactionInfo& txInfo,
 }
 
 void TKqpCountersBase::Init() {
-    /* Requests */
-    QueryActionRequests[NKikimrKqp::QUERY_ACTION_EXECUTE] =
-        KqpGroup->GetCounter("Requests/QueryExecute", true);
-    QueryActionRequests[NKikimrKqp::QUERY_ACTION_EXPLAIN] =
-        KqpGroup->GetCounter("Requests/QueryExplain", true);
-    QueryActionRequests[NKikimrKqp::QUERY_ACTION_VALIDATE] =
-        KqpGroup->GetCounter("Requests/QueryValidate", true);
-    QueryActionRequests[NKikimrKqp::QUERY_ACTION_PREPARE] =
-        KqpGroup->GetCounter("Requests/QueryPrepare", true);
-    QueryActionRequests[NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED] =
-        KqpGroup->GetCounter("Requests/QueryExecPrepared", true);
-    QueryActionRequests[NKikimrKqp::QUERY_ACTION_BEGIN_TX] =
-        KqpGroup->GetCounter("Requests/QueryBeginTx", true);
-    QueryActionRequests[NKikimrKqp::QUERY_ACTION_COMMIT_TX] =
-        KqpGroup->GetCounter("Requests/QueryCommitTx", true);
-    QueryActionRequests[NKikimrKqp::QUERY_ACTION_ROLLBACK_TX] =
-        KqpGroup->GetCounter("Requests/QueryRollbackTx", true);
+    /* Requests */ 
+    QueryActionRequests[NKikimrKqp::QUERY_ACTION_EXECUTE] = 
+        KqpGroup->GetCounter("Requests/QueryExecute", true); 
+    QueryActionRequests[NKikimrKqp::QUERY_ACTION_EXPLAIN] = 
+        KqpGroup->GetCounter("Requests/QueryExplain", true); 
+    QueryActionRequests[NKikimrKqp::QUERY_ACTION_VALIDATE] = 
+        KqpGroup->GetCounter("Requests/QueryValidate", true); 
+    QueryActionRequests[NKikimrKqp::QUERY_ACTION_PREPARE] = 
+        KqpGroup->GetCounter("Requests/QueryPrepare", true); 
+    QueryActionRequests[NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED] = 
+        KqpGroup->GetCounter("Requests/QueryExecPrepared", true); 
+    QueryActionRequests[NKikimrKqp::QUERY_ACTION_BEGIN_TX] = 
+        KqpGroup->GetCounter("Requests/QueryBeginTx", true); 
+    QueryActionRequests[NKikimrKqp::QUERY_ACTION_COMMIT_TX] = 
+        KqpGroup->GetCounter("Requests/QueryCommitTx", true); 
+    QueryActionRequests[NKikimrKqp::QUERY_ACTION_ROLLBACK_TX] = 
+        KqpGroup->GetCounter("Requests/QueryRollbackTx", true); 
     QueryActionRequests[NKikimrKqp::QUERY_ACTION_PARSE] =
         KqpGroup->GetCounter("Requests/QueryParse", true);
-    OtherQueryRequests = KqpGroup->GetCounter("Requests/QueryOther", true);
-
-    CloseSessionRequests = KqpGroup->GetCounter("Requests/CloseSession", true);
-    CreateSessionRequests = KqpGroup->GetCounter("Requests/CreateSession", true);
-    PingSessionRequests = KqpGroup->GetCounter("Requests/PingSession", true);
-
-    RequestBytes = KqpGroup->GetCounter("Requests/Bytes", true);
+    OtherQueryRequests = KqpGroup->GetCounter("Requests/QueryOther", true); 
+ 
+    CloseSessionRequests = KqpGroup->GetCounter("Requests/CloseSession", true); 
+    CreateSessionRequests = KqpGroup->GetCounter("Requests/CreateSession", true); 
+    PingSessionRequests = KqpGroup->GetCounter("Requests/PingSession", true); 
+ 
+    RequestBytes = KqpGroup->GetCounter("Requests/Bytes", true); 
     YdbRequestBytes = YdbGroup->GetNamedCounter("name", "table.query.request.bytes", true);
-    QueryBytes = KqpGroup->GetCounter("Requests/QueryBytes", true);
-    ParametersBytes = KqpGroup->GetCounter("Requests/ParametersBytes", true);
+    QueryBytes = KqpGroup->GetCounter("Requests/QueryBytes", true); 
+    ParametersBytes = KqpGroup->GetCounter("Requests/ParametersBytes", true); 
     YdbParametersBytes = YdbGroup->GetNamedCounter("name", "table.query.request.parameters_bytes", true);
-
-    SqlV0Translations = KqpGroup->GetCounter("Requests/Sql/V0", true);
-    SqlV1Translations = KqpGroup->GetCounter("Requests/Sql/V1", true);
-    SqlUnknownTranslations = KqpGroup->GetCounter("Requests/Sql/Unknown", true);
-
+ 
+    SqlV0Translations = KqpGroup->GetCounter("Requests/Sql/V0", true); 
+    SqlV1Translations = KqpGroup->GetCounter("Requests/Sql/V1", true); 
+    SqlUnknownTranslations = KqpGroup->GetCounter("Requests/Sql/Unknown", true); 
+ 
     QueryTypes[NKikimrKqp::EQueryType::QUERY_TYPE_UNDEFINED] =
         KqpGroup->GetCounter("Request/QueryTypeUndefined", true);
     QueryTypes[NKikimrKqp::EQueryType::QUERY_TYPE_SQL_DML] =
@@ -120,7 +120,7 @@ void TKqpCountersBase::Init() {
     QueryMaxShardProgramSize = KqpGroup->GetHistogram("Query/MaxShardProgramSize",
         NMonitoring::ExplicitHistogram({1_MB, 9_MB, 29_MB}));
 
-    /* Request latency */
+    /* Request latency */ 
     QueryLatencies[NKikimrKqp::QUERY_ACTION_EXECUTE] = KqpGroup->GetHistogram(
         "Query/ExecuteLatencyMs", NMonitoring::ExponentialHistogram(20, 2, 1));
     QueryLatencies[NKikimrKqp::QUERY_ACTION_EXPLAIN] = KqpGroup->GetHistogram(
@@ -145,61 +145,61 @@ void TKqpCountersBase::Init() {
     YdbResponsesLocksInvalidated = YdbGroup->GetSubgroup("issue_type", "optimistic_locks_invalidation")
         ->GetNamedCounter("name", "api.grpc.response.issues", true);
 
-    /* Response statuses */
-    YdbResponses[Ydb::StatusIds::STATUS_CODE_UNSPECIFIED] = KqpGroup->GetCounter("YdbResponses/Unspecified", true);
-    YdbResponses[Ydb::StatusIds::SUCCESS] = KqpGroup->GetCounter("YdbResponses/Success", true);
-    YdbResponses[Ydb::StatusIds::BAD_REQUEST] = KqpGroup->GetCounter("YdbResponses/BadRequest", true);
-    YdbResponses[Ydb::StatusIds::UNAUTHORIZED] = KqpGroup->GetCounter("YdbResponses/Unauthorized", true);
-    YdbResponses[Ydb::StatusIds::INTERNAL_ERROR] = KqpGroup->GetCounter("YdbResponses/InternalError", true);
-    YdbResponses[Ydb::StatusIds::ABORTED] = KqpGroup->GetCounter("YdbResponses/Aborted", true);
-    YdbResponses[Ydb::StatusIds::UNAVAILABLE] = KqpGroup->GetCounter("YdbResponses/Unavailable", true);
-    YdbResponses[Ydb::StatusIds::OVERLOADED] = KqpGroup->GetCounter("YdbResponses/Overloaded", true);
-    YdbResponses[Ydb::StatusIds::SCHEME_ERROR] = KqpGroup->GetCounter("YdbResponses/SchemeError", true);
-    YdbResponses[Ydb::StatusIds::GENERIC_ERROR] = KqpGroup->GetCounter("YdbResponses/GenericError", true);
-    YdbResponses[Ydb::StatusIds::TIMEOUT] = KqpGroup->GetCounter("YdbResponses/Timeout", true);
-    YdbResponses[Ydb::StatusIds::BAD_SESSION] = KqpGroup->GetCounter("YdbResponses/BadSession", true);
-    YdbResponses[Ydb::StatusIds::PRECONDITION_FAILED] = KqpGroup->GetCounter("YdbResponses/PreconditionFailed", true);
-    YdbResponses[Ydb::StatusIds::ALREADY_EXISTS] = KqpGroup->GetCounter("YdbResponses/AlreadyExists", true);
-    YdbResponses[Ydb::StatusIds::NOT_FOUND] = KqpGroup->GetCounter("YdbResponses/NotFound", true);
-    YdbResponses[Ydb::StatusIds::SESSION_EXPIRED] = KqpGroup->GetCounter("YdbResponses/SessionExpired", true);
-    YdbResponses[Ydb::StatusIds::CANCELLED] = KqpGroup->GetCounter("YdbResponses/Cancelled", true);
-    YdbResponses[Ydb::StatusIds::UNDETERMINED] = KqpGroup->GetCounter("YdbResponses/Undetermined", true);
-    YdbResponses[Ydb::StatusIds::UNSUPPORTED] = KqpGroup->GetCounter("YdbResponses/Unsupported", true);
-    YdbResponses[Ydb::StatusIds::SESSION_BUSY] = KqpGroup->GetCounter("YdbResponses/SessionBusy", true);
-    OtherYdbResponses = KqpGroup->GetCounter("YdbResponses/Other", true);
-
-    ResponseBytes = KqpGroup->GetCounter("Responses/Bytes", true);
+    /* Response statuses */ 
+    YdbResponses[Ydb::StatusIds::STATUS_CODE_UNSPECIFIED] = KqpGroup->GetCounter("YdbResponses/Unspecified", true); 
+    YdbResponses[Ydb::StatusIds::SUCCESS] = KqpGroup->GetCounter("YdbResponses/Success", true); 
+    YdbResponses[Ydb::StatusIds::BAD_REQUEST] = KqpGroup->GetCounter("YdbResponses/BadRequest", true); 
+    YdbResponses[Ydb::StatusIds::UNAUTHORIZED] = KqpGroup->GetCounter("YdbResponses/Unauthorized", true); 
+    YdbResponses[Ydb::StatusIds::INTERNAL_ERROR] = KqpGroup->GetCounter("YdbResponses/InternalError", true); 
+    YdbResponses[Ydb::StatusIds::ABORTED] = KqpGroup->GetCounter("YdbResponses/Aborted", true); 
+    YdbResponses[Ydb::StatusIds::UNAVAILABLE] = KqpGroup->GetCounter("YdbResponses/Unavailable", true); 
+    YdbResponses[Ydb::StatusIds::OVERLOADED] = KqpGroup->GetCounter("YdbResponses/Overloaded", true); 
+    YdbResponses[Ydb::StatusIds::SCHEME_ERROR] = KqpGroup->GetCounter("YdbResponses/SchemeError", true); 
+    YdbResponses[Ydb::StatusIds::GENERIC_ERROR] = KqpGroup->GetCounter("YdbResponses/GenericError", true); 
+    YdbResponses[Ydb::StatusIds::TIMEOUT] = KqpGroup->GetCounter("YdbResponses/Timeout", true); 
+    YdbResponses[Ydb::StatusIds::BAD_SESSION] = KqpGroup->GetCounter("YdbResponses/BadSession", true); 
+    YdbResponses[Ydb::StatusIds::PRECONDITION_FAILED] = KqpGroup->GetCounter("YdbResponses/PreconditionFailed", true); 
+    YdbResponses[Ydb::StatusIds::ALREADY_EXISTS] = KqpGroup->GetCounter("YdbResponses/AlreadyExists", true); 
+    YdbResponses[Ydb::StatusIds::NOT_FOUND] = KqpGroup->GetCounter("YdbResponses/NotFound", true); 
+    YdbResponses[Ydb::StatusIds::SESSION_EXPIRED] = KqpGroup->GetCounter("YdbResponses/SessionExpired", true); 
+    YdbResponses[Ydb::StatusIds::CANCELLED] = KqpGroup->GetCounter("YdbResponses/Cancelled", true); 
+    YdbResponses[Ydb::StatusIds::UNDETERMINED] = KqpGroup->GetCounter("YdbResponses/Undetermined", true); 
+    YdbResponses[Ydb::StatusIds::UNSUPPORTED] = KqpGroup->GetCounter("YdbResponses/Unsupported", true); 
+    YdbResponses[Ydb::StatusIds::SESSION_BUSY] = KqpGroup->GetCounter("YdbResponses/SessionBusy", true); 
+    OtherYdbResponses = KqpGroup->GetCounter("YdbResponses/Other", true); 
+ 
+    ResponseBytes = KqpGroup->GetCounter("Responses/Bytes", true); 
     YdbResponseBytes = YdbGroup->GetNamedCounter("name", "table.query.response.bytes", true);
-    QueryResultsBytes = KqpGroup->GetCounter("Responses/QueryResultBytes", true);
-
-    /* Workers */
+    QueryResultsBytes = KqpGroup->GetCounter("Responses/QueryResultBytes", true); 
+ 
+    /* Workers */ 
     WorkerLifeSpan = KqpGroup->GetHistogram(
         "Workers/LifeSpanMs", NMonitoring::ExponentialHistogram(20, 2, 1));
     QueriesPerWorker = KqpGroup->GetHistogram(
         "Workers/QueriesPerWorkerQ", NMonitoring::ExponentialHistogram(16, 2, 1));
 
-    WorkersCreated = KqpGroup->GetCounter("Workers/Created", true);
-    WorkersClosedIdle = KqpGroup->GetCounter("Workers/ClosedIdle", true);
+    WorkersCreated = KqpGroup->GetCounter("Workers/Created", true); 
+    WorkersClosedIdle = KqpGroup->GetCounter("Workers/ClosedIdle", true); 
     YdbWorkersClosedIdle = YdbGroup->GetNamedCounter("name", "table.session.closed_by_idle_count", true);
-    WorkersClosedError = KqpGroup->GetCounter("Workers/ClosedError", true);
-    WorkersClosedRequest = KqpGroup->GetCounter("Workers/ClosedRequest", true);
-    ActiveWorkers = KqpGroup->GetCounter("Workers/Active", false);
+    WorkersClosedError = KqpGroup->GetCounter("Workers/ClosedError", true); 
+    WorkersClosedRequest = KqpGroup->GetCounter("Workers/ClosedRequest", true); 
+    ActiveWorkers = KqpGroup->GetCounter("Workers/Active", false); 
     ProxyForwardedRequests = KqpGroup->GetCounter("Proxy/Forwarded", true);
 
     SessionBalancerCV = KqpGroup->GetCounter("SessionBalancer/CV", false);
     SessionBalancerShutdowns = KqpGroup->GetCounter("SessionBalancer/Shutdown", true);
 
     YdbActiveWorkers = YdbGroup->GetNamedCounter("name", "table.session.active_count", false);
-
+ 
     WorkerCleanupLatency = KqpGroup->GetHistogram(
         "Workers/CleanupLatencyMs", NMonitoring::ExponentialHistogram(10, 2, 1));
 
-    /* Transactions */
-    TxCreated = KqpGroup->GetCounter("Transactions/Created", true);
-    TxAborted = KqpGroup->GetCounter("Transactions/Aborted", true);
-    TxCommited = KqpGroup->GetCounter("Transactions/Commited", true);
-    TxEvicted = KqpGroup->GetCounter("Transactions/Evicted", true);
-
+    /* Transactions */ 
+    TxCreated = KqpGroup->GetCounter("Transactions/Created", true); 
+    TxAborted = KqpGroup->GetCounter("Transactions/Aborted", true); 
+    TxCommited = KqpGroup->GetCounter("Transactions/Commited", true); 
+    TxEvicted = KqpGroup->GetCounter("Transactions/Evicted", true); 
+ 
     TxActivePerSession = KqpGroup->GetHistogram(
         "Transactions/TxActivePerSession", NMonitoring::ExponentialHistogram(16, 2, 1));
     TxAbortedPerSession = KqpGroup->GetHistogram(
@@ -214,7 +214,7 @@ void TKqpCountersBase::Init() {
 
     CompileCpuTime = KqpGroup->GetHistogram(
         "Compilation/CPUTimeMs", NMonitoring::ExponentialHistogram(20, 2, 1));
-
+ 
     CreateYdbTxKindCounters(TKqpTransactionInfo::EKind::Pure, "pure");
     CreateYdbTxKindCounters(TKqpTransactionInfo::EKind::ReadOnly, "read_only");
     CreateYdbTxKindCounters(TKqpTransactionInfo::EKind::WriteOnly, "write_only");
@@ -229,18 +229,18 @@ void TKqpCountersBase::Init() {
 
     YdbCompileDuration = YdbGroup->GetNamedHistogram("name",
         "table.query.compilation.latency_milliseconds", NMonitoring::ExponentialHistogram(20, 2, 1));
-}
-
+} 
+ 
 void TKqpCountersBase::ReportQueryAction(NKikimrKqp::EQueryAction action) {
-    auto counter = QueryActionRequests.FindPtr(action);
-    if (counter) {
-        (*counter)->Inc();
-        return;
-    }
-
-    OtherQueryRequests->Inc();
-}
-
+    auto counter = QueryActionRequests.FindPtr(action); 
+    if (counter) { 
+        (*counter)->Inc(); 
+        return; 
+    } 
+ 
+    OtherQueryRequests->Inc(); 
+} 
+ 
 void TKqpCountersBase::ReportQueryType(NKikimrKqp::EQueryType type) {
     auto counter = QueryTypes.FindPtr(type);
     if (counter) {
@@ -321,63 +321,63 @@ void TKqpCountersBase::ReportQueryMaxShardProgramSize(ui64 programSize) {
     QueryMaxShardProgramSize->Collect(programSize > Max<i64>() ? Max<i64>() : static_cast<i64>(programSize));
 }
 
-void TKqpCountersBase::ReportResponseStatus(ui64 responseSize, Ydb::StatusIds::StatusCode ydbStatus) {
+void TKqpCountersBase::ReportResponseStatus(ui64 responseSize, Ydb::StatusIds::StatusCode ydbStatus) { 
     *ResponseBytes += responseSize;
     *YdbResponseBytes += responseSize;
 
-    auto ydbCounter = YdbResponses.FindPtr(ydbStatus);
-    if (ydbCounter) {
-        (*ydbCounter)->Inc();
-    } else {
-        OtherYdbResponses->Inc();
-    }
-}
-
+    auto ydbCounter = YdbResponses.FindPtr(ydbStatus); 
+    if (ydbCounter) { 
+        (*ydbCounter)->Inc(); 
+    } else { 
+        OtherYdbResponses->Inc(); 
+    } 
+} 
+ 
 void TKqpCountersBase::ReportResultsBytes(ui64 resultsBytes) {
     *QueryResultsBytes += resultsBytes;
 }
 
 TString TKqpCountersBase::GetIssueName(ui32 issueCode) {
-    auto kikimrIssueDescriptor = NKikimrIssues::TIssuesIds::EIssueCode_descriptor();
-    if (kikimrIssueDescriptor) {
-        auto valueDescriptor = kikimrIssueDescriptor->FindValueByNumber(issueCode);
-        if (valueDescriptor) {
-            return TStringBuilder() << "KIKIMR:" << valueDescriptor->name();
-        }
-    }
-
-    auto yqlIssueDescriptor = NYql::TIssuesIds::EIssueCode_descriptor();
-    if (yqlIssueDescriptor) {
-        auto valueDescriptor = yqlIssueDescriptor->FindValueByNumber(issueCode);
-        if (valueDescriptor) {
-            return TStringBuilder() << "YQL:" << valueDescriptor->name();
-        }
-    }
-
-    return TStringBuilder() << "CODE:" << ToString(issueCode);
-}
-
+    auto kikimrIssueDescriptor = NKikimrIssues::TIssuesIds::EIssueCode_descriptor(); 
+    if (kikimrIssueDescriptor) { 
+        auto valueDescriptor = kikimrIssueDescriptor->FindValueByNumber(issueCode); 
+        if (valueDescriptor) { 
+            return TStringBuilder() << "KIKIMR:" << valueDescriptor->name(); 
+        } 
+    } 
+ 
+    auto yqlIssueDescriptor = NYql::TIssuesIds::EIssueCode_descriptor(); 
+    if (yqlIssueDescriptor) { 
+        auto valueDescriptor = yqlIssueDescriptor->FindValueByNumber(issueCode); 
+        if (valueDescriptor) { 
+            return TStringBuilder() << "YQL:" << valueDescriptor->name(); 
+        } 
+    } 
+ 
+    return TStringBuilder() << "CODE:" << ToString(issueCode); 
+} 
+ 
 void TKqpCountersBase::ReportIssues(const Ydb::Issue::IssueMessage& issue) {
-    auto issueCounter = IssueCounters.FindPtr(issue.issue_code());
-    if (!issueCounter) {
-        auto counterName = TStringBuilder() << "Issues/" << GetIssueName(issue.issue_code());
-        auto counter = KqpGroup->GetCounter(counterName , true);
-
-        auto result = IssueCounters.emplace(issue.issue_code(), counter);
-        issueCounter = &result.first->second;
-    }
-
-    (*issueCounter)->Inc();
-
-    if (issue.issue_code() == TIssuesIds::KIKIMR_LOCKS_INVALIDATED) {
-        YdbResponsesLocksInvalidated->Inc();
-    }
-
+    auto issueCounter = IssueCounters.FindPtr(issue.issue_code()); 
+    if (!issueCounter) { 
+        auto counterName = TStringBuilder() << "Issues/" << GetIssueName(issue.issue_code()); 
+        auto counter = KqpGroup->GetCounter(counterName , true); 
+ 
+        auto result = IssueCounters.emplace(issue.issue_code(), counter); 
+        issueCounter = &result.first->second; 
+    } 
+ 
+    (*issueCounter)->Inc(); 
+ 
+    if (issue.issue_code() == TIssuesIds::KIKIMR_LOCKS_INVALIDATED) { 
+        YdbResponsesLocksInvalidated->Inc(); 
+    } 
+ 
     for (auto& childIssue : issue.issues()) {
-        ReportIssues(childIssue);
-    }
-}
-
+        ReportIssues(childIssue); 
+    } 
+} 
+ 
 void TKqpCountersBase::ReportQueryLatency(NKikimrKqp::EQueryAction action, const TDuration& duration) {
     if (action == NKikimrKqp::QUERY_ACTION_EXECUTE ||
         action == NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED ||
@@ -387,41 +387,41 @@ void TKqpCountersBase::ReportQueryLatency(NKikimrKqp::EQueryAction action, const
         YdbQueryExecuteLatency->Collect(duration.MilliSeconds());
     }
 
-    auto counter = QueryLatencies.FindPtr(action);
+    auto counter = QueryLatencies.FindPtr(action); 
     if (counter) {
         (*counter)->Collect(duration.MilliSeconds());
-    }
-}
-
+    } 
+} 
+ 
 
 void TKqpCountersBase::ReportTransaction(const TKqpTransactionInfo& txInfo) {
-    switch (txInfo.Status) {
-        case TKqpTransactionInfo::EStatus::Active:
-            return;
-        case TKqpTransactionInfo::EStatus::Aborted:
-            TxAborted->Inc();
-            return;
+    switch (txInfo.Status) { 
+        case TKqpTransactionInfo::EStatus::Active: 
+            return; 
+        case TKqpTransactionInfo::EStatus::Aborted: 
+            TxAborted->Inc(); 
+            return; 
         case TKqpTransactionInfo::EStatus::Committed:
-            TxCommited->Inc();
-            break;
-    }
+            TxCommited->Inc(); 
+            break; 
+    } 
     UpdateYdbTxCounters(txInfo, YdbTxByKind);
-}
-
+} 
+ 
 void TKqpCountersBase::ReportSqlVersion(ui16 sqlVersion) {
-    switch (sqlVersion) {
-        case 0:
-            SqlV0Translations->Inc();
-            break;
-        case 1:
-            SqlV1Translations->Inc();
-            break;
-        default:
-            SqlUnknownTranslations->Inc();
-            break;
-    }
-}
-
+    switch (sqlVersion) { 
+        case 0: 
+            SqlV0Translations->Inc(); 
+            break; 
+        case 1: 
+            SqlV1Translations->Inc(); 
+            break; 
+        default: 
+            SqlUnknownTranslations->Inc(); 
+            break; 
+    } 
+} 
+ 
 void TKqpCountersBase::ReportWorkerCreated() {
     WorkersCreated->Inc();
     ActiveWorkers->Inc();
@@ -876,11 +876,11 @@ void TKqpCounters::ReportQueryMaxShardProgramSize(TKqpDbCountersPtr dbCounters,
 }
 
 void TKqpCounters::ReportResponseStatus(TKqpDbCountersPtr dbCounters, ui64 responseSize,
-    Ydb::StatusIds::StatusCode ydbStatus)
+    Ydb::StatusIds::StatusCode ydbStatus) 
 {
-    TKqpCountersBase::ReportResponseStatus(responseSize, ydbStatus);
+    TKqpCountersBase::ReportResponseStatus(responseSize, ydbStatus); 
     if (dbCounters) {
-        dbCounters->ReportResponseStatus(responseSize, ydbStatus);
+        dbCounters->ReportResponseStatus(responseSize, ydbStatus); 
     }
 }
 
@@ -1135,4 +1135,4 @@ void TKqpCounters::RemoveDbCounters(const TString& database) {
 }
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/counters/kqp_counters.h b/ydb/core/kqp/counters/kqp_counters.h
index 53a8f7d2c2..40d7291ed5 100644
--- a/ydb/core/kqp/counters/kqp_counters.h
+++ b/ydb/core/kqp/counters/kqp_counters.h
@@ -1,5 +1,5 @@
-#pragma once
-
+#pragma once 
+ 
 #include "kqp_db_counters.h"
 
 #include <library/cpp/actors/helpers/mon_histogram_helper.h>
@@ -11,22 +11,22 @@
 #include <ydb/core/protos/kqp.pb.h>
 #include <ydb/core/sys_view/common/events.h>
 #include <ydb/core/tx/tx_proxy/mon.h>
-
+ 
 #include <ydb/library/yql/minikql/aligned_page_pool.h>
-
+ 
 #include <util/system/spinlock.h>
-
-namespace NKikimr {
-namespace NKqp {
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
 class TKqpCountersBase {
 protected:
     struct TYdbTxByKindCounters {
         NMonitoring::THistogramPtr TotalDuration;
         NMonitoring::THistogramPtr ServerDuration;
         NMonitoring::THistogramPtr ClientDuration;
-    };
-
+    }; 
+ 
 protected:
     void CreateYdbTxKindCounters(TKqpTransactionInfo::EKind kind, const TString& name);
     static void UpdateYdbTxCounters(const TKqpTransactionInfo& txInfo,
@@ -34,7 +34,7 @@ protected:
 
     void Init();
 
-    void ReportQueryAction(NKikimrKqp::EQueryAction action);
+    void ReportQueryAction(NKikimrKqp::EQueryAction action); 
     void ReportQueryType(NKikimrKqp::EQueryType type);
 
     void ReportSessionShutdownRequest();
@@ -52,18 +52,18 @@ protected:
     void ReportQueryMaxShardReplySize(ui64 replySize);
     void ReportQueryMaxShardProgramSize(ui64 programSize);
 
-    void ReportResponseStatus(ui64 responseSize, Ydb::StatusIds::StatusCode ydbStatus);
+    void ReportResponseStatus(ui64 responseSize, Ydb::StatusIds::StatusCode ydbStatus); 
     void ReportResultsBytes(ui64 resultsSize);
 
     static TString GetIssueName(ui32 issueCode);
     void ReportIssues(const Ydb::Issue::IssueMessage& issue);
 
-    void ReportQueryLatency(NKikimrKqp::EQueryAction action, const TDuration& duration);
+    void ReportQueryLatency(NKikimrKqp::EQueryAction action, const TDuration& duration); 
 
     void ReportTransaction(const TKqpTransactionInfo& txInfo);
 
-    void ReportSqlVersion(ui16 sqlVersion);
-
+    void ReportSqlVersion(ui16 sqlVersion); 
+ 
     void ReportWorkerCreated();
     void ReportWorkerFinished(TDuration lifeSpan);
     void ReportWorkerCleanupLatency(TDuration cleanupTime);
@@ -71,7 +71,7 @@ protected:
     void ReportWorkerClosedError();
     void ReportWorkerClosedRequest();
     void ReportQueriesPerWorker(ui32 queryId);
-
+ 
     void ReportProxyForwardedRequest();
     void ReportSessionBalancerCV(ui32 value);
 
@@ -98,24 +98,24 @@ protected:
     NMonitoring::TDynamicCounterPtr KqpGroup;
     NMonitoring::TDynamicCounterPtr YdbGroup;
     NMonitoring::TDynamicCounterPtr QueryReplayGroup;
-
-    // Requests
+ 
+    // Requests 
     THashMap<NKikimrKqp::EQueryAction, NMonitoring::TDynamicCounters::TCounterPtr> QueryActionRequests;
-    NMonitoring::TDynamicCounters::TCounterPtr OtherQueryRequests;
-    NMonitoring::TDynamicCounters::TCounterPtr CloseSessionRequests;
-    NMonitoring::TDynamicCounters::TCounterPtr CreateSessionRequests;
-    NMonitoring::TDynamicCounters::TCounterPtr PingSessionRequests;
-
-    NMonitoring::TDynamicCounters::TCounterPtr RequestBytes;
+    NMonitoring::TDynamicCounters::TCounterPtr OtherQueryRequests; 
+    NMonitoring::TDynamicCounters::TCounterPtr CloseSessionRequests; 
+    NMonitoring::TDynamicCounters::TCounterPtr CreateSessionRequests; 
+    NMonitoring::TDynamicCounters::TCounterPtr PingSessionRequests; 
+ 
+    NMonitoring::TDynamicCounters::TCounterPtr RequestBytes; 
     NMonitoring::TDynamicCounters::TCounterPtr YdbRequestBytes;
-    NMonitoring::TDynamicCounters::TCounterPtr QueryBytes;
-    NMonitoring::TDynamicCounters::TCounterPtr ParametersBytes;
+    NMonitoring::TDynamicCounters::TCounterPtr QueryBytes; 
+    NMonitoring::TDynamicCounters::TCounterPtr ParametersBytes; 
     NMonitoring::TDynamicCounters::TCounterPtr YdbParametersBytes;
-
-    NMonitoring::TDynamicCounters::TCounterPtr SqlV0Translations;
-    NMonitoring::TDynamicCounters::TCounterPtr SqlV1Translations;
-    NMonitoring::TDynamicCounters::TCounterPtr SqlUnknownTranslations;
-
+ 
+    NMonitoring::TDynamicCounters::TCounterPtr SqlV0Translations; 
+    NMonitoring::TDynamicCounters::TCounterPtr SqlV1Translations; 
+    NMonitoring::TDynamicCounters::TCounterPtr SqlUnknownTranslations; 
+ 
     THashMap<NKikimrKqp::EQueryType, NMonitoring::TDynamicCounters::TCounterPtr> QueryTypes;
     NMonitoring::TDynamicCounters::TCounterPtr OtherQueryTypes;
 
@@ -128,39 +128,39 @@ protected:
     NMonitoring::THistogramPtr QueryMaxShardReplySize;
     NMonitoring::THistogramPtr QueryMaxShardProgramSize;
 
-    // Request latency
+    // Request latency 
     THashMap<NKikimrKqp::EQueryAction, NMonitoring::THistogramPtr> QueryLatencies;
     NMonitoring::THistogramPtr YdbQueryExecuteLatency;
-
-    // Responses
-    NMonitoring::TDynamicCounters::TCounterPtr OtherResponses;
+ 
+    // Responses 
+    NMonitoring::TDynamicCounters::TCounterPtr OtherResponses; 
     NMonitoring::TDynamicCounters::TCounterPtr YdbResponsesLocksInvalidated;
 
-    THashMap<Ydb::StatusIds::StatusCode, NMonitoring::TDynamicCounters::TCounterPtr> YdbResponses;
-    NMonitoring::TDynamicCounters::TCounterPtr OtherYdbResponses;
-
-    NMonitoring::TDynamicCounters::TCounterPtr ResponseBytes;
+    THashMap<Ydb::StatusIds::StatusCode, NMonitoring::TDynamicCounters::TCounterPtr> YdbResponses; 
+    NMonitoring::TDynamicCounters::TCounterPtr OtherYdbResponses; 
+ 
+    NMonitoring::TDynamicCounters::TCounterPtr ResponseBytes; 
     NMonitoring::TDynamicCounters::TCounterPtr YdbResponseBytes;
-    NMonitoring::TDynamicCounters::TCounterPtr QueryResultsBytes;
-
-    THashMap<ui32, NMonitoring::TDynamicCounters::TCounterPtr> IssueCounters;
-
-    // Workers
+    NMonitoring::TDynamicCounters::TCounterPtr QueryResultsBytes; 
+ 
+    THashMap<ui32, NMonitoring::TDynamicCounters::TCounterPtr> IssueCounters; 
+ 
+    // Workers 
     NMonitoring::THistogramPtr WorkerLifeSpan;
     NMonitoring::THistogramPtr QueriesPerWorker;
-    NMonitoring::TDynamicCounters::TCounterPtr WorkersCreated;
-    NMonitoring::TDynamicCounters::TCounterPtr WorkersClosedIdle;
+    NMonitoring::TDynamicCounters::TCounterPtr WorkersCreated; 
+    NMonitoring::TDynamicCounters::TCounterPtr WorkersClosedIdle; 
     NMonitoring::TDynamicCounters::TCounterPtr YdbWorkersClosedIdle;
-    NMonitoring::TDynamicCounters::TCounterPtr WorkersClosedError;
-    NMonitoring::TDynamicCounters::TCounterPtr WorkersClosedRequest;
-    NMonitoring::TDynamicCounters::TCounterPtr ActiveWorkers;
+    NMonitoring::TDynamicCounters::TCounterPtr WorkersClosedError; 
+    NMonitoring::TDynamicCounters::TCounterPtr WorkersClosedRequest; 
+    NMonitoring::TDynamicCounters::TCounterPtr ActiveWorkers; 
     NMonitoring::TDynamicCounters::TCounterPtr YdbActiveWorkers;
     NMonitoring::TDynamicCounters::TCounterPtr SessionBalancerCV;
     NMonitoring::TDynamicCounters::TCounterPtr SessionBalancerShutdowns;
     NMonitoring::TDynamicCounters::TCounterPtr ProxyForwardedRequests;
 
     NMonitoring::THistogramPtr WorkerCleanupLatency;
-
+ 
     // Transactions
     NMonitoring::TDynamicCounters::TCounterPtr TxCreated;
     NMonitoring::TDynamicCounters::TCounterPtr TxAborted;
@@ -250,7 +250,7 @@ public:
     void ReportCloseSession(TKqpDbCountersPtr dbCounters, ui64 requestSize);
     void ReportQueryRequest(TKqpDbCountersPtr dbCounters, const NKikimrKqp::TQueryRequest& request);
 
-    void ReportResponseStatus(TKqpDbCountersPtr dbCounters, ui64 responseSize, Ydb::StatusIds::StatusCode ydbStatus);
+    void ReportResponseStatus(TKqpDbCountersPtr dbCounters, ui64 responseSize, Ydb::StatusIds::StatusCode ydbStatus); 
     void ReportResultsBytes(TKqpDbCountersPtr dbCounters, ui64 resultsSize);
     void ReportIssues(TKqpDbCountersPtr dbCounters, const Ydb::Issue::IssueMessage& issue);
 
@@ -312,13 +312,13 @@ public:
     // Transactions
     THashMap<TKqpTransactionInfo::EKind, TTxByKindCounters> TxByKind;
 
-    // Compile service
-    NMonitoring::TDynamicCounters::TCounterPtr CompileQueryCacheSize;
-    NMonitoring::TDynamicCounters::TCounterPtr CompileQueryCacheBytes;
-    NMonitoring::TDynamicCounters::TCounterPtr CompileQueryCacheEvicted;
-    NMonitoring::TDynamicCounters::TCounterPtr CompileQueueSize;
+    // Compile service 
+    NMonitoring::TDynamicCounters::TCounterPtr CompileQueryCacheSize; 
+    NMonitoring::TDynamicCounters::TCounterPtr CompileQueryCacheBytes; 
+    NMonitoring::TDynamicCounters::TCounterPtr CompileQueryCacheEvicted; 
+    NMonitoring::TDynamicCounters::TCounterPtr CompileQueueSize; 
     NMonitoring::TDynamicCounters::TCounterPtr ForceNewEngineCompileErrors;
-
+ 
     // Resource Manager
     NMonitoring::TDynamicCounters::TCounterPtr RmComputeActors;
     NMonitoring::TDynamicCounters::TCounterPtr RmMemory;
@@ -361,8 +361,8 @@ public:
     TConcurrentRWHashMap<TString, TKqpDbCountersPtr, 256> DbCounters;
     TActorSystem* ActorSystem = nullptr;
     TActorId DbWatcherActorId;
-};
-
+}; 
+ 
 struct TKqpRequestCounters : public TThrRefBase {
     using TPtr = TIntrusivePtr<TKqpRequestCounters>;
 
@@ -372,4 +372,4 @@ struct TKqpRequestCounters : public TThrRefBase {
 };
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/executer/kqp_data_executer.cpp b/ydb/core/kqp/executer/kqp_data_executer.cpp
index 003d4ffa20..a5019208c3 100644
--- a/ydb/core/kqp/executer/kqp_data_executer.cpp
+++ b/ydb/core/kqp/executer/kqp_data_executer.cpp
@@ -35,7 +35,7 @@ namespace {
 static constexpr TDuration MinReattachDelay = TDuration::MilliSeconds(10);
 static constexpr TDuration MaxReattachDelay = TDuration::MilliSeconds(100);
 static constexpr TDuration MaxReattachDuration = TDuration::Seconds(4);
-static constexpr ui32 ReplySizeLimit = 48 * 1024 * 1024; // 48 MB
+static constexpr ui32 ReplySizeLimit = 48 * 1024 * 1024; // 48 MB 
 
 class TKqpDataExecuter : public TKqpExecuterBase<TKqpDataExecuter, EExecType::Data> {
     using TBase = TKqpExecuterBase<TKqpDataExecuter, EExecType::Data>;
@@ -130,18 +130,18 @@ public:
     TKqpDataExecuter(IKqpGateway::TExecPhysicalRequest&& request, const TString& database, const TMaybe<TString>& userToken,
         TKqpRequestCounters::TPtr counters)
         : TBase(std::move(request), database, userToken, counters)
-    {
-        YQL_ENSURE(Request.IsolationLevel != NKikimrKqp::ISOLATION_LEVEL_UNDEFINED);
-
-        if (Request.AcquireLocksTxId || Request.ValidateLocks || Request.EraseLocks) {
-            YQL_ENSURE(Request.IsolationLevel == NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE);
-        }
-
-        if (Request.Snapshot.IsValid()) {
-            YQL_ENSURE(Request.IsolationLevel == NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE);
-        }
-    }
-
+    { 
+        YQL_ENSURE(Request.IsolationLevel != NKikimrKqp::ISOLATION_LEVEL_UNDEFINED); 
+
+        if (Request.AcquireLocksTxId || Request.ValidateLocks || Request.EraseLocks) { 
+            YQL_ENSURE(Request.IsolationLevel == NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE); 
+        } 
+ 
+        if (Request.Snapshot.IsValid()) { 
+            YQL_ENSURE(Request.IsolationLevel == NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE); 
+        } 
+    } 
+ 
 public:
     STATEFN(WaitResolveState) {
         switch (ev->GetTypeRewrite()) {
@@ -1264,25 +1264,25 @@ private:
                 auto& stage = tx.Body.GetStages(stageIdx);
                 auto& stageInfo = TasksGraph.GetStageInfo(TStageId(txIdx, stageIdx));
 
-                if (stageInfo.Meta.ShardKind == NSchemeCache::TSchemeCacheRequest::KindAsyncIndexTable) {
-                    TMaybe<TString> error;
-
-                    if (stageInfo.Meta.ShardKey->RowOperation != TKeyDesc::ERowOperation::Read) {
-                        error = TStringBuilder() << "Non-read operations can't be performed on async index table"
-                            << ": " << stageInfo.Meta.ShardKey->TableId;
-                    } else if (Request.IsolationLevel != NKikimrKqp::ISOLATION_LEVEL_READ_STALE) {
-                        error = TStringBuilder() << "Read operation can be performed on async index table"
-                            << ": " << stageInfo.Meta.ShardKey->TableId << " only with StaleRO isolation level";
-                    }
-
-                    if (error) {
-                        LOG_E(*error);
-                        ReplyErrorAndDie(Ydb::StatusIds::PRECONDITION_FAILED,
-                            YqlIssue({}, NYql::TIssuesIds::KIKIMR_PRECONDITION_FAILED, *error));
-                        return;
-                    }
-                }
-
+                if (stageInfo.Meta.ShardKind == NSchemeCache::TSchemeCacheRequest::KindAsyncIndexTable) { 
+                    TMaybe<TString> error; 
+ 
+                    if (stageInfo.Meta.ShardKey->RowOperation != TKeyDesc::ERowOperation::Read) { 
+                        error = TStringBuilder() << "Non-read operations can't be performed on async index table" 
+                            << ": " << stageInfo.Meta.ShardKey->TableId; 
+                    } else if (Request.IsolationLevel != NKikimrKqp::ISOLATION_LEVEL_READ_STALE) { 
+                        error = TStringBuilder() << "Read operation can be performed on async index table" 
+                            << ": " << stageInfo.Meta.ShardKey->TableId << " only with StaleRO isolation level"; 
+                    } 
+ 
+                    if (error) { 
+                        LOG_E(*error); 
+                        ReplyErrorAndDie(Ydb::StatusIds::PRECONDITION_FAILED, 
+                            YqlIssue({}, NYql::TIssuesIds::KIKIMR_PRECONDITION_FAILED, *error)); 
+                        return; 
+                    } 
+                } 
+ 
                 LOG_D("Stage " << stageInfo.Id << " AST: " << stage.GetProgramAst());
 
                 ReadOnlyTx &= !stage.GetIsEffectsStage();
@@ -1437,20 +1437,20 @@ private:
 
         // Single-shard transactions are always immediate
         ImmediateTx = datashardTxs.size() <= 1;
-        switch (Request.IsolationLevel) {
+        switch (Request.IsolationLevel) { 
             // OnlineRO with AllowInconsistentReads = true
-            case NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED:
-            // StaleRO transactions always execute as immediate
-            // (legacy behaviour, for compatibility with current execution engine)
-            case NKikimrKqp::ISOLATION_LEVEL_READ_STALE:
-                YQL_ENSURE(ReadOnlyTx);
-                ImmediateTx = true;
-                break;
-
-            default:
-                break;
-        }
-
+            case NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED: 
+            // StaleRO transactions always execute as immediate 
+            // (legacy behaviour, for compatibility with current execution engine) 
+            case NKikimrKqp::ISOLATION_LEVEL_READ_STALE: 
+                YQL_ENSURE(ReadOnlyTx); 
+                ImmediateTx = true; 
+                break; 
+ 
+            default: 
+                break; 
+        }
+ 
         if (ReadOnlyTx && Request.Snapshot.IsValid()) {
             // Snapshot reads are always immediate
             ImmediateTx = true;
@@ -1458,8 +1458,8 @@ private:
 
         UseFollowers = Request.IsolationLevel == NKikimrKqp::ISOLATION_LEVEL_READ_STALE;
         if (datashardTxs.size() > 1) {
-            // Followers only allowed for single shard transactions.
-            // (legacy behaviour, for compatibility with current execution engine)
+            // Followers only allowed for single shard transactions. 
+            // (legacy behaviour, for compatibility with current execution engine) 
             UseFollowers = false;
         }
         if (Request.Snapshot.IsValid()) {
@@ -1544,7 +1544,7 @@ private:
         auto lockTxId = Request.AcquireLocksTxId;
         if (lockTxId.Defined() && *lockTxId == 0) {
             lockTxId = TxId;
-        }
+        } 
 
         // first, start compute tasks
         TVector<ui64> computeTaskIds{Reserve(computeTasks.size())};
@@ -1599,12 +1599,12 @@ private:
             ExecuteDatashardTransaction(shardId, shardTx, lockTxId);
         }
 
-        LOG_I("Total tasks: " << TasksGraph.GetTasks().size()
+        LOG_I("Total tasks: " << TasksGraph.GetTasks().size() 
             << ", readonly: " << ReadOnlyTx
             << ", datashardTxs: " << datashardTxs.size()
             << ", immediate: " << ImmediateTx
             << ", useFollowers: " << UseFollowers);
-
+ 
         LOG_T("Updating channels after the creation of compute actors");
         THashMap<TActorId, THashSet<ui64>> updates;
         for (ui64 taskId : computeTaskIds) {
@@ -1612,7 +1612,7 @@ private:
             CollectTaskChannelsUpdates(task, updates);
         }
         PropagateChannelsUpdates(updates);
-        CheckExecutionComplete();
+        CheckExecutionComplete(); 
     }
 
     void Finalize() {
@@ -1653,16 +1653,16 @@ private:
             Stats.reset();
         }
 
-        auto resultSize = response.ByteSize();
-        if (resultSize > (int)ReplySizeLimit) {
-            TString message = TStringBuilder() << "Query result size limit exceeded. ("
-                << resultSize << " > " << ReplySizeLimit << ")";
-
-            auto issue = YqlIssue({}, TIssuesIds::KIKIMR_RESULT_UNAVAILABLE, message);
-            ReplyErrorAndDie(Ydb::StatusIds::PRECONDITION_FAILED, issue);
-            return;
-        }
-
+        auto resultSize = response.ByteSize(); 
+        if (resultSize > (int)ReplySizeLimit) { 
+            TString message = TStringBuilder() << "Query result size limit exceeded. (" 
+                << resultSize << " > " << ReplySizeLimit << ")"; 
+ 
+            auto issue = YqlIssue({}, TIssuesIds::KIKIMR_RESULT_UNAVAILABLE, message); 
+            ReplyErrorAndDie(Ydb::StatusIds::PRECONDITION_FAILED, issue); 
+            return; 
+        } 
+ 
         LOG_D("Sending response to: " << Target << ", results: " << Results.size());
         Send(Target, ResponseEv.release());
         PassAway();
diff --git a/ydb/core/kqp/executer/kqp_executer_impl.cpp b/ydb/core/kqp/executer/kqp_executer_impl.cpp
index 0931e5d2c7..ccdb107e88 100644
--- a/ydb/core/kqp/executer/kqp_executer_impl.cpp
+++ b/ydb/core/kqp/executer/kqp_executer_impl.cpp
@@ -45,7 +45,7 @@ void PrepareKqpTaskParameters(const NKqpProto::TKqpPhyStage& stage, const TStage
         if (auto* taskParam = task.Meta.Params.FindPtr(paramName)) {
             dqParams[paramName] = *taskParam;
         } else {
-            auto* paramValue = stageInfo.Meta.Tx.Params.Values.FindPtr(paramName);
+            auto* paramValue = stageInfo.Meta.Tx.Params.Values.FindPtr(paramName); 
             YQL_ENSURE(paramValue);
             dqParams[paramName] = NDq::TDqDataSerializer::SerializeParam(*paramValue, typeEnv, holderFactory);
         }
diff --git a/ydb/core/kqp/executer/kqp_executer_impl.h b/ydb/core/kqp/executer/kqp_executer_impl.h
index 6ecf78ab05..282d63d35a 100644
--- a/ydb/core/kqp/executer/kqp_executer_impl.h
+++ b/ydb/core/kqp/executer/kqp_executer_impl.h
@@ -497,7 +497,7 @@ protected:
     void InternalError(const TString& message) {
         LOG_E(message);
         TerminateComputeActors(Ydb::StatusIds::INTERNAL_ERROR, message);
-        auto issue = NYql::YqlIssue({}, NYql::TIssuesIds::UNEXPECTED, "Internal error while executing transaction.");
+        auto issue = NYql::YqlIssue({}, NYql::TIssuesIds::UNEXPECTED, "Internal error while executing transaction."); 
         issue.AddSubIssue(MakeIntrusive<NYql::TIssue>(message));
         ReplyErrorAndDie(Ydb::StatusIds::INTERNAL_ERROR, issue);
     }
diff --git a/ydb/core/kqp/executer/kqp_executer_stats.cpp b/ydb/core/kqp/executer/kqp_executer_stats.cpp
index 8c3605fd91..b781f9ec9e 100644
--- a/ydb/core/kqp/executer/kqp_executer_stats.cpp
+++ b/ydb/core/kqp/executer/kqp_executer_stats.cpp
@@ -5,7 +5,7 @@
 namespace NKikimr::NKqp {
 
 using namespace NYql;
-using namespace NYql::NDq;
+using namespace NYql::NDq; 
 
 namespace {
 
@@ -37,7 +37,7 @@ void UpdateMinMax(NDqProto::TDqStatsMinMax* minMax, ui64 value) noexcept {
     } else {
         minMax->SetMin(std::min(minMax->GetMin(), value));
     }
-    minMax->SetMax(std::max(minMax->GetMax(), value));
+    minMax->SetMax(std::max(minMax->GetMax(), value)); 
 }
 
 NDqProto::TDqStageStats* GetOrCreateStageStats(const NYql::NDqProto::TDqTaskStats& taskStats,
@@ -60,7 +60,7 @@ NDqProto::TDqStageStats* GetOrCreateStageStats(const NYql::NDqProto::TDqTaskStat
     newStage->SetStageGuid(stageProto.GetStageGuid());
     newStage->SetProgram(stageProto.GetProgramAst());
     return newStage;
-}
+} 
 
 NDqProto::TDqTableAggrStats* GetOrCreateTableAggrStats(NDqProto::TDqStageStats* stage, const TString& tablePath) {
     for(auto& table : *stage->MutableTables()) {
@@ -71,9 +71,9 @@ NDqProto::TDqTableAggrStats* GetOrCreateTableAggrStats(NDqProto::TDqStageStats*
     auto table = stage->AddTables();
     table->SetTablePath(tablePath);
     return table;
-}
+} 
 
-} // anonymous namespace
+} // anonymous namespace 
 
 void TQueryExecutionStats::AddComputeActorStats(ui32 /* nodeId */, NYql::NDqProto::TDqComputeActorStats&& stats) {
 //    Cerr << (TStringBuilder() << "::AddComputeActorStats " << stats.DebugString() << Endl);
@@ -135,16 +135,16 @@ void TQueryExecutionStats::AddDatashardPrepareStats(NKikimrQueryStats::TTxStats&
 
     Result->SetCpuTimeUs(Result->GetCpuTimeUs() + cpuUs);
 }
-
+ 
 void TQueryExecutionStats::AddDatashardStats(NYql::NDqProto::TDqComputeActorStats&& stats,
     NKikimrQueryStats::TTxStats&& txStats)
 {
 //    Cerr << (TStringBuilder() << "::AddDatashardStats " << stats.DebugString() << ", " << txStats.DebugString() << Endl);
-
+ 
     ui64 datashardCpuTimeUs = 0;
     for (const auto& perShard : txStats.GetPerShardStats()) {
         AffectedShards.emplace(perShard.GetShardId());
-
+ 
         datashardCpuTimeUs += perShard.GetCpuTimeUsec();
         UpdateAggr(ExtraStats.MutableShardsCpuTimeUs(), perShard.GetCpuTimeUsec());
     }
diff --git a/ydb/core/kqp/executer/kqp_executer_stats.h b/ydb/core/kqp/executer/kqp_executer_stats.h
index 56c7921318..658549af62 100644
--- a/ydb/core/kqp/executer/kqp_executer_stats.h
+++ b/ydb/core/kqp/executer/kqp_executer_stats.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "kqp_tasks_graph.h"
+#include "kqp_tasks_graph.h" 
 #include <ydb/library/yql/dq/actors/protos/dq_stats.pb.h>
 #include <util/generic/vector.h>
 
diff --git a/ydb/core/kqp/executer/kqp_literal_executer.cpp b/ydb/core/kqp/executer/kqp_literal_executer.cpp
index 3aabd41548..2b5833e418 100644
--- a/ydb/core/kqp/executer/kqp_literal_executer.cpp
+++ b/ydb/core/kqp/executer/kqp_literal_executer.cpp
@@ -97,9 +97,9 @@ private:
                 }
             }
         } catch (const TMemoryLimitExceededException& e) {
-            LOG_W("TKqpLiteralExecuter, memory limit exceeded.");
-            ReplyErrorAndDie(Ydb::StatusIds::PRECONDITION_FAILED,
-                YqlIssue({}, TIssuesIds::KIKIMR_PRECONDITION_FAILED, "Memory limit exceeded"));
+            LOG_W("TKqpLiteralExecuter, memory limit exceeded."); 
+            ReplyErrorAndDie(Ydb::StatusIds::PRECONDITION_FAILED, 
+                YqlIssue({}, TIssuesIds::KIKIMR_PRECONDITION_FAILED, "Memory limit exceeded")); 
         } catch (...) {
             auto msg = CurrentExceptionMessage();
             LOG_C("TKqpLiteralExecuter, unexpected exception caught: " << msg);
@@ -346,7 +346,7 @@ private:
 private:
     void InternalError(const TString& message) {
         LOG_E(message);
-        auto issue = NYql::YqlIssue({}, NYql::TIssuesIds::UNEXPECTED, "Internal error while executing transaction.");
+        auto issue = NYql::YqlIssue({}, NYql::TIssuesIds::UNEXPECTED, "Internal error while executing transaction."); 
         issue.AddSubIssue(MakeIntrusive<TIssue>(message));
         ReplyErrorAndDie(Ydb::StatusIds::INTERNAL_ERROR, issue);
     }
diff --git a/ydb/core/kqp/executer/kqp_partition_helper.cpp b/ydb/core/kqp/executer/kqp_partition_helper.cpp
index ac786f6c24..03d0f4bbca 100644
--- a/ydb/core/kqp/executer/kqp_partition_helper.cpp
+++ b/ydb/core/kqp/executer/kqp_partition_helper.cpp
@@ -192,7 +192,7 @@ TVector<TCell> FillKeyValues(const TVector<NUdf::TDataTypeId>& keyColumnTypes, c
                 YQL_ENSURE(false, "Unexpected type case " << (int) tupleValue.GetKindCase());
         }
 
-        auto param = stageInfo.Meta.Tx.Params.Values.FindPtr(paramName);
+        auto param = stageInfo.Meta.Tx.Params.Values.FindPtr(paramName); 
         YQL_ENSURE(param, "Param not found: " << paramName);
 
         const auto* protoType = &param->GetType();
@@ -334,7 +334,7 @@ TVector<TSerializedPointOrRange> FillRangesFromParameter(const TVector<NUdf::TDa
 {
     TString paramName = rangesParam.GetParamName();
 
-    auto param = stageInfo.Meta.Tx.Params.Values.FindPtr(paramName);
+    auto param = stageInfo.Meta.Tx.Params.Values.FindPtr(paramName); 
     YQL_ENSURE(param, "Param not found: " << paramName);
 
     const auto* protoType = &param->GetType();
@@ -754,7 +754,7 @@ THashMap<ui64, TShardInfo> PruneEffectPartitionsImpl(const TKqpTableKeys& tableK
         effect.GetRowsValue().GetKindCase() == NKqpProto::TKqpPhyValue::kParamValue)
     {
         const auto& name = effect.GetRowsValue().GetParamValue().GetParamName();
-        auto param = stageInfo.Meta.Tx.Params.Values.FindPtr(name);
+        auto param = stageInfo.Meta.Tx.Params.Values.FindPtr(name); 
         YQL_ENSURE(param);
 
         auto shardsMap = PartitionParamByKey(*param, stageInfo.Meta.TableId, tableKeys, *stageInfo.Meta.ShardKey,
diff --git a/ydb/core/kqp/executer/kqp_planner.cpp b/ydb/core/kqp/executer/kqp_planner.cpp
index 6bcfa85c66..b8eaa0da98 100644
--- a/ydb/core/kqp/executer/kqp_planner.cpp
+++ b/ydb/core/kqp/executer/kqp_planner.cpp
@@ -33,7 +33,7 @@ TKqpPlanner::TKqpPlanner(ui64 txId, const TActorId& executer, TVector<NDqProto::
     , Database(database)
     , UserToken(userToken)
     , Deadline(deadline)
-    , StatsMode(statsMode)
+    , StatsMode(statsMode) 
     , DisableLlvmForUdfStages(disableLlvmForUdfStages)
     , EnableLlvm(enableLlvm)
     , WithSpilling(withSpilling)
diff --git a/ydb/core/kqp/executer/kqp_result_channel.cpp b/ydb/core/kqp/executer/kqp_result_channel.cpp
index 0fe235323e..b061302a68 100644
--- a/ydb/core/kqp/executer/kqp_result_channel.cpp
+++ b/ydb/core/kqp/executer/kqp_result_channel.cpp
@@ -17,7 +17,7 @@ namespace {
 class TResultCommonChannelProxy : public NActors::TActor<TResultCommonChannelProxy> {
 public:
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
-        return NKikimrServices::TActivity::KQP_RESULT_CHANNEL_PROXY;
+        return NKikimrServices::TActivity::KQP_RESULT_CHANNEL_PROXY; 
     }
 
     TResultCommonChannelProxy(ui64 txId, ui64 channelId, TQueryExecutionStats* stats, TActorId executer)
diff --git a/ydb/core/kqp/executer/kqp_result_channel.h b/ydb/core/kqp/executer/kqp_result_channel.h
index 299b0f686b..d5eb0594d1 100644
--- a/ydb/core/kqp/executer/kqp_result_channel.h
+++ b/ydb/core/kqp/executer/kqp_result_channel.h
@@ -15,10 +15,10 @@ class TData;
 } // namespace NDqProto
 } // namespace NYql
 
-namespace NKikimrMiniKQL {
-class TType;
-} // namespace NKikimrMiniKQL
-
+namespace NKikimrMiniKQL { 
+class TType; 
+} // namespace NKikimrMiniKQL 
+ 
 namespace NKikimr::NKqp {
 
 struct TQueryExecutionStats;
diff --git a/ydb/core/kqp/executer/kqp_scan_executer.cpp b/ydb/core/kqp/executer/kqp_scan_executer.cpp
index 07c29f64e2..3dc3583dab 100644
--- a/ydb/core/kqp/executer/kqp_scan_executer.cpp
+++ b/ydb/core/kqp/executer/kqp_scan_executer.cpp
@@ -1,12 +1,12 @@
-#include "kqp_executer.h"
+#include "kqp_executer.h" 
 #include "kqp_executer_impl.h"
 #include "kqp_partition_helper.h"
 #include "kqp_planner.h"
 #include "kqp_result_channel.h"
-#include "kqp_tasks_graph.h"
-#include "kqp_tasks_validate.h"
+#include "kqp_tasks_graph.h" 
+#include "kqp_tasks_validate.h" 
 #include "kqp_shards_resolver.h"
-
+ 
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/base/tablet_pipecache.h>
 #include <ydb/core/client/minikql_compile/db_key_resolver.h>
@@ -16,32 +16,32 @@
 #include <ydb/core/kqp/node/kqp_node.h>
 #include <ydb/core/kqp/runtime/kqp_transport.h>
 #include <ydb/core/kqp/prepare/kqp_query_plan.h>
-
+ 
 #include <ydb/library/yql/dq/runtime/dq_columns_resolve.h>
 #include <ydb/library/yql/dq/tasks/dq_connection_builder.h>
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
-
+ 
 #include <library/cpp/actors/core/actor_bootstrapped.h>
 #include <library/cpp/actors/core/hfunc.h>
 #include <library/cpp/actors/core/interconnect.h>
 #include <library/cpp/actors/core/log.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
 using namespace NYql::NDq;
-
-namespace {
-
+ 
+namespace { 
+ 
 class TKqpScanExecuter : public TKqpExecuterBase<TKqpScanExecuter, EExecType::Scan> {
     using TBase = TKqpExecuterBase<TKqpScanExecuter, EExecType::Scan>;
 
-public:
+public: 
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
         return NKikimrServices::TActivity::KQP_EXECUTER_ACTOR;
-    }
-
+    } 
+ 
     TKqpScanExecuter(IKqpGateway::TExecPhysicalRequest&& request, const TString& database,
         const TMaybe<TString>& userToken, TKqpRequestCounters::TPtr counters)
         : TBase(std::move(request), database, userToken, counters)
@@ -50,7 +50,7 @@ public:
         YQL_ENSURE(Request.Locks.empty());
         YQL_ENSURE(!Request.ValidateLocks);
         YQL_ENSURE(!Request.EraseLocks);
-        YQL_ENSURE(Request.IsolationLevel == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED);
+        YQL_ENSURE(Request.IsolationLevel == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED); 
         YQL_ENSURE(Request.Snapshot.IsValid());
 
         size_t resultsSize = Request.Transactions[0].Body.ResultsSize();
@@ -65,33 +65,33 @@ public:
                 YQL_ENSURE(Request.Transactions[0].Body.GetResults(i).GetIsStream() == streamResult);
             }
         }
-    }
-
+    } 
+ 
 public:
-    TActorId KqpShardsResolverId;
-
-    STATEFN(WaitResolveState) {
+    TActorId KqpShardsResolverId; 
+ 
+    STATEFN(WaitResolveState) { 
         switch (ev->GetTypeRewrite()) {
-            hFunc(TEvKqpExecuter::TEvTableResolveStatus, HandleResolve);
-            hFunc(TEvKqpExecuter::TEvShardsResolveStatus, HandleResolve);
+            hFunc(TEvKqpExecuter::TEvTableResolveStatus, HandleResolve); 
+            hFunc(TEvKqpExecuter::TEvShardsResolveStatus, HandleResolve); 
             hFunc(TEvKqp::TEvAbortExecution, HandleAbortExecution);
             hFunc(TEvents::TEvWakeup, HandleTimeout);
-            default:
+            default: 
                 UnexpectedEvent("WaitResolveState", ev->GetTypeRewrite());
-        }
+        } 
         ReportEventElapsedTime();
-    }
-
-    void HandleResolve(TEvKqpExecuter::TEvTableResolveStatus::TPtr& ev) {
-        auto& reply = *ev->Get();
-
-        KqpTableResolverId = {};
-
-        if (reply.Status != Ydb::StatusIds::SUCCESS) {
+    } 
+ 
+    void HandleResolve(TEvKqpExecuter::TEvTableResolveStatus::TPtr& ev) { 
+        auto& reply = *ev->Get(); 
+
+        KqpTableResolverId = {}; 
+ 
+        if (reply.Status != Ydb::StatusIds::SUCCESS) { 
             TBase::ReplyErrorAndDie(reply.Status, reply.Issues);
-            return;
-        }
-
+            return; 
+        } 
+ 
         TSet<ui64> shardIds;
         for (auto& [stageId, stageInfo] : TasksGraph.GetStagesInfo()) {
             if (stageInfo.Meta.ShardKey) {
@@ -110,23 +110,23 @@ public:
         }
     }
 
-    void HandleResolve(TEvKqpExecuter::TEvShardsResolveStatus::TPtr& ev) {
-        auto& reply = *ev->Get();
-
-        KqpShardsResolverId = {};
+    void HandleResolve(TEvKqpExecuter::TEvShardsResolveStatus::TPtr& ev) { 
+        auto& reply = *ev->Get(); 
 
+        KqpShardsResolverId = {}; 
+ 
         // TODO: count resolve time in CpuTime
 
-        if (reply.Status != Ydb::StatusIds::SUCCESS) {
+        if (reply.Status != Ydb::StatusIds::SUCCESS) { 
             LOG_W("Shards nodes resolve failed, status: " << Ydb::StatusIds_StatusCode_Name(reply.Status)
                 << ", issues: " << reply.Issues.ToString());
             TBase::ReplyErrorAndDie(reply.Status, reply.Issues);
-            return;
-        }
-
-        LOG_D("Shards nodes resolved, success: " << reply.ShardNodes.size() << ", failed: " << reply.Unresolved);
-
-        ShardIdToNodeId = std::move(reply.ShardNodes);
+            return; 
+        } 
+ 
+        LOG_D("Shards nodes resolved, success: " << reply.ShardNodes.size() << ", failed: " << reply.Unresolved); 
+ 
+        ShardIdToNodeId = std::move(reply.ShardNodes); 
         for (auto& [shardId, nodeId] : ShardIdToNodeId) {
             ShardsOnNode[nodeId].push_back(shardId);
         }
@@ -147,12 +147,12 @@ public:
         }
 
         Execute();
-    }
-
+    } 
+ 
 private:
     STATEFN(ExecuteState) {
-        try {
-            switch (ev->GetTypeRewrite()) {
+        try { 
+            switch (ev->GetTypeRewrite()) { 
                 hFunc(TEvDqCompute::TEvState, HandleExecute);
                 hFunc(TEvKqpExecuter::TEvStreamDataAck, HandleExecute);
                 hFunc(TEvKqp::TEvAbortExecution, HandleAbortExecution);
@@ -164,23 +164,23 @@ private:
                 IgnoreFunc(TEvInterconnect::TEvNodeConnected);
                 default:
                     UnexpectedEvent("ExecuteState", ev->GetTypeRewrite());
-            }
-        } catch (const yexception& e) {
+            } 
+        } catch (const yexception& e) { 
             InternalError(e.what());
-        }
+        } 
         ReportEventElapsedTime();
-    }
-
+    } 
+ 
     void HandleExecute(TEvDqCompute::TEvState::TPtr& ev) {
         TActorId computeActor = ev->Sender;
         auto& state = ev->Get()->Record;
         ui64 taskId = state.GetTaskId();
-
+ 
         LOG_D("Got execution state from compute actor: " << computeActor
             << ", task: " << taskId
             << ", state: " << NDqProto::EComputeState_Name((NDqProto::EComputeState) state.GetState())
             << ", stats: " << state.GetStats());
-
+ 
         switch (state.GetState()) {
             case NDqProto::COMPUTE_STATE_UNKNOWN: {
                 YQL_ENSURE(false, "unexpected state from " << computeActor << ", task: " << taskId);
@@ -250,8 +250,8 @@ private:
         }
 
         CheckExecutionComplete();
-    }
-
+    } 
+ 
     void HandleExecute(TEvKqpExecuter::TEvStreamDataAck::TPtr& ev) {
         LOG_T("Recv stream data ack, seqNo: " << ev->Get()->Record.GetSeqNo()
             << ", freeSpace: " << ev->Get()->Record.GetFreeSpace()
@@ -369,7 +369,7 @@ private:
         }
     }
 
-private:
+private: 
     void FillReadInfo(TTaskMeta& taskMeta, ui64 itemsLimit, bool reverse,
         const TMaybe<::NKqpProto::TKqpPhyOpReadOlapRanges>& readOlapRange)
     {
@@ -658,37 +658,37 @@ private:
         LOG_D("Stage " << stageInfo.Id << " will be executed using " << taskCount << " tasks.");
     }
 
-    void BuildComputeTasks(TStageInfo& stageInfo) {
-        auto& stage = GetStage(stageInfo);
-
-        ui32 partitionsCount = 1;
-        for (ui32 inputIndex = 0; inputIndex < stage.InputsSize(); ++inputIndex) {
-            const auto& input = stage.GetInputs(inputIndex);
-
-            // Current assumptions:
-            // 1. `Broadcast` can not be the 1st stage input unless it's a single input
-            // 2. All stage's inputs, except 1st one, must be a `Broadcast` or `UnionAll`
-            if (inputIndex == 0) {
-                if (stage.InputsSize() > 1) {
-                    YQL_ENSURE(input.GetTypeCase() != NKqpProto::TKqpPhyConnection::kBroadcast);
-                }
-            } else {
-                switch (input.GetTypeCase()) {
-                    case NKqpProto::TKqpPhyConnection::kBroadcast:
+    void BuildComputeTasks(TStageInfo& stageInfo) { 
+        auto& stage = GetStage(stageInfo); 
+ 
+        ui32 partitionsCount = 1; 
+        for (ui32 inputIndex = 0; inputIndex < stage.InputsSize(); ++inputIndex) { 
+            const auto& input = stage.GetInputs(inputIndex); 
+ 
+            // Current assumptions: 
+            // 1. `Broadcast` can not be the 1st stage input unless it's a single input 
+            // 2. All stage's inputs, except 1st one, must be a `Broadcast` or `UnionAll` 
+            if (inputIndex == 0) { 
+                if (stage.InputsSize() > 1) { 
+                    YQL_ENSURE(input.GetTypeCase() != NKqpProto::TKqpPhyConnection::kBroadcast); 
+                } 
+            } else { 
+                switch (input.GetTypeCase()) { 
+                    case NKqpProto::TKqpPhyConnection::kBroadcast: 
                     case NKqpProto::TKqpPhyConnection::kHashShuffle:
-                    case NKqpProto::TKqpPhyConnection::kUnionAll:
+                    case NKqpProto::TKqpPhyConnection::kUnionAll: 
                     case NKqpProto::TKqpPhyConnection::kMerge:
-                        break;
-                    default:
-                        YQL_ENSURE(false, "Unexpected connection type: " << (ui32)input.GetTypeCase());
-                }
-            }
-
-            auto& originStageInfo = TasksGraph.GetStageInfo(TStageId(stageInfo.Id.TxId, input.GetStageIndex()));
-
-            switch (input.GetTypeCase()) {
+                        break; 
+                    default: 
+                        YQL_ENSURE(false, "Unexpected connection type: " << (ui32)input.GetTypeCase()); 
+                } 
+            } 
+ 
+            auto& originStageInfo = TasksGraph.GetStageInfo(TStageId(stageInfo.Id.TxId, input.GetStageIndex())); 
+ 
+            switch (input.GetTypeCase()) { 
                 case NKqpProto::TKqpPhyConnection::kHashShuffle: {
-                    partitionsCount = std::max(partitionsCount, (ui32)originStageInfo.Tasks.size() / 2);
+                    partitionsCount = std::max(partitionsCount, (ui32)originStageInfo.Tasks.size() / 2); 
                     ui32 nodes = ShardsOnNode.size();
                     if (nodes) {
                         // <= 2 tasks on node
@@ -696,39 +696,39 @@ private:
                     } else {
                         partitionsCount = std::min(partitionsCount, 24u);
                     }
-                    break;
-                }
-
+                    break; 
+                } 
+ 
                 case NKqpProto::TKqpPhyConnection::kMap:
-                    partitionsCount = originStageInfo.Tasks.size();
-                    break;
-
-                default:
+                    partitionsCount = originStageInfo.Tasks.size(); 
                     break;
-            }
-        }
-
-        for (ui32 i = 0; i < partitionsCount; ++i) {
+ 
+                default: 
+                    break; 
+            } 
+        } 
+ 
+        for (ui32 i = 0; i < partitionsCount; ++i) { 
             auto& task = TasksGraph.AddTask(stageInfo);
             LOG_D("Stage " << stageInfo.Id << " create compute task: " << task.Id);
-        }
-    }
-
+        } 
+    } 
+ 
     void Execute() {
         auto& funcRegistry = *AppData()->FunctionRegistry;
         NMiniKQL::TScopedAlloc alloc(TAlignedPagePoolCounters(), funcRegistry.SupportsSizedAllocators());
-        NMiniKQL::TTypeEnvironment typeEnv(alloc);
-
-        NMiniKQL::TMemoryUsageInfo memInfo("PrepareTasks");
-        NMiniKQL::THolderFactory holderFactory(alloc.Ref(), memInfo, &funcRegistry);
-
+        NMiniKQL::TTypeEnvironment typeEnv(alloc); 
+ 
+        NMiniKQL::TMemoryUsageInfo memInfo("PrepareTasks"); 
+        NMiniKQL::THolderFactory holderFactory(alloc.Ref(), memInfo, &funcRegistry); 
+ 
         auto& tx = Request.Transactions[0];
         for (ui32 stageIdx = 0; stageIdx < tx.Body.StagesSize(); ++stageIdx) {
             auto& stage = tx.Body.GetStages(stageIdx);
             auto& stageInfo = TasksGraph.GetStageInfo(TStageId(0, stageIdx));
-
+ 
             LOG_D("Stage " << stageInfo.Id << " AST: " << stage.GetProgramAst());
-
+ 
             Y_VERIFY_DEBUG(!stage.GetIsEffectsStage());
 
             if (stageInfo.Meta.ShardOperations.empty()) {
@@ -741,19 +741,19 @@ private:
                 BuildDatashardScanTasks(stageInfo, holderFactory, typeEnv);
             } else {
                 YQL_ENSURE(false, "Unexpected stage type " << (int) stageInfo.Meta.TableKind);
-            }
-
+            } 
+ 
             BuildKqpStageChannels(TasksGraph, TableKeys, stageInfo, TxId, AppData()->EnableKqpSpilling);
-        }
-
+        } 
+ 
         BuildKqpExecuterResults(tx.Body, Results);
         BuildKqpTaskGraphResultChannels(TasksGraph, tx.Body, 0);
 
-        TIssue validateIssue;
+        TIssue validateIssue; 
         if (!ValidateTasks(TasksGraph, EExecType::Scan, AppData()->EnableKqpSpilling, validateIssue)) {
             TBase::ReplyErrorAndDie(Ydb::StatusIds::INTERNAL_ERROR, validateIssue);
-            return;
-        }
+            return; 
+        } 
 
         // NodeId -> {Tasks}
         THashMap<ui64, TVector<NYql::NDqProto::TDqTask>> scanTasks;
@@ -761,28 +761,28 @@ private:
         ui32 nScanTasks = 0;
 
         TVector<NYql::NDqProto::TDqTask> computeTasks;
-
+ 
         for (auto& task : TasksGraph.GetTasks()) {
             auto& stageInfo = TasksGraph.GetStageInfo(task.StageId);
-            auto& stage = GetStage(stageInfo);
-
+            auto& stage = GetStage(stageInfo); 
+ 
             NYql::NDqProto::TDqTask taskDesc;
-            taskDesc.SetId(task.Id);
+            taskDesc.SetId(task.Id); 
             ActorIdToProto(SelfId(), taskDesc.MutableExecuter()->MutableActorId());
-
-            for (auto& input : task.Inputs) {
+ 
+            for (auto& input : task.Inputs) { 
                 FillInputDesc(*taskDesc.AddInputs(), input);
-            }
-
-            for (auto& output : task.Outputs) {
-                FillOutputDesc(*taskDesc.AddOutputs(), output);
-            }
-
-            taskDesc.MutableProgram()->CopyFrom(stage.GetProgram());
+            } 
+ 
+            for (auto& output : task.Outputs) { 
+                FillOutputDesc(*taskDesc.AddOutputs(), output); 
+            } 
+ 
+            taskDesc.MutableProgram()->CopyFrom(stage.GetProgram()); 
             taskDesc.SetStageId(task.StageId.StageId);
 
             PrepareKqpTaskParameters(stage, stageInfo, task, taskDesc, typeEnv, holderFactory);
-
+ 
             if (task.Meta.NodeId || stageInfo.Meta.IsSysView()) {
                 NKikimrTxDataShard::TKqpTransaction::TScanTaskMeta protoTaskMeta;
 
@@ -845,7 +845,7 @@ private:
                         YQL_ENSURE(task.Meta.ReadInfo.OlapProgram.Program.empty());
                     }
                 }
-
+ 
                 for (auto& read : *task.Meta.Reads) {
                     auto* protoReadMeta = protoTaskMeta.AddReads();
                     protoReadMeta->SetShardId(read.ShardId);
@@ -879,9 +879,9 @@ private:
                 }
             } else {
                 computeTasks.emplace_back(std::move(taskDesc));
-            }
-        }
-
+            } 
+        } 
+ 
         if (computeTasks.size() + nScanTasks > Request.MaxComputeActors) {
             LOG_N("Too many compute actors: computeTasks=" << computeTasks.size() << ", scanTasks=" << nScanTasks);
             TBase::ReplyErrorAndDie(Ydb::StatusIds::PRECONDITION_FAILED,
@@ -923,13 +923,13 @@ private:
             Database, UserToken, Deadline.GetOrElse(TInstant::Zero()), Request.StatsMode,
             Request.DisableLlvmForUdfStages, Request.LlvmEnabled, AppData()->EnableKqpSpilling, Request.RlPath);
         RegisterWithSameMailbox(planner);
-    }
-
+    } 
+ 
     void Finalize() {
         auto& response = *ResponseEv->Record.MutableResponse();
-
-        response.SetStatus(Ydb::StatusIds::SUCCESS);
-
+ 
+        response.SetStatus(Ydb::StatusIds::SUCCESS); 
+ 
         TKqpProtoBuilder protoBuilder(*AppData()->FunctionRegistry);
 
         for (auto& result : Results) {
@@ -940,11 +940,11 @@ private:
                 YQL_ENSURE(Results.size() == 1);
                 protoBuilder.BuildStream(result.Data, result.ItemType, result.ResultItemType.Get(), protoResult);
                 continue;
-            }
+            } 
 
             protoBuilder.BuildValue(result.Data, result.ItemType, protoResult);
-        }
-
+        } 
+ 
         if (Stats) {
             ReportEventElapsedTime();
 
@@ -956,13 +956,13 @@ private:
                 auto planWithStats = AddExecStatsToTxPlan(tx.GetPlan(), response.GetResult().GetStats());
                 response.MutableResult()->MutableStats()->AddTxPlansWithStats(planWithStats);
             }
-        }
-
+        } 
+ 
         LOG_D("Sending response to: " << Target);
         Send(Target, ResponseEv.release());
         PassAway();
-    }
-
+    } 
+ 
 private:
     void ReplyErrorAndDie(Ydb::StatusIds::StatusCode status,
         google::protobuf::RepeatedPtrField<Ydb::Issue::IssueMessage>* issues) override
@@ -989,11 +989,11 @@ private:
             );
             channelPair.second->Receive(ev, TActivationContext::AsActorContext());
         }
-
-        if (KqpShardsResolverId) {
-            Send(KqpShardsResolverId, new TEvents::TEvPoison);
-        }
-
+ 
+        if (KqpShardsResolverId) { 
+            Send(KqpShardsResolverId, new TEvents::TEvPoison); 
+        } 
+ 
         for (auto& [shardId, nodeId] : ShardIdToNodeId) {
             Send(TActivationContext::InterconnectProxy(nodeId), new TEvents::TEvUnsubscribe());
         }
@@ -1002,16 +1002,16 @@ private:
         Counters->Counters->ScanTxTotalTimeHistogram->Collect(totalTime.MilliSeconds());
 
         TBase::PassAway();
-    }
-
-private:
+    } 
+ 
+private: 
     bool CheckExecutionComplete() {
         if (PendingComputeActors.empty() && PendingComputeTasks.empty()) {
             Finalize();
             UpdateResourcesUsage(true);
-            return true;
-        }
-
+            return true; 
+        } 
+ 
         UpdateResourcesUsage(false);
 
         if (IsDebugLogEnabled()) {
@@ -1026,16 +1026,16 @@ private:
             LOG_D(sb);
         }
 
-        return false;
-    }
-
+        return false; 
+    } 
+ 
 public:
-    void FillEndpointDesc(NYql::NDqProto::TEndpoint& endpoint, const TTask& task) {
+    void FillEndpointDesc(NYql::NDqProto::TEndpoint& endpoint, const TTask& task) { 
         if (task.ComputeActorId) {
             ActorIdToProto(task.ComputeActorId, endpoint.MutableActorId());
-        }
-    }
-
+        } 
+    } 
+ 
     IActor* GetOrCreateChannelProxy(const TChannel& channel) {
         IActor* proxy;
 
@@ -1066,39 +1066,39 @@ public:
     }
 
     void FillChannelDesc(NYql::NDqProto::TChannel& channelDesc, const TChannel& channel) {
-        channelDesc.SetId(channel.Id);
+        channelDesc.SetId(channel.Id); 
         channelDesc.SetSrcTaskId(channel.SrcTask);
         channelDesc.SetDstTaskId(channel.DstTask);
-
+ 
         YQL_ENSURE(channel.SrcTask);
         FillEndpointDesc(*channelDesc.MutableSrcEndpoint(), TasksGraph.GetTask(channel.SrcTask));
-
+ 
         if (channel.DstTask) {
             FillEndpointDesc(*channelDesc.MutableDstEndpoint(), TasksGraph.GetTask(channel.DstTask));
-        } else {
+        } else { 
             auto proxy = GetOrCreateChannelProxy(channel);
             ActorIdToProto(proxy->SelfId(), channelDesc.MutableDstEndpoint()->MutableActorId());
-        }
-
+        } 
+ 
         channelDesc.SetIsPersistent(IsCrossShardChannel(TasksGraph, channel));
         channelDesc.SetInMemory(channel.InMemory);
-    }
-
-private:
+    } 
+ 
+private: 
     TVector<TKqpExecuterTxResult> Results;
     std::unordered_map<ui64, IActor*> ResultChannelProxies;
     THashSet<ui64> PendingComputeTasks; // Not started yet, waiting resources
     TMap<ui64, ui64> ShardIdToNodeId;
     TMap<ui64, TVector<ui64>> ShardsOnNode;
-};
-
-} // namespace
-
+}; 
+ 
+} // namespace 
+ 
 IActor* CreateKqpScanExecuter(IKqpGateway::TExecPhysicalRequest&& request, const TString& database,
     const TMaybe<TString>& userToken, TKqpRequestCounters::TPtr counters)
 {
     return new TKqpScanExecuter(std::move(request), database, userToken, counters);
-}
-
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/executer/kqp_shards_resolver.cpp b/ydb/core/kqp/executer/kqp_shards_resolver.cpp
index 506dfcf573..8e6bb74a25 100644
--- a/ydb/core/kqp/executer/kqp_shards_resolver.cpp
+++ b/ydb/core/kqp/executer/kqp_shards_resolver.cpp
@@ -32,13 +32,13 @@ constexpr ui32 MAX_RETRIES_COUNT = 3;
 class TKqpShardsResolver : public TActorBootstrapped<TKqpShardsResolver> {
 public:
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
-        return NKikimrServices::TActivity::KQP_SHARDS_RESOLVER;
+        return NKikimrServices::TActivity::KQP_SHARDS_RESOLVER; 
     }
 
 public:
-    TKqpShardsResolver(const TActorId& owner, ui64 txId, TSet<ui64>&& shardIds, float failRatio)
-        : Owner(owner)
-        , TxId(txId)
+    TKqpShardsResolver(const TActorId& owner, ui64 txId, TSet<ui64>&& shardIds, float failRatio) 
+        : Owner(owner) 
+        , TxId(txId) 
         , ShardIds(std::move(shardIds))
         , MaxFailedShards(ShardIds.size() * failRatio) {}
 
@@ -64,7 +64,7 @@ private:
             cFunc(TEvents::TSystem::Poison, PassAway);
             default: {
                 LOG_C("Unexpected event: " << ev->GetTypeRewrite());
-                ReplyErrorAndDie(Ydb::StatusIds::INTERNAL_ERROR, "Unexpected event while resolving shards");
+                ReplyErrorAndDie(Ydb::StatusIds::INTERNAL_ERROR, "Unexpected event while resolving shards"); 
             }
         }
     }
@@ -79,7 +79,7 @@ private:
 
             if (Result.size() + FailedTablets == ShardIds.size()) {
                 LOG_D("Done, success: " << Result.size() << ", failed: " << FailedTablets);
-                ReplyAndDie();
+                ReplyAndDie(); 
                 return;
             }
 
@@ -91,14 +91,14 @@ private:
             ++FailedTablets;
             if (FailedTablets > MaxFailedShards) {
                 LOG_W("Too many failed requests: " << FailedTablets << " (" << ShardIds.size() << ")");
-                ReplyErrorAndDie(Ydb::StatusIds::GENERIC_ERROR, TStringBuilder()
-                    << "Too many unresolved shards: " << FailedTablets);
+                ReplyErrorAndDie(Ydb::StatusIds::GENERIC_ERROR, TStringBuilder() 
+                    << "Too many unresolved shards: " << FailedTablets); 
                 return;
             }
 
             if (FailedTablets + Result.size() == ShardIds.size()) {
                 LOG_D("Done, success: " << Result.size() << ", failed: " << FailedTablets);
-                ReplyAndDie();
+                ReplyAndDie(); 
                 return;
             }
 
@@ -121,24 +121,24 @@ private:
         return resolveFlags;
     }
 
-    void ReplyErrorAndDie(Ydb::StatusIds::StatusCode status, TString&& message) {
-        auto replyEv = MakeHolder<TEvKqpExecuter::TEvShardsResolveStatus>();
-        replyEv->Status = status;
-        replyEv->Issues.AddIssue(TIssue(message));
-        Send(Owner, replyEv.Release());
-        PassAway();
-    }
-
-    void ReplyAndDie() {
-        auto replyEv = MakeHolder<TEvKqpExecuter::TEvShardsResolveStatus>();
-        replyEv->ShardNodes = std::move(Result);
-        replyEv->Unresolved = FailedTablets;
-        Send(Owner, replyEv.Release());
-        PassAway();
-    }
-
+    void ReplyErrorAndDie(Ydb::StatusIds::StatusCode status, TString&& message) { 
+        auto replyEv = MakeHolder<TEvKqpExecuter::TEvShardsResolveStatus>(); 
+        replyEv->Status = status; 
+        replyEv->Issues.AddIssue(TIssue(message)); 
+        Send(Owner, replyEv.Release()); 
+        PassAway(); 
+    } 
+ 
+    void ReplyAndDie() { 
+        auto replyEv = MakeHolder<TEvKqpExecuter::TEvShardsResolveStatus>(); 
+        replyEv->ShardNodes = std::move(Result); 
+        replyEv->Unresolved = FailedTablets; 
+        Send(Owner, replyEv.Release()); 
+        PassAway(); 
+    } 
+ 
 private:
-    const TActorId Owner;
+    const TActorId Owner; 
     const ui64 TxId;
     const TSet<ui64> ShardIds;
     const ui32 MaxFailedShards;
@@ -154,8 +154,8 @@ private:
 
 } // anonymous namespace
 
-IActor* CreateKqpShardsResolver(const TActorId& owner, ui64 txId, TSet<ui64>&& shardIds, float failRatio) {
-    return new TKqpShardsResolver(owner, txId, std::move(shardIds), failRatio);
+IActor* CreateKqpShardsResolver(const TActorId& owner, ui64 txId, TSet<ui64>&& shardIds, float failRatio) { 
+    return new TKqpShardsResolver(owner, txId, std::move(shardIds), failRatio); 
 }
 
 } // namespace NKikimr::NKqp
diff --git a/ydb/core/kqp/executer/kqp_shards_resolver.h b/ydb/core/kqp/executer/kqp_shards_resolver.h
index 8408d79c7b..0365a4ddb8 100644
--- a/ydb/core/kqp/executer/kqp_shards_resolver.h
+++ b/ydb/core/kqp/executer/kqp_shards_resolver.h
@@ -5,7 +5,7 @@
 
 namespace NKikimr::NKqp {
 
-NActors::IActor* CreateKqpShardsResolver(const NActors::TActorId& owner, ui64 txId, TSet<ui64>&& shardIds,
-    float failRatio);
+NActors::IActor* CreateKqpShardsResolver(const NActors::TActorId& owner, ui64 txId, TSet<ui64>&& shardIds, 
+    float failRatio); 
 
 } // namespace NKikimr::NKqp
diff --git a/ydb/core/kqp/executer/kqp_table_resolver.cpp b/ydb/core/kqp/executer/kqp_table_resolver.cpp
index 6d02c3d07c..f19352f276 100644
--- a/ydb/core/kqp/executer/kqp_table_resolver.cpp
+++ b/ydb/core/kqp/executer/kqp_table_resolver.cpp
@@ -22,18 +22,18 @@ namespace {
 class TKqpTableResolver : public TActorBootstrapped<TKqpTableResolver> {
 public:
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
-        return NKikimrServices::TActivity::KQP_TABLE_RESOLVER;
+        return NKikimrServices::TActivity::KQP_TABLE_RESOLVER; 
     }
 
-    TKqpTableResolver(const TActorId& owner, ui64 txId, TMaybe<TString> userToken,
-        const TVector<IKqpGateway::TPhysicalTxData>& transactions, TKqpTableKeys& tableKeys,
-        TKqpTasksGraph& tasksGraph)
-        : Owner(owner)
-        , TxId(txId)
+    TKqpTableResolver(const TActorId& owner, ui64 txId, TMaybe<TString> userToken, 
+        const TVector<IKqpGateway::TPhysicalTxData>& transactions, TKqpTableKeys& tableKeys, 
+        TKqpTasksGraph& tasksGraph) 
+        : Owner(owner) 
+        , TxId(txId) 
         , UserToken(userToken)
-        , Transactions(transactions)
-        , TableKeys(tableKeys)
-        , TasksGraph(tasksGraph) {}
+        , Transactions(transactions) 
+        , TableKeys(tableKeys) 
+        , TasksGraph(tasksGraph) {} 
 
     void Bootstrap() {
         ResolveTables();
@@ -55,7 +55,7 @@ private:
 
         const auto& entries = ev->Get()->Request->ResultSet;
         LOG_D("Resolved tables: " << entries.size());
-        YQL_ENSURE(entries.size() == TableKeys.Size());
+        YQL_ENSURE(entries.size() == TableKeys.Size()); 
 
         for (auto& entry : entries) {
             if (entry.Status != NSchemeCache::TSchemeCacheNavigate::EStatus::Ok) {
@@ -204,7 +204,7 @@ private:
 
             auto& stageInfo = DecodeStageInfo(entry.UserData);
             stageInfo.Meta.ShardKey = std::move(entry.KeyDescription);
-            stageInfo.Meta.ShardKind = std::move(entry.Kind);
+            stageInfo.Meta.ShardKind = std::move(entry.Kind); 
         }
 
         timer.reset();
@@ -223,10 +223,10 @@ private:
 private:
     // TODO: Get rid of ResolveTables & TableKeys, get table information from phy tx proto.
     void ResolveTables() {
-        for (auto& tx : Transactions) {
+        for (auto& tx : Transactions) { 
             for (auto& stage : tx.Body.GetStages()) {
                 for (auto& op : stage.GetTableOps()) {
-                    auto& table = TableKeys.GetOrAddTable(MakeTableId(op.GetTable()), op.GetTable().GetPath());
+                    auto& table = TableKeys.GetOrAddTable(MakeTableId(op.GetTable()), op.GetTable().GetPath()); 
                     for (auto& column : op.GetColumns()) {
                         table.Columns.emplace(column.GetName(), TKqpTableKeys::TColumn());
                     }
@@ -235,8 +235,8 @@ private:
         }
 
         auto request = MakeHolder<NSchemeCache::TSchemeCacheNavigate>();
-        request->ResultSet.reserve(TableKeys.Size());
-        for (auto& [tableId, table] : TableKeys.Get()) {
+        request->ResultSet.reserve(TableKeys.Size()); 
+        for (auto& [tableId, table] : TableKeys.Get()) { 
             NSchemeCache::TSchemeCacheNavigate::TEntry entry;
             entry.RequestType = NSchemeCache::TSchemeCacheNavigate::TEntry::ERequestType::ByTableId;
             entry.TableId = tableId;
@@ -254,12 +254,12 @@ private:
         FillKqpTasksGraphStages(TasksGraph, Transactions);
 
         auto request = MakeHolder<NSchemeCache::TSchemeCacheRequest>();
-        request->ResultSet.reserve(TasksGraph.GetStagesInfo().size());
+        request->ResultSet.reserve(TasksGraph.GetStagesInfo().size()); 
         if (UserToken) {
             request->UserToken = new NACLib::TUserToken(*UserToken);
         }
 
-        for (auto& pair : TasksGraph.GetStagesInfo()) {
+        for (auto& pair : TasksGraph.GetStagesInfo()) { 
             auto& stageInfo = pair.second;
             if (!stageInfo.Meta.ShardOperations.empty()) {
                 YQL_ENSURE(stageInfo.Meta.TableId);
@@ -298,7 +298,7 @@ private:
         auto range = GetFullRange(tableKey.KeyColumnTypes.size());
 
         return MakeHolder<TKeyDesc>(table, range.ToTableRange(), operation, tableKey.KeyColumnTypes,
-            TVector<TKeyDesc::TColumnOp>{});
+            TVector<TKeyDesc::TColumnOp>{}); 
     }
 
     static TSerializedTableRange GetFullRange(ui32 columnsCount) {
@@ -319,13 +319,13 @@ private:
 private:
     void UnexpectedEvent(const TString& state, ui32 eventType) {
         LOG_C("TKqpTableResolver, unexpected event: " << eventType << ", at state:" << state << ", self: " << SelfId());
-        auto issue = NYql::YqlIssue({}, NYql::TIssuesIds::UNEXPECTED, "Internal error while executing transaction.");
-        ReplyErrorAndDie(Ydb::StatusIds::INTERNAL_ERROR, std::move(issue));
+        auto issue = NYql::YqlIssue({}, NYql::TIssuesIds::UNEXPECTED, "Internal error while executing transaction."); 
+        ReplyErrorAndDie(Ydb::StatusIds::INTERNAL_ERROR, std::move(issue)); 
     }
 
     void ReplyErrorAndDie(Ydb::StatusIds::StatusCode status, TIssue&& issue) {
         auto replyEv = std::make_unique<TEvKqpExecuter::TEvTableResolveStatus>();
-        replyEv->Status = status;
+        replyEv->Status = status; 
         replyEv->Issues.AddIssue(std::move(issue));
         replyEv->CpuTime = CpuTime;
         Send(Owner, replyEv.release());
@@ -333,15 +333,15 @@ private:
     }
 
 private:
-    const TActorId Owner;
+    const TActorId Owner; 
     const ui64 TxId;
     const TMaybe<TString> UserToken;
-    const TVector<IKqpGateway::TPhysicalTxData>& Transactions;
-    TKqpTableKeys& TableKeys;
-
-    // TODO: TableResolver should not populate TasksGraph as it's not related to its job (bad API).
-    TKqpTasksGraph& TasksGraph;
-
+    const TVector<IKqpGateway::TPhysicalTxData>& Transactions; 
+    TKqpTableKeys& TableKeys; 
+ 
+    // TODO: TableResolver should not populate TasksGraph as it's not related to its job (bad API). 
+    TKqpTasksGraph& TasksGraph; 
+ 
     bool ShouldTerminate = false;
     TMaybe<ui32> GotUnexpectedEvent;
     TDuration CpuTime;
@@ -349,9 +349,9 @@ private:
 
 } // anonymous namespace
 
-NActors::IActor* CreateKqpTableResolver(const TActorId& owner, ui64 txId, TMaybe<TString> userToken,
-    const TVector<IKqpGateway::TPhysicalTxData>& transactions, TKqpTableKeys& tableKeys, TKqpTasksGraph& tasksGraph) {
-    return new TKqpTableResolver(owner, txId, userToken, transactions, tableKeys, tasksGraph);
+NActors::IActor* CreateKqpTableResolver(const TActorId& owner, ui64 txId, TMaybe<TString> userToken, 
+    const TVector<IKqpGateway::TPhysicalTxData>& transactions, TKqpTableKeys& tableKeys, TKqpTasksGraph& tasksGraph) { 
+    return new TKqpTableResolver(owner, txId, userToken, transactions, tableKeys, tasksGraph); 
 }
 
 } // namespace NKikimr::NKqp
diff --git a/ydb/core/kqp/executer/kqp_table_resolver.h b/ydb/core/kqp/executer/kqp_table_resolver.h
index e9618cf41d..6972d0bdeb 100644
--- a/ydb/core/kqp/executer/kqp_table_resolver.h
+++ b/ydb/core/kqp/executer/kqp_table_resolver.h
@@ -1,10 +1,10 @@
 #pragma once
 
-#include "kqp_tasks_graph.h"
+#include "kqp_tasks_graph.h" 
 
 namespace NKikimr::NKqp {
 
-NActors::IActor* CreateKqpTableResolver(const TActorId& owner, ui64 txId, TMaybe<TString> userToken,
-    const TVector<IKqpGateway::TPhysicalTxData>& transactions, TKqpTableKeys& tableKeys, TKqpTasksGraph& tasksGraph);
+NActors::IActor* CreateKqpTableResolver(const TActorId& owner, ui64 txId, TMaybe<TString> userToken, 
+    const TVector<IKqpGateway::TPhysicalTxData>& transactions, TKqpTableKeys& tableKeys, TKqpTasksGraph& tasksGraph); 
 
 } // namespace NKikimr::NKqp
diff --git a/ydb/core/kqp/executer/kqp_tasks_graph.cpp b/ydb/core/kqp/executer/kqp_tasks_graph.cpp
index 1ccfa26047..f76f25fed8 100644
--- a/ydb/core/kqp/executer/kqp_tasks_graph.cpp
+++ b/ydb/core/kqp/executer/kqp_tasks_graph.cpp
@@ -1,10 +1,10 @@
-#include "kqp_tasks_graph.h"
+#include "kqp_tasks_graph.h" 
 
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/protos/tx_datashard.pb.h>
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/tx/datashard/range_ops.h>
-
+ 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 
 #include <library/cpp/actors/core/log.h>
@@ -18,11 +18,11 @@ using namespace NYql::NNodes;
 
 // #define DBG_TRACE
 
-void LogStage(const NActors::TActorContext& ctx, const TStageInfo& stageInfo) {
-    // TODO: Print stage details, including input types and program.
+void LogStage(const NActors::TActorContext& ctx, const TStageInfo& stageInfo) { 
+    // TODO: Print stage details, including input types and program. 
     LOG_DEBUG_S(ctx, NKikimrServices::KQP_EXECUTER, "StageInfo: StageId #" << stageInfo.Id
         << ", InputsCount: " << stageInfo.InputsCount
-        << ", OutputsCount: " << stageInfo.OutputsCount);
+        << ", OutputsCount: " << stageInfo.OutputsCount); 
 }
 
 bool HasReads(const TStageInfo& stageInfo) {
@@ -67,7 +67,7 @@ void FillKqpTasksGraphStages(TKqpTasksGraph& tasksGraph, const TVector<IKqpGatew
                 switch (op.GetTypeCase()) {
                     case NKqpProto::TKqpPhyTableOperation::kReadRange:
                     case NKqpProto::TKqpPhyTableOperation::kReadRanges:
-                    case NKqpProto::TKqpPhyTableOperation::kReadOlapRange:
+                    case NKqpProto::TKqpPhyTableOperation::kReadOlapRange: 
                     case NKqpProto::TKqpPhyTableOperation::kLookup:
                         stageInfo.Meta.ShardOperations.insert(TKeyDesc::ERowOperation::Read);
                         break;
@@ -116,7 +116,7 @@ void BuildKqpTaskGraphResultChannels(TKqpTasksGraph& tasksGraph, const NKqpProto
     }
 }
 
-void BuildMapShardChannels(TKqpTasksGraph& graph, const TStageInfo& stageInfo, ui32 inputIndex,
+void BuildMapShardChannels(TKqpTasksGraph& graph, const TStageInfo& stageInfo, ui32 inputIndex, 
     const TStageInfo& inputStageInfo, ui32 outputIndex, bool enableSpilling, const TChannelLogFunc& logFunc)
 {
     YQL_ENSURE(stageInfo.Tasks.size() == inputStageInfo.Tasks.size());
@@ -153,7 +153,7 @@ void BuildMapShardChannels(TKqpTasksGraph& graph, const TStageInfo& stageInfo, u
     }
 }
 
-void BuildShuffleShardChannels(TKqpTasksGraph& graph, const TStageInfo& stageInfo, ui32 inputIndex,
+void BuildShuffleShardChannels(TKqpTasksGraph& graph, const TStageInfo& stageInfo, ui32 inputIndex, 
     const TStageInfo& inputStageInfo, ui32 outputIndex, const TKqpTableKeys& tableKeys, bool enableSpilling,
     const TChannelLogFunc& logFunc)
 {
@@ -169,7 +169,7 @@ void BuildShuffleShardChannels(TKqpTasksGraph& graph, const TStageInfo& stageInf
         auto& originTask = graph.GetTask(originTaskId);
         auto& taskOutput = originTask.Outputs[outputIndex];
         taskOutput.Type = TKqpTaskOutputType::ShardRangePartition;
-        taskOutput.KeyColumns = table.KeyColumns;
+        taskOutput.KeyColumns = table.KeyColumns; 
 
         for (auto& targetTaskId : stageInfo.Tasks) {
             auto& targetTask = graph.GetTask(targetTaskId);
@@ -293,13 +293,13 @@ bool IsCrossShardChannel(TKqpTasksGraph& tasksGraph, const TChannel& channel) {
     return targetShard != tasksGraph.GetTask(channel.SrcTask).Meta.ShardId;
 }
 
-const NKqpProto::TKqpPhyStage& GetStage(const TStageInfo& stageInfo) {
-    auto& txBody = stageInfo.Meta.Tx.Body;
-    YQL_ENSURE(stageInfo.Id.StageId < txBody.StagesSize());
-
-    return txBody.GetStages(stageInfo.Id.StageId);
-}
-
+const NKqpProto::TKqpPhyStage& GetStage(const TStageInfo& stageInfo) { 
+    auto& txBody = stageInfo.Meta.Tx.Body; 
+    YQL_ENSURE(stageInfo.Id.StageId < txBody.StagesSize()); 
+ 
+    return txBody.GetStages(stageInfo.Id.StageId); 
+} 
+ 
 void TShardKeyRanges::AddPoint(TSerializedCellVec&& point) {
     if (!IsFullRange()) {
         Ranges.emplace_back(std::move(point));
diff --git a/ydb/core/kqp/executer/kqp_tasks_graph.h b/ydb/core/kqp/executer/kqp_tasks_graph.h
index 7c356ab623..e2fc3d2823 100644
--- a/ydb/core/kqp/executer/kqp_tasks_graph.h
+++ b/ydb/core/kqp/executer/kqp_tasks_graph.h
@@ -19,15 +19,15 @@ namespace NKqp {
 
 struct TTransaction : private TMoveOnly {
     NYql::NNodes::TKqpPhysicalTx Node;
-    TKqpParamsMap Params;
+    TKqpParamsMap Params; 
 
-    inline TTransaction(const NYql::NNodes::TKqpPhysicalTx& node, TKqpParamsMap&& params)
+    inline TTransaction(const NYql::NNodes::TKqpPhysicalTx& node, TKqpParamsMap&& params) 
         : Node(node)
         , Params(std::move(params)) {}
 };
 
 struct TStageInfoMeta {
-    const IKqpGateway::TPhysicalTxData& Tx;
+    const IKqpGateway::TPhysicalTxData& Tx; 
 
     TTableId TableId;
     TString TablePath;
@@ -37,9 +37,9 @@ struct TStageInfoMeta {
 
     THashSet<TKeyDesc::ERowOperation> ShardOperations;
     THolder<TKeyDesc> ShardKey;
-    NSchemeCache::TSchemeCacheRequest::EKind ShardKind = NSchemeCache::TSchemeCacheRequest::EKind::KindUnknown;
-
-    explicit TStageInfoMeta(const IKqpGateway::TPhysicalTxData& tx)
+    NSchemeCache::TSchemeCacheRequest::EKind ShardKind = NSchemeCache::TSchemeCacheRequest::EKind::KindUnknown; 
+ 
+    explicit TStageInfoMeta(const IKqpGateway::TPhysicalTxData& tx) 
         : Tx(tx)
         , TableKind(ETableKind::Unknown)
     {}
@@ -156,14 +156,14 @@ struct TKqpTaskOutputType {
     };
 };
 
-const NKqpProto::TKqpPhyStage& GetStage(const TStageInfo& stageInfo);
-
-void LogStage(const NActors::TActorContext& ctx, const TStageInfo& stageInfo);
-
+const NKqpProto::TKqpPhyStage& GetStage(const TStageInfo& stageInfo); 
+ 
+void LogStage(const NActors::TActorContext& ctx, const TStageInfo& stageInfo); 
+ 
 bool HasReads(const TStageInfo& stageInfo);
 bool HasWrites(const TStageInfo& stageInfo);
 
 bool IsCrossShardChannel(TKqpTasksGraph& tasksGraph, const NYql::NDq::TChannel& channel);
-
+ 
 } // namespace NKqp
 } // namespace NKikimr
diff --git a/ydb/core/kqp/executer/kqp_tasks_validate.cpp b/ydb/core/kqp/executer/kqp_tasks_validate.cpp
index dea7056ff0..a26b5c646b 100644
--- a/ydb/core/kqp/executer/kqp_tasks_validate.cpp
+++ b/ydb/core/kqp/executer/kqp_tasks_validate.cpp
@@ -1,108 +1,108 @@
-#include "kqp_tasks_validate.h"
-
-using namespace NYql;
-
-namespace NKikimr {
-namespace NKqp {
-
-namespace {
-
-class TTasksValidator {
-    using TGraphType = TKqpTasksGraph;
+#include "kqp_tasks_validate.h" 
+ 
+using namespace NYql; 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+namespace { 
+ 
+class TTasksValidator { 
+    using TGraphType = TKqpTasksGraph; 
     using TStageType = TGraphType::TStageInfoType;
-    using TTaskType = TGraphType::TTaskType;
-    using TInputType = TGraphType::TTaskType::TInputType;
-    using TOutputType = TGraphType::TTaskType::TOutputType;
-
-public:
+    using TTaskType = TGraphType::TTaskType; 
+    using TInputType = TGraphType::TTaskType::TInputType; 
+    using TOutputType = TGraphType::TTaskType::TOutputType; 
+ 
+public: 
     TTasksValidator(const TGraphType& tasksGraph, const EExecType& execType, bool enableSpilling)
-        : TasksGraph(tasksGraph)
+        : TasksGraph(tasksGraph) 
         , ExecType(execType)
         , EnableSpilling(enableSpilling) {}
-
-    void Validate() {
-        for (auto& task : TasksGraph.GetTasks()) {
-            ValidateTask(task);
-        }
-    }
-
-private:
-    void ValidateChannel(ui64 channelId) {
-        auto& channel = TasksGraph.GetChannel(channelId);
-
-        YQL_ENSURE(channel.SrcTask);
-        auto& srcTask = TasksGraph.GetTask(channel.SrcTask);
-
-        if (channel.DstTask) {
-            auto& dstTask = TasksGraph.GetTask(channel.DstTask);
-            if (IsDataExec() && dstTask.Meta.ShardId) {
-                YQL_ENSURE(srcTask.Meta.ShardId, "Invalid channel from non-shard task to shard task"
-                    << ", channelId: " << channelId
-                    << ", srcTaskId: " << channel.SrcTask
-                    << ", dstTaskId: " << channel.DstTask);
-            }
-        }
+ 
+    void Validate() { 
+        for (auto& task : TasksGraph.GetTasks()) { 
+            ValidateTask(task); 
+        } 
+    } 
+ 
+private: 
+    void ValidateChannel(ui64 channelId) { 
+        auto& channel = TasksGraph.GetChannel(channelId); 
+ 
+        YQL_ENSURE(channel.SrcTask); 
+        auto& srcTask = TasksGraph.GetTask(channel.SrcTask); 
+ 
+        if (channel.DstTask) { 
+            auto& dstTask = TasksGraph.GetTask(channel.DstTask); 
+            if (IsDataExec() && dstTask.Meta.ShardId) { 
+                YQL_ENSURE(srcTask.Meta.ShardId, "Invalid channel from non-shard task to shard task" 
+                    << ", channelId: " << channelId 
+                    << ", srcTaskId: " << channel.SrcTask 
+                    << ", dstTaskId: " << channel.DstTask); 
+            } 
+        } 
 
         if (!EnableSpilling) {
             YQL_ENSURE(channel.InMemory, "With spilling off, all channels should be stored in memory only. "
                 << "Not InMemory channelId: " << channelId);
         }
-    }
-
-    void ValidateInput(const TInputType& input) {
-        for (ui64 channelId : input.Channels) {
-            ValidateChannel(channelId);
-        }
-    }
-
-    void ValidateOutput(const TOutputType& output) {
-        for (ui64 channelId : output.Channels) {
-            ValidateChannel(channelId);
-        }
-    }
-
-    void ValidateTask(const TTaskType& task) {
-        for (auto& input : task.Inputs) {
-            ValidateInput(input);
-        }
-
-        for (auto& output : task.Outputs) {
-            ValidateOutput(output);
-        }
-
-        if (task.Meta.Writes) {
-            YQL_ENSURE(task.Outputs.size() == 1, "Read-write tasks should have single output.");
-        }
-
+    } 
+ 
+    void ValidateInput(const TInputType& input) { 
+        for (ui64 channelId : input.Channels) { 
+            ValidateChannel(channelId); 
+        } 
+    } 
+ 
+    void ValidateOutput(const TOutputType& output) { 
+        for (ui64 channelId : output.Channels) { 
+            ValidateChannel(channelId); 
+        } 
+    } 
+ 
+    void ValidateTask(const TTaskType& task) { 
+        for (auto& input : task.Inputs) { 
+            ValidateInput(input); 
+        } 
+ 
+        for (auto& output : task.Outputs) { 
+            ValidateOutput(output); 
+        } 
+
+        if (task.Meta.Writes) { 
+            YQL_ENSURE(task.Outputs.size() == 1, "Read-write tasks should have single output."); 
+        } 
+ 
         const auto& stageInfo = TasksGraph.GetStageInfo(task.StageId);
         if (stageInfo.Meta.TableKind == ETableKind::Olap) {
             YQL_ENSURE(task.Meta.Reads->size() == 1,
                        "OLAP scan task must read exactly 1 range from 1 columnshard");
             YQL_ENSURE(!task.Meta.Writes, "OLAP writes are not supported yet");
         }
-    }
-
-    bool IsDataExec() {
-        return ExecType == EExecType::Data;
-    }
-
-private:
-    const TGraphType& TasksGraph;
-    EExecType ExecType;
+    } 
+ 
+    bool IsDataExec() { 
+        return ExecType == EExecType::Data; 
+    } 
+ 
+private: 
+    const TGraphType& TasksGraph; 
+    EExecType ExecType; 
     bool EnableSpilling;
-};
-
-} // namespace
-
+}; 
+ 
+} // namespace 
+ 
 bool ValidateTasks(const TKqpTasksGraph& tasksGraph, const EExecType& execType, bool enableSpilling, NYql::TIssue& issue) {
-    try {
+    try { 
         TTasksValidator(tasksGraph, execType, enableSpilling).Validate();
-        return true;
-    } catch (const TYqlPanic& e) {
-        issue = YqlIssue({}, TIssuesIds::DEFAULT_ERROR, e.what());
-        return false;
-    }
-}
-
-} // namespace NKqp
-} // namespace NKikimr
+        return true; 
+    } catch (const TYqlPanic& e) { 
+        issue = YqlIssue({}, TIssuesIds::DEFAULT_ERROR, e.what()); 
+        return false; 
+    } 
+} 
+ 
+} // namespace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/executer/kqp_tasks_validate.h b/ydb/core/kqp/executer/kqp_tasks_validate.h
index f7fd4d1672..0aefd4b615 100644
--- a/ydb/core/kqp/executer/kqp_tasks_validate.h
+++ b/ydb/core/kqp/executer/kqp_tasks_validate.h
@@ -1,12 +1,12 @@
-#pragma once
-
+#pragma once 
+ 
 #include "kqp_executer_impl.h"
-#include "kqp_tasks_graph.h"
-
-namespace NKikimr {
-namespace NKqp {
-
+#include "kqp_tasks_graph.h" 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
 bool ValidateTasks(const TKqpTasksGraph& tasksGraph, const EExecType& execType, bool enableSpilling, NYql::TIssue& issue);
-
-} // namespace NKqp
-} // namespace NKikimr
+ 
+} // namespace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/executer/ut/kqp_executer_ut.cpp b/ydb/core/kqp/executer/ut/kqp_executer_ut.cpp
index 3148a2ec59..ac05f5c3dc 100644
--- a/ydb/core/kqp/executer/ut/kqp_executer_ut.cpp
+++ b/ydb/core/kqp/executer/ut/kqp_executer_ut.cpp
@@ -4,151 +4,151 @@
 #include <ydb/core/kqp/host/kqp_host.h>
 #include <ydb/core/ydb_convert/ydb_convert.h>
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
+ 
 #include <ydb/library/yql/dq/common/dq_value.h>
 #include <ydb/library/yql/core/services/mounts/yql_mounts.h>
-
+ 
 #include <library/cpp/protobuf/util/pb_io.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-using namespace NYdb::NTable;
-
-namespace {
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+using namespace NYdb::NTable; 
+ 
+namespace { 
+ 
 [[maybe_unused]]
-NKqpProto::TKqpPhyTx BuildTxPlan(const TString& sql, TIntrusivePtr<IKqpGateway> gateway,
-    const TKikimrConfiguration::TPtr& config)
-{
-    auto cluster = TString(DefaultKikimrClusterName);
-
-    TExprContext moduleCtx;
-    IModuleResolver::TPtr moduleResolver;
-    UNIT_ASSERT(GetYqlDefaultModuleResolver(moduleCtx, moduleResolver));
-
+NKqpProto::TKqpPhyTx BuildTxPlan(const TString& sql, TIntrusivePtr<IKqpGateway> gateway, 
+    const TKikimrConfiguration::TPtr& config) 
+{ 
+    auto cluster = TString(DefaultKikimrClusterName); 
+ 
+    TExprContext moduleCtx; 
+    IModuleResolver::TPtr moduleResolver; 
+    UNIT_ASSERT(GetYqlDefaultModuleResolver(moduleCtx, moduleResolver)); 
+ 
     auto qp = CreateKqpHost(gateway, cluster, "/Root", config, moduleResolver);
-    auto result = qp->SyncPrepareDataQuery(sql, IKqpHost::TPrepareSettings());
-    result.Issues().PrintTo(Cerr);
-    UNIT_ASSERT(result.Success());
-
-    auto& phyQuery = result.PreparedQuery.GetPhysicalQuery();
-    UNIT_ASSERT(phyQuery.TransactionsSize() == 1);
-    return phyQuery.GetTransactions(0);
-}
-
+    auto result = qp->SyncPrepareDataQuery(sql, IKqpHost::TPrepareSettings()); 
+    result.Issues().PrintTo(Cerr); 
+    UNIT_ASSERT(result.Success()); 
+ 
+    auto& phyQuery = result.PreparedQuery.GetPhysicalQuery(); 
+    UNIT_ASSERT(phyQuery.TransactionsSize() == 1); 
+    return phyQuery.GetTransactions(0); 
+} 
+ 
 [[maybe_unused]]
-TIntrusivePtr<IKqpGateway> MakeIcGateway(const TKikimrRunner& kikimr) {
-    auto actorSystem = kikimr.GetTestServer().GetRuntime()->GetAnyNodeActorSystem();
+TIntrusivePtr<IKqpGateway> MakeIcGateway(const TKikimrRunner& kikimr) { 
+    auto actorSystem = kikimr.GetTestServer().GetRuntime()->GetAnyNodeActorSystem(); 
     return CreateKikimrIcGateway(TString(DefaultKikimrClusterName), "/Root", TKqpGatewaySettings(),
         actorSystem, kikimr.GetTestServer().GetRuntime()->GetNodeId(0), TAlignedPagePoolCounters());
-}
-
+} 
+ 
 [[maybe_unused]]
-TKikimrParamsMap GetParamsMap(const NYdb::TParams& params) {
-    TKikimrParamsMap paramsMap;
-
-    auto paramValues = params.GetValues();
-    for (auto& pair : paramValues) {
+TKikimrParamsMap GetParamsMap(const NYdb::TParams& params) { 
+    TKikimrParamsMap paramsMap; 
+ 
+    auto paramValues = params.GetValues(); 
+    for (auto& pair : paramValues) { 
         Ydb::TypedValue protoParam;
-        protoParam.mutable_type()->CopyFrom(NYdb::TProtoAccessor::GetProto(pair.second.GetType()));
-        protoParam.mutable_value()->CopyFrom(NYdb::TProtoAccessor::GetProto(pair.second));
-
-        NKikimrMiniKQL::TParams mkqlParam;
+        protoParam.mutable_type()->CopyFrom(NYdb::TProtoAccessor::GetProto(pair.second.GetType())); 
+        protoParam.mutable_value()->CopyFrom(NYdb::TProtoAccessor::GetProto(pair.second)); 
+ 
+        NKikimrMiniKQL::TParams mkqlParam; 
         ConvertYdbTypeToMiniKQLType(protoParam.type(), *mkqlParam.MutableType());
         ConvertYdbValueToMiniKQLValue(protoParam.type(), protoParam.value(), *mkqlParam.MutableValue());
-
-        paramsMap.insert(std::make_pair(pair.first, mkqlParam));
-    }
-
-    return paramsMap;
-}
-
+ 
+        paramsMap.insert(std::make_pair(pair.first, mkqlParam)); 
+    } 
+ 
+    return paramsMap; 
+} 
+ 
 [[maybe_unused]]
-TKqpParamsRefMap GetParamRefsMap(const TKikimrParamsMap& paramsMap) {
-    TKqpParamsRefMap refsMap;
-
-    for (auto& pair : paramsMap) {
+TKqpParamsRefMap GetParamRefsMap(const TKikimrParamsMap& paramsMap) { 
+    TKqpParamsRefMap refsMap; 
+ 
+    for (auto& pair : paramsMap) { 
         refsMap.emplace(std::make_pair(pair.first, NDq::TMkqlValueRef(pair.second)));
-    }
-
-    return refsMap;
-}
-
-} // namespace
-
-Y_UNIT_TEST_SUITE(KqpExecuter) {
-    // TODO: Test shard write shuffle.
-    /*
-    Y_UNIT_TEST(BlindWriteDistributed) {
-        TKikimrRunner kikimr;
-        auto gateway = MakeIcGateway(kikimr);
-
-        TExprContext ctx;
-        auto tx = BuildTxPlan(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-            DECLARE $items AS 'List<Struct<Key:Uint64?, Text:String?>>';
-
-            $itemsSource = (
-                SELECT Item.Key AS Key, Item.Text AS Text
-                FROM (SELECT $items AS List) FLATTEN BY List AS Item
-            );
-
-            UPSERT INTO [Root/EightShard]
-            SELECT * FROM $itemsSource;
-        )", gateway, ctx);
-
-        LogTxPlan(kikimr, tx);
-
+    } 
+ 
+    return refsMap; 
+} 
+ 
+} // namespace 
+ 
+Y_UNIT_TEST_SUITE(KqpExecuter) { 
+    // TODO: Test shard write shuffle. 
+    /* 
+    Y_UNIT_TEST(BlindWriteDistributed) { 
+        TKikimrRunner kikimr; 
+        auto gateway = MakeIcGateway(kikimr); 
+ 
+        TExprContext ctx; 
+        auto tx = BuildTxPlan(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+            DECLARE $items AS 'List<Struct<Key:Uint64?, Text:String?>>'; 
+ 
+            $itemsSource = ( 
+                SELECT Item.Key AS Key, Item.Text AS Text 
+                FROM (SELECT $items AS List) FLATTEN BY List AS Item 
+            ); 
+ 
+            UPSERT INTO [Root/EightShard] 
+            SELECT * FROM $itemsSource; 
+        )", gateway, ctx); 
+ 
+        LogTxPlan(kikimr, tx); 
+ 
         auto db = kikimr.GetTableClient();
-        auto params = db.GetParamsBuilder()
-            .AddParam("$items")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                    .AddMember("Key")
-                        .OptionalUint64(205)
-                    .AddMember("Text")
-                        .OptionalString("New")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                    .AddMember("Key")
-                        .OptionalUint64(505)
-                    .AddMember("Text")
-                        .OptionalString("New")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .Build();
-
-        auto paramsMap = GetParamsMap(std::move(params));
-
-        IKqpGateway::TExecPhysicalRequest request;
-        request.Transactions.emplace_back(tx.Ref(), GetParamRefsMap(paramsMap));
-
-        auto txResult = gateway->ExecutePhysical(std::move(request)).GetValueSync();
-        UNIT_ASSERT(txResult.Success());
-
-        UNIT_ASSERT_VALUES_EQUAL(txResult.ExecuterResult.GetStats().GetAffectedShards(), 2);
-
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        auto result = session.ExecuteDataQuery(R"(
-            SELECT * FROM [Root/EightShard] WHERE Text = "New" ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"(
-            [
-                [#;[205u];["New"]];
-                [#;[505u];["New"]]
-            ]
-        )", NYdb::FormatResultSetYson(result.GetResultSet(0)));
-    }
-    */
-}
-
-} // namspace NKqp
-} // namespace NKikimr
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$items") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Key") 
+                        .OptionalUint64(205) 
+                    .AddMember("Text") 
+                        .OptionalString("New") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Key") 
+                        .OptionalUint64(505) 
+                    .AddMember("Text") 
+                        .OptionalString("New") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        auto paramsMap = GetParamsMap(std::move(params)); 
+ 
+        IKqpGateway::TExecPhysicalRequest request; 
+        request.Transactions.emplace_back(tx.Ref(), GetParamRefsMap(paramsMap)); 
+ 
+        auto txResult = gateway->ExecutePhysical(std::move(request)).GetValueSync(); 
+        UNIT_ASSERT(txResult.Success()); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(txResult.ExecuterResult.GetStats().GetAffectedShards(), 2); 
+ 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        auto result = session.ExecuteDataQuery(R"( 
+            SELECT * FROM [Root/EightShard] WHERE Text = "New" ORDER BY Key; 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"( 
+            [ 
+                [#;[205u];["New"]]; 
+                [#;[505u];["New"]] 
+            ] 
+        )", NYdb::FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+    */ 
+} 
+ 
+} // namspace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/executer/ut/ya.make b/ydb/core/kqp/executer/ut/ya.make
index 7a2024f9bd..1864a51320 100644
--- a/ydb/core/kqp/executer/ut/ya.make
+++ b/ydb/core/kqp/executer/ut/ya.make
@@ -1,28 +1,28 @@
 UNITTEST_FOR(ydb/core/kqp)
-
+ 
 OWNER(
     spuchin
     g:kikimr
 )
-
-FORK_SUBTESTS()
-
-IF (SANITIZER_TYPE OR WITH_VALGRIND)
-    SIZE(MEDIUM)
-ENDIF()
-
-SRCS(
+ 
+FORK_SUBTESTS() 
+ 
+IF (SANITIZER_TYPE OR WITH_VALGRIND) 
+    SIZE(MEDIUM) 
+ENDIF() 
+ 
+SRCS( 
     # kqp_executer_ut.cpp
-)
-
-PEERDIR(
+) 
+ 
+PEERDIR( 
     ydb/core/kqp
     ydb/core/kqp/common
     ydb/core/kqp/host
     ydb/core/kqp/ut/common
     ydb/public/sdk/cpp/client/ydb_proto
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-END()
+END() 
diff --git a/ydb/core/kqp/executer/ya.make b/ydb/core/kqp/executer/ya.make
index 3db082d5d0..9a65913190 100644
--- a/ydb/core/kqp/executer/ya.make
+++ b/ydb/core/kqp/executer/ya.make
@@ -1,11 +1,11 @@
-LIBRARY()
-
-OWNER(
-    spuchin
-    g:kikimr
-)
-
-SRCS(
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
+    g:kikimr 
+) 
+ 
+SRCS( 
     kqp_data_executer.cpp
     kqp_scan_executer.cpp
     kqp_executer_impl.cpp
@@ -18,11 +18,11 @@ SRCS(
     kqp_shards_resolver.cpp
     kqp_result_channel.cpp
     kqp_table_resolver.cpp
-    kqp_tasks_graph.cpp
-    kqp_tasks_validate.cpp
-)
-
-PEERDIR(
+    kqp_tasks_graph.cpp 
+    kqp_tasks_validate.cpp 
+) 
+ 
+PEERDIR( 
     library/cpp/actors/core
     ydb/core/actorlib_impl
     ydb/core/base
@@ -38,8 +38,8 @@ PEERDIR(
     ydb/library/yql/dq/actors/compute
     ydb/library/yql/dq/runtime
     ydb/library/yql/dq/tasks
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
 END()
diff --git a/ydb/core/kqp/expr_nodes/kqp_expr_nodes.cpp b/ydb/core/kqp/expr_nodes/kqp_expr_nodes.cpp
index 50a65907c5..af37dfe156 100644
--- a/ydb/core/kqp/expr_nodes/kqp_expr_nodes.cpp
+++ b/ydb/core/kqp/expr_nodes/kqp_expr_nodes.cpp
@@ -1 +1 @@
-#include "kqp_expr_nodes.h"
+#include "kqp_expr_nodes.h" 
diff --git a/ydb/core/kqp/expr_nodes/kqp_expr_nodes.h b/ydb/core/kqp/expr_nodes/kqp_expr_nodes.h
index 36184799d5..ae4b729fb9 100644
--- a/ydb/core/kqp/expr_nodes/kqp_expr_nodes.h
+++ b/ydb/core/kqp/expr_nodes/kqp_expr_nodes.h
@@ -1,15 +1,15 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.gen.h>
-
+ 
 #include <ydb/library/yql/dq/expr_nodes/dq_expr_nodes.h>
-
-namespace NYql {
-namespace NNodes {
-
+ 
+namespace NYql { 
+namespace NNodes { 
+ 
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.decl.inl.h>
-
+ 
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.defs.inl.h>
-
-} // namespace NNodes
-} // namespace NYql
+ 
+} // namespace NNodes 
+} // namespace NYql 
diff --git a/ydb/core/kqp/expr_nodes/kqp_expr_nodes.json b/ydb/core/kqp/expr_nodes/kqp_expr_nodes.json
index 2faa33d5e1..5a692ef9f3 100644
--- a/ydb/core/kqp/expr_nodes/kqp_expr_nodes.json
+++ b/ydb/core/kqp/expr_nodes/kqp_expr_nodes.json
@@ -1,58 +1,58 @@
-{
-    "NodeRootType": "TExprBase",
-    "NodeBuilderBase": "TNodeBuilderBase",
-    "ListBuilderBase": "TListBuilderBase",
-    "FreeArgCallableBase": "TFreeArgCallable",
-    "FreeArgBuilderBase": "TFreeArgCallableBuilderBase",
-    "Nodes": [
-        {
-            "Name": "TKqlKeyTuple",
-            "VarArgBase": "TExprBase",
-            "Match": {"Type": "CallableBase"},
-            "Builder": {"Generate": "None"}
-        },
-        {
-            "Name": "TKqlKeyInc",
-            "Base": "TKqlKeyTuple",
-            "Match": {"Type": "Callable", "Name": "KqlKeyInc"}
-        },
-        {
-            "Name": "TKqlKeyExc",
-            "Base": "TKqlKeyTuple",
-            "Match": {"Type": "Callable", "Name": "KqlKeyExc"}
-        },
-        {
-            "Name": "TKqlKeyRange",
-            "Base": "TExprBase",
-            "Match": {"Type": "Tuple"},
-            "Children": [
-                {"Index": 0, "Name": "From", "Type": "TKqlKeyTuple"},
-                {"Index": 1, "Name": "To", "Type": "TKqlKeyTuple"}
-            ]
-        },
-        {
-            "Name": "TKqpTable",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KqpTable"},
-            "Children": [
-                {"Index": 0, "Name": "Path", "Type": "TCoAtom"},
-                {"Index": 1, "Name": "PathId", "Type": "TCoAtom"},
-                {"Index": 2, "Name": "SysView", "Type": "TCoAtom"},
-                {"Index": 3, "Name": "Version", "Type": "TCoAtom"}
-            ]
-        },
-        {
+{ 
+    "NodeRootType": "TExprBase", 
+    "NodeBuilderBase": "TNodeBuilderBase", 
+    "ListBuilderBase": "TListBuilderBase", 
+    "FreeArgCallableBase": "TFreeArgCallable", 
+    "FreeArgBuilderBase": "TFreeArgCallableBuilderBase", 
+    "Nodes": [ 
+        { 
+            "Name": "TKqlKeyTuple", 
+            "VarArgBase": "TExprBase", 
+            "Match": {"Type": "CallableBase"}, 
+            "Builder": {"Generate": "None"} 
+        }, 
+        { 
+            "Name": "TKqlKeyInc", 
+            "Base": "TKqlKeyTuple", 
+            "Match": {"Type": "Callable", "Name": "KqlKeyInc"} 
+        }, 
+        { 
+            "Name": "TKqlKeyExc", 
+            "Base": "TKqlKeyTuple", 
+            "Match": {"Type": "Callable", "Name": "KqlKeyExc"} 
+        }, 
+        { 
+            "Name": "TKqlKeyRange", 
+            "Base": "TExprBase", 
+            "Match": {"Type": "Tuple"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "From", "Type": "TKqlKeyTuple"}, 
+                {"Index": 1, "Name": "To", "Type": "TKqlKeyTuple"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKqpTable", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KqpTable"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Path", "Type": "TCoAtom"}, 
+                {"Index": 1, "Name": "PathId", "Type": "TCoAtom"}, 
+                {"Index": 2, "Name": "SysView", "Type": "TCoAtom"}, 
+                {"Index": 3, "Name": "Version", "Type": "TCoAtom"} 
+            ] 
+        }, 
+        { 
             "Name": "TKqlReadTableBase",
-            "Base": "TCallable",
+            "Base": "TCallable", 
             "Match": {"Type": "CallableBase"},
-            "Children": [
-                {"Index": 0, "Name": "Table", "Type": "TKqpTable"},
-                {"Index": 1, "Name": "Range", "Type": "TKqlKeyRange"},
+            "Children": [ 
+                {"Index": 0, "Name": "Table", "Type": "TKqpTable"}, 
+                {"Index": 1, "Name": "Range", "Type": "TKqlKeyRange"}, 
                 {"Index": 2, "Name": "Columns", "Type": "TCoAtomList"},
                 {"Index": 3, "Name": "Settings", "Type": "TCoNameValueTupleList"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TKqlReadTable",
             "Base": "TKqlReadTableBase",
             "Match": {"Type": "Callable", "Name": "KqlReadTable"}
@@ -121,21 +121,21 @@
             "Match": {"Type": "Callable", "Name": "KqpWideReadOlapTableRanges"}
         },
         {
-            "Name": "TKqlLookupTableBase",
-            "Base": "TCallable",
-            "Match": {"Type": "CallableBase"},
-            "Children": [
-                {"Index": 0, "Name": "Table", "Type": "TKqpTable"},
-                {"Index": 1, "Name": "LookupKeys", "Type": "TExprBase"},
-                {"Index": 2, "Name": "Columns", "Type": "TCoAtomList"}
-            ]
-        },
-        {
-            "Name": "TKqlLookupTable",
-            "Base": "TKqlLookupTableBase",
-            "Match": {"Type": "Callable", "Name": "KqlLookupTable"}
-        },
-        {
+            "Name": "TKqlLookupTableBase", 
+            "Base": "TCallable", 
+            "Match": {"Type": "CallableBase"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Table", "Type": "TKqpTable"}, 
+                {"Index": 1, "Name": "LookupKeys", "Type": "TExprBase"}, 
+                {"Index": 2, "Name": "Columns", "Type": "TCoAtomList"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKqlLookupTable", 
+            "Base": "TKqlLookupTableBase", 
+            "Match": {"Type": "Callable", "Name": "KqlLookupTable"} 
+        }, 
+        { 
             "Name": "TKqlLookupIndex",
             "Base": "TKqlLookupTableBase",
             "Match": {"Type": "Callable", "Name": "KqlLookupIndex"},
@@ -144,32 +144,32 @@
             ]
         },
         {
-            "Name": "TKqpLookupTable",
-            "Base": "TKqlLookupTableBase",
-            "Match": {"Type": "Callable", "Name": "KqpLookupTable"}
-        },
-        {
-            "Name": "TKqlTableEffect",
-            "Base": "TExprBase",
+            "Name": "TKqpLookupTable", 
+            "Base": "TKqlLookupTableBase", 
+            "Match": {"Type": "Callable", "Name": "KqpLookupTable"} 
+        }, 
+        { 
+            "Name": "TKqlTableEffect", 
+            "Base": "TExprBase", 
+            "Match": {"Type": "CallableBase"}, 
+            "Builder": {"Generate": "None"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Table", "Type": "TKqpTable"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKqlUpsertRowsBase", 
+            "Base": "TKqlTableEffect", 
             "Match": {"Type": "CallableBase"},
-            "Builder": {"Generate": "None"},
-            "Children": [
-                {"Index": 0, "Name": "Table", "Type": "TKqpTable"}
-            ]
-        },
-        {
-            "Name": "TKqlUpsertRowsBase",
-            "Base": "TKqlTableEffect",
-            "Match": {"Type": "CallableBase"},
-            "Children": [
-                {"Index": 1, "Name": "Input", "Type": "TExprBase"},
-                {"Index": 2, "Name": "Columns", "Type": "TCoAtomList"}
-            ]
-        },
-        {
-            "Name": "TKqlUpsertRows",
-            "Base": "TKqlUpsertRowsBase",
-            "Match": {"Type": "Callable", "Name": "KqlUpsertRows"}
+            "Children": [ 
+                {"Index": 1, "Name": "Input", "Type": "TExprBase"}, 
+                {"Index": 2, "Name": "Columns", "Type": "TCoAtomList"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKqlUpsertRows", 
+            "Base": "TKqlUpsertRowsBase", 
+            "Match": {"Type": "Callable", "Name": "KqlUpsertRows"} 
         },
         {
             "Name": "TKqlUpsertRowsIndex",
@@ -177,12 +177,12 @@
             "Match": {"Type": "Callable", "Name": "KqlUpsertRowsIndex"}
         },
         {
-            "Name": "TKqpUpsertRows",
-            "Base": "TKqlUpsertRowsBase",
-            "Match": {"Type": "Callable", "Name": "KqpUpsertRows"},
-            "Children": [
-                {"Index": 3, "Name": "Settings", "Type": "TCoNameValueTupleList"}
-            ]
+            "Name": "TKqpUpsertRows", 
+            "Base": "TKqlUpsertRowsBase", 
+            "Match": {"Type": "Callable", "Name": "KqpUpsertRows"}, 
+            "Children": [ 
+                {"Index": 3, "Name": "Settings", "Type": "TCoNameValueTupleList"} 
+            ] 
         },
         {
             "Name": "TKqlInsertRowsBase",
@@ -224,29 +224,29 @@
             "Match": {"Type": "Callable", "Name": "TKqlInsertRowsIndex"}
         },
         {
-            "Name": "TKqpParamBinding",
-            "Base": "TExprBase",
-            "Match": {"Type": "Tuple"},
-            "Children": [
-                {"Index": 0, "Name": "Name", "Type": "TCoAtom"},
-                {"Index": 1, "Name": "Binding", "Type": "TCallable", "Optional": true}
-            ]
-        },
-        {
-            "Name": "TKqpParamBindingList",
-            "ListBase": "TKqpParamBinding"
-        },
-        {
-            "Name": "TKqpTxResultBinding",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KqpTxResultBinding"},
-            "Children": [
-                {"Index": 0, "Name": "Type", "Type": "TExprBase"},
-                {"Index": 1, "Name": "TxIndex", "Type": "TCoAtom"},
-                {"Index": 2, "Name": "ResultIndex", "Type": "TCoAtom"}
-            ]
-        },
-        {
+            "Name": "TKqpParamBinding", 
+            "Base": "TExprBase", 
+            "Match": {"Type": "Tuple"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Name", "Type": "TCoAtom"}, 
+                {"Index": 1, "Name": "Binding", "Type": "TCallable", "Optional": true} 
+            ] 
+        }, 
+        { 
+            "Name": "TKqpParamBindingList", 
+            "ListBase": "TKqpParamBinding" 
+        }, 
+        { 
+            "Name": "TKqpTxResultBinding", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KqpTxResultBinding"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Type", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "TxIndex", "Type": "TCoAtom"}, 
+                {"Index": 2, "Name": "ResultIndex", "Type": "TCoAtom"} 
+            ] 
+        }, 
+        { 
             "Name": "TKqpTxInternalBinding",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "KqpTxInternalBinding"},
@@ -256,31 +256,31 @@
             ]
         },
         {
-            "Name": "TKqpPhysicalTx",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KqpPhysicalTx"},
-            "Children": [
+            "Name": "TKqpPhysicalTx", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KqpPhysicalTx"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Stages", "Type": "TDqPhyStageList"},
-                {"Index": 1, "Name": "Results", "Type": "TExprList"},
-                {"Index": 2, "Name": "ParamBindings", "Type": "TKqpParamBindingList"},
+                {"Index": 1, "Name": "Results", "Type": "TExprList"}, 
+                {"Index": 2, "Name": "ParamBindings", "Type": "TKqpParamBindingList"}, 
                 {"Index": 3, "Name": "Settings", "Type": "TCoNameValueTupleList"}
-            ]
-        },
-        {
-            "Name": "TKqpPhysicalTxList",
-            "ListBase": "TKqpPhysicalTx"
-        },
-        {
-            "Name": "TKqpPhysicalQuery",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KqpPhysicalQuery"},
-            "Children": [
-                {"Index": 0, "Name": "Transactions", "Type": "TKqpPhysicalTxList"},
+            ] 
+        }, 
+        { 
+            "Name": "TKqpPhysicalTxList", 
+            "ListBase": "TKqpPhysicalTx" 
+        }, 
+        { 
+            "Name": "TKqpPhysicalQuery", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KqpPhysicalQuery"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Transactions", "Type": "TKqpPhysicalTxList"}, 
                 {"Index": 1, "Name": "Results", "Type": "TExprList"},
                 {"Index": 2, "Name": "Settings", "Type": "TCoNameValueTupleList"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TKqlQueryResult",
             "Base": "TExprBase",
             "Match": {"Type": "Tuple"},
@@ -294,37 +294,37 @@
             "ListBase": "TKqlQueryResult"
         },
         {
-            "Name": "TKqlQuery",
-            "Base": "TExprBase",
-            "Match": {"Type": "Tuple"},
-            "Children": [
+            "Name": "TKqlQuery", 
+            "Base": "TExprBase", 
+            "Match": {"Type": "Tuple"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Results", "Type": "TKqlQueryResultList"},
-                {"Index": 1, "Name": "Effects", "Type": "TExprList"}
-            ]
-        },
-        {
-            "Name": "TKqpEffects",
-            "VarArgBase": "TExprBase",
-            "Match": {"Type": "Callable", "Name": "KqpEffects"}
-        },
-        {
-            "Name": "TKqpConnection",
-            "Base": "TDqConnection",
-            "Match": {"Type": "CallableBase"},
-            "Builder": {"Generate": "None"},
-            "Children": [
-                {"Index": 0, "Name": "Output", "Type": "TDqOutput"}
-            ]
-        },
-        {
-            "Name": "TKqpCnMapShard",
-            "Base": "TKqpConnection",
-            "Match": {"Type": "Callable", "Name": "KqpCnMapShard"}
-        },
-        {
-            "Name": "TKqpCnShuffleShard",
-            "Base": "TDqConnection",
-            "Match": {"Type": "Callable", "Name": "KqpCnShuffleShard"}
+                {"Index": 1, "Name": "Effects", "Type": "TExprList"} 
+            ] 
+        },
+        {
+            "Name": "TKqpEffects", 
+            "VarArgBase": "TExprBase", 
+            "Match": {"Type": "Callable", "Name": "KqpEffects"} 
+        }, 
+        { 
+            "Name": "TKqpConnection", 
+            "Base": "TDqConnection", 
+            "Match": {"Type": "CallableBase"}, 
+            "Builder": {"Generate": "None"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Output", "Type": "TDqOutput"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKqpCnMapShard", 
+            "Base": "TKqpConnection", 
+            "Match": {"Type": "Callable", "Name": "KqpCnMapShard"} 
+        }, 
+        { 
+            "Name": "TKqpCnShuffleShard", 
+            "Base": "TDqConnection", 
+            "Match": {"Type": "Callable", "Name": "KqpCnShuffleShard"} 
         },
         {
             "Name": "TKqpProgram",
@@ -357,20 +357,20 @@
             "Name": "TKqpDeleteRows",
             "Base": "TKqlDeleteRowsBase",
             "Match": {"Type": "Callable", "Name": "KqpDeleteRows"}
-        },
-        {
-            "Name": "TKqpOlapOperationBase",
-            "Base": "TCallable",
-            "Match": {"Type": "CallableBase"},
-            "Children": [
-                {"Index": 0, "Name": "Input", "Type": "TExprBase"}
-            ]
-        },
-        {
+        }, 
+        { 
+            "Name": "TKqpOlapOperationBase", 
+            "Base": "TCallable", 
+            "Match": {"Type": "CallableBase"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Input", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TKqpOlapFilter",
-            "Base": "TKqpOlapOperationBase",
+            "Base": "TKqpOlapOperationBase", 
             "Match": {"Type": "Callable", "Name": "KqpOlapFilter"},
-            "Children": [
+            "Children": [ 
                 {"Index": 1, "Name": "Condition", "Type": "TExprBase"}
             ]
         },
@@ -381,7 +381,7 @@
             "Children": [
                 {"Index": 1, "Name": "Left", "Type": "TExprBase"},
                 {"Index": 2, "Name": "Right", "Type": "TExprBase"}
-            ]
+            ] 
         },
         {
             "Name": "TKqpOlapFilterEqual",
@@ -426,6 +426,6 @@
                 {"Index": 2, "Name": "IssueCode", "Type": "TCoAtom"},
                 {"Index": 3, "Name": "Message", "Type": "TExprBase"}
             ]
-        }
-    ]
-}
+        } 
+    ] 
+} 
diff --git a/ydb/core/kqp/expr_nodes/ya.make b/ydb/core/kqp/expr_nodes/ya.make
index 241519b92d..a0768811ee 100644
--- a/ydb/core/kqp/expr_nodes/ya.make
+++ b/ydb/core/kqp/expr_nodes/ya.make
@@ -1,31 +1,31 @@
-LIBRARY()
-
-OWNER(
-    spuchin
-    g:kikimr
-)
-
-SRCS(
-    kqp_expr_nodes.h
-    kqp_expr_nodes.cpp
-)
-
-PEERDIR(
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
+    g:kikimr 
+) 
+ 
+SRCS( 
+    kqp_expr_nodes.h 
+    kqp_expr_nodes.cpp 
+) 
+ 
+PEERDIR( 
     ydb/library/yql/dq/expr_nodes
-)
-
+) 
+ 
 SRCDIR(ydb/library/yql/core/expr_nodes_gen)
-
-RUN_PROGRAM(
+ 
+RUN_PROGRAM( 
     ydb/library/yql/core/expr_nodes_gen/gen yql_expr_nodes_gen.jnj kqp_expr_nodes.json kqp_expr_nodes.gen.h
         kqp_expr_nodes.decl.inl.h kqp_expr_nodes.defs.inl.h
-    IN yql_expr_nodes_gen.jnj
-    IN kqp_expr_nodes.json
-    OUT kqp_expr_nodes.gen.h
-    OUT kqp_expr_nodes.decl.inl.h
-    OUT kqp_expr_nodes.defs.inl.h
+    IN yql_expr_nodes_gen.jnj 
+    IN kqp_expr_nodes.json 
+    OUT kqp_expr_nodes.gen.h 
+    OUT kqp_expr_nodes.decl.inl.h 
+    OUT kqp_expr_nodes.defs.inl.h 
     OUTPUT_INCLUDES ${ARCADIA_ROOT}/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.h
         ${ARCADIA_ROOT}/util/generic/hash_set.h
-)
-
-END()
+) 
+ 
+END() 
diff --git a/ydb/core/kqp/host/kqp_host.cpp b/ydb/core/kqp/host/kqp_host.cpp
index 44af6d1168..c105154796 100644
--- a/ydb/core/kqp/host/kqp_host.cpp
+++ b/ydb/core/kqp/host/kqp_host.cpp
@@ -1,10 +1,10 @@
-#include "kqp_host_impl.h"
-
+#include "kqp_host_impl.h" 
+ 
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/prepare/kqp_query_plan.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
-
+ 
 #include <ydb/library/yql/core/yql_opt_proposed_by_data.h>
 #include <ydb/library/yql/core/services/yql_plan.h>
 #include <ydb/library/yql/core/services/yql_transform_pipeline.h>
@@ -14,110 +14,110 @@
 #include <ydb/library/yql/providers/common/udf_resolve/yql_simple_udf_resolver.h>
 #include <ydb/library/yql/minikql/invoke_builtins/mkql_builtins.h>
 #include <ydb/library/yql/sql/sql.h>
-
+ 
 #include <library/cpp/cache/cache.h>
 #include <library/cpp/random_provider/random_provider.h>
 #include <library/cpp/time_provider/time_provider.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NCommon;
-using namespace NYql::NNodes;
-using namespace NThreading;
-
-using TSqlVersion = ui16;
-
-namespace {
-
-void AddQueryStats(NKqpProto::TKqpStatsQuery& total, NKqpProto::TKqpStatsQuery&& stats) {
-    // NOTE: Do not add duration & compilation stats as they are computed for the
-    // whole query in KQP worker.
-
-    for (auto& execution : *stats.MutableExecutions()) {
-        total.AddExecutions()->Swap(&execution);
-    }
-
-    total.SetWorkerCpuTimeUs(total.GetWorkerCpuTimeUs() + stats.GetWorkerCpuTimeUs());
-}
-
-class TKqpResultWriter : public IResultWriter {
-public:
-    TKqpResultWriter() {}
-
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NCommon; 
+using namespace NYql::NNodes; 
+using namespace NThreading; 
+ 
+using TSqlVersion = ui16; 
+ 
+namespace { 
+ 
+void AddQueryStats(NKqpProto::TKqpStatsQuery& total, NKqpProto::TKqpStatsQuery&& stats) { 
+    // NOTE: Do not add duration & compilation stats as they are computed for the 
+    // whole query in KQP worker. 
+ 
+    for (auto& execution : *stats.MutableExecutions()) { 
+        total.AddExecutions()->Swap(&execution); 
+    } 
+ 
+    total.SetWorkerCpuTimeUs(total.GetWorkerCpuTimeUs() + stats.GetWorkerCpuTimeUs()); 
+} 
+ 
+class TKqpResultWriter : public IResultWriter { 
+public: 
+    TKqpResultWriter() {} 
+ 
     bool IsDiscard() const override {
         return Discard;
-    }
-
+    } 
+ 
     void Init(bool discard, const TString& label, TMaybe<TPosition> pos) override {
         Discard = discard;
         Y_UNUSED(label);
         Y_UNUSED(pos);
     }
 
-    void Write(const TStringBuf& resultData) override {
+    void Write(const TStringBuf& resultData) override { 
         if (!Discard) {
             YQL_ENSURE(Result.empty());
             Result = resultData;
         }
-    }
-
-    void Commit(bool overflow) override {
-        YQL_ENSURE(!overflow);
-    }
-
-    TStringBuf Str() override {
-        return Result;
-    }
-
-    ui64 Size() override {
+    } 
+ 
+    void Commit(bool overflow) override { 
+        YQL_ENSURE(!overflow); 
+    } 
+ 
+    TStringBuf Str() override { 
+        return Result; 
+    } 
+ 
+    ui64 Size() override { 
         return Result.size();
-    }
-
-private:
+    } 
+ 
+private: 
     bool Discard = false;
     TString Result;
-};
-
-struct TExecuteContext : TThrRefBase {
-    TVector<IKqpHost::TQueryResult> QueryResults;
-    IKikimrQueryExecutor::TExecuteSettings Settings;
+}; 
+ 
+struct TExecuteContext : TThrRefBase { 
+    TVector<IKqpHost::TQueryResult> QueryResults; 
+    IKikimrQueryExecutor::TExecuteSettings Settings; 
     NActors::TActorId ReplyTarget;
-
-    void Reset(const IKikimrQueryExecutor::TExecuteSettings& settings) {
-        Settings = settings;
-        QueryResults.clear();
-    }
-};
-
+ 
+    void Reset(const IKikimrQueryExecutor::TExecuteSettings& settings) { 
+        Settings = settings; 
+        QueryResults.clear(); 
+    } 
+}; 
+ 
 void FillAstAndPlan(IKqpHost::TQueryResult& queryResult, TExprNode* queryRoot, TExprContext& ctx, IPlanBuilder& planBuilder) {
-    TStringStream astStream;
+    TStringStream astStream; 
     auto ast = ConvertToAst(*queryRoot, ctx, TExprAnnotationFlags::None, true);
-    ast.Root->PrettyPrintTo(astStream, TAstPrintFlags::ShortQuote | TAstPrintFlags::PerLine);
-    queryResult.QueryAst = astStream.Str();
-
-    TStringStream planStream;
+    ast.Root->PrettyPrintTo(astStream, TAstPrintFlags::ShortQuote | TAstPrintFlags::PerLine); 
+    queryResult.QueryAst = astStream.Str(); 
+ 
+    TStringStream planStream; 
     NYson::TYsonWriter writer(&planStream, NYson::EYsonFormat::Binary);
-    planBuilder.Clear();
-    planBuilder.WritePlan(writer, queryRoot);
-    queryResult.QueryPlan = planStream.Str();
-}
-
-void FillAstAndPlan(IKqpHost::TQueryResult& queryResult, const NKikimrKqp::TPreparedQuery& query) {
-    YQL_ENSURE(query.KqlsSize() == 1);
-
-    queryResult.QueryAst = query.GetKqls(0).GetAst();
-    queryResult.QueryPlan = query.GetKqls(0).GetPlan();
-
-    if (queryResult.QueryPlan.empty()) {
-        TStringStream planStream;
+    planBuilder.Clear(); 
+    planBuilder.WritePlan(writer, queryRoot); 
+    queryResult.QueryPlan = planStream.Str(); 
+} 
+ 
+void FillAstAndPlan(IKqpHost::TQueryResult& queryResult, const NKikimrKqp::TPreparedQuery& query) { 
+    YQL_ENSURE(query.KqlsSize() == 1); 
+ 
+    queryResult.QueryAst = query.GetKqls(0).GetAst(); 
+    queryResult.QueryPlan = query.GetKqls(0).GetPlan(); 
+ 
+    if (queryResult.QueryPlan.empty()) { 
+        TStringStream planStream; 
         NYson::TYsonWriter writer(&planStream, NYson::EYsonFormat::Binary);
-        writer.OnEntity();
-        queryResult.QueryPlan = planStream.Str();
-    }
-}
-
+        writer.OnEntity(); 
+        queryResult.QueryPlan = planStream.Str(); 
+    } 
+} 
+ 
 /*
  * Validate YqlScript.
  */
@@ -147,21 +147,21 @@ private:
 /*
  * Explain Yql/YqlScript.
  */
-class TAsyncExplainYqlResult : public TKqpAsyncResultBase<IKqpHost::TQueryResult> {
-public:
-    using TResult = IKqpHost::TQueryResult;
-
+class TAsyncExplainYqlResult : public TKqpAsyncResultBase<IKqpHost::TQueryResult> { 
+public: 
+    using TResult = IKqpHost::TQueryResult; 
+ 
     TAsyncExplainYqlResult(TExprNode* queryRoot, TIntrusivePtr<TKikimrSessionContext> sessionCtx,
         TExprContext& exprCtx, TAutoPtr<IGraphTransformer> transformer,
         IPlanBuilder& planBuilder, TMaybe<TSqlVersion> sqlVersion, bool useDqExplain = false)
-        : TKqpAsyncResultBase(queryRoot, exprCtx, *transformer.Get())
+        : TKqpAsyncResultBase(queryRoot, exprCtx, *transformer.Get()) 
         , SessionCtx(sessionCtx)
-        , Transformer(transformer)
-        , PlanBuilder(planBuilder)
+        , Transformer(transformer) 
+        , PlanBuilder(planBuilder) 
         , SqlVersion(sqlVersion)
         , UseDqExplain(useDqExplain) {}
-
-    void FillResult(TResult& queryResult) const override {
+ 
+    void FillResult(TResult& queryResult) const override { 
         if (UseDqExplain) {
             TVector<const TString> plans;
             for (auto id : SessionCtx->Query().ExecutionOrder) {
@@ -174,181 +174,181 @@ public:
         } else {
             FillAstAndPlan(queryResult, GetExprRoot().Get(), GetExprContext(), PlanBuilder);
         }
-        queryResult.SqlVersion = SqlVersion;
-    }
-
-private:
+        queryResult.SqlVersion = SqlVersion; 
+    } 
+ 
+private: 
     TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-    TAutoPtr<IGraphTransformer> Transformer;
-    IPlanBuilder& PlanBuilder;
-    TMaybe<TSqlVersion> SqlVersion;
+    TAutoPtr<IGraphTransformer> Transformer; 
+    IPlanBuilder& PlanBuilder; 
+    TMaybe<TSqlVersion> SqlVersion; 
     bool UseDqExplain;
-};
-
+}; 
+ 
 /*
  * Execute Yql/SchemeQuery/YqlScript.
  */
-class TAsyncExecuteYqlResult : public TKqpAsyncExecuteResultBase<IKqpHost::TQueryResult> {
-public:
-    using TResult = IKqpHost::TQueryResult;
-
-    TAsyncExecuteYqlResult(TExprNode* queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer,
-        const TString& cluster, TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-        const TResultProviderConfig& resultProviderConfig, IPlanBuilder& planBuilder,
+class TAsyncExecuteYqlResult : public TKqpAsyncExecuteResultBase<IKqpHost::TQueryResult> { 
+public: 
+    using TResult = IKqpHost::TQueryResult; 
+ 
+    TAsyncExecuteYqlResult(TExprNode* queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer, 
+        const TString& cluster, TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+        const TResultProviderConfig& resultProviderConfig, IPlanBuilder& planBuilder, 
         TMaybe<TSqlVersion> sqlVersion)
-        : TKqpAsyncExecuteResultBase(queryRoot, exprCtx, transformer, sessionCtx->TxPtr())
-        , Cluster(cluster)
-        , SessionCtx(sessionCtx)
-        , ResultProviderConfig(resultProviderConfig)
-        , PlanBuilder(planBuilder)
-        , SqlVersion(sqlVersion) {}
-
-    void FillResult(TResult& queryResult) const override {
-        for (auto& resultStr : ResultProviderConfig.CommittedResults) {
+        : TKqpAsyncExecuteResultBase(queryRoot, exprCtx, transformer, sessionCtx->TxPtr()) 
+        , Cluster(cluster) 
+        , SessionCtx(sessionCtx) 
+        , ResultProviderConfig(resultProviderConfig) 
+        , PlanBuilder(planBuilder) 
+        , SqlVersion(sqlVersion) {} 
+ 
+    void FillResult(TResult& queryResult) const override { 
+        for (auto& resultStr : ResultProviderConfig.CommittedResults) { 
             queryResult.Results.emplace_back(
-                google::protobuf::Arena::CreateMessage<NKikimrMiniKQL::TResult>(queryResult.ProtobufArenaPtr.get()));
+                google::protobuf::Arena::CreateMessage<NKikimrMiniKQL::TResult>(queryResult.ProtobufArenaPtr.get())); 
             NKikimrMiniKQL::TResult* result = queryResult.Results.back();
 
             if (!result->ParseFromArray(resultStr.data(), resultStr.size())) {
-                queryResult = ResultFromError<TResult>("Failed to parse run result.");
-                return;
-            }
-        }
-
+                queryResult = ResultFromError<TResult>("Failed to parse run result."); 
+                return; 
+            } 
+        } 
+ 
         TVector<const TString> queryPlans;
-        for (auto id : SessionCtx->Query().ExecutionOrder) {
+        for (auto id : SessionCtx->Query().ExecutionOrder) { 
             auto result = SessionCtx->Query().Results.FindPtr(id);
-            if (result) {
+            if (result) { 
                 queryPlans.push_back(SerializeAnalyzePlan(result->QueryStats));
-                AddQueryStats(queryResult.QueryStats, std::move(result->QueryStats));
+                AddQueryStats(queryResult.QueryStats, std::move(result->QueryStats)); 
             }
         }
 
         FillAstAndPlan(queryResult, GetExprRoot().Get(), GetExprContext(), PlanBuilder);
-        queryResult.SqlVersion = SqlVersion;
+        queryResult.SqlVersion = SqlVersion; 
         queryResult.QueryPlan = SerializeScriptPlan(queryPlans);
-    }
-
-private:
-    TString Cluster;
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-    const TResultProviderConfig& ResultProviderConfig;
-    IPlanBuilder& PlanBuilder;
-    TMaybe<TSqlVersion> SqlVersion;
-};
-
+    } 
+ 
+private: 
+    TString Cluster; 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+    const TResultProviderConfig& ResultProviderConfig; 
+    IPlanBuilder& PlanBuilder; 
+    TMaybe<TSqlVersion> SqlVersion; 
+}; 
+ 
 /*
  * Execute prepared Yql/ScanQuery/DataQuery.
  */
-class TAsyncExecutePreparedResult : public TKqpAsyncExecuteResultBase<IKqpHost::TQueryResult> {
-public:
-    using TResult = IKqpHost::TQueryResult;
-
-    TAsyncExecutePreparedResult(TExprNode* queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer,
-        TIntrusivePtr<TKikimrSessionContext> sessionCtx, const IDataProvider::TFillSettings& fillSettings,
+class TAsyncExecutePreparedResult : public TKqpAsyncExecuteResultBase<IKqpHost::TQueryResult> { 
+public: 
+    using TResult = IKqpHost::TQueryResult; 
+ 
+    TAsyncExecutePreparedResult(TExprNode* queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer, 
+        TIntrusivePtr<TKikimrSessionContext> sessionCtx, const IDataProvider::TFillSettings& fillSettings, 
         TIntrusivePtr<TExecuteContext> executeCtx, std::shared_ptr<const NKikimrKqp::TPreparedQuery> query,
         TMaybe<TSqlVersion> sqlVersion)
-        : TKqpAsyncExecuteResultBase(queryRoot, exprCtx, transformer, sessionCtx->TxPtr())
-        , SessionCtx(sessionCtx)
-        , FillSettings(fillSettings)
-        , ExecuteCtx(executeCtx)
-        , Query(query)
-        , SqlVersion(sqlVersion) {}
-
-    void FillResult(TResult& queryResult) const override {
+        : TKqpAsyncExecuteResultBase(queryRoot, exprCtx, transformer, sessionCtx->TxPtr()) 
+        , SessionCtx(sessionCtx) 
+        , FillSettings(fillSettings) 
+        , ExecuteCtx(executeCtx) 
+        , Query(query) 
+        , SqlVersion(sqlVersion) {} 
+ 
+    void FillResult(TResult& queryResult) const override { 
         for (const auto& result : SessionCtx->Query().PreparedQuery->GetResults()) {
-            YQL_ENSURE(result.GetKqlIndex() < ExecuteCtx->QueryResults.size());
-            const auto& execResult = ExecuteCtx->QueryResults[result.GetKqlIndex()];
-
-            YQL_ENSURE(result.GetResultIndex() < execResult.Results.size());
-            const auto& resultValue = execResult.Results[result.GetResultIndex()];
-
-            auto fillSettings = FillSettings;
-            if (result.GetRowsLimit()) {
-                fillSettings.RowsLimitPerWrite = result.GetRowsLimit();
-            }
+            YQL_ENSURE(result.GetKqlIndex() < ExecuteCtx->QueryResults.size()); 
+            const auto& execResult = ExecuteCtx->QueryResults[result.GetKqlIndex()]; 
+ 
+            YQL_ENSURE(result.GetResultIndex() < execResult.Results.size()); 
+            const auto& resultValue = execResult.Results[result.GetResultIndex()]; 
+ 
+            auto fillSettings = FillSettings; 
+            if (result.GetRowsLimit()) { 
+                fillSettings.RowsLimitPerWrite = result.GetRowsLimit(); 
+            } 
             TVector<TString> columnHints(result.GetColumnHints().begin(), result.GetColumnHints().end());
-            auto protoResult = KikimrResultToProto(*resultValue, columnHints, fillSettings,
-                queryResult.ProtobufArenaPtr.get());
-
-            queryResult.Results.push_back(protoResult);
-        }
-
+            auto protoResult = KikimrResultToProto(*resultValue, columnHints, fillSettings, 
+                queryResult.ProtobufArenaPtr.get()); 
+ 
+            queryResult.Results.push_back(protoResult); 
+        } 
+ 
         if (!SessionCtx->Query().PrepareOnly && SessionCtx->Query().PreparedQuery->KqlsSize() == 1) {
             FillAstAndPlan(queryResult, *SessionCtx->Query().PreparedQuery);
-        }
+        } 
         queryResult.QueryAst = SessionCtx->Query().PreparedQuery->GetPhysicalQuery().GetQueryAst();
-
-        if (Query) {
+ 
+        if (Query) { 
             queryResult.PreparedQuery = Query;
-        }
-
+        } 
+ 
         /*
          * Set stats and plan for DataQuery. In case of ScanQuery they will be set
          * later in TStreamExecuteScanQueryRPC.
          */
-        if (ExecuteCtx->QueryResults.size() == 1) {
-            auto& execResult = ExecuteCtx->QueryResults[0];
-            queryResult.QueryStats.Swap(&execResult.QueryStats);
+        if (ExecuteCtx->QueryResults.size() == 1) { 
+            auto& execResult = ExecuteCtx->QueryResults[0]; 
+            queryResult.QueryStats.Swap(&execResult.QueryStats); 
             queryResult.QueryPlan = SerializeAnalyzePlan(queryResult.QueryStats);
         }
 
-        queryResult.SqlVersion = SqlVersion;
-    }
-
-private:
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-    IDataProvider::TFillSettings FillSettings;
-    TIntrusivePtr<TExecuteContext> ExecuteCtx;
+        queryResult.SqlVersion = SqlVersion; 
+    } 
+ 
+private: 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+    IDataProvider::TFillSettings FillSettings; 
+    TIntrusivePtr<TExecuteContext> ExecuteCtx; 
     mutable std::shared_ptr<const NKikimrKqp::TPreparedQuery> Query;
-    TMaybe<TSqlVersion> SqlVersion;
-};
-
+    TMaybe<TSqlVersion> SqlVersion; 
+}; 
+ 
 /*
  * Prepare ScanQuery/DataQuery by AST (when called through scripting).
  */
-class TAsyncExecuteKqlResult : public TKqpAsyncExecuteResultBase<IKqpHost::TQueryResult> {
-public:
-    using TResult = IKqpHost::TQueryResult;
-
-    TAsyncExecuteKqlResult(TExprNode* queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer,
+class TAsyncExecuteKqlResult : public TKqpAsyncExecuteResultBase<IKqpHost::TQueryResult> { 
+public: 
+    using TResult = IKqpHost::TQueryResult; 
+ 
+    TAsyncExecuteKqlResult(TExprNode* queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer, 
         TIntrusivePtr<TKikimrSessionContext> sessionCtx, TExecuteContext& executeCtx)
-        : TKqpAsyncExecuteResultBase(queryRoot, exprCtx, transformer, sessionCtx->TxPtr())
-        , SessionCtx(sessionCtx)
-        , ExecuteCtx(executeCtx) {}
-
-    void FillResult(TResult& queryResult) const override {
-        YQL_ENSURE(ExecuteCtx.QueryResults.size() == 1);
+        : TKqpAsyncExecuteResultBase(queryRoot, exprCtx, transformer, sessionCtx->TxPtr()) 
+        , SessionCtx(sessionCtx) 
+        , ExecuteCtx(executeCtx) {} 
+ 
+    void FillResult(TResult& queryResult) const override { 
+        YQL_ENSURE(ExecuteCtx.QueryResults.size() == 1); 
         queryResult = std::move(ExecuteCtx.QueryResults[0]);
         queryResult.QueryPlan = SerializeExplainPlan(queryResult.PreparingQuery->GetPhysicalQuery());
-    }
-
-private:
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
+    } 
+ 
+private: 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
     TExecuteContext& ExecuteCtx;
-};
-
+}; 
+ 
 /*
  * Prepare ScanQuery/DataQuery.
  */
-class TAsyncPrepareYqlResult : public TKqpAsyncResultBase<IKqpHost::TQueryResult> {
-public:
-    using TResult = IKqpHost::TQueryResult;
-
-    TAsyncPrepareYqlResult(TExprNode* queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer,
+class TAsyncPrepareYqlResult : public TKqpAsyncResultBase<IKqpHost::TQueryResult> { 
+public: 
+    using TResult = IKqpHost::TQueryResult; 
+ 
+    TAsyncPrepareYqlResult(TExprNode* queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer, 
         TIntrusivePtr<TKikimrQueryContext> queryCtx, const TString& queryText, TMaybe<TSqlVersion> sqlVersion)
-        : TKqpAsyncResultBase(queryRoot, exprCtx, transformer)
-        , QueryCtx(queryCtx)
-        , QueryText(queryText)
-        , SqlVersion(sqlVersion) {}
-
-    void FillResult(TResult& prepareResult) const override {
-        YQL_ENSURE(QueryCtx->PrepareOnly);
+        : TKqpAsyncResultBase(queryRoot, exprCtx, transformer) 
+        , QueryCtx(queryCtx) 
+        , QueryText(queryText) 
+        , SqlVersion(sqlVersion) {} 
+ 
+    void FillResult(TResult& prepareResult) const override { 
+        YQL_ENSURE(QueryCtx->PrepareOnly); 
         YQL_ENSURE(QueryCtx->PreparingQuery);
 
         prepareResult.PreparingQuery = std::move(QueryCtx->PreparingQuery);
         prepareResult.PreparingQuery->SetText(std::move(QueryText));
-        prepareResult.SqlVersion = SqlVersion;
+        prepareResult.SqlVersion = SqlVersion; 
 
         if (prepareResult.PreparingQuery->GetVersion() == NKikimrKqp::TPreparedQuery::VERSION_PHYSICAL_V1) {
             prepareResult.QueryPlan = SerializeExplainPlan(prepareResult.PreparingQuery->GetPhysicalQuery());
@@ -358,14 +358,14 @@ public:
         }
 
         prepareResult.QueryTraits = QueryCtx->QueryTraits;
-    }
-
-private:
-    TIntrusivePtr<TKikimrQueryContext> QueryCtx;
-    TString QueryText;
-    TMaybe<TSqlVersion> SqlVersion;
-};
-
+    } 
+ 
+private: 
+    TIntrusivePtr<TKikimrQueryContext> QueryCtx; 
+    TString QueryText; 
+    TMaybe<TSqlVersion> SqlVersion; 
+}; 
+ 
 class TFailExpressionEvaluation : public TSyncTransformerBase {
 public:
     TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) override {
@@ -401,447 +401,447 @@ public:
     }
 };
 
-class TPrepareDataQueryAstTransformer : public TGraphTransformerBase {
-public:
-    TPrepareDataQueryAstTransformer(const TString& cluster, const TIntrusivePtr<TExecuteContext>& executeCtx,
+class TPrepareDataQueryAstTransformer : public TGraphTransformerBase { 
+public: 
+    TPrepareDataQueryAstTransformer(const TString& cluster, const TIntrusivePtr<TExecuteContext>& executeCtx, 
         const TIntrusivePtr<TKikimrQueryContext>& queryCtx, const TIntrusivePtr<IKqpRunner>& kqpRunner)
-        : Cluster(cluster)
-        , ExecuteCtx(executeCtx)
-        , QueryCtx(queryCtx)
-        , KqpRunner(kqpRunner) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        output = input;
-
-        if (!AsyncResult) {
-            YQL_ENSURE(QueryCtx->PrepareOnly);
-            YQL_ENSURE(!ExecuteCtx->Settings.CommitTx);
-            YQL_ENSURE(!ExecuteCtx->Settings.RollbackTx);
-            YQL_ENSURE(!ExecuteCtx->Settings.IsolationLevel);
-
-            if (QueryCtx->Type == EKikimrQueryType::Scan) {
-                AsyncResult = KqpRunner->PrepareScanQuery(Cluster, input.Get(), ctx, ExecuteCtx->Settings);
-            } else {
-                AsyncResult = KqpRunner->PrepareDataQuery(Cluster, input.Get(), ctx, ExecuteCtx->Settings);
-            }
-        }
-
-        Promise = NewPromise();
-
-        auto promise = Promise;
-        AsyncResult->Continue().Apply([promise](const TFuture<bool>& future) mutable {
-            YQL_ENSURE(future.HasValue());
-            promise.SetValue();
-        });
-
-        return TStatus::Async;
-    }
-
-    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
-        Y_UNUSED(input);
-        return Promise.GetFuture();
-    }
-
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        Y_UNUSED(ctx);
-
-        output = input;
-
-        if (!AsyncResult->HasResult()) {
-            return TStatus::Repeat;
-        }
-
-        auto queryResult = AsyncResult->GetResult();
-        if (!queryResult.Success()) {
-            return TStatus::Error;
-        }
-
+        : Cluster(cluster) 
+        , ExecuteCtx(executeCtx) 
+        , QueryCtx(queryCtx) 
+        , KqpRunner(kqpRunner) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        output = input; 
+ 
+        if (!AsyncResult) { 
+            YQL_ENSURE(QueryCtx->PrepareOnly); 
+            YQL_ENSURE(!ExecuteCtx->Settings.CommitTx); 
+            YQL_ENSURE(!ExecuteCtx->Settings.RollbackTx); 
+            YQL_ENSURE(!ExecuteCtx->Settings.IsolationLevel); 
+ 
+            if (QueryCtx->Type == EKikimrQueryType::Scan) { 
+                AsyncResult = KqpRunner->PrepareScanQuery(Cluster, input.Get(), ctx, ExecuteCtx->Settings); 
+            } else { 
+                AsyncResult = KqpRunner->PrepareDataQuery(Cluster, input.Get(), ctx, ExecuteCtx->Settings); 
+            } 
+        } 
+ 
+        Promise = NewPromise(); 
+ 
+        auto promise = Promise; 
+        AsyncResult->Continue().Apply([promise](const TFuture<bool>& future) mutable { 
+            YQL_ENSURE(future.HasValue()); 
+            promise.SetValue(); 
+        }); 
+ 
+        return TStatus::Async; 
+    } 
+ 
+    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
+        Y_UNUSED(input); 
+        return Promise.GetFuture(); 
+    } 
+ 
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        Y_UNUSED(ctx); 
+ 
+        output = input; 
+ 
+        if (!AsyncResult->HasResult()) { 
+            return TStatus::Repeat; 
+        } 
+ 
+        auto queryResult = AsyncResult->GetResult(); 
+        if (!queryResult.Success()) { 
+            return TStatus::Error; 
+        } 
+ 
         IKqpHost::TQueryResult prepareResult;
         prepareResult.SetSuccess();
         prepareResult.PreparingQuery = std::move(QueryCtx->PreparingQuery);
-
+ 
         ExecuteCtx->QueryResults.emplace_back(std::move(prepareResult));
-        return TStatus::Ok;
-    }
-
-    void Rewind() override {
-        AsyncResult.Reset();
-    }
-
-private:
-    TString Cluster;
-    TIntrusivePtr<TExecuteContext> ExecuteCtx;
-    TIntrusivePtr<TKikimrQueryContext> QueryCtx;
-    TIntrusivePtr<IKqpRunner> KqpRunner;
-    TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult> AsyncResult;
-    TPromise<void> Promise;
-};
-
-NKikimrMiniKQL::TParams* ValidateParameter(const TString& name, const TTypeAnnotationNode& type,
-    const TPosition& pos, TKikimrParamsMap& parameters, TExprContext& ctx)
-{
-    auto parameter = parameters.FindPtr(name);
-    if (!parameter) {
-        if (type.GetKind() == ETypeAnnotationKind::Optional) {
-            auto& newParameter = parameters[name];
-
-            if (!ExportTypeToKikimrProto(type, *newParameter.MutableType(), ctx)) {
-                ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_REQUEST,
-                    TStringBuilder() << "Failed to export parameter type: " << name));
-                return nullptr;
-            }
-
-            return &newParameter;
-        }
-
-        ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_REQUEST,
-            TStringBuilder() << "Missing value for parameter: " << name));
-        return nullptr;
-    }
-
-    const TTypeAnnotationNode* actualType;
-    {
-        TIssueScopeGuard issueScope(ctx.IssueManager, [pos, name]() {
-            return MakeIntrusive<TIssue>(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_REQUEST, TStringBuilder()
-                << "Failed to parse parameter type: " << name));
-        });
-
-        actualType = ParseTypeFromKikimrProto(parameter->GetType(), ctx);
-        if (!actualType) {
-            return nullptr;
-        }
-    }
-
-    if (!IsSameAnnotation(*actualType, type)) {
-        ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_REQUEST, TStringBuilder() << "Parameter " << name
-            << " type mismatch, expected: " << type << ", actual: " << *actualType));
-        return nullptr;
-    }
-
-    return parameter;
-}
-
+        return TStatus::Ok; 
+    } 
+ 
+    void Rewind() override { 
+        AsyncResult.Reset(); 
+    } 
+ 
+private: 
+    TString Cluster; 
+    TIntrusivePtr<TExecuteContext> ExecuteCtx; 
+    TIntrusivePtr<TKikimrQueryContext> QueryCtx; 
+    TIntrusivePtr<IKqpRunner> KqpRunner; 
+    TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult> AsyncResult; 
+    TPromise<void> Promise; 
+}; 
+ 
+NKikimrMiniKQL::TParams* ValidateParameter(const TString& name, const TTypeAnnotationNode& type, 
+    const TPosition& pos, TKikimrParamsMap& parameters, TExprContext& ctx) 
+{ 
+    auto parameter = parameters.FindPtr(name); 
+    if (!parameter) { 
+        if (type.GetKind() == ETypeAnnotationKind::Optional) { 
+            auto& newParameter = parameters[name]; 
+ 
+            if (!ExportTypeToKikimrProto(type, *newParameter.MutableType(), ctx)) { 
+                ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_REQUEST, 
+                    TStringBuilder() << "Failed to export parameter type: " << name)); 
+                return nullptr; 
+            } 
+ 
+            return &newParameter; 
+        } 
+ 
+        ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_REQUEST, 
+            TStringBuilder() << "Missing value for parameter: " << name)); 
+        return nullptr; 
+    } 
+ 
+    const TTypeAnnotationNode* actualType; 
+    { 
+        TIssueScopeGuard issueScope(ctx.IssueManager, [pos, name]() { 
+            return MakeIntrusive<TIssue>(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_REQUEST, TStringBuilder() 
+                << "Failed to parse parameter type: " << name)); 
+        }); 
+ 
+        actualType = ParseTypeFromKikimrProto(parameter->GetType(), ctx); 
+        if (!actualType) { 
+            return nullptr; 
+        } 
+    } 
+ 
+    if (!IsSameAnnotation(*actualType, type)) { 
+        ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_REQUEST, TStringBuilder() << "Parameter " << name 
+            << " type mismatch, expected: " << type << ", actual: " << *actualType)); 
+        return nullptr; 
+    } 
+ 
+    return parameter; 
+} 
+ 
 class TCollectParametersTransformer {
-public:
+public: 
     TCollectParametersTransformer(TIntrusivePtr<TKikimrQueryContext> queryCtx)
-        : QueryCtx(queryCtx) {}
-
-    IGraphTransformer::TStatus operator()(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
+        : QueryCtx(queryCtx) {} 
+ 
+    IGraphTransformer::TStatus operator()(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) { 
         if (QueryCtx->PrepareOnly && QueryCtx->PreparingQuery->ParametersSize() > 0) {
-            return IGraphTransformer::TStatus::Ok;
-        }
-
+            return IGraphTransformer::TStatus::Ok; 
+        } 
+ 
         TOptimizeExprSettings optSettings(nullptr);
-        optSettings.VisitChanges = false;
-
-        auto& queryCtx = QueryCtx;
-        auto status = OptimizeExpr(input, output,
-            [&queryCtx](const TExprNode::TPtr& input, TExprContext& ctx) -> TExprNode::TPtr {
-                auto ret = input;
-                TExprBase node(input);
-
+        optSettings.VisitChanges = false; 
+ 
+        auto& queryCtx = QueryCtx; 
+        auto status = OptimizeExpr(input, output, 
+            [&queryCtx](const TExprNode::TPtr& input, TExprContext& ctx) -> TExprNode::TPtr { 
+                auto ret = input; 
+                TExprBase node(input); 
+ 
                 if (auto maybeParameter = node.Maybe<TCoParameter>()) {
-                    auto parameter = maybeParameter.Cast();
-                    auto name = parameter.Name().Value();
+                    auto parameter = maybeParameter.Cast(); 
+                    auto name = parameter.Name().Value(); 
                     auto expectedType = parameter.Ref().GetTypeAnn();
-
-                    if (queryCtx->PrepareOnly) {
+ 
+                    if (queryCtx->PrepareOnly) { 
                         auto& paramDesc = *queryCtx->PreparingQuery->AddParameters();
-                        paramDesc.SetName(TString(name));
-                        if (!ExportTypeToKikimrProto(*expectedType, *paramDesc.MutableType(), ctx)) {
+                        paramDesc.SetName(TString(name)); 
+                        if (!ExportTypeToKikimrProto(*expectedType, *paramDesc.MutableType(), ctx)) { 
                             ctx.AddError(TIssue(ctx.GetPosition(parameter.Pos()), TStringBuilder()
-                                << "Failed to export parameter type: " << name));
-                            return nullptr;
-                        }
-
-                        return ret;
-                    }
-
+                                << "Failed to export parameter type: " << name)); 
+                            return nullptr; 
+                        } 
+ 
+                        return ret; 
+                    } 
+ 
                     auto parameterValue = ValidateParameter(TString(name), *expectedType, ctx.GetPosition(parameter.Pos()),
-                        queryCtx->Parameters, ctx);
-                    if (!parameterValue) {
-                        return nullptr;
-                    }
-
+                        queryCtx->Parameters, ctx); 
+                    if (!parameterValue) { 
+                        return nullptr; 
+                    } 
+ 
                     if (queryCtx->Type == EKikimrQueryType::YqlScript ||
                         queryCtx->Type == EKikimrQueryType::YqlScriptStreaming)
                     {
-                        return ret;
-                    }
-
-                    TExprNode::TPtr valueExpr;
-                    {
+                        return ret; 
+                    } 
+ 
+                    TExprNode::TPtr valueExpr; 
+                    { 
                         TIssueScopeGuard issueScope(ctx.IssueManager, [parameter, name, &ctx]() {
                             return MakeIntrusive<TIssue>(YqlIssue(ctx.GetPosition(parameter.Pos()), TIssuesIds::KIKIMR_BAD_REQUEST,
-                                TStringBuilder() << "Failed to parse parameter value: " << name));
-                        });
-
-                        valueExpr = ParseKikimrProtoValue(parameterValue->GetType(), parameterValue->GetValue(),
-                            parameter.Pos(), ctx);
-                    }
-
-                    if (!valueExpr) {
-                        return nullptr;
-                    }
-
-                    ret = valueExpr;
-                }
-
-                return ret;
-            }, ctx, optSettings);
-
-        return status;
-    }
-
-    static TAutoPtr<IGraphTransformer> Sync(TIntrusivePtr<TKikimrQueryContext> queryCtx) {
+                                TStringBuilder() << "Failed to parse parameter value: " << name)); 
+                        }); 
+ 
+                        valueExpr = ParseKikimrProtoValue(parameterValue->GetType(), parameterValue->GetValue(), 
+                            parameter.Pos(), ctx); 
+                    } 
+ 
+                    if (!valueExpr) { 
+                        return nullptr; 
+                    } 
+ 
+                    ret = valueExpr; 
+                } 
+ 
+                return ret; 
+            }, ctx, optSettings); 
+ 
+        return status; 
+    } 
+ 
+    static TAutoPtr<IGraphTransformer> Sync(TIntrusivePtr<TKikimrQueryContext> queryCtx) { 
         return CreateFunctorTransformer(TCollectParametersTransformer(queryCtx));
-    }
-
-private:
-    TIntrusivePtr<TKikimrQueryContext> QueryCtx;
-};
-
-class TValidatePreparedTransformer {
-public:
-    TValidatePreparedTransformer(TIntrusivePtr<TKikimrQueryContext> queryCtx)
-        : QueryCtx(queryCtx) {}
-
-    IGraphTransformer::TStatus operator()(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
-        YQL_ENSURE(!QueryCtx->PrepareOnly);
+    } 
+ 
+private: 
+    TIntrusivePtr<TKikimrQueryContext> QueryCtx; 
+}; 
+ 
+class TValidatePreparedTransformer { 
+public: 
+    TValidatePreparedTransformer(TIntrusivePtr<TKikimrQueryContext> queryCtx) 
+        : QueryCtx(queryCtx) {} 
+ 
+    IGraphTransformer::TStatus operator()(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) { 
+        YQL_ENSURE(!QueryCtx->PrepareOnly); 
         YQL_ENSURE(QueryCtx->PreparedQuery);
-        YQL_ENSURE(input->Type() == TExprNode::World);
-        output = input;
-
+        YQL_ENSURE(input->Type() == TExprNode::World); 
+        output = input; 
+ 
         for (const auto& paramDesc : QueryCtx->PreparedQuery->GetParameters()) {
             TIssueScopeGuard issueScope(ctx.IssueManager, [input, &paramDesc, &ctx]() {
                 return MakeIntrusive<TIssue>(YqlIssue(ctx.GetPosition(input->Pos()), TIssuesIds::KIKIMR_BAD_REQUEST, TStringBuilder()
-                    << "Failed to parse parameter type: " << paramDesc.GetName()));
-            });
-
-            auto expectedType = ParseTypeFromKikimrProto(paramDesc.GetType(), ctx);
-            if (!expectedType) {
-                return IGraphTransformer::TStatus::Error;
-            }
-
-            if (!ValidateParameter(paramDesc.GetName(), *expectedType, TPosition(), QueryCtx->Parameters, ctx)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-        }
-
-        return IGraphTransformer::TStatus::Ok;
-    }
-
-    static TAutoPtr<IGraphTransformer> Sync(TIntrusivePtr<TKikimrQueryContext> queryCtx) {
-        return CreateFunctorTransformer(TValidatePreparedTransformer(queryCtx));
-    }
-
-private:
-    TIntrusivePtr<TKikimrQueryContext> QueryCtx;
-};
-
-class TExecutePreparedTransformer : public TGraphTransformerBase {
-public:
-    TExecutePreparedTransformer(TIntrusivePtr<TKikimrQueryContext> queryCtx,
-        TIntrusivePtr<TExecuteContext> executeCtx, TIntrusivePtr<IKqpRunner> kqpRunner, const TString& cluster)
-        : QueryCtx(queryCtx)
-        , ExecuteCtx(executeCtx)
-        , KqpRunner(kqpRunner)
-        , Cluster(cluster)
-        , CurrentKqlIndex(0) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        YQL_ENSURE(!QueryCtx->PrepareOnly);
+                    << "Failed to parse parameter type: " << paramDesc.GetName())); 
+            }); 
+ 
+            auto expectedType = ParseTypeFromKikimrProto(paramDesc.GetType(), ctx); 
+            if (!expectedType) { 
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
+            if (!ValidateParameter(paramDesc.GetName(), *expectedType, TPosition(), QueryCtx->Parameters, ctx)) { 
+                return IGraphTransformer::TStatus::Error; 
+            } 
+        } 
+ 
+        return IGraphTransformer::TStatus::Ok; 
+    } 
+ 
+    static TAutoPtr<IGraphTransformer> Sync(TIntrusivePtr<TKikimrQueryContext> queryCtx) { 
+        return CreateFunctorTransformer(TValidatePreparedTransformer(queryCtx)); 
+    } 
+ 
+private: 
+    TIntrusivePtr<TKikimrQueryContext> QueryCtx; 
+}; 
+ 
+class TExecutePreparedTransformer : public TGraphTransformerBase { 
+public: 
+    TExecutePreparedTransformer(TIntrusivePtr<TKikimrQueryContext> queryCtx, 
+        TIntrusivePtr<TExecuteContext> executeCtx, TIntrusivePtr<IKqpRunner> kqpRunner, const TString& cluster) 
+        : QueryCtx(queryCtx) 
+        , ExecuteCtx(executeCtx) 
+        , KqpRunner(kqpRunner) 
+        , Cluster(cluster) 
+        , CurrentKqlIndex(0) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        YQL_ENSURE(!QueryCtx->PrepareOnly); 
         YQL_ENSURE(QueryCtx->PreparedQuery);
-        YQL_ENSURE(input->Type() == TExprNode::World);
-        output = input;
-
-        if (!AsyncResult) {
+        YQL_ENSURE(input->Type() == TExprNode::World); 
+        output = input; 
+ 
+        if (!AsyncResult) { 
             const auto& query = *QueryCtx->PreparedQuery;
             YQL_ENSURE(QueryCtx->Type != EKikimrQueryType::Unspecified);
-
-            if (query.GetVersion() == NKikimrKqp::TPreparedQuery::VERSION_PHYSICAL_V1) {
-                if (CurrentKqlIndex) {
-                    return TStatus::Ok;
-                }
-
+ 
+            if (query.GetVersion() == NKikimrKqp::TPreparedQuery::VERSION_PHYSICAL_V1) { 
+                if (CurrentKqlIndex) { 
+                    return TStatus::Ok; 
+                } 
+ 
                 const auto& phyQuery = query.GetPhysicalQuery();
-
-                if (QueryCtx->Type == EKikimrQueryType::Scan) {
-                    AsyncResult = KqpRunner->ExecutePreparedScanQuery(Cluster, input.Get(), phyQuery, ctx,
-                        ExecuteCtx->ReplyTarget);
-                } else {
-                    YQL_ENSURE(QueryCtx->Type == EKikimrQueryType::Dml);
-                    AsyncResult = KqpRunner->ExecutePreparedQueryNewEngine(Cluster, input.Get(), phyQuery, ctx,
-                        ExecuteCtx->Settings);
-                }
-            } else {
-                if (CurrentKqlIndex >= query.KqlsSize()) {
-                    return TStatus::Ok;
-                }
-
+ 
+                if (QueryCtx->Type == EKikimrQueryType::Scan) { 
+                    AsyncResult = KqpRunner->ExecutePreparedScanQuery(Cluster, input.Get(), phyQuery, ctx, 
+                        ExecuteCtx->ReplyTarget); 
+                } else { 
+                    YQL_ENSURE(QueryCtx->Type == EKikimrQueryType::Dml); 
+                    AsyncResult = KqpRunner->ExecutePreparedQueryNewEngine(Cluster, input.Get(), phyQuery, ctx, 
+                        ExecuteCtx->Settings); 
+                } 
+            } else { 
+                if (CurrentKqlIndex >= query.KqlsSize()) { 
+                    return TStatus::Ok; 
+                } 
+ 
                 const auto& kql = query.GetKqls(CurrentKqlIndex);
-
+ 
                 YQL_ENSURE(QueryCtx->Type == EKikimrQueryType::Dml);
                 YQL_ENSURE(!kql.GetSettings().GetNewEngine());
                 AsyncResult = KqpRunner->ExecutePreparedDataQuery(Cluster, input.Get(), kql, ctx, ExecuteCtx->Settings);
-            }
-        }
-
-        Promise = NewPromise();
-
-        auto promise = Promise;
-        AsyncResult->Continue().Apply([promise](const TFuture<bool>& future) mutable {
-            YQL_ENSURE(future.HasValue());
-            promise.SetValue();
-        });
-
-        return TStatus::Async;
-    }
-
-    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
-        Y_UNUSED(input);
-        return Promise.GetFuture();
-    }
-
+            } 
+        } 
+ 
+        Promise = NewPromise(); 
+ 
+        auto promise = Promise; 
+        AsyncResult->Continue().Apply([promise](const TFuture<bool>& future) mutable { 
+            YQL_ENSURE(future.HasValue()); 
+            promise.SetValue(); 
+        }); 
+ 
+        return TStatus::Async; 
+    } 
+ 
+    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
+        Y_UNUSED(input); 
+        return Promise.GetFuture(); 
+    } 
+ 
     TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext&) final {
-        output = input;
-
-        if (!AsyncResult->HasResult()) {
-            return TStatus::Repeat;
-        }
-
+        output = input; 
+ 
+        if (!AsyncResult->HasResult()) { 
+            return TStatus::Repeat; 
+        } 
+ 
         auto queryResult = std::move(AsyncResult->GetResult());
-        if (!queryResult.Success()) {
-            return TStatus::Error;
-        }
-
+        if (!queryResult.Success()) { 
+            return TStatus::Error; 
+        } 
+ 
         ExecuteCtx->QueryResults.emplace_back(std::move(queryResult));
-
-        ++CurrentKqlIndex;
-        AsyncResult.Reset();
-
-        return TStatus::Repeat;
-    }
-
-    void Rewind() override {
-        CurrentKqlIndex = 0;
-        AsyncResult.Reset();
-    }
-
-private:
-    TIntrusivePtr<TKikimrQueryContext> QueryCtx;
-    TIntrusivePtr<TExecuteContext> ExecuteCtx;
-    TIntrusivePtr<IKqpRunner> KqpRunner;
-    TString Cluster;
-    ui32 CurrentKqlIndex;
-    TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult> AsyncResult;
-    TPromise<void> Promise;
-};
-
-template <typename TResult>
-TResult SyncProcess(TIntrusivePtr<IKikimrAsyncResult<TResult>> asyncResult) {
-    if (asyncResult->HasResult()) {
-        return asyncResult->GetResult();
-    }
-
-    for (;;) {
-        auto future = asyncResult->Continue();
-        future.Wait();
-        bool finished = future.GetValue();
-        if (finished) {
-            return asyncResult->GetResult();
-        }
-    }
-}
-
-template<typename TResult, typename TLambda>
-TIntrusivePtr<IKikimrAsyncResult<TResult>> CheckedProcess(TExprContext& ctx, TLambda&& getResultFunc) {
-    try {
-        auto asyncResult = getResultFunc(ctx);
-        return asyncResult
-            ? asyncResult
-            : MakeKikimrResultHolder(ResultFromErrors<TResult>(ctx.IssueManager.GetIssues()));
-    }
+ 
+        ++CurrentKqlIndex; 
+        AsyncResult.Reset(); 
+ 
+        return TStatus::Repeat; 
+    } 
+ 
+    void Rewind() override { 
+        CurrentKqlIndex = 0; 
+        AsyncResult.Reset(); 
+    } 
+ 
+private: 
+    TIntrusivePtr<TKikimrQueryContext> QueryCtx; 
+    TIntrusivePtr<TExecuteContext> ExecuteCtx; 
+    TIntrusivePtr<IKqpRunner> KqpRunner; 
+    TString Cluster; 
+    ui32 CurrentKqlIndex; 
+    TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult> AsyncResult; 
+    TPromise<void> Promise; 
+}; 
+ 
+template <typename TResult> 
+TResult SyncProcess(TIntrusivePtr<IKikimrAsyncResult<TResult>> asyncResult) { 
+    if (asyncResult->HasResult()) { 
+        return asyncResult->GetResult(); 
+    } 
+ 
+    for (;;) { 
+        auto future = asyncResult->Continue(); 
+        future.Wait(); 
+        bool finished = future.GetValue(); 
+        if (finished) { 
+            return asyncResult->GetResult(); 
+        } 
+    } 
+} 
+ 
+template<typename TResult, typename TLambda> 
+TIntrusivePtr<IKikimrAsyncResult<TResult>> CheckedProcess(TExprContext& ctx, TLambda&& getResultFunc) { 
+    try { 
+        auto asyncResult = getResultFunc(ctx); 
+        return asyncResult 
+            ? asyncResult 
+            : MakeKikimrResultHolder(ResultFromErrors<TResult>(ctx.IssueManager.GetIssues())); 
+    } 
     catch (const std::exception& e) {
-        return MakeKikimrResultHolder(ResultFromException<TResult>(e));
-    }
-}
-
-template<typename TResult, typename TLambda>
-TResult CheckedSyncProcess(TLambda&& getResultFunc) {
-    try {
-        auto asyncResult = getResultFunc();
-        return SyncProcess(asyncResult);
-    }
+        return MakeKikimrResultHolder(ResultFromException<TResult>(e)); 
+    } 
+} 
+ 
+template<typename TResult, typename TLambda> 
+TResult CheckedSyncProcess(TLambda&& getResultFunc) { 
+    try { 
+        auto asyncResult = getResultFunc(); 
+        return SyncProcess(asyncResult); 
+    } 
     catch (const std::exception& e) {
-        return ResultFromException<TResult>(e);
-    }
-}
-
-template<typename TLambda>
-IKqpHost::IAsyncQueryResultPtr CheckedProcessQuery(TExprContext& ctx, TLambda&& getResultFunc) {
-    return CheckedProcess<IKqpHost::TQueryResult>(ctx, getResultFunc);
-}
-
-template<typename TLambda>
-IKqpHost::TQueryResult CheckedSyncProcessQuery(TLambda&& getResultFunc) {
-    return CheckedSyncProcess<IKqpHost::TQueryResult>(getResultFunc);
-}
-
-class TKqpQueryExecutor : public IKikimrQueryExecutor {
-public:
-    TKqpQueryExecutor(const TIntrusivePtr<IKqpGateway>& gateway, const TIntrusivePtr<TKikimrSessionContext>& sessionCtx,
-        const TIntrusivePtr<IKqpRunner>& kqpRunner)
-        : Gateway(gateway)
-        , SessionCtx(sessionCtx)
-        , KqpRunner(kqpRunner) {}
-
+        return ResultFromException<TResult>(e); 
+    } 
+} 
+ 
+template<typename TLambda> 
+IKqpHost::IAsyncQueryResultPtr CheckedProcessQuery(TExprContext& ctx, TLambda&& getResultFunc) { 
+    return CheckedProcess<IKqpHost::TQueryResult>(ctx, getResultFunc); 
+} 
+ 
+template<typename TLambda> 
+IKqpHost::TQueryResult CheckedSyncProcessQuery(TLambda&& getResultFunc) { 
+    return CheckedSyncProcess<IKqpHost::TQueryResult>(getResultFunc); 
+} 
+ 
+class TKqpQueryExecutor : public IKikimrQueryExecutor { 
+public: 
+    TKqpQueryExecutor(const TIntrusivePtr<IKqpGateway>& gateway, const TIntrusivePtr<TKikimrSessionContext>& sessionCtx, 
+        const TIntrusivePtr<IKqpRunner>& kqpRunner) 
+        : Gateway(gateway) 
+        , SessionCtx(sessionCtx) 
+        , KqpRunner(kqpRunner) {} 
+ 
     TIntrusivePtr<TAsyncQueryResult> ExecuteKql(const TString&, const TExprNode::TPtr&, TExprContext&,
         const TExecuteSettings&) override
-    {
-        YQL_ENSURE(false, "Unexpected ExecuteKql call.");
-        return nullptr;
-    }
-
-    TIntrusivePtr<TAsyncQueryResult> ExecuteDataQuery(const TString& cluster, const TExprNode::TPtr& query,
-        TExprContext& ctx, const TExecuteSettings& settings) override
-    {
+    { 
+        YQL_ENSURE(false, "Unexpected ExecuteKql call."); 
+        return nullptr; 
+    } 
+ 
+    TIntrusivePtr<TAsyncQueryResult> ExecuteDataQuery(const TString& cluster, const TExprNode::TPtr& query, 
+        TExprContext& ctx, const TExecuteSettings& settings) override 
+    { 
         auto queryType = SessionCtx->Query().Type;
-
+ 
         YQL_ENSURE(!settings.UseScanQuery ||
                    queryType == EKikimrQueryType::YqlScript ||
                    queryType == EKikimrQueryType::YqlScriptStreaming);
 
-        if (SessionCtx->Query().PrepareOnly) {
+        if (SessionCtx->Query().PrepareOnly) { 
             switch (queryType) {
-                case EKikimrQueryType::Dml:
-                    return KqpRunner->PrepareDataQuery(cluster, query, ctx, settings);
-                case EKikimrQueryType::Scan:
-                    return KqpRunner->PrepareScanQuery(cluster, query, ctx, settings);
+                case EKikimrQueryType::Dml: 
+                    return KqpRunner->PrepareDataQuery(cluster, query, ctx, settings); 
+                case EKikimrQueryType::Scan: 
+                    return KqpRunner->PrepareScanQuery(cluster, query, ctx, settings); 
                 case EKikimrQueryType::YqlScript:
                 case EKikimrQueryType::YqlScriptStreaming:
                     break;
-                default:
+                default: 
                     YQL_ENSURE(false, "Unexpected query type for prepare action: " << queryType);
-                    return nullptr;
-            }
-        }
-
+                    return nullptr; 
+            } 
+        } 
+ 
         switch (queryType) {
             case EKikimrQueryType::YqlScript:
             case EKikimrQueryType::YqlScriptStreaming:
             {
-                YQL_ENSURE(TMaybeNode<TKiDataQuery>(query));
-                TKiDataQuery dataQuery(query);
-
+                YQL_ENSURE(TMaybeNode<TKiDataQuery>(query)); 
+                TKiDataQuery dataQuery(query); 
+ 
                 auto queryAstStr = SerializeExpr(ctx, *query);
-
-                bool useScanQuery = ShouldUseScanQuery(dataQuery, settings);
-
-                IKqpGateway::TAstQuerySettings querySettings;
-                querySettings.StatsMode = GetStatsMode(settings.StatsMode);
-
-                TFuture<TQueryResult> future;
+ 
+                bool useScanQuery = ShouldUseScanQuery(dataQuery, settings); 
+ 
+                IKqpGateway::TAstQuerySettings querySettings; 
+                querySettings.StatsMode = GetStatsMode(settings.StatsMode); 
+ 
+                TFuture<TQueryResult> future; 
                 switch (queryType) {
                 case EKikimrQueryType::YqlScript:
                     if (useScanQuery) {
@@ -849,7 +849,7 @@ public:
                         if (!dataQuery.Results().Empty()) {
                             rowsLimit = FromString<ui64>(dataQuery.Results().Item(0).RowsLimit());
                         }
-
+ 
                         if (SessionCtx->Query().PrepareOnly) {
                             future = Gateway->ExplainScanQueryAst(Cluster, queryAstStr);
                         } else {
@@ -883,185 +883,185 @@ public:
                 default:
                     YQL_ENSURE(false, "Unexpected query type for execute action: " << queryType);
                     return nullptr;
-                }
-
-                return MakeIntrusive<TKikimrFutureResult<TQueryResult>>(future, ctx);
-            }
-
-            default:
+                } 
+ 
+                return MakeIntrusive<TKikimrFutureResult<TQueryResult>>(future, ctx); 
+            } 
+ 
+            default: 
                 YQL_ENSURE(false, "Unexpected query type for execute script action: " << queryType);
-                return nullptr;
-        }
-    }
-
+                return nullptr; 
+        } 
+    } 
+ 
     TIntrusivePtr<TAsyncQueryResult> ExplainDataQuery(const TString&, const TExprNode::TPtr&, TExprContext&) override {
         YQL_ENSURE(false, "Not implemented.");
         return nullptr;
-    }
-
-private:
-    TKqpParamsMap CollectParameters(const TExprNode::TPtr& query) {
-        TKqpParamsMap paramsMap;
-
-        auto queryCtx = SessionCtx->QueryPtr();
-        VisitExpr(query, [queryCtx, &paramsMap] (const TExprNode::TPtr& exprNode) {
-            if (auto parameter = TMaybeNode<TCoParameter>(exprNode)) {
-                TString name(parameter.Cast().Name().Value());
-                auto paramValue = queryCtx->Parameters.FindPtr(name);
-                YQL_ENSURE(paramValue);
-
-                paramsMap.Values.emplace(name, *paramValue);
-            }
-
-            return true;
-        });
-
-        return paramsMap;
-    }
-
-    bool ShouldUseScanQuery(const TKiDataQuery& query, const TExecuteSettings& settings) {
-        if (settings.UseScanQuery) {
-            return *settings.UseScanQuery;
-        }
-
-        if (query.Effects().ArgCount() > 0) {
-            // Do not use ScanQuery for queries with effects.
-            return false;
-        }
-
-        if (query.Results().Size() != 1) {
-            // Do not use ScanQuery for queries with multiple result sets.
-            return false;
-        }
-
-        if (query.Operations().Empty()) {
-            // Do not use ScanQuery for pure queries.
-            return false;
-        }
-
-        for (const auto& operation : query.Operations()) {
-            auto& tableData = SessionCtx->Tables().ExistingTable(operation.Cluster(), operation.Table());
-            if (!tableData.Metadata->SysView.empty()) {
-                // Always use ScanQuery for queries with system tables.
-                return true;
-            }
-        }
-
-        if (!SessionCtx->Config().FeatureFlags.GetEnableImplicitScanQueryInScripts()) {
-            return false;
-        }
-
-        bool hasIndexReads = false;
-        bool hasJoins = false;
-        VisitExpr(query.Results().Ptr(), [&hasIndexReads, &hasJoins] (const TExprNode::TPtr& exprNode) {
-            auto node = TExprBase(exprNode);
-
-            if (auto read = node.Maybe<TKiReadTable>()) {
-                if (const auto& tableKey = read.TableKey().Maybe<TVarArgCallable<TExprBase>>()) {
-                    if (tableKey.Cast().ArgCount() > 1) {
-                        if (auto list = tableKey.Arg(1).Maybe<TExprList>()) {
-                            bool hasViews = std::any_of(list.Cast().begin(), list.Cast().end(),
-                                [](const TExprBase& item) {
-                                    return item.Maybe<TCoAtom>() && item.Cast<TCoAtom>().Value() == "view";
-                                });
-
-                            hasIndexReads = hasIndexReads || hasViews;
-                        }
-                    }
-                }
-
-                return false;
-            }
-
-            if (node.Maybe<TCoEquiJoin>()) {
-                hasJoins = true;
-            }
-
-            return true;
-        });
-
-        if (hasJoins) {
-            // Temporarily disable implicit ScanQuery usage for queries with joins. (KIKIMR-13343)
-            return false;
-        }
-
-        if (hasIndexReads) {
-            // Temporarily disable implicit ScanQuery usage for queries with index reads. (KIKIMR-13295)
-            return false;
-        }
-
-        return true;
-    }
-
-private:
-    TIntrusivePtr<IKqpGateway> Gateway;
-    TString Cluster;
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-    TIntrusivePtr<IKqpRunner> KqpRunner;
-};
-
-class TKqpHost : public IKqpHost {
-public:
+    } 
+ 
+private: 
+    TKqpParamsMap CollectParameters(const TExprNode::TPtr& query) { 
+        TKqpParamsMap paramsMap; 
+ 
+        auto queryCtx = SessionCtx->QueryPtr(); 
+        VisitExpr(query, [queryCtx, &paramsMap] (const TExprNode::TPtr& exprNode) { 
+            if (auto parameter = TMaybeNode<TCoParameter>(exprNode)) { 
+                TString name(parameter.Cast().Name().Value()); 
+                auto paramValue = queryCtx->Parameters.FindPtr(name); 
+                YQL_ENSURE(paramValue); 
+ 
+                paramsMap.Values.emplace(name, *paramValue); 
+            } 
+ 
+            return true; 
+        }); 
+ 
+        return paramsMap; 
+    } 
+ 
+    bool ShouldUseScanQuery(const TKiDataQuery& query, const TExecuteSettings& settings) { 
+        if (settings.UseScanQuery) { 
+            return *settings.UseScanQuery; 
+        } 
+ 
+        if (query.Effects().ArgCount() > 0) { 
+            // Do not use ScanQuery for queries with effects. 
+            return false; 
+        } 
+ 
+        if (query.Results().Size() != 1) { 
+            // Do not use ScanQuery for queries with multiple result sets. 
+            return false; 
+        } 
+ 
+        if (query.Operations().Empty()) { 
+            // Do not use ScanQuery for pure queries. 
+            return false; 
+        } 
+ 
+        for (const auto& operation : query.Operations()) { 
+            auto& tableData = SessionCtx->Tables().ExistingTable(operation.Cluster(), operation.Table()); 
+            if (!tableData.Metadata->SysView.empty()) { 
+                // Always use ScanQuery for queries with system tables. 
+                return true; 
+            } 
+        } 
+ 
+        if (!SessionCtx->Config().FeatureFlags.GetEnableImplicitScanQueryInScripts()) { 
+            return false; 
+        } 
+ 
+        bool hasIndexReads = false; 
+        bool hasJoins = false; 
+        VisitExpr(query.Results().Ptr(), [&hasIndexReads, &hasJoins] (const TExprNode::TPtr& exprNode) { 
+            auto node = TExprBase(exprNode); 
+ 
+            if (auto read = node.Maybe<TKiReadTable>()) { 
+                if (const auto& tableKey = read.TableKey().Maybe<TVarArgCallable<TExprBase>>()) { 
+                    if (tableKey.Cast().ArgCount() > 1) { 
+                        if (auto list = tableKey.Arg(1).Maybe<TExprList>()) { 
+                            bool hasViews = std::any_of(list.Cast().begin(), list.Cast().end(), 
+                                [](const TExprBase& item) { 
+                                    return item.Maybe<TCoAtom>() && item.Cast<TCoAtom>().Value() == "view"; 
+                                }); 
+ 
+                            hasIndexReads = hasIndexReads || hasViews; 
+                        } 
+                    } 
+                } 
+ 
+                return false; 
+            } 
+ 
+            if (node.Maybe<TCoEquiJoin>()) { 
+                hasJoins = true; 
+            } 
+ 
+            return true; 
+        }); 
+ 
+        if (hasJoins) { 
+            // Temporarily disable implicit ScanQuery usage for queries with joins. (KIKIMR-13343) 
+            return false; 
+        } 
+ 
+        if (hasIndexReads) { 
+            // Temporarily disable implicit ScanQuery usage for queries with index reads. (KIKIMR-13295) 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+private: 
+    TIntrusivePtr<IKqpGateway> Gateway; 
+    TString Cluster; 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+    TIntrusivePtr<IKqpRunner> KqpRunner; 
+}; 
+ 
+class TKqpHost : public IKqpHost { 
+public: 
     TKqpHost(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, const TString& database,
-        TKikimrConfiguration::TPtr config, IModuleResolver::TPtr moduleResolver,
-        const NKikimr::NMiniKQL::IFunctionRegistry* funcRegistry, bool keepConfigChanges)
-        : Gateway(gateway)
-        , Cluster(cluster)
-        , ExprCtx(new TExprContext())
-        , ModuleResolver(moduleResolver)
-        , KeepConfigChanges(keepConfigChanges)
-        , SessionCtx(new TKikimrSessionContext(config))
+        TKikimrConfiguration::TPtr config, IModuleResolver::TPtr moduleResolver, 
+        const NKikimr::NMiniKQL::IFunctionRegistry* funcRegistry, bool keepConfigChanges) 
+        : Gateway(gateway) 
+        , Cluster(cluster) 
+        , ExprCtx(new TExprContext()) 
+        , ModuleResolver(moduleResolver) 
+        , KeepConfigChanges(keepConfigChanges) 
+        , SessionCtx(new TKikimrSessionContext(config)) 
         , ClustersMap({{Cluster, TString(KikimrProviderName)}})
-        , TypesCtx(MakeIntrusive<TTypeAnnotationContext>())
-        , PlanBuilder(CreatePlanBuilder(*TypesCtx))
-        , FakeWorld(ExprCtx->NewWorld(TPosition()))
-        , ExecuteCtx(MakeIntrusive<TExecuteContext>())
-        , ImplicitTransaction(MakeIntrusive<TKqpTransactionContext>(true))
-        , ExplicitTransactions(MaxActiveTx())
-    {
-        if (funcRegistry) {
-            FuncRegistry = funcRegistry;
-        } else {
+        , TypesCtx(MakeIntrusive<TTypeAnnotationContext>()) 
+        , PlanBuilder(CreatePlanBuilder(*TypesCtx)) 
+        , FakeWorld(ExprCtx->NewWorld(TPosition())) 
+        , ExecuteCtx(MakeIntrusive<TExecuteContext>()) 
+        , ImplicitTransaction(MakeIntrusive<TKqpTransactionContext>(true)) 
+        , ExplicitTransactions(MaxActiveTx()) 
+    { 
+        if (funcRegistry) { 
+            FuncRegistry = funcRegistry; 
+        } else { 
             FuncRegistryHolder = NMiniKQL::CreateFunctionRegistry(NMiniKQL::CreateBuiltinRegistry());
-            FuncRegistry = FuncRegistryHolder.Get();
-        }
-
+            FuncRegistry = FuncRegistryHolder.Get(); 
+        } 
+ 
         SessionCtx->SetDatabase(database);
         SessionCtx->QueryPtr()->TimeProvider = TAppData::TimeProvider;
         SessionCtx->QueryPtr()->RandomProvider = TAppData::RandomProvider;
 
-        KqpRunner = CreateKqpRunner(Gateway, Cluster, TypesCtx, SessionCtx, *FuncRegistry);
-
-        ExprCtx->NodesAllocationLimit = SessionCtx->Config()._KqpExprNodesAllocationLimit.Get().GetRef();
-        ExprCtx->StringsAllocationLimit = SessionCtx->Config()._KqpExprStringsAllocationLimit.Get().GetRef();
-
-        // Kikimr provider
-        auto queryExecutor = MakeIntrusive<TKqpQueryExecutor>(Gateway, SessionCtx, KqpRunner);
-        auto kikimrDataSource = CreateKikimrDataSource(*FuncRegistry, *TypesCtx, Gateway, SessionCtx);
-        auto kikimrDataSink = CreateKikimrDataSink(*FuncRegistry, *TypesCtx, Gateway, SessionCtx, queryExecutor);
-
-        FillSettings.AllResultsBytesLimit = Nothing();
-        FillSettings.RowsLimitPerWrite = SessionCtx->Config()._ResultRowsLimit.Get().GetRef();
-        FillSettings.Format = IDataProvider::EResultFormat::Custom;
-        FillSettings.FormatDetails = TString(KikimrMkqlProtoFormat);
-
+        KqpRunner = CreateKqpRunner(Gateway, Cluster, TypesCtx, SessionCtx, *FuncRegistry); 
+ 
+        ExprCtx->NodesAllocationLimit = SessionCtx->Config()._KqpExprNodesAllocationLimit.Get().GetRef(); 
+        ExprCtx->StringsAllocationLimit = SessionCtx->Config()._KqpExprStringsAllocationLimit.Get().GetRef(); 
+ 
+        // Kikimr provider 
+        auto queryExecutor = MakeIntrusive<TKqpQueryExecutor>(Gateway, SessionCtx, KqpRunner); 
+        auto kikimrDataSource = CreateKikimrDataSource(*FuncRegistry, *TypesCtx, Gateway, SessionCtx); 
+        auto kikimrDataSink = CreateKikimrDataSink(*FuncRegistry, *TypesCtx, Gateway, SessionCtx, queryExecutor); 
+ 
+        FillSettings.AllResultsBytesLimit = Nothing(); 
+        FillSettings.RowsLimitPerWrite = SessionCtx->Config()._ResultRowsLimit.Get().GetRef(); 
+        FillSettings.Format = IDataProvider::EResultFormat::Custom; 
+        FillSettings.FormatDetails = TString(KikimrMkqlProtoFormat); 
+ 
         TypesCtx->AddDataSource(KikimrProviderName, kikimrDataSource);
         TypesCtx->AddDataSink(KikimrProviderName, kikimrDataSink);
-        TypesCtx->UdfResolver = CreateSimpleUdfResolver(FuncRegistry);
+        TypesCtx->UdfResolver = CreateSimpleUdfResolver(FuncRegistry); 
         TypesCtx->TimeProvider = TAppData::TimeProvider;
         TypesCtx->RandomProvider = TAppData::RandomProvider;
-        TypesCtx->Modules = ModuleResolver;
+        TypesCtx->Modules = ModuleResolver; 
         TypesCtx->UserDataStorage = MakeIntrusive<TUserDataStorage>(nullptr, TUserDataTable(), nullptr, nullptr);
         TypesCtx->JsonQueryReturnsJsonDocument = true;
-
-        // Result provider
-        auto writerFactory = [] () { return MakeIntrusive<TKqpResultWriter>(); };
+ 
+        // Result provider 
+        auto writerFactory = [] () { return MakeIntrusive<TKqpResultWriter>(); }; 
         ResultProviderConfig = MakeIntrusive<TResultProviderConfig>(*TypesCtx, *FuncRegistry, FillSettings.Format,
-            FillSettings.FormatDetails, writerFactory);
+            FillSettings.FormatDetails, writerFactory); 
         auto resultProvider = CreateResultProvider(ResultProviderConfig);
         TypesCtx->AddDataSink(ResultProviderName, resultProvider);
         TypesCtx->AvailablePureResultDataSources = TVector<TString>(1, TString(KikimrProviderName));
-
+ 
         // Config provider
         const TGatewaysConfig* gatewaysConfig = nullptr; // TODO: can we get real gatewaysConfig here?
         auto allowSettings = [](TStringBuf settingName) {
@@ -1070,9 +1070,9 @@ public:
         auto configProvider = CreateConfigProvider(*TypesCtx, gatewaysConfig, allowSettings);
         TypesCtx->AddDataSource(ConfigProviderName, configProvider);
 
-        YQL_ENSURE(TypesCtx->Initialize(*ExprCtx));
-
-        YqlTransformer = TTransformationPipeline(TypesCtx)
+        YQL_ENSURE(TypesCtx->Initialize(*ExprCtx)); 
+ 
+        YqlTransformer = TTransformationPipeline(TypesCtx) 
             .AddServiceTransformers()
             .Add(TLogExprTransformer::Sync("YqlTransformer", NYql::NLog::EComponent::ProviderKqp,
                 NYql::NLog::ELevel::TRACE), "LogYqlTransform")
@@ -1084,99 +1084,99 @@ public:
             .Add(TCollectParametersTransformer::Sync(SessionCtx->QueryPtr()), "CollectParameters")
             .AddPostTypeAnnotation()
             .AddOptimization(true, false)
-            .Add(TLogExprTransformer::Sync("Optimized expr"), "LogExpr")
+            .Add(TLogExprTransformer::Sync("Optimized expr"), "LogExpr") 
             .AddRun(&NullProgressWriter)
-            .Build();
-
-        DataQueryAstTransformer = TTransformationPipeline(TypesCtx)
-            .AddServiceTransformers()
-            .AddIntentDeterminationTransformer()
-            .AddTableMetadataLoaderTransformer()
-            .AddTypeAnnotationTransformer()
-            .Add(new TPrepareDataQueryAstTransformer(Cluster, ExecuteCtx, SessionCtx->QueryPtr(), KqpRunner),
-                "PrepareDataQueryAst")
-            .Build();
-
-        ExecutePreparedTransformer = TTransformationPipeline(TypesCtx)
-            .AddServiceTransformers()
-            .Add(TValidatePreparedTransformer::Sync(SessionCtx->QueryPtr()), "ValidatePrepared")
-            .Add(new TExecutePreparedTransformer(SessionCtx->QueryPtr(), ExecuteCtx, KqpRunner, Cluster),
-                "ExecutePrepared", TIssuesIds::CORE_EXEC)
-            .Build();
-    }
-
-    IAsyncQueryResultPtr ExecuteSchemeQuery(const TString& query, bool isSql) override {
-        return CheckedProcessQuery(*ExprCtx,
+            .Build(); 
+ 
+        DataQueryAstTransformer = TTransformationPipeline(TypesCtx) 
+            .AddServiceTransformers() 
+            .AddIntentDeterminationTransformer() 
+            .AddTableMetadataLoaderTransformer() 
+            .AddTypeAnnotationTransformer() 
+            .Add(new TPrepareDataQueryAstTransformer(Cluster, ExecuteCtx, SessionCtx->QueryPtr(), KqpRunner), 
+                "PrepareDataQueryAst") 
+            .Build(); 
+ 
+        ExecutePreparedTransformer = TTransformationPipeline(TypesCtx) 
+            .AddServiceTransformers() 
+            .Add(TValidatePreparedTransformer::Sync(SessionCtx->QueryPtr()), "ValidatePrepared") 
+            .Add(new TExecutePreparedTransformer(SessionCtx->QueryPtr(), ExecuteCtx, KqpRunner, Cluster), 
+                "ExecutePrepared", TIssuesIds::CORE_EXEC) 
+            .Build(); 
+    } 
+ 
+    IAsyncQueryResultPtr ExecuteSchemeQuery(const TString& query, bool isSql) override { 
+        return CheckedProcessQuery(*ExprCtx, 
             [this, &query, isSql] (TExprContext& ctx) {
-                return ExecuteSchemeQueryInternal(query, isSql, ctx);
-            });
-    }
-
-    TQueryResult SyncExecuteSchemeQuery(const TString& query, bool isSql) override {
-        return CheckedSyncProcessQuery(
+                return ExecuteSchemeQueryInternal(query, isSql, ctx); 
+            }); 
+    } 
+ 
+    TQueryResult SyncExecuteSchemeQuery(const TString& query, bool isSql) override { 
+        return CheckedSyncProcessQuery( 
             [this, &query, isSql] () {
-                return ExecuteSchemeQuery(query, isSql);
-            });
-    }
-
-    TBeginTxResult BeginTransaction(NKikimrKqp::EIsolationLevel isolationLevel, bool readonly) override {
-        try {
-            return BeginTransactionInternal(isolationLevel, readonly);
-        }
-        catch (const std::exception& e) {
-            return ResultFromException<TBeginTxResult>(e);
-        }
-    }
-
+                return ExecuteSchemeQuery(query, isSql); 
+            }); 
+    } 
+ 
+    TBeginTxResult BeginTransaction(NKikimrKqp::EIsolationLevel isolationLevel, bool readonly) override { 
+        try { 
+            return BeginTransactionInternal(isolationLevel, readonly); 
+        } 
+        catch (const std::exception& e) { 
+            return ResultFromException<TBeginTxResult>(e); 
+        } 
+    } 
+ 
     TGenericResult DeleteTransaction(const TString& txId) override {
-        try {
-            return DeleteTransactionInternal(txId);
-        }
-        catch (const std::exception& e) {
-            return ResultFromException<TGenericResult>(e);
-        }
-    }
-
+        try { 
+            return DeleteTransactionInternal(txId); 
+        } 
+        catch (const std::exception& e) { 
+            return ResultFromException<TGenericResult>(e); 
+        } 
+    } 
+ 
     IAsyncQueryResultPtr RollbackTransaction(const TString& txId,
         const IKikimrQueryExecutor::TExecuteSettings& settings) override
     {
-        return CheckedProcessQuery(*ExprCtx,
+        return CheckedProcessQuery(*ExprCtx, 
             [this, txId, settings] (TExprContext& ctx) {
                 return RollbackTransactionInternal(txId, settings, ctx);
-            });
-    }
-
+            }); 
+    } 
+ 
     TQueryResult SyncRollbackTransaction(const TString& txId,
         const IKikimrQueryExecutor::TExecuteSettings& settings) override
     {
-        return CheckedSyncProcessQuery(
+        return CheckedSyncProcessQuery( 
             [this, txId, settings] () {
                 return RollbackTransaction(txId, settings);
-            });
-    }
-
-    IAsyncQueryResultPtr CommitTransaction(const TString& txId,
-        const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        return CheckedProcessQuery(*ExprCtx,
-            [this, txId, settings] (TExprContext& ctx) {
-                return CommitTransactionInternal(txId, settings, ctx);
-            });
-    }
-
-    TQueryResult SyncCommitTransaction(const TString& txId,
-        const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        return CheckedSyncProcessQuery(
-            [this, txId, settings] () {
-                return CommitTransaction(txId, settings);
-            });
-    }
-
-    TMaybe<TKqpTransactionInfo> GetTransactionInfo() override {
-        return ImplicitTransaction->GetInfo();
-    }
-
+            }); 
+    } 
+ 
+    IAsyncQueryResultPtr CommitTransaction(const TString& txId, 
+        const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        return CheckedProcessQuery(*ExprCtx, 
+            [this, txId, settings] (TExprContext& ctx) { 
+                return CommitTransactionInternal(txId, settings, ctx); 
+            }); 
+    } 
+ 
+    TQueryResult SyncCommitTransaction(const TString& txId, 
+        const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        return CheckedSyncProcessQuery( 
+            [this, txId, settings] () { 
+                return CommitTransaction(txId, settings); 
+            }); 
+    } 
+ 
+    TMaybe<TKqpTransactionInfo> GetTransactionInfo() override { 
+        return ImplicitTransaction->GetInfo(); 
+    } 
+ 
     void ForceTxOldEngine(const TString& txId) override {
         if (auto tx = FindTransaction(txId)) {
             (*tx)->ForceOldEngine();
@@ -1189,67 +1189,67 @@ public:
         }
     }
 
-    TMaybe<TKqpTransactionInfo> GetTransactionInfo(const TString& txId) override {
-        auto tx = FindTransaction(txId);
-        if (!tx) {
-            return TMaybe<TKqpTransactionInfo>();
-        }
-
-        auto txCtx = *tx;
-        if (txCtx->IsClosed()) {
-            RemoveTransaction(txId);
-        }
-
-        if (txCtx->IsInvalidated() && SessionCtx->Config()._KqpRollbackInvalidatedTx.Get().GetRef()) {
-            AbortTransaction(txId);
-        }
-
-        return txCtx->GetInfo();
-    }
-
-    bool AbortTransaction(const TString& txId) override {
-        auto it = ExplicitTransactions.FindWithoutPromote(txId);
-        if (it != ExplicitTransactions.End()) {
-            AbortTransaction(it);
-            return true;
-        }
-
-        return false;
-    }
-
-    ui32 AbortAll() override {
-        auto abortedCount = ExplicitTransactions.Size();
-
-        for (auto it = ExplicitTransactions.Begin(); it != ExplicitTransactions.End(); ++it) {
-            it.Value()->Invalidate();
-            AbortedTransactions.emplace(std::make_pair(it.Key(), it.Value()));
-        }
-
-        ExplicitTransactions.Clear();
-        return abortedCount;
-    }
-
+    TMaybe<TKqpTransactionInfo> GetTransactionInfo(const TString& txId) override { 
+        auto tx = FindTransaction(txId); 
+        if (!tx) { 
+            return TMaybe<TKqpTransactionInfo>(); 
+        } 
+ 
+        auto txCtx = *tx; 
+        if (txCtx->IsClosed()) { 
+            RemoveTransaction(txId); 
+        } 
+ 
+        if (txCtx->IsInvalidated() && SessionCtx->Config()._KqpRollbackInvalidatedTx.Get().GetRef()) { 
+            AbortTransaction(txId); 
+        } 
+ 
+        return txCtx->GetInfo(); 
+    } 
+ 
+    bool AbortTransaction(const TString& txId) override { 
+        auto it = ExplicitTransactions.FindWithoutPromote(txId); 
+        if (it != ExplicitTransactions.End()) { 
+            AbortTransaction(it); 
+            return true; 
+        } 
+ 
+        return false; 
+    } 
+ 
+    ui32 AbortAll() override { 
+        auto abortedCount = ExplicitTransactions.Size(); 
+ 
+        for (auto it = ExplicitTransactions.Begin(); it != ExplicitTransactions.End(); ++it) { 
+            it.Value()->Invalidate(); 
+            AbortedTransactions.emplace(std::make_pair(it.Key(), it.Value())); 
+        } 
+ 
+        ExplicitTransactions.Clear(); 
+        return abortedCount; 
+    } 
+ 
     IAsyncQueryResultPtr RollbackAborted() override {
-        return CheckedProcessQuery(*ExprCtx,
+        return CheckedProcessQuery(*ExprCtx, 
             [this] (TExprContext& ctx) {
                 return RollbackAbortedInternal(ctx);
-            });
-    }
-
+            }); 
+    } 
+ 
     TQueryResult SyncRollbackAborted() override {
-        return CheckedSyncProcessQuery(
+        return CheckedSyncProcessQuery( 
             [this] () {
                 return RollbackAborted();
-            });
-    }
-
-    IAsyncQueryResultPtr ExplainDataQuery(const TString& query, bool isSql) override {
-        return CheckedProcessQuery(*ExprCtx,
-            [this, &query, isSql] (TExprContext& ctx) {
-                return ExplainDataQueryInternal(query, isSql, ctx);
-            });
-    }
-
+            }); 
+    } 
+ 
+    IAsyncQueryResultPtr ExplainDataQuery(const TString& query, bool isSql) override { 
+        return CheckedProcessQuery(*ExprCtx, 
+            [this, &query, isSql] (TExprContext& ctx) { 
+                return ExplainDataQueryInternal(query, isSql, ctx); 
+            }); 
+    } 
+ 
     IAsyncQueryResultPtr ExplainScanQuery(const TString& query, bool isSql) override {
         return CheckedProcessQuery(*ExprCtx,
             [this, &query, isSql] (TExprContext& ctx) {
@@ -1257,81 +1257,81 @@ public:
             });
     }
 
-    TQueryResult SyncExplainDataQuery(const TString& query, bool isSql) override {
-        return CheckedSyncProcessQuery(
-            [this, &query, isSql] () {
-                return ExplainDataQuery(query, isSql);
-            });
-    }
-
-    IAsyncQueryResultPtr PrepareDataQuery(const TString& query, const TPrepareSettings& settings) override {
-        return CheckedProcessQuery(*ExprCtx,
+    TQueryResult SyncExplainDataQuery(const TString& query, bool isSql) override { 
+        return CheckedSyncProcessQuery( 
+            [this, &query, isSql] () { 
+                return ExplainDataQuery(query, isSql); 
+            }); 
+    } 
+ 
+    IAsyncQueryResultPtr PrepareDataQuery(const TString& query, const TPrepareSettings& settings) override { 
+        return CheckedProcessQuery(*ExprCtx, 
             [this, &query, settings] (TExprContext& ctx) mutable {
-                return PrepareDataQueryInternal(query, settings, ctx);
-            });
-    }
-
-    TQueryResult SyncPrepareDataQuery(const TString& query, const TPrepareSettings& settings) override {
-        return CheckedSyncProcessQuery(
+                return PrepareDataQueryInternal(query, settings, ctx); 
+            }); 
+    } 
+ 
+    TQueryResult SyncPrepareDataQuery(const TString& query, const TPrepareSettings& settings) override { 
+        return CheckedSyncProcessQuery( 
             [this, &query, settings] () mutable {
-                return PrepareDataQuery(query, settings);
-            });
-    }
-
+                return PrepareDataQuery(query, settings); 
+            }); 
+    } 
+ 
     IAsyncQueryResultPtr ExecuteDataQuery(const TString& txId, std::shared_ptr<const NKikimrKqp::TPreparedQuery>& query,
-        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        return CheckedProcessQuery(*ExprCtx,
-            [this, txId, &query, parameters = std::move(parameters), settings] (TExprContext& ctx) mutable {
-                return ExecuteDataQueryInternal(txId, query, std::move(parameters), settings, {}, {}, ctx);
-            });
-    }
-
+        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        return CheckedProcessQuery(*ExprCtx, 
+            [this, txId, &query, parameters = std::move(parameters), settings] (TExprContext& ctx) mutable { 
+                return ExecuteDataQueryInternal(txId, query, std::move(parameters), settings, {}, {}, ctx); 
+            }); 
+    } 
+ 
     TQueryResult SyncExecuteDataQuery(const TString& txId, std::shared_ptr<const NKikimrKqp::TPreparedQuery>& query,
-        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        return CheckedSyncProcessQuery(
-            [this, txId, &query, parameters = std::move(parameters), settings] () mutable {
-                return ExecuteDataQuery(txId, query, std::move(parameters), settings);
-            });
-    }
-
-    IAsyncQueryResultPtr ExecuteDataQuery(const TString& txId, const TString& query, bool isSql,
-        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        return CheckedProcessQuery(*ExprCtx,
-            [this, txId, &query, isSql, parameters = std::move(parameters), settings] (TExprContext& ctx) mutable {
-                return ExecuteDataQueryInternal(txId, query, isSql, std::move(parameters), settings, ctx);
-            });
-    }
-
-    TQueryResult SyncExecuteDataQuery(const TString& txId, const TString& query, bool isSql,
-        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        return CheckedSyncProcessQuery(
-            [this, txId, &query, isSql, parameters = std::move(parameters), settings] () mutable {
-                return ExecuteDataQuery(txId, query, isSql, std::move(parameters), settings);
-            });
-    }
-
-    IAsyncQueryResultPtr ExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters,
-        const TExecScriptSettings& settings) override
-    {
-        return CheckedProcessQuery(*ExprCtx,
-            [this, &script, parameters = std::move(parameters), settings] (TExprContext& ctx) mutable {
-                return ExecuteYqlScriptInternal(script, std::move(parameters), settings, ctx);
-            });
-    }
-
-    TQueryResult SyncExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters,
-        const TExecScriptSettings& settings) override
-    {
-        return CheckedSyncProcessQuery(
-            [this, &script, parameters = std::move(parameters), settings] () mutable {
-                return ExecuteYqlScript(script, std::move(parameters), settings);
-            });
-    }
-
+        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        return CheckedSyncProcessQuery( 
+            [this, txId, &query, parameters = std::move(parameters), settings] () mutable { 
+                return ExecuteDataQuery(txId, query, std::move(parameters), settings); 
+            }); 
+    } 
+ 
+    IAsyncQueryResultPtr ExecuteDataQuery(const TString& txId, const TString& query, bool isSql, 
+        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        return CheckedProcessQuery(*ExprCtx, 
+            [this, txId, &query, isSql, parameters = std::move(parameters), settings] (TExprContext& ctx) mutable { 
+                return ExecuteDataQueryInternal(txId, query, isSql, std::move(parameters), settings, ctx); 
+            }); 
+    } 
+ 
+    TQueryResult SyncExecuteDataQuery(const TString& txId, const TString& query, bool isSql, 
+        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        return CheckedSyncProcessQuery( 
+            [this, txId, &query, isSql, parameters = std::move(parameters), settings] () mutable { 
+                return ExecuteDataQuery(txId, query, isSql, std::move(parameters), settings); 
+            }); 
+    } 
+ 
+    IAsyncQueryResultPtr ExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters, 
+        const TExecScriptSettings& settings) override 
+    { 
+        return CheckedProcessQuery(*ExprCtx, 
+            [this, &script, parameters = std::move(parameters), settings] (TExprContext& ctx) mutable { 
+                return ExecuteYqlScriptInternal(script, std::move(parameters), settings, ctx); 
+            }); 
+    } 
+ 
+    TQueryResult SyncExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters, 
+        const TExecScriptSettings& settings) override 
+    { 
+        return CheckedSyncProcessQuery( 
+            [this, &script, parameters = std::move(parameters), settings] () mutable { 
+                return ExecuteYqlScript(script, std::move(parameters), settings); 
+            }); 
+    } 
+ 
     IAsyncQueryResultPtr StreamExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters,
         const NActors::TActorId& target, const TExecScriptSettings& settings) override
     {
@@ -1355,261 +1355,261 @@ public:
         });
     }
 
-    IAsyncQueryResultPtr ExplainYqlScript(const TString& script) override {
-        return CheckedProcessQuery(*ExprCtx,
-            [this, &script] (TExprContext& ctx) mutable {
-                return ExplainYqlScriptInternal(script, ctx);
-            });
-    }
-
-    TQueryResult SyncExplainYqlScript(const TString& script) override {
-        return CheckedSyncProcessQuery(
-            [this, &script] () mutable {
-                return ExplainYqlScript(script);
-            });
-    }
-
-    IAsyncQueryResultPtr ExecuteScanQuery(const TString& query, bool isSql, NKikimrMiniKQL::TParams&& parameters,
+    IAsyncQueryResultPtr ExplainYqlScript(const TString& script) override { 
+        return CheckedProcessQuery(*ExprCtx, 
+            [this, &script] (TExprContext& ctx) mutable { 
+                return ExplainYqlScriptInternal(script, ctx); 
+            }); 
+    } 
+ 
+    TQueryResult SyncExplainYqlScript(const TString& script) override { 
+        return CheckedSyncProcessQuery( 
+            [this, &script] () mutable { 
+                return ExplainYqlScript(script); 
+            }); 
+    } 
+ 
+    IAsyncQueryResultPtr ExecuteScanQuery(const TString& query, bool isSql, NKikimrMiniKQL::TParams&& parameters, 
         const NActors::TActorId& target, const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        return CheckedProcessQuery(*ExprCtx,
-            [this, &query, isSql, parameters = std::move(parameters), target, settings] (TExprContext& ctx) mutable {
-                return ExecuteScanQueryInternal(query, isSql, std::move(parameters), target, settings, ctx);
-            });
-    }
-
-private:
-    ui32 MaxActiveTx() const {
-        return SessionCtx->Config()._KqpMaxActiveTxPerSession.Get().GetRef();
-    }
-
-    TMaybe<TIntrusivePtr<TKqpTransactionContext>> FindTransaction(const TString& id) {
-        auto it = ExplicitTransactions.Find(id);
-        if (it != ExplicitTransactions.End()) {
-            auto& value = it.Value();
-            value->Touch();
-            return value;
-        }
-
-        return {};
-    }
-
-    void RemoveTransaction(const TString& txId) {
-        auto it = ExplicitTransactions.FindWithoutPromote(txId);
-        if (it != ExplicitTransactions.End()) {
-            ExplicitTransactions.Erase(it);
-        }
-    }
-
-    void AbortTransaction(const TLRUCache<TString, TIntrusivePtr<TKqpTransactionContext>>::TIterator& it) {
-        it.Value()->Invalidate();
-        AbortedTransactions.emplace(std::make_pair(it.Key(), it.Value()));
-        ExplicitTransactions.Erase(it);
-    }
-
-    TExprNode::TPtr CompileQuery(const TString& query, bool isSql, bool sqlAutoCommit, TExprContext& ctx,
-        TMaybe<TSqlVersion>& sqlVersion) const
-    {
-        TAstParseResult astRes;
-        if (isSql) {
-            NSQLTranslation::TTranslationSettings settings;
-
-            if (sqlVersion) {
-                settings.SyntaxVersion = *sqlVersion;
-
-                if (*sqlVersion > 0) {
-                    // Restrict fallback to V0
-                    settings.V0Behavior = NSQLTranslation::EV0Behavior::Disable;
-                }
-            } else {
-                settings.SyntaxVersion = SessionCtx->Config()._KqpYqlSyntaxVersion.Get().GetRef();
-                settings.V0Behavior = NSQLTranslation::EV0Behavior::Silent;
-            }
-
+    { 
+        return CheckedProcessQuery(*ExprCtx, 
+            [this, &query, isSql, parameters = std::move(parameters), target, settings] (TExprContext& ctx) mutable { 
+                return ExecuteScanQueryInternal(query, isSql, std::move(parameters), target, settings, ctx); 
+            }); 
+    } 
+ 
+private: 
+    ui32 MaxActiveTx() const { 
+        return SessionCtx->Config()._KqpMaxActiveTxPerSession.Get().GetRef(); 
+    } 
+ 
+    TMaybe<TIntrusivePtr<TKqpTransactionContext>> FindTransaction(const TString& id) { 
+        auto it = ExplicitTransactions.Find(id); 
+        if (it != ExplicitTransactions.End()) { 
+            auto& value = it.Value(); 
+            value->Touch(); 
+            return value; 
+        } 
+ 
+        return {}; 
+    } 
+ 
+    void RemoveTransaction(const TString& txId) { 
+        auto it = ExplicitTransactions.FindWithoutPromote(txId); 
+        if (it != ExplicitTransactions.End()) { 
+            ExplicitTransactions.Erase(it); 
+        } 
+    } 
+ 
+    void AbortTransaction(const TLRUCache<TString, TIntrusivePtr<TKqpTransactionContext>>::TIterator& it) { 
+        it.Value()->Invalidate(); 
+        AbortedTransactions.emplace(std::make_pair(it.Key(), it.Value())); 
+        ExplicitTransactions.Erase(it); 
+    } 
+ 
+    TExprNode::TPtr CompileQuery(const TString& query, bool isSql, bool sqlAutoCommit, TExprContext& ctx, 
+        TMaybe<TSqlVersion>& sqlVersion) const 
+    { 
+        TAstParseResult astRes; 
+        if (isSql) { 
+            NSQLTranslation::TTranslationSettings settings; 
+ 
+            if (sqlVersion) { 
+                settings.SyntaxVersion = *sqlVersion; 
+ 
+                if (*sqlVersion > 0) { 
+                    // Restrict fallback to V0 
+                    settings.V0Behavior = NSQLTranslation::EV0Behavior::Disable; 
+                } 
+            } else { 
+                settings.SyntaxVersion = SessionCtx->Config()._KqpYqlSyntaxVersion.Get().GetRef(); 
+                settings.V0Behavior = NSQLTranslation::EV0Behavior::Silent; 
+            } 
+ 
             settings.InferSyntaxVersion = true;
             settings.V0ForceDisable = false;
             settings.WarnOnV0 = false;
-            settings.DefaultCluster = Cluster;
+            settings.DefaultCluster = Cluster; 
             settings.ClusterMapping = ClustersMap;
-            auto tablePathPrefix = SessionCtx->Config()._KqpTablePathPrefix.Get().GetRef();
-            if (!tablePathPrefix.empty()) {
-                settings.PathPrefix = tablePathPrefix;
-            }
-            settings.EndOfQueryCommit = sqlAutoCommit;
-
+            auto tablePathPrefix = SessionCtx->Config()._KqpTablePathPrefix.Get().GetRef(); 
+            if (!tablePathPrefix.empty()) { 
+                settings.PathPrefix = tablePathPrefix; 
+            } 
+            settings.EndOfQueryCommit = sqlAutoCommit; 
+ 
             ui16 actualSyntaxVersion = 0;
             astRes = NSQLTranslation::SqlToYql(query, settings, nullptr, &actualSyntaxVersion);
             TypesCtx->DeprecatedSQL = (actualSyntaxVersion == 0);
-            sqlVersion = actualSyntaxVersion;
-        } else {
-            sqlVersion = {};
-            astRes = ParseAst(query);
-
-            // Do not check SQL constraints on s-expressions input, as it may come from both V0/V1.
-            // Constraints were already checked on type annotation of SQL query.
-            TypesCtx->DeprecatedSQL = true;
-        }
-
+            sqlVersion = actualSyntaxVersion; 
+        } else { 
+            sqlVersion = {}; 
+            astRes = ParseAst(query); 
+ 
+            // Do not check SQL constraints on s-expressions input, as it may come from both V0/V1. 
+            // Constraints were already checked on type annotation of SQL query. 
+            TypesCtx->DeprecatedSQL = true; 
+        } 
+ 
         ctx.IssueManager.AddIssues(astRes.Issues);
-        if (!astRes.IsOk()) {
-            return nullptr;
-        }
-
+        if (!astRes.IsOk()) { 
+            return nullptr; 
+        } 
+ 
         TExprNode::TPtr result;
         if (!CompileExpr(*astRes.Root, result, ctx, ModuleResolver.get())) {
-            return nullptr;
-        }
-
-        YQL_CLOG(INFO, ProviderKqp) << "Compiled query:\n" << KqpExprToPrettyString(*result, ctx);
-
-        return result;
-    }
-
-    TExprNode::TPtr CompileYqlQuery(const TString& query, bool isSql, bool sqlAutoCommit, TExprContext& ctx,
-        TMaybe<TSqlVersion>& sqlVersion) const
-    {
-        auto queryExpr = CompileQuery(query, isSql, sqlAutoCommit, ctx, sqlVersion);
-        if (!queryExpr) {
-            return nullptr;
-        }
-
-        if (!isSql) {
-            return queryExpr;
-        }
-
+            return nullptr; 
+        } 
+ 
+        YQL_CLOG(INFO, ProviderKqp) << "Compiled query:\n" << KqpExprToPrettyString(*result, ctx); 
+ 
+        return result; 
+    } 
+ 
+    TExprNode::TPtr CompileYqlQuery(const TString& query, bool isSql, bool sqlAutoCommit, TExprContext& ctx, 
+        TMaybe<TSqlVersion>& sqlVersion) const 
+    { 
+        auto queryExpr = CompileQuery(query, isSql, sqlAutoCommit, ctx, sqlVersion); 
+        if (!queryExpr) { 
+            return nullptr; 
+        } 
+ 
+        if (!isSql) { 
+            return queryExpr; 
+        } 
+ 
         if (TMaybeNode<TCoCommit>(queryExpr) && TCoCommit(queryExpr).DataSink().Maybe<TKiDataSink>()) {
-            return queryExpr;
-        }
-
+            return queryExpr; 
+        } 
+ 
         return Build<TCoCommit>(ctx, queryExpr->Pos())
-            .World(queryExpr)
-            .DataSink<TKiDataSink>()
-                .Category().Build(KikimrProviderName)
-                .Cluster().Build(Cluster)
-                .Build()
-            .Settings()
-                .Add()
-                    .Name().Build("mode")
+            .World(queryExpr) 
+            .DataSink<TKiDataSink>() 
+                .Category().Build(KikimrProviderName) 
+                .Cluster().Build(Cluster) 
+                .Build() 
+            .Settings() 
+                .Add() 
+                    .Name().Build("mode") 
                     .Value<TCoAtom>().Build(KikimrCommitModeFlush())
-                    .Build()
-                .Build()
-            .Done()
-            .Ptr();
-    }
-
-    static bool ParseParameters(NKikimrMiniKQL::TParams&& parameters, TKikimrParamsMap& map,
-        TExprContext& ctx)
-    {
-        if (!parameters.HasType()) {
-            return true;
-        }
-
-        if (parameters.GetType().GetKind() != NKikimrMiniKQL::Struct) {
-            ctx.AddError(YqlIssue(TPosition(), TIssuesIds::KIKIMR_BAD_REQUEST,
-                "Expected struct as query parameters type"));
-            return false;
-        }
-
-        auto& structType = *parameters.MutableType()->MutableStruct();
-        for (ui32 i = 0; i < structType.MemberSize(); ++i) {
-            auto memberName = structType.GetMember(i).GetName();
-
-            if (parameters.GetValue().StructSize() <= i) {
-                ctx.AddError(YqlIssue(TPosition(), TIssuesIds::KIKIMR_BAD_REQUEST,
-                    TStringBuilder() << "Missing value for parameter: " << memberName));
-                return false;
-            }
-
-            NKikimrMiniKQL::TParams param;
-            param.MutableType()->Swap(structType.MutableMember(i)->MutableType());
-            param.MutableValue()->Swap(parameters.MutableValue()->MutableStruct(i));
-
-            auto result = map.emplace(std::make_pair(memberName, std::move(param)));
-            if (!result.second) {
-                ctx.AddError(YqlIssue(TPosition(), TIssuesIds::KIKIMR_BAD_REQUEST,
-                    TStringBuilder() << "Duplicate parameter: " << memberName));
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    TBeginTxResult BeginTransactionInternal(NKikimrKqp::EIsolationLevel isolationLevel, bool readonly) {
-        YQL_ENSURE(ExplicitTransactions.Size() <= MaxActiveTx());
-
-        if (isolationLevel == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED) {
-            return ResultFromError<TBeginTxResult>(YqlIssue(TPosition(), TIssuesIds::KIKIMR_BAD_OPERATION,
-                "Unknown transaction mode."));
-        }
-
-        TBeginTxResult result;
-        if (ExplicitTransactions.Size() == MaxActiveTx()) {
-            auto it = ExplicitTransactions.FindOldest();
-            YQL_ENSURE(it != ExplicitTransactions.End());
-
-            auto idleDuration = TInstant::Now() - it.Value()->LastAccessTime;
-            if (idleDuration.Seconds() >= SessionCtx->Config()._KqpTxIdleTimeoutSec.Get().GetRef()) {
-                AbortTransaction(it);
-                ++result.EvictedTx;
-            } else {
-                result.AddIssue(YqlIssue(TPosition(), TIssuesIds::KIKIMR_TOO_MANY_TRANSACTIONS));
-                result.CurrentActiveTx = ExplicitTransactions.Size();
-                result.CurrentAbortedTx = AbortedTransactions.size();
-                return result;
-            }
-        }
-
+                    .Build() 
+                .Build() 
+            .Done() 
+            .Ptr(); 
+    } 
+ 
+    static bool ParseParameters(NKikimrMiniKQL::TParams&& parameters, TKikimrParamsMap& map, 
+        TExprContext& ctx) 
+    { 
+        if (!parameters.HasType()) { 
+            return true; 
+        } 
+ 
+        if (parameters.GetType().GetKind() != NKikimrMiniKQL::Struct) { 
+            ctx.AddError(YqlIssue(TPosition(), TIssuesIds::KIKIMR_BAD_REQUEST, 
+                "Expected struct as query parameters type")); 
+            return false; 
+        } 
+ 
+        auto& structType = *parameters.MutableType()->MutableStruct(); 
+        for (ui32 i = 0; i < structType.MemberSize(); ++i) { 
+            auto memberName = structType.GetMember(i).GetName(); 
+ 
+            if (parameters.GetValue().StructSize() <= i) { 
+                ctx.AddError(YqlIssue(TPosition(), TIssuesIds::KIKIMR_BAD_REQUEST, 
+                    TStringBuilder() << "Missing value for parameter: " << memberName)); 
+                return false; 
+            } 
+ 
+            NKikimrMiniKQL::TParams param; 
+            param.MutableType()->Swap(structType.MutableMember(i)->MutableType()); 
+            param.MutableValue()->Swap(parameters.MutableValue()->MutableStruct(i)); 
+ 
+            auto result = map.emplace(std::make_pair(memberName, std::move(param))); 
+            if (!result.second) { 
+                ctx.AddError(YqlIssue(TPosition(), TIssuesIds::KIKIMR_BAD_REQUEST, 
+                    TStringBuilder() << "Duplicate parameter: " << memberName)); 
+                return false; 
+            } 
+        } 
+ 
+        return true; 
+    } 
+ 
+    TBeginTxResult BeginTransactionInternal(NKikimrKqp::EIsolationLevel isolationLevel, bool readonly) { 
+        YQL_ENSURE(ExplicitTransactions.Size() <= MaxActiveTx()); 
+ 
+        if (isolationLevel == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED) { 
+            return ResultFromError<TBeginTxResult>(YqlIssue(TPosition(), TIssuesIds::KIKIMR_BAD_OPERATION, 
+                "Unknown transaction mode.")); 
+        } 
+ 
+        TBeginTxResult result; 
+        if (ExplicitTransactions.Size() == MaxActiveTx()) { 
+            auto it = ExplicitTransactions.FindOldest(); 
+            YQL_ENSURE(it != ExplicitTransactions.End()); 
+ 
+            auto idleDuration = TInstant::Now() - it.Value()->LastAccessTime; 
+            if (idleDuration.Seconds() >= SessionCtx->Config()._KqpTxIdleTimeoutSec.Get().GetRef()) { 
+                AbortTransaction(it); 
+                ++result.EvictedTx; 
+            } else { 
+                result.AddIssue(YqlIssue(TPosition(), TIssuesIds::KIKIMR_TOO_MANY_TRANSACTIONS)); 
+                result.CurrentActiveTx = ExplicitTransactions.Size(); 
+                result.CurrentAbortedTx = AbortedTransactions.size(); 
+                return result; 
+            } 
+        } 
+ 
         auto txCtx = MakeIntrusive<TKqpTransactionContext>(/* implicit */ false);
-        txCtx->EffectiveIsolationLevel = isolationLevel;
-        txCtx->Readonly = readonly;
-
-        auto txId = CreateGuidAsString();
-        YQL_ENSURE(ExplicitTransactions.Insert(std::make_pair(txId, txCtx)));
-
-        result.SetSuccess();
-        result.TxId = txId;
-        result.CurrentActiveTx = ExplicitTransactions.Size();
-        result.CurrentAbortedTx = AbortedTransactions.size();
-        return result;
-    }
-
-    TGenericResult DeleteTransactionInternal(const TString& txId) {
-        auto maybeTx = FindTransaction(txId);
-        if (!maybeTx) {
-            return ResultFromError<TGenericResult>(
-                YqlIssue(TPosition(), TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND, TStringBuilder()
-                    << "Transaction not found: " << txId));
-        }
-
-        if ((*maybeTx)->QueriesCount > 0) {
-            return ResultFromError<TGenericResult>(
-                YqlIssue(TPosition(), TIssuesIds::DEFAULT_ERROR, TStringBuilder()
-                    << "Transaction is not empty: " << txId));
-        }
-
-        RemoveTransaction(txId);
-
-        TGenericResult result;
-        result.SetSuccess();
-        return result;
-    }
-
-    IAsyncQueryResultPtr ExecuteSchemeQueryInternal(const TString& query, bool isSql, TExprContext& ctx) {
-        SetupYqlTransformer(nullptr);
-
-        SessionCtx->Query().Type = EKikimrQueryType::Ddl;
-
-        TMaybe<TSqlVersion> sqlVersion;
-        auto queryExpr = CompileYqlQuery(query, isSql, false, ctx, sqlVersion);
-        if (!queryExpr) {
-            return nullptr;
-        }
-
-        return MakeIntrusive<TAsyncExecuteYqlResult>(queryExpr.Get(), ctx, *YqlTransformer, Cluster, SessionCtx,
-            *ResultProviderConfig, *PlanBuilder, sqlVersion);
-    }
-
+        txCtx->EffectiveIsolationLevel = isolationLevel; 
+        txCtx->Readonly = readonly; 
+ 
+        auto txId = CreateGuidAsString(); 
+        YQL_ENSURE(ExplicitTransactions.Insert(std::make_pair(txId, txCtx))); 
+ 
+        result.SetSuccess(); 
+        result.TxId = txId; 
+        result.CurrentActiveTx = ExplicitTransactions.Size(); 
+        result.CurrentAbortedTx = AbortedTransactions.size(); 
+        return result; 
+    } 
+ 
+    TGenericResult DeleteTransactionInternal(const TString& txId) { 
+        auto maybeTx = FindTransaction(txId); 
+        if (!maybeTx) { 
+            return ResultFromError<TGenericResult>( 
+                YqlIssue(TPosition(), TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND, TStringBuilder() 
+                    << "Transaction not found: " << txId)); 
+        } 
+ 
+        if ((*maybeTx)->QueriesCount > 0) { 
+            return ResultFromError<TGenericResult>( 
+                YqlIssue(TPosition(), TIssuesIds::DEFAULT_ERROR, TStringBuilder() 
+                    << "Transaction is not empty: " << txId)); 
+        } 
+ 
+        RemoveTransaction(txId); 
+ 
+        TGenericResult result; 
+        result.SetSuccess(); 
+        return result; 
+    } 
+ 
+    IAsyncQueryResultPtr ExecuteSchemeQueryInternal(const TString& query, bool isSql, TExprContext& ctx) { 
+        SetupYqlTransformer(nullptr); 
+ 
+        SessionCtx->Query().Type = EKikimrQueryType::Ddl; 
+ 
+        TMaybe<TSqlVersion> sqlVersion; 
+        auto queryExpr = CompileYqlQuery(query, isSql, false, ctx, sqlVersion); 
+        if (!queryExpr) { 
+            return nullptr; 
+        } 
+ 
+        return MakeIntrusive<TAsyncExecuteYqlResult>(queryExpr.Get(), ctx, *YqlTransformer, Cluster, SessionCtx, 
+            *ResultProviderConfig, *PlanBuilder, sqlVersion); 
+    } 
+ 
     IAsyncQueryResultPtr RollbackTransactionInternal(const TString& txId,
         const IKikimrQueryExecutor::TExecuteSettings& settings, TExprContext& ctx)
     {
@@ -1633,21 +1633,21 @@ private:
             query->SetVersion(NKikimrKqp::TPreparedQuery::VERSION_V1);
             query->AddKqls();
         }
-
+ 
         YQL_CLOG(INFO, ProviderKqp) << "Rollback tx: " << txId << ", query: " << query->ShortUtf8DebugString();
 
         std::shared_ptr<const NKikimrKqp::TPreparedQuery> q(query.release());
         return ExecuteDataQueryInternal(txId, q, NKikimrMiniKQL::TParams(), settings, {}, {}, ctx);
-    }
-
+    } 
+ 
     IAsyncQueryResultPtr RollbackTransactionInternal(TIntrusivePtr<TKqpTransactionContext> tx,
         const IKikimrQueryExecutor::TExecuteSettings& settings, TExprContext& ctx)
     {
         YQL_ENSURE(settings.RollbackTx);
-
+ 
         auto query = std::make_unique<NKikimrKqp::TPreparedQuery>();
         auto settings1 = settings;
-
+ 
         auto engine = tx->DeferredEffects.GetEngine();
         if (engine.has_value() && *engine == TKqpTransactionInfo::EEngine::NewEngine) {
             YQL_ENSURE(!settings.UseNewEngine.Defined() || *settings.UseNewEngine == true);
@@ -1660,23 +1660,23 @@ private:
             query->SetVersion(NKikimrKqp::TPreparedQuery::VERSION_V1);
             query->AddKqls();
         }
-
+ 
         std::shared_ptr<const NKikimrKqp::TPreparedQuery> q(query.release());
         return ExecuteDataQueryInternal(tx, q, {}, settings1, {}, {}, /* replyPrepared */ false, ctx);
-    }
-
-    IAsyncQueryResultPtr CommitTransactionInternal(const TString& txId,
-        const IKikimrQueryExecutor::TExecuteSettings& settings, TExprContext& ctx)
-    {
+    } 
+ 
+    IAsyncQueryResultPtr CommitTransactionInternal(const TString& txId, 
+        const IKikimrQueryExecutor::TExecuteSettings& settings, TExprContext& ctx) 
+    { 
         auto maybeTx = FindTransaction(txId);
         if (!maybeTx) {
             return MakeKikimrResultHolder(ResultFromError<TQueryResult>(
                 YqlIssue(TPosition(), TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND, TStringBuilder()
                     << "Transaction not found: " << txId)));
         }
-
-        YQL_ENSURE(settings.CommitTx);
-
+ 
+        YQL_ENSURE(settings.CommitTx); 
+ 
         auto query = std::make_unique<NKikimrKqp::TPreparedQuery>();
         auto engine = maybeTx->Get()->DeferredEffects.GetEngine();
         if (engine.has_value() && *engine == TKqpTransactionInfo::EEngine::NewEngine) {
@@ -1692,23 +1692,23 @@ private:
         std::shared_ptr<const NKikimrKqp::TPreparedQuery> q(query.release());
         return ExecuteDataQueryInternal(txId, q, NKikimrMiniKQL::TParams(), settings, /* issues */ {},
             /* sqlVersion */ {}, ctx);
-    }
-
+    } 
+ 
     IAsyncQueryResultPtr RollbackAbortedInternal(TExprContext& ctx) {
-        if (AbortedTransactions.empty()) {
-            TQueryResult result;
-            result.SetSuccess();
+        if (AbortedTransactions.empty()) { 
+            TQueryResult result; 
+            result.SetSuccess(); 
             return MakeKikimrResultHolder(std::move(result));
-        }
-
-        TVector<TIntrusivePtr<TKqpTransactionContext>> txs;
+        } 
+ 
+        TVector<TIntrusivePtr<TKqpTransactionContext>> txs; 
         txs.reserve(AbortedTransactions.size());
-        for (auto& pair : AbortedTransactions) {
-            txs.push_back(pair.second);
-        }
-
-        AbortedTransactions.clear();
-        return MakeIntrusive<TKqpAsyncExecAllResult<TIntrusivePtr<TKqpTransactionContext>, TQueryResult>>(txs,
+        for (auto& pair : AbortedTransactions) { 
+            txs.push_back(pair.second); 
+        } 
+ 
+        AbortedTransactions.clear(); 
+        return MakeIntrusive<TKqpAsyncExecAllResult<TIntrusivePtr<TKqpTransactionContext>, TQueryResult>>(txs, 
             [this, &ctx] (const TIntrusivePtr<TKqpTransactionContext>& tx) {
                 IKikimrQueryExecutor::TExecuteSettings settings;
                 settings.RollbackTx = true;
@@ -1718,27 +1718,27 @@ private:
                 settings.UseNewEngine = engine.has_value() && *engine == TKqpTransactionInfo::EEngine::NewEngine;
 
                 return RollbackTransactionInternal(tx, settings, ctx);
-            });
-    }
-
-    IAsyncQueryResultPtr ExplainDataQueryInternal(const TString& query, bool isSql, TExprContext& ctx) {
+            }); 
+    } 
+ 
+    IAsyncQueryResultPtr ExplainDataQueryInternal(const TString& query, bool isSql, TExprContext& ctx) { 
         if (isSql) {
             return PrepareDataQueryInternal(query, {}, ctx);
         }
-
+ 
         auto prepareResult = PrepareDataQueryAstInternal(query, {}, ctx);
-        if (!prepareResult) {
-            return nullptr;
-        }
-
-        return AsyncApplyResult<TQueryResult, TQueryResult>(prepareResult, []
+        if (!prepareResult) { 
+            return nullptr; 
+        } 
+ 
+        return AsyncApplyResult<TQueryResult, TQueryResult>(prepareResult, [] 
             (TQueryResult&& prepared) -> IAsyncQueryResultPtr {
                 if (!prepared.Success()) {
                     return MakeKikimrResultHolder(std::move(prepared));
-                }
-
-                TQueryResult explainResult;
-                explainResult.SetSuccess();
+                } 
+ 
+                TQueryResult explainResult; 
+                explainResult.SetSuccess(); 
                 if (prepared.PreparingQuery->GetVersion() == NKikimrKqp::TPreparedQuery::VERSION_PHYSICAL_V1) {
                     explainResult.QueryPlan = std::move(prepared.QueryPlan);
                     explainResult.QueryAst = std::move(*prepared.PreparingQuery->MutablePhysicalQuery()->MutableQueryAst());
@@ -1747,9 +1747,9 @@ private:
                 }
                 explainResult.SqlVersion = prepared.SqlVersion;
                 return MakeKikimrResultHolder(std::move(explainResult));
-            });
-    }
-
+            }); 
+    } 
+ 
     IAsyncQueryResultPtr ExplainScanQueryInternal(const TString& query, bool isSql, TExprContext& ctx) {
         auto prepareResult = isSql
             ? PrepareScanQueryInternal(query, ctx)
@@ -1757,142 +1757,142 @@ private:
         return prepareResult;
     }
 
-    IAsyncQueryResultPtr PrepareDataQueryInternal(const TString& query, const TPrepareSettings& settings,
-        TExprContext& ctx)
-    {
-        // TODO: Use empty tx context
+    IAsyncQueryResultPtr PrepareDataQueryInternal(const TString& query, const TPrepareSettings& settings, 
+        TExprContext& ctx) 
+    { 
+        // TODO: Use empty tx context 
         auto tempTxCtx = MakeIntrusive<TKqpTransactionContext>(/* implicit */ true);
-        SetupYqlTransformer(tempTxCtx);
-
-        SessionCtx->Query().Type = EKikimrQueryType::Dml;
-        SessionCtx->Query().PrepareOnly = true;
+        SetupYqlTransformer(tempTxCtx); 
+ 
+        SessionCtx->Query().Type = EKikimrQueryType::Dml; 
+        SessionCtx->Query().PrepareOnly = true; 
         SessionCtx->Query().PreparingQuery = std::make_unique<NKikimrKqp::TPreparedQuery>();
         if (settings.UseNewEngine) {
             SessionCtx->Config().UseNewEngine = *settings.UseNewEngine;
         }
-        if (settings.DocumentApiRestricted) {
-            SessionCtx->Query().DocumentApiRestricted = *settings.DocumentApiRestricted;
-        }
-
-        TMaybe<TSqlVersion> sqlVersion;
+        if (settings.DocumentApiRestricted) { 
+            SessionCtx->Query().DocumentApiRestricted = *settings.DocumentApiRestricted; 
+        } 
+ 
+        TMaybe<TSqlVersion> sqlVersion; 
         auto queryExpr = CompileYqlQuery(query, /* isSql */ true, /* sqlAutoCommit */ false, ctx, sqlVersion);
-        if (!queryExpr) {
-            return nullptr;
-        }
-
-        return MakeIntrusive<TAsyncPrepareYqlResult>(queryExpr.Get(), ctx, *YqlTransformer, SessionCtx->QueryPtr(),
-            query, sqlVersion);
-    }
-
-    IAsyncQueryResultPtr PrepareDataQueryAstInternal(const TString& queryAst, const TPrepareSettings& settings,
-        TExprContext& ctx)
-    {
-        // TODO: Use empty tx context
-        TIntrusivePtr<IKikimrTransactionContext> tempTxCtx = MakeIntrusive<TKqpTransactionContext>(true);
-        IKikimrQueryExecutor::TExecuteSettings execSettings;
-        execSettings.UseNewEngine = settings.UseNewEngine;
-        SetupDataQueryAstTransformer(execSettings, tempTxCtx);
-
-        SessionCtx->Query().Type = EKikimrQueryType::Dml;
-        SessionCtx->Query().PrepareOnly = true;
+        if (!queryExpr) { 
+            return nullptr; 
+        } 
+ 
+        return MakeIntrusive<TAsyncPrepareYqlResult>(queryExpr.Get(), ctx, *YqlTransformer, SessionCtx->QueryPtr(), 
+            query, sqlVersion); 
+    } 
+ 
+    IAsyncQueryResultPtr PrepareDataQueryAstInternal(const TString& queryAst, const TPrepareSettings& settings, 
+        TExprContext& ctx) 
+    { 
+        // TODO: Use empty tx context 
+        TIntrusivePtr<IKikimrTransactionContext> tempTxCtx = MakeIntrusive<TKqpTransactionContext>(true); 
+        IKikimrQueryExecutor::TExecuteSettings execSettings; 
+        execSettings.UseNewEngine = settings.UseNewEngine; 
+        SetupDataQueryAstTransformer(execSettings, tempTxCtx); 
+ 
+        SessionCtx->Query().Type = EKikimrQueryType::Dml; 
+        SessionCtx->Query().PrepareOnly = true; 
         SessionCtx->Query().PreparingQuery = std::make_unique<NKikimrKqp::TPreparedQuery>();
-        if (settings.DocumentApiRestricted) {
-            SessionCtx->Query().DocumentApiRestricted = *settings.DocumentApiRestricted;
-        }
-
-        TMaybe<TSqlVersion> sqlVersion;
-        auto queryExpr = CompileYqlQuery(queryAst, false, false, ctx, sqlVersion);
-        if (!queryExpr) {
-            return nullptr;
-        }
-
-        YQL_ENSURE(!sqlVersion);
-
-        return MakeIntrusive<TAsyncExecuteKqlResult>(queryExpr.Get(), ctx, *DataQueryAstTransformer,
-            SessionCtx, *ExecuteCtx);
-    }
-
+        if (settings.DocumentApiRestricted) { 
+            SessionCtx->Query().DocumentApiRestricted = *settings.DocumentApiRestricted; 
+        } 
+ 
+        TMaybe<TSqlVersion> sqlVersion; 
+        auto queryExpr = CompileYqlQuery(queryAst, false, false, ctx, sqlVersion); 
+        if (!queryExpr) { 
+            return nullptr; 
+        } 
+ 
+        YQL_ENSURE(!sqlVersion); 
+ 
+        return MakeIntrusive<TAsyncExecuteKqlResult>(queryExpr.Get(), ctx, *DataQueryAstTransformer, 
+            SessionCtx, *ExecuteCtx); 
+    } 
+ 
     IAsyncQueryResultPtr PrepareScanQueryInternal(const TString& query, TExprContext& ctx, EKikimrStatsMode statsMode = EKikimrStatsMode::None) {
-        SetupYqlTransformer(nullptr);
-
-        SessionCtx->Query().Type = EKikimrQueryType::Scan;
-        SessionCtx->Query().PrepareOnly = true;
+        SetupYqlTransformer(nullptr); 
+ 
+        SessionCtx->Query().Type = EKikimrQueryType::Scan; 
+        SessionCtx->Query().PrepareOnly = true; 
         SessionCtx->Query().StatsMode = statsMode;
         SessionCtx->Query().PreparingQuery = std::make_unique<NKikimrKqp::TPreparedQuery>();
-
-        TMaybe<TSqlVersion> sqlVersion = 1;
-        auto queryExpr = CompileYqlQuery(query, true, false, ctx, sqlVersion);
-        if (!queryExpr) {
-            return nullptr;
-        }
-
-        return MakeIntrusive<TAsyncPrepareYqlResult>(queryExpr.Get(), ctx, *YqlTransformer, SessionCtx->QueryPtr(),
-            query, sqlVersion);
-    }
-
-    IAsyncQueryResultPtr PrepareScanQueryAstInternal(const TString& queryAst, TExprContext& ctx) {
-        IKikimrQueryExecutor::TExecuteSettings settings;
-        SetupDataQueryAstTransformer(settings);
-
-        SessionCtx->Query().Type = EKikimrQueryType::Scan;
-        SessionCtx->Query().PrepareOnly = true;
+ 
+        TMaybe<TSqlVersion> sqlVersion = 1; 
+        auto queryExpr = CompileYqlQuery(query, true, false, ctx, sqlVersion); 
+        if (!queryExpr) { 
+            return nullptr; 
+        } 
+ 
+        return MakeIntrusive<TAsyncPrepareYqlResult>(queryExpr.Get(), ctx, *YqlTransformer, SessionCtx->QueryPtr(), 
+            query, sqlVersion); 
+    } 
+ 
+    IAsyncQueryResultPtr PrepareScanQueryAstInternal(const TString& queryAst, TExprContext& ctx) { 
+        IKikimrQueryExecutor::TExecuteSettings settings; 
+        SetupDataQueryAstTransformer(settings); 
+ 
+        SessionCtx->Query().Type = EKikimrQueryType::Scan; 
+        SessionCtx->Query().PrepareOnly = true; 
         SessionCtx->Query().PreparingQuery = std::make_unique<NKikimrKqp::TPreparedQuery>();
-
-        TMaybe<TSqlVersion> sqlVersion;
-        auto queryExpr = CompileYqlQuery(queryAst, false, false, ctx, sqlVersion);
-        if (!queryExpr) {
-            return nullptr;
-        }
-
-        YQL_ENSURE(!sqlVersion);
-
-        return MakeIntrusive<TAsyncExecuteKqlResult>(queryExpr.Get(), ctx, *DataQueryAstTransformer,
-            SessionCtx, *ExecuteCtx);
-    }
-
-    IAsyncQueryResultPtr ExecuteDataQueryInternal(TIntrusivePtr<TKqpTransactionContext> tx,
+ 
+        TMaybe<TSqlVersion> sqlVersion; 
+        auto queryExpr = CompileYqlQuery(queryAst, false, false, ctx, sqlVersion); 
+        if (!queryExpr) { 
+            return nullptr; 
+        } 
+ 
+        YQL_ENSURE(!sqlVersion); 
+ 
+        return MakeIntrusive<TAsyncExecuteKqlResult>(queryExpr.Get(), ctx, *DataQueryAstTransformer, 
+            SessionCtx, *ExecuteCtx); 
+    } 
+ 
+    IAsyncQueryResultPtr ExecuteDataQueryInternal(TIntrusivePtr<TKqpTransactionContext> tx, 
         std::shared_ptr<const NKikimrKqp::TPreparedQuery>& preparedQuery, NKikimrMiniKQL::TParams&& parameters,
-        const IKikimrQueryExecutor::TExecuteSettings& settings, const TIssues& issues,
-        const TMaybe<TSqlVersion>& sqlVersion, bool replyPrepared, TExprContext& ctx)
-    {
-        YQL_ENSURE(!settings.CommitTx || !settings.RollbackTx);
-
+        const IKikimrQueryExecutor::TExecuteSettings& settings, const TIssues& issues, 
+        const TMaybe<TSqlVersion>& sqlVersion, bool replyPrepared, TExprContext& ctx) 
+    { 
+        YQL_ENSURE(!settings.CommitTx || !settings.RollbackTx); 
+ 
         switch (preparedQuery->GetVersion()) {
-            case NKikimrKqp::TPreparedQuery::VERSION_V1: {
+            case NKikimrKqp::TPreparedQuery::VERSION_V1: { 
                 YQL_ENSURE(preparedQuery->KqlsSize() == 1);
                 auto& kql = preparedQuery->GetKqls(0);
-                YQL_ENSURE(!kql.GetSettings().GetCommitTx());
-                YQL_ENSURE(!kql.GetSettings().GetRollbackTx());
-                YQL_ENSURE(kql.GetSettings().GetIsolationLevel() == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED);
-                break;
-            }
-
-            case NKikimrKqp::TPreparedQuery::VERSION_PHYSICAL_V1: {
-                break;
-            }
-
-            default:
-                return MakeKikimrResultHolder(ResultFromError<TQueryResult>(
-                    TIssue(TPosition(), TStringBuilder()
+                YQL_ENSURE(!kql.GetSettings().GetCommitTx()); 
+                YQL_ENSURE(!kql.GetSettings().GetRollbackTx()); 
+                YQL_ENSURE(kql.GetSettings().GetIsolationLevel() == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED); 
+                break; 
+            } 
+ 
+            case NKikimrKqp::TPreparedQuery::VERSION_PHYSICAL_V1: { 
+                break; 
+            } 
+ 
+            default: 
+                return MakeKikimrResultHolder(ResultFromError<TQueryResult>( 
+                    TIssue(TPosition(), TStringBuilder() 
                         << "Unexpected query version: " << preparedQuery->GetVersion())));
-        }
-
-        SetupExecutePreparedTransformer(settings, tx);
-
+        } 
+ 
+        SetupExecutePreparedTransformer(settings, tx); 
+ 
         if (issues) {
             ctx.IssueManager.AddIssues(issues);
         }
 
-        if (!ParseParameters(std::move(parameters), SessionCtx->Query().Parameters, ctx)) {
-            return nullptr;
-        }
-
-        SessionCtx->Query().Type = EKikimrQueryType::Dml;
-        SessionCtx->Query().StatsMode = settings.StatsMode;
-        SessionCtx->Query().Deadlines = settings.Deadlines;
-        SessionCtx->Query().Limits = settings.Limits;
+        if (!ParseParameters(std::move(parameters), SessionCtx->Query().Parameters, ctx)) { 
+            return nullptr; 
+        } 
+ 
+        SessionCtx->Query().Type = EKikimrQueryType::Dml; 
+        SessionCtx->Query().StatsMode = settings.StatsMode; 
+        SessionCtx->Query().Deadlines = settings.Deadlines; 
+        SessionCtx->Query().Limits = settings.Limits; 
         SessionCtx->Query().PreparedQuery = preparedQuery;
-
+ 
         // moved to kqp_runner.cpp, ExecutePreparedQuery(...)
 //        if (preparedQuery->GetVersion() == NKikimrKqp::TPreparedQuery::VERSION_V1) {
 //            SessionCtx->Query().PreparedQuery.MutableKqls(0)->MutableSettings()->SetCommitTx(settings.CommitTx);
@@ -1902,96 +1902,96 @@ private:
         std::shared_ptr<const NKikimrKqp::TPreparedQuery> reply;
         if (replyPrepared) {
             reply = preparedQuery;
-        }
-
-        return MakeIntrusive<TAsyncExecutePreparedResult>(FakeWorld.Get(), ctx, *ExecutePreparedTransformer,
+        } 
+ 
+        return MakeIntrusive<TAsyncExecutePreparedResult>(FakeWorld.Get(), ctx, *ExecutePreparedTransformer, 
             SessionCtx, FillSettings, ExecuteCtx, reply, sqlVersion);
-    }
-
+    } 
+ 
     IAsyncQueryResultPtr ExecuteDataQueryInternal(const TString& txId, std::shared_ptr<const NKikimrKqp::TPreparedQuery>& query,
-        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings,
-        const TIssues& issues, const TMaybe<TSqlVersion>& sqlVersion, TExprContext& ctx)
-    {
-        auto maybeTx = FindTransaction(txId);
-        if (!maybeTx) {
-            return MakeKikimrResultHolder(ResultFromError<TQueryResult>(
-                YqlIssue(TPosition(), TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND, TStringBuilder()
-                    << "Transaction not found: " << txId)));
-        }
-
-        (*maybeTx)->OnBeginQuery();
-
-        return ExecuteDataQueryInternal(*maybeTx, query, std::move(parameters), settings, issues, sqlVersion,
-            /* replyPrepared */ false, ctx);
-    }
-
-    IAsyncQueryResultPtr ExecuteDataQueryInternal(const TString& txId, const TString& query, bool isSql,
-        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings,
-        TExprContext& ctx)
-    {
-        auto maybeTx = FindTransaction(txId);
-        if (!maybeTx) {
-            return MakeKikimrResultHolder(ResultFromError<TQueryResult>(
-                YqlIssue(TPosition(), TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND, TStringBuilder()
-                    << "Transaction not found: " << txId)));
-        }
-
-        (*maybeTx)->OnBeginQuery();
-
-        TPrepareSettings prepareSettings;
-        prepareSettings.UseNewEngine = settings.UseNewEngine;
-        prepareSettings.DocumentApiRestricted = settings.DocumentApiRestricted;
-
-        auto prepareResult = isSql
-            ? PrepareDataQueryInternal(query, prepareSettings, ctx)
-            : PrepareDataQueryAstInternal(query, prepareSettings, ctx);
-
-        if (!prepareResult) {
-            return nullptr;
-        }
-
-        auto tx = *maybeTx;
-        return AsyncApplyResult<TQueryResult, TQueryResult>(prepareResult,
-            [this, tx, parameters = std::move(parameters), settings, &ctx]
+        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings, 
+        const TIssues& issues, const TMaybe<TSqlVersion>& sqlVersion, TExprContext& ctx) 
+    { 
+        auto maybeTx = FindTransaction(txId); 
+        if (!maybeTx) { 
+            return MakeKikimrResultHolder(ResultFromError<TQueryResult>( 
+                YqlIssue(TPosition(), TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND, TStringBuilder() 
+                    << "Transaction not found: " << txId))); 
+        } 
+ 
+        (*maybeTx)->OnBeginQuery(); 
+ 
+        return ExecuteDataQueryInternal(*maybeTx, query, std::move(parameters), settings, issues, sqlVersion, 
+            /* replyPrepared */ false, ctx); 
+    } 
+ 
+    IAsyncQueryResultPtr ExecuteDataQueryInternal(const TString& txId, const TString& query, bool isSql, 
+        NKikimrMiniKQL::TParams&& parameters, const IKikimrQueryExecutor::TExecuteSettings& settings, 
+        TExprContext& ctx) 
+    { 
+        auto maybeTx = FindTransaction(txId); 
+        if (!maybeTx) { 
+            return MakeKikimrResultHolder(ResultFromError<TQueryResult>( 
+                YqlIssue(TPosition(), TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND, TStringBuilder() 
+                    << "Transaction not found: " << txId))); 
+        } 
+ 
+        (*maybeTx)->OnBeginQuery(); 
+ 
+        TPrepareSettings prepareSettings; 
+        prepareSettings.UseNewEngine = settings.UseNewEngine; 
+        prepareSettings.DocumentApiRestricted = settings.DocumentApiRestricted; 
+ 
+        auto prepareResult = isSql 
+            ? PrepareDataQueryInternal(query, prepareSettings, ctx) 
+            : PrepareDataQueryAstInternal(query, prepareSettings, ctx); 
+ 
+        if (!prepareResult) { 
+            return nullptr; 
+        } 
+ 
+        auto tx = *maybeTx; 
+        return AsyncApplyResult<TQueryResult, TQueryResult>(prepareResult, 
+            [this, tx, parameters = std::move(parameters), settings, &ctx] 
             (TQueryResult&& prepared) mutable -> IAsyncQueryResultPtr {
                 if (!prepared.Success()) {
-                    tx->Invalidate();
+                    tx->Invalidate(); 
                     return MakeKikimrResultHolder(std::move(prepared));
-                }
-
+                } 
+ 
                 std::shared_ptr<const NKikimrKqp::TPreparedQuery> query;
                 query.reset(prepared.PreparingQuery.release());
 
                 return ExecuteDataQueryInternal(tx, query, std::move(parameters), settings, prepared.Issues(),
                     prepared.SqlVersion, /* replyPrepared */ true, ctx);
-            });
-    }
-
-    IAsyncQueryResultPtr ExecuteYqlScriptInternal(const TString& script, NKikimrMiniKQL::TParams&& parameters,
-        const TExecScriptSettings& settings, TExprContext& ctx)
-    {
-        SetupYqlTransformer(nullptr);
-
-        SessionCtx->Query().Type = EKikimrQueryType::YqlScript;
-        SessionCtx->Query().Deadlines = settings.Deadlines;
-        SessionCtx->Query().StatsMode = settings.StatsMode;
+            }); 
+    } 
+ 
+    IAsyncQueryResultPtr ExecuteYqlScriptInternal(const TString& script, NKikimrMiniKQL::TParams&& parameters, 
+        const TExecScriptSettings& settings, TExprContext& ctx) 
+    { 
+        SetupYqlTransformer(nullptr); 
+ 
+        SessionCtx->Query().Type = EKikimrQueryType::YqlScript; 
+        SessionCtx->Query().Deadlines = settings.Deadlines; 
+        SessionCtx->Query().StatsMode = settings.StatsMode; 
         SessionCtx->Query().PreparingQuery = std::make_unique<NKikimrKqp::TPreparedQuery>();
         SessionCtx->Query().PreparedQuery.reset();
-
-        TMaybe<TSqlVersion> sqlVersion;
-        auto scriptExpr = CompileYqlQuery(script, true, true, ctx, sqlVersion);
-        if (!scriptExpr) {
-            return nullptr;
-        }
-
-        if (!ParseParameters(std::move(parameters), SessionCtx->Query().Parameters, ctx)) {
-            return nullptr;
-        }
-
-        return MakeIntrusive<TAsyncExecuteYqlResult>(scriptExpr.Get(), ctx, *YqlTransformer, Cluster, SessionCtx,
-            *ResultProviderConfig, *PlanBuilder, sqlVersion);
-    }
-
+ 
+        TMaybe<TSqlVersion> sqlVersion; 
+        auto scriptExpr = CompileYqlQuery(script, true, true, ctx, sqlVersion); 
+        if (!scriptExpr) { 
+            return nullptr; 
+        } 
+ 
+        if (!ParseParameters(std::move(parameters), SessionCtx->Query().Parameters, ctx)) { 
+            return nullptr; 
+        } 
+ 
+        return MakeIntrusive<TAsyncExecuteYqlResult>(scriptExpr.Get(), ctx, *YqlTransformer, Cluster, SessionCtx, 
+            *ResultProviderConfig, *PlanBuilder, sqlVersion); 
+    } 
+ 
     IAsyncQueryResultPtr StreamExecuteYqlScriptInternal(const TString& script, NKikimrMiniKQL::TParams&& parameters,
         const NActors::TActorId& target,const TExecScriptSettings& settings, TExprContext& ctx)
     {
@@ -2044,7 +2044,7 @@ private:
         return MakeIntrusive<TAsyncValidateYqlResult>(scriptExpr.Get(), SessionCtx, ctx, transformer, sqlVersion);
     }
 
-    IAsyncQueryResultPtr ExplainYqlScriptInternal(const TString& script, TExprContext& ctx) {
+    IAsyncQueryResultPtr ExplainYqlScriptInternal(const TString& script, TExprContext& ctx) { 
         SetupYqlTransformer(nullptr);
 
         SessionCtx->Query().Type = EKikimrQueryType::YqlScript;
@@ -2060,207 +2060,207 @@ private:
 
         return MakeIntrusive<TAsyncExplainYqlResult>(scriptExpr.Get(), SessionCtx, ctx, YqlTransformer,
             *PlanBuilder, sqlVersion, true /* UseDqExplain */);
-    }
-
-    IAsyncQueryResultPtr ExecuteScanQueryInternal(const TString& query, bool isSql,
+    } 
+ 
+    IAsyncQueryResultPtr ExecuteScanQueryInternal(const TString& query, bool isSql, 
         NKikimrMiniKQL::TParams&& parameters, const NActors::TActorId& target,
-        const IKikimrQueryExecutor::TExecuteSettings& settings, TExprContext& ctx)
-    {
-        auto prepareResult = isSql
+        const IKikimrQueryExecutor::TExecuteSettings& settings, TExprContext& ctx) 
+    { 
+        auto prepareResult = isSql 
             ? PrepareScanQueryInternal(query, ctx, settings.StatsMode)
-            : PrepareScanQueryAstInternal(query, ctx);
-
-        if (!prepareResult) {
-            return nullptr;
-        }
-
-        if (!isSql) {
-            // Disable LLVM for scripting queries.
-            // TODO: KIKIMR-13561
-            SessionCtx->Config().EnableLlvm = EOptionalFlag::Disabled;
-        }
-
-        return AsyncApplyResult<TQueryResult, TQueryResult>(prepareResult,
+            : PrepareScanQueryAstInternal(query, ctx); 
+ 
+        if (!prepareResult) { 
+            return nullptr; 
+        } 
+ 
+        if (!isSql) { 
+            // Disable LLVM for scripting queries. 
+            // TODO: KIKIMR-13561 
+            SessionCtx->Config().EnableLlvm = EOptionalFlag::Disabled; 
+        } 
+ 
+        return AsyncApplyResult<TQueryResult, TQueryResult>(prepareResult, 
             [this, parameters = std::move(parameters), target, settings, &ctx]
             (TQueryResult&& prepared) mutable -> IAsyncQueryResultPtr {
                 if (!prepared.Success()) {
                     return MakeKikimrResultHolder(std::move(prepared));
-                }
-
+                } 
+ 
                 std::shared_ptr<const NKikimrKqp::TPreparedQuery> query;
                 query.reset(prepared.PreparingQuery.release());
 
                 return ExecuteScanQueryInternal(query, std::move(parameters), target, settings, prepared.Issues(),
                     prepared.SqlVersion, ctx);
-            });
-    }
-
+            }); 
+    } 
+ 
     IAsyncQueryResultPtr ExecuteScanQueryInternal(std::shared_ptr<const NKikimrKqp::TPreparedQuery>& query,
         NKikimrMiniKQL::TParams&& parameters, const NActors::TActorId& target,
-        const IKikimrQueryExecutor::TExecuteSettings& settings, const TIssues& issues,
-        const TMaybe<TSqlVersion>& sqlVersion, TExprContext& ctx)
-    {
-        auto txCtx = MakeIntrusive<TKqpTransactionContext>(true);
-        txCtx->EffectiveIsolationLevel = NKikimrKqp::ISOLATION_LEVEL_UNDEFINED;
-
+        const IKikimrQueryExecutor::TExecuteSettings& settings, const TIssues& issues, 
+        const TMaybe<TSqlVersion>& sqlVersion, TExprContext& ctx) 
+    { 
+        auto txCtx = MakeIntrusive<TKqpTransactionContext>(true); 
+        txCtx->EffectiveIsolationLevel = NKikimrKqp::ISOLATION_LEVEL_UNDEFINED; 
+ 
         SetupExecutePreparedTransformer(settings, txCtx);
 
-        ExecuteCtx->ReplyTarget = target;
-
-        if (issues) {
-            ctx.IssueManager.AddIssues(issues);
-        }
-
-        if (!ParseParameters(std::move(parameters), SessionCtx->Query().Parameters, ctx)) {
-            return nullptr;
-        }
-
-        SessionCtx->Query().Type = EKikimrQueryType::Scan;
+        ExecuteCtx->ReplyTarget = target; 
+ 
+        if (issues) { 
+            ctx.IssueManager.AddIssues(issues); 
+        } 
+ 
+        if (!ParseParameters(std::move(parameters), SessionCtx->Query().Parameters, ctx)) { 
+            return nullptr; 
+        } 
+ 
+        SessionCtx->Query().Type = EKikimrQueryType::Scan; 
         SessionCtx->Query().PreparedQuery = query;
         SessionCtx->Query().Deadlines = settings.Deadlines;
-        SessionCtx->Query().Limits = settings.Limits;
-        SessionCtx->Query().StatsMode = settings.StatsMode;
+        SessionCtx->Query().Limits = settings.Limits; 
+        SessionCtx->Query().StatsMode = settings.StatsMode; 
         SessionCtx->Query().RlPath = settings.RlPath;
-
-        return MakeIntrusive<TAsyncExecutePreparedResult>(FakeWorld.Get(), ctx, *ExecutePreparedTransformer,
+ 
+        return MakeIntrusive<TAsyncExecutePreparedResult>(FakeWorld.Get(), ctx, *ExecutePreparedTransformer, 
             SessionCtx, FillSettings, ExecuteCtx, nullptr, sqlVersion);
-    }
-
-    void SetupSession(TIntrusivePtr<IKikimrTransactionContext> txCtx) {
-        ExprCtx->Reset();
+    } 
+ 
+    void SetupSession(TIntrusivePtr<IKikimrTransactionContext> txCtx) { 
+        ExprCtx->Reset(); 
         ExprCtx->Step.Done(TExprStep::ExprEval); // KIKIMR-8067
-
-        TypesCtx->DeprecatedSQL = false;
-        TypesCtx->CachedNow.reset();
-        std::get<0>(TypesCtx->CachedRandom).reset();
-        std::get<1>(TypesCtx->CachedRandom).reset();
-        std::get<2>(TypesCtx->CachedRandom).reset();
-
-        SessionCtx->Reset(KeepConfigChanges);
-        if (txCtx) {
-            SessionCtx->SetTx(txCtx);
-        }
-    }
-
-    void SetupYqlTransformer(TIntrusivePtr<IKikimrTransactionContext> txCtx) {
-        SetupSession(txCtx);
-
-        YqlTransformer->Rewind();
-
-        ResultProviderConfig->FillSettings = FillSettings;
-        ResultProviderConfig->CommittedResults.clear();
-    }
-
-    void SetupDataQueryAstTransformer(const IKikimrQueryExecutor::TExecuteSettings& settings,
-        TIntrusivePtr<IKikimrTransactionContext> txCtx = {})
-    {
-        SetupSession(txCtx);
-
-        DataQueryAstTransformer->Rewind();
-
-        ExecuteCtx->Reset(settings);
-    }
-
-    void SetupExecutePreparedTransformer(const IKikimrQueryExecutor::TExecuteSettings& settings,
-        TIntrusivePtr<IKikimrTransactionContext> txCtx)
-    {
-        SetupSession(txCtx);
-
-        ExecutePreparedTransformer->Rewind();
-
-        ExecuteCtx->Reset(settings);
-    }
-
-private:
-    TIntrusivePtr<IKqpGateway> Gateway;
+ 
+        TypesCtx->DeprecatedSQL = false; 
+        TypesCtx->CachedNow.reset(); 
+        std::get<0>(TypesCtx->CachedRandom).reset(); 
+        std::get<1>(TypesCtx->CachedRandom).reset(); 
+        std::get<2>(TypesCtx->CachedRandom).reset(); 
+ 
+        SessionCtx->Reset(KeepConfigChanges); 
+        if (txCtx) { 
+            SessionCtx->SetTx(txCtx); 
+        } 
+    } 
+ 
+    void SetupYqlTransformer(TIntrusivePtr<IKikimrTransactionContext> txCtx) { 
+        SetupSession(txCtx); 
+ 
+        YqlTransformer->Rewind(); 
+ 
+        ResultProviderConfig->FillSettings = FillSettings; 
+        ResultProviderConfig->CommittedResults.clear(); 
+    } 
+ 
+    void SetupDataQueryAstTransformer(const IKikimrQueryExecutor::TExecuteSettings& settings, 
+        TIntrusivePtr<IKikimrTransactionContext> txCtx = {}) 
+    { 
+        SetupSession(txCtx); 
+ 
+        DataQueryAstTransformer->Rewind(); 
+ 
+        ExecuteCtx->Reset(settings); 
+    } 
+ 
+    void SetupExecutePreparedTransformer(const IKikimrQueryExecutor::TExecuteSettings& settings, 
+        TIntrusivePtr<IKikimrTransactionContext> txCtx) 
+    { 
+        SetupSession(txCtx); 
+ 
+        ExecutePreparedTransformer->Rewind(); 
+ 
+        ExecuteCtx->Reset(settings); 
+    } 
+ 
+private: 
+    TIntrusivePtr<IKqpGateway> Gateway; 
     TString Cluster;
-    THolder<TExprContext> ExprCtx;
-    IModuleResolver::TPtr ModuleResolver;
-    bool KeepConfigChanges;
-
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
+    THolder<TExprContext> ExprCtx; 
+    IModuleResolver::TPtr ModuleResolver; 
+    bool KeepConfigChanges; 
+ 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
     THashMap<TString, TString> ClustersMap;
-
-    TIntrusivePtr<NKikimr::NMiniKQL::IFunctionRegistry> FuncRegistryHolder;
-    const NKikimr::NMiniKQL::IFunctionRegistry* FuncRegistry;
-
-    TIntrusivePtr<TTypeAnnotationContext> TypesCtx;
-    TAutoPtr<IPlanBuilder> PlanBuilder;
-    IDataProvider::TFillSettings FillSettings;
-    TIntrusivePtr<TResultProviderConfig> ResultProviderConfig;
-    TAutoPtr<IGraphTransformer> YqlTransformer;
-    TAutoPtr<IGraphTransformer> DataQueryAstTransformer;
-    TAutoPtr<IGraphTransformer> ExecutePreparedTransformer;
-    TExprNode::TPtr FakeWorld;
-
-    TIntrusivePtr<TExecuteContext> ExecuteCtx;
-    TIntrusivePtr<IKqpRunner> KqpRunner;
-
-    TIntrusivePtr<TKqpTransactionContext> ImplicitTransaction;
-    TLRUCache<TString, TIntrusivePtr<TKqpTransactionContext>> ExplicitTransactions;
-    THashMap<TString, TIntrusivePtr<TKqpTransactionContext>> AbortedTransactions;
-};
-
-} // namespace
-
+ 
+    TIntrusivePtr<NKikimr::NMiniKQL::IFunctionRegistry> FuncRegistryHolder; 
+    const NKikimr::NMiniKQL::IFunctionRegistry* FuncRegistry; 
+ 
+    TIntrusivePtr<TTypeAnnotationContext> TypesCtx; 
+    TAutoPtr<IPlanBuilder> PlanBuilder; 
+    IDataProvider::TFillSettings FillSettings; 
+    TIntrusivePtr<TResultProviderConfig> ResultProviderConfig; 
+    TAutoPtr<IGraphTransformer> YqlTransformer; 
+    TAutoPtr<IGraphTransformer> DataQueryAstTransformer; 
+    TAutoPtr<IGraphTransformer> ExecutePreparedTransformer; 
+    TExprNode::TPtr FakeWorld; 
+ 
+    TIntrusivePtr<TExecuteContext> ExecuteCtx; 
+    TIntrusivePtr<IKqpRunner> KqpRunner; 
+ 
+    TIntrusivePtr<TKqpTransactionContext> ImplicitTransaction; 
+    TLRUCache<TString, TIntrusivePtr<TKqpTransactionContext>> ExplicitTransactions; 
+    THashMap<TString, TIntrusivePtr<TKqpTransactionContext>> AbortedTransactions; 
+}; 
+ 
+} // namespace 
+ 
 NDqProto::EDqStatsMode GetStatsMode(NYql::EKikimrStatsMode statsMode) {
-    switch (statsMode) {
-        case NYql::EKikimrStatsMode::Basic:
+    switch (statsMode) { 
+        case NYql::EKikimrStatsMode::Basic: 
             return NYql::NDqProto::DQ_STATS_MODE_BASIC;
-        case NYql::EKikimrStatsMode::Profile:
+        case NYql::EKikimrStatsMode::Profile: 
             return NYql::NDqProto::DQ_STATS_MODE_PROFILE;
-        default:
+        default: 
             return NYql::NDqProto::DQ_STATS_MODE_NONE;
-    }
-}
-
+    } 
+} 
+ 
 TKqpTransactionInfo TKqpTransactionContext::GetInfo() const {
-    TKqpTransactionInfo txInfo;
-
-    // Status
-    if (Invalidated) {
-        txInfo.Status = TKqpTransactionInfo::EStatus::Aborted;
-    } else if (Closed) {
+    TKqpTransactionInfo txInfo; 
+ 
+    // Status 
+    if (Invalidated) { 
+        txInfo.Status = TKqpTransactionInfo::EStatus::Aborted; 
+    } else if (Closed) { 
         txInfo.Status = TKqpTransactionInfo::EStatus::Committed;
-    } else {
-        txInfo.Status = TKqpTransactionInfo::EStatus::Active;
-    }
-
-    // Kind
-    bool hasReads = false;
-    bool hasWrites = false;
-    for (auto& pair : TableOperations) {
-        hasReads = hasReads || (pair.second & KikimrReadOps());
-        hasWrites = hasWrites || (pair.second & KikimrModifyOps());
-    }
-
-    if (hasReads) {
-        txInfo.Kind = hasWrites
-            ? TKqpTransactionInfo::EKind::ReadWrite
-            : TKqpTransactionInfo::EKind::ReadOnly;
-    } else {
-        txInfo.Kind = hasWrites
-            ? TKqpTransactionInfo::EKind::WriteOnly
-            : TKqpTransactionInfo::EKind::Pure;
-    }
-
-    txInfo.TotalDuration = FinishTime - CreationTime;
-    txInfo.ServerDuration = QueriesDuration;
-    txInfo.QueriesCount = QueriesCount;
-
+    } else { 
+        txInfo.Status = TKqpTransactionInfo::EStatus::Active; 
+    } 
+ 
+    // Kind 
+    bool hasReads = false; 
+    bool hasWrites = false; 
+    for (auto& pair : TableOperations) { 
+        hasReads = hasReads || (pair.second & KikimrReadOps()); 
+        hasWrites = hasWrites || (pair.second & KikimrModifyOps()); 
+    } 
+ 
+    if (hasReads) { 
+        txInfo.Kind = hasWrites 
+            ? TKqpTransactionInfo::EKind::ReadWrite 
+            : TKqpTransactionInfo::EKind::ReadOnly; 
+    } else { 
+        txInfo.Kind = hasWrites 
+            ? TKqpTransactionInfo::EKind::WriteOnly 
+            : TKqpTransactionInfo::EKind::Pure; 
+    } 
+ 
+    txInfo.TotalDuration = FinishTime - CreationTime; 
+    txInfo.ServerDuration = QueriesDuration; 
+    txInfo.QueriesCount = QueriesCount; 
+ 
     txInfo.TxEngine = DeferredEffects.GetEngine();
     txInfo.ForceNewEngineState = ForceNewEngineSettings;
 
-    return txInfo;
-}
-
-TIntrusivePtr<IKqpHost> CreateKqpHost(TIntrusivePtr<IKqpGateway> gateway,
+    return txInfo; 
+} 
+ 
+TIntrusivePtr<IKqpHost> CreateKqpHost(TIntrusivePtr<IKqpGateway> gateway, 
     const TString& cluster, const TString& database, TKikimrConfiguration::TPtr config, IModuleResolver::TPtr moduleResolver,
-    const NKikimr::NMiniKQL::IFunctionRegistry* funcRegistry, bool keepConfigChanges)
-{
+    const NKikimr::NMiniKQL::IFunctionRegistry* funcRegistry, bool keepConfigChanges) 
+{ 
     return MakeIntrusive<TKqpHost>(gateway, cluster, database, config, moduleResolver, funcRegistry,
-        keepConfigChanges);
-}
-
+        keepConfigChanges); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/host/kqp_host.h b/ydb/core/kqp/host/kqp_host.h
index 11282d0ebe..e7e2a19538 100644
--- a/ydb/core/kqp/host/kqp_host.h
+++ b/ydb/core/kqp/host/kqp_host.h
@@ -1,124 +1,124 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/common/kqp_transform.h>
 #include <ydb/core/kqp/common/kqp_gateway.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider.h>
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-class IKqpHost : public TThrRefBase {
-public:
-    using TQueryResult = IKqpGateway::TQueryResult;
-    using TGenericResult = IKqpGateway::TGenericResult;
-    using IAsyncQueryResult = NYql::IKikimrAsyncResult<TQueryResult>;
-    using IAsyncQueryResultPtr = TIntrusivePtr<IAsyncQueryResult>;
-    using IAsyncGenericResult = NYql::IKikimrAsyncResult<TGenericResult>;
-    using IAsyncGenericResultPtr = TIntrusivePtr<IAsyncGenericResult>;
-
-    struct TBeginTxResult : public NYql::NCommon::TOperationResult {
-        TString TxId;
-        ui32 EvictedTx = 0;
-        ui32 CurrentActiveTx = 0;
-        ui32 CurrentAbortedTx = 0;
-    };
-
-    struct TPrepareSettings {
-        TMaybe<bool> UseNewEngine;
-        TMaybe<bool> DocumentApiRestricted;
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+class IKqpHost : public TThrRefBase { 
+public: 
+    using TQueryResult = IKqpGateway::TQueryResult; 
+    using TGenericResult = IKqpGateway::TGenericResult; 
+    using IAsyncQueryResult = NYql::IKikimrAsyncResult<TQueryResult>; 
+    using IAsyncQueryResultPtr = TIntrusivePtr<IAsyncQueryResult>; 
+    using IAsyncGenericResult = NYql::IKikimrAsyncResult<TGenericResult>; 
+    using IAsyncGenericResultPtr = TIntrusivePtr<IAsyncGenericResult>; 
+ 
+    struct TBeginTxResult : public NYql::NCommon::TOperationResult { 
+        TString TxId; 
+        ui32 EvictedTx = 0; 
+        ui32 CurrentActiveTx = 0; 
+        ui32 CurrentAbortedTx = 0; 
+    }; 
+ 
+    struct TPrepareSettings { 
+        TMaybe<bool> UseNewEngine; 
+        TMaybe<bool> DocumentApiRestricted; 
 
         TString ToString() const {
             return TStringBuilder() << "TPrepareSettings{ UseNewEngine: " << UseNewEngine
                 << ", DocumentApiRestricted: " << DocumentApiRestricted << " }";
         }
-    };
-
-    struct TExecScriptSettings {
-        NYql::TKikimrQueryDeadlines Deadlines;
-        NYql::EKikimrStatsMode StatsMode = NYql::EKikimrStatsMode::None;
-    };
-
-    virtual ~IKqpHost() {}
-
-    virtual TMaybe<TKqpTransactionInfo> GetTransactionInfo() = 0;
-
+    }; 
+ 
+    struct TExecScriptSettings { 
+        NYql::TKikimrQueryDeadlines Deadlines; 
+        NYql::EKikimrStatsMode StatsMode = NYql::EKikimrStatsMode::None; 
+    }; 
+ 
+    virtual ~IKqpHost() {} 
+ 
+    virtual TMaybe<TKqpTransactionInfo> GetTransactionInfo() = 0; 
+ 
     virtual void ForceTxOldEngine(const TString& txId) = 0;
     virtual void ForceTxNewEngine(const TString& txId, ui32 percent, ui32 level) = 0;
 
-    /* Transaction control */
-    virtual TBeginTxResult BeginTransaction(NKikimrKqp::EIsolationLevel isolationLevel,
-        bool readonly) = 0;
-
-    virtual TGenericResult DeleteTransaction(const TString& txId) = 0;
-
-    virtual IAsyncQueryResultPtr CommitTransaction(const TString& txId,
-        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-    virtual TQueryResult SyncCommitTransaction(const TString& txId,
-        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
+    /* Transaction control */ 
+    virtual TBeginTxResult BeginTransaction(NKikimrKqp::EIsolationLevel isolationLevel, 
+        bool readonly) = 0; 
+ 
+    virtual TGenericResult DeleteTransaction(const TString& txId) = 0; 
+ 
+    virtual IAsyncQueryResultPtr CommitTransaction(const TString& txId, 
+        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+    virtual TQueryResult SyncCommitTransaction(const TString& txId, 
+        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+ 
     virtual IAsyncQueryResultPtr RollbackTransaction(const TString& txId,
         const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
     virtual TQueryResult SyncRollbackTransaction(const TString& txId,
         const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
-    virtual TMaybe<TKqpTransactionInfo> GetTransactionInfo(const TString& txId) = 0;
-
-    virtual bool AbortTransaction(const TString& txId) = 0;
-    virtual ui32 AbortAll() = 0;
-
+ 
+    virtual TMaybe<TKqpTransactionInfo> GetTransactionInfo(const TString& txId) = 0; 
+ 
+    virtual bool AbortTransaction(const TString& txId) = 0; 
+    virtual ui32 AbortAll() = 0; 
+ 
     virtual IAsyncQueryResultPtr RollbackAborted() = 0;
     virtual TQueryResult SyncRollbackAborted() = 0;
-
-    /* Data queries */
-    virtual IAsyncQueryResultPtr ExplainDataQuery(const TString& query, bool isSql) = 0;
-    virtual TQueryResult SyncExplainDataQuery(const TString& query, bool isSql) = 0;
-
-    virtual IAsyncQueryResultPtr PrepareDataQuery(const TString& query, const TPrepareSettings& settings) = 0;
-    virtual TQueryResult SyncPrepareDataQuery(const TString& query, const TPrepareSettings& settings) = 0;
-
+ 
+    /* Data queries */ 
+    virtual IAsyncQueryResultPtr ExplainDataQuery(const TString& query, bool isSql) = 0; 
+    virtual TQueryResult SyncExplainDataQuery(const TString& query, bool isSql) = 0; 
+ 
+    virtual IAsyncQueryResultPtr PrepareDataQuery(const TString& query, const TPrepareSettings& settings) = 0; 
+    virtual TQueryResult SyncPrepareDataQuery(const TString& query, const TPrepareSettings& settings) = 0; 
+ 
     virtual IAsyncQueryResultPtr ExecuteDataQuery(const TString& txId, std::shared_ptr<const NKikimrKqp::TPreparedQuery>& query,
-        NKikimrMiniKQL::TParams&& parameters, const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
+        NKikimrMiniKQL::TParams&& parameters, const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+ 
     virtual TQueryResult SyncExecuteDataQuery(const TString& txId, std::shared_ptr<const NKikimrKqp::TPreparedQuery>& query,
-        NKikimrMiniKQL::TParams&& parameters, const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
-    virtual IAsyncQueryResultPtr ExecuteDataQuery(const TString& txId, const TString& query, bool isSql,
-        NKikimrMiniKQL::TParams&& parameters, const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
-    virtual TQueryResult SyncExecuteDataQuery(const TString& txId, const TString& query, bool isSql,
-        NKikimrMiniKQL::TParams&&, const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
-    /* Scheme queries */
-    virtual IAsyncQueryResultPtr ExecuteSchemeQuery(const TString& query, bool isSql) = 0;
-    virtual TQueryResult SyncExecuteSchemeQuery(const TString& query, bool isSql) = 0;
-
-    /* Scan queries */
-    virtual IAsyncQueryResultPtr ExecuteScanQuery(const TString& query, bool isSql,
+        NKikimrMiniKQL::TParams&& parameters, const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+ 
+    virtual IAsyncQueryResultPtr ExecuteDataQuery(const TString& txId, const TString& query, bool isSql, 
+        NKikimrMiniKQL::TParams&& parameters, const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+ 
+    virtual TQueryResult SyncExecuteDataQuery(const TString& txId, const TString& query, bool isSql, 
+        NKikimrMiniKQL::TParams&&, const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+ 
+    /* Scheme queries */ 
+    virtual IAsyncQueryResultPtr ExecuteSchemeQuery(const TString& query, bool isSql) = 0; 
+    virtual TQueryResult SyncExecuteSchemeQuery(const TString& query, bool isSql) = 0; 
+ 
+    /* Scan queries */ 
+    virtual IAsyncQueryResultPtr ExecuteScanQuery(const TString& query, bool isSql, 
         NKikimrMiniKQL::TParams&& parameters, const NActors::TActorId& target,
-        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
+        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+ 
     virtual IAsyncQueryResultPtr ExplainScanQuery(const TString& query, bool isSql) = 0;
 
-    /* Scripting */
+    /* Scripting */ 
     virtual IAsyncQueryResultPtr ValidateYqlScript(const TString& script) = 0;
     virtual TQueryResult SyncValidateYqlScript(const TString& script) = 0;
 
-    virtual IAsyncQueryResultPtr ExplainYqlScript(const TString& script) = 0;
-    virtual TQueryResult SyncExplainYqlScript(const TString& script) = 0;
-
-    virtual IAsyncQueryResultPtr ExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters,
-        const TExecScriptSettings& settings) = 0;
-    virtual TQueryResult SyncExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters,
-        const TExecScriptSettings& settings) = 0;
+    virtual IAsyncQueryResultPtr ExplainYqlScript(const TString& script) = 0; 
+    virtual TQueryResult SyncExplainYqlScript(const TString& script) = 0; 
+ 
+    virtual IAsyncQueryResultPtr ExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters, 
+        const TExecScriptSettings& settings) = 0; 
+    virtual TQueryResult SyncExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters, 
+        const TExecScriptSettings& settings) = 0; 
 
     virtual IAsyncQueryResultPtr StreamExecuteYqlScript(const TString& script, NKikimrMiniKQL::TParams&& parameters,
         const NActors::TActorId& target, const TExecScriptSettings& settings) = 0;
-};
-
-TIntrusivePtr<IKqpHost> CreateKqpHost(TIntrusivePtr<IKqpGateway> gateway,
+}; 
+ 
+TIntrusivePtr<IKqpHost> CreateKqpHost(TIntrusivePtr<IKqpGateway> gateway, 
     const TString& cluster, const TString& database, NYql::TKikimrConfiguration::TPtr config, NYql::IModuleResolver::TPtr moduleResolver,
-    const NKikimr::NMiniKQL::IFunctionRegistry* funcRegistry = nullptr, bool keepConfigChanges = false);
-
+    const NKikimr::NMiniKQL::IFunctionRegistry* funcRegistry = nullptr, bool keepConfigChanges = false); 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/host/kqp_host_impl.h b/ydb/core/kqp/host/kqp_host_impl.h
index fb1fb139cd..796edc7cfb 100644
--- a/ydb/core/kqp/host/kqp_host_impl.h
+++ b/ydb/core/kqp/host/kqp_host_impl.h
@@ -1,297 +1,297 @@
-#pragma once
-
-#include "kqp_host.h"
-
+#pragma once 
+ 
+#include "kqp_host.h" 
+ 
 #include <ydb/core/kqp/common/kqp_transform.h>
 #include <ydb/core/kqp/prepare/kqp_prepare.h>
-
-namespace NKikimr {
-namespace NKqp {
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
 NYql::NDqProto::EDqStatsMode GetStatsMode(NYql::EKikimrStatsMode statsMode);
-
-template<typename TResult, bool copyIssues = true>
-class TKqpAsyncResultBase : public NYql::IKikimrAsyncResult<TResult> {
-public:
-    using TTransformStatusCallback = std::function<void(const NYql::IGraphTransformer::TStatus&)>;
-
-public:
-    TKqpAsyncResultBase(const NYql::TExprNode::TPtr& exprRoot, NYql::TExprContext& exprCtx,
-        NYql::IGraphTransformer& transformer, TTransformStatusCallback transformCallback = {})
-        : ExprRoot(exprRoot)
-        , ExprCtx(exprCtx)
-        , Transformer(transformer)
-        , TransformCallback(transformCallback) {}
-
-    bool HasResult() const override {
-        if (TransformFinished()) {
-            return TransformCallbackDone || !TransformCallback;
-        }
-
-        return false;
-    }
-
+ 
+template<typename TResult, bool copyIssues = true> 
+class TKqpAsyncResultBase : public NYql::IKikimrAsyncResult<TResult> { 
+public: 
+    using TTransformStatusCallback = std::function<void(const NYql::IGraphTransformer::TStatus&)>; 
+ 
+public: 
+    TKqpAsyncResultBase(const NYql::TExprNode::TPtr& exprRoot, NYql::TExprContext& exprCtx, 
+        NYql::IGraphTransformer& transformer, TTransformStatusCallback transformCallback = {}) 
+        : ExprRoot(exprRoot) 
+        , ExprCtx(exprCtx) 
+        , Transformer(transformer) 
+        , TransformCallback(transformCallback) {} 
+ 
+    bool HasResult() const override { 
+        if (TransformFinished()) { 
+            return TransformCallbackDone || !TransformCallback; 
+        } 
+ 
+        return false; 
+    } 
+ 
     TResult GetResult() override {
-        YQL_ENSURE(HasResult());
-
-        if (Status.GetValue() == NYql::IGraphTransformer::TStatus::Error) {
-            return NYql::NCommon::ResultFromErrors<TResult>(ExprCtx.IssueManager.GetIssues());
-        }
-
-        YQL_ENSURE(Status.GetValue() == NYql::IGraphTransformer::TStatus::Ok);
-
-        TResult result;
-        result.ProtobufArenaPtr.reset(new google::protobuf::Arena());
-
-        result.SetSuccess();
-
-        if (copyIssues) {
-            result.AddIssues(ExprCtx.IssueManager.GetIssues());
-        }
-        FillResult(result);
+        YQL_ENSURE(HasResult()); 
+ 
+        if (Status.GetValue() == NYql::IGraphTransformer::TStatus::Error) { 
+            return NYql::NCommon::ResultFromErrors<TResult>(ExprCtx.IssueManager.GetIssues()); 
+        } 
+ 
+        YQL_ENSURE(Status.GetValue() == NYql::IGraphTransformer::TStatus::Ok); 
+ 
+        TResult result; 
+        result.ProtobufArenaPtr.reset(new google::protobuf::Arena()); 
+ 
+        result.SetSuccess(); 
+ 
+        if (copyIssues) { 
+            result.AddIssues(ExprCtx.IssueManager.GetIssues()); 
+        } 
+        FillResult(result); 
         return std::move(result);
-    }
-
-    NThreading::TFuture<bool> Continue() override {
-        if (TransformFinished()) {
-            if (TransformCallback && !TransformCallbackDone) {
-                TransformCallback(Status.GetValue());
-                TransformCallbackDone = true;
-            }
-
-            return NThreading::MakeFuture<bool>(true);
-        }
-
-        Status = NThreading::NewPromise<NYql::IGraphTransformer::TStatus>();
-
-        auto resultPromise = NThreading::NewPromise<bool>();
-        auto statusPromise = Status;
-        bool hasCallback = !!TransformCallback;
-
-        AsyncTransform(Transformer, ExprRoot, ExprCtx, Started,
-            [resultPromise, statusPromise, hasCallback](const NYql::IGraphTransformer::TStatus& status) mutable {
-                bool transformFinished = status != NYql::IGraphTransformer::TStatus::Async;
-                bool finished = transformFinished && !hasCallback;
-
-                statusPromise.SetValue(status);
-                resultPromise.SetValue(finished);
-            });
-
-        Started = true;
-        return resultPromise.GetFuture();
-    }
-
-protected:
-    virtual void FillResult(TResult& result) const = 0;
-
-    NYql::TExprNode::TPtr GetExprRoot() const { return ExprRoot; }
+    } 
+ 
+    NThreading::TFuture<bool> Continue() override { 
+        if (TransformFinished()) { 
+            if (TransformCallback && !TransformCallbackDone) { 
+                TransformCallback(Status.GetValue()); 
+                TransformCallbackDone = true; 
+            } 
+ 
+            return NThreading::MakeFuture<bool>(true); 
+        } 
+ 
+        Status = NThreading::NewPromise<NYql::IGraphTransformer::TStatus>(); 
+ 
+        auto resultPromise = NThreading::NewPromise<bool>(); 
+        auto statusPromise = Status; 
+        bool hasCallback = !!TransformCallback; 
+ 
+        AsyncTransform(Transformer, ExprRoot, ExprCtx, Started, 
+            [resultPromise, statusPromise, hasCallback](const NYql::IGraphTransformer::TStatus& status) mutable { 
+                bool transformFinished = status != NYql::IGraphTransformer::TStatus::Async; 
+                bool finished = transformFinished && !hasCallback; 
+ 
+                statusPromise.SetValue(status); 
+                resultPromise.SetValue(finished); 
+            }); 
+ 
+        Started = true; 
+        return resultPromise.GetFuture(); 
+    } 
+ 
+protected: 
+    virtual void FillResult(TResult& result) const = 0; 
+ 
+    NYql::TExprNode::TPtr GetExprRoot() const { return ExprRoot; } 
     NYql::TExprContext& GetExprContext() const { return ExprCtx; }
-    NYql::IGraphTransformer& GetTransformer() const { return Transformer; }
-
-private:
-    bool TransformFinished() const {
-        return Status.HasValue() && Status.GetValue() != NYql::IGraphTransformer::TStatus::Async;
-    }
-
-private:
-    NYql::TExprNode::TPtr ExprRoot;
-    NYql::TExprContext& ExprCtx;
-    NYql::IGraphTransformer& Transformer;
-    bool Started = false;
-    TTransformStatusCallback TransformCallback;
-    bool TransformCallbackDone = false;
-    NThreading::TPromise<NYql::IGraphTransformer::TStatus> Status;
-};
-
-
-template<typename TResult, typename TApplyResult>
-class TKqpAsyncApplyResult : public NYql::IKikimrAsyncResult<TApplyResult> {
-public:
+    NYql::IGraphTransformer& GetTransformer() const { return Transformer; } 
+ 
+private: 
+    bool TransformFinished() const { 
+        return Status.HasValue() && Status.GetValue() != NYql::IGraphTransformer::TStatus::Async; 
+    } 
+ 
+private: 
+    NYql::TExprNode::TPtr ExprRoot; 
+    NYql::TExprContext& ExprCtx; 
+    NYql::IGraphTransformer& Transformer; 
+    bool Started = false; 
+    TTransformStatusCallback TransformCallback; 
+    bool TransformCallbackDone = false; 
+    NThreading::TPromise<NYql::IGraphTransformer::TStatus> Status; 
+}; 
+ 
+ 
+template<typename TResult, typename TApplyResult> 
+class TKqpAsyncApplyResult : public NYql::IKikimrAsyncResult<TApplyResult> { 
+public: 
     using TCallback = std::function<TIntrusivePtr<NYql::IKikimrAsyncResult<TApplyResult>>(TResult&&)>;
-
-    TKqpAsyncApplyResult(TIntrusivePtr<NYql::IKikimrAsyncResult<TResult>> result, const TCallback& callback)
-        : Result(result)
-        , Callback(callback)
-    {
-        YQL_ENSURE(Result);
-        YQL_ENSURE(Callback);
-    }
-
-    bool HasResult() const override {
-        if (!ApplyResult) {
-            return false;
-        }
-
-        return ApplyResult->HasResult();
-    }
-
+ 
+    TKqpAsyncApplyResult(TIntrusivePtr<NYql::IKikimrAsyncResult<TResult>> result, const TCallback& callback) 
+        : Result(result) 
+        , Callback(callback) 
+    { 
+        YQL_ENSURE(Result); 
+        YQL_ENSURE(Callback); 
+    } 
+ 
+    bool HasResult() const override { 
+        if (!ApplyResult) { 
+            return false; 
+        } 
+ 
+        return ApplyResult->HasResult(); 
+    } 
+ 
     TApplyResult GetResult() override {
-        YQL_ENSURE(HasResult());
-
+        YQL_ENSURE(HasResult()); 
+ 
         return std::move(ApplyResult->GetResult());
-    }
-
-    NThreading::TFuture<bool> Continue() override {
-        if (!ApplyResult) {
-            if (Result->HasResult()) {
-                ApplyResult = Callback(Result->GetResult());
-            } else {
-                return Result->Continue().Apply([](const NThreading::TFuture<bool>& future) {
-                    YQL_ENSURE(future.HasValue());
-                    return NThreading::MakeFuture<bool>(false);
-                });
-            }
-        }
-
-        return ApplyResult->Continue();
-    }
-private:
-    TIntrusivePtr<NYql::IKikimrAsyncResult<TResult>> Result;
-    TIntrusivePtr<NYql::IKikimrAsyncResult<TApplyResult>> ApplyResult;
-    TCallback Callback;
-};
-
-template<typename TItem, typename TExecResult>
-class TKqpAsyncExecAllResult : public NYql::IKikimrAsyncResult<TExecResult> {
-public:
+    } 
+ 
+    NThreading::TFuture<bool> Continue() override { 
+        if (!ApplyResult) { 
+            if (Result->HasResult()) { 
+                ApplyResult = Callback(Result->GetResult()); 
+            } else { 
+                return Result->Continue().Apply([](const NThreading::TFuture<bool>& future) { 
+                    YQL_ENSURE(future.HasValue()); 
+                    return NThreading::MakeFuture<bool>(false); 
+                }); 
+            } 
+        } 
+ 
+        return ApplyResult->Continue(); 
+    } 
+private: 
+    TIntrusivePtr<NYql::IKikimrAsyncResult<TResult>> Result; 
+    TIntrusivePtr<NYql::IKikimrAsyncResult<TApplyResult>> ApplyResult; 
+    TCallback Callback; 
+}; 
+ 
+template<typename TItem, typename TExecResult> 
+class TKqpAsyncExecAllResult : public NYql::IKikimrAsyncResult<TExecResult> { 
+public: 
     using TCallback = std::function<TIntrusivePtr<NYql::IKikimrAsyncResult<TExecResult>>(TItem&&)>;
-
-    TKqpAsyncExecAllResult(const TVector<TItem>& items, const TCallback& callback)
-        : Items(items)
-        , Callback(callback)
-    {
-        YQL_ENSURE(Callback);
-    }
-
-    bool HasResult() const override {
-        return CurrentIndex >= Items.size();
-    }
-
+ 
+    TKqpAsyncExecAllResult(const TVector<TItem>& items, const TCallback& callback) 
+        : Items(items) 
+        , Callback(callback) 
+    { 
+        YQL_ENSURE(Callback); 
+    } 
+ 
+    bool HasResult() const override { 
+        return CurrentIndex >= Items.size(); 
+    } 
+ 
     TExecResult GetResult() override {
-        YQL_ENSURE(HasResult());
-
-        TExecResult execResult;
-        if (Success) {
-            execResult.SetSuccess();
-        }
-
-        execResult.AddIssues(Issues);
-
+        YQL_ENSURE(HasResult()); 
+ 
+        TExecResult execResult; 
+        if (Success) { 
+            execResult.SetSuccess(); 
+        } 
+ 
+        execResult.AddIssues(Issues); 
+ 
         return std::move(execResult);
-    }
-
-    NThreading::TFuture<bool> Continue() override {
-        if (HasResult()) {
-            return NThreading::MakeFuture<bool>(true);
-        }
-
-        if (!CurrentResult) {
+    } 
+ 
+    NThreading::TFuture<bool> Continue() override { 
+        if (HasResult()) { 
+            return NThreading::MakeFuture<bool>(true); 
+        } 
+ 
+        if (!CurrentResult) { 
             CurrentResult.Reset(Callback(std::move(Items[CurrentIndex])));
-        }
-
-        if (CurrentResult->HasResult()) {
-            auto result = CurrentResult->GetResult();
-            Success = Success && result.Success();
-            Issues.AddIssues(result.Issues());
-
-            ++CurrentIndex;
-            CurrentResult.Reset();
-
-            return NThreading::MakeFuture<bool>(false);
-        }
-
-        return CurrentResult->Continue().Apply(
-            [](const NThreading::TFuture<bool>& future) {
-                YQL_ENSURE(future.HasValue());
-                return NThreading::MakeFuture<bool>(false);
-            });;
-    }
-
-private:
-    TVector<TItem> Items;
-    TCallback Callback;
-
-    ui32 CurrentIndex= 0;
-    TIntrusivePtr<NYql::IKikimrAsyncResult<TExecResult>> CurrentResult;
-    bool Success = true;
-    NYql::TIssues Issues;
-};
-
-template<typename TResult, typename TApplyResult>
-TIntrusivePtr<NYql::IKikimrAsyncResult<TApplyResult>> AsyncApplyResult(
-    TIntrusivePtr<NYql::IKikimrAsyncResult<TResult>> result,
-    const typename TKqpAsyncApplyResult<TResult, TApplyResult>::TCallback& callback)
-{
-    return MakeIntrusive<TKqpAsyncApplyResult<TResult, TApplyResult>>(result, callback);
-}
-
-template<typename TResult, bool copyIssues = true>
-class TKqpAsyncExecuteResultBase : public TKqpAsyncResultBase<TResult, copyIssues> {
-public:
-    TKqpAsyncExecuteResultBase(const NYql::TExprNode::TPtr& exprRoot, NYql::TExprContext& exprCtx,
-        NYql::IGraphTransformer& transformer, TIntrusivePtr<NYql::IKikimrTransactionContext> txCtx)
-        : TKqpAsyncResultBase<TResult, copyIssues>(exprRoot, exprCtx, transformer,
-            [txCtx](const auto& status) {
-                if (txCtx) {
-                    auto& kqpTxCtx = static_cast<TKqpTransactionContext&>(*txCtx);
-                    if (status == NYql::IGraphTransformer::TStatus::Ok) {
-                        kqpTxCtx.OnEndQuery();
-                    } else {
-                        kqpTxCtx.Invalidate();
-                    }
-                }
-            }) {}
-};
-
-class IKqpRunner : public TThrRefBase {
-public:
-    using TQueryResult = NYql::IKikimrGateway::TQueryResult;
-    using TAsyncQueryResult = NYql::IKikimrAsyncResult<TQueryResult>;
-
-    /* Data queries */
-    virtual TIntrusivePtr<TAsyncQueryResult> PrepareDataQuery(const TString& cluster,
-        const NYql::TExprNode::TPtr& query, NYql::TExprContext& ctx,
-        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
-    virtual TIntrusivePtr<TAsyncQueryResult> PrepareScanQuery(const TString& cluster,
-        const NYql::TExprNode::TPtr& query, NYql::TExprContext& ctx,
-        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
-    virtual TIntrusivePtr<TAsyncQueryResult> ExecutePreparedDataQuery(const TString& cluster,
+        } 
+ 
+        if (CurrentResult->HasResult()) { 
+            auto result = CurrentResult->GetResult(); 
+            Success = Success && result.Success(); 
+            Issues.AddIssues(result.Issues()); 
+ 
+            ++CurrentIndex; 
+            CurrentResult.Reset(); 
+ 
+            return NThreading::MakeFuture<bool>(false); 
+        } 
+ 
+        return CurrentResult->Continue().Apply( 
+            [](const NThreading::TFuture<bool>& future) { 
+                YQL_ENSURE(future.HasValue()); 
+                return NThreading::MakeFuture<bool>(false); 
+            });; 
+    } 
+ 
+private: 
+    TVector<TItem> Items; 
+    TCallback Callback; 
+ 
+    ui32 CurrentIndex= 0; 
+    TIntrusivePtr<NYql::IKikimrAsyncResult<TExecResult>> CurrentResult; 
+    bool Success = true; 
+    NYql::TIssues Issues; 
+}; 
+ 
+template<typename TResult, typename TApplyResult> 
+TIntrusivePtr<NYql::IKikimrAsyncResult<TApplyResult>> AsyncApplyResult( 
+    TIntrusivePtr<NYql::IKikimrAsyncResult<TResult>> result, 
+    const typename TKqpAsyncApplyResult<TResult, TApplyResult>::TCallback& callback) 
+{ 
+    return MakeIntrusive<TKqpAsyncApplyResult<TResult, TApplyResult>>(result, callback); 
+} 
+ 
+template<typename TResult, bool copyIssues = true> 
+class TKqpAsyncExecuteResultBase : public TKqpAsyncResultBase<TResult, copyIssues> { 
+public: 
+    TKqpAsyncExecuteResultBase(const NYql::TExprNode::TPtr& exprRoot, NYql::TExprContext& exprCtx, 
+        NYql::IGraphTransformer& transformer, TIntrusivePtr<NYql::IKikimrTransactionContext> txCtx) 
+        : TKqpAsyncResultBase<TResult, copyIssues>(exprRoot, exprCtx, transformer, 
+            [txCtx](const auto& status) { 
+                if (txCtx) { 
+                    auto& kqpTxCtx = static_cast<TKqpTransactionContext&>(*txCtx); 
+                    if (status == NYql::IGraphTransformer::TStatus::Ok) { 
+                        kqpTxCtx.OnEndQuery(); 
+                    } else { 
+                        kqpTxCtx.Invalidate(); 
+                    } 
+                } 
+            }) {} 
+}; 
+ 
+class IKqpRunner : public TThrRefBase { 
+public: 
+    using TQueryResult = NYql::IKikimrGateway::TQueryResult; 
+    using TAsyncQueryResult = NYql::IKikimrAsyncResult<TQueryResult>; 
+ 
+    /* Data queries */ 
+    virtual TIntrusivePtr<TAsyncQueryResult> PrepareDataQuery(const TString& cluster, 
+        const NYql::TExprNode::TPtr& query, NYql::TExprContext& ctx, 
+        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+ 
+    virtual TIntrusivePtr<TAsyncQueryResult> PrepareScanQuery(const TString& cluster, 
+        const NYql::TExprNode::TPtr& query, NYql::TExprContext& ctx, 
+        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+ 
+    virtual TIntrusivePtr<TAsyncQueryResult> ExecutePreparedDataQuery(const TString& cluster, 
         NYql::TExprNode* queryExpr, const NKikimrKqp::TPreparedKql& kql, NYql::TExprContext& ctx,
+        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0; 
+ 
+    virtual TIntrusivePtr<TAsyncQueryResult> ExecutePreparedQueryNewEngine(const TString& cluster, 
+        const NYql::TExprNode::TPtr& world, const NKqpProto::TKqpPhyQuery& phyQuery, NYql::TExprContext& ctx, 
         const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
 
-    virtual TIntrusivePtr<TAsyncQueryResult> ExecutePreparedQueryNewEngine(const TString& cluster,
-        const NYql::TExprNode::TPtr& world, const NKqpProto::TKqpPhyQuery& phyQuery, NYql::TExprContext& ctx,
-        const NYql::IKikimrQueryExecutor::TExecuteSettings& settings) = 0;
-
-    virtual TIntrusivePtr<TAsyncQueryResult> ExecutePreparedScanQuery(const TString& cluster,
-        const NYql::TExprNode::TPtr& world, const NKqpProto::TKqpPhyQuery& phyQuery, NYql::TExprContext& ctx,
+    virtual TIntrusivePtr<TAsyncQueryResult> ExecutePreparedScanQuery(const TString& cluster, 
+        const NYql::TExprNode::TPtr& world, const NKqpProto::TKqpPhyQuery& phyQuery, NYql::TExprContext& ctx, 
         const NActors::TActorId& target) = 0;
-};
-
-TIntrusivePtr<IKqpRunner> CreateKqpRunner(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-    TIntrusivePtr<NYql::TTypeAnnotationContext> typesCtx, TIntrusivePtr<NYql::TKikimrSessionContext> sessionCtx,
-    const NMiniKQL::IFunctionRegistry& funcRegistry);
-
-TAutoPtr<NYql::IGraphTransformer> CreateKqpExecutePreparedTransformer(TIntrusivePtr<IKqpGateway> gateway,
-    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx);
-
+}; 
+ 
+TIntrusivePtr<IKqpRunner> CreateKqpRunner(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+    TIntrusivePtr<NYql::TTypeAnnotationContext> typesCtx, TIntrusivePtr<NYql::TKikimrSessionContext> sessionCtx, 
+    const NMiniKQL::IFunctionRegistry& funcRegistry); 
+ 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpExecutePreparedTransformer(TIntrusivePtr<IKqpGateway> gateway, 
+    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx); 
+ 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpAcquireMvccSnapshotTransformer(TIntrusivePtr<IKqpGateway> gateway,
     TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx, bool newEngine = false);
 
-TAutoPtr<NYql::IGraphTransformer> CreateKqpExecutePhysicalDataTransformer(TIntrusivePtr<IKqpGateway> gateway,
-    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx);
-
+TAutoPtr<NYql::IGraphTransformer> CreateKqpExecutePhysicalDataTransformer(TIntrusivePtr<IKqpGateway> gateway, 
+    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx); 
+ 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpExplainPreparedTransformer(TIntrusivePtr<IKqpGateway> gateway,
     const TString& cluster, TIntrusivePtr<TKqlTransformContext> transformCtx);
 
-TAutoPtr<NYql::IGraphTransformer> CreateKqpExecuteScanTransformer(TIntrusivePtr<IKqpGateway> gateway,
-    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx);
-
+TAutoPtr<NYql::IGraphTransformer> CreateKqpExecuteScanTransformer(TIntrusivePtr<IKqpGateway> gateway, 
+    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx); 
+ 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpCreateSnapshotTransformer(TIntrusivePtr<IKqpGateway> gateway,
     TIntrusivePtr<TKqlTransformContext> transformCtx, TIntrusivePtr<TKqpTransactionState> txState);
 
@@ -299,4 +299,4 @@ TAutoPtr<NYql::IGraphTransformer> CreateKqpReleaseSnapshotTransformer(TIntrusive
     TIntrusivePtr<TKqpTransactionState> txState);
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/host/kqp_ne_helper.h b/ydb/core/kqp/host/kqp_ne_helper.h
index 64b495afcc..3f4fb2e691 100644
--- a/ydb/core/kqp/host/kqp_ne_helper.h
+++ b/ydb/core/kqp/host/kqp_ne_helper.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.h>
-
+ 
 #include <ydb/library/yql/ast/yql_expr.h>
 
 namespace NKikimr {
diff --git a/ydb/core/kqp/host/kqp_run_data.cpp b/ydb/core/kqp/host/kqp_run_data.cpp
index b2bc80d71b..ce4d078107 100644
--- a/ydb/core/kqp/host/kqp_run_data.cpp
+++ b/ydb/core/kqp/host/kqp_run_data.cpp
@@ -1,26 +1,26 @@
-#include "kqp_host_impl.h"
-#include "kqp_run_physical.h"
-
+#include "kqp_host_impl.h" 
+#include "kqp_run_physical.h" 
+ 
 #include <ydb/core/kqp/common/kqp_yql.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-using namespace NThreading;
-
-class TKqpExecutePhysicalDataTransformer : public TKqpExecutePhysicalTransformerBase {
-public:
-    TKqpExecutePhysicalDataTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : TKqpExecutePhysicalTransformerBase(gateway, cluster, txState, transformCtx) {}
-
-protected:
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+using namespace NThreading; 
+ 
+class TKqpExecutePhysicalDataTransformer : public TKqpExecutePhysicalTransformerBase { 
+public: 
+    TKqpExecutePhysicalDataTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : TKqpExecutePhysicalTransformerBase(gateway, cluster, txState, transformCtx) {} 
+ 
+protected: 
     TStatus DoExecute(const NKqpProto::TKqpPhyTx* tx, bool commit, NYql::TExprContext& ctx) final {
-        auto& txState = TxState->Tx();
+        auto& txState = TxState->Tx(); 
         auto request = PrepareRequest();
-
+ 
         if (!request.Timeout) {
             ctx.AddError(YqlIssue({}, TIssuesIds::KIKIMR_TIMEOUT, "Query request timeout."));
             return TStatus::Error;
@@ -31,52 +31,52 @@ protected:
             return TStatus::Error;
         }
 
-        if (tx) {
-            switch (tx->GetType()) {
-                case NKqpProto::TKqpPhyTx::TYPE_COMPUTE:
-                case NKqpProto::TKqpPhyTx::TYPE_DATA:
-                    break;
-                default:
-                    YQL_ENSURE(false, "Unexpected physical tx type in data query: " << (ui32)tx->GetType());
-            }
-
-            request.Transactions.emplace_back(*tx, PrepareParameters(*tx));
-        } else {
-            YQL_ENSURE(commit);
+        if (tx) { 
+            switch (tx->GetType()) { 
+                case NKqpProto::TKqpPhyTx::TYPE_COMPUTE: 
+                case NKqpProto::TKqpPhyTx::TYPE_DATA: 
+                    break; 
+                default: 
+                    YQL_ENSURE(false, "Unexpected physical tx type in data query: " << (ui32)tx->GetType()); 
+            } 
+ 
+            request.Transactions.emplace_back(*tx, PrepareParameters(*tx)); 
+        } else { 
+            YQL_ENSURE(commit); 
             if (txState.DeferredEffects.Empty() && !txState.Locks.HasLocks()) {
-                return TStatus::Ok;
-            }
-        }
-
-        if (commit) {
+                return TStatus::Ok; 
+            } 
+        } 
+ 
+        if (commit) { 
             Y_VERIFY_DEBUG(txState.DeferredEffects.Empty() || !txState.Locks.Broken());
 
             for (const auto& effect : txState.DeferredEffects) {
-                YQL_ENSURE(!effect.Node);
-                YQL_ENSURE(effect.PhysicalTx.GetType() == NKqpProto::TKqpPhyTx::TYPE_DATA);
-                request.Transactions.emplace_back(effect.PhysicalTx, GetParamsRefMap(effect.Params));
-            }
-
+                YQL_ENSURE(!effect.Node); 
+                YQL_ENSURE(effect.PhysicalTx.GetType() == NKqpProto::TKqpPhyTx::TYPE_DATA); 
+                request.Transactions.emplace_back(effect.PhysicalTx, GetParamsRefMap(effect.Params)); 
+            } 
+ 
             if (!txState.DeferredEffects.Empty()) {
                 request.PerShardKeysSizeLimitBytes = TransformCtx->Config->_CommitPerShardKeysSizeLimitBytes.Get().GetRef();
             }
 
-            if (txState.Locks.HasLocks()) {
+            if (txState.Locks.HasLocks()) { 
                 request.ValidateLocks = !(txState.GetSnapshot().IsValid() && txState.DeferredEffects.Empty());
                 request.EraseLocks = true;
 
                 for (auto& [lockId, lock] : txState.Locks.LocksMap) {
                     request.Locks.emplace_back(lock.GetValueRef(txState.Locks.LockType));
-                }
-            }
+                } 
+            } 
         } else if (ShouldAcquireLocks()) {
             request.AcquireLocksTxId = txState.Locks.GetLockTxId();
-        }
-
-        ExecuteFuture = Gateway->ExecutePhysical(std::move(request), {});
-        return TStatus::Async;
-    }
-
+        } 
+ 
+        ExecuteFuture = Gateway->ExecutePhysical(std::move(request), {}); 
+        return TStatus::Async; 
+    } 
+ 
     TStatus DoRollback() final {
         auto& txState = TxState->Tx();
 
@@ -98,31 +98,31 @@ protected:
             request.Locks.emplace_back(lock.GetValueRef(txState.Locks.LockType));
         }
 
-        ExecuteFuture = Gateway->ExecutePhysical(std::move(request), {});
+        ExecuteFuture = Gateway->ExecutePhysical(std::move(request), {}); 
         return TStatus::Async;
     }
 
-    bool OnExecuterResult(NKikimrKqp::TExecuterTxResult&& execResult, TExprContext& ctx, bool commit) override {
-        if (execResult.HasLocks()) {
-            YQL_ENSURE(!commit);
-
+    bool OnExecuterResult(NKikimrKqp::TExecuterTxResult&& execResult, TExprContext& ctx, bool commit) override { 
+        if (execResult.HasLocks()) { 
+            YQL_ENSURE(!commit); 
+ 
             if (!MergeLocks(execResult.GetLocks().GetType(), execResult.GetLocks().GetValue(), TxState->Tx(), ctx)) {
                 return false;
-            }
-        }
-
-        if (execResult.HasStats()) {
-            TransformCtx->QueryStats.AddExecutions()->Swap(execResult.MutableStats());
-        }
-
-        if (commit) {
+            } 
+        } 
+ 
+        if (execResult.HasStats()) { 
+            TransformCtx->QueryStats.AddExecutions()->Swap(execResult.MutableStats()); 
+        } 
+ 
+        if (commit) { 
             ClearTx();
-        }
-
-        return true;
-    }
-
-private:
+        } 
+ 
+        return true; 
+    } 
+ 
+private: 
     IKqpGateway::TExecPhysicalRequest PrepareRequest() {
         IKqpGateway::TExecPhysicalRequest request;
         auto now = Gateway->GetCurrentTime();
@@ -136,7 +136,7 @@ private:
         request.TotalReadSizeLimitBytes = TransformCtx->QueryCtx->Limits.PhaseLimits.TotalReadSizeLimitBytes;
         request.MkqlMemoryLimit = TransformCtx->QueryCtx->Limits.PhaseLimits.ComputeNodeMemoryLimitBytes;
         request.Snapshot = TxState->Tx().GetSnapshot();
-        request.IsolationLevel = *TxState->Tx().EffectiveIsolationLevel;
+        request.IsolationLevel = *TxState->Tx().EffectiveIsolationLevel; 
 
         return request;
     }
@@ -171,23 +171,23 @@ private:
         return true;
     }
 
-    TKqpParamsMap GetParamsRefMap(const TParamValueMap& map) {
-        TKqpParamsMap paramsMap(TransformState);
-        for (auto& pair : map) {
-            auto valueRef = NYql::NDq::TMkqlValueRef(pair.second);
-            YQL_ENSURE(paramsMap.Values.emplace(std::make_pair(pair.first, valueRef)).second);
-        }
-
-        return paramsMap;
-    }
-};
-
-TAutoPtr<IGraphTransformer> CreateKqpExecutePhysicalDataTransformer(TIntrusivePtr<IKqpGateway> gateway,
-    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx)
-{
-    return new TKqpExecutePhysicalDataTransformer(gateway, cluster, txState, transformCtx);
-}
-
+    TKqpParamsMap GetParamsRefMap(const TParamValueMap& map) { 
+        TKqpParamsMap paramsMap(TransformState); 
+        for (auto& pair : map) { 
+            auto valueRef = NYql::NDq::TMkqlValueRef(pair.second); 
+            YQL_ENSURE(paramsMap.Values.emplace(std::make_pair(pair.first, valueRef)).second); 
+        } 
+ 
+        return paramsMap; 
+    } 
+}; 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpExecutePhysicalDataTransformer(TIntrusivePtr<IKqpGateway> gateway, 
+    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx) 
+{ 
+    return new TKqpExecutePhysicalDataTransformer(gateway, cluster, txState, transformCtx); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/host/kqp_run_physical.cpp b/ydb/core/kqp/host/kqp_run_physical.cpp
index e6bd601eef..89e9999c84 100644
--- a/ydb/core/kqp/host/kqp_run_physical.cpp
+++ b/ydb/core/kqp/host/kqp_run_physical.cpp
@@ -1,29 +1,29 @@
-#include "kqp_run_physical.h"
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-using namespace NThreading;
-
-IGraphTransformer::TStatus TKqpExecutePhysicalTransformerBase::DoTransform(TExprNode::TPtr input,
-    TExprNode::TPtr& output, TExprContext& ctx)
-{
-    output = input;
-
-    auto settings = TransformCtx->Settings;
-
-    YQL_ENSURE(TMaybeNode<TCoWorld>(input));
-    YQL_ENSURE(TransformCtx->PhysicalQuery);
-
+#include "kqp_run_physical.h" 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+using namespace NThreading; 
+ 
+IGraphTransformer::TStatus TKqpExecutePhysicalTransformerBase::DoTransform(TExprNode::TPtr input, 
+    TExprNode::TPtr& output, TExprContext& ctx) 
+{ 
+    output = input; 
+ 
+    auto settings = TransformCtx->Settings; 
+ 
+    YQL_ENSURE(TMaybeNode<TCoWorld>(input)); 
+    YQL_ENSURE(TransformCtx->PhysicalQuery); 
+ 
     const auto& query = *TransformCtx->PhysicalQuery;
-
-    TStatus status = TStatus::Ok;
-
-    auto& txState = TxState->Tx();
+ 
+    TStatus status = TStatus::Ok; 
+ 
+    auto& txState = TxState->Tx(); 
     const ui64 txsCount = query.TransactionsSize();
-
+ 
     if (settings.GetRollbackTx()) {
         if (ExecuteFlags.HasFlags(TKqpExecuteFlag::Rollback)) {
             ClearTx();
@@ -32,7 +32,7 @@ IGraphTransformer::TStatus TKqpExecutePhysicalTransformerBase::DoTransform(TExpr
         }
     } else if (ExecuteFlags.HasFlags(TKqpExecuteFlag::Commit)) {
         YQL_ENSURE(CurrentTxIndex >= txsCount);
-    } else {
+    } else { 
         if (CurrentTxIndex >= txsCount) {
             if (!txState.DeferredEffects.Empty() && TxState->Tx().Locks.Broken()) {
                 TxState->Tx().Locks.ReportIssues(ctx);
@@ -54,116 +54,116 @@ IGraphTransformer::TStatus TKqpExecutePhysicalTransformerBase::DoTransform(TExpr
 
                 ++CurrentTxIndex;
                 return TStatus::Repeat;
-            }
-
+            } 
+ 
             // tx without effects
 
-            bool commit = false;
+            bool commit = false; 
             if (CurrentTxIndex == txsCount - 1 && settings.GetCommitTx() && txState.DeferredEffects.Empty()) {
                 // last transaction and no effects (RO-query)
                 commit = true;
-            }
+            } 
             status = Execute(&tx, commit, ctx);
-        }
-    }
-
-    if (status == TStatus::Ok) {
-        for (const auto& resultBinding : query.GetResultBindings()) {
-            YQL_ENSURE(resultBinding.GetTypeCase() == NKqpProto::TKqpPhyResultBinding::kTxResultBinding);
-            auto& txResultBinding = resultBinding.GetTxResultBinding();
-            auto txIndex = txResultBinding.GetTxIndex();
-            auto resultIndex = txResultBinding.GetResultIndex();
-
-
-            auto& txResults = TransformState->TxResults;
-            YQL_ENSURE(txIndex < txResults.size());
-            YQL_ENSURE(resultIndex < txResults[txIndex].size());
-            TransformCtx->PhysicalQueryResults.emplace_back(std::move(txResults[txIndex][resultIndex]));
-        }
-
-        return status;
-    }
-
-    if (status == TStatus::Error) {
-        return status;
-    }
-
-    YQL_ENSURE(status == TStatus::Async);
-
-    Promise = NewPromise();
-    auto promise = Promise;
-    ExecuteFuture.Apply([promise](const TFuture<IKqpGateway::TExecPhysicalResult> future) mutable {
-        YQL_ENSURE(future.HasValue());
-        promise.SetValue();
-    });
-
-    return status;
-}
-
-TFuture<void> TKqpExecutePhysicalTransformerBase::DoGetAsyncFuture(const TExprNode& input) {
-    Y_UNUSED(input);
-    return Promise.GetFuture();
-}
-
-IGraphTransformer::TStatus TKqpExecutePhysicalTransformerBase::DoApplyAsyncChanges(TExprNode::TPtr input,
-    TExprNode::TPtr& output, TExprContext& ctx)
-{
-    output = input;
-
-    auto result = ExecuteFuture.ExtractValue();
-    result.ReportIssues(ctx.IssueManager);
-    if (!result.Success()) {
-        TxState->Tx().Invalidate();
-        return TStatus::Error;
-    }
-
+        } 
+    } 
+ 
+    if (status == TStatus::Ok) { 
+        for (const auto& resultBinding : query.GetResultBindings()) { 
+            YQL_ENSURE(resultBinding.GetTypeCase() == NKqpProto::TKqpPhyResultBinding::kTxResultBinding); 
+            auto& txResultBinding = resultBinding.GetTxResultBinding(); 
+            auto txIndex = txResultBinding.GetTxIndex(); 
+            auto resultIndex = txResultBinding.GetResultIndex(); 
+ 
+ 
+            auto& txResults = TransformState->TxResults; 
+            YQL_ENSURE(txIndex < txResults.size()); 
+            YQL_ENSURE(resultIndex < txResults[txIndex].size()); 
+            TransformCtx->PhysicalQueryResults.emplace_back(std::move(txResults[txIndex][resultIndex])); 
+        } 
+ 
+        return status; 
+    } 
+ 
+    if (status == TStatus::Error) { 
+        return status; 
+    } 
+ 
+    YQL_ENSURE(status == TStatus::Async); 
+ 
+    Promise = NewPromise(); 
+    auto promise = Promise; 
+    ExecuteFuture.Apply([promise](const TFuture<IKqpGateway::TExecPhysicalResult> future) mutable { 
+        YQL_ENSURE(future.HasValue()); 
+        promise.SetValue(); 
+    }); 
+ 
+    return status; 
+} 
+ 
+TFuture<void> TKqpExecutePhysicalTransformerBase::DoGetAsyncFuture(const TExprNode& input) { 
+    Y_UNUSED(input); 
+    return Promise.GetFuture(); 
+} 
+ 
+IGraphTransformer::TStatus TKqpExecutePhysicalTransformerBase::DoApplyAsyncChanges(TExprNode::TPtr input, 
+    TExprNode::TPtr& output, TExprContext& ctx) 
+{ 
+    output = input; 
+ 
+    auto result = ExecuteFuture.ExtractValue(); 
+    result.ReportIssues(ctx.IssueManager); 
+    if (!result.Success()) { 
+        TxState->Tx().Invalidate(); 
+        return TStatus::Error; 
+    } 
+ 
     if (ExecuteFlags.HasFlags(TKqpExecuteFlag::Rollback)) {
         return TStatus::Repeat;
     }
 
-    auto& execResult = result.ExecuterResult;
-    if (ExecuteFlags.HasFlags(TKqpExecuteFlag::Results)) {
-        TVector<NKikimrMiniKQL::TResult> txResults;
-        txResults.resize(execResult.ResultsSize());
-        for (ui32 i = 0; i < execResult.ResultsSize(); ++i) {
-            txResults[i].Swap(execResult.MutableResults(i));
-        }
-
-        TransformState->TxResults.emplace_back(std::move(txResults));
-    }
-
-    if (!OnExecuterResult(std::move(execResult), ctx, ExecuteFlags.HasFlags(TKqpExecuteFlag::Commit))) {
-        return TStatus::Error;
-    }
-
-    ++CurrentTxIndex;
-    return TStatus::Repeat;
-}
-
-void TKqpExecutePhysicalTransformerBase::Rewind() {
-    ExecuteFlags = TKqpExecuteFlags();
-    CurrentTxIndex = 0;
-    TransformState->TxResults.clear();
-}
-
+    auto& execResult = result.ExecuterResult; 
+    if (ExecuteFlags.HasFlags(TKqpExecuteFlag::Results)) { 
+        TVector<NKikimrMiniKQL::TResult> txResults; 
+        txResults.resize(execResult.ResultsSize()); 
+        for (ui32 i = 0; i < execResult.ResultsSize(); ++i) { 
+            txResults[i].Swap(execResult.MutableResults(i)); 
+        } 
+ 
+        TransformState->TxResults.emplace_back(std::move(txResults)); 
+    } 
+ 
+    if (!OnExecuterResult(std::move(execResult), ctx, ExecuteFlags.HasFlags(TKqpExecuteFlag::Commit))) { 
+        return TStatus::Error; 
+    } 
+ 
+    ++CurrentTxIndex; 
+    return TStatus::Repeat; 
+} 
+ 
+void TKqpExecutePhysicalTransformerBase::Rewind() { 
+    ExecuteFlags = TKqpExecuteFlags(); 
+    CurrentTxIndex = 0; 
+    TransformState->TxResults.clear(); 
+} 
+ 
 IGraphTransformer::TStatus TKqpExecutePhysicalTransformerBase::Execute(const NKqpProto::TKqpPhyTx* tx, bool commit,
     NYql::TExprContext& ctx)
 {
-    ExecuteFlags = TKqpExecuteFlags();
-
-    if (tx) {
-        ExecuteFlags |= TKqpExecuteFlag::Results;
-    } else {
-        YQL_ENSURE(commit);
-    }
-
-    if (commit) {
-        ExecuteFlags |= TKqpExecuteFlag::Commit;
-    }
-
+    ExecuteFlags = TKqpExecuteFlags(); 
+ 
+    if (tx) { 
+        ExecuteFlags |= TKqpExecuteFlag::Results; 
+    } else { 
+        YQL_ENSURE(commit); 
+    } 
+ 
+    if (commit) { 
+        ExecuteFlags |= TKqpExecuteFlag::Commit; 
+    } 
+ 
     return DoExecute(tx, commit, ctx);
-}
-
+} 
+ 
 IGraphTransformer::TStatus TKqpExecutePhysicalTransformerBase::Rollback() {
     ExecuteFlags = TKqpExecuteFlags();
     ExecuteFlags |= TKqpExecuteFlag::Rollback;
@@ -174,29 +174,29 @@ IGraphTransformer::TStatus TKqpExecutePhysicalTransformerBase::Rollback() {
 bool TKqpExecutePhysicalTransformerBase::AddDeferredEffect(const NKqpProto::TKqpPhyTx& tx) {
     TParamValueMap params;
     PreserveParams(tx, params);
-
+ 
     return TxState->Tx().AddDeferredEffect(tx, std::move(params));
-}
-
-NDq::TMkqlValueRef TKqpExecutePhysicalTransformerBase::GetParamValue(
-    const NKqpProto::TKqpPhyParamBinding& paramBinding)
-{
-    switch (paramBinding.GetTypeCase()) {
-        case NKqpProto::TKqpPhyParamBinding::kExternalBinding: {
-            auto clientParam = TransformCtx->QueryCtx->Parameters.FindPtr(paramBinding.GetName());
-            YQL_ENSURE(clientParam, "Parameter not found: " << paramBinding.GetName());
-            return NDq::TMkqlValueRef(*clientParam);
-        }
-        case NKqpProto::TKqpPhyParamBinding::kTxResultBinding: {
-            auto& txResultBinding = paramBinding.GetTxResultBinding();
-            auto txIndex = txResultBinding.GetTxIndex();
-            auto resultIndex = txResultBinding.GetResultIndex();
-
-            auto& txResults = TransformState->TxResults;
-            YQL_ENSURE(txIndex < txResults.size());
-            YQL_ENSURE(resultIndex < txResults[txIndex].size());
-            return NDq::TMkqlValueRef(txResults[txIndex][resultIndex]);
-        }
+} 
+ 
+NDq::TMkqlValueRef TKqpExecutePhysicalTransformerBase::GetParamValue( 
+    const NKqpProto::TKqpPhyParamBinding& paramBinding) 
+{ 
+    switch (paramBinding.GetTypeCase()) { 
+        case NKqpProto::TKqpPhyParamBinding::kExternalBinding: { 
+            auto clientParam = TransformCtx->QueryCtx->Parameters.FindPtr(paramBinding.GetName()); 
+            YQL_ENSURE(clientParam, "Parameter not found: " << paramBinding.GetName()); 
+            return NDq::TMkqlValueRef(*clientParam); 
+        } 
+        case NKqpProto::TKqpPhyParamBinding::kTxResultBinding: { 
+            auto& txResultBinding = paramBinding.GetTxResultBinding(); 
+            auto txIndex = txResultBinding.GetTxIndex(); 
+            auto resultIndex = txResultBinding.GetResultIndex(); 
+ 
+            auto& txResults = TransformState->TxResults; 
+            YQL_ENSURE(txIndex < txResults.size()); 
+            YQL_ENSURE(resultIndex < txResults[txIndex].size()); 
+            return NDq::TMkqlValueRef(txResults[txIndex][resultIndex]); 
+        } 
         case NKqpProto::TKqpPhyParamBinding::kInternalBinding: {
             auto& internalBinding = paramBinding.GetInternalBinding();
             auto& param = TransformCtx->QueryCtx->Parameters[paramBinding.GetName()];
@@ -251,33 +251,33 @@ NDq::TMkqlValueRef TKqpExecutePhysicalTransformerBase::GetParamValue(
 
             return NDq::TMkqlValueRef(param);
         }
-        default:
-            YQL_ENSURE(false, "Unexpected parameter binding type: " << (ui32)paramBinding.GetTypeCase());
-    }
-}
-
-TKqpParamsMap TKqpExecutePhysicalTransformerBase::PrepareParameters(const NKqpProto::TKqpPhyTx& tx) {
-    TKqpParamsMap paramsMap(TransformState);
-    for (const auto& paramBinding : tx.GetParamBindings()) {
-        auto it = paramsMap.Values.emplace(paramBinding.GetName(), GetParamValue(paramBinding));
+        default: 
+            YQL_ENSURE(false, "Unexpected parameter binding type: " << (ui32)paramBinding.GetTypeCase()); 
+    } 
+} 
+ 
+TKqpParamsMap TKqpExecutePhysicalTransformerBase::PrepareParameters(const NKqpProto::TKqpPhyTx& tx) { 
+    TKqpParamsMap paramsMap(TransformState); 
+    for (const auto& paramBinding : tx.GetParamBindings()) { 
+        auto it = paramsMap.Values.emplace(paramBinding.GetName(), GetParamValue(paramBinding)); 
         YQL_ENSURE(it.second);
-    }
-
-    return paramsMap;
-}
-
-void TKqpExecutePhysicalTransformerBase::PreserveParams(const NKqpProto::TKqpPhyTx& tx, TParamValueMap& paramsMap) {
-    for (const auto& paramBinding : tx.GetParamBindings()) {
-        auto paramValueRef = GetParamValue(paramBinding);
-
-        NKikimrMiniKQL::TParams param;
-        param.MutableType()->CopyFrom(paramValueRef.GetType());
-        param.MutableValue()->CopyFrom(paramValueRef.GetValue());
-
+    } 
+ 
+    return paramsMap; 
+} 
+ 
+void TKqpExecutePhysicalTransformerBase::PreserveParams(const NKqpProto::TKqpPhyTx& tx, TParamValueMap& paramsMap) { 
+    for (const auto& paramBinding : tx.GetParamBindings()) { 
+        auto paramValueRef = GetParamValue(paramBinding); 
+ 
+        NKikimrMiniKQL::TParams param; 
+        param.MutableType()->CopyFrom(paramValueRef.GetType()); 
+        param.MutableValue()->CopyFrom(paramValueRef.GetValue()); 
+ 
         YQL_ENSURE(paramsMap.emplace(paramBinding.GetName(), std::move(param)).second);
-    }
-}
-
+    } 
+} 
+ 
 void TKqpExecutePhysicalTransformerBase::ClearTx() {
     TxState->Tx().ClearDeferredEffects();
     TxState->Tx().Locks.Clear();
@@ -285,4 +285,4 @@ void TKqpExecutePhysicalTransformerBase::ClearTx() {
 }
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/host/kqp_run_physical.h b/ydb/core/kqp/host/kqp_run_physical.h
index c55fcc59a0..dbc715831f 100644
--- a/ydb/core/kqp/host/kqp_run_physical.h
+++ b/ydb/core/kqp/host/kqp_run_physical.h
@@ -1,88 +1,88 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/common/kqp_gateway.h>
 #include <ydb/core/kqp/expr_nodes/kqp_expr_nodes.h>
 #include <ydb/core/kqp/prepare/kqp_prepare.h>
-
+ 
 #include <ydb/library/yql/core/yql_graph_transformer.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-enum class TKqpExecuteFlag : ui32 {
-    Results  = 1 << 0,
-    Commit   = 1 << 1,
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+enum class TKqpExecuteFlag : ui32 { 
+    Results  = 1 << 0, 
+    Commit   = 1 << 1, 
     Rollback = 1 << 2,
-};
-
-Y_DECLARE_FLAGS(TKqpExecuteFlags, TKqpExecuteFlag);
-Y_DECLARE_OPERATORS_FOR_FLAGS(TKqpExecuteFlags);
-
-class TKqpExecutePhysicalTransformerBase : public NYql::TGraphTransformerBase {
-public:
-    TKqpExecutePhysicalTransformerBase(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : Gateway(gateway)
-        , Cluster(cluster)
-        , TxState(txState)
-        , TransformCtx(transformCtx)
-        , CurrentTxIndex(0)
-        , TransformState(std::make_shared<TTransformState>(txState)) {}
-
-
-    TStatus DoTransform(NYql::TExprNode::TPtr input, NYql::TExprNode::TPtr& output, NYql::TExprContext& ctx) override;
-
-    NThreading::TFuture<void> DoGetAsyncFuture(const NYql::TExprNode& input) override;
-
-    TStatus DoApplyAsyncChanges(NYql::TExprNode::TPtr input, NYql::TExprNode::TPtr& output,
-        NYql::TExprContext& ctx) override;
-
-    void Rewind() override;
-
-protected:
+}; 
+ 
+Y_DECLARE_FLAGS(TKqpExecuteFlags, TKqpExecuteFlag); 
+Y_DECLARE_OPERATORS_FOR_FLAGS(TKqpExecuteFlags); 
+ 
+class TKqpExecutePhysicalTransformerBase : public NYql::TGraphTransformerBase { 
+public: 
+    TKqpExecutePhysicalTransformerBase(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : Gateway(gateway) 
+        , Cluster(cluster) 
+        , TxState(txState) 
+        , TransformCtx(transformCtx) 
+        , CurrentTxIndex(0) 
+        , TransformState(std::make_shared<TTransformState>(txState)) {} 
+ 
+ 
+    TStatus DoTransform(NYql::TExprNode::TPtr input, NYql::TExprNode::TPtr& output, NYql::TExprContext& ctx) override; 
+ 
+    NThreading::TFuture<void> DoGetAsyncFuture(const NYql::TExprNode& input) override; 
+ 
+    TStatus DoApplyAsyncChanges(NYql::TExprNode::TPtr input, NYql::TExprNode::TPtr& output, 
+        NYql::TExprContext& ctx) override; 
+ 
+    void Rewind() override; 
+ 
+protected: 
     virtual TStatus DoExecute(const NKqpProto::TKqpPhyTx* tx, bool commit, NYql::TExprContext& ctx) = 0;
     virtual TStatus DoRollback() = 0;
-
+ 
     virtual bool OnExecuterResult(NKikimrKqp::TExecuterTxResult&& execResult, NYql::TExprContext& ctx, bool commit) = 0;
-
-protected:
-    NYql::NDq::TMkqlValueRef GetParamValue(const NKqpProto::TKqpPhyParamBinding& paramBinding);
-
-    TKqpParamsMap PrepareParameters(const NKqpProto::TKqpPhyTx& tx);
-
+ 
+protected: 
+    NYql::NDq::TMkqlValueRef GetParamValue(const NKqpProto::TKqpPhyParamBinding& paramBinding); 
+ 
+    TKqpParamsMap PrepareParameters(const NKqpProto::TKqpPhyTx& tx); 
+ 
     void ClearTx();
 
-private:
+private: 
     TStatus Execute(const NKqpProto::TKqpPhyTx* tx, bool commit, NYql::TExprContext& ctx);
     TStatus Rollback();
-
+ 
     bool AddDeferredEffect(const NKqpProto::TKqpPhyTx& tx);
-
-    void PreserveParams(const NKqpProto::TKqpPhyTx& tx, TParamValueMap& paramsMap);
-
-protected:
-    struct TTransformState {
-        TTransformState(TIntrusivePtr<TKqpTransactionState> txState)
-            : TxState(txState) {}
-
-        TIntrusivePtr<TKqpTransactionState> TxState;
-        TVector<TVector<NKikimrMiniKQL::TResult>> TxResults;
-    };
-
-protected:
-    TIntrusivePtr<IKqpGateway> Gateway;
-    TString Cluster;
-
-    TIntrusivePtr<TKqpTransactionState> TxState;
-    TIntrusivePtr<TKqlTransformContext> TransformCtx;
-
-    ui32 CurrentTxIndex;
-    TKqpExecuteFlags ExecuteFlags;
-    NThreading::TFuture<IKqpGateway::TExecPhysicalResult> ExecuteFuture;
-    NThreading::TPromise<void> Promise;
-
-    std::shared_ptr<TTransformState> TransformState;
-};
-
+ 
+    void PreserveParams(const NKqpProto::TKqpPhyTx& tx, TParamValueMap& paramsMap); 
+ 
+protected: 
+    struct TTransformState { 
+        TTransformState(TIntrusivePtr<TKqpTransactionState> txState) 
+            : TxState(txState) {} 
+ 
+        TIntrusivePtr<TKqpTransactionState> TxState; 
+        TVector<TVector<NKikimrMiniKQL::TResult>> TxResults; 
+    }; 
+ 
+protected: 
+    TIntrusivePtr<IKqpGateway> Gateway; 
+    TString Cluster; 
+ 
+    TIntrusivePtr<TKqpTransactionState> TxState; 
+    TIntrusivePtr<TKqlTransformContext> TransformCtx; 
+ 
+    ui32 CurrentTxIndex; 
+    TKqpExecuteFlags ExecuteFlags; 
+    NThreading::TFuture<IKqpGateway::TExecPhysicalResult> ExecuteFuture; 
+    NThreading::TPromise<void> Promise; 
+ 
+    std::shared_ptr<TTransformState> TransformState; 
+}; 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/host/kqp_run_prepared.cpp b/ydb/core/kqp/host/kqp_run_prepared.cpp
index e71a3bacee..0a53c766b3 100644
--- a/ydb/core/kqp/host/kqp_run_prepared.cpp
+++ b/ydb/core/kqp/host/kqp_run_prepared.cpp
@@ -1,97 +1,97 @@
-#include "kqp_host_impl.h"
-
+#include "kqp_host_impl.h" 
+ 
 #include <ydb/library/yql/utils/log/log.h>
-
+ 
 #include <google/protobuf/text_format.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-using namespace NThreading;
-
-namespace {
-
-class TKqpExecutePreparedTransformer : public TGraphTransformerBase {
-public:
-    TKqpExecutePreparedTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : Gateway(gateway)
-        , Cluster(cluster)
-        , TxState(txState)
-        , TransformCtx(transformCtx)
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+using namespace NThreading; 
+ 
+namespace { 
+ 
+class TKqpExecutePreparedTransformer : public TGraphTransformerBase { 
+public: 
+    TKqpExecutePreparedTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : Gateway(gateway) 
+        , Cluster(cluster) 
+        , TxState(txState) 
+        , TransformCtx(transformCtx) 
         , CurrentMkqlIndex(0)
     {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        output = input;
-
-        const auto& kql = TransformCtx->GetPreparedKql();
-
-        if (CurrentMkqlIndex >= kql.MkqlsSize()) {
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        output = input; 
+ 
+        const auto& kql = TransformCtx->GetPreparedKql(); 
+ 
+        if (CurrentMkqlIndex >= kql.MkqlsSize()) { 
             return Finish(ctx);
-        }
-
-        const auto& mkql = kql.GetMkqls(CurrentMkqlIndex);
-
+        } 
+ 
+        const auto& mkql = kql.GetMkqls(CurrentMkqlIndex); 
+ 
         AcquireLocks = ShouldAcquireLocks(kql);
-
-        Promise = NewPromise();
-
+ 
+        Promise = NewPromise(); 
+ 
         if (!Execute(mkql, MkqlExecuteResult.Future)) {
-            return TStatus::Error;
-        }
-
-        auto promise = Promise;
-        MkqlExecuteResult.Future.Apply([promise](const TFuture<IKqpGateway::TMkqlResult> future) mutable {
-            YQL_ENSURE(future.HasValue());
-            promise.SetValue();
-        });
-
-        return TStatus::Async;
-    }
-
-    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
-        Y_UNUSED(input);
-        return Promise.GetFuture();
-    }
-
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        output = input;
-
-        NKikimr::NKqp::IKqpGateway::TMkqlResult result(MkqlExecuteResult.Future.ExtractValue());
-        result.ReportIssues(ctx.IssueManager);
-        if (!result.Success()) {
-            return TStatus::Error;
-        }
-
-        const auto& mkql = TransformCtx->GetPreparedKql().GetMkqls(CurrentMkqlIndex);
-        if (mkql.GetIsPure()) {
-            Y_VERIFY_DEBUG(result.TxStats.TableAccessStatsSize() == 0);
-        }
-
-        auto mkqlResult = MakeSimpleShared<NKikimrMiniKQL::TResult>();
-        mkqlResult->Swap(&result.Result);
-
-        if (AcquireLocks) {
+            return TStatus::Error; 
+        } 
+ 
+        auto promise = Promise; 
+        MkqlExecuteResult.Future.Apply([promise](const TFuture<IKqpGateway::TMkqlResult> future) mutable { 
+            YQL_ENSURE(future.HasValue()); 
+            promise.SetValue(); 
+        }); 
+ 
+        return TStatus::Async; 
+    } 
+ 
+    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
+        Y_UNUSED(input); 
+        return Promise.GetFuture(); 
+    } 
+ 
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        output = input; 
+ 
+        NKikimr::NKqp::IKqpGateway::TMkqlResult result(MkqlExecuteResult.Future.ExtractValue()); 
+        result.ReportIssues(ctx.IssueManager); 
+        if (!result.Success()) { 
+            return TStatus::Error; 
+        } 
+ 
+        const auto& mkql = TransformCtx->GetPreparedKql().GetMkqls(CurrentMkqlIndex); 
+        if (mkql.GetIsPure()) { 
+            Y_VERIFY_DEBUG(result.TxStats.TableAccessStatsSize() == 0); 
+        } 
+ 
+        auto mkqlResult = MakeSimpleShared<NKikimrMiniKQL::TResult>(); 
+        mkqlResult->Swap(&result.Result); 
+ 
+        if (AcquireLocks) { 
             if (!UnpackMergeLocks(*mkqlResult, TxState->Tx(), ctx)) {
                 return TStatus::Error;
-            }
-        }
-
-        TransformCtx->MkqlResults.push_back(mkqlResult);
-        TransformCtx->AddMkqlStats(MkqlExecuteResult.Program, std::move(result.TxStats));
-
-        ++CurrentMkqlIndex;
-        return TStatus::Repeat;
-    }
-
-    void Rewind() override {
-        CurrentMkqlIndex = 0;
-    }
-
-private:
+            } 
+        } 
+ 
+        TransformCtx->MkqlResults.push_back(mkqlResult); 
+        TransformCtx->AddMkqlStats(MkqlExecuteResult.Program, std::move(result.TxStats)); 
+ 
+        ++CurrentMkqlIndex; 
+        return TStatus::Repeat; 
+    } 
+ 
+    void Rewind() override { 
+        CurrentMkqlIndex = 0; 
+    } 
+ 
+private: 
     TStatus Finish(TExprContext& ctx) {
         const auto& kql = TransformCtx->GetPreparedKql();
         if (!kql.GetEffects().empty()) {
@@ -115,47 +115,47 @@ private:
         return TStatus::Ok;
     }
 
-    bool Execute(const NKikimrKqp::TPreparedMkql& mkql, TFuture<IKqpGateway::TMkqlResult>& future) {
-        if (YQL_CLOG_ACTIVE(DEBUG, ProviderKqp)) {
-            TString mkqlText;
-            NProtoBuf::TextFormat::PrintToString(mkql, &mkqlText);
-            YQL_CLOG(DEBUG, ProviderKqp) << "Mkql:" << Endl << mkqlText;
-        }
-
+    bool Execute(const NKikimrKqp::TPreparedMkql& mkql, TFuture<IKqpGateway::TMkqlResult>& future) { 
+        if (YQL_CLOG_ACTIVE(DEBUG, ProviderKqp)) { 
+            TString mkqlText; 
+            NProtoBuf::TextFormat::PrintToString(mkql, &mkqlText); 
+            YQL_CLOG(DEBUG, ProviderKqp) << "Mkql:" << Endl << mkqlText; 
+        } 
+ 
         TVector<NKikimrKqp::TParameterBinding> bindings(mkql.GetBindings().begin(), mkql.GetBindings().end());
-        auto execParams = BuildParamsMap(bindings, TxState, TransformCtx, AcquireLocks);
-
-        if (YQL_CLOG_ACTIVE(TRACE, ProviderKqp)) {
-            TStringBuilder paramsTextBuilder;
-            for (auto& pair : execParams.Values) {
-                TString paramText;
-                NProtoBuf::TextFormat::PrintToString(pair.second.GetValue(), &paramText);
-                paramsTextBuilder << pair.first << ": " << paramText << Endl;
-            }
-
-            YQL_CLOG(TRACE, ProviderKqp) << "MiniKQL parameters:" << Endl << paramsTextBuilder;
-        }
-
-        if (TransformCtx->QueryCtx->StatsMode == EKikimrStatsMode::Profile) {
+        auto execParams = BuildParamsMap(bindings, TxState, TransformCtx, AcquireLocks); 
+ 
+        if (YQL_CLOG_ACTIVE(TRACE, ProviderKqp)) { 
+            TStringBuilder paramsTextBuilder; 
+            for (auto& pair : execParams.Values) { 
+                TString paramText; 
+                NProtoBuf::TextFormat::PrintToString(pair.second.GetValue(), &paramText); 
+                paramsTextBuilder << pair.first << ": " << paramText << Endl; 
+            } 
+ 
+            YQL_CLOG(TRACE, ProviderKqp) << "MiniKQL parameters:" << Endl << paramsTextBuilder; 
+        } 
+ 
+        if (TransformCtx->QueryCtx->StatsMode == EKikimrStatsMode::Profile) { 
             MkqlExecuteResult.Program = mkql.GetProgramText();
-        }
-
-        future = Gateway->ExecuteMkqlPrepared(Cluster, mkql.GetProgram(), std::move(execParams),
+        } 
+ 
+        future = Gateway->ExecuteMkqlPrepared(Cluster, mkql.GetProgram(), std::move(execParams), 
             TransformCtx->GetMkqlSettings(false, Gateway->GetCurrentTime()),
             TxState->Tx().GetSnapshot());
-        return true;
-    }
-
-    bool GetExpr(const TString& astStr, TExprNode::TPtr& expr, TExprContext& ctx) {
-        auto astRes = ParseAst(astStr);
+        return true; 
+    } 
+ 
+    bool GetExpr(const TString& astStr, TExprNode::TPtr& expr, TExprContext& ctx) { 
+        auto astRes = ParseAst(astStr); 
         ctx.IssueManager.AddIssues(astRes.Issues);
-        if (!astRes.IsOk()) {
-            return false;
-        }
-
+        if (!astRes.IsOk()) { 
+            return false; 
+        } 
+ 
         return CompileExpr(*astRes.Root, expr, ctx, nullptr);
-    }
-
+    } 
+ 
     bool ShouldAcquireLocks(const NKikimrKqp::TPreparedKql& kql) {
         if (*TxState->Tx().EffectiveIsolationLevel != NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE) {
             return false;
@@ -184,27 +184,27 @@ private:
         return true;
     }
 
-private:
-    TIntrusivePtr<IKqpGateway> Gateway;
-    TString Cluster;
-
-    TIntrusivePtr<TKqpTransactionState> TxState;
-    TIntrusivePtr<TKqlTransformContext> TransformCtx;
-
-    ui32 CurrentMkqlIndex;
-    bool AcquireLocks;
+private: 
+    TIntrusivePtr<IKqpGateway> Gateway; 
+    TString Cluster; 
+ 
+    TIntrusivePtr<TKqpTransactionState> TxState; 
+    TIntrusivePtr<TKqlTransformContext> TransformCtx; 
+ 
+    ui32 CurrentMkqlIndex; 
+    bool AcquireLocks; 
     TMkqlExecuteResult MkqlExecuteResult;
-    TPromise<void> Promise;
-};
-
-} // namespace
-
-TAutoPtr<IGraphTransformer> CreateKqpExecutePreparedTransformer(TIntrusivePtr<IKqpGateway> gateway,
-    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx)
-{
-    return new TKqpExecutePreparedTransformer(gateway, cluster, txState, transformCtx);
-}
-
+    TPromise<void> Promise; 
+}; 
+ 
+} // namespace 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpExecutePreparedTransformer(TIntrusivePtr<IKqpGateway> gateway, 
+    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx) 
+{ 
+    return new TKqpExecutePreparedTransformer(gateway, cluster, txState, transformCtx); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/host/kqp_run_scan.cpp b/ydb/core/kqp/host/kqp_run_scan.cpp
index 7c91ae8200..dd5723e559 100644
--- a/ydb/core/kqp/host/kqp_run_scan.cpp
+++ b/ydb/core/kqp/host/kqp_run_scan.cpp
@@ -1,70 +1,70 @@
-#include "kqp_host_impl.h"
-#include "kqp_run_physical.h"
-
+#include "kqp_host_impl.h" 
+#include "kqp_run_physical.h" 
+ 
 #include <ydb/core/base/kikimr_issue.h>
 #include <ydb/core/kqp/common/kqp_yql.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-using namespace NThreading;
-
-class TKqpExecuteScanTransformer : public TKqpExecutePhysicalTransformerBase {
-public:
-    TKqpExecuteScanTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : TKqpExecutePhysicalTransformerBase(gateway, cluster, txState, transformCtx) {}
-
-protected:
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+using namespace NThreading; 
+ 
+class TKqpExecuteScanTransformer : public TKqpExecutePhysicalTransformerBase { 
+public: 
+    TKqpExecuteScanTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : TKqpExecutePhysicalTransformerBase(gateway, cluster, txState, transformCtx) {} 
+ 
+protected: 
     TStatus DoExecute(const NKqpProto::TKqpPhyTx* tx, bool commit, NYql::TExprContext&) final {
-        YQL_ENSURE(tx);
-        YQL_ENSURE(!commit);
-
-        IKqpGateway::TExecPhysicalRequest request;
-        request.Transactions.emplace_back(*tx, PrepareParameters(*tx));
+        YQL_ENSURE(tx); 
+        YQL_ENSURE(!commit); 
+ 
+        IKqpGateway::TExecPhysicalRequest request; 
+        request.Transactions.emplace_back(*tx, PrepareParameters(*tx)); 
 
         request.RlPath = TransformCtx->QueryCtx->RlPath;
         request.Timeout = TransformCtx->QueryCtx->Deadlines.TimeoutAt - Gateway->GetCurrentTime();
         if (!request.Timeout) {
-            // TODO: Just cancel request.
+            // TODO: Just cancel request. 
             request.Timeout = TDuration::MilliSeconds(1);
         }
         request.MaxComputeActors = TransformCtx->Config->_KqpMaxComputeActors.Get().GetRef();
-        request.StatsMode = GetStatsMode(TransformCtx->QueryCtx->StatsMode);
+        request.StatsMode = GetStatsMode(TransformCtx->QueryCtx->StatsMode); 
         request.DisableLlvmForUdfStages = TransformCtx->Config->DisableLlvmForUdfStages();
         request.LlvmEnabled = TransformCtx->Config->GetEnableLlvm() != EOptionalFlag::Disabled;
         request.Snapshot = TxState->Tx().GetSnapshot();
-
-        switch (tx->GetType()) {
-            case NKqpProto::TKqpPhyTx::TYPE_COMPUTE:
+ 
+        switch (tx->GetType()) { 
+            case NKqpProto::TKqpPhyTx::TYPE_COMPUTE: 
                 ExecuteFuture = Gateway->ExecutePhysical(std::move(request), TransformCtx->ReplyTarget);
-                break;
-            case NKqpProto::TKqpPhyTx::TYPE_SCAN:
-                ExecuteFuture = Gateway->ExecuteScanQuery(std::move(request), TransformCtx->ReplyTarget);
-                break;
-            default:
+                break; 
+            case NKqpProto::TKqpPhyTx::TYPE_SCAN: 
+                ExecuteFuture = Gateway->ExecuteScanQuery(std::move(request), TransformCtx->ReplyTarget); 
+                break; 
+            default: 
                 YQL_ENSURE(false, "Unexpected physical tx type in scan query: "
                     << NKqpProto::TKqpPhyTx_EType_Name(tx->GetType()));
-        }
-
-        return TStatus::Async;
-    }
-
+        } 
+ 
+        return TStatus::Async; 
+    } 
+ 
     TStatus DoRollback() final {
         YQL_ENSURE(false, "Rollback in ScanQuery tx");
     }
 
-    bool OnExecuterResult(NKikimrKqp::TExecuterTxResult&& execResult, TExprContext& ctx, bool commit) override {
-        Y_UNUSED(execResult);
-        Y_UNUSED(ctx);
-        Y_UNUSED(commit);
-
-        return true;
-    }
-};
-
+    bool OnExecuterResult(NKikimrKqp::TExecuterTxResult&& execResult, TExprContext& ctx, bool commit) override { 
+        Y_UNUSED(execResult); 
+        Y_UNUSED(ctx); 
+        Y_UNUSED(commit); 
+ 
+        return true; 
+    } 
+}; 
+ 
 class TKqpCreateSnapshotTransformer : public TGraphTransformerBase {
 public:
     TKqpCreateSnapshotTransformer(TIntrusivePtr<IKqpGateway> gateway, TIntrusivePtr<TKqlTransformContext> transformCtx,
@@ -178,13 +178,13 @@ private:
 };
 
 
-TAutoPtr<IGraphTransformer> CreateKqpExecuteScanTransformer(TIntrusivePtr<IKqpGateway> gateway,
-    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx)
-{
-    return new TKqpExecuteScanTransformer(gateway, cluster, txState, transformCtx);
-}
-
+TAutoPtr<IGraphTransformer> CreateKqpExecuteScanTransformer(TIntrusivePtr<IKqpGateway> gateway, 
+    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx) 
+{ 
+    return new TKqpExecuteScanTransformer(gateway, cluster, txState, transformCtx); 
+} 
+ 
 TAutoPtr<IGraphTransformer> CreateKqpCreateSnapshotTransformer(TIntrusivePtr<IKqpGateway> gateway,
     TIntrusivePtr<TKqlTransformContext> transformCtx, TIntrusivePtr<TKqpTransactionState> txState)
 {
@@ -198,4 +198,4 @@ TAutoPtr<IGraphTransformer> CreateKqpReleaseSnapshotTransformer(TIntrusivePtr<IK
 }
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/host/kqp_runner.cpp b/ydb/core/kqp/host/kqp_runner.cpp
index 42b4eca7c6..84c2474190 100644
--- a/ydb/core/kqp/host/kqp_runner.cpp
+++ b/ydb/core/kqp/host/kqp_runner.cpp
@@ -1,215 +1,215 @@
-#include "kqp_host_impl.h"
+#include "kqp_host_impl.h" 
 #include "kqp_ne_helper.h"
-
+ 
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/compile/kqp_compile.h>
 #include <ydb/core/kqp/opt/kqp_opt.h>
 #include <ydb/core/kqp/prepare/kqp_query_plan.h>
 #include <ydb/core/kqp/prepare/kqp_prepare.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
-
+ 
 #include <ydb/library/yql/core/yql_graph_transformer.h>
 #include <ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.h>
 #include <ydb/library/yql/core/type_ann/type_ann_expr.h>
 #include <ydb/library/yql/utils/log/log.h>
 #include <ydb/library/yql/core/services/yql_transform_pipeline.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NOpt;
-using namespace NYql;
-using namespace NYql::NCommon;
-using namespace NYql::NNodes;
-using namespace NThreading;
-
-namespace {
-
-void FillAstAndPlan(NKikimrKqp::TPreparedKql& kql, const TExprNode::TPtr& queryExpr, TExprContext& ctx) {
-    TStringStream astStream;
-    auto ast = ConvertToAst(*queryExpr, ctx, TExprAnnotationFlags::None, true);
-    ast.Root->PrettyPrintTo(astStream, TAstPrintFlags::ShortQuote | TAstPrintFlags::PerLine);
-    kql.SetAst(astStream.Str());
-
-    NJsonWriter::TBuf writer;
-    writer.SetIndentSpaces(2);
-
-    WriteKqlPlan(writer, queryExpr);
-    kql.SetPlan(writer.Str());
-}
-
-class TAsyncRunResult : public TKqpAsyncResultBase<IKikimrQueryExecutor::TQueryResult, false> {
-public:
-    using TResult = IKikimrQueryExecutor::TQueryResult;
-
-    TAsyncRunResult(const TExprNode::TPtr& queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer,
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NOpt; 
+using namespace NYql; 
+using namespace NYql::NCommon; 
+using namespace NYql::NNodes; 
+using namespace NThreading; 
+ 
+namespace { 
+ 
+void FillAstAndPlan(NKikimrKqp::TPreparedKql& kql, const TExprNode::TPtr& queryExpr, TExprContext& ctx) { 
+    TStringStream astStream; 
+    auto ast = ConvertToAst(*queryExpr, ctx, TExprAnnotationFlags::None, true); 
+    ast.Root->PrettyPrintTo(astStream, TAstPrintFlags::ShortQuote | TAstPrintFlags::PerLine); 
+    kql.SetAst(astStream.Str()); 
+ 
+    NJsonWriter::TBuf writer; 
+    writer.SetIndentSpaces(2); 
+ 
+    WriteKqlPlan(writer, queryExpr); 
+    kql.SetPlan(writer.Str()); 
+} 
+ 
+class TAsyncRunResult : public TKqpAsyncResultBase<IKikimrQueryExecutor::TQueryResult, false> { 
+public: 
+    using TResult = IKikimrQueryExecutor::TQueryResult; 
+ 
+    TAsyncRunResult(const TExprNode::TPtr& queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer, 
         const TKqlTransformContext& transformCtx)
-        : TKqpAsyncResultBase(queryRoot, exprCtx, transformer)
+        : TKqpAsyncResultBase(queryRoot, exprCtx, transformer) 
         , TransformCtx(transformCtx) {}
-
-    void FillResult(TResult& queryResult) const override {
-        if (TransformCtx.QueryCtx->PrepareOnly) {
-            return;
-        }
-
-        if (!TransformCtx.MkqlResults.empty() && TransformCtx.MkqlResults.back()) {
-            queryResult.Results = UnpackKikimrRunResult(*TransformCtx.MkqlResults.back(),
-                queryResult.ProtobufArenaPtr.get());
-        }
-
+ 
+    void FillResult(TResult& queryResult) const override { 
+        if (TransformCtx.QueryCtx->PrepareOnly) { 
+            return; 
+        } 
+ 
+        if (!TransformCtx.MkqlResults.empty() && TransformCtx.MkqlResults.back()) { 
+            queryResult.Results = UnpackKikimrRunResult(*TransformCtx.MkqlResults.back(), 
+                queryResult.ProtobufArenaPtr.get()); 
+        } 
+ 
         queryResult.QueryTraits = TransformCtx.QueryCtx->QueryTraits;
-        queryResult.QueryStats.CopyFrom(TransformCtx.QueryStats);
-    }
-
-private:
-    const TKqlTransformContext& TransformCtx;
-};
-
-class TPhysicalAsyncRunResult : public TKqpAsyncResultBase<IKikimrQueryExecutor::TQueryResult, false> {
-public:
-    using TResult = IKikimrQueryExecutor::TQueryResult;
-
-    TPhysicalAsyncRunResult(const TExprNode::TPtr& queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer,
-        const TKqlTransformContext& transformCtx)
-        : TKqpAsyncResultBase(queryRoot, exprCtx, transformer)
-        , TransformCtx(transformCtx) {}
-
-    void FillResult(TResult& queryResult) const override {
-        TVector<NKikimrMiniKQL::TResult*> results;
-        for (auto& phyResult : TransformCtx.PhysicalQueryResults) {
-            auto result = google::protobuf::Arena::CreateMessage<NKikimrMiniKQL::TResult>(
-                queryResult.ProtobufArenaPtr.get());
-
-            result->CopyFrom(phyResult);
-            results.push_back(result);
-        }
-
+        queryResult.QueryStats.CopyFrom(TransformCtx.QueryStats); 
+    } 
+ 
+private: 
+    const TKqlTransformContext& TransformCtx; 
+}; 
+ 
+class TPhysicalAsyncRunResult : public TKqpAsyncResultBase<IKikimrQueryExecutor::TQueryResult, false> { 
+public: 
+    using TResult = IKikimrQueryExecutor::TQueryResult; 
+ 
+    TPhysicalAsyncRunResult(const TExprNode::TPtr& queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer, 
+        const TKqlTransformContext& transformCtx) 
+        : TKqpAsyncResultBase(queryRoot, exprCtx, transformer) 
+        , TransformCtx(transformCtx) {} 
+ 
+    void FillResult(TResult& queryResult) const override { 
+        TVector<NKikimrMiniKQL::TResult*> results; 
+        for (auto& phyResult : TransformCtx.PhysicalQueryResults) { 
+            auto result = google::protobuf::Arena::CreateMessage<NKikimrMiniKQL::TResult>( 
+                queryResult.ProtobufArenaPtr.get()); 
+ 
+            result->CopyFrom(phyResult); 
+            results.push_back(result); 
+        } 
+ 
         queryResult.QueryTraits = TransformCtx.QueryCtx->QueryTraits;
-        queryResult.QueryStats.CopyFrom(TransformCtx.QueryStats);
-        queryResult.Results = std::move(results);
-    }
-
-private:
-    const TKqlTransformContext& TransformCtx;
-};
-
-class TScanAsyncRunResult : public TKqpAsyncResultBase<IKikimrQueryExecutor::TQueryResult, false> {
-public:
-    using TResult = IKikimrQueryExecutor::TQueryResult;
-
-    TScanAsyncRunResult(const TExprNode::TPtr& queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer)
-        : TKqpAsyncResultBase(queryRoot, exprCtx, transformer) {}
-
-    void FillResult(TResult& queryResult) const override {
-        Y_UNUSED(queryResult);
-    }
-};
-
-class TKqpIterationGuardTransformer : public TSyncTransformerBase {
-public:
-    const ui32 MaxTransformIterations = 100;
-
-public:
-    TKqpIterationGuardTransformer()
-        : Iterations(0) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+        queryResult.QueryStats.CopyFrom(TransformCtx.QueryStats); 
+        queryResult.Results = std::move(results); 
+    } 
+ 
+private: 
+    const TKqlTransformContext& TransformCtx; 
+}; 
+ 
+class TScanAsyncRunResult : public TKqpAsyncResultBase<IKikimrQueryExecutor::TQueryResult, false> { 
+public: 
+    using TResult = IKikimrQueryExecutor::TQueryResult; 
+ 
+    TScanAsyncRunResult(const TExprNode::TPtr& queryRoot, TExprContext& exprCtx, IGraphTransformer& transformer) 
+        : TKqpAsyncResultBase(queryRoot, exprCtx, transformer) {} 
+ 
+    void FillResult(TResult& queryResult) const override { 
+        Y_UNUSED(queryResult); 
+    } 
+}; 
+ 
+class TKqpIterationGuardTransformer : public TSyncTransformerBase { 
+public: 
+    const ui32 MaxTransformIterations = 100; 
+ 
+public: 
+    TKqpIterationGuardTransformer() 
+        : Iterations(0) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         output = input;
-
-        if (Iterations > MaxTransformIterations) {
+ 
+        if (Iterations > MaxTransformIterations) { 
             ctx.AddError(TIssue(ctx.GetPosition(input->Pos()), TStringBuilder()
                 << "Exceeded maximum allowed KQP iterations: " << MaxTransformIterations));
-            return TStatus::Error;
-        }
-
-        ++Iterations;
-        YQL_CLOG(DEBUG, ProviderKqp) << "Iteration #" << Iterations << ":" << Endl
-            << KqpExprToPrettyString(*input, ctx);
-
-        return TStatus::Ok;
-    }
-
-    void Rewind() override {
-        Iterations = 0;
-    }
-
-private:
-    ui32 Iterations;
-};
-
-class TKqpRunner : public IKqpRunner {
-public:
-    TKqpRunner(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-        TIntrusivePtr<TTypeAnnotationContext> typesCtx, TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-        const NMiniKQL::IFunctionRegistry& funcRegistry)
-        : Gateway(gateway)
-        , Cluster(cluster)
-        , TypesCtx(*typesCtx)
-        , FuncRegistry(funcRegistry)
-        , Config(sessionCtx->ConfigPtr())
-        , TxState(MakeIntrusive<TKqpTransactionState>(sessionCtx))
-        , TransformCtx(MakeIntrusive<TKqlTransformContext>(Config, sessionCtx->QueryPtr(), sessionCtx->TablesPtr()))
-        , OptimizeCtx(MakeIntrusive<TKqpOptimizeContext>(cluster, Config, sessionCtx->QueryPtr(),
-            sessionCtx->TablesPtr()))
-        , BuildQueryCtx(MakeIntrusive<TKqpBuildQueryContext>())
-    {
-        KqlTypeAnnTransformer = CreateTypeAnnotationTransformer(CreateExtCallableTypeAnnotationTransformer(*typesCtx),
-            *typesCtx);
-
+            return TStatus::Error; 
+        } 
+ 
+        ++Iterations; 
+        YQL_CLOG(DEBUG, ProviderKqp) << "Iteration #" << Iterations << ":" << Endl 
+            << KqpExprToPrettyString(*input, ctx); 
+ 
+        return TStatus::Ok; 
+    } 
+ 
+    void Rewind() override { 
+        Iterations = 0; 
+    } 
+ 
+private: 
+    ui32 Iterations; 
+}; 
+ 
+class TKqpRunner : public IKqpRunner { 
+public: 
+    TKqpRunner(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+        TIntrusivePtr<TTypeAnnotationContext> typesCtx, TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+        const NMiniKQL::IFunctionRegistry& funcRegistry) 
+        : Gateway(gateway) 
+        , Cluster(cluster) 
+        , TypesCtx(*typesCtx) 
+        , FuncRegistry(funcRegistry) 
+        , Config(sessionCtx->ConfigPtr()) 
+        , TxState(MakeIntrusive<TKqpTransactionState>(sessionCtx)) 
+        , TransformCtx(MakeIntrusive<TKqlTransformContext>(Config, sessionCtx->QueryPtr(), sessionCtx->TablesPtr())) 
+        , OptimizeCtx(MakeIntrusive<TKqpOptimizeContext>(cluster, Config, sessionCtx->QueryPtr(), 
+            sessionCtx->TablesPtr())) 
+        , BuildQueryCtx(MakeIntrusive<TKqpBuildQueryContext>()) 
+    { 
+        KqlTypeAnnTransformer = CreateTypeAnnotationTransformer(CreateExtCallableTypeAnnotationTransformer(*typesCtx), 
+            *typesCtx); 
+ 
         auto logLevel = NLog::ELevel::TRACE;
         auto logComp = NLog::EComponent::ProviderKqp;
 
-        KqlOptimizeTransformer = TTransformationPipeline(typesCtx)
-            .AddServiceTransformers()
+        KqlOptimizeTransformer = TTransformationPipeline(typesCtx) 
+            .AddServiceTransformers() 
             .Add(TLogExprTransformer::Sync("KqlOptimizeTransformer", logComp, logLevel), "LogKqlOptimize")
-            .AddTypeAnnotationTransformer()
+            .AddTypeAnnotationTransformer() 
             .AddPostTypeAnnotation()
-            .AddOptimization(false)
-            .Build(false);
-
+            .AddOptimization(false) 
+            .Build(false); 
+ 
         KqlPrepareTransformer = TTransformationPipeline(typesCtx)
-            .AddServiceTransformers()
+            .AddServiceTransformers() 
             .Add(TLogExprTransformer::Sync("KqlPrepareTransformer", logComp, logLevel), "LogKqlRun")
-            .Add(new TKqpIterationGuardTransformer(), "IterationGuard")
-            .AddTypeAnnotationTransformer()
-            .Add(CreateKqpCheckKiProgramTransformer(), "CheckQuery")
-            .Add(CreateKqpSimplifyTransformer(), "Simplify")
-            .Add(CreateKqpAnalyzeTransformer(TransformCtx), "Analyze")
-            .Add(CreateKqpRewriteTransformer(TransformCtx), "Rewrite")
+            .Add(new TKqpIterationGuardTransformer(), "IterationGuard") 
+            .AddTypeAnnotationTransformer() 
+            .Add(CreateKqpCheckKiProgramTransformer(), "CheckQuery") 
+            .Add(CreateKqpSimplifyTransformer(), "Simplify") 
+            .Add(CreateKqpAnalyzeTransformer(TransformCtx), "Analyze") 
+            .Add(CreateKqpRewriteTransformer(TransformCtx), "Rewrite") 
             .Add(CreateKqpExecTransformer(Gateway, Cluster, TxState, TransformCtx), "Prepare")
-            .Add(CreateKqpSubstituteTransformer(TxState, TransformCtx), "Substitute")
-            .Add(CreateKqpFinalizeTransformer(Gateway, Cluster, TxState, TransformCtx), "Finalize")
+            .Add(CreateKqpSubstituteTransformer(TxState, TransformCtx), "Substitute") 
+            .Add(CreateKqpFinalizeTransformer(Gateway, Cluster, TxState, TransformCtx), "Finalize") 
             .Build(false);
-
-        PreparedRunTransformer = TTransformationPipeline(typesCtx)
+ 
+        PreparedRunTransformer = TTransformationPipeline(typesCtx) 
             .Add(TLogExprTransformer::Sync("PreparedRun iteration", logComp, logLevel), "KqlPreparedRun")
             .Add(CreateKqpAcquireMvccSnapshotTransformer(Gateway, TxState, TransformCtx), "AcquireMvccSnapshot")
-            .Add(CreateKqpExecutePreparedTransformer(Gateway, Cluster, TxState, TransformCtx), "ExecutePrepared")
-            .Add(CreateKqpFinalizeTransformer(Gateway, Cluster, TxState, TransformCtx), "Finalize")
-            .Build(false);
-
+            .Add(CreateKqpExecutePreparedTransformer(Gateway, Cluster, TxState, TransformCtx), "ExecutePrepared") 
+            .Add(CreateKqpFinalizeTransformer(Gateway, Cluster, TxState, TransformCtx), "Finalize") 
+            .Build(false); 
+ 
         PreparedExplainTransformer = TTransformationPipeline(typesCtx)
             .Add(CreateKqpExplainPreparedTransformer(Gateway, Cluster, TransformCtx), "ExplainQuery")
             .Build(false);
 
-        PhysicalOptimizeTransformer = TTransformationPipeline(typesCtx)
-            .AddServiceTransformers()
+        PhysicalOptimizeTransformer = TTransformationPipeline(typesCtx) 
+            .AddServiceTransformers() 
             .Add(TLogExprTransformer::Sync("PhysicalOptimizeTransformer", logComp, logLevel), "LogPhysicalOptimize")
-            .AddTypeAnnotationTransformer(CreateKqpTypeAnnotationTransformer(Cluster, sessionCtx->TablesPtr(),
+            .AddTypeAnnotationTransformer(CreateKqpTypeAnnotationTransformer(Cluster, sessionCtx->TablesPtr(), 
                 *typesCtx, Config))
-            .Add(CreateKqpCheckQueryTransformer(), "CheckKqlQuery")
+            .Add(CreateKqpCheckQueryTransformer(), "CheckKqlQuery") 
             .AddPostTypeAnnotation()
-            .AddCommonOptimization()
+            .AddCommonOptimization() 
             .Add(CreateKqpLogOptTransformer(OptimizeCtx, *typesCtx, Config), "LogicalOptimize")
             .Add(CreateKqpPhyOptTransformer(OptimizeCtx, *typesCtx), "PhysicalOptimize")
             .Add(CreateKqpFinalizingOptTransformer(), "FinalizingOptimize")
-            .Add(CreateKqpQueryPhasesTransformer(), "QueryPhases")
-            .Add(CreateKqpQueryEffectsTransformer(OptimizeCtx), "QueryEffects")
+            .Add(CreateKqpQueryPhasesTransformer(), "QueryPhases") 
+            .Add(CreateKqpQueryEffectsTransformer(OptimizeCtx), "QueryEffects") 
             .Add(CreateKqpCheckPhysicalQueryTransformer(), "CheckKqlPhysicalQuery")
-            .Build(false);
-
-        PhysicalBuildQueryTransformer = TTransformationPipeline(typesCtx)
-            .AddServiceTransformers()
+            .Build(false); 
+ 
+        PhysicalBuildQueryTransformer = TTransformationPipeline(typesCtx) 
+            .AddServiceTransformers() 
             .Add(TLogExprTransformer::Sync("PhysicalBuildQueryTransformer", logComp, logLevel), "LogPhysicalBuildQuery")
             .AddTypeAnnotationTransformer(CreateKqpTypeAnnotationTransformer(Cluster, sessionCtx->TablesPtr(), *typesCtx, Config))
             .AddPostTypeAnnotation()
@@ -223,8 +223,8 @@ public:
                     *typesCtx,
                     Config),
                 "BuildPhysicalTxs")
-            .Build(false);
-
+            .Build(false); 
+ 
         PhysicalPeepholeTransformer = TTransformationPipeline(typesCtx)
             .AddServiceTransformers()
             .Add(TLogExprTransformer::Sync("PhysicalPeepholeTransformer", logComp, logLevel), "LogPhysicalPeephole")
@@ -237,152 +237,152 @@ public:
                     *typesCtx), *typesCtx, Config), "Peephole")
             .Build(false);
 
-        PhysicalRunQueryTransformer = TTransformationPipeline(typesCtx)
+        PhysicalRunQueryTransformer = TTransformationPipeline(typesCtx) 
             .Add(CreateKqpAcquireMvccSnapshotTransformer(Gateway, TxState, TransformCtx, true), "AcquireMvccSnapshot")
-            .Add(CreateKqpExecutePhysicalDataTransformer(Gateway, Cluster, TxState, TransformCtx), "ExecutePhysical")
-            .Build(false);
-
-        ScanRunQueryTransformer = TTransformationPipeline(typesCtx)
+            .Add(CreateKqpExecutePhysicalDataTransformer(Gateway, Cluster, TxState, TransformCtx), "ExecutePhysical") 
+            .Build(false); 
+ 
+        ScanRunQueryTransformer = TTransformationPipeline(typesCtx) 
             .Add(CreateKqpCreateSnapshotTransformer(Gateway, TransformCtx, TxState), "CreateSnapshot")
-            .Add(CreateKqpExecuteScanTransformer(Gateway, Cluster, TxState, TransformCtx), "ExecuteScan")
+            .Add(CreateKqpExecuteScanTransformer(Gateway, Cluster, TxState, TransformCtx), "ExecuteScan") 
             .Add(CreateKqpReleaseSnapshotTransformer(Gateway, TxState), "ReleaseSnapshot")
-            .Build(false);
-    }
-
-    TIntrusivePtr<TAsyncQueryResult> PrepareDataQuery(const TString& cluster, const TExprNode::TPtr& query,
-        TExprContext& ctx, const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        YQL_ENSURE(TransformCtx->QueryCtx->Type == EKikimrQueryType::Dml);
-        YQL_ENSURE(TransformCtx->QueryCtx->PrepareOnly);
+            .Build(false); 
+    } 
+ 
+    TIntrusivePtr<TAsyncQueryResult> PrepareDataQuery(const TString& cluster, const TExprNode::TPtr& query, 
+        TExprContext& ctx, const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        YQL_ENSURE(TransformCtx->QueryCtx->Type == EKikimrQueryType::Dml); 
+        YQL_ENSURE(TransformCtx->QueryCtx->PrepareOnly); 
         YQL_ENSURE(TransformCtx->QueryCtx->PreparingQuery);
         YQL_ENSURE(TMaybeNode<TKiDataQuery>(query));
-
+ 
         return PrepareQueryInternal(cluster, TKiDataQuery(query), ctx, settings);
-    }
-
-    TIntrusivePtr<TAsyncQueryResult> PrepareScanQuery(const TString& cluster, const TExprNode::TPtr& query,
-        TExprContext& ctx, const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        YQL_ENSURE(TransformCtx->QueryCtx->Type == EKikimrQueryType::Scan);
-        YQL_ENSURE(TransformCtx->QueryCtx->PrepareOnly);
+    } 
+ 
+    TIntrusivePtr<TAsyncQueryResult> PrepareScanQuery(const TString& cluster, const TExprNode::TPtr& query, 
+        TExprContext& ctx, const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        YQL_ENSURE(TransformCtx->QueryCtx->Type == EKikimrQueryType::Scan); 
+        YQL_ENSURE(TransformCtx->QueryCtx->PrepareOnly); 
         YQL_ENSURE(TransformCtx->QueryCtx->PreparingQuery);
         YQL_ENSURE(TMaybeNode<TKiDataQuery>(query));
+ 
+        TKiDataQuery dataQuery(query); 
 
-        TKiDataQuery dataQuery(query);
-
-        if (dataQuery.Results().Size() != 1) {
-            ctx.AddError(YqlIssue(ctx.GetPosition(dataQuery.Pos()), TIssuesIds::KIKIMR_PRECONDITION_FAILED,
-                "Scan query should have a single result set."));
+        if (dataQuery.Results().Size() != 1) { 
+            ctx.AddError(YqlIssue(ctx.GetPosition(dataQuery.Pos()), TIssuesIds::KIKIMR_PRECONDITION_FAILED, 
+                "Scan query should have a single result set.")); 
             return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-        if (dataQuery.Effects().ArgCount() > 0) {
-            ctx.AddError(YqlIssue(ctx.GetPosition(dataQuery.Pos()), TIssuesIds::KIKIMR_PRECONDITION_FAILED,
-                "Scan query cannot have data modifications."));
+        } 
+        if (dataQuery.Effects().ArgCount() > 0) { 
+            ctx.AddError(YqlIssue(ctx.GetPosition(dataQuery.Pos()), TIssuesIds::KIKIMR_PRECONDITION_FAILED, 
+                "Scan query cannot have data modifications.")); 
             return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-
-        IKikimrQueryExecutor::TExecuteSettings scanSettings(settings);
+        } 
+ 
+        IKikimrQueryExecutor::TExecuteSettings scanSettings(settings); 
         return PrepareQueryInternal(cluster, dataQuery, ctx, scanSettings);
-    }
-
-    TIntrusivePtr<TAsyncQueryResult> ExecutePreparedDataQuery(const TString& cluster, TExprNode* queryExpr,
+    } 
+ 
+    TIntrusivePtr<TAsyncQueryResult> ExecutePreparedDataQuery(const TString& cluster, TExprNode* queryExpr, 
         const NKikimrKqp::TPreparedKql& kql, TExprContext& ctx,
-        const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        YQL_ENSURE(queryExpr->Type() == TExprNode::World);
-        YQL_ENSURE(cluster == Cluster);
-
-        PreparedRunTransformer->Rewind();
-
-        TransformCtx->Reset();
-        TransformCtx->Settings.CopyFrom(kql.GetSettings());
+        const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        YQL_ENSURE(queryExpr->Type() == TExprNode::World); 
+        YQL_ENSURE(cluster == Cluster); 
+ 
+        PreparedRunTransformer->Rewind(); 
+ 
+        TransformCtx->Reset(); 
+        TransformCtx->Settings.CopyFrom(kql.GetSettings()); 
         TransformCtx->Settings.SetCommitTx(settings.CommitTx);
         TransformCtx->Settings.SetRollbackTx(settings.RollbackTx);
-        TransformCtx->PreparedKql = &kql;
-
-        YQL_ENSURE(TxState->Tx().EffectiveIsolationLevel);
-        YQL_ENSURE(TransformCtx->Settings.GetIsolationLevel() == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED);
-
-        bool strictDml = MergeFlagValue(Config->StrictDml.Get(Cluster), settings.StrictDml);
-        if (!ApplyTableOperations(kql, strictDml, ctx)) {
+        TransformCtx->PreparedKql = &kql; 
+ 
+        YQL_ENSURE(TxState->Tx().EffectiveIsolationLevel); 
+        YQL_ENSURE(TransformCtx->Settings.GetIsolationLevel() == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED); 
+ 
+        bool strictDml = MergeFlagValue(Config->StrictDml.Get(Cluster), settings.StrictDml); 
+        if (!ApplyTableOperations(kql, strictDml, ctx)) { 
             return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-
+        } 
+ 
         return MakeIntrusive<TAsyncRunResult>(queryExpr, ctx, *PreparedRunTransformer, *TransformCtx);
-    }
-
-    TIntrusivePtr<TAsyncQueryResult> ExecutePreparedQueryNewEngine(const TString& cluster,
-        const NYql::TExprNode::TPtr& world, const NKqpProto::TKqpPhyQuery& phyQuery, TExprContext& ctx,
-        const IKikimrQueryExecutor::TExecuteSettings& settings) override
-    {
-        YQL_ENSURE(cluster == Cluster);
-        YQL_ENSURE(phyQuery.GetType() == NKqpProto::TKqpPhyQuery::TYPE_DATA);
-
-        if (!Config->HasAllowKqpNewEngine()) {
-            ctx.AddError(TIssue(TPosition(), "NewEngine execution is not allowed on this cluster."));
-            return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(
-                ctx.IssueManager.GetIssues()));
-        }
-
-        return ExecutePhysicalDataQuery(world, phyQuery, ctx, settings);
-    }
-
-    TIntrusivePtr<TAsyncQueryResult> ExecutePreparedScanQuery(const TString& cluster,
-        const NYql::TExprNode::TPtr& world, const NKqpProto::TKqpPhyQuery& phyQuery, TExprContext& ctx,
+    } 
+ 
+    TIntrusivePtr<TAsyncQueryResult> ExecutePreparedQueryNewEngine(const TString& cluster, 
+        const NYql::TExprNode::TPtr& world, const NKqpProto::TKqpPhyQuery& phyQuery, TExprContext& ctx, 
+        const IKikimrQueryExecutor::TExecuteSettings& settings) override 
+    { 
+        YQL_ENSURE(cluster == Cluster); 
+        YQL_ENSURE(phyQuery.GetType() == NKqpProto::TKqpPhyQuery::TYPE_DATA); 
+ 
+        if (!Config->HasAllowKqpNewEngine()) { 
+            ctx.AddError(TIssue(TPosition(), "NewEngine execution is not allowed on this cluster.")); 
+            return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>( 
+                ctx.IssueManager.GetIssues())); 
+        } 
+ 
+        return ExecutePhysicalDataQuery(world, phyQuery, ctx, settings); 
+    } 
+ 
+    TIntrusivePtr<TAsyncQueryResult> ExecutePreparedScanQuery(const TString& cluster, 
+        const NYql::TExprNode::TPtr& world, const NKqpProto::TKqpPhyQuery& phyQuery, TExprContext& ctx, 
         const NActors::TActorId& target) override
     {
         YQL_ENSURE(cluster == Cluster);
-        YQL_ENSURE(phyQuery.GetType() == NKqpProto::TKqpPhyQuery::TYPE_SCAN);
+        YQL_ENSURE(phyQuery.GetType() == NKqpProto::TKqpPhyQuery::TYPE_SCAN); 
 
-        return ExecutePhysicalScanQuery(world, phyQuery, ctx, target);
-    }
-
-private:
-    bool ApplyTableOperations(const TVector<NKqpProto::TKqpTableOp>& operations,
-        const TVector<NKqpProto::TKqpTableInfo>& tableInfos, bool strictDml, TExprContext& ctx)
-    {
-        auto isolationLevel = *TxState->Tx().EffectiveIsolationLevel;
-        if (!TxState->Tx().ApplyTableOperations(operations, tableInfos, isolationLevel, strictDml, EKikimrQueryType::Dml, ctx)) {
-            return false;
-        }
-
-        return true;
-    }
-
-    bool ApplyTableOperations(const NKikimrKqp::TPreparedKql& kql, bool strictDml, TExprContext& ctx) {
-        TVector<NKqpProto::TKqpTableOp> operations(kql.GetOperations().begin(), kql.GetOperations().end());
-        TVector<NKqpProto::TKqpTableInfo> tableInfos(kql.GetTableInfo().begin(), kql.GetTableInfo().end());
-        return ApplyTableOperations(operations, tableInfos, strictDml, ctx);
-    }
-
-    bool ApplyTableOperations(const NKqpProto::TKqpPhyQuery& query, bool strictDml, TExprContext& ctx) {
-        TVector<NKqpProto::TKqpTableOp> operations(query.GetTableOps().begin(), query.GetTableOps().end());
-        TVector<NKqpProto::TKqpTableInfo> tableInfos(query.GetTableInfos().begin(), query.GetTableInfos().end());
-        return ApplyTableOperations(operations, tableInfos, strictDml, ctx);
+        return ExecutePhysicalScanQuery(world, phyQuery, ctx, target); 
     }
 
+private: 
+    bool ApplyTableOperations(const TVector<NKqpProto::TKqpTableOp>& operations, 
+        const TVector<NKqpProto::TKqpTableInfo>& tableInfos, bool strictDml, TExprContext& ctx) 
+    { 
+        auto isolationLevel = *TxState->Tx().EffectiveIsolationLevel; 
+        if (!TxState->Tx().ApplyTableOperations(operations, tableInfos, isolationLevel, strictDml, EKikimrQueryType::Dml, ctx)) { 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+    bool ApplyTableOperations(const NKikimrKqp::TPreparedKql& kql, bool strictDml, TExprContext& ctx) { 
+        TVector<NKqpProto::TKqpTableOp> operations(kql.GetOperations().begin(), kql.GetOperations().end()); 
+        TVector<NKqpProto::TKqpTableInfo> tableInfos(kql.GetTableInfo().begin(), kql.GetTableInfo().end()); 
+        return ApplyTableOperations(operations, tableInfos, strictDml, ctx); 
+    } 
+ 
+    bool ApplyTableOperations(const NKqpProto::TKqpPhyQuery& query, bool strictDml, TExprContext& ctx) { 
+        TVector<NKqpProto::TKqpTableOp> operations(query.GetTableOps().begin(), query.GetTableOps().end()); 
+        TVector<NKqpProto::TKqpTableInfo> tableInfos(query.GetTableInfos().begin(), query.GetTableInfos().end()); 
+        return ApplyTableOperations(operations, tableInfos, strictDml, ctx); 
+    } 
+ 
     TIntrusivePtr<TAsyncQueryResult> PrepareQueryInternal(const TString& cluster, const TKiDataQuery& dataQuery,
-        TExprContext& ctx, const IKikimrQueryExecutor::TExecuteSettings& settings)
-    {
-        YQL_ENSURE(cluster == Cluster);
-
+        TExprContext& ctx, const IKikimrQueryExecutor::TExecuteSettings& settings) 
+    { 
+        YQL_ENSURE(cluster == Cluster); 
+ 
         auto* queryCtx = TransformCtx->QueryCtx.Get();
 
         if (queryCtx->Type == EKikimrQueryType::Dml) {
-            ui32 resultsCount = dataQuery.Results().Size();
-            for (ui32 i = 0; i < resultsCount; ++i) {
+            ui32 resultsCount = dataQuery.Results().Size(); 
+            for (ui32 i = 0; i < resultsCount; ++i) { 
                 auto& result = *queryCtx->PreparingQuery->AddResults();
-                result.SetKqlIndex(0);
-                result.SetResultIndex(i);
-                for (const auto& column : dataQuery.Results().Item(i).Columns()) {
-                    *result.AddColumnHints() = column.Value();
-                }
-                result.SetRowsLimit(FromString<ui64>(dataQuery.Results().Item(i).RowsLimit()));
-            }
+                result.SetKqlIndex(0); 
+                result.SetResultIndex(i); 
+                for (const auto& column : dataQuery.Results().Item(i).Columns()) { 
+                    *result.AddColumnHints() = column.Value(); 
+                } 
+                result.SetRowsLimit(FromString<ui64>(dataQuery.Results().Item(i).RowsLimit())); 
+            } 
         } else {
             // scan query
-        }
-
+        } 
+ 
         bool sysColumnsEnabled = TransformCtx->Config->SystemColumnsEnabled();
 
         std::optional<TKqpTransactionInfo::EEngine> engine;
@@ -403,9 +403,9 @@ private:
         if ((queryCtx->Type == EKikimrQueryType::Scan) ||
             (engine.has_value() && *engine == TKqpTransactionInfo::EEngine::NewEngine))
         {
-            return PrepareQueryNewEngine(cluster, dataQuery, ctx, settings, sysColumnsEnabled);
-        }
-
+            return PrepareQueryNewEngine(cluster, dataQuery, ctx, settings, sysColumnsEnabled); 
+        } 
+ 
         // OldEngine only
         YQL_ENSURE(!engine.has_value() || *engine == TKqpTransactionInfo::EEngine::OldEngine);
 
@@ -420,33 +420,33 @@ private:
         }
 
         auto program = BuildKiProgram(dataQuery, *TransformCtx->Tables, ctx, sysColumnsEnabled);
-
-        KqlOptimizeTransformer->Rewind();
-
-        TExprNode::TPtr optimizedProgram = program.Ptr();
-        auto status = InstantTransform(*KqlOptimizeTransformer, optimizedProgram, ctx);
-        if (status != IGraphTransformer::TStatus::Ok || !TMaybeNode<TKiProgram>(optimizedProgram)) {
+ 
+        KqlOptimizeTransformer->Rewind(); 
+ 
+        TExprNode::TPtr optimizedProgram = program.Ptr(); 
+        auto status = InstantTransform(*KqlOptimizeTransformer, optimizedProgram, ctx); 
+        if (status != IGraphTransformer::TStatus::Ok || !TMaybeNode<TKiProgram>(optimizedProgram)) { 
             ctx.AddError(TIssue(ctx.GetPosition(dataQuery.Pos()), "Failed to optimize KQL query."));
             return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-
-        YQL_ENSURE(optimizedProgram->GetTypeAnn());
+        } 
+ 
+        YQL_ENSURE(optimizedProgram->GetTypeAnn()); 
 
         queryCtx->QueryTraits = CollectQueryTraits(TKiProgram(optimizedProgram), ctx);
 
-        KqlTypeAnnTransformer->Rewind();
-
-        TExprNode::TPtr finalProgram;
-        bool hasNonDeterministicFunctions;
+        KqlTypeAnnTransformer->Rewind(); 
+ 
+        TExprNode::TPtr finalProgram; 
+        bool hasNonDeterministicFunctions; 
         TPeepholeSettings peepholeSettings;
         peepholeSettings.WithNonDeterministicRules = false;
         status = PeepHoleOptimizeNode<false>(optimizedProgram, finalProgram, ctx, TypesCtx, KqlTypeAnnTransformer.Get(),
             hasNonDeterministicFunctions, peepholeSettings);
-        if (status != IGraphTransformer::TStatus::Ok) {
+        if (status != IGraphTransformer::TStatus::Ok) { 
             ctx.AddError(TIssue(ctx.GetPosition(dataQuery.Pos()), "Failed to peephole optimize KQL query."));
             return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-
+        } 
+ 
         status = ReplaceNonDetFunctionsWithParams(finalProgram, ctx);
         if (status != IGraphTransformer::TStatus::Ok) {
             ctx.AddError(TIssue(ctx.GetPosition(dataQuery.Pos()),
@@ -455,24 +455,24 @@ private:
         }
 
         KqlPrepareTransformer->Rewind();
-
-        NKikimrKqp::TKqlSettings kqlSettings;
-        kqlSettings.SetCommitTx(settings.CommitTx);
-        kqlSettings.SetRollbackTx(settings.RollbackTx);
-
-        TransformCtx->Reset();
-        TransformCtx->Settings = kqlSettings;
-
-        if (!TxState->Tx().EffectiveIsolationLevel) {
-            TxState->Tx().EffectiveIsolationLevel = kqlSettings.GetIsolationLevel();
-        }
-
+ 
+        NKikimrKqp::TKqlSettings kqlSettings; 
+        kqlSettings.SetCommitTx(settings.CommitTx); 
+        kqlSettings.SetRollbackTx(settings.RollbackTx); 
+ 
+        TransformCtx->Reset(); 
+        TransformCtx->Settings = kqlSettings; 
+ 
+        if (!TxState->Tx().EffectiveIsolationLevel) { 
+            TxState->Tx().EffectiveIsolationLevel = kqlSettings.GetIsolationLevel(); 
+        } 
+ 
         TransformCtx->QueryCtx->PreparingQuery->SetVersion(NKikimrKqp::TPreparedQuery::VERSION_V1);
         auto kql = TransformCtx->QueryCtx->PreparingQuery->AddKqls();
         kql->MutableSettings()->CopyFrom(TransformCtx->Settings);
 
         FillAstAndPlan(*kql, finalProgram, ctx);
-
+ 
         auto operations = TableOperationsToProto(dataQuery.Operations(), ctx);
         for (auto& op : operations) {
             const auto& tableName = op.GetTable();
@@ -481,65 +481,65 @@ private:
             const auto& desc = TransformCtx->Tables->GetTable(cluster, tableName);
             TableDescriptionToTableInfo(desc, kql->AddTableInfo());
         }
-
+ 
         TransformCtx->PreparingKql = kql;
 
         return MakeIntrusive<TAsyncRunResult>(finalProgram, ctx, *KqlPrepareTransformer, *TransformCtx);
-    }
-
-    TIntrusivePtr<TAsyncQueryResult> PrepareQueryNewEngine(const TString& cluster, const TKiDataQuery& dataQuery,
-        TExprContext& ctx, const IKikimrQueryExecutor::TExecuteSettings& settings, bool sysColumnsEnabled)
-    {
-        YQL_ENSURE(cluster == Cluster);
-        YQL_ENSURE(!settings.CommitTx);
-        YQL_ENSURE(!settings.RollbackTx);
-        YQL_ENSURE(TransformCtx->QueryCtx->PrepareOnly);
-
+    } 
+ 
+    TIntrusivePtr<TAsyncQueryResult> PrepareQueryNewEngine(const TString& cluster, const TKiDataQuery& dataQuery, 
+        TExprContext& ctx, const IKikimrQueryExecutor::TExecuteSettings& settings, bool sysColumnsEnabled) 
+    { 
+        YQL_ENSURE(cluster == Cluster); 
+        YQL_ENSURE(!settings.CommitTx); 
+        YQL_ENSURE(!settings.RollbackTx); 
+        YQL_ENSURE(TransformCtx->QueryCtx->PrepareOnly); 
+ 
         EKikimrQueryType queryType = TransformCtx->QueryCtx->Type;
         switch (queryType) {
             case EKikimrQueryType::Dml:
-            case EKikimrQueryType::Scan:
+            case EKikimrQueryType::Scan: 
                 break;
             default:
                 YQL_ENSURE(false, "PrepareQueryNewEngine, unexpected query type: " << queryType);
         }
 
         if (!Config->HasAllowKqpNewEngine() && queryType == EKikimrQueryType::Dml) {
-            ctx.AddError(TIssue(ctx.GetPosition(dataQuery.Pos()),
-                "NewEngine execution is not allowed on this cluster."));
-            return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-
-        auto kqlQuery = BuildKqlQuery(dataQuery, *TransformCtx->Tables, ctx, sysColumnsEnabled, OptimizeCtx);
-        if (!kqlQuery) {
+            ctx.AddError(TIssue(ctx.GetPosition(dataQuery.Pos()), 
+                "NewEngine execution is not allowed on this cluster.")); 
             return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-
-        auto query = kqlQuery->Ptr();
+        } 
+ 
+        auto kqlQuery = BuildKqlQuery(dataQuery, *TransformCtx->Tables, ctx, sysColumnsEnabled, OptimizeCtx); 
+        if (!kqlQuery) { 
+            return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues())); 
+        } 
+ 
+        auto query = kqlQuery->Ptr(); 
         YQL_CLOG(INFO, ProviderKqp) << "Initial KQL query: " << KqpExprToPrettyString(*query, ctx);
-
-        TransformCtx->Reset();
-        TransformCtx->Settings = NKikimrKqp::TKqlSettings();
-
-        PhysicalOptimizeTransformer->Rewind();
-        auto optimizedQuery = query;
-        auto status = InstantTransform(*PhysicalOptimizeTransformer, optimizedQuery, ctx);
-        if (status != IGraphTransformer::TStatus::Ok) {
+ 
+        TransformCtx->Reset(); 
+        TransformCtx->Settings = NKikimrKqp::TKqlSettings(); 
+ 
+        PhysicalOptimizeTransformer->Rewind(); 
+        auto optimizedQuery = query; 
+        auto status = InstantTransform(*PhysicalOptimizeTransformer, optimizedQuery, ctx); 
+        if (status != IGraphTransformer::TStatus::Ok) { 
             ctx.AddError(TIssue(ctx.GetPosition(query->Pos()), "Failed to optimize query."));
             return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-
+        } 
+ 
         YQL_CLOG(INFO, ProviderKqp) << "Optimized KQL query: " << KqpExprToPrettyString(*optimizedQuery, ctx);
-
-        BuildQueryCtx->Reset();
-        PhysicalBuildQueryTransformer->Rewind();
-        auto builtQuery = optimizedQuery;
-        status = InstantTransform(*PhysicalBuildQueryTransformer, builtQuery, ctx);
-        if (status != IGraphTransformer::TStatus::Ok) {
+ 
+        BuildQueryCtx->Reset(); 
+        PhysicalBuildQueryTransformer->Rewind(); 
+        auto builtQuery = optimizedQuery; 
+        status = InstantTransform(*PhysicalBuildQueryTransformer, builtQuery, ctx); 
+        if (status != IGraphTransformer::TStatus::Ok) { 
             ctx.AddError(TIssue(ctx.GetPosition(query->Pos()), "Failed to build physical query."));
             return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-
+        } 
+ 
         PhysicalPeepholeTransformer->Rewind();
         auto transformedQuery = builtQuery;
         status = InstantTransform(*PhysicalPeepholeTransformer, transformedQuery, ctx);
@@ -550,96 +550,96 @@ private:
         }
 
         YQL_CLOG(INFO, ProviderKqp) << "Physical KQL query: " << KqpExprToPrettyString(*builtQuery, ctx);
-
+ 
         auto& preparedQuery = *TransformCtx->QueryCtx->PreparingQuery;
         TKqpPhysicalQuery physicalQuery(transformedQuery);
         auto compiler = CreateKqpQueryCompiler(Cluster, OptimizeCtx->Tables, FuncRegistry);
-        auto ret = compiler->CompilePhysicalQuery(physicalQuery, dataQuery.Operations(),
-            *preparedQuery.MutablePhysicalQuery(), ctx);
+        auto ret = compiler->CompilePhysicalQuery(physicalQuery, dataQuery.Operations(), 
+            *preparedQuery.MutablePhysicalQuery(), ctx); 
         if (!ret) {
             ctx.AddError(TIssue(ctx.GetPosition(query->Pos()), "Failed to compile physical query."));
             return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
+        } 
         preparedQuery.SetVersion(NKikimrKqp::TPreparedQuery::VERSION_PHYSICAL_V1);
         // TODO(sk): only on stats mode or if explain-only
         PreparedExplainTransformer->Rewind();
         return MakeIntrusive<TPhysicalAsyncRunResult>(builtQuery, ctx, *PreparedExplainTransformer, *TransformCtx);
-    }
-
-    TIntrusivePtr<TAsyncQueryResult> ExecutePhysicalDataQuery(const TExprNode::TPtr& world,
-        const NKqpProto::TKqpPhyQuery& phyQuery, TExprContext& ctx,
-        const IKikimrQueryExecutor::TExecuteSettings& settings)
-    {
-        PhysicalRunQueryTransformer->Rewind();
-
-        TransformCtx->Reset();
-        TransformCtx->PhysicalQuery = &phyQuery;
-
-        YQL_ENSURE(TxState->Tx().EffectiveIsolationLevel);
-        YQL_ENSURE(TransformCtx->Settings.GetIsolationLevel() == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED);
-
-        // TODO: Avoid using KQL settings
-        TransformCtx->Settings.SetCommitTx(settings.CommitTx);
-        TransformCtx->Settings.SetRollbackTx(settings.RollbackTx);
-
-        bool strictDml = MergeFlagValue(Config->StrictDml.Get(Cluster), settings.StrictDml);
-        if (!ApplyTableOperations(phyQuery, strictDml, ctx)) {
-            return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues()));
-        }
-        return MakeIntrusive<TPhysicalAsyncRunResult>(world, ctx, *PhysicalRunQueryTransformer, *TransformCtx);
-    }
-
-    TIntrusivePtr<TAsyncQueryResult> ExecutePhysicalScanQuery(const TExprNode::TPtr& world,
+    } 
+ 
+    TIntrusivePtr<TAsyncQueryResult> ExecutePhysicalDataQuery(const TExprNode::TPtr& world, 
+        const NKqpProto::TKqpPhyQuery& phyQuery, TExprContext& ctx, 
+        const IKikimrQueryExecutor::TExecuteSettings& settings) 
+    { 
+        PhysicalRunQueryTransformer->Rewind(); 
+ 
+        TransformCtx->Reset(); 
+        TransformCtx->PhysicalQuery = &phyQuery; 
+ 
+        YQL_ENSURE(TxState->Tx().EffectiveIsolationLevel); 
+        YQL_ENSURE(TransformCtx->Settings.GetIsolationLevel() == NKikimrKqp::ISOLATION_LEVEL_UNDEFINED); 
+ 
+        // TODO: Avoid using KQL settings 
+        TransformCtx->Settings.SetCommitTx(settings.CommitTx); 
+        TransformCtx->Settings.SetRollbackTx(settings.RollbackTx); 
+ 
+        bool strictDml = MergeFlagValue(Config->StrictDml.Get(Cluster), settings.StrictDml); 
+        if (!ApplyTableOperations(phyQuery, strictDml, ctx)) { 
+            return MakeKikimrResultHolder(ResultFromErrors<IKqpHost::TQueryResult>(ctx.IssueManager.GetIssues())); 
+        } 
+        return MakeIntrusive<TPhysicalAsyncRunResult>(world, ctx, *PhysicalRunQueryTransformer, *TransformCtx); 
+    } 
+ 
+    TIntrusivePtr<TAsyncQueryResult> ExecutePhysicalScanQuery(const TExprNode::TPtr& world, 
         const NKqpProto::TKqpPhyQuery& phyQuery, TExprContext& ctx, const NActors::TActorId& target)
-    {
-        ScanRunQueryTransformer->Rewind();
-
-        TransformCtx->Reset();
-        TransformCtx->PhysicalQuery = &phyQuery;
-        TransformCtx->ReplyTarget = target;
-
+    { 
+        ScanRunQueryTransformer->Rewind(); 
+ 
+        TransformCtx->Reset(); 
+        TransformCtx->PhysicalQuery = &phyQuery; 
+        TransformCtx->ReplyTarget = target; 
+ 
         Y_ASSERT(!TxState->Tx().GetSnapshot().IsValid());
 
-        return MakeIntrusive<TScanAsyncRunResult>(world, ctx, *ScanRunQueryTransformer);
-    }
-
-    static bool MergeFlagValue(const TMaybe<bool>& configFlag, const TMaybe<bool>& flag) {
-        if (flag) {
-            return *flag;
-        }
-
-        if (configFlag) {
-            return *configFlag;
-        }
-
-        return false;
-    }
-
-private:
-    TIntrusivePtr<IKqpGateway> Gateway;
+        return MakeIntrusive<TScanAsyncRunResult>(world, ctx, *ScanRunQueryTransformer); 
+    } 
+ 
+    static bool MergeFlagValue(const TMaybe<bool>& configFlag, const TMaybe<bool>& flag) { 
+        if (flag) { 
+            return *flag; 
+        } 
+ 
+        if (configFlag) { 
+            return *configFlag; 
+        } 
+ 
+        return false; 
+    } 
+ 
+private: 
+    TIntrusivePtr<IKqpGateway> Gateway; 
     TString Cluster;
-    TTypeAnnotationContext& TypesCtx;
-    const NMiniKQL::IFunctionRegistry& FuncRegistry;
-    TKikimrConfiguration::TPtr Config;
-
-    TIntrusivePtr<TKqpTransactionState> TxState;
-    TIntrusivePtr<TKqlTransformContext> TransformCtx;
-    TIntrusivePtr<TKqpOptimizeContext> OptimizeCtx;
-    TIntrusivePtr<TKqpBuildQueryContext> BuildQueryCtx;
-
-    TAutoPtr<IGraphTransformer> KqlTypeAnnTransformer;
-    TAutoPtr<IGraphTransformer> KqlOptimizeTransformer;
+    TTypeAnnotationContext& TypesCtx; 
+    const NMiniKQL::IFunctionRegistry& FuncRegistry; 
+    TKikimrConfiguration::TPtr Config; 
+ 
+    TIntrusivePtr<TKqpTransactionState> TxState; 
+    TIntrusivePtr<TKqlTransformContext> TransformCtx; 
+    TIntrusivePtr<TKqpOptimizeContext> OptimizeCtx; 
+    TIntrusivePtr<TKqpBuildQueryContext> BuildQueryCtx; 
+ 
+    TAutoPtr<IGraphTransformer> KqlTypeAnnTransformer; 
+    TAutoPtr<IGraphTransformer> KqlOptimizeTransformer; 
     TAutoPtr<IGraphTransformer> KqlPrepareTransformer;
-    TAutoPtr<IGraphTransformer> PreparedRunTransformer;
+    TAutoPtr<IGraphTransformer> PreparedRunTransformer; 
     TAutoPtr<IGraphTransformer> PreparedExplainTransformer;
-
-    TAutoPtr<IGraphTransformer> PhysicalOptimizeTransformer;
-    TAutoPtr<IGraphTransformer> PhysicalBuildQueryTransformer;
+ 
+    TAutoPtr<IGraphTransformer> PhysicalOptimizeTransformer; 
+    TAutoPtr<IGraphTransformer> PhysicalBuildQueryTransformer; 
     TAutoPtr<IGraphTransformer> PhysicalPeepholeTransformer;
-    TAutoPtr<IGraphTransformer> PhysicalRunQueryTransformer;
-    TAutoPtr<IGraphTransformer> ScanRunQueryTransformer;
-};
-
+    TAutoPtr<IGraphTransformer> PhysicalRunQueryTransformer; 
+    TAutoPtr<IGraphTransformer> ScanRunQueryTransformer; 
+}; 
+ 
 class TKqpAcquireMvccSnapshotTransformer : public TGraphTransformerBase {
 public:
     TKqpAcquireMvccSnapshotTransformer(TIntrusivePtr<IKqpGateway> gateway, TIntrusivePtr<TKqlTransformContext> transformCtx,
@@ -789,19 +789,19 @@ private:
     TIntrusivePtr<TKqpTransactionState> TxState;
 };
 
-} // namespace
-
+} // namespace 
+ 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpAcquireMvccSnapshotTransformer(TIntrusivePtr<IKqpGateway> gateway,
     TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx, bool newEngine) {
     return new TKqpAcquireMvccSnapshotTransformer(gateway, transformCtx, txState, newEngine);
 }
 
-TIntrusivePtr<IKqpRunner> CreateKqpRunner(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-    TIntrusivePtr<TTypeAnnotationContext> typesCtx, TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-    const NMiniKQL::IFunctionRegistry& funcRegistry)
-{
-    return new TKqpRunner(gateway, cluster, typesCtx, sessionCtx, funcRegistry);
-}
-
+TIntrusivePtr<IKqpRunner> CreateKqpRunner(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+    TIntrusivePtr<TTypeAnnotationContext> typesCtx, TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+    const NMiniKQL::IFunctionRegistry& funcRegistry) 
+{ 
+    return new TKqpRunner(gateway, cluster, typesCtx, sessionCtx, funcRegistry); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/host/ya.make b/ydb/core/kqp/host/ya.make
index e0f595515c..9e08655349 100644
--- a/ydb/core/kqp/host/ya.make
+++ b/ydb/core/kqp/host/ya.make
@@ -1,22 +1,22 @@
-LIBRARY()
-
-OWNER(
-    spuchin
-    g:kikimr
-)
-
-SRCS(
-    kqp_host.cpp
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
+    g:kikimr 
+) 
+ 
+SRCS( 
+    kqp_host.cpp 
     kqp_ne_helper.cpp
-    kqp_run_data.cpp
+    kqp_run_data.cpp 
     kqp_explain_prepared.cpp
-    kqp_run_physical.cpp
-    kqp_run_prepared.cpp
-    kqp_run_scan.cpp
-    kqp_runner.cpp
-)
-
-PEERDIR(
+    kqp_run_physical.cpp 
+    kqp_run_prepared.cpp 
+    kqp_run_scan.cpp 
+    kqp_runner.cpp 
+) 
+ 
+PEERDIR( 
     ydb/core/base
     ydb/core/kqp/common
     ydb/core/kqp/opt
@@ -30,8 +30,8 @@ PEERDIR(
     ydb/library/yql/providers/common/udf_resolve
     ydb/library/yql/providers/config
     ydb/library/yql/providers/result/provider
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-END()
+END() 
diff --git a/ydb/core/kqp/kqp.h b/ydb/core/kqp/kqp.h
index 09f794591d..ac46863e95 100644
--- a/ydb/core/kqp/kqp.h
+++ b/ydb/core/kqp/kqp.h
@@ -1,33 +1,33 @@
-#pragma once
-
+#pragma once 
+ 
 #include "kqp_query_replay.h"
 #include <ydb/core/kqp/common/kqp_common.h>
 #include <ydb/core/kqp/counters/kqp_counters.h>
 #include <ydb/core/kqp/provider/yql_kikimr_query_traits.h>
 #include <ydb/public/api/protos/ydb_status_codes.pb.h>
-
+ 
 #include <ydb/library/yql/dq/actors/dq.h>
 #include <ydb/library/yql/public/issue/yql_issue.h>
-
-#include <util/generic/guid.h>
+ 
+#include <util/generic/guid.h> 
 #include <util/generic/ptr.h>
-
-namespace NKikimr {
-namespace NKqp {
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
 const TStringBuf DefaultKikimrClusterName = "kikimr";
 const TStringBuf DefaultKikimrPublicClusterName = "db";
-
+ 
 inline NActors::TActorId MakeKqpProxyID(ui32 nodeId) {
-    const char name[12] = "kqp_proxy";
+    const char name[12] = "kqp_proxy"; 
     return NActors::TActorId(nodeId, TStringBuf(name, 12));
-}
-
+} 
+ 
 inline NActors::TActorId MakeKqpCompileServiceID(ui32 nodeId) {
-    const char name[12] = "kqp_compile";
+    const char name[12] = "kqp_compile"; 
     return NActors::TActorId(nodeId, TStringBuf(name, 12));
-}
-
+} 
+ 
 inline NActors::TActorId MakeKqpResourceManagerServiceID(ui32 nodeId) {
     const char name[12] = "kqp_resman";
     return NActors::TActorId(nodeId, TStringBuf(name, 12));
@@ -104,119 +104,119 @@ private:
     TIntrusivePtr<TKqpShutdownState> ShutdownState_;
 };
 
-struct TKqpQuerySettings {
-    bool DocumentApiRestricted = true;
-
-    bool operator==(const TKqpQuerySettings& other) const {
-        return
-            DocumentApiRestricted == other.DocumentApiRestricted;
-    }
-
-    bool operator!=(const TKqpQuerySettings& other) {
-        return !(*this == other);
-    }
-
-    bool operator<(const TKqpQuerySettings&) = delete;
-    bool operator>(const TKqpQuerySettings&) = delete;
-    bool operator<=(const TKqpQuerySettings&) = delete;
-    bool operator>=(const TKqpQuerySettings&) = delete;
-
-    size_t GetHash() const noexcept {
-        auto tuple = std::make_tuple(DocumentApiRestricted);
-        return THash<decltype(tuple)>()(tuple);
-    }
-};
-
-struct TKqpQueryId {
-    TString Cluster;
-    TString Database;
-    TString UserSid;
-    TString Text;
-    TKqpQuerySettings Settings;
-
-public:
-    TKqpQueryId(const TString& cluster, const TString& database, const TString& text)
-        : Cluster(cluster)
-        , Database(database)
-        , Text(text) {}
-
-    bool operator==(const TKqpQueryId& other) const {
-        return
-            Cluster == other.Cluster &&
-            Database == other.Database &&
-            UserSid == other.UserSid &&
-            Text == other.Text &&
-            Settings == other.Settings;
-    }
-
-    bool operator!=(const TKqpQueryId& other) {
-        return !(*this == other);
-    }
-
-    bool operator<(const TKqpQueryId&) = delete;
-    bool operator>(const TKqpQueryId&) = delete;
-    bool operator<=(const TKqpQueryId&) = delete;
-    bool operator>=(const TKqpQueryId&) = delete;
-
-    size_t GetHash() const noexcept {
-        auto tuple = std::make_tuple(Cluster, Database, UserSid, Text, Settings);
-        return THash<decltype(tuple)>()(tuple);
-    }
-};
-
+struct TKqpQuerySettings { 
+    bool DocumentApiRestricted = true; 
+ 
+    bool operator==(const TKqpQuerySettings& other) const { 
+        return 
+            DocumentApiRestricted == other.DocumentApiRestricted; 
+    } 
+ 
+    bool operator!=(const TKqpQuerySettings& other) { 
+        return !(*this == other); 
+    } 
+ 
+    bool operator<(const TKqpQuerySettings&) = delete; 
+    bool operator>(const TKqpQuerySettings&) = delete; 
+    bool operator<=(const TKqpQuerySettings&) = delete; 
+    bool operator>=(const TKqpQuerySettings&) = delete; 
+ 
+    size_t GetHash() const noexcept { 
+        auto tuple = std::make_tuple(DocumentApiRestricted); 
+        return THash<decltype(tuple)>()(tuple); 
+    } 
+}; 
+ 
+struct TKqpQueryId { 
+    TString Cluster; 
+    TString Database; 
+    TString UserSid; 
+    TString Text; 
+    TKqpQuerySettings Settings; 
+ 
+public: 
+    TKqpQueryId(const TString& cluster, const TString& database, const TString& text) 
+        : Cluster(cluster) 
+        , Database(database) 
+        , Text(text) {} 
+ 
+    bool operator==(const TKqpQueryId& other) const { 
+        return 
+            Cluster == other.Cluster && 
+            Database == other.Database && 
+            UserSid == other.UserSid && 
+            Text == other.Text && 
+            Settings == other.Settings; 
+    } 
+ 
+    bool operator!=(const TKqpQueryId& other) { 
+        return !(*this == other); 
+    } 
+ 
+    bool operator<(const TKqpQueryId&) = delete; 
+    bool operator>(const TKqpQueryId&) = delete; 
+    bool operator<=(const TKqpQueryId&) = delete; 
+    bool operator>=(const TKqpQueryId&) = delete; 
+ 
+    size_t GetHash() const noexcept { 
+        auto tuple = std::make_tuple(Cluster, Database, UserSid, Text, Settings); 
+        return THash<decltype(tuple)>()(tuple); 
+    } 
+}; 
+ 
 using TPreparedQueryConstPtr = std::shared_ptr<const NKikimrKqp::TPreparedQuery>;
 
-struct TKqpCompileResult {
+struct TKqpCompileResult { 
     using TConstPtr = std::shared_ptr<const TKqpCompileResult>;
-
+ 
     TKqpCompileResult(const TString& uid, TKqpQueryId&& query, const Ydb::StatusIds::StatusCode& status,
         const NYql::TIssues& issues)
-        : Status(status)
-        , Issues(issues)
-        , Query(std::move(query))
+        : Status(status) 
+        , Issues(issues) 
+        , Query(std::move(query)) 
         , Uid(uid) {}
-
-    TKqpCompileResult(const TString& uid, const Ydb::StatusIds::StatusCode& status, const NYql::TIssues& issues)
-        : Status(status)
-        , Issues(issues)
-        , Uid(uid) {}
-
+ 
+    TKqpCompileResult(const TString& uid, const Ydb::StatusIds::StatusCode& status, const NYql::TIssues& issues) 
+        : Status(status) 
+        , Issues(issues) 
+        , Uid(uid) {} 
+ 
     static std::shared_ptr<TKqpCompileResult> Make(const TString& uid, TKqpQueryId&& query,
         const Ydb::StatusIds::StatusCode& status, const NYql::TIssues& issues)
-    {
+    { 
         return std::make_shared<TKqpCompileResult>(uid, std::move(query), status, issues);
-    }
-
+    } 
+ 
     static std::shared_ptr<TKqpCompileResult> Make(const TString& uid, const Ydb::StatusIds::StatusCode& status,
-        const NYql::TIssues& issues)
-    {
+        const NYql::TIssues& issues) 
+    { 
         return std::make_shared<TKqpCompileResult>(uid, status, issues);
-    }
-
-    Ydb::StatusIds::StatusCode Status;
-    NYql::TIssues Issues;
-
-    TMaybe<TKqpQueryId> Query;
-    TString Uid;
-
+    } 
+ 
+    Ydb::StatusIds::StatusCode Status; 
+    NYql::TIssues Issues; 
+ 
+    TMaybe<TKqpQueryId> Query; 
+    TString Uid; 
+ 
     TPreparedQueryConstPtr PreparedQuery;
     TPreparedQueryConstPtr PreparedQueryNewEngine;
     std::optional<TQueryTraits> QueryTraits;
-};
-
-struct TEvKqp {
-    struct TEvQueryRequest : public TEventPB<TEvQueryRequest, NKikimrKqp::TEvQueryRequest,
-        TKqpEvents::EvQueryRequest> {};
-
-    struct TEvCloseSessionRequest : public TEventPB<TEvCloseSessionRequest,
-        NKikimrKqp::TEvCloseSessionRequest, TKqpEvents::EvCloseSessionRequest> {};
-
-    struct TEvCreateSessionRequest : public TEventPB<TEvCreateSessionRequest,
-        NKikimrKqp::TEvCreateSessionRequest, TKqpEvents::EvCreateSessionRequest> {};
-
-    struct TEvPingSessionRequest : public TEventPB<TEvPingSessionRequest,
-        NKikimrKqp::TEvPingSessionRequest, TKqpEvents::EvPingSessionRequest> {};
-
+}; 
+ 
+struct TEvKqp { 
+    struct TEvQueryRequest : public TEventPB<TEvQueryRequest, NKikimrKqp::TEvQueryRequest, 
+        TKqpEvents::EvQueryRequest> {}; 
+ 
+    struct TEvCloseSessionRequest : public TEventPB<TEvCloseSessionRequest, 
+        NKikimrKqp::TEvCloseSessionRequest, TKqpEvents::EvCloseSessionRequest> {}; 
+ 
+    struct TEvCreateSessionRequest : public TEventPB<TEvCreateSessionRequest, 
+        NKikimrKqp::TEvCreateSessionRequest, TKqpEvents::EvCreateSessionRequest> {}; 
+ 
+    struct TEvPingSessionRequest : public TEventPB<TEvPingSessionRequest, 
+        NKikimrKqp::TEvPingSessionRequest, TKqpEvents::EvPingSessionRequest> {}; 
+ 
     struct TEvInitiateSessionShutdown : public TEventLocal<TEvInitiateSessionShutdown, TKqpEvents::EvInitiateSessionShutdown> {
         ui32 SoftTimeoutMs;
         ui32 HardTimeoutMs;
@@ -229,23 +229,23 @@ struct TEvKqp {
 
     struct TEvContinueShutdown : public TEventLocal<TEvContinueShutdown, TKqpEvents::EvContinueShutdown> {};
 
-    struct TEvProcessResponse : public TEventPB<TEvProcessResponse, NKikimrKqp::TEvProcessResponse,
-        TKqpEvents::EvProcessResponse>
-    {
-        static THolder<TEvProcessResponse> Error(Ydb::StatusIds::StatusCode ydbStatus, const TString& error) {
-            auto ev = MakeHolder<TEvProcessResponse>();
-            ev->Record.SetYdbStatus(ydbStatus);
-            ev->Record.SetError(error);
-            return ev;
-        }
-
-        static THolder<TEvProcessResponse> Success() {
-            auto ev = MakeHolder<TEvProcessResponse>();
-            ev->Record.SetYdbStatus(Ydb::StatusIds::SUCCESS);
-            return ev;
-        }
-    };
-
+    struct TEvProcessResponse : public TEventPB<TEvProcessResponse, NKikimrKqp::TEvProcessResponse, 
+        TKqpEvents::EvProcessResponse> 
+    { 
+        static THolder<TEvProcessResponse> Error(Ydb::StatusIds::StatusCode ydbStatus, const TString& error) { 
+            auto ev = MakeHolder<TEvProcessResponse>(); 
+            ev->Record.SetYdbStatus(ydbStatus); 
+            ev->Record.SetError(error); 
+            return ev; 
+        } 
+ 
+        static THolder<TEvProcessResponse> Success() { 
+            auto ev = MakeHolder<TEvProcessResponse>(); 
+            ev->Record.SetYdbStatus(Ydb::StatusIds::SUCCESS); 
+            return ev; 
+        } 
+    }; 
+ 
     struct TEvDataQueryStreamPart : public TEventPB<TEvDataQueryStreamPart,
         NKikimrKqp::TEvDataQueryStreamPart, TKqpEvents::EvDataQueryStreamPart> {};
 
@@ -328,63 +328,63 @@ struct TEvKqp {
     };
 
     struct TEvQueryResponse : public TEventPB<TEvQueryResponse, TProtoArenaHolder<NKikimrKqp::TEvQueryResponse>,
-        TKqpEvents::EvQueryResponse> {};
-
-    struct TEvCreateSessionResponse : public TEventPB<TEvCreateSessionResponse,
-        NKikimrKqp::TEvCreateSessionResponse, TKqpEvents::EvCreateSessionResponse> {};
-
-    struct TEvContinueProcess : public TEventLocal<TEvContinueProcess, TKqpEvents::EvContinueProcess> {
-        TEvContinueProcess(ui32 queryId, bool finished)
-            : QueryId(queryId)
-            , Finished(finished) {}
-
-        ui32 QueryId;
-        bool Finished;
-    };
-
-    struct TEvQueryTimeout : public TEventLocal<TEvQueryTimeout, TKqpEvents::EvQueryTimeout> {
-        TEvQueryTimeout(ui32 queryId)
-            : QueryId(queryId) {}
-
-        ui32 QueryId;
-    };
-
-    struct TEvIdleTimeout : public TEventLocal<TEvIdleTimeout, TKqpEvents::EvIdleTimeout> {
-        TEvIdleTimeout(ui32 timerId)
-            : TimerId(timerId) {}
-
-        ui32 TimerId;
-    };
-
-    struct TEvCloseSessionResponse : public TEventPB<TEvCloseSessionResponse,
-        NKikimrKqp::TEvCloseSessionResponse, TKqpEvents::EvCloseSessionResponse> {};
-
-    struct TEvPingSessionResponse : public TEventPB<TEvPingSessionResponse,
-        NKikimrKqp::TEvPingSessionResponse, TKqpEvents::EvPingSessionResponse> {};
-
-    struct TEvCompileRequest : public TEventLocal<TEvCompileRequest, TKqpEvents::EvCompileRequest> {
-        TEvCompileRequest(const TString& userToken, const TMaybe<TString>& uid, TMaybe<TKqpQueryId>&& query,
+        TKqpEvents::EvQueryResponse> {}; 
+ 
+    struct TEvCreateSessionResponse : public TEventPB<TEvCreateSessionResponse, 
+        NKikimrKqp::TEvCreateSessionResponse, TKqpEvents::EvCreateSessionResponse> {}; 
+ 
+    struct TEvContinueProcess : public TEventLocal<TEvContinueProcess, TKqpEvents::EvContinueProcess> { 
+        TEvContinueProcess(ui32 queryId, bool finished) 
+            : QueryId(queryId) 
+            , Finished(finished) {} 
+ 
+        ui32 QueryId; 
+        bool Finished; 
+    }; 
+ 
+    struct TEvQueryTimeout : public TEventLocal<TEvQueryTimeout, TKqpEvents::EvQueryTimeout> { 
+        TEvQueryTimeout(ui32 queryId) 
+            : QueryId(queryId) {} 
+ 
+        ui32 QueryId; 
+    }; 
+ 
+    struct TEvIdleTimeout : public TEventLocal<TEvIdleTimeout, TKqpEvents::EvIdleTimeout> { 
+        TEvIdleTimeout(ui32 timerId) 
+            : TimerId(timerId) {} 
+ 
+        ui32 TimerId; 
+    }; 
+ 
+    struct TEvCloseSessionResponse : public TEventPB<TEvCloseSessionResponse, 
+        NKikimrKqp::TEvCloseSessionResponse, TKqpEvents::EvCloseSessionResponse> {}; 
+ 
+    struct TEvPingSessionResponse : public TEventPB<TEvPingSessionResponse, 
+        NKikimrKqp::TEvPingSessionResponse, TKqpEvents::EvPingSessionResponse> {}; 
+ 
+    struct TEvCompileRequest : public TEventLocal<TEvCompileRequest, TKqpEvents::EvCompileRequest> { 
+        TEvCompileRequest(const TString& userToken, const TMaybe<TString>& uid, TMaybe<TKqpQueryId>&& query, 
             bool keepInCache, TInstant deadline, TKqpDbCountersPtr dbCounters)
-            : UserToken(userToken)
-            , Uid(uid)
-            , Query(std::move(query))
+            : UserToken(userToken) 
+            , Uid(uid) 
+            , Query(std::move(query)) 
             , KeepInCache(keepInCache)
-            , Deadline(deadline)
+            , Deadline(deadline) 
             , DbCounters(dbCounters)
-        {
-            Y_ENSURE(Uid.Defined() != Query.Defined());
-        }
-
-        TString UserToken;
-        TMaybe<TString> Uid;
-        TMaybe<TKqpQueryId> Query;
-        bool KeepInCache = false;
+        { 
+            Y_ENSURE(Uid.Defined() != Query.Defined()); 
+        } 
+ 
+        TString UserToken; 
+        TMaybe<TString> Uid; 
+        TMaybe<TKqpQueryId> Query; 
+        bool KeepInCache = false; 
         // it is allowed for local event to use absolute time (TInstant) instead of time interval (TDuration)
-        TInstant Deadline;
+        TInstant Deadline; 
         TKqpDbCountersPtr DbCounters;
-        TMaybe<bool> DocumentApiRestricted;
-    };
-
+        TMaybe<bool> DocumentApiRestricted; 
+    }; 
+ 
     struct TEvRecompileRequest : public TEventLocal<TEvRecompileRequest, TKqpEvents::EvRecompileRequest> {
         TEvRecompileRequest(const TString& userToken, const TString& uid, const TMaybe<TKqpQueryId>& query,
             TInstant deadline, TKqpDbCountersPtr dbCounters)
@@ -402,28 +402,28 @@ struct TEvKqp {
         TKqpDbCountersPtr DbCounters;
     };
 
-    struct TEvCompileResponse : public TEventLocal<TEvCompileResponse, TKqpEvents::EvCompileResponse> {
-        TEvCompileResponse(const TKqpCompileResult::TConstPtr& compileResult)
-            : CompileResult(compileResult) {}
-
-        TKqpCompileResult::TConstPtr CompileResult;
-        NKqpProto::TKqpStatsCompile Stats;
+    struct TEvCompileResponse : public TEventLocal<TEvCompileResponse, TKqpEvents::EvCompileResponse> { 
+        TEvCompileResponse(const TKqpCompileResult::TConstPtr& compileResult) 
+            : CompileResult(compileResult) {} 
+ 
+        TKqpCompileResult::TConstPtr CompileResult; 
+        NKqpProto::TKqpStatsCompile Stats; 
         std::optional<TString> ReplayMessage;
 
         ui32 ForceNewEnginePercent = 0;
         ui32 ForceNewEngineLevel = 0;
-    };
-
-    struct TEvCompileInvalidateRequest : public TEventLocal<TEvCompileInvalidateRequest,
-        TKqpEvents::EvCompileInvalidateRequest>
-    {
+    }; 
+ 
+    struct TEvCompileInvalidateRequest : public TEventLocal<TEvCompileInvalidateRequest, 
+        TKqpEvents::EvCompileInvalidateRequest> 
+    { 
         TEvCompileInvalidateRequest(const TString& uid, TKqpDbCountersPtr dbCounters)
             : Uid(uid)
             , DbCounters(dbCounters) {}
-
-        TString Uid;
+ 
+        TString Uid; 
         TKqpDbCountersPtr DbCounters;
-    };
+    }; 
 
     struct TEvInitiateShutdownRequest : public TEventLocal<TEvInitiateShutdownRequest, TKqpEvents::EvInitiateShutdownRequest> {
         TIntrusivePtr<TKqpShutdownState> ShutdownState;
@@ -436,63 +436,63 @@ struct TEvKqp {
     using TEvAbortExecution = NYql::NDq::TEvDq::TEvAbortExecution;
 };
 
-class TKqpRequestInfo {
-public:
-    TKqpRequestInfo(const TString& traceId, const TString& sessionId)
-        : TraceId(traceId)
-        , SessionId(sessionId) {}
-
-    TKqpRequestInfo(const TString& traceId)
-        : TraceId(traceId)
-        , SessionId() {}
-
-    TKqpRequestInfo()
-        : TraceId()
-        , SessionId() {}
-
-    const TString GetTraceId() const {
-        return TraceId;
-    }
-
-    const TString GetSessionId() const {
-        return SessionId;
-    }
-
-private:
-    TString TraceId;
-    TString SessionId;
-};
-
-
-static inline IOutputStream& operator<<(IOutputStream& stream, const TKqpRequestInfo& requestInfo) {
-    if (!requestInfo.GetTraceId().empty()) {
-        stream << "TraceId: \"" << requestInfo.GetTraceId() << "\", ";
-    }
-    if (!requestInfo.GetSessionId().empty()) {
-        stream << "SessionId: " << requestInfo.GetSessionId() << ", ";
-    }
-
-    return stream;
-}
-
-IActor* CreateKqpProxyService(const NKikimrConfig::TLogConfig& logConfig,
-    const NKikimrConfig::TTableServiceConfig& tableServiceConfig,
+class TKqpRequestInfo { 
+public: 
+    TKqpRequestInfo(const TString& traceId, const TString& sessionId) 
+        : TraceId(traceId) 
+        , SessionId(sessionId) {} 
+ 
+    TKqpRequestInfo(const TString& traceId) 
+        : TraceId(traceId) 
+        , SessionId() {} 
+ 
+    TKqpRequestInfo() 
+        : TraceId() 
+        , SessionId() {} 
+ 
+    const TString GetTraceId() const { 
+        return TraceId; 
+    } 
+ 
+    const TString GetSessionId() const { 
+        return SessionId; 
+    } 
+ 
+private: 
+    TString TraceId; 
+    TString SessionId; 
+}; 
+ 
+
+static inline IOutputStream& operator<<(IOutputStream& stream, const TKqpRequestInfo& requestInfo) { 
+    if (!requestInfo.GetTraceId().empty()) { 
+        stream << "TraceId: \"" << requestInfo.GetTraceId() << "\", "; 
+    } 
+    if (!requestInfo.GetSessionId().empty()) { 
+        stream << "SessionId: " << requestInfo.GetSessionId() << ", "; 
+    } 
+ 
+    return stream; 
+} 
+ 
+IActor* CreateKqpProxyService(const NKikimrConfig::TLogConfig& logConfig, 
+    const NKikimrConfig::TTableServiceConfig& tableServiceConfig, 
     TVector<NKikimrKqp::TKqpSetting>&& settings,
     std::shared_ptr<IQueryReplayBackendFactory> queryReplayFactory);
-
+ 
 } // namespace NKqp
-} // namespace NKikimr
-
-template<>
-struct THash<NKikimr::NKqp::TKqpQuerySettings> {
-    inline size_t operator()(const NKikimr::NKqp::TKqpQuerySettings& settings) const {
-        return settings.GetHash();
-    }
-};
-
-template<>
-struct THash<NKikimr::NKqp::TKqpQueryId> {
-    inline size_t operator()(const NKikimr::NKqp::TKqpQueryId& query) const {
-        return query.GetHash();
-    }
-};
+} // namespace NKikimr 
+ 
+template<> 
+struct THash<NKikimr::NKqp::TKqpQuerySettings> { 
+    inline size_t operator()(const NKikimr::NKqp::TKqpQuerySettings& settings) const { 
+        return settings.GetHash(); 
+    } 
+}; 
+ 
+template<> 
+struct THash<NKikimr::NKqp::TKqpQueryId> { 
+    inline size_t operator()(const NKikimr::NKqp::TKqpQueryId& query) const { 
+        return query.GetHash(); 
+    } 
+}; 
diff --git a/ydb/core/kqp/kqp_compile_actor.cpp b/ydb/core/kqp/kqp_compile_actor.cpp
index 27cf296a03..89eafd4929 100644
--- a/ydb/core/kqp/kqp_compile_actor.cpp
+++ b/ydb/core/kqp/kqp_compile_actor.cpp
@@ -1,12 +1,12 @@
-#include "kqp_impl.h"
+#include "kqp_impl.h" 
 #include "kqp_metadata_loader.h"
-
+ 
 #include <ydb/core/actorlib_impl/long_timer.h>
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/client/minikql_compile/mkql_compile_service.h>
 #include <ydb/core/kqp/counters/kqp_counters.h>
 #include <ydb/core/kqp/host/kqp_host.h>
-
+ 
 #include <ydb/library/yql/utils/actor_log/log.h>
 
 #include <library/cpp/actors/core/actor_bootstrapped.h>
@@ -14,77 +14,77 @@
 #include <library/cpp/json/json_writer.h>
 #include <library/cpp/string_utils/base64/base64.h>
 #include <library/cpp/digest/md5/md5.h>
-
-#include <util/string/escape.h>
-
+ 
+#include <util/string/escape.h> 
+ 
 #include <ydb/core/base/cputime.h>
 
-namespace NKikimr {
-namespace NKqp {
-
+namespace NKikimr { 
+namespace NKqp { 
+ 
 static std::atomic<bool> FailForcedNewEngineCompilationStatus = false;
 
 void FailForcedNewEngineCompilationForTests(bool fail) {
     FailForcedNewEngineCompilationStatus = fail;
 }
 
-static const TString YqlName = "CompileActor";
-
-using namespace NKikimrConfig;
-using namespace NThreading;
-using namespace NYql;
+static const TString YqlName = "CompileActor"; 
+ 
+using namespace NKikimrConfig; 
+using namespace NThreading; 
+using namespace NYql; 
 using namespace NYql::NDq;
-
-class TKqpCompileActor : public TActorBootstrapped<TKqpCompileActor> {
-public:
-    using TBase = TActorBootstrapped<TKqpCompileActor>;
-
-    static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
-        return NKikimrServices::TActivity::KQP_COMPILE_ACTOR;
-    }
-
+ 
+class TKqpCompileActor : public TActorBootstrapped<TKqpCompileActor> { 
+public: 
+    using TBase = TActorBootstrapped<TKqpCompileActor>; 
+ 
+    static constexpr NKikimrServices::TActivity::EType ActorActivityType() { 
+        return NKikimrServices::TActivity::KQP_COMPILE_ACTOR; 
+    } 
+ 
     TKqpCompileActor(const TActorId& owner, const TKqpSettings::TConstPtr& kqpSettings,
-        const TTableServiceConfig& serviceConfig, TIntrusivePtr<TModuleResolverState> moduleResolverState,
+        const TTableServiceConfig& serviceConfig, TIntrusivePtr<TModuleResolverState> moduleResolverState, 
         TIntrusivePtr<TKqpCounters> counters, const TString& uid, const TKqpQueryId& query, const TString& userToken,
         TKqpDbCountersPtr dbCounters, bool recompileWithNewEngine)
-        : Owner(owner)
-        , ModuleResolverState(moduleResolverState)
-        , Counters(counters)
+        : Owner(owner) 
+        , ModuleResolverState(moduleResolverState) 
+        , Counters(counters) 
         , Uid(uid)
-        , Query(query)
-        , UserToken(userToken)
+        , Query(query) 
+        , UserToken(userToken) 
         , DbCounters(dbCounters)
-        , Config(MakeIntrusive<TKikimrConfiguration>())
+        , Config(MakeIntrusive<TKikimrConfiguration>()) 
         , CompilationTimeout(TDuration::MilliSeconds(serviceConfig.GetCompileTimeoutMs()))
         , RecompileWithNewEngine(recompileWithNewEngine)
-    {
+    { 
         Config->Init(kqpSettings->DefaultSettings.GetDefaultSettings(), Query.Cluster, kqpSettings->Settings, false);
-
-        if (!Query.Database.empty()) {
-            Config->_KqpTablePathPrefix = Query.Database;
-        }
-
-        ApplyServiceConfig(*Config, serviceConfig);
-
-        Config->FreezeDefaults();
-    }
-
-    void Bootstrap(const TActorContext& ctx) {
-        StartTime = TInstant::Now();
-
+ 
+        if (!Query.Database.empty()) { 
+            Config->_KqpTablePathPrefix = Query.Database; 
+        } 
+ 
+        ApplyServiceConfig(*Config, serviceConfig); 
+ 
+        Config->FreezeDefaults(); 
+    } 
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        StartTime = TInstant::Now(); 
+ 
         Counters->ReportCompileStart(DbCounters);
 
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Start compilation"
-            << ", self: " << ctx.SelfID
-            << ", cluster: " << Query.Cluster
-            << ", database: " << Query.Database
-            << ", text: \"" << EscapeC(Query.Text) << "\""
-            << ", startTime: " << StartTime);
-
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Start compilation" 
+            << ", self: " << ctx.SelfID 
+            << ", cluster: " << Query.Cluster 
+            << ", database: " << Query.Database 
+            << ", text: \"" << EscapeC(Query.Text) << "\"" 
+            << ", startTime: " << StartTime); 
+ 
         TimeoutTimerActorId = CreateLongTimer(ctx, CompilationTimeout, new IEventHandle(SelfId(), SelfId(), new TEvents::TEvWakeup()));
-
+ 
         TYqlLogScope logScope(ctx, NKikimrServices::KQP_YQL, YqlName, "");
-
+ 
         TKqpRequestCounters::TPtr counters = new TKqpRequestCounters;
         counters->Counters = Counters;
         counters->DbCounters = DbCounters;
@@ -92,48 +92,48 @@ public:
         std::shared_ptr<NYql::IKikimrGateway::IKqpTableMetadataLoader> loader = std::make_shared<TKqpTableMetadataLoader>(TlsActivationContext->ActorSystem(), true);
         Gateway = CreateKikimrIcGateway(Query.Cluster, Query.Database, std::move(loader), ctx.ExecutorThread.ActorSystem,
             ctx.SelfID.NodeId(), counters, MakeMiniKQLCompileServiceID());
-        Gateway->SetToken(Query.Cluster, UserToken);
-
+        Gateway->SetToken(Query.Cluster, UserToken); 
+ 
         Config->FeatureFlags = AppData(ctx)->FeatureFlags;
 
         KqpHost = CreateKqpHost(Gateway, Query.Cluster, Query.Database, Config, ModuleResolverState->ModuleResolver,
-            AppData(ctx)->FunctionRegistry, false);
-
-        IKqpHost::TPrepareSettings prepareSettings;
+            AppData(ctx)->FunctionRegistry, false); 
+ 
+        IKqpHost::TPrepareSettings prepareSettings; 
         // prepareSettings.UseNewEngine = use default settings
-        prepareSettings.DocumentApiRestricted = Query.Settings.DocumentApiRestricted;
+        prepareSettings.DocumentApiRestricted = Query.Settings.DocumentApiRestricted; 
 
         NCpuTime::TCpuTimer timer(CompileCpuTime);
 
-        AsyncCompileResult = KqpHost->PrepareDataQuery(Query.Text, prepareSettings);
-
-        Continue(ctx);
-
-        Become(&TKqpCompileActor::CompileState);
-    }
-
-    void Die(const NActors::TActorContext& ctx) override {
-        if (TimeoutTimerActorId) {
-            ctx.Send(TimeoutTimerActorId, new TEvents::TEvPoisonPill());
-        }
-
-        TBase::Die(ctx);
-    }
-
-private:
-    STFUNC(CompileState) {
-        try {
-            switch (ev->GetTypeRewrite()) {
-                HFunc(TEvKqp::TEvContinueProcess, Handle);
-                CFunc(TEvents::TSystem::Wakeup, HandleTimeout);
-            default:
-                UnexpectedEvent("CompileState", ev->GetTypeRewrite(), ctx);
-            }
-        } catch (const yexception& e) {
-            InternalError(e.what(), ctx);
-        }
-    }
-
+        AsyncCompileResult = KqpHost->PrepareDataQuery(Query.Text, prepareSettings); 
+ 
+        Continue(ctx); 
+
+        Become(&TKqpCompileActor::CompileState); 
+    } 
+ 
+    void Die(const NActors::TActorContext& ctx) override { 
+        if (TimeoutTimerActorId) { 
+            ctx.Send(TimeoutTimerActorId, new TEvents::TEvPoisonPill()); 
+        } 
+ 
+        TBase::Die(ctx); 
+    } 
+ 
+private: 
+    STFUNC(CompileState) { 
+        try { 
+            switch (ev->GetTypeRewrite()) { 
+                HFunc(TEvKqp::TEvContinueProcess, Handle); 
+                CFunc(TEvents::TSystem::Wakeup, HandleTimeout); 
+            default: 
+                UnexpectedEvent("CompileState", ev->GetTypeRewrite(), ctx); 
+            } 
+        } catch (const yexception& e) { 
+            InternalError(e.what(), ctx); 
+        } 
+    } 
+ 
     STFUNC(RecompileNewEngineState) {
         try {
             switch (ev->GetTypeRewrite()) {
@@ -156,20 +156,20 @@ private:
         }
     }
 
-private:
-    void Continue(const TActorContext &ctx) {
-        TActorSystem* actorSystem = ctx.ExecutorThread.ActorSystem;
+private: 
+    void Continue(const TActorContext &ctx) { 
+        TActorSystem* actorSystem = ctx.ExecutorThread.ActorSystem; 
         TActorId selfId = ctx.SelfID;
-
-        auto callback = [actorSystem, selfId](const TFuture<bool>& future) {
-            bool finished = future.GetValue();
-            auto processEv = MakeHolder<TEvKqp::TEvContinueProcess>(0, finished);
-            actorSystem->Send(selfId, processEv.Release());
-        };
-
-        AsyncCompileResult->Continue().Apply(callback);
-    }
-
+ 
+        auto callback = [actorSystem, selfId](const TFuture<bool>& future) { 
+            bool finished = future.GetValue(); 
+            auto processEv = MakeHolder<TEvKqp::TEvContinueProcess>(0, finished); 
+            actorSystem->Send(selfId, processEv.Release()); 
+        }; 
+ 
+        AsyncCompileResult->Continue().Apply(callback); 
+    } 
+ 
     void AddMessageToReplayLog(const TString& queryPlan) {
         NJson::TJsonValue replayMessage(NJson::JSON_MAP);
         NJson::TJsonValue tablesMeta(NJson::JSON_ARRAY);
@@ -193,86 +193,86 @@ private:
         ReplayMessage = std::move(message);
     }
 
-    void Reply(const TKqpCompileResult::TConstPtr& compileResult, const TActorContext& ctx) {
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Send response"
-            << ", self: " << ctx.SelfID
-            << ", owner: " << Owner
-            << ", status: " << compileResult->Status
-            << ", issues: " << compileResult->Issues.ToString()
-            << ", uid: " << compileResult->Uid);
-
-        auto responseEv = MakeHolder<TEvKqp::TEvCompileResponse>(compileResult);
+    void Reply(const TKqpCompileResult::TConstPtr& compileResult, const TActorContext& ctx) { 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Send response" 
+            << ", self: " << ctx.SelfID 
+            << ", owner: " << Owner 
+            << ", status: " << compileResult->Status 
+            << ", issues: " << compileResult->Issues.ToString() 
+            << ", uid: " << compileResult->Uid); 
+ 
+        auto responseEv = MakeHolder<TEvKqp::TEvCompileResponse>(compileResult); 
 
         responseEv->ReplayMessage = std::move(ReplayMessage);
         ReplayMessage = std::nullopt;
-        auto& stats = responseEv->Stats;
-        stats.SetFromCache(false);
-        stats.SetDurationUs((TInstant::Now() - StartTime).MicroSeconds());
+        auto& stats = responseEv->Stats; 
+        stats.SetFromCache(false); 
+        stats.SetDurationUs((TInstant::Now() - StartTime).MicroSeconds()); 
         stats.SetCpuTimeUs(CompileCpuTime.MicroSeconds());
-        ctx.Send(Owner, responseEv.Release());
-
+        ctx.Send(Owner, responseEv.Release()); 
+ 
         Counters->ReportCompileFinish(DbCounters);
-
-        Die(ctx);
-    }
-
-    void ReplyError(Ydb::StatusIds::StatusCode status, const TIssues& issues, const TActorContext& ctx) {
+ 
+        Die(ctx); 
+    } 
+ 
+    void ReplyError(Ydb::StatusIds::StatusCode status, const TIssues& issues, const TActorContext& ctx) { 
         Reply(TKqpCompileResult::Make(Uid, std::move(Query), status, issues), ctx);
-    }
-
-    void InternalError(const TString message, const TActorContext &ctx) {
-        LOG_ERROR_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Internal error"
-            << ", self: " << ctx.SelfID
-            << ", message: " << message);
-
-
-        NYql::TIssue issue(NYql::TPosition(), "Internal error while compiling query.");
-        issue.AddSubIssue(MakeIntrusive<TIssue>(NYql::TPosition(), message));
-
-        ReplyError(Ydb::StatusIds::INTERNAL_ERROR, {issue}, ctx);
-    }
-
-    void UnexpectedEvent(const TString& state, ui32 eventType, const TActorContext &ctx) {
-        InternalError(TStringBuilder() << "TKqpCompileActor, unexpected event: " << eventType
-            << ", at state:" << state, ctx);
-    }
-
-    void Handle(TEvKqp::TEvContinueProcess::TPtr &ev, const TActorContext &ctx) {
-        Y_ENSURE(!ev->Get()->QueryId);
-
+    } 
+ 
+    void InternalError(const TString message, const TActorContext &ctx) { 
+        LOG_ERROR_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Internal error" 
+            << ", self: " << ctx.SelfID 
+            << ", message: " << message); 
+ 
+ 
+        NYql::TIssue issue(NYql::TPosition(), "Internal error while compiling query."); 
+        issue.AddSubIssue(MakeIntrusive<TIssue>(NYql::TPosition(), message)); 
+ 
+        ReplyError(Ydb::StatusIds::INTERNAL_ERROR, {issue}, ctx); 
+    } 
+ 
+    void UnexpectedEvent(const TString& state, ui32 eventType, const TActorContext &ctx) { 
+        InternalError(TStringBuilder() << "TKqpCompileActor, unexpected event: " << eventType 
+            << ", at state:" << state, ctx); 
+    } 
+ 
+    void Handle(TEvKqp::TEvContinueProcess::TPtr &ev, const TActorContext &ctx) { 
+        Y_ENSURE(!ev->Get()->QueryId); 
+ 
         TYqlLogScope logScope(ctx, NKikimrServices::KQP_YQL, YqlName, "");
-
-        if (!ev->Get()->Finished) {
+ 
+        if (!ev->Get()->Finished) { 
             NCpuTime::TCpuTimer timer(CompileCpuTime);
-            Continue(ctx);
-            return;
-        }
-
+            Continue(ctx); 
+            return; 
+        } 
+ 
         auto kqpResult = std::move(AsyncCompileResult->GetResult());
-        auto status = GetYdbStatus(kqpResult);
-
+        auto status = GetYdbStatus(kqpResult); 
+ 
         auto database = Query.Database;
-        if (kqpResult.SqlVersion) {
+        if (kqpResult.SqlVersion) { 
             Counters->ReportSqlVersion(DbCounters, *kqpResult.SqlVersion);
-        }
-
+        } 
+ 
         if (status == Ydb::StatusIds::SUCCESS) {
             AddMessageToReplayLog(kqpResult.QueryPlan);
         }
 
         KqpCompileResult = TKqpCompileResult::Make(Uid, std::move(Query), status, kqpResult.Issues());
-
-        if (status == Ydb::StatusIds::SUCCESS) {
+ 
+        if (status == Ydb::StatusIds::SUCCESS) { 
             YQL_ENSURE(kqpResult.PreparingQuery);
             KqpCompileResult->PreparedQuery.reset(kqpResult.PreparingQuery.release());
             KqpCompileResult->QueryTraits = kqpResult.QueryTraits;
-
+ 
             auto now = TInstant::Now();
             auto duration = now - StartTime;
             Counters->ReportCompileDurations(DbCounters, duration, CompileCpuTime);
-
-            LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Compilation successful"
-                << ", self: " << ctx.SelfID
+ 
+            LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Compilation successful" 
+                << ", self: " << ctx.SelfID 
                 << ", duration: " << duration
                 << ", traits: " << (KqpCompileResult->QueryTraits ? KqpCompileResult->QueryTraits->ToString() : "<none>"));
 
@@ -296,29 +296,29 @@ private:
 
                 return;
             }
-        } else {
+        } else { 
             LOG_ERROR_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Compilation failed"
                 << ", self: " << ctx.SelfID
                 << ", status: " << Ydb::StatusIds_StatusCode_Name(status)
                 << ", issues: " << kqpResult.Issues().ToString());
             Counters->ReportCompileError(DbCounters);
-        }
-
+        } 
+ 
         Reply(KqpCompileResult, ctx);
-    }
-
-    void HandleTimeout(const TActorContext& ctx) {
-        LOG_NOTICE_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Compilation timeout"
-            << ", self: " << ctx.SelfID
-            << ", cluster: " << Query.Cluster
-            << ", database: " << Query.Database
-            << ", text: \"" << EscapeC(Query.Text) << "\""
-            << ", startTime: " << StartTime);
-
-        NYql::TIssue issue(NYql::TPosition(), "Query compilation timed out.");
-        return ReplyError(Ydb::StatusIds::TIMEOUT, {issue}, ctx);
-    }
-
+    } 
+ 
+    void HandleTimeout(const TActorContext& ctx) { 
+        LOG_NOTICE_S(ctx, NKikimrServices::KQP_COMPILE_ACTOR, "Compilation timeout" 
+            << ", self: " << ctx.SelfID 
+            << ", cluster: " << Query.Cluster 
+            << ", database: " << Query.Database 
+            << ", text: \"" << EscapeC(Query.Text) << "\"" 
+            << ", startTime: " << StartTime); 
+ 
+        NYql::TIssue issue(NYql::TPosition(), "Query compilation timed out."); 
+        return ReplyError(Ydb::StatusIds::TIMEOUT, {issue}, ctx); 
+    } 
+ 
     void HandleRecompile(TEvKqp::TEvContinueProcess::TPtr &ev, const TActorContext &ctx) {
         Y_ENSURE(!ev->Get()->QueryId);
 
@@ -368,46 +368,46 @@ private:
         return Reply(KqpCompileResult, ctx);
     }
 
-private:
+private: 
     TActorId Owner;
-    TIntrusivePtr<TModuleResolverState> ModuleResolverState;
-    TIntrusivePtr<TKqpCounters> Counters;
+    TIntrusivePtr<TModuleResolverState> ModuleResolverState; 
+    TIntrusivePtr<TKqpCounters> Counters; 
     TString Uid;
-    TKqpQueryId Query;
-    TString UserToken;
+    TKqpQueryId Query; 
+    TString UserToken; 
     TKqpDbCountersPtr DbCounters;
-    TKikimrConfiguration::TPtr Config;
+    TKikimrConfiguration::TPtr Config; 
     TDuration CompilationTimeout;
     bool RecompileWithNewEngine;
-    TInstant StartTime;
+    TInstant StartTime; 
     TDuration CompileCpuTime;
     TInstant RecompileStartTime;
     TActorId TimeoutTimerActorId;
-    TIntrusivePtr<IKqpGateway> Gateway;
-    TIntrusivePtr<IKqpHost> KqpHost;
-    TIntrusivePtr<IKqpHost::IAsyncQueryResult> AsyncCompileResult;
+    TIntrusivePtr<IKqpGateway> Gateway; 
+    TIntrusivePtr<IKqpHost> KqpHost; 
+    TIntrusivePtr<IKqpHost::IAsyncQueryResult> AsyncCompileResult; 
     std::shared_ptr<TKqpCompileResult> KqpCompileResult;
     std::optional<TString> ReplayMessage;
-};
-
-void ApplyServiceConfig(TKikimrConfiguration& kqpConfig, const TTableServiceConfig& serviceConfig) {
-    kqpConfig._KqpAllowUnsafeCommit = serviceConfig.GetAllowUnsafeCommit();
-    if (serviceConfig.HasSqlVersion()) {
-        kqpConfig._KqpYqlSyntaxVersion = serviceConfig.GetSqlVersion();
-    }
-    if (serviceConfig.GetQueryLimits().HasResultRowsLimit()) {
-        kqpConfig._ResultRowsLimit = serviceConfig.GetQueryLimits().GetResultRowsLimit();
-    }
-}
-
+}; 
+ 
+void ApplyServiceConfig(TKikimrConfiguration& kqpConfig, const TTableServiceConfig& serviceConfig) { 
+    kqpConfig._KqpAllowUnsafeCommit = serviceConfig.GetAllowUnsafeCommit(); 
+    if (serviceConfig.HasSqlVersion()) { 
+        kqpConfig._KqpYqlSyntaxVersion = serviceConfig.GetSqlVersion(); 
+    } 
+    if (serviceConfig.GetQueryLimits().HasResultRowsLimit()) { 
+        kqpConfig._ResultRowsLimit = serviceConfig.GetQueryLimits().GetResultRowsLimit(); 
+    } 
+} 
+ 
 IActor* CreateKqpCompileActor(const TActorId& owner, const TKqpSettings::TConstPtr& kqpSettings,
-    const TTableServiceConfig& serviceConfig, TIntrusivePtr<TModuleResolverState> moduleResolverState,
+    const TTableServiceConfig& serviceConfig, TIntrusivePtr<TModuleResolverState> moduleResolverState, 
     TIntrusivePtr<TKqpCounters> counters, const TString& uid, const TKqpQueryId& query, const TString& userToken,
     TKqpDbCountersPtr dbCounters, bool recompileWithNewEngine)
-{
+{ 
     return new TKqpCompileActor(owner, kqpSettings, serviceConfig, moduleResolverState, counters, uid,
         std::move(query), userToken, dbCounters, recompileWithNewEngine);
-}
-
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/kqp_compile_request.cpp b/ydb/core/kqp/kqp_compile_request.cpp
index 2c18af159b..7d154ed9bc 100644
--- a/ydb/core/kqp/kqp_compile_request.cpp
+++ b/ydb/core/kqp/kqp_compile_request.cpp
@@ -1,304 +1,304 @@
-#include "kqp_impl.h"
-
+#include "kqp_impl.h" 
+ 
 #include <ydb/core/actorlib_impl/long_timer.h>
 #include <ydb/core/tx/scheme_cache/scheme_cache.h>
-
-#include <library/cpp/actors/core/actor_bootstrapped.h>
-#include <library/cpp/actors/core/hfunc.h>
-#include <library/cpp/actors/core/log.h>
-
-#include <util/string/escape.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NSchemeCache;
-using namespace NYql;
-
-class TKqpCompileRequestActor : public TActorBootstrapped<TKqpCompileRequestActor> {
-public:
-    using TBase = TActorBootstrapped<TKqpCompileRequestActor>;
-
-    static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
-        return NKikimrServices::TActivity::KQP_COMPILE_REQUEST;
-    }
-
-    TKqpCompileRequestActor(const TActorId& owner, const TString& userToken, const TMaybe<TString>& uid,
+ 
+#include <library/cpp/actors/core/actor_bootstrapped.h> 
+#include <library/cpp/actors/core/hfunc.h> 
+#include <library/cpp/actors/core/log.h> 
+ 
+#include <util/string/escape.h> 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NSchemeCache; 
+using namespace NYql; 
+ 
+class TKqpCompileRequestActor : public TActorBootstrapped<TKqpCompileRequestActor> { 
+public: 
+    using TBase = TActorBootstrapped<TKqpCompileRequestActor>; 
+ 
+    static constexpr NKikimrServices::TActivity::EType ActorActivityType() { 
+        return NKikimrServices::TActivity::KQP_COMPILE_REQUEST; 
+    } 
+ 
+    TKqpCompileRequestActor(const TActorId& owner, const TString& userToken, const TMaybe<TString>& uid, 
         TMaybe<TKqpQueryId>&& query, bool keepInCache, const TInstant& deadline, TKqpDbCountersPtr dbCounters)
-        : Owner(owner)
-        , UserToken(userToken)
-        , Uid(uid)
-        , Query(std::move(query))
-        , KeepInCache(keepInCache)
+        : Owner(owner) 
+        , UserToken(userToken) 
+        , Uid(uid) 
+        , Query(std::move(query)) 
+        , KeepInCache(keepInCache) 
         , Deadline(deadline)
         , DbCounters(dbCounters) {}
-
-    void Bootstrap(const TActorContext& ctx) {
-        TimeoutTimerId = CreateLongTimer(ctx, Deadline - TInstant::Now(),
-            new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
-
-        TMaybe<TKqpQueryId> query;
-        std::swap(Query, query);
-
-        auto compileEv = MakeHolder<TEvKqp::TEvCompileRequest>(UserToken, Uid, std::move(query),
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        TimeoutTimerId = CreateLongTimer(ctx, Deadline - TInstant::Now(), 
+            new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup())); 
+ 
+        TMaybe<TKqpQueryId> query; 
+        std::swap(Query, query); 
+ 
+        auto compileEv = MakeHolder<TEvKqp::TEvCompileRequest>(UserToken, Uid, std::move(query), 
             KeepInCache, Deadline, DbCounters);
-        ctx.Send(MakeKqpCompileServiceID(ctx.SelfID.NodeId()), compileEv.Release());
-
-        Become(&TKqpCompileRequestActor::MainState);
-    }
-
-    void Handle(TEvKqp::TEvCompileResponse::TPtr& ev, const TActorContext &ctx) {
-        auto compileResult = ev->Get()->CompileResult;
-        const auto& stats = ev->Get()->Stats;
-
-        if (compileResult->Status != Ydb::StatusIds::SUCCESS || !stats.GetFromCache()) {
-            ctx.Send(Owner, ev->Release().Release());
-            Die(ctx);
-            return;
-        }
-
+        ctx.Send(MakeKqpCompileServiceID(ctx.SelfID.NodeId()), compileEv.Release()); 
+ 
+        Become(&TKqpCompileRequestActor::MainState); 
+    } 
+ 
+    void Handle(TEvKqp::TEvCompileResponse::TPtr& ev, const TActorContext &ctx) { 
+        auto compileResult = ev->Get()->CompileResult; 
+        const auto& stats = ev->Get()->Stats; 
+ 
+        if (compileResult->Status != Ydb::StatusIds::SUCCESS || !stats.GetFromCache()) { 
+            ctx.Send(Owner, ev->Release().Release()); 
+            Die(ctx); 
+            return; 
+        } 
+ 
         if (!NavigateTables(*compileResult->PreparedQuery, compileResult->Query->Database, ctx)) {
-            ctx.Send(Owner, ev->Release().Release());
-            Die(ctx);
-            return;
-        }
-
-        DeferredResponse.Reset(ev->Release().Release());
-    }
-
-    void Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev, const TActorContext &ctx) {
-        if (ValidateTables(*ev->Get(), ctx)) {
-            ctx.Send(Owner, DeferredResponse.Release());
-            Die(ctx);
-            return;
-        }
-
-        auto& compileResult = *DeferredResponse->CompileResult;
-
+            ctx.Send(Owner, ev->Release().Release()); 
+            Die(ctx); 
+            return; 
+        } 
+ 
+        DeferredResponse.Reset(ev->Release().Release()); 
+    } 
+ 
+    void Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev, const TActorContext &ctx) { 
+        if (ValidateTables(*ev->Get(), ctx)) { 
+            ctx.Send(Owner, DeferredResponse.Release()); 
+            Die(ctx); 
+            return; 
+        } 
+ 
+        auto& compileResult = *DeferredResponse->CompileResult; 
+ 
         LOG_INFO_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Recompiling query due to scheme error"
-            << ", self: " << ctx.SelfID
-            << ", queryUid: " << compileResult.Uid);
-
+            << ", self: " << ctx.SelfID 
+            << ", queryUid: " << compileResult.Uid); 
+ 
         auto recompileEv = MakeHolder<TEvKqp::TEvRecompileRequest>(UserToken, compileResult.Uid, compileResult.Query,
             Deadline, DbCounters);
         ctx.Send(MakeKqpCompileServiceID(ctx.SelfID.NodeId()), recompileEv.Release());
-
-        DeferredResponse.Reset();
-    }
-
-    void HandleTimeout(const TActorContext& ctx) {
-        LOG_NOTICE_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Compile request deadline exceeded"
-            << ", self: " << ctx.SelfID);
-
-        NYql::TIssue issue(NYql::TPosition(), "Deadline exceeded during query compilation.");
-        return ReplyError(Ydb::StatusIds::TIMEOUT, {issue}, ctx);
-    }
-
-    void Die(const NActors::TActorContext& ctx) override {
-        if (TimeoutTimerId) {
-            ctx.Send(TimeoutTimerId, new TEvents::TEvPoisonPill());
-        }
-
-        TBase::Die(ctx);
-    }
-
-private:
-    STFUNC(MainState) {
-        try {
-            switch (ev->GetTypeRewrite()) {
-                HFunc(TEvKqp::TEvCompileResponse, Handle);
-                HFunc(TEvTxProxySchemeCache::TEvNavigateKeySetResult, Handle);
-                CFunc(TEvents::TSystem::Wakeup, HandleTimeout);
-            default:
-                UnexpectedEvent("MainState", ev->GetTypeRewrite(), ctx);
-            }
-        } catch (const yexception& e) {
-            InternalError(e.what(), ctx);
-        }
-    }
-
-private:
-    void FillTables(const NKikimrKqp::TPreparedKql& kql) {
-        for (const auto& tableInfo : kql.GetTableInfo()) {
-            TTableId tableId(tableInfo.GetTableId().GetOwnerId(), tableInfo.GetTableId().GetTableId());
-            auto it = TableVersions.find(tableId);
-            if (it != TableVersions.end()) {
-                Y_ENSURE(it->second == tableInfo.GetSchemaVersion());
-            } else {
-                TableVersions.emplace(tableId, tableInfo.GetSchemaVersion());
-            }
-        }
-    }
-
-    void FillTables(const NKqpProto::TKqpPhyTx& phyTx) {
-        for (const auto& stage : phyTx.GetStages()) {
-            for (const auto& tableOp : stage.GetTableOps()) {
-                TTableId tableId(tableOp.GetTable().GetOwnerId(), tableOp.GetTable().GetTableId());
-                auto it = TableVersions.find(tableId);
-                if (it != TableVersions.end()) {
-                    Y_ENSURE(it->second == tableOp.GetTable().GetVersion());
-                } else {
-                    TableVersions.emplace(tableId, tableOp.GetTable().GetVersion());
-                }
-            }
-        }
-    }
-
-    bool NavigateTables(const NKikimrKqp::TPreparedQuery& query, const TString& database, const TActorContext& ctx) {
-        TableVersions.clear();
-
-        switch (query.GetVersion()) {
-            case NKikimrKqp::TPreparedQuery::VERSION_V1:
-                for (const auto& kql : query.GetKqls()) {
-                    FillTables(kql);
-                }
-                break;
-
-            case NKikimrKqp::TPreparedQuery::VERSION_PHYSICAL_V1:
-                for (const auto& tx : query.GetPhysicalQuery().GetTransactions()) {
-                    FillTables(tx);
-                }
-                break;
-
-            default:
-                LOG_ERROR_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST,
-                    "Unexpected prepared query version"
-                    << ", self: " << ctx.SelfID
-                    << ", version: " << (ui32)query.GetVersion());
-                return false;
-        }
-
-        if (TableVersions.empty()) {
-            return false;
-        }
-
-        auto navigate = MakeHolder<TSchemeCacheNavigate>();
-        navigate->DatabaseName = database;
-        if (!UserToken.empty()) {
-            navigate->UserToken = new NACLib::TUserToken(UserToken);
-        }
-
-        for (const auto& [tableId, _] : TableVersions) {
-            TSchemeCacheNavigate::TEntry entry;
-            entry.TableId = tableId;
-            entry.RequestType = TSchemeCacheNavigate::TEntry::ERequestType::ByTableId;
-            entry.Operation = TSchemeCacheNavigate::EOp::OpTable;
-            entry.SyncVersion = false;
+ 
+        DeferredResponse.Reset(); 
+    } 
+ 
+    void HandleTimeout(const TActorContext& ctx) { 
+        LOG_NOTICE_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Compile request deadline exceeded" 
+            << ", self: " << ctx.SelfID); 
+ 
+        NYql::TIssue issue(NYql::TPosition(), "Deadline exceeded during query compilation."); 
+        return ReplyError(Ydb::StatusIds::TIMEOUT, {issue}, ctx); 
+    } 
+ 
+    void Die(const NActors::TActorContext& ctx) override { 
+        if (TimeoutTimerId) { 
+            ctx.Send(TimeoutTimerId, new TEvents::TEvPoisonPill()); 
+        } 
+ 
+        TBase::Die(ctx); 
+    } 
+ 
+private: 
+    STFUNC(MainState) { 
+        try { 
+            switch (ev->GetTypeRewrite()) { 
+                HFunc(TEvKqp::TEvCompileResponse, Handle); 
+                HFunc(TEvTxProxySchemeCache::TEvNavigateKeySetResult, Handle); 
+                CFunc(TEvents::TSystem::Wakeup, HandleTimeout); 
+            default: 
+                UnexpectedEvent("MainState", ev->GetTypeRewrite(), ctx); 
+            } 
+        } catch (const yexception& e) { 
+            InternalError(e.what(), ctx); 
+        } 
+    } 
+ 
+private: 
+    void FillTables(const NKikimrKqp::TPreparedKql& kql) { 
+        for (const auto& tableInfo : kql.GetTableInfo()) { 
+            TTableId tableId(tableInfo.GetTableId().GetOwnerId(), tableInfo.GetTableId().GetTableId()); 
+            auto it = TableVersions.find(tableId); 
+            if (it != TableVersions.end()) { 
+                Y_ENSURE(it->second == tableInfo.GetSchemaVersion()); 
+            } else { 
+                TableVersions.emplace(tableId, tableInfo.GetSchemaVersion()); 
+            } 
+        } 
+    } 
+ 
+    void FillTables(const NKqpProto::TKqpPhyTx& phyTx) { 
+        for (const auto& stage : phyTx.GetStages()) { 
+            for (const auto& tableOp : stage.GetTableOps()) { 
+                TTableId tableId(tableOp.GetTable().GetOwnerId(), tableOp.GetTable().GetTableId()); 
+                auto it = TableVersions.find(tableId); 
+                if (it != TableVersions.end()) { 
+                    Y_ENSURE(it->second == tableOp.GetTable().GetVersion()); 
+                } else { 
+                    TableVersions.emplace(tableId, tableOp.GetTable().GetVersion()); 
+                } 
+            } 
+        } 
+    } 
+ 
+    bool NavigateTables(const NKikimrKqp::TPreparedQuery& query, const TString& database, const TActorContext& ctx) { 
+        TableVersions.clear(); 
+ 
+        switch (query.GetVersion()) { 
+            case NKikimrKqp::TPreparedQuery::VERSION_V1: 
+                for (const auto& kql : query.GetKqls()) { 
+                    FillTables(kql); 
+                } 
+                break; 
+ 
+            case NKikimrKqp::TPreparedQuery::VERSION_PHYSICAL_V1: 
+                for (const auto& tx : query.GetPhysicalQuery().GetTransactions()) { 
+                    FillTables(tx); 
+                } 
+                break; 
+ 
+            default: 
+                LOG_ERROR_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, 
+                    "Unexpected prepared query version" 
+                    << ", self: " << ctx.SelfID 
+                    << ", version: " << (ui32)query.GetVersion()); 
+                return false; 
+        } 
+ 
+        if (TableVersions.empty()) { 
+            return false; 
+        } 
+ 
+        auto navigate = MakeHolder<TSchemeCacheNavigate>(); 
+        navigate->DatabaseName = database; 
+        if (!UserToken.empty()) { 
+            navigate->UserToken = new NACLib::TUserToken(UserToken); 
+        } 
+ 
+        for (const auto& [tableId, _] : TableVersions) { 
+            TSchemeCacheNavigate::TEntry entry; 
+            entry.TableId = tableId; 
+            entry.RequestType = TSchemeCacheNavigate::TEntry::ERequestType::ByTableId; 
+            entry.Operation = TSchemeCacheNavigate::EOp::OpTable; 
+            entry.SyncVersion = false; 
             entry.ShowPrivatePath = true;
-
-            navigate->ResultSet.emplace_back(entry);
-        }
-
-        auto ev = MakeHolder<TEvTxProxySchemeCache::TEvNavigateKeySet>(navigate.Release());
-        ctx.Send(MakeSchemeCacheID(), ev.Release());
-        return true;
-    }
-
-    bool ValidateTables(const TEvTxProxySchemeCache::TEvNavigateKeySetResult& response, const TActorContext& ctx) {
-        Y_ENSURE(response.Request);
-        const auto& navigate = *response.Request;
-
-        for (const auto& entry : navigate.ResultSet) {
-            switch (entry.Status) {
-                case TSchemeCacheNavigate::EStatus::Ok: {
-                    auto expectedVersion = TableVersions.FindPtr(TTableId(entry.TableId.PathId));
-                    if (!expectedVersion) {
-                        LOG_WARN_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST,
-                            "Unexpected tableId in scheme cache navigate reply"
-                            << ", self: " << ctx.SelfID
-                            << ", tableId: " << entry.TableId);
-                        continue;
-                    }
-
-                    if (!*expectedVersion) {
-                        // Do not check tables with zero version.
-                        continue;
-                    }
-
-                    if (entry.TableId.SchemaVersion && entry.TableId.SchemaVersion != *expectedVersion) {
-                        LOG_INFO_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Scheme version mismatch"
-                            << ", self: " << ctx.SelfID
-                            << ", pathId: " << entry.TableId.PathId
-                            << ", expected version: " << *expectedVersion
-                            << ", actual version: " << entry.TableId.SchemaVersion);
-                        return false;
-                    }
-
-                    break;
-                }
-
-                case TSchemeCacheNavigate::EStatus::PathErrorUnknown:
-                case TSchemeCacheNavigate::EStatus::PathNotTable:
-                case TSchemeCacheNavigate::EStatus::TableCreationNotComplete:
-                    LOG_INFO_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Scheme error"
-                        << ", self: " << ctx.SelfID
-                        << ", pathId: " << entry.TableId.PathId
-                        << ", status: " << entry.Status);
-                    return false;
-
-                case TSchemeCacheNavigate::EStatus::LookupError:
-                case TSchemeCacheNavigate::EStatus::RedirectLookupError:
-                    // Transient error, do not invalidate the query.
-                    // Hard validation will be performed later during the query execution.
-                    break;
-
-                default:
-                    // Unexpected reply, do not invalidate the query as it may block the query execution.
-                    // Hard validation will be performed later during the query execution.
-                    LOG_ERROR_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Unexpected reply from scheme cache"
-                        << ", self: " << ctx.SelfID
-                        << ", pathId: " << entry.TableId.PathId
-                        << ", status: " << entry.Status);
-                    break;
-            }
-        }
-
-        return true;
-    }
-
-private:
-    void UnexpectedEvent(const TString& state, ui32 eventType, const TActorContext &ctx) {
-        InternalError(TStringBuilder() << "TKqpCompileRequestActor, unexpected event: " << eventType
-            << ", at state:" << state, ctx);
-    }
-
+ 
+            navigate->ResultSet.emplace_back(entry); 
+        } 
+ 
+        auto ev = MakeHolder<TEvTxProxySchemeCache::TEvNavigateKeySet>(navigate.Release()); 
+        ctx.Send(MakeSchemeCacheID(), ev.Release()); 
+        return true; 
+    } 
+ 
+    bool ValidateTables(const TEvTxProxySchemeCache::TEvNavigateKeySetResult& response, const TActorContext& ctx) { 
+        Y_ENSURE(response.Request); 
+        const auto& navigate = *response.Request; 
+ 
+        for (const auto& entry : navigate.ResultSet) { 
+            switch (entry.Status) { 
+                case TSchemeCacheNavigate::EStatus::Ok: { 
+                    auto expectedVersion = TableVersions.FindPtr(TTableId(entry.TableId.PathId)); 
+                    if (!expectedVersion) { 
+                        LOG_WARN_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, 
+                            "Unexpected tableId in scheme cache navigate reply" 
+                            << ", self: " << ctx.SelfID 
+                            << ", tableId: " << entry.TableId); 
+                        continue; 
+                    } 
+ 
+                    if (!*expectedVersion) { 
+                        // Do not check tables with zero version. 
+                        continue; 
+                    } 
+ 
+                    if (entry.TableId.SchemaVersion && entry.TableId.SchemaVersion != *expectedVersion) { 
+                        LOG_INFO_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Scheme version mismatch" 
+                            << ", self: " << ctx.SelfID 
+                            << ", pathId: " << entry.TableId.PathId 
+                            << ", expected version: " << *expectedVersion 
+                            << ", actual version: " << entry.TableId.SchemaVersion); 
+                        return false; 
+                    } 
+ 
+                    break; 
+                } 
+ 
+                case TSchemeCacheNavigate::EStatus::PathErrorUnknown: 
+                case TSchemeCacheNavigate::EStatus::PathNotTable: 
+                case TSchemeCacheNavigate::EStatus::TableCreationNotComplete: 
+                    LOG_INFO_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Scheme error" 
+                        << ", self: " << ctx.SelfID 
+                        << ", pathId: " << entry.TableId.PathId 
+                        << ", status: " << entry.Status); 
+                    return false; 
+ 
+                case TSchemeCacheNavigate::EStatus::LookupError: 
+                case TSchemeCacheNavigate::EStatus::RedirectLookupError: 
+                    // Transient error, do not invalidate the query. 
+                    // Hard validation will be performed later during the query execution. 
+                    break; 
+ 
+                default: 
+                    // Unexpected reply, do not invalidate the query as it may block the query execution. 
+                    // Hard validation will be performed later during the query execution. 
+                    LOG_ERROR_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Unexpected reply from scheme cache" 
+                        << ", self: " << ctx.SelfID 
+                        << ", pathId: " << entry.TableId.PathId 
+                        << ", status: " << entry.Status); 
+                    break; 
+            } 
+        } 
+ 
+        return true; 
+    } 
+ 
+private: 
+    void UnexpectedEvent(const TString& state, ui32 eventType, const TActorContext &ctx) { 
+        InternalError(TStringBuilder() << "TKqpCompileRequestActor, unexpected event: " << eventType 
+            << ", at state:" << state, ctx); 
+    } 
+ 
     void InternalError(const TString& message, const TActorContext &ctx) {
-        LOG_ERROR_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Internal error"
-            << ", self: " << ctx.SelfID
-            << ", message: " << message);
-
-
-        NYql::TIssue issue(NYql::TPosition(), "Internal error while proccessing query compilation request.");
-        issue.AddSubIssue(MakeIntrusive<TIssue>(NYql::TPosition(), message));
-
-        ReplyError(Ydb::StatusIds::INTERNAL_ERROR, {issue}, ctx);
-    }
-
-    void ReplyError(Ydb::StatusIds::StatusCode status, const TIssues& issues, const TActorContext& ctx) {
-        auto responseEv = MakeHolder<TEvKqp::TEvCompileResponse>(TKqpCompileResult::Make({}, status, issues));
-        ctx.Send(Owner, responseEv.Release());
-        Die(ctx);
-    }
-
-private:
-    TActorId Owner;
-    TString UserToken;
-    TMaybe<TString> Uid;
-    TMaybe<TKqpQueryId> Query;
-    bool KeepInCache = false;
-    TInstant Deadline;
+        LOG_ERROR_S(ctx, NKikimrServices::KQP_COMPILE_REQUEST, "Internal error" 
+            << ", self: " << ctx.SelfID 
+            << ", message: " << message); 
+ 
+ 
+        NYql::TIssue issue(NYql::TPosition(), "Internal error while proccessing query compilation request."); 
+        issue.AddSubIssue(MakeIntrusive<TIssue>(NYql::TPosition(), message)); 
+ 
+        ReplyError(Ydb::StatusIds::INTERNAL_ERROR, {issue}, ctx); 
+    } 
+ 
+    void ReplyError(Ydb::StatusIds::StatusCode status, const TIssues& issues, const TActorContext& ctx) { 
+        auto responseEv = MakeHolder<TEvKqp::TEvCompileResponse>(TKqpCompileResult::Make({}, status, issues)); 
+        ctx.Send(Owner, responseEv.Release()); 
+        Die(ctx); 
+    } 
+ 
+private: 
+    TActorId Owner; 
+    TString UserToken; 
+    TMaybe<TString> Uid; 
+    TMaybe<TKqpQueryId> Query; 
+    bool KeepInCache = false; 
+    TInstant Deadline; 
     TKqpDbCountersPtr DbCounters;
-    TActorId TimeoutTimerId;
-    THashMap<TTableId, ui64> TableVersions;
-    THolder<TEvKqp::TEvCompileResponse> DeferredResponse;
-};
-
-
-IActor* CreateKqpCompileRequestActor(const TActorId& owner, const TString& userToken, const TMaybe<TString>& uid,
+    TActorId TimeoutTimerId; 
+    THashMap<TTableId, ui64> TableVersions; 
+    THolder<TEvKqp::TEvCompileResponse> DeferredResponse; 
+}; 
+ 
+ 
+IActor* CreateKqpCompileRequestActor(const TActorId& owner, const TString& userToken, const TMaybe<TString>& uid, 
     TMaybe<TKqpQueryId>&& query, bool keepInCache, const TInstant& deadline, TKqpDbCountersPtr dbCounters)
-{
+{ 
     return new TKqpCompileRequestActor(owner, userToken, uid, std::move(query), keepInCache, deadline, dbCounters);
-}
-
-} // namespace NKqp
-} // namespace NKikimr
+} 
+ 
+} // namespace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/kqp_compile_service.cpp b/ydb/core/kqp/kqp_compile_service.cpp
index da886224a2..4b2dd4d264 100644
--- a/ydb/core/kqp/kqp_compile_service.cpp
+++ b/ydb/core/kqp/kqp_compile_service.cpp
@@ -1,83 +1,83 @@
-#include "kqp_impl.h"
+#include "kqp_impl.h" 
 #include "kqp_query_replay.h"
-
+ 
 #include <ydb/core/actorlib_impl/long_timer.h>
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/cms/console/console.h>
 #include <ydb/core/cms/console/configs_dispatcher.h>
 #include <ydb/core/kqp/counters/kqp_counters.h>
 #include <ydb/library/aclib/aclib.h>
-
+ 
 #include <library/cpp/actors/core/actor_bootstrapped.h>
 #include <library/cpp/actors/core/hfunc.h>
 #include <library/cpp/cache/cache.h>
-
-#include <util/string/escape.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NKikimrConfig;
-using namespace NYql;
-
-
-class TKqpQueryCache {
-public:
+ 
+#include <util/string/escape.h> 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NKikimrConfig; 
+using namespace NYql; 
+ 
+
+class TKqpQueryCache { 
+public: 
     TKqpQueryCache(size_t size, TDuration ttl)
         : List(size)
         , Ttl(ttl) {}
-
-    bool Insert(const TKqpCompileResult::TConstPtr& compileResult) {
-        Y_ENSURE(compileResult->Query);
-        auto& query = *compileResult->Query;
-
-        auto queryIt = QueryIndex.emplace(query, compileResult->Uid);
-        Y_ENSURE(queryIt.second);
-
+ 
+    bool Insert(const TKqpCompileResult::TConstPtr& compileResult) { 
+        Y_ENSURE(compileResult->Query); 
+        auto& query = *compileResult->Query; 
+ 
+        auto queryIt = QueryIndex.emplace(query, compileResult->Uid); 
+        Y_ENSURE(queryIt.second); 
+ 
         auto it = Index.emplace(compileResult->Uid, TCacheEntry{compileResult,
                                     TAppData::TimeProvider->Now() + Ttl});
-        Y_VERIFY(it.second);
-
-        TItem* item = &const_cast<TItem&>(*it.first);
-        auto removedItem = List.Insert(item);
-
+        Y_VERIFY(it.second); 
+ 
+        TItem* item = &const_cast<TItem&>(*it.first); 
+        auto removedItem = List.Insert(item); 
+ 
         IncBytes(item->Value.CompileResult->PreparedQuery->ByteSize());
         if (item->Value.CompileResult->PreparedQueryNewEngine) {
             IncBytes(item->Value.CompileResult->PreparedQueryNewEngine->ByteSize());
         }
-
-        if (removedItem) {
+ 
+        if (removedItem) { 
             DecBytes(removedItem->Value.CompileResult->PreparedQuery->ByteSize());
-
+ 
             if (removedItem->Value.CompileResult->PreparedQueryNewEngine) {
                 DecBytes(removedItem->Value.CompileResult->PreparedQueryNewEngine->ByteSize());
             }
 
             QueryIndex.erase(*removedItem->Value.CompileResult->Query);
-            Index.erase(removedItem->Key);
-        }
-
-        Y_VERIFY(List.GetSize() == Index.size());
-        Y_VERIFY(List.GetSize() == QueryIndex.size());
-
-        return removedItem != nullptr;
-    }
-
-    TKqpCompileResult::TConstPtr FindByUid(const TString& uid, bool promote) {
-        auto it = Index.find(TItem(uid));
-        if (it != Index.end()) {
-            TItem* item = &const_cast<TItem&>(*it);
-            if (promote) {
+            Index.erase(removedItem->Key); 
+        } 
+ 
+        Y_VERIFY(List.GetSize() == Index.size()); 
+        Y_VERIFY(List.GetSize() == QueryIndex.size()); 
+ 
+        return removedItem != nullptr; 
+    } 
+ 
+    TKqpCompileResult::TConstPtr FindByUid(const TString& uid, bool promote) { 
+        auto it = Index.find(TItem(uid)); 
+        if (it != Index.end()) { 
+            TItem* item = &const_cast<TItem&>(*it); 
+            if (promote) { 
                 item->Value.ExpiredAt = TAppData::TimeProvider->Now() + Ttl;
-                List.Promote(item);
-            }
-
+                List.Promote(item); 
+            } 
+ 
             return item->Value.CompileResult;
-        }
-
-        return nullptr;
-    }
-
+        } 
+ 
+        return nullptr; 
+    } 
+ 
     void Replace(const TKqpCompileResult::TConstPtr& compileResult) {
         auto it = Index.find(TItem(compileResult->Uid));
         if (it != Index.end()) {
@@ -86,48 +86,48 @@ public:
         }
     }
 
-    TKqpCompileResult::TConstPtr FindByQuery(const TKqpQueryId& query, bool promote) {
-        auto uid = QueryIndex.FindPtr(query);
-        if (!uid) {
-            return nullptr;
-        }
-
-        return FindByUid(*uid, promote);
-    }
-
-    bool EraseByUid(const TString& uid) {
-        auto it = Index.find(TItem(uid));
-        if (it == Index.end()) {
-            return false;
-        }
-
-        TItem* item = &const_cast<TItem&>(*it);
-        List.Erase(item);
-
+    TKqpCompileResult::TConstPtr FindByQuery(const TKqpQueryId& query, bool promote) { 
+        auto uid = QueryIndex.FindPtr(query); 
+        if (!uid) { 
+            return nullptr; 
+        } 
+ 
+        return FindByUid(*uid, promote); 
+    } 
+ 
+    bool EraseByUid(const TString& uid) { 
+        auto it = Index.find(TItem(uid)); 
+        if (it == Index.end()) { 
+            return false; 
+        } 
+ 
+        TItem* item = &const_cast<TItem&>(*it); 
+        List.Erase(item); 
+ 
         DecBytes(item->Value.CompileResult->PreparedQuery->ByteSize());
         if (item->Value.CompileResult->PreparedQueryNewEngine) {
             DecBytes(item->Value.CompileResult->PreparedQueryNewEngine->ByteSize());
         }
-
+ 
         Y_VERIFY(item->Value.CompileResult);
         Y_VERIFY(item->Value.CompileResult->Query);
         QueryIndex.erase(*item->Value.CompileResult->Query);
-
-        Index.erase(it);
-
-        Y_VERIFY(List.GetSize() == Index.size());
-        Y_VERIFY(List.GetSize() == QueryIndex.size());
-        return true;
-    }
-
-    size_t Size() const {
-        return Index.size();
-    }
-
-    ui64 Bytes() const {
-        return ByteSize;
-    }
-
+ 
+        Index.erase(it); 
+ 
+        Y_VERIFY(List.GetSize() == Index.size()); 
+        Y_VERIFY(List.GetSize() == QueryIndex.size()); 
+        return true; 
+    } 
+ 
+    size_t Size() const { 
+        return Index.size(); 
+    } 
+ 
+    ui64 Bytes() const { 
+        return ByteSize; 
+    } 
+ 
     size_t EraseExpiredQueries() {
         auto prevSize = Size();
 
@@ -148,171 +148,171 @@ public:
         ByteSize = 0;
     }
 
-private:
-    void DecBytes(ui64 bytes) {
-        if (bytes > ByteSize) {
-            ByteSize = 0;
-        } else {
-            ByteSize -= bytes;
-        }
-    }
-
-    void IncBytes(ui64 bytes) {
-        ByteSize += bytes;
-    }
-
-private:
+private: 
+    void DecBytes(ui64 bytes) { 
+        if (bytes > ByteSize) { 
+            ByteSize = 0; 
+        } else { 
+            ByteSize -= bytes; 
+        } 
+    } 
+ 
+    void IncBytes(ui64 bytes) { 
+        ByteSize += bytes; 
+    } 
+ 
+private: 
     struct TCacheEntry {
         TKqpCompileResult::TConstPtr CompileResult;
         TInstant ExpiredAt;
     };
 
     using TList = TLRUList<TString, TCacheEntry>;
-    using TItem = TList::TItem;
-
-private:
-    TList List;
-    THashSet<TItem, TItem::THash> Index;
-    THashMap<TKqpQueryId, TString, THash<TKqpQueryId>> QueryIndex;
-    ui64 ByteSize = 0;
+    using TItem = TList::TItem; 
+ 
+private: 
+    TList List; 
+    THashSet<TItem, TItem::THash> Index; 
+    THashMap<TKqpQueryId, TString, THash<TKqpQueryId>> QueryIndex; 
+    ui64 ByteSize = 0; 
     TDuration Ttl;
-};
-
-struct TKqpCompileRequest {
+}; 
+ 
+struct TKqpCompileRequest { 
     TKqpCompileRequest(const TActorId& sender, const TString& uid, TKqpQueryId query, bool keepInCache,
         const TString& userToken, const TInstant& deadline, TKqpDbCountersPtr dbCounters)
-        : Sender(sender)
-        , Query(std::move(query))
+        : Sender(sender) 
+        , Query(std::move(query)) 
         , Uid(uid)
-        , KeepInCache(keepInCache)
-        , UserToken(userToken)
+        , KeepInCache(keepInCache) 
+        , UserToken(userToken) 
         , Deadline(deadline)
         , DbCounters(dbCounters) {}
-
+ 
     TActorId Sender;
-    TKqpQueryId Query;
+    TKqpQueryId Query; 
     TString Uid;
-    bool KeepInCache = false;
-    TString UserToken;
-    TInstant Deadline;
+    bool KeepInCache = false; 
+    TString UserToken; 
+    TInstant Deadline; 
     TKqpDbCountersPtr DbCounters;
     TActorId CompileActor;
-};
-
-class TKqpRequestsQueue {
-    using TRequestsList = TList<TKqpCompileRequest>;
-    using TRequestsIterator = TRequestsList::iterator;
-
-    struct TRequestsIteratorHash {
-        inline size_t operator()(const TRequestsIterator& iterator) const {
-            return THash<TKqpCompileRequest*>()(&*iterator);
-        }
-    };
-
-    using TRequestsIteratorSet = THashSet<TRequestsIterator, TRequestsIteratorHash>;
-
-public:
-    TKqpRequestsQueue(size_t maxSize)
-        : MaxSize(maxSize) {}
-
-    bool Enqueue(TKqpCompileRequest&& request) {
-        if (Size() >= MaxSize) {
-            return false;
-        }
-
-        Queue.push_back(std::move(request));
-        auto it = std::prev(Queue.end());
-        QueryIndex[it->Query].insert(it);
-        return true;
-    }
-
-    TMaybe<TKqpCompileRequest> Dequeue() {
-        for (auto it = Queue.begin(); it != Queue.end(); ++it) {
-            auto& request = *it;
-            if (!ActiveRequests.contains(request.Query)) {
-                auto result = std::move(request);
-
-                QueryIndex[result.Query].erase(it);
-                Queue.erase(it);
-
-                return result;
-            }
-        }
-
-        return {};
-    }
-
-    TVector<TKqpCompileRequest> ExtractByQuery(const TKqpQueryId& query) {
-        auto queryIt = QueryIndex.find(query);
-        if (queryIt == QueryIndex.end()) {
-            return {};
-        }
-
-        TVector<TKqpCompileRequest> result;
-        for (auto& requestIt : queryIt->second) {
-            Y_ENSURE(requestIt != Queue.end());
-            auto request = std::move(*requestIt);
-
-            Queue.erase(requestIt);
-
-            result.push_back(std::move(request));
-        }
-
-        QueryIndex.erase(queryIt);
-        return result;
-    }
-
-    size_t Size() const {
-        return Queue.size();
-    }
-
-    TKqpCompileRequest FinishActiveRequest(const TKqpQueryId& query) {
-        auto it = ActiveRequests.find(query);
-        Y_ENSURE(it != ActiveRequests.end());
-
-        auto request = std::move(it->second);
-        ActiveRequests.erase(it);
-
-        return request;
-    }
-
-    size_t ActiveRequestsCount() const {
-        return ActiveRequests.size();
-    }
-
-    void AddActiveRequest(TKqpCompileRequest&& request) {
-        auto result = ActiveRequests.emplace(request.Query, std::move(request));
-        Y_ENSURE(result.second);
-    }
-
-private:
-    size_t MaxSize = 0;
-    TRequestsList Queue;
-    THashMap<TKqpQueryId, TRequestsIteratorSet, THash<TKqpQueryId>> QueryIndex;
-    THashMap<TKqpQueryId, TKqpCompileRequest> ActiveRequests;
-};
-
-class TKqpCompileService : public TActorBootstrapped<TKqpCompileService> {
-public:
-    static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
-        return NKikimrServices::TActivity::KQP_COMPILE_SERVICE;
-    }
-
-    TKqpCompileService(const TTableServiceConfig& serviceConfig, const TKqpSettings::TConstPtr& kqpSettings,
+}; 
+ 
+class TKqpRequestsQueue { 
+    using TRequestsList = TList<TKqpCompileRequest>; 
+    using TRequestsIterator = TRequestsList::iterator; 
+ 
+    struct TRequestsIteratorHash { 
+        inline size_t operator()(const TRequestsIterator& iterator) const { 
+            return THash<TKqpCompileRequest*>()(&*iterator); 
+        } 
+    }; 
+ 
+    using TRequestsIteratorSet = THashSet<TRequestsIterator, TRequestsIteratorHash>; 
+ 
+public: 
+    TKqpRequestsQueue(size_t maxSize) 
+        : MaxSize(maxSize) {} 
+ 
+    bool Enqueue(TKqpCompileRequest&& request) { 
+        if (Size() >= MaxSize) { 
+            return false; 
+        } 
+ 
+        Queue.push_back(std::move(request)); 
+        auto it = std::prev(Queue.end()); 
+        QueryIndex[it->Query].insert(it); 
+        return true; 
+    } 
+ 
+    TMaybe<TKqpCompileRequest> Dequeue() { 
+        for (auto it = Queue.begin(); it != Queue.end(); ++it) { 
+            auto& request = *it; 
+            if (!ActiveRequests.contains(request.Query)) { 
+                auto result = std::move(request); 
+ 
+                QueryIndex[result.Query].erase(it); 
+                Queue.erase(it); 
+ 
+                return result; 
+            } 
+        } 
+ 
+        return {}; 
+    } 
+ 
+    TVector<TKqpCompileRequest> ExtractByQuery(const TKqpQueryId& query) { 
+        auto queryIt = QueryIndex.find(query); 
+        if (queryIt == QueryIndex.end()) { 
+            return {}; 
+        } 
+ 
+        TVector<TKqpCompileRequest> result; 
+        for (auto& requestIt : queryIt->second) { 
+            Y_ENSURE(requestIt != Queue.end()); 
+            auto request = std::move(*requestIt); 
+ 
+            Queue.erase(requestIt); 
+ 
+            result.push_back(std::move(request)); 
+        } 
+ 
+        QueryIndex.erase(queryIt); 
+        return result; 
+    } 
+ 
+    size_t Size() const { 
+        return Queue.size(); 
+    } 
+ 
+    TKqpCompileRequest FinishActiveRequest(const TKqpQueryId& query) { 
+        auto it = ActiveRequests.find(query); 
+        Y_ENSURE(it != ActiveRequests.end()); 
+ 
+        auto request = std::move(it->second); 
+        ActiveRequests.erase(it); 
+ 
+        return request; 
+    } 
+ 
+    size_t ActiveRequestsCount() const { 
+        return ActiveRequests.size(); 
+    } 
+ 
+    void AddActiveRequest(TKqpCompileRequest&& request) { 
+        auto result = ActiveRequests.emplace(request.Query, std::move(request)); 
+        Y_ENSURE(result.second); 
+    } 
+ 
+private: 
+    size_t MaxSize = 0; 
+    TRequestsList Queue; 
+    THashMap<TKqpQueryId, TRequestsIteratorSet, THash<TKqpQueryId>> QueryIndex; 
+    THashMap<TKqpQueryId, TKqpCompileRequest> ActiveRequests; 
+}; 
+ 
+class TKqpCompileService : public TActorBootstrapped<TKqpCompileService> { 
+public: 
+    static constexpr NKikimrServices::TActivity::EType ActorActivityType() { 
+        return NKikimrServices::TActivity::KQP_COMPILE_SERVICE; 
+    } 
+ 
+    TKqpCompileService(const TTableServiceConfig& serviceConfig, const TKqpSettings::TConstPtr& kqpSettings, 
         TIntrusivePtr<TModuleResolverState> moduleResolverState, TIntrusivePtr<TKqpCounters> counters,
         std::shared_ptr<IQueryReplayBackendFactory> queryReplayFactory)
-        : Config(serviceConfig)
-        , KqpSettings(kqpSettings)
-        , ModuleResolverState(moduleResolverState)
-        , Counters(counters)
+        : Config(serviceConfig) 
+        , KqpSettings(kqpSettings) 
+        , ModuleResolverState(moduleResolverState) 
+        , Counters(counters) 
         , QueryCache(Config.GetCompileQueryCacheSize(), TDuration::Seconds(Config.GetCompileQueryCacheTTLSec()))
         , RequestsQueue(Config.GetCompileRequestQueueSize())
         , QueryReplayFactory(std::move(queryReplayFactory))
     {}
-
-    void Bootstrap(const TActorContext& ctx) {
-        Y_UNUSED(ctx);
-
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        Y_UNUSED(ctx); 
+ 
         QueryReplayBackend.Reset(CreateQueryReplayBackend(Config, Counters, QueryReplayFactory));
         // Subscribe for TableService config changes
         ui32 tableServiceConfigKind = (ui32) NKikimrConsole::TConfigItem::TableServiceConfigItem;
@@ -320,18 +320,18 @@ public:
              new NConsole::TEvConfigsDispatcher::TEvSetConfigSubscriptionRequest({tableServiceConfigKind}),
              IEventHandle::FlagTrackDelivery);
 
-        Become(&TKqpCompileService::MainState);
+        Become(&TKqpCompileService::MainState); 
         if (Config.GetCompileQueryCacheTTLSec()) {
             StartCheckQueriesTtlTimer(ctx);
         }
-    }
-
-private:
-    STFUNC(MainState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TEvKqp::TEvCompileRequest, Handle);
-            HFunc(TEvKqp::TEvCompileResponse, Handle);
-            HFunc(TEvKqp::TEvCompileInvalidateRequest, Handle);
+    } 
+ 
+private: 
+    STFUNC(MainState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TEvKqp::TEvCompileRequest, Handle); 
+            HFunc(TEvKqp::TEvCompileResponse, Handle); 
+            HFunc(TEvKqp::TEvCompileInvalidateRequest, Handle); 
             HFunc(TEvKqp::TEvRecompileRequest, Handle);
 
             hFunc(NConsole::TEvConfigsDispatcher::TEvSetConfigSubscriptionResponse, HandleConfig);
@@ -340,12 +340,12 @@ private:
 
             CFunc(TEvents::TSystem::Wakeup, HandleTimeout);
             cFunc(TEvents::TEvPoison::EventType, PassAway);
-        default:
-            Y_FAIL("TKqpCompileService: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite());
-        }
-    }
-
-private:
+        default: 
+            Y_FAIL("TKqpCompileService: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite()); 
+        } 
+    } 
+ 
+private: 
     void HandleConfig(NConsole::TEvConfigsDispatcher::TEvSetConfigSubscriptionResponse::TPtr&) {
         LOG_INFO(*TlsActivationContext, NKikimrServices::KQP_COMPILE_SERVICE, "Subscribed for config changes");
     }
@@ -394,115 +394,115 @@ private:
         }
     }
 
-    void Handle(TEvKqp::TEvCompileRequest::TPtr& ev, const TActorContext& ctx) {
-        try {
-            PerformRequest(ev, ctx);
-        }
-        catch (const std::exception& e) {
-            LogException("TEvCompileRequest", ev->Sender, e, ctx);
-            ReplyInternalError(ev->Sender, "", e.what(), ctx);
-        }
-    }
-
-    void PerformRequest(TEvKqp::TEvCompileRequest::TPtr& ev, const TActorContext& ctx) {
-        auto& request = *ev->Get();
-
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Received compile request"
-            << ", sender: " << ev->Sender
-            << ", queryUid: " << (request.Uid ? *request.Uid : "<empty>")
-            << ", queryText: \"" << (request.Query ? EscapeC(request.Query->Text) : "<empty>") << "\""
-            << ", keepInCache: " << request.KeepInCache);
-
-        *Counters->CompileQueryCacheSize = QueryCache.Size();
-        *Counters->CompileQueryCacheBytes = QueryCache.Bytes();
-
-        auto userSid = NACLib::TUserToken(request.UserToken).GetUserSID();
+    void Handle(TEvKqp::TEvCompileRequest::TPtr& ev, const TActorContext& ctx) { 
+        try { 
+            PerformRequest(ev, ctx); 
+        } 
+        catch (const std::exception& e) { 
+            LogException("TEvCompileRequest", ev->Sender, e, ctx); 
+            ReplyInternalError(ev->Sender, "", e.what(), ctx); 
+        } 
+    } 
+ 
+    void PerformRequest(TEvKqp::TEvCompileRequest::TPtr& ev, const TActorContext& ctx) { 
+        auto& request = *ev->Get(); 
+ 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Received compile request" 
+            << ", sender: " << ev->Sender 
+            << ", queryUid: " << (request.Uid ? *request.Uid : "<empty>") 
+            << ", queryText: \"" << (request.Query ? EscapeC(request.Query->Text) : "<empty>") << "\"" 
+            << ", keepInCache: " << request.KeepInCache); 
+ 
+        *Counters->CompileQueryCacheSize = QueryCache.Size(); 
+        *Counters->CompileQueryCacheBytes = QueryCache.Bytes(); 
+ 
+        auto userSid = NACLib::TUserToken(request.UserToken).GetUserSID(); 
         auto dbCounters = request.DbCounters;
-
-        if (request.Uid) {
+ 
+        if (request.Uid) { 
             Counters->ReportCompileRequestGet(dbCounters);
-
-            auto compileResult = QueryCache.FindByUid(*request.Uid, request.KeepInCache);
-            if (compileResult) {
-                Y_ENSURE(compileResult->Query);
-                if (compileResult->Query->UserSid == userSid) {
+ 
+            auto compileResult = QueryCache.FindByUid(*request.Uid, request.KeepInCache); 
+            if (compileResult) { 
+                Y_ENSURE(compileResult->Query); 
+                if (compileResult->Query->UserSid == userSid) { 
                     Counters->ReportQueryCacheHit(dbCounters, true);
-
-                    LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Served query from cache by uid"
-                        << ", sender: " << ev->Sender
-                        << ", queryUid: " << *request.Uid);
-
-
-                    ReplyFromCache(ev->Sender, compileResult, ctx);
-                    return;
-                } else {
-                    LOG_NOTICE_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Non-matching user sid for query"
-                        << ", sender: " << ev->Sender
-                        << ", queryUid: " << *request.Uid
-                        << ", expected sid: " <<  compileResult->Query->UserSid
-                        << ", actual sid: " << userSid);
-                }
-            }
-
+ 
+                    LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Served query from cache by uid" 
+                        << ", sender: " << ev->Sender 
+                        << ", queryUid: " << *request.Uid); 
+ 
+ 
+                    ReplyFromCache(ev->Sender, compileResult, ctx); 
+                    return; 
+                } else { 
+                    LOG_NOTICE_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Non-matching user sid for query" 
+                        << ", sender: " << ev->Sender 
+                        << ", queryUid: " << *request.Uid 
+                        << ", expected sid: " <<  compileResult->Query->UserSid 
+                        << ", actual sid: " << userSid); 
+                } 
+            } 
+ 
             Counters->ReportQueryCacheHit(dbCounters, false);
-
-            LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Query not found"
-                << ", sender: " << ev->Sender
-                << ", queryUid: " << *request.Uid);
-
-            NYql::TIssue issue(NYql::TPosition(), TStringBuilder() << "Query not found: " << *request.Uid);
-            ReplyError(ev->Sender, *request.Uid, Ydb::StatusIds::NOT_FOUND, {issue}, ctx);
-            return;
-        }
-
+ 
+            LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Query not found" 
+                << ", sender: " << ev->Sender 
+                << ", queryUid: " << *request.Uid); 
+ 
+            NYql::TIssue issue(NYql::TPosition(), TStringBuilder() << "Query not found: " << *request.Uid); 
+            ReplyError(ev->Sender, *request.Uid, Ydb::StatusIds::NOT_FOUND, {issue}, ctx); 
+            return; 
+        } 
+ 
         Counters->ReportCompileRequestCompile(dbCounters);
-
-        Y_ENSURE(request.Query);
-        auto& query = *request.Query;
-
-        if (query.UserSid.empty()) {
-            query.UserSid = userSid;
-        } else {
-            Y_ENSURE(query.UserSid == userSid);
-        }
-
-        auto compileResult = QueryCache.FindByQuery(query, request.KeepInCache);
-        if (compileResult) {
+ 
+        Y_ENSURE(request.Query); 
+        auto& query = *request.Query; 
+ 
+        if (query.UserSid.empty()) { 
+            query.UserSid = userSid; 
+        } else { 
+            Y_ENSURE(query.UserSid == userSid); 
+        } 
+ 
+        auto compileResult = QueryCache.FindByQuery(query, request.KeepInCache); 
+        if (compileResult) { 
             Counters->ReportQueryCacheHit(dbCounters, true);
-
-            LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Served query from cache"
-                << ", sender: " << ev->Sender
-                << ", queryUid: " << compileResult->Uid);
-
-            ReplyFromCache(ev->Sender, compileResult, ctx);
-            return;
-        }
-
+ 
+            LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Served query from cache" 
+                << ", sender: " << ev->Sender 
+                << ", queryUid: " << compileResult->Uid); 
+ 
+            ReplyFromCache(ev->Sender, compileResult, ctx); 
+            return; 
+        } 
+ 
         Counters->ReportQueryCacheHit(dbCounters, false);
-
+ 
         TKqpCompileRequest compileRequest(ev->Sender, CreateGuidAsString(), std::move(*request.Query),
             request.KeepInCache, request.UserToken, request.Deadline, dbCounters);
-
-        if (!RequestsQueue.Enqueue(std::move(compileRequest))) {
+ 
+        if (!RequestsQueue.Enqueue(std::move(compileRequest))) { 
             Counters->ReportCompileRequestRejected(dbCounters);
-
-            LOG_WARN_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Requests queue size limit exceeded"
-                << ", sender: " << ev->Sender
-                << ", queueSize: " << RequestsQueue.Size());
-
-            NYql::TIssue issue(NYql::TPosition(), TStringBuilder() <<
-                "Exceeded maximum number of requests in compile service queue.");
-            ReplyError(ev->Sender, "", Ydb::StatusIds::OVERLOADED, {issue}, ctx);
-            return;
-        }
-
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Added request to queue"
-            << ", sender: " << ev->Sender
-            << ", queueSize: " << RequestsQueue.Size());
-
-        ProcessQueue(ctx);
-    }
-
+ 
+            LOG_WARN_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Requests queue size limit exceeded" 
+                << ", sender: " << ev->Sender 
+                << ", queueSize: " << RequestsQueue.Size()); 
+ 
+            NYql::TIssue issue(NYql::TPosition(), TStringBuilder() << 
+                "Exceeded maximum number of requests in compile service queue."); 
+            ReplyError(ev->Sender, "", Ydb::StatusIds::OVERLOADED, {issue}, ctx); 
+            return; 
+        } 
+ 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Added request to queue" 
+            << ", sender: " << ev->Sender 
+            << ", queueSize: " << RequestsQueue.Size()); 
+ 
+        ProcessQueue(ctx); 
+    } 
+ 
     void Handle(TEvKqp::TEvRecompileRequest::TPtr& ev, const TActorContext& ctx) {
         try {
             PerformRequest(ev, ctx);
@@ -558,79 +558,79 @@ private:
         ProcessQueue(ctx);
     }
 
-    void Handle(TEvKqp::TEvCompileResponse::TPtr& ev, const TActorContext& ctx) {
-        auto compileActorId = ev->Sender;
-        auto& compileResult = ev->Get()->CompileResult;
-        auto& compileStats = ev->Get()->Stats;
-
-        Y_VERIFY(compileResult->Query);
-
-        auto compileRequest = RequestsQueue.FinishActiveRequest(*compileResult->Query);
-        Y_VERIFY(compileRequest.CompileActor == compileActorId);
+    void Handle(TEvKqp::TEvCompileResponse::TPtr& ev, const TActorContext& ctx) { 
+        auto compileActorId = ev->Sender; 
+        auto& compileResult = ev->Get()->CompileResult; 
+        auto& compileStats = ev->Get()->Stats; 
+ 
+        Y_VERIFY(compileResult->Query); 
+ 
+        auto compileRequest = RequestsQueue.FinishActiveRequest(*compileResult->Query); 
+        Y_VERIFY(compileRequest.CompileActor == compileActorId); 
         Y_VERIFY(compileRequest.Uid == compileResult->Uid);
-
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Received response"
-            << ", sender: " << compileRequest.Sender
-            << ", status: " << compileResult->Status
-            << ", compileActor: " << ev->Sender);
-
-        try {
-            if (compileResult->Status == Ydb::StatusIds::SUCCESS) {
+ 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Received response" 
+            << ", sender: " << compileRequest.Sender 
+            << ", status: " << compileResult->Status 
+            << ", compileActor: " << ev->Sender); 
+ 
+        try { 
+            if (compileResult->Status == Ydb::StatusIds::SUCCESS) { 
                 if (QueryCache.FindByUid(compileResult->Uid, false)) {
                     QueryCache.Replace(compileResult);
                 } else if (compileRequest.KeepInCache) {
-                    if (QueryCache.Insert(compileResult)) {
-                        Counters->CompileQueryCacheEvicted->Inc();
-                    }
-                }
-
+                    if (QueryCache.Insert(compileResult)) { 
+                        Counters->CompileQueryCacheEvicted->Inc(); 
+                    } 
+                } 
+ 
                 if (ev->Get()->ReplayMessage) {
                     QueryReplayBackend->Collect(*ev->Get()->ReplayMessage);
                 }
 
-                auto requests = RequestsQueue.ExtractByQuery(*compileResult->Query);
-                for (auto& request : requests) {
-                    Reply(request.Sender, compileResult, compileStats, ctx);
-                }
+                auto requests = RequestsQueue.ExtractByQuery(*compileResult->Query); 
+                for (auto& request : requests) { 
+                    Reply(request.Sender, compileResult, compileStats, ctx); 
+                } 
             } else {
                 if (QueryCache.FindByUid(compileResult->Uid, false)) {
                     QueryCache.EraseByUid(compileResult->Uid);
                 }
-            }
-
-            Reply(compileRequest.Sender, compileResult, compileStats, ctx);
-        }
-        catch (const std::exception& e) {
-            LogException("TEvCompileResponse", ev->Sender, e, ctx);
-            ReplyInternalError(compileRequest.Sender, compileResult->Uid, e.what(), ctx);
-        }
-
-        ProcessQueue(ctx);
-    }
-
-    void Handle(TEvKqp::TEvCompileInvalidateRequest::TPtr& ev, const TActorContext& ctx) {
-        try {
-            PerformRequest(ev, ctx);
-        }
-        catch (const std::exception& e) {
-            LogException("TEvCompileInvalidateRequest", ev->Sender, e, ctx);
-        }
-    }
-
-    void PerformRequest(TEvKqp::TEvCompileInvalidateRequest::TPtr& ev, const TActorContext& ctx) {
-        Y_UNUSED(ctx);
-        auto& request = *ev->Get();
-
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Received invalidate request"
-            << ", sender: " << ev->Sender
+            } 
+ 
+            Reply(compileRequest.Sender, compileResult, compileStats, ctx); 
+        } 
+        catch (const std::exception& e) { 
+            LogException("TEvCompileResponse", ev->Sender, e, ctx); 
+            ReplyInternalError(compileRequest.Sender, compileResult->Uid, e.what(), ctx); 
+        } 
+ 
+        ProcessQueue(ctx); 
+    } 
+ 
+    void Handle(TEvKqp::TEvCompileInvalidateRequest::TPtr& ev, const TActorContext& ctx) { 
+        try { 
+            PerformRequest(ev, ctx); 
+        } 
+        catch (const std::exception& e) { 
+            LogException("TEvCompileInvalidateRequest", ev->Sender, e, ctx); 
+        } 
+    } 
+ 
+    void PerformRequest(TEvKqp::TEvCompileInvalidateRequest::TPtr& ev, const TActorContext& ctx) { 
+        Y_UNUSED(ctx); 
+        auto& request = *ev->Get(); 
+ 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Received invalidate request" 
+            << ", sender: " << ev->Sender 
             << ", queryUid: " << request.Uid);
-
+ 
         auto dbCounters = request.DbCounters;
         Counters->ReportCompileRequestInvalidate(dbCounters);
-
-        QueryCache.EraseByUid(request.Uid);
-    }
-
+ 
+        QueryCache.EraseByUid(request.Uid); 
+    } 
+ 
     void HandleTimeout(const TActorContext& ctx) {
         LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Received check queries TTL timeout");
 
@@ -642,127 +642,127 @@ private:
         StartCheckQueriesTtlTimer(ctx);
     }
 
-private:
-    void ProcessQueue(const TActorContext& ctx) {
-        auto maxActiveRequests = Config.GetCompileMaxActiveRequests();
-
-        while (RequestsQueue.ActiveRequestsCount() < maxActiveRequests) {
-            auto request = RequestsQueue.Dequeue();
-            if (!request) {
-                break;
-            }
-
+private: 
+    void ProcessQueue(const TActorContext& ctx) { 
+        auto maxActiveRequests = Config.GetCompileMaxActiveRequests(); 
+ 
+        while (RequestsQueue.ActiveRequestsCount() < maxActiveRequests) { 
+            auto request = RequestsQueue.Dequeue(); 
+            if (!request) { 
+                break; 
+            } 
+ 
             if (request->Deadline && request->Deadline < TAppData::TimeProvider->Now()) {
-                LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Compilation timed out"
-                    << ", sender: " << request->Sender
-                    << ", deadline: " << request->Deadline);
-
+                LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Compilation timed out" 
+                    << ", sender: " << request->Sender 
+                    << ", deadline: " << request->Deadline); 
+ 
                 Counters->ReportCompileRequestTimeout(request->DbCounters);
-
+ 
                 NYql::TIssue issue(NYql::TPosition(), "Compilation timed out.");
-                ReplyError(request->Sender, "", Ydb::StatusIds::TIMEOUT, {issue}, ctx);
-            } else {
-                StartCompilation(std::move(*request), ctx);
-            }
-        }
-
-        *Counters->CompileQueueSize = RequestsQueue.Size();
-    }
-
-    void StartCompilation(TKqpCompileRequest&& request, const TActorContext& ctx) {
+                ReplyError(request->Sender, "", Ydb::StatusIds::TIMEOUT, {issue}, ctx); 
+            } else { 
+                StartCompilation(std::move(*request), ctx); 
+            } 
+        } 
+ 
+        *Counters->CompileQueueSize = RequestsQueue.Size(); 
+    } 
+ 
+    void StartCompilation(TKqpCompileRequest&& request, const TActorContext& ctx) { 
         bool recompileWithNewEngine = Config.GetForceNewEnginePercent() > 0;
 
-        auto compileActor = CreateKqpCompileActor(ctx.SelfID, KqpSettings, Config, ModuleResolverState, Counters,
+        auto compileActor = CreateKqpCompileActor(ctx.SelfID, KqpSettings, Config, ModuleResolverState, Counters, 
             request.Uid, request.Query, request.UserToken, request.DbCounters, recompileWithNewEngine);
-        auto compileActorId = ctx.ExecutorThread.RegisterActor(compileActor, TMailboxType::HTSwap,
-            AppData(ctx)->UserPoolId);
-
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Created compile actor"
-            << ", sender: " << request.Sender
+        auto compileActorId = ctx.ExecutorThread.RegisterActor(compileActor, TMailboxType::HTSwap, 
+            AppData(ctx)->UserPoolId); 
+ 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Created compile actor" 
+            << ", sender: " << request.Sender 
             << ", compileActor: " << compileActorId
             << ", recompileWithNewEngine: " << recompileWithNewEngine);
-
-        request.CompileActor = compileActorId;
-        RequestsQueue.AddActiveRequest(std::move(request));
-    }
-
+ 
+        request.CompileActor = compileActorId; 
+        RequestsQueue.AddActiveRequest(std::move(request)); 
+    } 
+ 
     void StartCheckQueriesTtlTimer(const TActorContext& ctx) {
         CheckQueriesTtlTimer = CreateLongTimer(ctx, TDuration::Seconds(Config.GetCompileQueryCacheTTLSec()),
             new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
     }
 
     void Reply(const TActorId& sender, const TKqpCompileResult::TConstPtr& compileResult,
-        const NKqpProto::TKqpStatsCompile& compileStats, const TActorContext& ctx)
-    {
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Send response"
-            << ", sender: " << sender
-            << ", queryUid: " << compileResult->Uid
-            << ", status:" << compileResult->Status);
-
-        auto responseEv = MakeHolder<TEvKqp::TEvCompileResponse>(compileResult);
-        responseEv->Stats.CopyFrom(compileStats);
+        const NKqpProto::TKqpStatsCompile& compileStats, const TActorContext& ctx) 
+    { 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Send response" 
+            << ", sender: " << sender 
+            << ", queryUid: " << compileResult->Uid 
+            << ", status:" << compileResult->Status); 
+ 
+        auto responseEv = MakeHolder<TEvKqp::TEvCompileResponse>(compileResult); 
+        responseEv->Stats.CopyFrom(compileStats); 
 
         if (responseEv->CompileResult && responseEv->CompileResult->PreparedQueryNewEngine) {
             responseEv->ForceNewEnginePercent = Config.GetForceNewEnginePercent();
             responseEv->ForceNewEngineLevel = Config.GetForceNewEngineLevel();
         }
 
-        ctx.Send(sender, responseEv.Release());
-    }
-
+        ctx.Send(sender, responseEv.Release()); 
+    } 
+ 
     void ReplyFromCache(const TActorId& sender, const TKqpCompileResult::TConstPtr& compileResult,
-        const TActorContext& ctx)
-    {
-        NKqpProto::TKqpStatsCompile stats;
-        stats.SetFromCache(true);
-
-        Reply(sender, compileResult, stats, ctx);
-    }
-
+        const TActorContext& ctx) 
+    { 
+        NKqpProto::TKqpStatsCompile stats; 
+        stats.SetFromCache(true); 
+ 
+        Reply(sender, compileResult, stats, ctx); 
+    } 
+ 
     void ReplyError(const TActorId& sender, const TString& uid, Ydb::StatusIds::StatusCode status,
-        const TIssues& issues, const TActorContext& ctx)
-    {
-        Reply(sender, TKqpCompileResult::Make(uid, status, issues), NKqpProto::TKqpStatsCompile(), ctx);
-    }
-
+        const TIssues& issues, const TActorContext& ctx) 
+    { 
+        Reply(sender, TKqpCompileResult::Make(uid, status, issues), NKqpProto::TKqpStatsCompile(), ctx); 
+    } 
+ 
     void ReplyInternalError(const TActorId& sender, const TString& uid, const TString& message,
-        const TActorContext& ctx)
-    {
-        NYql::TIssue issue(NYql::TPosition(), TStringBuilder() << "Internal error during query compilation.");
-        issue.AddSubIssue(MakeIntrusive<TIssue>(NYql::TPosition(), message));
-
-        ReplyError(sender, uid, Ydb::StatusIds::INTERNAL_ERROR, {issue}, ctx);
-    }
-
+        const TActorContext& ctx) 
+    { 
+        NYql::TIssue issue(NYql::TPosition(), TStringBuilder() << "Internal error during query compilation."); 
+        issue.AddSubIssue(MakeIntrusive<TIssue>(NYql::TPosition(), message)); 
+ 
+        ReplyError(sender, uid, Ydb::StatusIds::INTERNAL_ERROR, {issue}, ctx); 
+    } 
+ 
     static void LogException(const TString& scope, const TActorId& sender, const std::exception& e,
-        const TActorContext& ctx)
-    {
-        LOG_CRIT_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Exception"
-            << ", scope: " << scope
-            << ", sender: " << sender
-            << ", message: " << e.what());
-    }
-
-private:
-    TTableServiceConfig Config;
-    TKqpSettings::TConstPtr KqpSettings;
-    TIntrusivePtr<TModuleResolverState> ModuleResolverState;
-    TIntrusivePtr<TKqpCounters> Counters;
+        const TActorContext& ctx) 
+    { 
+        LOG_CRIT_S(ctx, NKikimrServices::KQP_COMPILE_SERVICE, "Exception" 
+            << ", scope: " << scope 
+            << ", sender: " << sender 
+            << ", message: " << e.what()); 
+    } 
+ 
+private: 
+    TTableServiceConfig Config; 
+    TKqpSettings::TConstPtr KqpSettings; 
+    TIntrusivePtr<TModuleResolverState> ModuleResolverState; 
+    TIntrusivePtr<TKqpCounters> Counters; 
     THolder<IQueryReplayBackend> QueryReplayBackend;
-
-    TKqpQueryCache QueryCache;
-    TKqpRequestsQueue RequestsQueue;
+ 
+    TKqpQueryCache QueryCache; 
+    TKqpRequestsQueue RequestsQueue; 
     TActorId CheckQueriesTtlTimer;
     std::shared_ptr<IQueryReplayBackendFactory> QueryReplayFactory;
-};
-
-IActor* CreateKqpCompileService(const TTableServiceConfig& serviceConfig, const TKqpSettings::TConstPtr& kqpSettings,
+}; 
+ 
+IActor* CreateKqpCompileService(const TTableServiceConfig& serviceConfig, const TKqpSettings::TConstPtr& kqpSettings, 
     TIntrusivePtr<TModuleResolverState> moduleResolverState, TIntrusivePtr<TKqpCounters> counters,
     std::shared_ptr<IQueryReplayBackendFactory> queryReplayFactory)
-{
+{ 
     return new TKqpCompileService(serviceConfig, kqpSettings, moduleResolverState, counters,
             std::move(queryReplayFactory));
-}
-
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/kqp_default_settings.txt b/ydb/core/kqp/kqp_default_settings.txt
index ff501a2db6..554d88ac05 100644
--- a/ydb/core/kqp/kqp_default_settings.txt
+++ b/ydb/core/kqp/kqp_default_settings.txt
@@ -1,127 +1,127 @@
-DefaultSettings {
-    Name: "_KqpExprNodesAllocationLimit"
-    Value: "1000000"
-}
-
-DefaultSettings {
-    Name: "_KqpExprStringsAllocationLimit"
-    Value: "33554432"
-}
-
-DefaultSettings {
-    Name: "_KqpMaxActiveTxPerSession"
-    Value: "10"
-}
-
-DefaultSettings {
-    Name: "_KqpQueryTimeoutSec"
-    Value: "600"
-}
-
-DefaultSettings {
-    Name: "_KqpRollbackInvalidatedTx"
+DefaultSettings { 
+    Name: "_KqpExprNodesAllocationLimit" 
+    Value: "1000000" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpExprStringsAllocationLimit" 
+    Value: "33554432" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpMaxActiveTxPerSession" 
+    Value: "10" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpQueryTimeoutSec" 
+    Value: "600" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpRollbackInvalidatedTx" 
+    Value: "true" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpSessionIdleTimeoutSec" 
+    Value: "600" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpSlowLogWarningThresholdMs" 
+    Value: "10000" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpSlowLogNoticeThresholdMs" 
+    Value: "1000" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpSlowLogTraceThresholdMs" 
+    Value: "1000" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpTablePathPrefix" 
+    Value: "" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpTxIdleTimeoutSec" 
+    Value: "300" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpYqlSyntaxVersion" 
+    Value: "0" 
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpAllowNewEngine" 
     Value: "true"
-}
-
-DefaultSettings {
-    Name: "_KqpSessionIdleTimeoutSec"
-    Value: "600"
-}
-
-DefaultSettings {
-    Name: "_KqpSlowLogWarningThresholdMs"
-    Value: "10000"
-}
-
-DefaultSettings {
-    Name: "_KqpSlowLogNoticeThresholdMs"
-    Value: "1000"
-}
-
-DefaultSettings {
-    Name: "_KqpSlowLogTraceThresholdMs"
+} 
+ 
+DefaultSettings { 
+    Name: "_KqpAllowUnsafeCommit" 
+    Value: "true" 
+} 
+ 
+DefaultSettings { 
+    Name: "_CommitPerShardKeysSizeLimitBytes" 
+    Value: "10485760" 
+} 
+ 
+DefaultSettings { 
+    Name: "_CommitReadsLimit" 
+    Value: "10" 
+} 
+ 
+DefaultSettings { 
+    Name: "_RestrictModifyPermissions" 
+    Value: "false" 
+} 
+ 
+DefaultSettings { 
+    Name: "_ResultRowsLimit" 
     Value: "1000"
-}
-
-DefaultSettings {
-    Name: "_KqpTablePathPrefix"
-    Value: ""
-}
-
-DefaultSettings {
-    Name: "_KqpTxIdleTimeoutSec"
-    Value: "300"
-}
-
-DefaultSettings {
-    Name: "_KqpYqlSyntaxVersion"
-    Value: "0"
-}
-
-DefaultSettings {
-    Name: "_KqpAllowNewEngine"
-    Value: "true"
-}
-
-DefaultSettings {
-    Name: "_KqpAllowUnsafeCommit"
-    Value: "true"
-}
-
-DefaultSettings {
-    Name: "_CommitPerShardKeysSizeLimitBytes"
-    Value: "10485760"
-}
-
-DefaultSettings {
-    Name: "_CommitReadsLimit"
-    Value: "10"
-}
-
-DefaultSettings {
-    Name: "_RestrictModifyPermissions"
-    Value: "false"
-}
-
-DefaultSettings {
-    Name: "_ResultRowsLimit"
-    Value: "1000"
-}
-
-DefaultSettings {
+} 
+ 
+DefaultSettings { 
     Name: "_AllowReverseRange"
     Value: "true"
 }
 
 DefaultSettings {
-    Name: "CommitSafety"
-    Value: "Safe"
-}
-
-DefaultSettings {
-    Name: "IsolationLevel"
-    Value: "Serializable"
-}
-
-DefaultSettings {
-    Name: "Profile"
-    Value: "false"
-}
-
-DefaultSettings {
-    Name: "UnwrapReadTableValues"
-    Value: "false"
-}
-
-DefaultSettings {
-    Name: "StrictDml"
-    Value: "true"
-}
-
-DefaultSettings {
-    Name: "OptDisableJoinReverseTableLookup"
-    Value: "true"
-}
+    Name: "CommitSafety" 
+    Value: "Safe" 
+} 
+ 
+DefaultSettings { 
+    Name: "IsolationLevel" 
+    Value: "Serializable" 
+} 
+ 
+DefaultSettings { 
+    Name: "Profile" 
+    Value: "false" 
+} 
+ 
+DefaultSettings { 
+    Name: "UnwrapReadTableValues" 
+    Value: "false" 
+}
+ 
+DefaultSettings { 
+    Name: "StrictDml" 
+    Value: "true" 
+} 
+ 
+DefaultSettings { 
+    Name: "OptDisableJoinReverseTableLookup" 
+    Value: "true" 
+} 
 
 DefaultSettings {
     Name: "_KqpMaxComputeActors"
diff --git a/ydb/core/kqp/kqp_ic_gateway.cpp b/ydb/core/kqp/kqp_ic_gateway.cpp
index 47489a9bd5..f7d59f0f56 100644
--- a/ydb/core/kqp/kqp_ic_gateway.cpp
+++ b/ydb/core/kqp/kqp_ic_gateway.cpp
@@ -1,7 +1,7 @@
 #include "kqp_ic_gateway_actors.h"
-#include "kqp_impl.h"
+#include "kqp_impl.h" 
 #include "kqp_metadata_loader.h"
-
+ 
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/base/path.h>
 #include <ydb/core/base/tablet_pipe.h>
@@ -23,29 +23,29 @@
 #include <ydb/core/ydb_convert/ydb_convert.h>
 #include <ydb/library/aclib/aclib.h>
 #include <ydb/public/lib/base/msgbus_status.h>
-
+ 
 #include <ydb/library/yql/minikql/mkql_node_serialization.h>
 #include <ydb/library/yql/providers/common/proto/gateways_config.pb.h>
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
-
+ 
 #include <library/cpp/actors/core/actor_bootstrapped.h>
 #include <library/cpp/actors/core/hfunc.h>
-
+ 
 #include <util/string/split.h>
 #include <util/string/vector.h>
 
-namespace NKikimr {
-namespace NKqp {
-
+namespace NKikimr { 
+namespace NKqp { 
+ 
 using NYql::TIssue;
 using TIssuesIds = NYql::TIssuesIds;
-using namespace NThreading;
+using namespace NThreading; 
 using namespace NYql::NCommon;
 using namespace NSchemeShard;
 using namespace NKikimrSchemeOp;
-
-using NKikimrTxUserProxy::TMiniKQLTransaction;
-
+ 
+using NKikimrTxUserProxy::TMiniKQLTransaction; 
+ 
 constexpr const IKqpGateway::TKqpSnapshot IKqpGateway::TKqpSnapshot::InvalidSnapshot = TKqpSnapshot();
 
 #define STATIC_ASSERT_STATE_EQUAL(name) \
@@ -60,223 +60,223 @@ STATIC_ASSERT_STATE_EQUAL(WriteOnly)
 
 #undef STATIC_ASSERT_STATE_EQUAL
 
-namespace {
-
-template <class TResult>
-static NThreading::TFuture<TResult> NotImplemented() {
-    TResult result;
+namespace { 
+ 
+template <class TResult> 
+static NThreading::TFuture<TResult> NotImplemented() { 
+    TResult result; 
     result.AddIssue(TIssue({}, "Not implemented in interconnect gateway."));
-    return NThreading::MakeFuture(result);
-}
-
-struct TAppConfigResult : public IKqpGateway::TGenericResult {
+    return NThreading::MakeFuture(result); 
+} 
+ 
+struct TAppConfigResult : public IKqpGateway::TGenericResult { 
     std::shared_ptr<const NKikimrConfig::TAppConfig> Config;
 };
 
-
-template<typename TRequest, typename TResponse, typename TResult>
-class TProxyRequestHandler: public TRequestHandlerBase<
-    TProxyRequestHandler<TRequest, TResponse, TResult>,
-    TRequest,
-    TResponse,
-    TResult>
-{
-public:
-    using TBase = typename TProxyRequestHandler::TBase;
-    using TCallbackFunc = typename TBase::TCallbackFunc;
-
-    TProxyRequestHandler(TRequest* request, TPromise<TResult> promise, TCallbackFunc callback)
+ 
+template<typename TRequest, typename TResponse, typename TResult> 
+class TProxyRequestHandler: public TRequestHandlerBase< 
+    TProxyRequestHandler<TRequest, TResponse, TResult>, 
+    TRequest, 
+    TResponse, 
+    TResult> 
+{ 
+public: 
+    using TBase = typename TProxyRequestHandler::TBase; 
+    using TCallbackFunc = typename TBase::TCallbackFunc; 
+ 
+    TProxyRequestHandler(TRequest* request, TPromise<TResult> promise, TCallbackFunc callback) 
         : TBase(request, promise, callback) {}
-
-    void Bootstrap(const TActorContext& ctx) {
+ 
+    void Bootstrap(const TActorContext& ctx) { 
         TActorId txproxy = MakeTxProxyID();
         ctx.Send(txproxy, this->Request.Release());
-
-        this->Become(&TProxyRequestHandler::AwaitState);
-    }
-
-    using TBase::Handle;
-    using TBase::HandleResponse;
-
-    STFUNC(AwaitState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TResponse, HandleResponse);
-            HFunc(TEvTabletPipe::TEvClientConnected, Handle);
-            HFunc(TEvTabletPipe::TEvClientDestroyed, Handle);
-
-        default:
-            TBase::HandleUnexpectedEvent("TProxyRequestHandler", ev->GetTypeRewrite(), ctx);
-        }
-    }
-};
-
-template<typename TRequest, typename TResponse, typename TResult>
-class TKqpRequestHandler: public TRequestHandlerBase<
-    TKqpRequestHandler<TRequest, TResponse, TResult>,
-    TRequest,
-    TResponse,
-    TResult>
-{
-public:
-    using TBase = typename TKqpRequestHandler::TBase;
-    using TCallbackFunc = typename TBase::TCallbackFunc;
-
-    TKqpRequestHandler(TRequest* request, TPromise<TResult> promise, TCallbackFunc callback)
-        : TBase(request, promise, callback) {}
-
-    void Bootstrap(const TActorContext& ctx) {
+ 
+        this->Become(&TProxyRequestHandler::AwaitState); 
+    } 
+ 
+    using TBase::Handle; 
+    using TBase::HandleResponse; 
+ 
+    STFUNC(AwaitState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TResponse, HandleResponse); 
+            HFunc(TEvTabletPipe::TEvClientConnected, Handle); 
+            HFunc(TEvTabletPipe::TEvClientDestroyed, Handle); 
+ 
+        default: 
+            TBase::HandleUnexpectedEvent("TProxyRequestHandler", ev->GetTypeRewrite(), ctx); 
+        } 
+    } 
+}; 
+ 
+template<typename TRequest, typename TResponse, typename TResult> 
+class TKqpRequestHandler: public TRequestHandlerBase< 
+    TKqpRequestHandler<TRequest, TResponse, TResult>, 
+    TRequest, 
+    TResponse, 
+    TResult> 
+{ 
+public: 
+    using TBase = typename TKqpRequestHandler::TBase; 
+    using TCallbackFunc = typename TBase::TCallbackFunc; 
+ 
+    TKqpRequestHandler(TRequest* request, TPromise<TResult> promise, TCallbackFunc callback) 
+        : TBase(request, promise, callback) {} 
+ 
+    void Bootstrap(const TActorContext& ctx) { 
         TActorId kqpProxy = MakeKqpProxyID(ctx.SelfID.NodeId());
-        ctx.Send(kqpProxy, this->Request.Release());
-
-        this->Become(&TKqpRequestHandler::AwaitState);
-    }
-
-    void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& kqpResponse = ev->Get()->Record;
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, ctx.SelfID
-            << "Received process error for kqp query: " << kqpResponse.GetError());
-
-        TBase::HandleError(kqpResponse.GetError(), ctx);
-    }
-
-    using TBase::Handle;
-    using TBase::HandleResponse;
-
-    STFUNC(AwaitState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle);
-            HFunc(TResponse, HandleResponse);
-
-        default:
-            TBase::HandleUnexpectedEvent("TKqpRequestHandler", ev->GetTypeRewrite(), ctx);
-        }
-    }
-};
-
-class TKqpScanQueryRequestHandler : public TRequestHandlerBase<
-    TKqpScanQueryRequestHandler,
-    NKqp::TEvKqp::TEvQueryRequest,
-    NKqp::TEvKqp::TEvQueryResponse,
-    IKqpGateway::TQueryResult>
-{
-public:
-    const ui32 ResultSetBytesLimit = 48 * 1024 * 1024; // 48 MB
-
-    using TRequest = NKqp::TEvKqp::TEvQueryRequest;
-    using TResponse = NKqp::TEvKqp::TEvQueryResponse;
-    using TResult = IKqpGateway::TQueryResult;
-
-    using TBase = TKqpScanQueryRequestHandler::TBase;
-
-    TKqpScanQueryRequestHandler(TRequest* request, ui64 rowsLimit, TPromise<TResult> promise, TCallbackFunc callback)
-        : TBase(request, promise, callback)
-        , RowsLimit(rowsLimit) {}
-
-    void Bootstrap(const TActorContext& ctx) {
+        ctx.Send(kqpProxy, this->Request.Release()); 
+ 
+        this->Become(&TKqpRequestHandler::AwaitState); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& kqpResponse = ev->Get()->Record; 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, ctx.SelfID 
+            << "Received process error for kqp query: " << kqpResponse.GetError()); 
+ 
+        TBase::HandleError(kqpResponse.GetError(), ctx); 
+    } 
+ 
+    using TBase::Handle; 
+    using TBase::HandleResponse; 
+ 
+    STFUNC(AwaitState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle); 
+            HFunc(TResponse, HandleResponse); 
+ 
+        default: 
+            TBase::HandleUnexpectedEvent("TKqpRequestHandler", ev->GetTypeRewrite(), ctx); 
+        } 
+    } 
+}; 
+ 
+class TKqpScanQueryRequestHandler : public TRequestHandlerBase< 
+    TKqpScanQueryRequestHandler, 
+    NKqp::TEvKqp::TEvQueryRequest, 
+    NKqp::TEvKqp::TEvQueryResponse, 
+    IKqpGateway::TQueryResult> 
+{ 
+public: 
+    const ui32 ResultSetBytesLimit = 48 * 1024 * 1024; // 48 MB 
+ 
+    using TRequest = NKqp::TEvKqp::TEvQueryRequest; 
+    using TResponse = NKqp::TEvKqp::TEvQueryResponse; 
+    using TResult = IKqpGateway::TQueryResult; 
+ 
+    using TBase = TKqpScanQueryRequestHandler::TBase; 
+ 
+    TKqpScanQueryRequestHandler(TRequest* request, ui64 rowsLimit, TPromise<TResult> promise, TCallbackFunc callback) 
+        : TBase(request, promise, callback) 
+        , RowsLimit(rowsLimit) {} 
+ 
+    void Bootstrap(const TActorContext& ctx) { 
         ActorIdToProto(SelfId(), this->Request->Record.MutableRequestActorId());
-
+ 
         TActorId kqpProxy = MakeKqpProxyID(ctx.SelfID.NodeId());
-        ctx.Send(kqpProxy, this->Request.Release());
-
-        this->Become(&TKqpScanQueryRequestHandler::AwaitState);
-    }
-
-    void Handle(NKqp::TEvKqpExecuter::TEvStreamData::TPtr& ev, const TActorContext& ctx) {
-        auto& record = ev->Get()->Record;
-
-        if (!HasMeta) {
-            for (auto& column : record.GetResultSet().columns()) {
-                ResultSet.add_columns()->CopyFrom(column);
-            }
-
-            HasMeta = true;
-        }
-
-        bool truncated = false;
-        for (auto& row : record.GetResultSet().rows()) {
-            truncated = truncated || (RowsLimit && (ui64)ResultSet.rows_size() >= RowsLimit);
-            truncated = truncated || (ResultSet.ByteSizeLong() >= ResultSetBytesLimit);
-            if (truncated) {
-                break;
-            }
-
-            ResultSet.add_rows()->CopyFrom(row);
-        }
-
-        if (truncated) {
-            ResultSet.set_truncated(true);
-        }
-
-        auto resp = MakeHolder<NKqp::TEvKqpExecuter::TEvStreamDataAck>();
+        ctx.Send(kqpProxy, this->Request.Release()); 
+ 
+        this->Become(&TKqpScanQueryRequestHandler::AwaitState); 
+    } 
+ 
+    void Handle(NKqp::TEvKqpExecuter::TEvStreamData::TPtr& ev, const TActorContext& ctx) { 
+        auto& record = ev->Get()->Record; 
+ 
+        if (!HasMeta) { 
+            for (auto& column : record.GetResultSet().columns()) { 
+                ResultSet.add_columns()->CopyFrom(column); 
+            } 
+ 
+            HasMeta = true; 
+        } 
+ 
+        bool truncated = false; 
+        for (auto& row : record.GetResultSet().rows()) { 
+            truncated = truncated || (RowsLimit && (ui64)ResultSet.rows_size() >= RowsLimit); 
+            truncated = truncated || (ResultSet.ByteSizeLong() >= ResultSetBytesLimit); 
+            if (truncated) { 
+                break; 
+            } 
+ 
+            ResultSet.add_rows()->CopyFrom(row); 
+        } 
+ 
+        if (truncated) { 
+            ResultSet.set_truncated(true); 
+        } 
+ 
+        auto resp = MakeHolder<NKqp::TEvKqpExecuter::TEvStreamDataAck>(); 
         resp->Record.SetEnough(truncated);
-        resp->Record.SetSeqNo(ev->Get()->Record.GetSeqNo());
-        resp->Record.SetFreeSpace(ResultSetBytesLimit);
-        ctx.Send(ev->Sender, resp.Release());
-    }
-
-    void Handle(NKqp::TEvKqpExecuter::TEvStreamProfile::TPtr& ev, const TActorContext& ctx) {
-        Y_UNUSED(ctx);
-        Executions.push_back(std::move(*ev->Get()->Record.MutableProfile()));
-    }
-
-    void Handle(NKqp::TEvKqpExecuter::TEvExecuterProgress::TPtr& ev, const TActorContext& ctx) {
+        resp->Record.SetSeqNo(ev->Get()->Record.GetSeqNo()); 
+        resp->Record.SetFreeSpace(ResultSetBytesLimit); 
+        ctx.Send(ev->Sender, resp.Release()); 
+    } 
+ 
+    void Handle(NKqp::TEvKqpExecuter::TEvStreamProfile::TPtr& ev, const TActorContext& ctx) { 
+        Y_UNUSED(ctx); 
+        Executions.push_back(std::move(*ev->Get()->Record.MutableProfile())); 
+    } 
+ 
+    void Handle(NKqp::TEvKqpExecuter::TEvExecuterProgress::TPtr& ev, const TActorContext& ctx) { 
         ExecuterActorId = ActorIdFromProto(ev->Get()->Record.GetExecuterActorId());
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, SelfId()
-            << "Received executer progress for scan query, id: " << ExecuterActorId);
-    }
-
-    void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) {
-        const auto& kqpResponse = ev->Get()->Record;
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, SelfId()
-            << "Received process error for scan query: " << kqpResponse.GetError());
-
-        TBase::HandleError(kqpResponse.GetError(), ctx);
-    }
-
-    void Handle(NKqp::TEvKqp::TEvAbortExecution::TPtr& ev, const TActorContext& ctx) {
-        auto& record = ev->Get()->Record;
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, SelfId()
-            << "Received abort execution event for scan query: " << record.GetMessage());
-
-        TBase::HandleError(record.GetMessage(), ctx);
-    }
-
-    using TBase::HandleResponse;
-
-    void HandleResponse(typename TResponse::TPtr &ev, const TActorContext &ctx) {
-        auto& response = *ev->Get()->Record.GetRef().MutableResponse();
-
-        NKikimr::ConvertYdbResultToKqpResult(ResultSet,*response.AddResults());
-        for (auto& execStats : Executions) {
-            response.MutableQueryStats()->AddExecutions()->Swap(&execStats);
-        }
-        Executions.clear();
-
-        TBase::HandleResponse(ev, ctx);
-    }
-
-    STFUNC(AwaitState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle);
-            HFunc(NKqp::TEvKqp::TEvAbortExecution, Handle);
-            HFunc(NKqp::TEvKqpExecuter::TEvStreamData, Handle);
-            HFunc(NKqp::TEvKqpExecuter::TEvStreamProfile, Handle);
-            HFunc(NKqp::TEvKqpExecuter::TEvExecuterProgress, Handle);
-            HFunc(TResponse, HandleResponse);
-
-        default:
-            TBase::HandleUnexpectedEvent("TKqpScanQueryRequestHandler", ev->GetTypeRewrite(), ctx);
-        }
-    }
-
-private:
-    ui64 RowsLimit = 0;
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, SelfId() 
+            << "Received executer progress for scan query, id: " << ExecuterActorId); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) { 
+        const auto& kqpResponse = ev->Get()->Record; 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, SelfId() 
+            << "Received process error for scan query: " << kqpResponse.GetError()); 
+ 
+        TBase::HandleError(kqpResponse.GetError(), ctx); 
+    } 
+ 
+    void Handle(NKqp::TEvKqp::TEvAbortExecution::TPtr& ev, const TActorContext& ctx) { 
+        auto& record = ev->Get()->Record; 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, SelfId() 
+            << "Received abort execution event for scan query: " << record.GetMessage()); 
+ 
+        TBase::HandleError(record.GetMessage(), ctx); 
+    } 
+ 
+    using TBase::HandleResponse; 
+ 
+    void HandleResponse(typename TResponse::TPtr &ev, const TActorContext &ctx) { 
+        auto& response = *ev->Get()->Record.GetRef().MutableResponse(); 
+ 
+        NKikimr::ConvertYdbResultToKqpResult(ResultSet,*response.AddResults()); 
+        for (auto& execStats : Executions) { 
+            response.MutableQueryStats()->AddExecutions()->Swap(&execStats); 
+        } 
+        Executions.clear(); 
+ 
+        TBase::HandleResponse(ev, ctx); 
+    } 
+ 
+    STFUNC(AwaitState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(NKqp::TEvKqp::TEvProcessResponse, Handle); 
+            HFunc(NKqp::TEvKqp::TEvAbortExecution, Handle); 
+            HFunc(NKqp::TEvKqpExecuter::TEvStreamData, Handle); 
+            HFunc(NKqp::TEvKqpExecuter::TEvStreamProfile, Handle); 
+            HFunc(NKqp::TEvKqpExecuter::TEvExecuterProgress, Handle); 
+            HFunc(TResponse, HandleResponse); 
+ 
+        default: 
+            TBase::HandleUnexpectedEvent("TKqpScanQueryRequestHandler", ev->GetTypeRewrite(), ctx); 
+        } 
+    } 
+ 
+private: 
+    ui64 RowsLimit = 0; 
     TActorId ExecuterActorId;
-    bool HasMeta = false;
-    Ydb::ResultSet ResultSet;
+    bool HasMeta = false; 
+    Ydb::ResultSet ResultSet; 
     TVector<NYql::NDqProto::TDqExecutionStats> Executions;
-};
-
+}; 
+ 
 // Handles data query request for StreamExecuteYqlScript
 template<typename TRequest, typename TResponse, typename TResult>
 class TKqpStreamRequestHandler : public TRequestHandlerBase<
@@ -304,9 +304,9 @@ public:
     void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) {
         const auto& kqpResponse = ev->Get()->Record;
         LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, ctx.SelfID
-            << "Received process error for kqp data query: " << kqpResponse.GetError());
+            << "Received process error for kqp data query: " << kqpResponse.GetError()); 
 
-        TBase::HandleError(kqpResponse.GetError(), ctx);
+        TBase::HandleError(kqpResponse.GetError(), ctx); 
     }
 
     using TBase::Promise;
@@ -431,9 +431,9 @@ public:
     void Handle(NKqp::TEvKqp::TEvProcessResponse::TPtr& ev, const TActorContext& ctx) {
         const auto& kqpResponse = ev->Get()->Record;
         LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, SelfId()
-            << "Received process error for scan query: " << kqpResponse.GetError());
+            << "Received process error for scan query: " << kqpResponse.GetError()); 
 
-        TBase::HandleError(kqpResponse.GetError(), ctx);
+        TBase::HandleError(kqpResponse.GetError(), ctx); 
     }
 
     void Handle(NKqp::TEvKqp::TEvAbortExecution::TPtr& ev, const TActorContext& ctx) {
@@ -479,380 +479,380 @@ private:
     TVector<NYql::NDqProto::TDqExecutionStats> Executions;
 };
 
-class TMkqlRequestHandler : public TRequestHandlerBase<
-    TMkqlRequestHandler,
-    TEvTxUserProxy::TEvProposeTransaction,
-    TEvTxUserProxy::TEvProposeTransactionStatus,
-    IKqpGateway::TMkqlResult>
-{
-public:
-    using TBase = typename TMkqlRequestHandler::TBase;
-    using TCallbackFunc = typename TBase::TCallbackFunc;
-    using TRequest = TEvTxUserProxy::TEvProposeTransaction;
-    using TResponse = TEvTxUserProxy::TEvProposeTransactionStatus;
-    using TResult = IKqpGateway::TMkqlResult;
-
-    TMkqlRequestHandler(const TAlignedPagePoolCounters& allocCounters, TRequest* request,
-        TKqpParamsMap&& paramsMap, TPromise<TResult> promise, TCallbackFunc callback,
+class TMkqlRequestHandler : public TRequestHandlerBase< 
+    TMkqlRequestHandler, 
+    TEvTxUserProxy::TEvProposeTransaction, 
+    TEvTxUserProxy::TEvProposeTransactionStatus, 
+    IKqpGateway::TMkqlResult> 
+{ 
+public: 
+    using TBase = typename TMkqlRequestHandler::TBase; 
+    using TCallbackFunc = typename TBase::TCallbackFunc; 
+    using TRequest = TEvTxUserProxy::TEvProposeTransaction; 
+    using TResponse = TEvTxUserProxy::TEvProposeTransactionStatus; 
+    using TResult = IKqpGateway::TMkqlResult; 
+ 
+    TMkqlRequestHandler(const TAlignedPagePoolCounters& allocCounters, TRequest* request, 
+        TKqpParamsMap&& paramsMap, TPromise<TResult> promise, TCallbackFunc callback, 
         const TActorId& miniKqlComplileServiceActorId)
         : TBase(request, promise, callback)
-        , ParamsMap(std::move(paramsMap))
-        , CompilationPending(false)
+        , ParamsMap(std::move(paramsMap)) 
+        , CompilationPending(false) 
         , CompilationRetried(false)
         , AllocCounters(allocCounters)
         , MiniKqlComplileServiceActorId(miniKqlComplileServiceActorId)
     {}
-
-    void Bootstrap(const TActorContext& ctx) {
-        auto& mkqlTx = *Request->Record.MutableTransaction()->MutableMiniKQLTransaction();
-
-        if (mkqlTx.HasProgram() && mkqlTx.GetProgram().HasText()) {
-            MkqlProgramText = mkqlTx.GetProgram().GetText();
-            CompileProgram(ctx, mkqlTx.GetMode() == NKikimrTxUserProxy::TMiniKQLTransaction::COMPILE);
-        }
-
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        auto& mkqlTx = *Request->Record.MutableTransaction()->MutableMiniKQLTransaction(); 
+ 
+        if (mkqlTx.HasProgram() && mkqlTx.GetProgram().HasText()) { 
+            MkqlProgramText = mkqlTx.GetProgram().GetText(); 
+            CompileProgram(ctx, mkqlTx.GetMode() == NKikimrTxUserProxy::TMiniKQLTransaction::COMPILE); 
+        } 
+ 
         mkqlTx.SetCollectStats(true);
-        YQL_ENSURE(!mkqlTx.HasParams());
-
-        if (!ParamsMap.Values.empty()) {
-            try {
-                mkqlTx.MutableParams()->SetBin(BuildParams(ParamsMap, AllocCounters, ctx));
-            }
-            catch(const yexception& e) {
-                Promise.SetValue(ResultFromError<TResult>(e.what()));
-                this->Die(ctx);
-                return;
-            }
-        }
-
-        ProceedWithExecution(ctx);
-
-        this->Become(&TMkqlRequestHandler::AwaitState);
-    }
-
-    void Handle(TMiniKQLCompileServiceEvents::TEvCompileStatus::TPtr &ev, const TActorContext &ctx) {
-        const auto& result = ev->Get()->Result;
-        auto& mkqlTx = *Request->Record.MutableTransaction()->MutableMiniKQLTransaction();
-
-        if (!result.Errors.Empty()) {
-            Promise.SetValue(ResultFromIssues<TResult>(GetMkqlCompileStatus(result.Errors),
+        YQL_ENSURE(!mkqlTx.HasParams()); 
+ 
+        if (!ParamsMap.Values.empty()) { 
+            try { 
+                mkqlTx.MutableParams()->SetBin(BuildParams(ParamsMap, AllocCounters, ctx)); 
+            } 
+            catch(const yexception& e) { 
+                Promise.SetValue(ResultFromError<TResult>(e.what())); 
+                this->Die(ctx); 
+                return; 
+            } 
+        } 
+ 
+        ProceedWithExecution(ctx); 
+ 
+        this->Become(&TMkqlRequestHandler::AwaitState); 
+    } 
+ 
+    void Handle(TMiniKQLCompileServiceEvents::TEvCompileStatus::TPtr &ev, const TActorContext &ctx) { 
+        const auto& result = ev->Get()->Result; 
+        auto& mkqlTx = *Request->Record.MutableTransaction()->MutableMiniKQLTransaction(); 
+ 
+        if (!result.Errors.Empty()) { 
+            Promise.SetValue(ResultFromIssues<TResult>(GetMkqlCompileStatus(result.Errors), 
                 "Query compilation failed", result.Errors));
-
-            this->Die(ctx);
-            return;
-        }
-
-        if (mkqlTx.GetMode() == NKikimrTxUserProxy::TMiniKQLTransaction::COMPILE) {
-            TResult reply;
-            reply.SetSuccess();
-            reply.CompiledProgram = result.CompiledProgram;
+ 
+            this->Die(ctx); 
+            return; 
+        } 
+ 
+        if (mkqlTx.GetMode() == NKikimrTxUserProxy::TMiniKQLTransaction::COMPILE) { 
+            TResult reply; 
+            reply.SetSuccess(); 
+            reply.CompiledProgram = result.CompiledProgram; 
             Promise.SetValue(std::move(reply));
-            this->Die(ctx);
-            return;
-        }
-
-        auto& pgm = *mkqlTx.MutableProgram();
-        pgm.ClearText();
-        pgm.SetBin(result.CompiledProgram);
-
-        CompileResolveCookies = std::move(ev->Get()->CompileResolveCookies);
-
-        CompilationPending = false;
-        ProceedWithExecution(ctx);
-    }
-
-    void HandleResponse(TResponse::TPtr &ev, const TActorContext &ctx) {
-        auto& response = *ev->Get();
-        ui32 status = response.Record.GetStatus();
-
-        bool resolveError = status == TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ResolveError ||
-            status == TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardNotAvailable;
-
-        if (resolveError && !CompilationRetried && !MkqlProgramText.empty()) {
-            CompilationRetried = true;
-            CompileProgram(ctx, false);
-            ProceedWithExecution(ctx);
-            return;
-        }
-
-        Callback(Promise, std::move(*ev->Get()));
-        this->Die(ctx);
-    }
-
-    using TBase::Handle;
-
-    STFUNC(AwaitState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TResponse, HandleResponse);
-            HFunc(TEvTabletPipe::TEvClientConnected, Handle);
-            HFunc(TEvTabletPipe::TEvClientDestroyed, Handle);
-            HFunc(TMiniKQLCompileServiceEvents::TEvCompileStatus, Handle);
-        default:
-            TBase::HandleUnexpectedEvent("TMkqlRequestHandler", ev->GetTypeRewrite(), ctx);
-        }
-    }
-
-private:
-    static TString BuildParams(const TKqpParamsMap& paramsMap, const TAlignedPagePoolCounters& counters,
-        const TActorContext &ctx)
-    {
-        NMiniKQL::TScopedAlloc alloc(counters, AppData(ctx)->FunctionRegistry->SupportsSizedAllocators());
-        NMiniKQL::TTypeEnvironment env(alloc);
-
-        NMiniKQL::TStructLiteralBuilder structBuilder(env);
-        structBuilder.Reserve(paramsMap.Values.size());
-        for (auto& pair : paramsMap.Values) {
-            const TString& name = pair.first;
+            this->Die(ctx); 
+            return; 
+        } 
+ 
+        auto& pgm = *mkqlTx.MutableProgram(); 
+        pgm.ClearText(); 
+        pgm.SetBin(result.CompiledProgram); 
+ 
+        CompileResolveCookies = std::move(ev->Get()->CompileResolveCookies); 
+ 
+        CompilationPending = false; 
+        ProceedWithExecution(ctx); 
+    } 
+ 
+    void HandleResponse(TResponse::TPtr &ev, const TActorContext &ctx) { 
+        auto& response = *ev->Get(); 
+        ui32 status = response.Record.GetStatus(); 
+ 
+        bool resolveError = status == TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ResolveError || 
+            status == TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardNotAvailable; 
+ 
+        if (resolveError && !CompilationRetried && !MkqlProgramText.empty()) { 
+            CompilationRetried = true; 
+            CompileProgram(ctx, false); 
+            ProceedWithExecution(ctx); 
+            return; 
+        } 
+ 
+        Callback(Promise, std::move(*ev->Get())); 
+        this->Die(ctx); 
+    } 
+ 
+    using TBase::Handle; 
+ 
+    STFUNC(AwaitState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TResponse, HandleResponse); 
+            HFunc(TEvTabletPipe::TEvClientConnected, Handle); 
+            HFunc(TEvTabletPipe::TEvClientDestroyed, Handle); 
+            HFunc(TMiniKQLCompileServiceEvents::TEvCompileStatus, Handle); 
+        default: 
+            TBase::HandleUnexpectedEvent("TMkqlRequestHandler", ev->GetTypeRewrite(), ctx); 
+        } 
+    } 
+ 
+private: 
+    static TString BuildParams(const TKqpParamsMap& paramsMap, const TAlignedPagePoolCounters& counters, 
+        const TActorContext &ctx) 
+    { 
+        NMiniKQL::TScopedAlloc alloc(counters, AppData(ctx)->FunctionRegistry->SupportsSizedAllocators()); 
+        NMiniKQL::TTypeEnvironment env(alloc); 
+ 
+        NMiniKQL::TStructLiteralBuilder structBuilder(env); 
+        structBuilder.Reserve(paramsMap.Values.size()); 
+        for (auto& pair : paramsMap.Values) { 
+            const TString& name = pair.first; 
             const NYql::NDq::TMkqlValueRef& param = pair.second;
-
-            auto valueNode = NMiniKQL::ImportValueFromProto(param.GetType(), param.GetValue(), env);
-            structBuilder.Add(name, valueNode);
-        }
-
-        auto node = NMiniKQL::TRuntimeNode(structBuilder.Build(), true);
-        return NMiniKQL::SerializeRuntimeNode(node, env);
-    }
-
-    NYql::EYqlIssueCode GetMkqlCompileStatus(const NYql::TIssues& issues) {
-        for (auto& issue : issues) {
-            switch (issue.GetCode()) {
-                case NKikimrIssues::TIssuesIds::GENERIC_RESOLVE_ERROR:
-                    return TIssuesIds::KIKIMR_SCHEME_MISMATCH;
-
-                case NKikimrIssues::TIssuesIds::RESOLVE_LOOKUP_ERROR:
-                    return TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE;
-            }
-        }
-
-        return TIssuesIds::DEFAULT_ERROR;
-    }
-
-    void CompileProgram(const TActorContext &ctx, bool forceRefresh) {
-        auto compileEv = MakeHolder<TMiniKQLCompileServiceEvents::TEvCompile>(MkqlProgramText);
-        compileEv->ForceRefresh = forceRefresh;
-        if (!CompileResolveCookies.empty()) {
-            compileEv->CompileResolveCookies = std::move(CompileResolveCookies);
-        }
+ 
+            auto valueNode = NMiniKQL::ImportValueFromProto(param.GetType(), param.GetValue(), env); 
+            structBuilder.Add(name, valueNode); 
+        } 
+ 
+        auto node = NMiniKQL::TRuntimeNode(structBuilder.Build(), true); 
+        return NMiniKQL::SerializeRuntimeNode(node, env); 
+    } 
+ 
+    NYql::EYqlIssueCode GetMkqlCompileStatus(const NYql::TIssues& issues) { 
+        for (auto& issue : issues) { 
+            switch (issue.GetCode()) { 
+                case NKikimrIssues::TIssuesIds::GENERIC_RESOLVE_ERROR: 
+                    return TIssuesIds::KIKIMR_SCHEME_MISMATCH; 
+ 
+                case NKikimrIssues::TIssuesIds::RESOLVE_LOOKUP_ERROR: 
+                    return TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE; 
+            } 
+        } 
+ 
+        return TIssuesIds::DEFAULT_ERROR; 
+    } 
+ 
+    void CompileProgram(const TActorContext &ctx, bool forceRefresh) { 
+        auto compileEv = MakeHolder<TMiniKQLCompileServiceEvents::TEvCompile>(MkqlProgramText); 
+        compileEv->ForceRefresh = forceRefresh; 
+        if (!CompileResolveCookies.empty()) { 
+            compileEv->CompileResolveCookies = std::move(CompileResolveCookies); 
+        } 
         ctx.Send(MiniKqlComplileServiceActorId, compileEv.Release());
-        CompilationPending = true;
-    }
-
-    void ProceedWithExecution(const TActorContext& ctx) {
-        if (!CompilationPending) {
-            TAutoPtr<TRequest> ev = new TRequest();
-            ev->Record.CopyFrom(this->Request->Record);
+        CompilationPending = true; 
+    } 
+ 
+    void ProceedWithExecution(const TActorContext& ctx) { 
+        if (!CompilationPending) { 
+            TAutoPtr<TRequest> ev = new TRequest(); 
+            ev->Record.CopyFrom(this->Request->Record); 
 
             TActorId txproxy = MakeTxProxyID();
             ctx.Send(txproxy, ev.Release());
-        }
-    }
-
-private:
-    TKqpParamsMap ParamsMap;
-    bool CompilationPending;
-    bool CompilationRetried;
+        } 
+    } 
+ 
+private: 
+    TKqpParamsMap ParamsMap; 
+    bool CompilationPending; 
+    bool CompilationRetried; 
     TString MkqlProgramText;
     THashMap<TString, ui64> CompileResolveCookies;
     TAlignedPagePoolCounters AllocCounters;
     TActorId MiniKqlComplileServiceActorId;
-};
-
-class TSchemeOpRequestHandler: public TRequestHandlerBase<
-    TSchemeOpRequestHandler,
-    TEvTxUserProxy::TEvProposeTransaction,
-    TEvTxUserProxy::TEvProposeTransactionStatus,
-    IKqpGateway::TGenericResult>
-{
-public:
-    using TBase = typename TSchemeOpRequestHandler::TBase;
-    using TRequest = TEvTxUserProxy::TEvProposeTransaction;
-    using TResponse = TEvTxUserProxy::TEvProposeTransactionStatus;
-    using TResult = IKqpGateway::TGenericResult;
-
+}; 
+ 
+class TSchemeOpRequestHandler: public TRequestHandlerBase< 
+    TSchemeOpRequestHandler, 
+    TEvTxUserProxy::TEvProposeTransaction, 
+    TEvTxUserProxy::TEvProposeTransactionStatus, 
+    IKqpGateway::TGenericResult> 
+{ 
+public: 
+    using TBase = typename TSchemeOpRequestHandler::TBase; 
+    using TRequest = TEvTxUserProxy::TEvProposeTransaction; 
+    using TResponse = TEvTxUserProxy::TEvProposeTransactionStatus; 
+    using TResult = IKqpGateway::TGenericResult; 
+ 
     TSchemeOpRequestHandler(TRequest* request, TPromise<TResult> promise)
         : TBase(request, promise, {}) {}
-
-    void Bootstrap(const TActorContext& ctx) {
+ 
+    void Bootstrap(const TActorContext& ctx) { 
         TActorId txproxy = MakeTxProxyID();
         ctx.Send(txproxy, this->Request.Release());
-
-        this->Become(&TSchemeOpRequestHandler::AwaitState);
-    }
-
-    using TBase::Handle;
-
-    void HandleResponse(typename TResponse::TPtr &ev, const TActorContext &ctx) {
-        auto& response = ev->Get()->Record;
-        auto status = static_cast<TEvTxUserProxy::TEvProposeTransactionStatus::EStatus>(response.GetStatus());
-
+ 
+        this->Become(&TSchemeOpRequestHandler::AwaitState); 
+    } 
+ 
+    using TBase::Handle; 
+ 
+    void HandleResponse(typename TResponse::TPtr &ev, const TActorContext &ctx) { 
+        auto& response = ev->Get()->Record; 
+        auto status = static_cast<TEvTxUserProxy::TEvProposeTransactionStatus::EStatus>(response.GetStatus()); 
+ 
         LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, "Received TEvProposeTransactionStatus for scheme request"
-            << ", TxId: " << response.GetTxId()
-            << ", status: " << status
-            << ", scheme shard status: " << response.GetSchemeShardStatus());
-
-        switch (status) {
-            case TEvTxUserProxy::TResultStatus::ExecInProgress: {
-                ui64 schemeShardTabletId = response.GetSchemeShardTabletId();
-                IActor* pipeActor = NTabletPipe::CreateClient(ctx.SelfID, schemeShardTabletId);
-                Y_VERIFY(pipeActor);
-                ShemePipeActorId = ctx.ExecutorThread.RegisterActor(pipeActor);
-
+            << ", TxId: " << response.GetTxId() 
+            << ", status: " << status 
+            << ", scheme shard status: " << response.GetSchemeShardStatus()); 
+ 
+        switch (status) { 
+            case TEvTxUserProxy::TResultStatus::ExecInProgress: { 
+                ui64 schemeShardTabletId = response.GetSchemeShardTabletId(); 
+                IActor* pipeActor = NTabletPipe::CreateClient(ctx.SelfID, schemeShardTabletId); 
+                Y_VERIFY(pipeActor); 
+                ShemePipeActorId = ctx.ExecutorThread.RegisterActor(pipeActor); 
+ 
                 auto request = MakeHolder<TEvSchemeShard::TEvNotifyTxCompletion>();
-                request->Record.SetTxId(response.GetTxId());
-                NTabletPipe::SendData(ctx, ShemePipeActorId, request.Release());
-
+                request->Record.SetTxId(response.GetTxId()); 
+                NTabletPipe::SendData(ctx, ShemePipeActorId, request.Release()); 
+ 
                 LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, "Sent TEvNotifyTxCompletion request"
-                    << ", TxId: " << response.GetTxId());
-
-                return;
-            }
-
-            case TEvTxUserProxy::TResultStatus::AccessDenied: {
+                    << ", TxId: " << response.GetTxId()); 
+ 
+                return; 
+            } 
+ 
+            case TEvTxUserProxy::TResultStatus::AccessDenied: { 
                 LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, "Access denied for scheme request"
-                    << ", TxId: " << response.GetTxId());
-
-                TIssue issue(NYql::TPosition(), "Access denied.");
-                Promise.SetValue(ResultFromIssues<TResult>(TIssuesIds::KIKIMR_ACCESS_DENIED,
-                    "Access denied for scheme request", {issue}));
-                this->Die(ctx);
-                return;
-            }
-
-            case TEvTxUserProxy::TResultStatus::ExecComplete: {
+                    << ", TxId: " << response.GetTxId()); 
+ 
+                TIssue issue(NYql::TPosition(), "Access denied."); 
+                Promise.SetValue(ResultFromIssues<TResult>(TIssuesIds::KIKIMR_ACCESS_DENIED, 
+                    "Access denied for scheme request", {issue})); 
+                this->Die(ctx); 
+                return; 
+            } 
+ 
+            case TEvTxUserProxy::TResultStatus::ExecComplete: { 
                 if (response.GetSchemeShardStatus() == NKikimrScheme::EStatus::StatusSuccess ||
                     response.GetSchemeShardStatus() == NKikimrScheme::EStatus::StatusAlreadyExists)
-                {
+                { 
                     LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, "Successful completion of scheme request"
-                    << ", TxId: " << response.GetTxId());
-
-                    IKqpGateway::TGenericResult result;
-                    result.SetSuccess();
+                    << ", TxId: " << response.GetTxId()); 
+ 
+                    IKqpGateway::TGenericResult result; 
+                    result.SetSuccess(); 
                     Promise.SetValue(std::move(result));
-                    this->Die(ctx);
-                    return;
-                }
-                break;
-            }
-
-            case TEvTxUserProxy::TResultStatus::ProxyShardNotAvailable: {
-                Promise.SetValue(ResultFromIssues<TResult>(TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE,
-                    "Schemeshard not available", {}));
-                this->Die(ctx);
-                return;
-            }
-
-            case TEvTxUserProxy::TResultStatus::ResolveError: {
-                Promise.SetValue(ResultFromIssues<TResult>(TIssuesIds::KIKIMR_SCHEME_ERROR,
-                    response.GetSchemeShardReason(), {}));
-                this->Die(ctx);
-                return;
-            }
-
+                    this->Die(ctx); 
+                    return; 
+                } 
+                break; 
+            } 
+ 
+            case TEvTxUserProxy::TResultStatus::ProxyShardNotAvailable: { 
+                Promise.SetValue(ResultFromIssues<TResult>(TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE, 
+                    "Schemeshard not available", {})); 
+                this->Die(ctx); 
+                return; 
+            } 
+ 
+            case TEvTxUserProxy::TResultStatus::ResolveError: { 
+                Promise.SetValue(ResultFromIssues<TResult>(TIssuesIds::KIKIMR_SCHEME_ERROR, 
+                    response.GetSchemeShardReason(), {})); 
+                this->Die(ctx); 
+                return; 
+            } 
+ 
             case TEvTxUserProxy::TResultStatus::ExecError:
-                switch (response.GetSchemeShardStatus()) {
+                switch (response.GetSchemeShardStatus()) { 
                     case NKikimrScheme::EStatus::StatusMultipleModifications: {
-                        Promise.SetValue(ResultFromIssues<TResult>(TIssuesIds::KIKIMR_MULTIPLE_SCHEME_MODIFICATIONS,
-                            response.GetSchemeShardReason(), {}));
-                        this->Die(ctx);
-                        return;
-                    }
+                        Promise.SetValue(ResultFromIssues<TResult>(TIssuesIds::KIKIMR_MULTIPLE_SCHEME_MODIFICATIONS, 
+                            response.GetSchemeShardReason(), {})); 
+                        this->Die(ctx); 
+                        return; 
+                    } 
                     case NKikimrScheme::EStatus::StatusPathDoesNotExist: {
                         Promise.SetValue(ResultFromIssues<TResult>(TIssuesIds::KIKIMR_SCHEME_ERROR,
                             response.GetSchemeShardReason(), {}));
                         this->Die(ctx);
                         return;
                     }
-
-                    default:
-                        break;
-                }
+ 
+                    default: 
+                        break; 
+                } 
                 break;
-
-            default:
-                break;
-        }
-
-        LOG_ERROR_S(ctx, NKikimrServices::KQP_GATEWAY, "Unexpected error on scheme request"
-            << ", TxId: " << response.GetTxId()
-            << ", ProxyStatus: " << status
-            << ", SchemeShardReason: " << response.GetSchemeShardReason());
-
-        TStringBuilder message;
-        message << "Scheme operation failed, status: " << status;
-        if (!response.GetSchemeShardReason().empty()) {
-            message << ", reason: " << response.GetSchemeShardReason();
-        }
-
+ 
+            default: 
+                break; 
+        } 
+ 
+        LOG_ERROR_S(ctx, NKikimrServices::KQP_GATEWAY, "Unexpected error on scheme request" 
+            << ", TxId: " << response.GetTxId() 
+            << ", ProxyStatus: " << status 
+            << ", SchemeShardReason: " << response.GetSchemeShardReason()); 
+ 
+        TStringBuilder message; 
+        message << "Scheme operation failed, status: " << status; 
+        if (!response.GetSchemeShardReason().empty()) { 
+            message << ", reason: " << response.GetSchemeShardReason(); 
+        } 
+ 
         Promise.SetValue(ResultFromError<TResult>(TIssue({}, message)));
-        this->Die(ctx);
-    }
-
+        this->Die(ctx); 
+    } 
+ 
     void Handle(TEvSchemeShard::TEvNotifyTxCompletionResult::TPtr& ev, const TActorContext& ctx) {
-        auto& response = ev->Get()->Record;
-
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, "Received TEvNotifyTxCompletionResult for scheme request"
-            << ", TxId: " << response.GetTxId());
-
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, "Successful completion of scheme request"
-            << ", TxId: " << response.GetTxId());
-
-        IKqpGateway::TGenericResult result;
-        result.SetSuccess();
-
+        auto& response = ev->Get()->Record; 
+ 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, "Received TEvNotifyTxCompletionResult for scheme request" 
+            << ", TxId: " << response.GetTxId()); 
+ 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_GATEWAY, "Successful completion of scheme request" 
+            << ", TxId: " << response.GetTxId()); 
+ 
+        IKqpGateway::TGenericResult result; 
+        result.SetSuccess(); 
+ 
         Promise.SetValue(std::move(result));
         NTabletPipe::CloseClient(ctx, ShemePipeActorId);
-        this->Die(ctx);
-    }
-
+        this->Die(ctx); 
+    } 
+ 
     void Handle(TEvSchemeShard::TEvNotifyTxCompletionRegistered::TPtr&, const TActorContext&) {}
-
-    STFUNC(AwaitState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TResponse, HandleResponse);
-            HFunc(TEvTabletPipe::TEvClientConnected, Handle);
-            HFunc(TEvTabletPipe::TEvClientDestroyed, Handle);
+ 
+    STFUNC(AwaitState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TResponse, HandleResponse); 
+            HFunc(TEvTabletPipe::TEvClientConnected, Handle); 
+            HFunc(TEvTabletPipe::TEvClientDestroyed, Handle); 
             HFunc(TEvSchemeShard::TEvNotifyTxCompletionResult, Handle);
             HFunc(TEvSchemeShard::TEvNotifyTxCompletionRegistered, Handle);
-        default:
-            TBase::HandleUnexpectedEvent("TSchemeOpRequestHandler", ev->GetTypeRewrite(), ctx);
-        }
-    }
-
-private:
+        default: 
+            TBase::HandleUnexpectedEvent("TSchemeOpRequestHandler", ev->GetTypeRewrite(), ctx); 
+        } 
+    } 
+ 
+private: 
     TActorId ShemePipeActorId;
-};
-
-class TKqpExecPhysicalRequestHandler: public TActorBootstrapped<TKqpExecPhysicalRequestHandler> {
-public:
-    using TRequest = TEvTxUserProxy::TEvProposeKqpTransaction;
-    using TResult = IKqpGateway::TExecPhysicalResult;
-
+}; 
+ 
+class TKqpExecPhysicalRequestHandler: public TActorBootstrapped<TKqpExecPhysicalRequestHandler> { 
+public: 
+    using TRequest = TEvTxUserProxy::TEvProposeKqpTransaction; 
+    using TResult = IKqpGateway::TExecPhysicalResult; 
+ 
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
-        return NKikimrServices::TActivity::KQP_EXEC_PHYSICAL_REQUEST_HANDLER;
-    }
-
+        return NKikimrServices::TActivity::KQP_EXEC_PHYSICAL_REQUEST_HANDLER; 
+    } 
+ 
     TKqpExecPhysicalRequestHandler(TRequest* request, bool streaming, const TActorId& target, TPromise<TResult> promise)
-        : Request(request)
+        : Request(request) 
         , Streaming(streaming)
         , Executer(request->ExecuterId)
-        , Target(target)
-        , Promise(promise) {}
-
-    void Bootstrap(const TActorContext& ctx) {
-        ctx.Send(MakeTxProxyID(), this->Request.Release());
-
-        Become(&TKqpExecPhysicalRequestHandler::ProcessState);
-    }
-
-private:
-    void Handle(TEvKqpExecuter::TEvStreamData::TPtr &ev, const TActorContext &ctx) {
+        , Target(target) 
+        , Promise(promise) {} 
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        ctx.Send(MakeTxProxyID(), this->Request.Release()); 
+ 
+        Become(&TKqpExecPhysicalRequestHandler::ProcessState); 
+    } 
+ 
+private: 
+    void Handle(TEvKqpExecuter::TEvStreamData::TPtr &ev, const TActorContext &ctx) { 
         if (Streaming) {
             TlsActivationContext->Send(ev->Forward(Target));
         } else {
             HandleUnexpectedEvent(ev->GetTypeRewrite(), ctx);
         }
-    }
-
+    } 
+ 
     void Handle(TEvKqpExecuter::TEvStreamDataAck::TPtr &ev, const TActorContext &ctx) {
         if (Streaming) {
             TlsActivationContext->Send(ev->Forward(Executer));
@@ -863,29 +863,29 @@ private:
 
     void Handle(TEvKqpExecuter::TEvTxResponse::TPtr &ev, const TActorContext &) {
         auto* response = ev->Get()->Record.MutableResponse();
-
-        TResult result;
+ 
+        TResult result; 
         if (response->GetStatus() == Ydb::StatusIds::SUCCESS) {
-            result.SetSuccess();
-        }
+            result.SetSuccess(); 
+        } 
         for (auto& issue : response->GetIssues()) {
-            result.AddIssue(NYql::IssueFromMessage(issue));
-        }
-
-        result.ExecuterResult.Swap(response->MutableResult());
-
-        if (Target && result.ExecuterResult.HasStats()) {
+            result.AddIssue(NYql::IssueFromMessage(issue)); 
+        } 
+ 
+        result.ExecuterResult.Swap(response->MutableResult()); 
+ 
+        if (Target && result.ExecuterResult.HasStats()) { 
             auto statsEv = MakeHolder<TEvKqpExecuter::TEvStreamProfile>();
             auto& record = statsEv->Record;
-
-            record.MutableProfile()->Swap(result.ExecuterResult.MutableStats());
+ 
+            record.MutableProfile()->Swap(result.ExecuterResult.MutableStats()); 
             this->Send(Target, statsEv.Release());
         }
 
-        Promise.SetValue(std::move(result));
+        Promise.SetValue(std::move(result)); 
         this->PassAway();
-    }
-
+    } 
+ 
     void Handle(TEvKqpExecuter::TEvExecuterProgress::TPtr& ev, const TActorContext&) {
         this->Send(Target, ev->Release().Release());
     }
@@ -904,65 +904,65 @@ private:
         this->PassAway();
     }
 
-    void HandleUnexpectedEvent(ui32 eventType, const TActorContext &ctx) {
-        LOG_CRIT_S(ctx, NKikimrServices::KQP_GATEWAY,
-            "TKqpExecPhysicalRequestHandler, unexpected event, type: " << eventType);
-
-        Promise.SetValue(ResultFromError<TResult>(YqlIssue({}, TIssuesIds::UNEXPECTED, TStringBuilder()
-            << "TKqpExecPhysicalRequestHandler, unexpected event, type: " << eventType)));
-
+    void HandleUnexpectedEvent(ui32 eventType, const TActorContext &ctx) { 
+        LOG_CRIT_S(ctx, NKikimrServices::KQP_GATEWAY, 
+            "TKqpExecPhysicalRequestHandler, unexpected event, type: " << eventType); 
+ 
+        Promise.SetValue(ResultFromError<TResult>(YqlIssue({}, TIssuesIds::UNEXPECTED, TStringBuilder() 
+            << "TKqpExecPhysicalRequestHandler, unexpected event, type: " << eventType))); 
+ 
         this->PassAway();
-    }
-
-    STFUNC(ProcessState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TEvKqpExecuter::TEvStreamData, Handle);
+    } 
+ 
+    STFUNC(ProcessState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TEvKqpExecuter::TEvStreamData, Handle); 
             HFunc(TEvKqpExecuter::TEvStreamDataAck, Handle);
-            HFunc(TEvKqpExecuter::TEvTxResponse, Handle);
+            HFunc(TEvKqpExecuter::TEvTxResponse, Handle); 
             HFunc(TEvKqpExecuter::TEvExecuterProgress, Handle);
             HFunc(TEvKqp::TEvAbortExecution, Handle);
-        default:
-            HandleUnexpectedEvent(ev->GetTypeRewrite(), ctx);
-        }
-    }
-
-private:
-    THolder<TRequest> Request;
+        default: 
+            HandleUnexpectedEvent(ev->GetTypeRewrite(), ctx); 
+        } 
+    } 
+ 
+private: 
+    THolder<TRequest> Request; 
     bool Streaming;
     TActorId Executer;
     TActorId Target;
-    TPromise<TResult> Promise;
-};
-
-template<typename TResult>
+    TPromise<TResult> Promise; 
+}; 
+ 
+template<typename TResult> 
 TFuture<TResult> InvalidCluster(const TString& cluster) {
-    return MakeFuture(ResultFromError<TResult>("Invalid cluster:" + cluster));
-}
-
-void KqpResponseToQueryResult(const NKikimrKqp::TEvQueryResponse& response, IKqpGateway::TQueryResult& queryResult) {
-    auto& queryResponse = response.GetResponse();
-
-    if (response.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-        queryResult.SetSuccess();
-    }
-
-    for (auto& issue : queryResponse.GetQueryIssues()) {
-        queryResult.AddIssue(NYql::IssueFromMessage(issue));
-    }
-
-    for (auto& result : queryResponse.GetResults()) {
-        auto arenaResult = google::protobuf::Arena::CreateMessage<NKikimrMiniKQL::TResult>(
-            queryResult.ProtobufArenaPtr.get());
-
-        arenaResult->CopyFrom(result);
-        queryResult.Results.push_back(arenaResult);
-    }
-
-    queryResult.QueryAst = queryResponse.GetQueryAst();
-    queryResult.QueryPlan = queryResponse.GetQueryPlan();
-    queryResult.QueryStats = queryResponse.GetQueryStats();
-}
-
+    return MakeFuture(ResultFromError<TResult>("Invalid cluster:" + cluster)); 
+} 
+ 
+void KqpResponseToQueryResult(const NKikimrKqp::TEvQueryResponse& response, IKqpGateway::TQueryResult& queryResult) { 
+    auto& queryResponse = response.GetResponse(); 
+ 
+    if (response.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+        queryResult.SetSuccess(); 
+    } 
+ 
+    for (auto& issue : queryResponse.GetQueryIssues()) { 
+        queryResult.AddIssue(NYql::IssueFromMessage(issue)); 
+    } 
+ 
+    for (auto& result : queryResponse.GetResults()) { 
+        auto arenaResult = google::protobuf::Arena::CreateMessage<NKikimrMiniKQL::TResult>( 
+            queryResult.ProtobufArenaPtr.get()); 
+ 
+        arenaResult->CopyFrom(result); 
+        queryResult.Results.push_back(arenaResult); 
+    } 
+ 
+    queryResult.QueryAst = queryResponse.GetQueryAst(); 
+    queryResult.QueryPlan = queryResponse.GetQueryPlan(); 
+    queryResult.QueryStats = queryResponse.GetQueryStats(); 
+} 
+ 
 namespace {
     struct TSendRoleWrapper : public TThrRefBase {
         using TMethod = std::function<void(TString&&, NYql::TAlterGroupSettings::EAction, std::vector<TString>&&)>;
@@ -970,60 +970,60 @@ namespace {
     };
 }
 
-class TKikimrIcGateway : public IKqpGateway {
-private:
-    struct TUserTokenData {
-        TString Serialized;
-        NACLib::TUserToken Data;
-
-        TUserTokenData(const TString& serialized)
-            : Serialized(serialized)
-            , Data(serialized) {}
-    };
+class TKikimrIcGateway : public IKqpGateway { 
+private: 
+    struct TUserTokenData { 
+        TString Serialized; 
+        NACLib::TUserToken Data; 
+ 
+        TUserTokenData(const TString& serialized) 
+            : Serialized(serialized) 
+            , Data(serialized) {} 
+    }; 
     using TNavigate = NSchemeCache::TSchemeCacheNavigate;
-
-public:
+ 
+public: 
     TKikimrIcGateway(const TString& cluster, const TString& database, std::shared_ptr<IKqpTableMetadataLoader>&& metadataLoader,
         TActorSystem* actorSystem, ui32 nodeId, TKqpRequestCounters::TPtr counters, const TActorId& mkqlComplileService)
-        : Cluster(cluster)
-        , Database(database)
+        : Cluster(cluster) 
+        , Database(database) 
         , ActorSystem(actorSystem)
         , NodeId(nodeId)
         , Counters(counters)
         , MetadataLoader(std::move(metadataLoader))
         , MkqlComplileService(mkqlComplileService)
     {}
-
-    bool HasCluster(const TString& cluster) override {
-        return cluster == Cluster;
-    }
-
+ 
+    bool HasCluster(const TString& cluster) override { 
+        return cluster == Cluster; 
+    } 
+ 
     TVector<TString> GetClusters() override {
-        return {Cluster};
-    }
-
-    TString GetDefaultCluster() override {
-        return Cluster;
-    }
-
+        return {Cluster}; 
+    } 
+ 
+    TString GetDefaultCluster() override { 
+        return Cluster; 
+    } 
+ 
     TMaybe<NYql::TKikimrClusterConfig> GetClusterConfig(const TString& cluster) override {
         Y_UNUSED(cluster);
         return {};
     }
 
     TMaybe<TString> GetSetting(const TString& cluster, const TString& name) override {
-        Y_UNUSED(cluster);
-        Y_UNUSED(name);
-        return {};
-    }
-
-    void SetToken(const TString& cluster, const TString& token) override {
-        YQL_ENSURE(cluster == Cluster);
-        if (!token.empty()) {
-            UserToken = TUserTokenData(token);
-        }
-    }
-
+        Y_UNUSED(cluster); 
+        Y_UNUSED(name); 
+        return {}; 
+    } 
+ 
+    void SetToken(const TString& cluster, const TString& token) override { 
+        YQL_ENSURE(cluster == Cluster); 
+        if (!token.empty()) { 
+            UserToken = TUserTokenData(token); 
+        } 
+    } 
+ 
     TVector<TString> GetCollectedSchemeData() override {
         return MetadataLoader->GetCollectedSchemeData();
     }
@@ -1033,37 +1033,37 @@ public:
     }
 
     TFuture<TListPathResult> ListPath(const TString& cluster, const TString &path) override {
-        using TRequest = TEvTxUserProxy::TEvNavigate;
-
-        try {
-            if (!CheckCluster(cluster)) {
-                return InvalidCluster<TListPathResult>(cluster);
-            }
-
-            auto ev = MakeHolder<TRequest>();
+        using TRequest = TEvTxUserProxy::TEvNavigate; 
+ 
+        try { 
+            if (!CheckCluster(cluster)) { 
+                return InvalidCluster<TListPathResult>(cluster); 
+            } 
+ 
+            auto ev = MakeHolder<TRequest>(); 
             ev->Record.SetDatabaseName(Database);
-            if (UserToken) {
-                ev->Record.SetUserToken(UserToken->Serialized);
-            }
-            auto& describePath = *ev->Record.MutableDescribePath();
-            describePath.SetPath(CanonizePath(path));
-
-            return SendProxyRequest<TRequest, TDescribeSchemeResponse, TListPathResult>(ev.Release(),
-                [path] (TPromise<TListPathResult> promise, TDescribeSchemeResponse&& response) {
-                    try {
-                        promise.SetValue(GetListPathResult(
+            if (UserToken) { 
+                ev->Record.SetUserToken(UserToken->Serialized); 
+            } 
+            auto& describePath = *ev->Record.MutableDescribePath(); 
+            describePath.SetPath(CanonizePath(path)); 
+ 
+            return SendProxyRequest<TRequest, TDescribeSchemeResponse, TListPathResult>(ev.Release(), 
+                [path] (TPromise<TListPathResult> promise, TDescribeSchemeResponse&& response) { 
+                    try { 
+                        promise.SetValue(GetListPathResult( 
                             response.GetRecord().GetPathDescription(), path));
-                    }
-                    catch (yexception& e) {
-                        promise.SetValue(ResultFromException<TListPathResult>(e));
-                    }
-                });
-        }
-        catch (yexception& e) {
-            return MakeFuture(ResultFromException<TListPathResult>(e));
-        }
-    }
-
+                    } 
+                    catch (yexception& e) { 
+                        promise.SetValue(ResultFromException<TListPathResult>(e)); 
+                    } 
+                }); 
+        } 
+        catch (yexception& e) { 
+            return MakeFuture(ResultFromException<TListPathResult>(e)); 
+        } 
+    } 
+ 
     static ui64 GetExpectedVersion(const std::pair<TIndexId, TString>& pathId) {
         return pathId.first.SchemaVersion;
     }
@@ -1074,7 +1074,7 @@ public:
 
     TFuture<TTableMetadataResult> LoadTableMetadata(const TString& cluster, const TString& table,
         TLoadTableMetadataSettings settings) override {
-        try {
+        try { 
             if (!CheckCluster(cluster)) {
                 return InvalidCluster<TTableMetadataResult>(cluster);
             }
@@ -1086,67 +1086,67 @@ public:
 
         } catch (yexception& e) {
             return MakeFuture(ResultFromException<TTableMetadataResult>(e));
-        }
-    }
-
+        } 
+    } 
+ 
     TFuture<TGenericResult> CreateTable(NYql::TKikimrTableMetadataPtr metadata, bool createDir) override {
-        using TRequest = TEvTxUserProxy::TEvProposeTransaction;
-
-        try {
-            if (!CheckCluster(metadata->Cluster)) {
-                return InvalidCluster<TGenericResult>(metadata->Cluster);
-            }
-
-            std::pair<TString, TString> pathPair;
-            if (createDir) {
-                TString error;
+        using TRequest = TEvTxUserProxy::TEvProposeTransaction; 
+ 
+        try { 
+            if (!CheckCluster(metadata->Cluster)) { 
+                return InvalidCluster<TGenericResult>(metadata->Cluster); 
+            } 
+ 
+            std::pair<TString, TString> pathPair; 
+            if (createDir) { 
+                TString error; 
                 if (!TrySplitPathByDb(metadata->Name, Database, pathPair, error)) {
-                    return MakeFuture(ResultFromError<TGenericResult>(error));
-                }
-            } else {
-                TString error;
-                if (!TrySplitTablePath(metadata->Name, pathPair, error)) {
-                    return MakeFuture(ResultFromError<TGenericResult>(error));
-                }
-            }
-
-            using TConfigRequest = NConsole::TEvConfigsDispatcher::TEvGetConfigRequest;
-            using TConfigResponse = NConsole::TEvConfigsDispatcher::TEvGetConfigResponse;
-
-            ui32 configKind = (ui32)NKikimrConsole::TConfigItem::TableProfilesConfigItem;
-            auto ev = MakeHolder<TConfigRequest>(configKind);
-
-            auto configsDispatcherId = NConsole::MakeConfigsDispatcherID(NodeId);
-            auto configFuture = SendActorRequest<TConfigRequest, TConfigResponse, TAppConfigResult>(
-                configsDispatcherId,
-                ev.Release(),
-                [](TPromise<TAppConfigResult> promise, TConfigResponse&& response) mutable {
-                    TAppConfigResult result;
-                    result.SetSuccess();
-                    result.Config = response.Config;
-                    promise.SetValue(result);
-                });
-
-            auto tablePromise = NewPromise<TGenericResult>();
-
-            configFuture.Subscribe([this, metadata, tablePromise, pathPair]
-                (const TFuture<TAppConfigResult>& future) mutable {
-                    auto configResult = future.GetValue();
-                    if (!configResult.Success()) {
-                        tablePromise.SetValue(configResult);
-                        return;
-                    }
-
-                    NGRpcService::TTableProfiles profiles;
-                    profiles.Load(configResult.Config->GetTableProfilesConfig());
-
-                    auto ev = MakeHolder<TRequest>();
+                    return MakeFuture(ResultFromError<TGenericResult>(error)); 
+                } 
+            } else { 
+                TString error; 
+                if (!TrySplitTablePath(metadata->Name, pathPair, error)) { 
+                    return MakeFuture(ResultFromError<TGenericResult>(error)); 
+                } 
+            } 
+ 
+            using TConfigRequest = NConsole::TEvConfigsDispatcher::TEvGetConfigRequest; 
+            using TConfigResponse = NConsole::TEvConfigsDispatcher::TEvGetConfigResponse; 
+
+            ui32 configKind = (ui32)NKikimrConsole::TConfigItem::TableProfilesConfigItem; 
+            auto ev = MakeHolder<TConfigRequest>(configKind); 
+ 
+            auto configsDispatcherId = NConsole::MakeConfigsDispatcherID(NodeId); 
+            auto configFuture = SendActorRequest<TConfigRequest, TConfigResponse, TAppConfigResult>( 
+                configsDispatcherId, 
+                ev.Release(), 
+                [](TPromise<TAppConfigResult> promise, TConfigResponse&& response) mutable { 
+                    TAppConfigResult result; 
+                    result.SetSuccess(); 
+                    result.Config = response.Config; 
+                    promise.SetValue(result); 
+                }); 
+ 
+            auto tablePromise = NewPromise<TGenericResult>(); 
+ 
+            configFuture.Subscribe([this, metadata, tablePromise, pathPair] 
+                (const TFuture<TAppConfigResult>& future) mutable { 
+                    auto configResult = future.GetValue(); 
+                    if (!configResult.Success()) { 
+                        tablePromise.SetValue(configResult); 
+                        return; 
+                    } 
+ 
+                    NGRpcService::TTableProfiles profiles; 
+                    profiles.Load(configResult.Config->GetTableProfilesConfig()); 
+ 
+                    auto ev = MakeHolder<TRequest>(); 
                     ev->Record.SetDatabaseName(Database);
-                    if (UserToken) {
-                        ev->Record.SetUserToken(UserToken->Serialized);
-                    }
-                    auto& schemeTx = *ev->Record.MutableTransaction()->MutableModifyScheme();
-                    schemeTx.SetWorkingDir(pathPair.first);
+                    if (UserToken) { 
+                        ev->Record.SetUserToken(UserToken->Serialized); 
+                    } 
+                    auto& schemeTx = *ev->Record.MutableTransaction()->MutableModifyScheme(); 
+                    schemeTx.SetWorkingDir(pathPair.first); 
                     NKikimrSchemeOp::TTableDescription* tableDesc = nullptr;
                     if (!metadata->Indexes.empty()) {
                         schemeTx.SetOperationType(NKikimrSchemeOp::ESchemeOpCreateIndexedTable);
@@ -1178,19 +1178,19 @@ public:
                         FillCreateTableColumnDesc(*tableDesc, pathPair.second, metadata);
                     }
 
-                    Ydb::StatusIds::StatusCode code;
-                    TString error;
+                    Ydb::StatusIds::StatusCode code; 
+                    TString error; 
                     TList<TString> warnings;
 
                     if (!FillCreateTableDesc(metadata, *tableDesc, profiles, code, error, warnings)) {
-                        IKqpGateway::TGenericResult errResult;
-                        errResult.AddIssue(NYql::TIssue(error));
+                        IKqpGateway::TGenericResult errResult; 
+                        errResult.AddIssue(NYql::TIssue(error)); 
                         errResult.SetStatus(NYql::YqlStatusFromYdbStatus(code));
-                        tablePromise.SetValue(errResult);
-                        return;
-                    }
+                        tablePromise.SetValue(errResult); 
+                        return; 
+                    } 
 
-                    SendSchemeRequest(ev.Release()).Apply(
+                    SendSchemeRequest(ev.Release()).Apply( 
                         [tablePromise, warnings{std::move(warnings)}](const TFuture<TGenericResult>& future) mutable {
                             if (warnings.size()) {
                                 auto result = future.GetValue();
@@ -1204,16 +1204,16 @@ public:
                             } else {
                                 tablePromise.SetValue(future.GetValue());
                             }
-                        });
-                });
-
-            return tablePromise.GetFuture();
-        }
-        catch (yexception& e) {
-            return MakeFuture(ResultFromException<TGenericResult>(e));
-        }
-    }
-
+                        }); 
+                }); 
+ 
+            return tablePromise.GetFuture(); 
+        } 
+        catch (yexception& e) { 
+            return MakeFuture(ResultFromException<TGenericResult>(e)); 
+        } 
+    } 
+ 
     TFuture<TGenericResult> AlterTable(Ydb::Table::AlterTableRequest&& req, const TString& cluster) override {
         try {
             if (!CheckCluster(cluster)) {
@@ -1266,11 +1266,11 @@ public:
     }
 
     TFuture<TGenericResult> DropTable(const TString& cluster, const TString& table) override {
-        try {
-            if (!CheckCluster(cluster)) {
-                return InvalidCluster<TGenericResult>(cluster);
-            }
-
+        try { 
+            if (!CheckCluster(cluster)) { 
+                return InvalidCluster<TGenericResult>(cluster); 
+            } 
+ 
             Ydb::Table::DropTableRequest dropTable;
             dropTable.set_path(table);
 
@@ -1279,12 +1279,12 @@ public:
             using TEvDropTableRequest = TGRpcRequestWrapper<TRpcServices::EvDropTable, Ydb::Table::DropTableRequest, Ydb::Table::DropTableResponse, true, TRateLimiterMode::Rps>;
 
             return SendLocalRpcRequestNoResult<TEvDropTableRequest>(std::move(dropTable), Database, GetTokenCompat());
-        }
-        catch (yexception& e) {
-            return MakeFuture(ResultFromException<TGenericResult>(e));
-        }
-    }
-
+        } 
+        catch (yexception& e) { 
+            return MakeFuture(ResultFromException<TGenericResult>(e)); 
+        } 
+    } 
+ 
     TFuture<TGenericResult> CreateUser(const TString& cluster, const NYql::TCreateUserSettings& settings) override {
         using TRequest = TEvTxUserProxy::TEvProposeTransaction;
 
@@ -1594,26 +1594,26 @@ public:
         }
     }
 
-    TFuture<TMkqlResult> ExecuteMkql(const TString& cluster, const TString& program,
-        TKqpParamsMap&& params, const TMkqlSettings& settings, const TKqpSnapshot& snapshot) override
-    {
+    TFuture<TMkqlResult> ExecuteMkql(const TString& cluster, const TString& program, 
+        TKqpParamsMap&& params, const TMkqlSettings& settings, const TKqpSnapshot& snapshot) override 
+    { 
         return RunInternal(cluster, program, std::move(params), false, false, settings, snapshot);
-    }
-
-    TFuture<TMkqlResult> ExecuteMkqlPrepared(const TString& cluster, const TString& program,
-        TKqpParamsMap&& params, const TMkqlSettings& settings, const TKqpSnapshot& snapshot) override
-    {
+    } 
+ 
+    TFuture<TMkqlResult> ExecuteMkqlPrepared(const TString& cluster, const TString& program, 
+        TKqpParamsMap&& params, const TMkqlSettings& settings, const TKqpSnapshot& snapshot) override 
+    { 
         return RunInternal(cluster, program, std::move(params), false, true, settings, snapshot);
-    }
-
-    TFuture<TMkqlResult> PrepareMkql(const TString& cluster, const TString& program) override {
-        return RunInternal(cluster, program, TKqpParamsMap(), true, false, TMkqlSettings());
-    }
-
+    } 
+ 
+    TFuture<TMkqlResult> PrepareMkql(const TString& cluster, const TString& program) override { 
+        return RunInternal(cluster, program, TKqpParamsMap(), true, false, TMkqlSettings()); 
+    } 
+ 
     TFuture<TExecPhysicalResult> ExecutePhysical(TExecPhysicalRequest&& request, const NActors::TActorId& target) override {
-        return ExecutePhysicalQueryInternal(std::move(request), target, false);
-    }
-
+        return ExecutePhysicalQueryInternal(std::move(request), target, false); 
+    } 
+ 
     TFuture<TExecPhysicalResult> ExecutePure(TExecPhysicalRequest&& request, const NActors::TActorId& target) override {
         YQL_ENSURE(!request.Transactions.empty());
         YQL_ENSURE(request.Locks.empty());
@@ -1638,40 +1638,40 @@ public:
         return ExecutePhysicalQueryInternal(std::move(request), target, false);
     }
 
-    TFuture<TQueryResult> ExecScanQueryAst(const TString& cluster, const TString& query,
-        TKqpParamsMap&& params, const TAstQuerySettings& settings, ui64 rowsLimit) override
-    {
-        using TRequest = NKqp::TEvKqp::TEvQueryRequest;
-        using TResponse = NKqp::TEvKqp::TEvQueryResponse;
-
-        auto ev = MakeHolder<TRequest>();
-        if (UserToken) {
-            ev->Record.SetUserToken(UserToken->Serialized);
-        }
-
-        ev->Record.MutableRequest()->SetDatabase(Database);
-        ev->Record.MutableRequest()->SetCluster(cluster);
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
-        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_AST_SCAN);
-        ev->Record.MutableRequest()->SetQuery(query);
-        ev->Record.MutableRequest()->SetKeepSession(false);
-        ev->Record.MutableRequest()->SetStatsMode(settings.StatsMode);
-
-        if (!params.Values.empty()) {
-            FillParameters(std::move(params), *ev->Record.MutableRequest()->MutableParameters());
-        }
-
-        return SendKqpScanQueryRequest(ev.Release(), rowsLimit,
-            [] (TPromise<TQueryResult> promise, TResponse&& responseEv) {
-                TQueryResult queryResult;
-                queryResult.ProtobufArenaPtr.reset(new google::protobuf::Arena());
-                KqpResponseToQueryResult(responseEv.Record.GetRef(), queryResult);
+    TFuture<TQueryResult> ExecScanQueryAst(const TString& cluster, const TString& query, 
+        TKqpParamsMap&& params, const TAstQuerySettings& settings, ui64 rowsLimit) override 
+    { 
+        using TRequest = NKqp::TEvKqp::TEvQueryRequest; 
+        using TResponse = NKqp::TEvKqp::TEvQueryResponse; 
+ 
+        auto ev = MakeHolder<TRequest>(); 
+        if (UserToken) { 
+            ev->Record.SetUserToken(UserToken->Serialized); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetDatabase(Database); 
+        ev->Record.MutableRequest()->SetCluster(cluster); 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE); 
+        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_AST_SCAN); 
+        ev->Record.MutableRequest()->SetQuery(query); 
+        ev->Record.MutableRequest()->SetKeepSession(false); 
+        ev->Record.MutableRequest()->SetStatsMode(settings.StatsMode); 
+ 
+        if (!params.Values.empty()) { 
+            FillParameters(std::move(params), *ev->Record.MutableRequest()->MutableParameters()); 
+        } 
+ 
+        return SendKqpScanQueryRequest(ev.Release(), rowsLimit, 
+            [] (TPromise<TQueryResult> promise, TResponse&& responseEv) { 
+                TQueryResult queryResult; 
+                queryResult.ProtobufArenaPtr.reset(new google::protobuf::Arena()); 
+                KqpResponseToQueryResult(responseEv.Record.GetRef(), queryResult); 
                 promise.SetValue(std::move(queryResult));
-            });
-    }
-
+            }); 
+    } 
+ 
     TFuture<TQueryResult> StreamExecDataQueryAst(const TString& cluster, const TString& query,
-        TKqpParamsMap&& params, const TAstQuerySettings& settings,
+        TKqpParamsMap&& params, const TAstQuerySettings& settings, 
         const Ydb::Table::TransactionSettings& txSettings, const NActors::TActorId& target) override
     {
         using TRequest = NKqp::TEvKqp::TEvQueryRequest;
@@ -1690,7 +1690,7 @@ public:
         ev->Record.MutableRequest()->SetKeepSession(false);
         ev->Record.MutableRequest()->SetStatsMode(settings.StatsMode);
 
-        if (!params.Values.empty()) {
+        if (!params.Values.empty()) { 
             FillParameters(std::move(params), *ev->Record.MutableRequest()->MutableParameters());
         }
 
@@ -1711,7 +1711,7 @@ public:
     }
 
     TFuture<TQueryResult> StreamExecScanQueryAst(const TString& cluster, const TString& query,
-        TKqpParamsMap&& params, const TAstQuerySettings& settings, const NActors::TActorId& target) override
+        TKqpParamsMap&& params, const TAstQuerySettings& settings, const NActors::TActorId& target) override 
     {
         using TRequest = NKqp::TEvKqp::TEvQueryRequest;
         using TResponse = NKqp::TEvKqp::TEvQueryResponse;
@@ -1729,7 +1729,7 @@ public:
         ev->Record.MutableRequest()->SetKeepSession(false);
         ev->Record.MutableRequest()->SetStatsMode(settings.StatsMode);
 
-        if (!params.Values.empty()) {
+        if (!params.Values.empty()) { 
             FillParameters(std::move(params), *ev->Record.MutableRequest()->MutableParameters());
         }
 
@@ -1768,88 +1768,88 @@ public:
             });
     }
 
-    TFuture<TQueryResult> ExecDataQueryAst(const TString& cluster, const TString& query, TKqpParamsMap&& params,
-        const TAstQuerySettings& settings, const Ydb::Table::TransactionSettings& txSettings) override
-    {
-        using TRequest = NKqp::TEvKqp::TEvQueryRequest;
-        using TResponse = NKqp::TEvKqp::TEvQueryResponse;
-
-        auto ev = MakeHolder<TRequest>();
-        if (UserToken) {
-            ev->Record.SetUserToken(UserToken->Serialized);
-        }
-
-        ev->Record.MutableRequest()->SetDatabase(Database);
-        ev->Record.MutableRequest()->SetCluster(cluster);
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
-        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_AST_DML);
-        ev->Record.MutableRequest()->SetQuery(query);
-        ev->Record.MutableRequest()->SetKeepSession(false);
-        ev->Record.MutableRequest()->SetStatsMode(settings.StatsMode);
-
-        if (!params.Values.empty()) {
-            FillParameters(std::move(params), *ev->Record.MutableRequest()->MutableParameters());
-        }
-
+    TFuture<TQueryResult> ExecDataQueryAst(const TString& cluster, const TString& query, TKqpParamsMap&& params, 
+        const TAstQuerySettings& settings, const Ydb::Table::TransactionSettings& txSettings) override 
+    { 
+        using TRequest = NKqp::TEvKqp::TEvQueryRequest; 
+        using TResponse = NKqp::TEvKqp::TEvQueryResponse; 
+ 
+        auto ev = MakeHolder<TRequest>(); 
+        if (UserToken) { 
+            ev->Record.SetUserToken(UserToken->Serialized); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetDatabase(Database); 
+        ev->Record.MutableRequest()->SetCluster(cluster); 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE); 
+        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_AST_DML); 
+        ev->Record.MutableRequest()->SetQuery(query); 
+        ev->Record.MutableRequest()->SetKeepSession(false); 
+        ev->Record.MutableRequest()->SetStatsMode(settings.StatsMode); 
+ 
+        if (!params.Values.empty()) { 
+            FillParameters(std::move(params), *ev->Record.MutableRequest()->MutableParameters()); 
+        } 
+ 
         //auto& querySettings = *ev->Record.MutableRequest()->MutableQuerySettings();
         //querySettings.set_use_new_engine(NYql::GetFlagValue(settings.UseNewEngine));
-
-        auto& txControl = *ev->Record.MutableRequest()->MutableTxControl();
-        txControl.mutable_begin_tx()->CopyFrom(txSettings);
-        txControl.set_commit_tx(true);
-
-        return SendKqpRequest<TRequest, TResponse, TQueryResult>(ev.Release(),
-            [] (TPromise<TQueryResult> promise, TResponse&& responseEv) {
-                TQueryResult queryResult;
-                queryResult.ProtobufArenaPtr.reset(new google::protobuf::Arena());
-                KqpResponseToQueryResult(responseEv.Record.GetRef(), queryResult);
+ 
+        auto& txControl = *ev->Record.MutableRequest()->MutableTxControl(); 
+        txControl.mutable_begin_tx()->CopyFrom(txSettings); 
+        txControl.set_commit_tx(true); 
+ 
+        return SendKqpRequest<TRequest, TResponse, TQueryResult>(ev.Release(), 
+            [] (TPromise<TQueryResult> promise, TResponse&& responseEv) { 
+                TQueryResult queryResult; 
+                queryResult.ProtobufArenaPtr.reset(new google::protobuf::Arena()); 
+                KqpResponseToQueryResult(responseEv.Record.GetRef(), queryResult); 
                 promise.SetValue(std::move(queryResult));
-            });
-    }
-
-    TFuture<TQueryResult> ExplainDataQueryAst(const TString& cluster, const TString& query) override {
-        using TRequest = NKqp::TEvKqp::TEvQueryRequest;
-        using TResponse = NKqp::TEvKqp::TEvQueryResponse;
-
-        auto ev = MakeHolder<TRequest>();
-        if (UserToken) {
-            ev->Record.SetUserToken(UserToken->Serialized);
-        }
-
-        ev->Record.MutableRequest()->SetDatabase(Database);
-        ev->Record.MutableRequest()->SetCluster(cluster);
-        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXPLAIN);
-        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_AST_DML);
-        ev->Record.MutableRequest()->SetQuery(query);
-        ev->Record.MutableRequest()->SetKeepSession(false);
-
-        return SendKqpRequest<TRequest, TResponse, TQueryResult>(ev.Release(),
-            [] (TPromise<TQueryResult> promise, TResponse&& responseEv) {
-                auto& response = responseEv.Record.GetRef();
-                auto& queryResponse = response.GetResponse();
-
-                TQueryResult queryResult;
-                queryResult.ProtobufArenaPtr.reset(new google::protobuf::Arena());
-
-                if (response.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
-                    queryResult.SetSuccess();
-                }
-
-                for (auto& issue : queryResponse.GetQueryIssues()) {
-                    queryResult.AddIssue(NYql::IssueFromMessage(issue));
-                }
-
-                queryResult.QueryAst = queryResponse.GetQueryAst();
-                queryResult.QueryPlan = queryResponse.GetQueryPlan();
-
+            }); 
+    } 
+ 
+    TFuture<TQueryResult> ExplainDataQueryAst(const TString& cluster, const TString& query) override { 
+        using TRequest = NKqp::TEvKqp::TEvQueryRequest; 
+        using TResponse = NKqp::TEvKqp::TEvQueryResponse; 
+ 
+        auto ev = MakeHolder<TRequest>(); 
+        if (UserToken) { 
+            ev->Record.SetUserToken(UserToken->Serialized); 
+        } 
+ 
+        ev->Record.MutableRequest()->SetDatabase(Database); 
+        ev->Record.MutableRequest()->SetCluster(cluster); 
+        ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXPLAIN); 
+        ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_AST_DML); 
+        ev->Record.MutableRequest()->SetQuery(query); 
+        ev->Record.MutableRequest()->SetKeepSession(false); 
+ 
+        return SendKqpRequest<TRequest, TResponse, TQueryResult>(ev.Release(), 
+            [] (TPromise<TQueryResult> promise, TResponse&& responseEv) { 
+                auto& response = responseEv.Record.GetRef(); 
+                auto& queryResponse = response.GetResponse(); 
+ 
+                TQueryResult queryResult; 
+                queryResult.ProtobufArenaPtr.reset(new google::protobuf::Arena()); 
+ 
+                if (response.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
+                    queryResult.SetSuccess(); 
+                } 
+ 
+                for (auto& issue : queryResponse.GetQueryIssues()) { 
+                    queryResult.AddIssue(NYql::IssueFromMessage(issue)); 
+                } 
+ 
+                queryResult.QueryAst = queryResponse.GetQueryAst(); 
+                queryResult.QueryPlan = queryResponse.GetQueryPlan(); 
+ 
                 promise.SetValue(std::move(queryResult));
-            });
-    }
-
+            }); 
+    } 
+ 
     TFuture<TExecPhysicalResult> ExecuteScanQuery(TExecPhysicalRequest&& request, const TActorId& target) override {
-        return ExecutePhysicalQueryInternal(std::move(request), target, true);
-    }
-
+        return ExecutePhysicalQueryInternal(std::move(request), target, true); 
+    } 
+ 
     TFuture<TKqpSnapshotHandle> CreatePersistentSnapshot(const TVector<TString>& tablePaths, TDuration queryTimeout) override {
         auto* snapMgr = CreateKqpSnapshotManager(Database, queryTimeout);
         auto snapMgrActorId = RegisterActor(snapMgr);
@@ -1910,50 +1910,50 @@ public:
         return TAppData::TimeProvider->Now();
     }
 
-private:
+private: 
     using TDescribeSchemeResponse = TEvSchemeShard::TEvDescribeSchemeResult;
-    using TTransactionResponse = TEvTxUserProxy::TEvProposeTransactionStatus;
-
-private:
+    using TTransactionResponse = TEvTxUserProxy::TEvProposeTransactionStatus; 
+ 
+private: 
     TActorId RegisterActor(IActor* actor) {
-        return ActorSystem->Register(actor, TMailboxType::HTSwap, ActorSystem->AppData<TAppData>()->UserPoolId);
-    }
-
-    template<typename TRequest, typename TResponse, typename TResult>
-    TFuture<TResult> SendProxyRequest(TRequest* request,
-        typename TProxyRequestHandler<TRequest, TResponse, TResult>::TCallbackFunc callback)
-    {
-        auto promise = NewPromise<TResult>();
-        IActor* requestHandler = new TProxyRequestHandler<TRequest, TResponse, TResult>(request,
-            promise, callback);
-        RegisterActor(requestHandler);
-
-        return promise.GetFuture();
-    }
-
-    template<typename TRequest, typename TResponse, typename TResult>
-    TFuture<TResult> SendKqpRequest(TRequest* request,
-        typename TKqpRequestHandler<TRequest, TResponse, TResult>::TCallbackFunc callback)
-    {
-        auto promise = NewPromise<TResult>();
-        IActor* requestHandler = new TKqpRequestHandler<TRequest, TResponse, TResult>(request,
-            promise, callback);
-        RegisterActor(requestHandler);
-
-        return promise.GetFuture();
-    }
-
-    TFuture<TQueryResult> SendKqpScanQueryRequest(NKqp::TEvKqp::TEvQueryRequest* request, ui64 rowsLimit,
-        TKqpScanQueryRequestHandler::TCallbackFunc callback)
-    {
-        auto promise = NewPromise<TQueryResult>();
-        IActor* requestHandler = new TKqpScanQueryRequestHandler(request, rowsLimit, promise, callback);
-        RegisterActor(requestHandler);
-
-        return promise.GetFuture();
-    }
-
-    template<typename TRequest, typename TResponse, typename TResult>
+        return ActorSystem->Register(actor, TMailboxType::HTSwap, ActorSystem->AppData<TAppData>()->UserPoolId); 
+    } 
+ 
+    template<typename TRequest, typename TResponse, typename TResult> 
+    TFuture<TResult> SendProxyRequest(TRequest* request, 
+        typename TProxyRequestHandler<TRequest, TResponse, TResult>::TCallbackFunc callback) 
+    { 
+        auto promise = NewPromise<TResult>(); 
+        IActor* requestHandler = new TProxyRequestHandler<TRequest, TResponse, TResult>(request, 
+            promise, callback); 
+        RegisterActor(requestHandler); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
+    template<typename TRequest, typename TResponse, typename TResult> 
+    TFuture<TResult> SendKqpRequest(TRequest* request, 
+        typename TKqpRequestHandler<TRequest, TResponse, TResult>::TCallbackFunc callback) 
+    { 
+        auto promise = NewPromise<TResult>(); 
+        IActor* requestHandler = new TKqpRequestHandler<TRequest, TResponse, TResult>(request, 
+            promise, callback); 
+        RegisterActor(requestHandler); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
+    TFuture<TQueryResult> SendKqpScanQueryRequest(NKqp::TEvKqp::TEvQueryRequest* request, ui64 rowsLimit, 
+        TKqpScanQueryRequestHandler::TCallbackFunc callback) 
+    { 
+        auto promise = NewPromise<TQueryResult>(); 
+        IActor* requestHandler = new TKqpScanQueryRequestHandler(request, rowsLimit, promise, callback); 
+        RegisterActor(requestHandler); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
+    template<typename TRequest, typename TResponse, typename TResult> 
     TFuture<TResult> SendKqpStreamRequest(TRequest* request, const NActors::TActorId& target,
         typename TKqpStreamRequestHandler<TRequest, TResponse, TResult>::TCallbackFunc callback)
     {
@@ -1977,36 +1977,36 @@ private:
 
     template<typename TRequest, typename TResponse, typename TResult>
     TFuture<TResult> SendActorRequest(const TActorId& actorId, TRequest* request,
-        typename TActorRequestHandler<TRequest, TResponse, TResult>::TCallbackFunc callback)
-    {
-        auto promise = NewPromise<TResult>();
-        IActor* requestHandler = new TActorRequestHandler<TRequest, TResponse, TResult>(actorId, request,
-            promise, callback);
-        RegisterActor(requestHandler);
-
-        return promise.GetFuture();
-    }
-
-    TFuture<TMkqlResult> SendMkqlRequest(TEvTxUserProxy::TEvProposeTransaction* request,
-        TKqpParamsMap&& paramsMap, TMkqlRequestHandler::TCallbackFunc callback)
-    {
-        auto promise = NewPromise<TMkqlResult>();
+        typename TActorRequestHandler<TRequest, TResponse, TResult>::TCallbackFunc callback) 
+    { 
+        auto promise = NewPromise<TResult>(); 
+        IActor* requestHandler = new TActorRequestHandler<TRequest, TResponse, TResult>(actorId, request, 
+            promise, callback); 
+        RegisterActor(requestHandler); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
+    TFuture<TMkqlResult> SendMkqlRequest(TEvTxUserProxy::TEvProposeTransaction* request, 
+        TKqpParamsMap&& paramsMap, TMkqlRequestHandler::TCallbackFunc callback) 
+    { 
+        auto promise = NewPromise<TMkqlResult>(); 
         IActor* requestHandler = new TMkqlRequestHandler(Counters->Counters->AllocCounters, request,
             std::move(paramsMap), promise, callback, MkqlComplileService);
-        RegisterActor(requestHandler);
-
-        return promise.GetFuture();
-    }
-
-    TFuture<TGenericResult> SendSchemeRequest(TEvTxUserProxy::TEvProposeTransaction* request)
-    {
-        auto promise = NewPromise<TGenericResult>();
+        RegisterActor(requestHandler); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
+    TFuture<TGenericResult> SendSchemeRequest(TEvTxUserProxy::TEvProposeTransaction* request) 
+    { 
+        auto promise = NewPromise<TGenericResult>(); 
         IActor* requestHandler = new TSchemeOpRequestHandler(request, promise);
-        RegisterActor(requestHandler);
-
-        return promise.GetFuture();
-    }
-
+        RegisterActor(requestHandler); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
     template<typename TRpc>
     TFuture<TGenericResult> SendLocalRpcRequestNoResult(typename TRpc::TRequest&& proto, const TString& databse, const TString& token) {
         return NRpcService::DoLocalRpc<TRpc>(std::move(proto), databse, token, ActorSystem).Apply([](NThreading::TFuture<typename TRpc::TResponse> future) {
@@ -2032,94 +2032,94 @@ private:
     }
 
     bool CheckCluster(const TString& cluster) {
-        return cluster == Cluster;
-    }
-
-    TFuture<TMkqlResult> RunInternal(const TString& cluster, const TString& program, TKqpParamsMap&& params,
+        return cluster == Cluster; 
+    } 
+ 
+    TFuture<TMkqlResult> RunInternal(const TString& cluster, const TString& program, TKqpParamsMap&& params, 
         bool compileOnly, bool prepared, const TMkqlSettings& settings, const TKqpSnapshot& snapshot = TKqpSnapshot::InvalidSnapshot)
-    {
-        using TRequest = TEvTxUserProxy::TEvProposeTransaction;
-
-        try {
-            if (!CheckCluster(cluster)) {
-                return InvalidCluster<TMkqlResult>(cluster);
-            }
-
-            auto ev = MakeHolder<TRequest>();
+    { 
+        using TRequest = TEvTxUserProxy::TEvProposeTransaction; 
+ 
+        try { 
+            if (!CheckCluster(cluster)) { 
+                return InvalidCluster<TMkqlResult>(cluster); 
+            } 
+ 
+            auto ev = MakeHolder<TRequest>(); 
             ev->Record.SetDatabaseName(Database);
-            if (UserToken) {
-                ev->Record.SetUserToken(UserToken->Serialized);
-            }
-            auto& mkqlTx = *ev->Record.MutableTransaction()->MutableMiniKQLTransaction();
-            mkqlTx.SetFlatMKQL(true);
-            mkqlTx.SetMode(compileOnly ? TMiniKQLTransaction::COMPILE : TMiniKQLTransaction::COMPILE_AND_EXEC);
-
-            if (prepared) {
-                mkqlTx.MutableProgram()->SetBin(program);
-            } else {
-                mkqlTx.MutableProgram()->SetText(program);
-            }
-
-            if (!compileOnly) {
-                if (settings.LlvmRuntime) {
-                    mkqlTx.SetLlvmRuntime(true);
-                }
-
-                if (settings.PerShardKeysSizeLimitBytes) {
-                    mkqlTx.SetPerShardKeysSizeLimitBytes(*settings.PerShardKeysSizeLimitBytes);
-                }
-
-                if (settings.CancelAfterMs) {
-                    ev->Record.SetCancelAfterMs(settings.CancelAfterMs);
-                }
-
-                if (settings.TimeoutMs) {
-                    ev->Record.SetExecTimeoutPeriod(settings.TimeoutMs);
-                }
-
-                const auto& limits = settings.Limits;
-
-                if (limits.AffectedShardsLimit) {
-                    mkqlTx.MutableLimits()->SetAffectedShardsLimit(limits.AffectedShardsLimit);
-                }
-
-                if (limits.ReadsetCountLimit) {
-                    mkqlTx.MutableLimits()->SetReadsetCountLimit(limits.ReadsetCountLimit);
-                }
-
-                if (limits.ComputeNodeMemoryLimitBytes) {
-                    mkqlTx.MutableLimits()->SetComputeNodeMemoryLimitBytes(limits.ComputeNodeMemoryLimitBytes);
-                }
-
-                if (limits.TotalReadSizeLimitBytes) {
-                    mkqlTx.MutableLimits()->SetTotalReadSizeLimitBytes(limits.TotalReadSizeLimitBytes);
-                }
+            if (UserToken) { 
+                ev->Record.SetUserToken(UserToken->Serialized); 
+            } 
+            auto& mkqlTx = *ev->Record.MutableTransaction()->MutableMiniKQLTransaction(); 
+            mkqlTx.SetFlatMKQL(true); 
+            mkqlTx.SetMode(compileOnly ? TMiniKQLTransaction::COMPILE : TMiniKQLTransaction::COMPILE_AND_EXEC); 
+ 
+            if (prepared) { 
+                mkqlTx.MutableProgram()->SetBin(program); 
+            } else { 
+                mkqlTx.MutableProgram()->SetText(program); 
+            } 
+ 
+            if (!compileOnly) { 
+                if (settings.LlvmRuntime) { 
+                    mkqlTx.SetLlvmRuntime(true); 
+                } 
+ 
+                if (settings.PerShardKeysSizeLimitBytes) { 
+                    mkqlTx.SetPerShardKeysSizeLimitBytes(*settings.PerShardKeysSizeLimitBytes); 
+                } 
+ 
+                if (settings.CancelAfterMs) { 
+                    ev->Record.SetCancelAfterMs(settings.CancelAfterMs); 
+                } 
+ 
+                if (settings.TimeoutMs) { 
+                    ev->Record.SetExecTimeoutPeriod(settings.TimeoutMs); 
+                } 
+ 
+                const auto& limits = settings.Limits; 
+ 
+                if (limits.AffectedShardsLimit) { 
+                    mkqlTx.MutableLimits()->SetAffectedShardsLimit(limits.AffectedShardsLimit); 
+                } 
+ 
+                if (limits.ReadsetCountLimit) { 
+                    mkqlTx.MutableLimits()->SetReadsetCountLimit(limits.ReadsetCountLimit); 
+                } 
+ 
+                if (limits.ComputeNodeMemoryLimitBytes) { 
+                    mkqlTx.MutableLimits()->SetComputeNodeMemoryLimitBytes(limits.ComputeNodeMemoryLimitBytes); 
+                } 
+ 
+                if (limits.TotalReadSizeLimitBytes) { 
+                    mkqlTx.MutableLimits()->SetTotalReadSizeLimitBytes(limits.TotalReadSizeLimitBytes); 
+                } 
 
                 if (snapshot.IsValid()) {
                     mkqlTx.SetSnapshotStep(snapshot.Step);
                     mkqlTx.SetSnapshotTxId(snapshot.TxId);
                 }
-            }
-
+            } 
+ 
             if (settings.CollectStats) {
                 mkqlTx.SetCollectStats(true);
             }
 
-            return SendMkqlRequest(ev.Release(), std::move(params),
-                [compileOnly] (TPromise<TMkqlResult> promise, TTransactionResponse&& response) {
-                    try {
-                        promise.SetValue(GetMkqlResult(GetRunResponse(std::move(response.Record)), compileOnly));
-                    }
-                    catch (yexception& e) {
-                        promise.SetValue(ResultFromException<TMkqlResult>(e));
-                    }
-                });
-        }
-        catch (yexception& e) {
-            return MakeFuture(ResultFromException<TMkqlResult>(e));
-        }
-    }
-
+            return SendMkqlRequest(ev.Release(), std::move(params), 
+                [compileOnly] (TPromise<TMkqlResult> promise, TTransactionResponse&& response) { 
+                    try { 
+                        promise.SetValue(GetMkqlResult(GetRunResponse(std::move(response.Record)), compileOnly)); 
+                    } 
+                    catch (yexception& e) { 
+                        promise.SetValue(ResultFromException<TMkqlResult>(e)); 
+                    } 
+                }); 
+        } 
+        catch (yexception& e) { 
+            return MakeFuture(ResultFromException<TMkqlResult>(e)); 
+        } 
+    } 
+ 
     TFuture<TExecPhysicalResult> ExecutePhysicalQueryInternal(TExecPhysicalRequest&& request, const TActorId& target,
         bool streaming)
     {
@@ -2132,7 +2132,7 @@ private:
         auto promise = NewPromise<TExecPhysicalResult>();
 
         auto ev = MakeHolder<TEvTxUserProxy::TEvProposeKqpTransaction>(executerId);
-        IActor* requestHandler = new TKqpExecPhysicalRequestHandler(ev.Release(), streaming, target, promise);
+        IActor* requestHandler = new TKqpExecPhysicalRequestHandler(ev.Release(), streaming, target, promise); 
         RegisterActor(requestHandler);
 
         return promise.GetFuture();
@@ -2152,226 +2152,226 @@ private:
         return false;
     }
 
-private:
-    static TRunResponse GetRunResponse(NKikimrTxUserProxy::TEvProposeTransactionStatus&& ev) {
-        IKqpGateway::TRunResponse response;
-
-        response.HasProxyError = ev.GetStatus() != TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecComplete
-            && ev.GetStatus() != TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecAlready;
-        response.ProxyStatus = ev.GetStatus();
-        if (response.HasProxyError) {
-            NMsgBusProxy::ExplainProposeTransactionStatus(ev.GetStatus(), response.ProxyStatusName,
-                response.ProxyStatusDesc);
-        }
-
-        auto executionResponseStatus = static_cast<NMiniKQL::IEngineFlat::EStatus>(
-            ev.GetExecutionEngineResponseStatus());
-        auto executionEngineStatus = static_cast<NMiniKQL::IEngineFlat::EResult>(
-            ev.GetExecutionEngineStatus());
-        response.HasExecutionEngineError = executionResponseStatus == NMiniKQL::IEngineFlat::EStatus::Error &&
-            executionEngineStatus != NMiniKQL::IEngineFlat::EResult::Ok;
-        if (response.HasExecutionEngineError) {
-            NMsgBusProxy::ExplainExecutionEngineStatus(ev.GetExecutionEngineStatus(),
-                response.ExecutionEngineStatusName, response.ExecutionEngineStatusDesc);
-        }
-
-        NYql::IssuesFromMessage(ev.GetIssues(), response.Issues);
-
-        response.MiniKQLErrors = ev.GetMiniKQLErrors();
-        response.DataShardErrors = ev.GetDataShardErrors();
-        response.MiniKQLCompileResults = ev.GetMiniKQLCompileResults();
-
-        response.ExecutionEngineEvaluatedResponse.Swap(ev.MutableExecutionEngineEvaluatedResponse());
+private: 
+    static TRunResponse GetRunResponse(NKikimrTxUserProxy::TEvProposeTransactionStatus&& ev) { 
+        IKqpGateway::TRunResponse response; 
+ 
+        response.HasProxyError = ev.GetStatus() != TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecComplete 
+            && ev.GetStatus() != TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecAlready; 
+        response.ProxyStatus = ev.GetStatus(); 
+        if (response.HasProxyError) { 
+            NMsgBusProxy::ExplainProposeTransactionStatus(ev.GetStatus(), response.ProxyStatusName, 
+                response.ProxyStatusDesc); 
+        } 
+ 
+        auto executionResponseStatus = static_cast<NMiniKQL::IEngineFlat::EStatus>( 
+            ev.GetExecutionEngineResponseStatus()); 
+        auto executionEngineStatus = static_cast<NMiniKQL::IEngineFlat::EResult>( 
+            ev.GetExecutionEngineStatus()); 
+        response.HasExecutionEngineError = executionResponseStatus == NMiniKQL::IEngineFlat::EStatus::Error && 
+            executionEngineStatus != NMiniKQL::IEngineFlat::EResult::Ok; 
+        if (response.HasExecutionEngineError) { 
+            NMsgBusProxy::ExplainExecutionEngineStatus(ev.GetExecutionEngineStatus(), 
+                response.ExecutionEngineStatusName, response.ExecutionEngineStatusDesc); 
+        } 
+ 
+        NYql::IssuesFromMessage(ev.GetIssues(), response.Issues); 
+ 
+        response.MiniKQLErrors = ev.GetMiniKQLErrors(); 
+        response.DataShardErrors = ev.GetDataShardErrors(); 
+        response.MiniKQLCompileResults = ev.GetMiniKQLCompileResults(); 
+ 
+        response.ExecutionEngineEvaluatedResponse.Swap(ev.MutableExecutionEngineEvaluatedResponse()); 
         response.TxStats = ev.GetTxStats();
-
-        return response;
-    }
-
-    static TListPathResult GetListPathResult(const TPathDescription& pathDesc, const TString& path) {
-        if (pathDesc.GetSelf().GetPathType() != EPathTypeDir) {
-            return ResultFromError<TListPathResult>(TString("Directory not found: ") + path);
-        }
-
-        TListPathResult result;
-        result.SetSuccess();
-
-        result.Path = path;
-        for (auto entry : pathDesc.GetChildren()) {
-            result.Items.push_back(NYql::TKikimrListPathItem(
-                entry.GetName(),
-                entry.GetPathType() == EPathTypeDir));
-        }
-
-        return result;
-    }
-
+ 
+        return response; 
+    } 
+ 
+    static TListPathResult GetListPathResult(const TPathDescription& pathDesc, const TString& path) { 
+        if (pathDesc.GetSelf().GetPathType() != EPathTypeDir) { 
+            return ResultFromError<TListPathResult>(TString("Directory not found: ") + path); 
+        } 
+ 
+        TListPathResult result; 
+        result.SetSuccess(); 
+ 
+        result.Path = path; 
+        for (auto entry : pathDesc.GetChildren()) { 
+            result.Items.push_back(NYql::TKikimrListPathItem( 
+                entry.GetName(), 
+                entry.GetPathType() == EPathTypeDir)); 
+        } 
+ 
+        return result; 
+    } 
+ 
     static void FillCreateTableColumnDesc(NKikimrSchemeOp::TTableDescription& tableDesc,
         const TString& name, NYql::TKikimrTableMetadataPtr metadata)
-    {
-        tableDesc.SetName(name);
-
+    { 
+        tableDesc.SetName(name); 
+ 
         Y_ENSURE(metadata->ColumnOrder.size() == metadata->Columns.size());
         for (const auto& name : metadata->ColumnOrder) {
             auto columnIt = metadata->Columns.find(name);
             Y_ENSURE(columnIt != metadata->Columns.end());
-
-            TColumnDescription& columnDesc = *tableDesc.AddColumns();
+ 
+            TColumnDescription& columnDesc = *tableDesc.AddColumns(); 
             columnDesc.SetName(columnIt->second.Name);
             columnDesc.SetType(columnIt->second.Type);
             columnDesc.SetNotNull(columnIt->second.NotNull);
             if (columnIt->second.Families) {
                 columnDesc.SetFamilyName(*columnIt->second.Families.begin());
             }
-        }
-
-        for (TString& keyColumn : metadata->KeyColumnNames) {
-            tableDesc.AddKeyColumnNames(keyColumn);
-        }
-    }
-
-    static bool CheckLoadTableMetadataStatus(ui32 status, const TString& reason,
-        IKikimrGateway::TTableMetadataResult& error)
-    {
-        using TResult = IKikimrGateway::TTableMetadataResult;
-
-        switch (status) {
+        } 
+ 
+        for (TString& keyColumn : metadata->KeyColumnNames) { 
+            tableDesc.AddKeyColumnNames(keyColumn); 
+        } 
+    } 
+ 
+    static bool CheckLoadTableMetadataStatus(ui32 status, const TString& reason, 
+        IKikimrGateway::TTableMetadataResult& error) 
+    { 
+        using TResult = IKikimrGateway::TTableMetadataResult; 
+ 
+        switch (status) { 
             case NKikimrScheme::EStatus::StatusSuccess:
             case NKikimrScheme::EStatus::StatusPathDoesNotExist:
-                return true;
+                return true; 
             case NKikimrScheme::EStatus::StatusSchemeError:
-                error = ResultFromError<TResult>(YqlIssue({}, TIssuesIds::KIKIMR_SCHEME_ERROR, reason));
-                return false;
+                error = ResultFromError<TResult>(YqlIssue({}, TIssuesIds::KIKIMR_SCHEME_ERROR, reason)); 
+                return false; 
             case NKikimrScheme::EStatus::StatusAccessDenied:
-                error = ResultFromError<TResult>(YqlIssue({}, TIssuesIds::KIKIMR_ACCESS_DENIED, reason));
-                return false;
+                error = ResultFromError<TResult>(YqlIssue({}, TIssuesIds::KIKIMR_ACCESS_DENIED, reason)); 
+                return false; 
             case NKikimrScheme::EStatus::StatusNotAvailable:
-                error = ResultFromError<TResult>(YqlIssue({}, TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE, reason));
-                return false;
-            default:
-                error = ResultFromError<TResult>(TStringBuilder() << status << ": " <<  reason);
-                return false;
-        }
-    }
-
-    static TMkqlResult GetMkqlResult(TRunResponse&& response, bool compileOnly) {
-        auto& txRes = response.MiniKQLCompileResults;
-
-        if (txRes.ProgramCompileErrorsSize() > 0) {
-            NYql::TIssues errors;
-            for (size_t i = 0, end = txRes.ProgramCompileErrorsSize(); i < end; ++i) {
-                const auto& err = txRes.GetProgramCompileErrors(i);
-                errors.AddIssue(NYql::IssueFromMessage(err));
-            }
-            return ResultFromIssues<TMkqlResult>(TIssuesIds::KIKIMR_COMPILE_ERROR, "MiniKQL compilation error",
-                errors);
-        }
-
-        YQL_ENSURE(txRes.ParamsCompileErrorsSize() == 0);
-
-        if (!compileOnly) {
-            NYql::TIssues internalIssues;
-            if (response.HasExecutionEngineError) {
-                internalIssues.AddIssue(TIssue(NYql::TPosition(), TString("Execution engine failure (")
-                    + response.ExecutionEngineStatusName + "): " + response.ExecutionEngineStatusDesc));
-            }
-
+                error = ResultFromError<TResult>(YqlIssue({}, TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE, reason)); 
+                return false; 
+            default: 
+                error = ResultFromError<TResult>(TStringBuilder() << status << ": " <<  reason); 
+                return false; 
+        } 
+    } 
+ 
+    static TMkqlResult GetMkqlResult(TRunResponse&& response, bool compileOnly) { 
+        auto& txRes = response.MiniKQLCompileResults; 
+ 
+        if (txRes.ProgramCompileErrorsSize() > 0) { 
+            NYql::TIssues errors; 
+            for (size_t i = 0, end = txRes.ProgramCompileErrorsSize(); i < end; ++i) { 
+                const auto& err = txRes.GetProgramCompileErrors(i); 
+                errors.AddIssue(NYql::IssueFromMessage(err)); 
+            } 
+            return ResultFromIssues<TMkqlResult>(TIssuesIds::KIKIMR_COMPILE_ERROR, "MiniKQL compilation error", 
+                errors); 
+        } 
+ 
+        YQL_ENSURE(txRes.ParamsCompileErrorsSize() == 0); 
+ 
+        if (!compileOnly) { 
+            NYql::TIssues internalIssues; 
+            if (response.HasExecutionEngineError) { 
+                internalIssues.AddIssue(TIssue(NYql::TPosition(), TString("Execution engine failure (") 
+                    + response.ExecutionEngineStatusName + "): " + response.ExecutionEngineStatusDesc)); 
+            } 
+ 
             if (!response.DataShardErrors.empty()) {
-                internalIssues.AddIssue(TIssue(NYql::TPosition(), TString("Data shard errors: ")
-                    + response.DataShardErrors));
-            }
-
+                internalIssues.AddIssue(TIssue(NYql::TPosition(), TString("Data shard errors: ") 
+                    + response.DataShardErrors)); 
+            } 
+ 
             if (!response.MiniKQLErrors.empty()) {
-                internalIssues.AddIssue(TIssue(NYql::TPosition(), TString("Execution engine errors: ")
-                    + response.MiniKQLErrors));
-            }
-
-            if (response.HasProxyError) {
-                auto message = TString("Error executing transaction (") + response.ProxyStatusName + "): "
-                    + response.ProxyStatusDesc;
-
-                NYql::TIssue proxyIssue(NYql::TPosition(), message);
-                for (auto& issue : internalIssues) {
-                    proxyIssue.AddSubIssue(MakeIntrusive<TIssue>(issue));
-                }
-                for (auto& issue : response.Issues) {
-                    proxyIssue.AddSubIssue(MakeIntrusive<TIssue>(issue));
-                }
-
-                return ResultFromIssues<TMkqlResult>(KikimrProxyErrorStatus(response.ProxyStatus), {proxyIssue});
-            }
-
-            if (!internalIssues.Empty()) {
-                return ResultFromErrors<TMkqlResult>(internalIssues);
-            }
-        }
-
-        TMkqlResult result;
-        result.SetSuccess();
-        result.CompiledProgram = txRes.GetCompiledProgram();
-        result.Result.Swap(&response.ExecutionEngineEvaluatedResponse);
-        result.TxStats.Swap(&response.TxStats);
-        return result;
-    }
-
-    static NYql::EYqlIssueCode KikimrProxyErrorStatus(ui32 proxyStatus) {
-        NYql::EYqlIssueCode status = TIssuesIds::DEFAULT_ERROR;
-
-        switch (proxyStatus) {
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ResolveError:
-                status = TIssuesIds::KIKIMR_SCHEME_MISMATCH;
-                break;
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyNotReady:
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardNotAvailable:
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardTryLater:
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorDeclined:
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorOutdated:
-                status = TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE;
-                break;
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardOverloaded:
-                status = TIssuesIds::KIKIMR_OVERLOADED;
-                break;
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable:
-                status = TIssuesIds::KIKIMR_RESULT_UNAVAILABLE;
-                break;
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::AccessDenied:
-                status = TIssuesIds::KIKIMR_ACCESS_DENIED;
-                break;
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecTimeout:
-                status = TIssuesIds::KIKIMR_TIMEOUT;
-                break;
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecCancelled:
-                status = TIssuesIds::KIKIMR_OPERATION_CANCELLED;
-                break;
+                internalIssues.AddIssue(TIssue(NYql::TPosition(), TString("Execution engine errors: ") 
+                    + response.MiniKQLErrors)); 
+            } 
+ 
+            if (response.HasProxyError) { 
+                auto message = TString("Error executing transaction (") + response.ProxyStatusName + "): " 
+                    + response.ProxyStatusDesc; 
+ 
+                NYql::TIssue proxyIssue(NYql::TPosition(), message); 
+                for (auto& issue : internalIssues) { 
+                    proxyIssue.AddSubIssue(MakeIntrusive<TIssue>(issue)); 
+                } 
+                for (auto& issue : response.Issues) { 
+                    proxyIssue.AddSubIssue(MakeIntrusive<TIssue>(issue)); 
+                } 
+ 
+                return ResultFromIssues<TMkqlResult>(KikimrProxyErrorStatus(response.ProxyStatus), {proxyIssue}); 
+            } 
+ 
+            if (!internalIssues.Empty()) { 
+                return ResultFromErrors<TMkqlResult>(internalIssues); 
+            } 
+        } 
+ 
+        TMkqlResult result; 
+        result.SetSuccess(); 
+        result.CompiledProgram = txRes.GetCompiledProgram(); 
+        result.Result.Swap(&response.ExecutionEngineEvaluatedResponse); 
+        result.TxStats.Swap(&response.TxStats); 
+        return result; 
+    } 
+ 
+    static NYql::EYqlIssueCode KikimrProxyErrorStatus(ui32 proxyStatus) { 
+        NYql::EYqlIssueCode status = TIssuesIds::DEFAULT_ERROR; 
+ 
+        switch (proxyStatus) { 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ResolveError: 
+                status = TIssuesIds::KIKIMR_SCHEME_MISMATCH; 
+                break; 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyNotReady: 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardNotAvailable: 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardTryLater: 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorDeclined: 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorOutdated: 
+                status = TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE; 
+                break; 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardOverloaded: 
+                status = TIssuesIds::KIKIMR_OVERLOADED; 
+                break; 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable: 
+                status = TIssuesIds::KIKIMR_RESULT_UNAVAILABLE; 
+                break; 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::AccessDenied: 
+                status = TIssuesIds::KIKIMR_ACCESS_DENIED; 
+                break; 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecTimeout: 
+                status = TIssuesIds::KIKIMR_TIMEOUT; 
+                break; 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecCancelled: 
+                status = TIssuesIds::KIKIMR_OPERATION_CANCELLED; 
+                break; 
             case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::WrongRequest:
                 status = TIssuesIds::KIKIMR_BAD_REQUEST;
                 break;
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardUnknown:
-            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorUnknown:
-                status = TIssuesIds::KIKIMR_OPERATION_STATE_UNKNOWN;
-                break;
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardUnknown: 
+            case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorUnknown: 
+                status = TIssuesIds::KIKIMR_OPERATION_STATE_UNKNOWN; 
+                break; 
             case TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecAborted:
                 status = TIssuesIds::KIKIMR_OPERATION_ABORTED;
                 break;
-            default:
-                break;
-        }
-
-        return status;
-    }
-
-    static void FillParameters(TKqpParamsMap&& params, NKikimrMiniKQL::TParams& output) {
-        output.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Struct);
-        auto type = output.MutableType()->MutableStruct();
-        auto value = output.MutableValue();
-        for (auto& pair : params.Values) {
-            auto typeMember = type->AddMember();
-            typeMember->SetName(pair.first);
-
-            typeMember->MutableType()->CopyFrom(pair.second.GetType());
-            value->AddStruct()->CopyFrom(pair.second.GetValue());
-        }
-    }
-
+            default: 
+                break; 
+        } 
+ 
+        return status; 
+    } 
+ 
+    static void FillParameters(TKqpParamsMap&& params, NKikimrMiniKQL::TParams& output) { 
+        output.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Struct); 
+        auto type = output.MutableType()->MutableStruct(); 
+        auto value = output.MutableValue(); 
+        for (auto& pair : params.Values) { 
+            auto typeMember = type->AddMember(); 
+            typeMember->SetName(pair.first); 
+ 
+            typeMember->MutableType()->CopyFrom(pair.second.GetType()); 
+            value->AddStruct()->CopyFrom(pair.second.GetValue()); 
+        } 
+    } 
+ 
     static bool ConvertDataSlotToYdbTypedValue(NYql::EDataSlot fromType, const TString& fromValue, Ydb::Type* toType,
             Ydb::Value* toValue)
     {
@@ -2636,26 +2636,26 @@ private:
         return true;
     }
 
-private:
-    TString Cluster;
-    TString Database;
-    TActorSystem* ActorSystem;
-    ui32 NodeId;
+private: 
+    TString Cluster; 
+    TString Database; 
+    TActorSystem* ActorSystem; 
+    ui32 NodeId; 
     TKqpRequestCounters::TPtr Counters;
     TAlignedPagePoolCounters AllocCounters;
-    TMaybe<TUserTokenData> UserToken;
+    TMaybe<TUserTokenData> UserToken; 
     std::shared_ptr<IKqpTableMetadataLoader> MetadataLoader;
     TActorId MkqlComplileService;
-};
-
-} // namespace
-
-TIntrusivePtr<IKqpGateway> CreateKikimrIcGateway(const TString& cluster, const TString& database,
+}; 
+ 
+} // namespace 
+ 
+TIntrusivePtr<IKqpGateway> CreateKikimrIcGateway(const TString& cluster, const TString& database, 
     std::shared_ptr<NYql::IKikimrGateway::IKqpTableMetadataLoader>&& metadataLoader, TActorSystem* actorSystem, ui32 nodeId, TKqpRequestCounters::TPtr counters,
     const TActorId& mkqlComplileService)
-{
+{ 
     return MakeIntrusive<TKikimrIcGateway>(cluster, database, std::move(metadataLoader), actorSystem, nodeId, counters, mkqlComplileService);
-}
-
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/kqp_impl.h b/ydb/core/kqp/kqp_impl.h
index 7d6f172899..a96faf3e00 100644
--- a/ydb/core/kqp/kqp_impl.h
+++ b/ydb/core/kqp/kqp_impl.h
@@ -1,30 +1,30 @@
-#pragma once
-
-#include "kqp.h"
-
+#pragma once 
+ 
+#include "kqp.h" 
+ 
 #include <ydb/core/kqp/common/kqp_gateway.h>
 #include <ydb/core/kqp/provider/yql_kikimr_settings.h>
-
+ 
 #include <ydb/library/yql/utils/log/log.h>
 #include <ydb/library/yql/utils/log/tls_backend.h>
-
+ 
 #include <library/cpp/actors/core/actorsystem.h>
 #include <library/cpp/protobuf/util/pb_io.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-struct TKqpSettings {
+namespace NKikimr { 
+namespace NKqp { 
+ 
+struct TKqpSettings { 
     using TConstPtr = std::shared_ptr<const TKqpSettings>;
-
-    TKqpSettings(const TVector<NKikimrKqp::TKqpSetting>& settings)
-        : Settings(settings)
-    {
-        auto defaultSettingsData = NResource::Find("kqp_default_settings.txt");
-        TStringInput defaultSettingsStream(defaultSettingsData);
-        Y_VERIFY(TryParseFromTextFormat(defaultSettingsStream, DefaultSettings));
-    }
-
+ 
+    TKqpSettings(const TVector<NKikimrKqp::TKqpSetting>& settings) 
+        : Settings(settings) 
+    { 
+        auto defaultSettingsData = NResource::Find("kqp_default_settings.txt"); 
+        TStringInput defaultSettingsStream(defaultSettingsData); 
+        Y_VERIFY(TryParseFromTextFormat(defaultSettingsStream, DefaultSettings)); 
+    } 
+ 
     TKqpSettings()
         : Settings()
     {
@@ -33,66 +33,66 @@ struct TKqpSettings {
         Y_VERIFY(TryParseFromTextFormat(defaultSettingsStream, DefaultSettings));
     }
 
-    NKikimrKqp::TKqpDefaultSettings DefaultSettings;
-    TVector<NKikimrKqp::TKqpSetting> Settings;
-};
-
-struct TModuleResolverState : public TThrRefBase {
-    NYql::TExprContext ExprCtx;
-    NYql::IModuleResolver::TPtr ModuleResolver;
-    THolder<NYql::TExprContext::TFreezeGuard> FreezeGuardHolder;
-};
-
-void ApplyServiceConfig(NYql::TKikimrConfiguration& kqpConfig, const NKikimrConfig::TTableServiceConfig& serviceConfig);
-
-IActor* CreateKqpCompileService(const NKikimrConfig::TTableServiceConfig& serviceConfig,
-    const TKqpSettings::TConstPtr& kqpSettings, TIntrusivePtr<TModuleResolverState> moduleResolverState,
+    NKikimrKqp::TKqpDefaultSettings DefaultSettings; 
+    TVector<NKikimrKqp::TKqpSetting> Settings; 
+}; 
+ 
+struct TModuleResolverState : public TThrRefBase { 
+    NYql::TExprContext ExprCtx; 
+    NYql::IModuleResolver::TPtr ModuleResolver; 
+    THolder<NYql::TExprContext::TFreezeGuard> FreezeGuardHolder; 
+}; 
+ 
+void ApplyServiceConfig(NYql::TKikimrConfiguration& kqpConfig, const NKikimrConfig::TTableServiceConfig& serviceConfig); 
+ 
+IActor* CreateKqpCompileService(const NKikimrConfig::TTableServiceConfig& serviceConfig, 
+    const TKqpSettings::TConstPtr& kqpSettings, TIntrusivePtr<TModuleResolverState> moduleResolverState, 
     TIntrusivePtr<TKqpCounters> counters, std::shared_ptr<IQueryReplayBackendFactory> queryReplayFactory);
-
+ 
 IActor* CreateKqpCompileActor(const TActorId& owner, const TKqpSettings::TConstPtr& kqpSettings,
-    const NKikimrConfig::TTableServiceConfig& serviceConfig, TIntrusivePtr<TModuleResolverState> moduleResolverState,
+    const NKikimrConfig::TTableServiceConfig& serviceConfig, TIntrusivePtr<TModuleResolverState> moduleResolverState, 
     TIntrusivePtr<TKqpCounters> counters, const TString& uid, const TKqpQueryId& query, const TString& userToken,
     TKqpDbCountersPtr dbCounters, bool recompileWithNewEngine);
-
-IActor* CreateKqpCompileRequestActor(const TActorId& owner, const TString& userToken, const TMaybe<TString>& uid,
+ 
+IActor* CreateKqpCompileRequestActor(const TActorId& owner, const TString& userToken, const TMaybe<TString>& uid, 
     TMaybe<TKqpQueryId>&& query, bool keepInCache, const TInstant& deadline, TKqpDbCountersPtr dbCounters);
-
-struct TKqpWorkerSettings {
-    TString Cluster;
-    TString Database;
-    bool LongSession = false;
-
-    NKikimrConfig::TTableServiceConfig Service;
-
+ 
+struct TKqpWorkerSettings { 
+    TString Cluster; 
+    TString Database; 
+    bool LongSession = false; 
+ 
+    NKikimrConfig::TTableServiceConfig Service; 
+ 
     TKqpDbCountersPtr DbCounters;
 
-    TKqpWorkerSettings(const TString& cluster, const TString& database,
+    TKqpWorkerSettings(const TString& cluster, const TString& database, 
         const NKikimrConfig::TTableServiceConfig& serviceConfig, TKqpDbCountersPtr dbCounters)
-        : Cluster(cluster)
-        , Database(database)
+        : Cluster(cluster) 
+        , Database(database) 
         , Service(serviceConfig)
         , DbCounters(dbCounters) {}
-};
-
+}; 
+ 
 IActor* CreateKqpWorkerActor(const TActorId& owner, const TString& sessionId,
-    const TKqpSettings::TConstPtr& kqpSettings, const TKqpWorkerSettings& workerSettings,
-    TIntrusivePtr<TModuleResolverState> moduleResolverState, TIntrusivePtr<TKqpCounters> counters);
-
+    const TKqpSettings::TConstPtr& kqpSettings, const TKqpWorkerSettings& workerSettings, 
+    TIntrusivePtr<TModuleResolverState> moduleResolverState, TIntrusivePtr<TKqpCounters> counters); 
+ 
 IActor* CreateKqpSessionActor(const TActorId& owner, const TString& sessionId,
     const TKqpSettings::TConstPtr& kqpSettings, const TKqpWorkerSettings& workerSettings,
     TIntrusivePtr<TModuleResolverState> moduleResolverState, TIntrusivePtr<TKqpCounters> counters);
 
-TIntrusivePtr<IKqpGateway> CreateKikimrIcGateway(const TString& cluster, const TString& database,
+TIntrusivePtr<IKqpGateway> CreateKikimrIcGateway(const TString& cluster, const TString& database, 
     std::shared_ptr<IKqpGateway::IKqpTableMetadataLoader>&& metadataLoader, NActors::TActorSystem* actorSystem, ui32 nodeId, TKqpRequestCounters::TPtr counters,
     const TActorId& MkqlCompileService);
-
+ 
 Ydb::StatusIds::StatusCode GetYdbStatus(const NYql::NCommon::TOperationResult& queryResult);
-void AddQueryIssues(NKikimrKqp::TQueryResponse& response, const NYql::TIssues& issues);
+void AddQueryIssues(NKikimrKqp::TQueryResponse& response, const NYql::TIssues& issues); 
 bool HasSchemeOrFatalIssues(const NYql::TIssues& issues);
-
+ 
 // for tests only
 void FailForcedNewEngineCompilationForTests(bool fail = true);
 void FailForcedNewEngineExecutionForTests(bool fail = true);
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/kqp_response.cpp b/ydb/core/kqp/kqp_response.cpp
index d3859cd39c..edfc1d5a13 100644
--- a/ydb/core/kqp/kqp_response.cpp
+++ b/ydb/core/kqp/kqp_response.cpp
@@ -1,163 +1,163 @@
-#include "kqp_impl.h"
-
+#include "kqp_impl.h" 
+ 
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-
-namespace {
-
-TMaybe<Ydb::StatusIds::StatusCode> GetYdbStatus(const TIssue& issue) {
-    if (issue.GetSeverity() == TSeverityIds::S_FATAL) {
-        return Ydb::StatusIds::INTERNAL_ERROR;
-    }
-
-    switch (issue.GetCode()) {
-        case TIssuesIds::KIKIMR_LOCKS_INVALIDATED:
-        case TIssuesIds::KIKIMR_LOCKS_ACQUIRE_FAILURE:
-        case TIssuesIds::KIKIMR_OPERATION_ABORTED:
-        case TIssuesIds::KIKIMR_SCHEME_MISMATCH:
-            return Ydb::StatusIds::ABORTED;
-
-        case TIssuesIds::KIKIMR_SCHEME_ERROR:
-            return Ydb::StatusIds::SCHEME_ERROR;
-
-        case TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE:
-            return Ydb::StatusIds::UNAVAILABLE;
-
-        case TIssuesIds::KIKIMR_OVERLOADED:
-        case TIssuesIds::KIKIMR_MULTIPLE_SCHEME_MODIFICATIONS:
-            return Ydb::StatusIds::OVERLOADED;
-
-        case TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION:
-            return Ydb::StatusIds::PRECONDITION_FAILED;
-
-        case TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND:
-            return Ydb::StatusIds::NOT_FOUND;
-
-        case TIssuesIds::KIKIMR_BAD_REQUEST:
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+ 
+namespace { 
+ 
+TMaybe<Ydb::StatusIds::StatusCode> GetYdbStatus(const TIssue& issue) { 
+    if (issue.GetSeverity() == TSeverityIds::S_FATAL) { 
+        return Ydb::StatusIds::INTERNAL_ERROR; 
+    } 
+ 
+    switch (issue.GetCode()) { 
+        case TIssuesIds::KIKIMR_LOCKS_INVALIDATED: 
+        case TIssuesIds::KIKIMR_LOCKS_ACQUIRE_FAILURE: 
+        case TIssuesIds::KIKIMR_OPERATION_ABORTED: 
+        case TIssuesIds::KIKIMR_SCHEME_MISMATCH: 
+            return Ydb::StatusIds::ABORTED; 
+ 
+        case TIssuesIds::KIKIMR_SCHEME_ERROR: 
+            return Ydb::StatusIds::SCHEME_ERROR; 
+ 
+        case TIssuesIds::KIKIMR_TEMPORARILY_UNAVAILABLE: 
+            return Ydb::StatusIds::UNAVAILABLE; 
+ 
+        case TIssuesIds::KIKIMR_OVERLOADED: 
+        case TIssuesIds::KIKIMR_MULTIPLE_SCHEME_MODIFICATIONS: 
+            return Ydb::StatusIds::OVERLOADED; 
+ 
+        case TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION: 
+            return Ydb::StatusIds::PRECONDITION_FAILED; 
+ 
+        case TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND: 
+            return Ydb::StatusIds::NOT_FOUND; 
+ 
+        case TIssuesIds::KIKIMR_BAD_REQUEST: 
         case TIssuesIds::KIKIMR_BAD_COLUMN_TYPE:
         case TIssuesIds::KIKIMR_NO_COLUMN_DEFAULT_VALUE:
-            return Ydb::StatusIds::BAD_REQUEST;
-
-        case TIssuesIds::CORE_GC_STRINGS_LIMIT_EXCEEDED:
-        case TIssuesIds::KIKIMR_TOO_MANY_TRANSACTIONS:
-            return Ydb::StatusIds::BAD_SESSION;
-
+            return Ydb::StatusIds::BAD_REQUEST; 
+ 
+        case TIssuesIds::CORE_GC_STRINGS_LIMIT_EXCEEDED: 
+        case TIssuesIds::KIKIMR_TOO_MANY_TRANSACTIONS: 
+            return Ydb::StatusIds::BAD_SESSION; 
+ 
         case TIssuesIds::KIKIMR_ACCESS_DENIED:
             return Ydb::StatusIds::UNAUTHORIZED;
 
-        case TIssuesIds::KIKIMR_TIMEOUT:
-            return Ydb::StatusIds::TIMEOUT;
-
-        case TIssuesIds::KIKIMR_OPERATION_CANCELLED:
-            return Ydb::StatusIds::CANCELLED;
-
-        case TIssuesIds::KIKIMR_RESULT_UNAVAILABLE:
-        case TIssuesIds::KIKIMR_OPERATION_STATE_UNKNOWN:
-            return Ydb::StatusIds::UNDETERMINED;
-
+        case TIssuesIds::KIKIMR_TIMEOUT: 
+            return Ydb::StatusIds::TIMEOUT; 
+ 
+        case TIssuesIds::KIKIMR_OPERATION_CANCELLED: 
+            return Ydb::StatusIds::CANCELLED; 
+ 
+        case TIssuesIds::KIKIMR_RESULT_UNAVAILABLE: 
+        case TIssuesIds::KIKIMR_OPERATION_STATE_UNKNOWN: 
+            return Ydb::StatusIds::UNDETERMINED; 
+ 
         case TIssuesIds::KIKIMR_PRECONDITION_FAILED:
             return Ydb::StatusIds::PRECONDITION_FAILED;
 
-        case TIssuesIds::KIKIMR_UNSUPPORTED:
-            return Ydb::StatusIds::UNSUPPORTED;
-
-        default:
-            break;
-    }
-
-    return TMaybe<Ydb::StatusIds::StatusCode>();
-}
-
-void CollectYdbStatuses(const TIssue& issue, TSet<Ydb::StatusIds::StatusCode>& statuses) {
-    if (issue.GetSeverity() == TSeverityIds::S_WARNING) {
-        return;
-    }
-
-    if (auto status = GetYdbStatus(issue)) {
-        statuses.insert(*status);
-        return;
-    }
-
-    const auto& subIssues = issue.GetSubIssues();
-    if (subIssues.empty()) {
-        statuses.insert(Ydb::StatusIds::GENERIC_ERROR);
-    }
-
-    for (auto& subIssue : subIssues) {
-        CollectYdbStatuses(*subIssue, statuses);
-    }
-}
-
+        case TIssuesIds::KIKIMR_UNSUPPORTED: 
+            return Ydb::StatusIds::UNSUPPORTED; 
+ 
+        default: 
+            break; 
+    } 
+ 
+    return TMaybe<Ydb::StatusIds::StatusCode>(); 
+} 
+ 
+void CollectYdbStatuses(const TIssue& issue, TSet<Ydb::StatusIds::StatusCode>& statuses) { 
+    if (issue.GetSeverity() == TSeverityIds::S_WARNING) { 
+        return; 
+    } 
+ 
+    if (auto status = GetYdbStatus(issue)) { 
+        statuses.insert(*status); 
+        return; 
+    } 
+ 
+    const auto& subIssues = issue.GetSubIssues(); 
+    if (subIssues.empty()) { 
+        statuses.insert(Ydb::StatusIds::GENERIC_ERROR); 
+    } 
+ 
+    for (auto& subIssue : subIssues) { 
+        CollectYdbStatuses(*subIssue, statuses); 
+    } 
+} 
+ 
 bool HasSchemeOrFatalIssues(const TIssue& issue) {
     if (issue.GetSeverity() == TSeverityIds::S_FATAL) {
         return true;
     }
 
-    switch (issue.GetCode()) {
-        case TIssuesIds::KIKIMR_SCHEME_MISMATCH:
-        case TIssuesIds::KIKIMR_SCHEME_ERROR:
-            return true;
-    }
-
-    for (auto& subIssue : issue.GetSubIssues()) {
+    switch (issue.GetCode()) { 
+        case TIssuesIds::KIKIMR_SCHEME_MISMATCH: 
+        case TIssuesIds::KIKIMR_SCHEME_ERROR: 
+            return true; 
+    } 
+ 
+    for (auto& subIssue : issue.GetSubIssues()) { 
         if (HasSchemeOrFatalIssues(*subIssue)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-} // namespace
-
+            return true; 
+        } 
+    } 
+ 
+    return false; 
+} 
+ 
+} // namespace 
+ 
 Ydb::StatusIds::StatusCode GetYdbStatus(const NYql::NCommon::TOperationResult& queryResult) {
-    if (queryResult.Success()) {
-        return Ydb::StatusIds::SUCCESS;
-    }
-
-    TSet<Ydb::StatusIds::StatusCode> statuses;
-    for (const auto& topIssue : queryResult.Issues()) {
-        CollectYdbStatuses(topIssue, statuses);
-    }
-
+    if (queryResult.Success()) { 
+        return Ydb::StatusIds::SUCCESS; 
+    } 
+ 
+    TSet<Ydb::StatusIds::StatusCode> statuses; 
+    for (const auto& topIssue : queryResult.Issues()) { 
+        CollectYdbStatuses(topIssue, statuses); 
+    } 
+ 
     if (statuses.contains(Ydb::StatusIds::UNAUTHORIZED)) {
         return Ydb::StatusIds::UNAUTHORIZED;
     }
 
     if (statuses.contains(Ydb::StatusIds::INTERNAL_ERROR)) {
-        return Ydb::StatusIds::INTERNAL_ERROR;
-    }
-
+        return Ydb::StatusIds::INTERNAL_ERROR; 
+    } 
+ 
     if (statuses.contains(Ydb::StatusIds::GENERIC_ERROR)) {
-        return Ydb::StatusIds::GENERIC_ERROR;
-    }
-
-    if (statuses.size() != 1) {
-        return Ydb::StatusIds::GENERIC_ERROR;
-    }
-
-    return *statuses.begin();
-}
-
-void AddQueryIssues(NKikimrKqp::TQueryResponse& response, const TIssues& issues) {
-    for (auto& issue : issues) {
-        IssueToMessage(issue, response.AddQueryIssues());
-    }
-}
-
+        return Ydb::StatusIds::GENERIC_ERROR; 
+    } 
+ 
+    if (statuses.size() != 1) { 
+        return Ydb::StatusIds::GENERIC_ERROR; 
+    } 
+ 
+    return *statuses.begin(); 
+} 
+ 
+void AddQueryIssues(NKikimrKqp::TQueryResponse& response, const TIssues& issues) { 
+    for (auto& issue : issues) { 
+        IssueToMessage(issue, response.AddQueryIssues()); 
+    } 
+} 
+ 
 bool HasSchemeOrFatalIssues(const TIssues& issues) {
-    for (auto& issue : issues) {
+    for (auto& issue : issues) { 
         if (HasSchemeOrFatalIssues(issue)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
+            return true; 
+        } 
+    } 
+ 
+    return false; 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/kqp_worker_actor.cpp b/ydb/core/kqp/kqp_worker_actor.cpp
index cccb8a51e8..e9931c3a04 100644
--- a/ydb/core/kqp/kqp_worker_actor.cpp
+++ b/ydb/core/kqp/kqp_worker_actor.cpp
@@ -1,7 +1,7 @@
-#include "kqp_impl.h"
+#include "kqp_impl.h" 
 #include "kqp_metadata_loader.h"
 #include <ydb/core/kqp/common/kqp_ru_calc.h>
-
+ 
 #include <ydb/core/actorlib_impl/long_timer.h>
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/base/counters.h>
@@ -14,7 +14,7 @@
 #include <ydb/core/kqp/common/kqp_timeouts.h>
 #include <ydb/core/sys_view/service/sysview_service.h>
 #include <ydb/library/aclib/aclib.h>
-
+ 
 #include <ydb/library/yql/utils/actor_log/log.h>
 
 #include <library/cpp/actors/core/actor_bootstrapped.h>
@@ -22,47 +22,47 @@
 #include <library/cpp/actors/core/hfunc.h>
 #include <library/cpp/actors/core/log.h>
 #include <library/cpp/json/json_reader.h>
-
-#include <util/string/escape.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NKikimrConfig;
-using namespace NThreading;
-using namespace NYql;
+ 
+#include <util/string/escape.h> 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NKikimrConfig; 
+using namespace NThreading; 
+using namespace NYql; 
 using namespace NYql::NDq;
 using namespace NRuCalc;
-
+ 
 static std::atomic<bool> FailForcedNewEngineExecution = false;
 void FailForcedNewEngineExecutionForTests(bool fail) {
     FailForcedNewEngineExecution = fail;
 }
 
-namespace {
-
+namespace { 
+ 
 constexpr std::string_view DocumentApiRequestType = "_document_api_request"sv;
-
-using TQueryResult = IKqpHost::TQueryResult;
-
-struct TKqpQueryState {
+ 
+using TQueryResult = IKqpHost::TQueryResult; 
+ 
+struct TKqpQueryState { 
     TActorId Sender;
-    ui64 ProxyRequestId = 0;
-    NKikimrKqp::TQueryRequest Request;
-    TIntrusivePtr<IKqpHost::IAsyncQueryResult> AsyncQueryResult;
-    IKqpHost::TQueryResult QueryResult;
-    TString Error;
-    TString TraceId;
-    TString RequestType;
-    ui64 ParametersSize = 0;
-    TString UserToken;
+    ui64 ProxyRequestId = 0; 
+    NKikimrKqp::TQueryRequest Request; 
+    TIntrusivePtr<IKqpHost::IAsyncQueryResult> AsyncQueryResult; 
+    IKqpHost::TQueryResult QueryResult; 
+    TString Error; 
+    TString TraceId; 
+    TString RequestType; 
+    ui64 ParametersSize = 0; 
+    TString UserToken; 
     TActorId RequestActorId;
-    TInstant StartTime;
+    TInstant StartTime; 
     TDuration CpuTime;
-    NYql::TKikimrQueryDeadlines QueryDeadlines;
-    TString TxId;
-    TKqpCompileResult::TConstPtr QueryCompileResult;
-    NKqpProto::TKqpStatsCompile CompileStats;
+    NYql::TKikimrQueryDeadlines QueryDeadlines; 
+    TString TxId; 
+    TKqpCompileResult::TConstPtr QueryCompileResult; 
+    NKqpProto::TKqpStatsCompile CompileStats; 
     ui32 ReplyFlags = 0;
     bool KeepSession = false;
     bool InteractiveTx = true;
@@ -74,8 +74,8 @@ struct TKqpQueryState {
     std::optional<TQueryTraits> QueryTraits;
 
     TMaybe<NKikimrKqp::TRlPath> RlPath;
-};
-
+}; 
+ 
 
 struct TSessionShutdownState {
     TSessionShutdownState(ui32 softTimeout, ui32 hardTimeout)
@@ -110,12 +110,12 @@ struct TSessionShutdownState {
     }
 };
 
-struct TKqpCleanupState {
-    bool Final = false;
-    TInstant Start;
-    TIntrusivePtr<IKqpHost::IAsyncQueryResult> AsyncResult;
-};
-
+struct TKqpCleanupState { 
+    bool Final = false; 
+    TInstant Start; 
+    TIntrusivePtr<IKqpHost::IAsyncQueryResult> AsyncResult; 
+}; 
+ 
 enum ETableReadType {
     Other = 0,
     Scan = 1,
@@ -123,166 +123,166 @@ enum ETableReadType {
 };
 
 EKikimrStatsMode GetStatsMode(const NKikimrKqp::TQueryRequest& queryRequest, EKikimrStatsMode minMode) {
-    if (queryRequest.GetProfile()) {
-        // TODO: Deprecate, StatsMode is the new way to enable stats.
-        return EKikimrStatsMode::Profile;
-    }
-
-    switch (queryRequest.GetStatsMode()) {
+    if (queryRequest.GetProfile()) { 
+        // TODO: Deprecate, StatsMode is the new way to enable stats. 
+        return EKikimrStatsMode::Profile; 
+    } 
+ 
+    switch (queryRequest.GetStatsMode()) { 
         case NYql::NDqProto::DQ_STATS_MODE_BASIC:
-            return EKikimrStatsMode::Basic;
+            return EKikimrStatsMode::Basic; 
         case NYql::NDqProto::DQ_STATS_MODE_PROFILE:
-            return EKikimrStatsMode::Profile;
-        default:
+            return EKikimrStatsMode::Profile; 
+        default: 
             return std::max(EKikimrStatsMode::None, minMode);
-    }
-}
-
-class TKqpWorkerActor : public TActorBootstrapped<TKqpWorkerActor> {
-public:
+    } 
+} 
+ 
+class TKqpWorkerActor : public TActorBootstrapped<TKqpWorkerActor> { 
+public: 
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
         return NKikimrServices::TActivity::KQP_WORKER_ACTOR;
-    }
-
+    } 
+ 
     TKqpWorkerActor(const TActorId& owner, const TString& sessionId, const TKqpSettings::TConstPtr& kqpSettings,
-        const TKqpWorkerSettings& workerSettings, TIntrusivePtr<TModuleResolverState> moduleResolverState,
-        TIntrusivePtr<TKqpCounters> counters)
-        : Owner(owner)
-        , SessionId(sessionId)
-        , Settings(workerSettings)
-        , ModuleResolverState(moduleResolverState)
-        , Counters(counters)
-        , Config(MakeIntrusive<TKikimrConfiguration>())
-        , CreationTime(TInstant::Now())
-        , QueryId(0)
-        , IdleTimerId(0)
+        const TKqpWorkerSettings& workerSettings, TIntrusivePtr<TModuleResolverState> moduleResolverState, 
+        TIntrusivePtr<TKqpCounters> counters) 
+        : Owner(owner) 
+        , SessionId(sessionId) 
+        , Settings(workerSettings) 
+        , ModuleResolverState(moduleResolverState) 
+        , Counters(counters) 
+        , Config(MakeIntrusive<TKikimrConfiguration>()) 
+        , CreationTime(TInstant::Now()) 
+        , QueryId(0) 
+        , IdleTimerId(0) 
         , ShutdownState(std::nullopt)
-    {
-        Y_VERIFY(ModuleResolverState);
-        Y_VERIFY(ModuleResolverState->ModuleResolver);
-
+    { 
+        Y_VERIFY(ModuleResolverState); 
+        Y_VERIFY(ModuleResolverState->ModuleResolver); 
+ 
         Config->Init(kqpSettings->DefaultSettings.GetDefaultSettings(), Settings.Cluster, kqpSettings->Settings, false);
-
-        if (!Settings.Database.empty()) {
-            Config->_KqpTablePathPrefix = Settings.Database;
-        }
-
-        ApplyServiceConfig(*Config, Settings.Service);
-
-        Config->FreezeDefaults();
+ 
+        if (!Settings.Database.empty()) { 
+            Config->_KqpTablePathPrefix = Settings.Database; 
+        } 
+ 
+        ApplyServiceConfig(*Config, Settings.Service); 
+ 
+        Config->FreezeDefaults(); 
 
         RequestCounters = MakeIntrusive<TKqpRequestCounters>();
         RequestCounters->Counters = Counters;
         RequestCounters->DbCounters = Settings.DbCounters;
         RequestCounters->TxProxyMon = MakeIntrusive<NTxProxy::TTxProxyMon>(AppData()->Counters);
-    }
-
-    void Bootstrap(const TActorContext& ctx) {
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, "Worker bootstrapped, workerId: " << ctx.SelfID);
+    } 
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, "Worker bootstrapped, workerId: " << ctx.SelfID); 
         Counters->ReportWorkerCreated(Settings.DbCounters);
-
+ 
         std::shared_ptr<NYql::IKikimrGateway::IKqpTableMetadataLoader> loader = std::make_shared<TKqpTableMetadataLoader>(TlsActivationContext->ActorSystem(), false);
         Gateway = CreateKikimrIcGateway(Settings.Cluster, Settings.Database, std::move(loader),
             ctx.ExecutorThread.ActorSystem, ctx.SelfID.NodeId(), RequestCounters, MakeMiniKQLCompileServiceID());
-
+ 
         Config->FeatureFlags = AppData(ctx)->FeatureFlags;
 
         KqpHost = CreateKqpHost(Gateway, Settings.Cluster, Settings.Database, Config, ModuleResolverState->ModuleResolver,
-            AppData(ctx)->FunctionRegistry, !Settings.LongSession);
-
-        Become(&TKqpWorkerActor::ReadyState);
-        StartIdleTimer(ctx);
-    }
-
-    void HandleReady(TEvKqp::TEvCloseSessionRequest::TPtr &ev, const TActorContext &ctx) {
-        ui64 proxyRequestId = ev->Cookie;
-        auto& event = ev->Get()->Record;
-        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId());
-        if (CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) {
-            LOG_INFO_S(ctx, NKikimrServices::KQP_WORKER, requestInfo << "Session closed due to explicit close event");
+            AppData(ctx)->FunctionRegistry, !Settings.LongSession); 
+ 
+        Become(&TKqpWorkerActor::ReadyState); 
+        StartIdleTimer(ctx); 
+    } 
+ 
+    void HandleReady(TEvKqp::TEvCloseSessionRequest::TPtr &ev, const TActorContext &ctx) { 
+        ui64 proxyRequestId = ev->Cookie; 
+        auto& event = ev->Get()->Record; 
+        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId()); 
+        if (CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) { 
+            LOG_INFO_S(ctx, NKikimrServices::KQP_WORKER, requestInfo << "Session closed due to explicit close event"); 
             Counters->ReportWorkerClosedRequest(Settings.DbCounters);
-            FinalCleanup(ctx);
-        }
-    }
-
-    void HandleReady(TEvKqp::TEvPingSessionRequest::TPtr &ev, const TActorContext &ctx) {
-        ui64 proxyRequestId = ev->Cookie;
-        auto& event = ev->Get()->Record;
-        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId());
-        if (!CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) {
-            return;
-        }
-
+            FinalCleanup(ctx); 
+        } 
+    } 
+ 
+    void HandleReady(TEvKqp::TEvPingSessionRequest::TPtr &ev, const TActorContext &ctx) { 
+        ui64 proxyRequestId = ev->Cookie; 
+        auto& event = ev->Get()->Record; 
+        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId()); 
+        if (!CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) { 
+            return; 
+        } 
+ 
         if (ShutdownState) {
-            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo, Ydb::StatusIds::BAD_SESSION,
-                "Session is under shutdown.", ctx);
+            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo, Ydb::StatusIds::BAD_SESSION, 
+                "Session is under shutdown.", ctx); 
             FinalCleanup(ctx);
             return;
         }
 
-        StartIdleTimer(ctx);
-
-        ReplyPingStatus(ev->Sender, proxyRequestId, true, ctx);
-    }
-
-    void HandleReady(TEvKqp::TEvContinueProcess::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-        Y_UNUSED(ctx);
-    }
-
-    void HandleReady(TEvKqp::TEvCompileResponse::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-
-        LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId)
-            << "Unexpected compile response while in Ready state.");
-    }
-
-    void HandleReady(TEvKqp::TEvQueryRequest::TPtr &ev, const TActorContext &ctx) {
-        ui64 proxyRequestId = ev->Cookie;
-        auto& event = ev->Get()->Record;
-        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId());
-
-        if (!CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) {
-            return;
-        }
-
+        StartIdleTimer(ctx); 
+ 
+        ReplyPingStatus(ev->Sender, proxyRequestId, true, ctx); 
+    } 
+ 
+    void HandleReady(TEvKqp::TEvContinueProcess::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+        Y_UNUSED(ctx); 
+    } 
+ 
+    void HandleReady(TEvKqp::TEvCompileResponse::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+ 
+        LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId) 
+            << "Unexpected compile response while in Ready state."); 
+    } 
+ 
+    void HandleReady(TEvKqp::TEvQueryRequest::TPtr &ev, const TActorContext &ctx) { 
+        ui64 proxyRequestId = ev->Cookie; 
+        auto& event = ev->Get()->Record; 
+        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId()); 
+ 
+        if (!CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) { 
+            return; 
+        } 
+ 
         if (ShutdownState && ShutdownState->SoftTimeoutReached()) {
             // we reached the soft timeout, so at this point we don't allow to accept new
             // queries for session.
             LOG_NOTICE_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId)
                 << "System shutdown requested: soft timeout reached, no queries can be accepted. Closing session.");
 
-            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo,
+            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo, 
                 Ydb::StatusIds::BAD_SESSION, "Session is under shutdown.", ctx);
             FinalCleanup(ctx);
             return;
         }
 
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo << "Received request, proxyRequestId: "
-            << proxyRequestId);
-
-        Y_VERIFY(!QueryState);
-        MakeNewQueryState();
-        QueryState->Request.Swap(event.MutableRequest());
-        auto& queryRequest = QueryState->Request;
-
-        if (!queryRequest.HasAction()) {
-            queryRequest.SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
-        }
-
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo << "Received request, proxyRequestId: " 
+            << proxyRequestId); 
+ 
+        Y_VERIFY(!QueryState); 
+        MakeNewQueryState(); 
+        QueryState->Request.Swap(event.MutableRequest()); 
+        auto& queryRequest = QueryState->Request; 
+ 
+        if (!queryRequest.HasAction()) { 
+            queryRequest.SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE); 
+        } 
+ 
         auto now = TAppData::TimeProvider->Now();
 
-        QueryState->ParametersSize = queryRequest.GetParameters().ByteSize();
-        QueryState->Sender = ev->Sender;
-        QueryState->ProxyRequestId = proxyRequestId;
-        QueryState->KeepSession = Settings.LongSession || queryRequest.GetKeepSession();
-        QueryState->TraceId = requestInfo.GetTraceId();
-        QueryState->RequestType = event.GetRequestType();
+        QueryState->ParametersSize = queryRequest.GetParameters().ByteSize(); 
+        QueryState->Sender = ev->Sender; 
+        QueryState->ProxyRequestId = proxyRequestId; 
+        QueryState->KeepSession = Settings.LongSession || queryRequest.GetKeepSession(); 
+        QueryState->TraceId = requestInfo.GetTraceId(); 
+        QueryState->RequestType = event.GetRequestType(); 
         QueryState->StartTime = now;
-        QueryState->ReplyFlags = queryRequest.GetReplyFlags();
-        QueryState->UserToken = event.GetUserToken();
+        QueryState->ReplyFlags = queryRequest.GetReplyFlags(); 
+        QueryState->UserToken = event.GetUserToken(); 
         QueryState->RequestActorId = ActorIdFromProto(event.GetRequestActorId());
-
+ 
         if (GetStatsMode(queryRequest, EKikimrStatsMode::None) > EKikimrStatsMode::Basic) {
             QueryState->ReplyFlags |= NKikimrKqp::QUERY_REPLY_FLAG_AST;
         }
@@ -293,68 +293,68 @@ public:
 
         NCpuTime::TCpuTimer timer;
 
-        if (queryRequest.GetCancelAfterMs()) {
+        if (queryRequest.GetCancelAfterMs()) { 
             QueryState->QueryDeadlines.CancelAt = now + TDuration::MilliSeconds(queryRequest.GetCancelAfterMs());
-        }
-
+        } 
+ 
         auto timeoutMs = GetQueryTimeout(queryRequest.GetType(), queryRequest.GetTimeoutMs(), Settings.Service);
         QueryState->QueryDeadlines.TimeoutAt = now + timeoutMs;
 
-        auto onError = [this, &ctx, &requestInfo] (Ydb::StatusIds::StatusCode status, const TString& message) {
-            ReplyProcessError(QueryState->Sender, QueryState->ProxyRequestId, requestInfo, status, message, ctx);
-
-            if (Settings.LongSession) {
-                QueryState.Reset();
-            } else {
-                Counters->ReportWorkerClosedError(Settings.DbCounters);
-                FinalCleanup(ctx);
-            }
-        };
-
-        auto onBadRequest = [onError] (const TString& message) {
-            onError(Ydb::StatusIds::BAD_REQUEST, message);
-        };
-
-        if (queryRequest.GetDatabase() != Settings.Database) {
-            onBadRequest(TStringBuilder() << "Wrong database, expected:" << Settings.Database
-                << ", got: " << queryRequest.GetDatabase());
-            return;
-        }
-
-        if (!CheckLegacyYql(requestInfo, queryRequest, ctx)) {
-            onBadRequest(TStringBuilder() << "Legacy YQL requests are restricted in current database, action: "
-                << (ui32)queryRequest.GetAction() << ", type: " << (ui32)queryRequest.GetType());
-            return;
-        }
-
-        switch (queryRequest.GetAction()) {
-            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED:
-            case NKikimrKqp::QUERY_ACTION_BEGIN_TX:
-            case NKikimrKqp::QUERY_ACTION_COMMIT_TX:
-            case NKikimrKqp::QUERY_ACTION_ROLLBACK_TX:
-                break;
-            default:
-                if (!queryRequest.HasType()) {
-                    onBadRequest("Query type not specified");
-                    return;
-                }
-        }
-
-        switch (queryRequest.GetAction()) {
-            case NKikimrKqp::QUERY_ACTION_EXPLAIN:
+        auto onError = [this, &ctx, &requestInfo] (Ydb::StatusIds::StatusCode status, const TString& message) { 
+            ReplyProcessError(QueryState->Sender, QueryState->ProxyRequestId, requestInfo, status, message, ctx); 
+ 
+            if (Settings.LongSession) { 
+                QueryState.Reset(); 
+            } else { 
+                Counters->ReportWorkerClosedError(Settings.DbCounters); 
+                FinalCleanup(ctx); 
+            } 
+        }; 
+ 
+        auto onBadRequest = [onError] (const TString& message) { 
+            onError(Ydb::StatusIds::BAD_REQUEST, message); 
+        }; 
+ 
+        if (queryRequest.GetDatabase() != Settings.Database) { 
+            onBadRequest(TStringBuilder() << "Wrong database, expected:" << Settings.Database 
+                << ", got: " << queryRequest.GetDatabase()); 
+            return; 
+        } 
+ 
+        if (!CheckLegacyYql(requestInfo, queryRequest, ctx)) { 
+            onBadRequest(TStringBuilder() << "Legacy YQL requests are restricted in current database, action: " 
+                << (ui32)queryRequest.GetAction() << ", type: " << (ui32)queryRequest.GetType()); 
+            return; 
+        } 
+ 
+        switch (queryRequest.GetAction()) { 
+            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED: 
+            case NKikimrKqp::QUERY_ACTION_BEGIN_TX: 
+            case NKikimrKqp::QUERY_ACTION_COMMIT_TX: 
+            case NKikimrKqp::QUERY_ACTION_ROLLBACK_TX: 
+                break; 
+            default: 
+                if (!queryRequest.HasType()) { 
+                    onBadRequest("Query type not specified"); 
+                    return; 
+                } 
+        } 
+ 
+        switch (queryRequest.GetAction()) { 
+            case NKikimrKqp::QUERY_ACTION_EXPLAIN: 
             case NKikimrKqp::QUERY_ACTION_PARSE:
-            case NKikimrKqp::QUERY_ACTION_VALIDATE:
-            case NKikimrKqp::QUERY_ACTION_PREPARE:
-                if (QueryState->KeepSession && !Settings.LongSession) {
-                    onBadRequest("Expected KeepSession=false for non-execute requests");
-                    return;
-                }
-                break;
-
-            default:
-                break;
-        }
-
+            case NKikimrKqp::QUERY_ACTION_VALIDATE: 
+            case NKikimrKqp::QUERY_ACTION_PREPARE: 
+                if (QueryState->KeepSession && !Settings.LongSession) { 
+                    onBadRequest("Expected KeepSession=false for non-execute requests"); 
+                    return; 
+                } 
+                break; 
+ 
+            default: 
+                break; 
+        } 
+ 
         HandleQueryRequest(timer, false, ctx);
     }
 
@@ -369,7 +369,7 @@ public:
             QueryState->OldEngineFallback = true;
         }
 
-        if (queryRequest.HasTxControl()) {
+        if (queryRequest.HasTxControl()) { 
             const auto& txControl = queryRequest.GetTxControl();
 
             switch (txControl.tx_selector_case()) {
@@ -405,26 +405,26 @@ public:
                 case Ydb::Table::TransactionControl::TX_SELECTOR_NOT_SET: {
                     Y_VERIFY(false);
                 }
-            }
+            } 
         } else {
             // some kind of internal query? or verify here?
-        }
-
-        StopIdleTimer(ctx);
-
-        if (CompileQuery(ctx)) {
+        } 
+ 
+        StopIdleTimer(ctx); 
+ 
+        if (CompileQuery(ctx)) { 
             if (QueryState) {
                 QueryState->CpuTime += timer.GetTime();
             }
-            return;
-        }
-
-        PerformQuery(ctx);
+            return; 
+        } 
+ 
+        PerformQuery(ctx); 
         if (QueryState) {
             QueryState->CpuTime += timer.GetTime();
         }
-    }
-
+    } 
+ 
     void HandleContinueShutdown(TEvKqp::TEvContinueShutdown::TPtr &ev, const TActorContext &ctx) {
         Y_UNUSED(ev);
         CheckContinueShutdown(ctx);
@@ -440,36 +440,36 @@ public:
         }
     }
 
-    void HandleReady(TEvKqp::TEvIdleTimeout::TPtr &ev, const TActorContext &ctx) {
-        auto timerId = ev->Get()->TimerId;
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, "Received TEvIdleTimeout in ready state, timer id: "
-            << timerId << ", sender: " << ev->Sender);
-
-        if (timerId == IdleTimerId) {
-            LOG_NOTICE_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId)
-                << "Worker idle timeout, worker destroyed");
+    void HandleReady(TEvKqp::TEvIdleTimeout::TPtr &ev, const TActorContext &ctx) { 
+        auto timerId = ev->Get()->TimerId; 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, "Received TEvIdleTimeout in ready state, timer id: " 
+            << timerId << ", sender: " << ev->Sender); 
+ 
+        if (timerId == IdleTimerId) { 
+            LOG_NOTICE_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId) 
+                << "Worker idle timeout, worker destroyed"); 
             Counters->ReportWorkerClosedIdle(Settings.DbCounters);
-            FinalCleanup(ctx);
-        }
-    }
-
-    void HandleCompileQuery(TEvKqp::TEvCompileResponse::TPtr &ev, const TActorContext &ctx) {
-        auto compileResult = ev->Get()->CompileResult;
-
-        Y_VERIFY(compileResult);
-        Y_VERIFY(QueryState);
-
+            FinalCleanup(ctx); 
+        } 
+    } 
+ 
+    void HandleCompileQuery(TEvKqp::TEvCompileResponse::TPtr &ev, const TActorContext &ctx) { 
+        auto compileResult = ev->Get()->CompileResult; 
+ 
+        Y_VERIFY(compileResult); 
+        Y_VERIFY(QueryState); 
+ 
         if (compileResult->Status != Ydb::StatusIds::SUCCESS) {
             if (ReplyQueryCompileError(compileResult, ctx)) {
-                StartIdleTimer(ctx);
-                Become(&TKqpWorkerActor::ReadyState);
-            } else {
-                FinalCleanup(ctx);
-            }
-
-            return;
-        }
-
+                StartIdleTimer(ctx); 
+                Become(&TKqpWorkerActor::ReadyState); 
+            } else { 
+                FinalCleanup(ctx); 
+            } 
+ 
+            return; 
+        } 
+ 
         QueryState->QueryTraits = compileResult->QueryTraits;
 
         if (!QueryState->ForceNewEngineState.ForcedNewEngine.has_value()) {
@@ -484,97 +484,97 @@ public:
 
         if (queryRequest.GetAction() == NKikimrKqp::QUERY_ACTION_PREPARE) {
             if (ReplyPrepareResult(compileResult, ctx)) {
-                StartIdleTimer(ctx);
-                Become(&TKqpWorkerActor::ReadyState);
-            } else {
-                FinalCleanup(ctx);
-            }
-
-            return;
-        }
-
-        QueryState->QueryCompileResult = compileResult;
-
-        switch (queryRequest.GetAction()) {
-            case NKikimrKqp::QUERY_ACTION_EXECUTE:
-            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED:
-                break;
-
-            default:
-                Y_VERIFY_S(false, "Unexpected action on successful compile result: "
+                StartIdleTimer(ctx); 
+                Become(&TKqpWorkerActor::ReadyState); 
+            } else { 
+                FinalCleanup(ctx); 
+            } 
+ 
+            return; 
+        } 
+ 
+        QueryState->QueryCompileResult = compileResult; 
+ 
+        switch (queryRequest.GetAction()) { 
+            case NKikimrKqp::QUERY_ACTION_EXECUTE: 
+            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED: 
+                break; 
+ 
+            default: 
+                Y_VERIFY_S(false, "Unexpected action on successful compile result: " 
                     << NKikimrKqp::EQueryAction_Name(queryRequest.GetAction()));
-                break;
-        }
-
+                break; 
+        } 
+ 
         NCpuTime::TCpuTimer timer;
-        PerformQuery(ctx);
+        PerformQuery(ctx); 
 
         // PerformQuery can reset QueryState
         if (QueryState) {
             QueryState->CpuTime += timer.GetTime();
         }
-    }
-
-    void HandleCompileQuery(TEvKqp::TEvQueryRequest::TPtr &ev, const TActorContext &ctx) {
-        ReplyBusy(ev, ctx);
-    }
-
-    void HandleCompileQuery(TEvKqp::TEvCloseSessionRequest::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-
-        Y_VERIFY(QueryState);
-        ReplyProcessError(QueryState->Sender, QueryState->ProxyRequestId,
-            TKqpRequestInfo(QueryState->TraceId, SessionId), Ydb::StatusIds::BAD_SESSION,
-                "Session is being closed", ctx);
-
+    } 
+ 
+    void HandleCompileQuery(TEvKqp::TEvQueryRequest::TPtr &ev, const TActorContext &ctx) { 
+        ReplyBusy(ev, ctx); 
+    } 
+ 
+    void HandleCompileQuery(TEvKqp::TEvCloseSessionRequest::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+ 
+        Y_VERIFY(QueryState); 
+        ReplyProcessError(QueryState->Sender, QueryState->ProxyRequestId, 
+            TKqpRequestInfo(QueryState->TraceId, SessionId), Ydb::StatusIds::BAD_SESSION, 
+                "Session is being closed", ctx); 
+ 
         Counters->ReportWorkerClosedError(Settings.DbCounters);
-        FinalCleanup(ctx);
-    }
-
-    void HandleCompileQuery(TEvKqp::TEvPingSessionRequest::TPtr &ev, const TActorContext &ctx) {
-        ui64 proxyRequestId = ev->Cookie;
-        ReplyPingStatus(ev->Sender, proxyRequestId, false, ctx);
-    }
-
-    void HandleCompileQuery(TEvKqp::TEvIdleTimeout::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-        Y_UNUSED(ctx);
-    }
-
-    void HandlePerformQuery(TEvKqp::TEvQueryRequest::TPtr &ev, const TActorContext &ctx) {
-        ReplyBusy(ev, ctx);
-    }
-
-    void HandlePerformQuery(TEvKqp::TEvCompileResponse::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-
-        LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId)
-            << "Unexpected compile response while in PerformQuery state.");
-    }
-
-    void HandlePerformQuery(TEvKqp::TEvCloseSessionRequest::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-        Y_UNUSED(ctx);
-        QueryState->KeepSession = false;
-    }
-
-    void HandlePerformQuery(TEvKqp::TEvPingSessionRequest::TPtr &ev, const TActorContext &ctx) {
-        ui64 proxyRequestId = ev->Cookie;
-        ReplyPingStatus(ev->Sender, proxyRequestId, false, ctx);
-    }
-
-    void HandlePerformQuery(TEvKqp::TEvContinueProcess::TPtr &ev, const TActorContext &ctx) {
-        if (ev->Get()->QueryId != QueryId) {
-            return;
-        }
-
-        Y_VERIFY(QueryState);
+        FinalCleanup(ctx); 
+    } 
+ 
+    void HandleCompileQuery(TEvKqp::TEvPingSessionRequest::TPtr &ev, const TActorContext &ctx) { 
+        ui64 proxyRequestId = ev->Cookie; 
+        ReplyPingStatus(ev->Sender, proxyRequestId, false, ctx); 
+    } 
+ 
+    void HandleCompileQuery(TEvKqp::TEvIdleTimeout::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+        Y_UNUSED(ctx); 
+    } 
+ 
+    void HandlePerformQuery(TEvKqp::TEvQueryRequest::TPtr &ev, const TActorContext &ctx) { 
+        ReplyBusy(ev, ctx); 
+    } 
+ 
+    void HandlePerformQuery(TEvKqp::TEvCompileResponse::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+ 
+        LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId) 
+            << "Unexpected compile response while in PerformQuery state."); 
+    } 
+ 
+    void HandlePerformQuery(TEvKqp::TEvCloseSessionRequest::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+        Y_UNUSED(ctx); 
+        QueryState->KeepSession = false; 
+    } 
+ 
+    void HandlePerformQuery(TEvKqp::TEvPingSessionRequest::TPtr &ev, const TActorContext &ctx) { 
+        ui64 proxyRequestId = ev->Cookie; 
+        ReplyPingStatus(ev->Sender, proxyRequestId, false, ctx); 
+    } 
+ 
+    void HandlePerformQuery(TEvKqp::TEvContinueProcess::TPtr &ev, const TActorContext &ctx) { 
+        if (ev->Get()->QueryId != QueryId) { 
+            return; 
+        } 
+ 
+        Y_VERIFY(QueryState); 
         TYqlLogScope logScope(ctx, NKikimrServices::KQP_YQL, SessionId, QueryState->TraceId);
-
-        if (ev->Get()->Finished) {
-            QueryState->QueryResult = QueryState->AsyncQueryResult->GetResult();
-            QueryState->AsyncQueryResult.Reset();
-
+ 
+        if (ev->Get()->Finished) { 
+            QueryState->QueryResult = QueryState->AsyncQueryResult->GetResult(); 
+            QueryState->AsyncQueryResult.Reset(); 
+ 
             if (!QueryState->OldEngineFallback) {
                 auto& x = QueryState->ForceNewEngineState;
                 if (x.ForcedNewEngine && *x.ForcedNewEngine) {
@@ -608,418 +608,418 @@ public:
                 }
             }
 
-            QueryCleanup(ctx);
-        } else {
+            QueryCleanup(ctx); 
+        } else { 
             NCpuTime::TCpuTimer timer(QueryState->CpuTime);
-            ContinueQueryProcess(ctx);
-        }
-    }
-
-    void HandlePerformQuery(TEvKqp::TEvIdleTimeout::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-        Y_UNUSED(ctx);
-    }
-
-    void HandlePerformCleanup(TEvKqp::TEvQueryRequest::TPtr &ev, const TActorContext &ctx) {
-        ui64 proxyRequestId = ev->Cookie;
-        auto& event = ev->Get()->Record;
-        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId());
-
-        if (!CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) {
-            return;
-        }
-
-        Y_VERIFY(CleanupState);
-        if (CleanupState->Final) {
-            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo, Ydb::StatusIds::BAD_SESSION,
-                "Session is being closed", ctx);
-        } else {
-            auto busyStatus = Settings.Service.GetUseSessionBusyStatus()
-                ? Ydb::StatusIds::SESSION_BUSY
-                : Ydb::StatusIds::PRECONDITION_FAILED;
-
-            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo,
-                busyStatus, "Pending previous query completion", ctx);
-        }
-    }
-
-    void HandlePerformCleanup(TEvKqp::TEvCompileResponse::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-
-        Y_VERIFY(CleanupState);
-        if (!CleanupState->Final) {
-            LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId)
-                << "Unexpected compile response while in PerformCleanup state.");
-        }
-    }
-
-    void HandlePerformCleanup(TEvKqp::TEvCloseSessionRequest::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-        Y_UNUSED(ctx);
-
-        Y_VERIFY(CleanupState);
-        if (!CleanupState->Final) {
-            Y_VERIFY(QueryState);
-            QueryState->KeepSession = false;
-        }
-    }
-
-    void HandlePerformCleanup(TEvKqp::TEvPingSessionRequest::TPtr &ev, const TActorContext &ctx) {
-        Y_VERIFY(CleanupState);
-
-        ui64 proxyRequestId = ev->Cookie;
-        auto& event = ev->Get()->Record;
-        TKqpRequestInfo requestInfo(event.GetTraceId(), event.GetRequest().GetSessionId());
-
-        if (CleanupState->Final) {
-            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo,
-                Ydb::StatusIds::BAD_SESSION, "Session is being closed", ctx);
-        } else {
-            ReplyPingStatus(ev->Sender, proxyRequestId, false, ctx);
-        }
-    }
-
-    void HandlePerformCleanup(TEvKqp::TEvContinueProcess::TPtr &ev, const TActorContext &ctx) {
-        if (ev->Get()->QueryId != QueryId) {
-            return;
-        }
-
+            ContinueQueryProcess(ctx); 
+        } 
+    } 
+ 
+    void HandlePerformQuery(TEvKqp::TEvIdleTimeout::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+        Y_UNUSED(ctx); 
+    } 
+ 
+    void HandlePerformCleanup(TEvKqp::TEvQueryRequest::TPtr &ev, const TActorContext &ctx) { 
+        ui64 proxyRequestId = ev->Cookie; 
+        auto& event = ev->Get()->Record; 
+        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId()); 
+ 
+        if (!CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) { 
+            return; 
+        } 
+ 
+        Y_VERIFY(CleanupState); 
+        if (CleanupState->Final) { 
+            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo, Ydb::StatusIds::BAD_SESSION, 
+                "Session is being closed", ctx); 
+        } else { 
+            auto busyStatus = Settings.Service.GetUseSessionBusyStatus() 
+                ? Ydb::StatusIds::SESSION_BUSY 
+                : Ydb::StatusIds::PRECONDITION_FAILED; 
+ 
+            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo, 
+                busyStatus, "Pending previous query completion", ctx); 
+        } 
+    } 
+ 
+    void HandlePerformCleanup(TEvKqp::TEvCompileResponse::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+ 
+        Y_VERIFY(CleanupState); 
+        if (!CleanupState->Final) { 
+            LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId) 
+                << "Unexpected compile response while in PerformCleanup state."); 
+        } 
+    } 
+ 
+    void HandlePerformCleanup(TEvKqp::TEvCloseSessionRequest::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+        Y_UNUSED(ctx); 
+ 
+        Y_VERIFY(CleanupState); 
+        if (!CleanupState->Final) { 
+            Y_VERIFY(QueryState); 
+            QueryState->KeepSession = false; 
+        } 
+    } 
+ 
+    void HandlePerformCleanup(TEvKqp::TEvPingSessionRequest::TPtr &ev, const TActorContext &ctx) { 
+        Y_VERIFY(CleanupState); 
+ 
+        ui64 proxyRequestId = ev->Cookie; 
+        auto& event = ev->Get()->Record; 
+        TKqpRequestInfo requestInfo(event.GetTraceId(), event.GetRequest().GetSessionId()); 
+ 
+        if (CleanupState->Final) { 
+            ReplyProcessError(ev->Sender, proxyRequestId, requestInfo, 
+                Ydb::StatusIds::BAD_SESSION, "Session is being closed", ctx); 
+        } else { 
+            ReplyPingStatus(ev->Sender, proxyRequestId, false, ctx); 
+        } 
+    } 
+ 
+    void HandlePerformCleanup(TEvKqp::TEvContinueProcess::TPtr &ev, const TActorContext &ctx) { 
+        if (ev->Get()->QueryId != QueryId) { 
+            return; 
+        } 
+ 
         TYqlLogScope logScope(ctx, NKikimrServices::KQP_YQL, SessionId);
-
-        if (ev->Get()->Finished) {
-            Y_VERIFY(CleanupState);
-            auto result = CleanupState->AsyncResult->GetResult();
-            if (!result.Success()) {
-                LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId)
-                    << "Failed to cleanup: " << result.Issues().ToString());
-            }
-
-            EndCleanup(ctx);
-        } else {
-            ContinueCleanup(ctx);
-        }
-    }
-
-    void HandlePerformCleanup(TEvKqp::TEvIdleTimeout::TPtr &ev, const TActorContext &ctx) {
-        Y_UNUSED(ev);
-        Y_UNUSED(ctx);
-    }
-
-    STFUNC(ReadyState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TEvKqp::TEvQueryRequest, HandleReady);
-            HFunc(TEvKqp::TEvCompileResponse, HandleReady);
-            HFunc(TEvKqp::TEvCloseSessionRequest, HandleReady);
-            HFunc(TEvKqp::TEvPingSessionRequest, HandleReady);
-            HFunc(TEvKqp::TEvContinueProcess, HandleReady);
-            HFunc(TEvKqp::TEvIdleTimeout, HandleReady);
+ 
+        if (ev->Get()->Finished) { 
+            Y_VERIFY(CleanupState); 
+            auto result = CleanupState->AsyncResult->GetResult(); 
+            if (!result.Success()) { 
+                LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo("", SessionId) 
+                    << "Failed to cleanup: " << result.Issues().ToString()); 
+            } 
+ 
+            EndCleanup(ctx); 
+        } else { 
+            ContinueCleanup(ctx); 
+        } 
+    } 
+ 
+    void HandlePerformCleanup(TEvKqp::TEvIdleTimeout::TPtr &ev, const TActorContext &ctx) { 
+        Y_UNUSED(ev); 
+        Y_UNUSED(ctx); 
+    } 
+ 
+    STFUNC(ReadyState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TEvKqp::TEvQueryRequest, HandleReady); 
+            HFunc(TEvKqp::TEvCompileResponse, HandleReady); 
+            HFunc(TEvKqp::TEvCloseSessionRequest, HandleReady); 
+            HFunc(TEvKqp::TEvPingSessionRequest, HandleReady); 
+            HFunc(TEvKqp::TEvContinueProcess, HandleReady); 
+            HFunc(TEvKqp::TEvIdleTimeout, HandleReady); 
             HFunc(TEvKqp::TEvInitiateSessionShutdown, HandleInitiateShutdown);
             HFunc(TEvKqp::TEvContinueShutdown, HandleContinueShutdown);
-        default:
-            Y_FAIL("TKqpWorkerActor, ReadyState: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite());
-        }
-    }
-
-    STFUNC(CompileQueryState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TEvKqp::TEvQueryRequest, HandleCompileQuery);
-            HFunc(TEvKqp::TEvCompileResponse, HandleCompileQuery);
-            HFunc(TEvKqp::TEvCloseSessionRequest, HandleCompileQuery);
-            HFunc(TEvKqp::TEvPingSessionRequest, HandleCompileQuery);
-            HFunc(TEvKqp::TEvIdleTimeout, HandleCompileQuery);
+        default: 
+            Y_FAIL("TKqpWorkerActor, ReadyState: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite()); 
+        } 
+    } 
+ 
+    STFUNC(CompileQueryState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TEvKqp::TEvQueryRequest, HandleCompileQuery); 
+            HFunc(TEvKqp::TEvCompileResponse, HandleCompileQuery); 
+            HFunc(TEvKqp::TEvCloseSessionRequest, HandleCompileQuery); 
+            HFunc(TEvKqp::TEvPingSessionRequest, HandleCompileQuery); 
+            HFunc(TEvKqp::TEvIdleTimeout, HandleCompileQuery); 
             HFunc(TEvKqp::TEvInitiateSessionShutdown, HandleInitiateShutdown);
             HFunc(TEvKqp::TEvContinueShutdown, HandleContinueShutdown);
-        default:
-            Y_FAIL("TKqpWorkerActor, CompileQueryState: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite());
-        }
-    }
-
-    STFUNC(PerformQueryState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TEvKqp::TEvQueryRequest, HandlePerformQuery);
-            HFunc(TEvKqp::TEvCompileResponse, HandlePerformQuery);
-            HFunc(TEvKqp::TEvCloseSessionRequest, HandlePerformQuery);
+        default: 
+            Y_FAIL("TKqpWorkerActor, CompileQueryState: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite()); 
+        } 
+    } 
+ 
+    STFUNC(PerformQueryState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TEvKqp::TEvQueryRequest, HandlePerformQuery); 
+            HFunc(TEvKqp::TEvCompileResponse, HandlePerformQuery); 
+            HFunc(TEvKqp::TEvCloseSessionRequest, HandlePerformQuery); 
             HFunc(TEvKqp::TEvPingSessionRequest, HandlePerformQuery);
-            HFunc(TEvKqp::TEvContinueProcess, HandlePerformQuery);
-            HFunc(TEvKqp::TEvIdleTimeout, HandlePerformQuery);
+            HFunc(TEvKqp::TEvContinueProcess, HandlePerformQuery); 
+            HFunc(TEvKqp::TEvIdleTimeout, HandlePerformQuery); 
             HFunc(TEvKqp::TEvInitiateSessionShutdown, HandleInitiateShutdown);
             HFunc(TEvKqp::TEvContinueShutdown, HandleContinueShutdown);
-        default:
-            Y_FAIL("TKqpWorkerActor, PerformQueryState: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite());
-        }
-    }
-
-    STFUNC(PerformCleanupState) {
-        switch (ev->GetTypeRewrite()) {
-            HFunc(TEvKqp::TEvQueryRequest, HandlePerformCleanup);
-            HFunc(TEvKqp::TEvCompileResponse, HandlePerformCleanup);
-            HFunc(TEvKqp::TEvCloseSessionRequest, HandlePerformCleanup);
+        default: 
+            Y_FAIL("TKqpWorkerActor, PerformQueryState: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite()); 
+        } 
+    } 
+ 
+    STFUNC(PerformCleanupState) { 
+        switch (ev->GetTypeRewrite()) { 
+            HFunc(TEvKqp::TEvQueryRequest, HandlePerformCleanup); 
+            HFunc(TEvKqp::TEvCompileResponse, HandlePerformCleanup); 
+            HFunc(TEvKqp::TEvCloseSessionRequest, HandlePerformCleanup); 
             HFunc(TEvKqp::TEvPingSessionRequest, HandlePerformCleanup);
-            HFunc(TEvKqp::TEvContinueProcess, HandlePerformCleanup);
-            HFunc(TEvKqp::TEvIdleTimeout, HandlePerformCleanup);
+            HFunc(TEvKqp::TEvContinueProcess, HandlePerformCleanup); 
+            HFunc(TEvKqp::TEvIdleTimeout, HandlePerformCleanup); 
             HFunc(TEvKqp::TEvInitiateSessionShutdown, HandleInitiateShutdown);
             HFunc(TEvKqp::TEvContinueShutdown, HandleContinueShutdown);
-        default:
-            Y_FAIL("TKqpWorkerActor, PerformCleanupState: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite());
-        }
-    }
-
-private:
-    bool CheckLegacyYql(const TKqpRequestInfo& requestInfo, const NKikimrKqp::TQueryRequest& queryRequest,
-        const TActorContext& ctx)
-    {
-        switch (queryRequest.GetType()) {
-            case NKikimrKqp::QUERY_TYPE_UNDEFINED:
-                switch (queryRequest.GetAction()) {
-                    case NKikimrKqp::QUERY_ACTION_EXECUTE:
-                    case NKikimrKqp::QUERY_ACTION_EXPLAIN:
+        default: 
+            Y_FAIL("TKqpWorkerActor, PerformCleanupState: unexpected event 0x%08" PRIx32, ev->GetTypeRewrite()); 
+        } 
+    } 
+ 
+private: 
+    bool CheckLegacyYql(const TKqpRequestInfo& requestInfo, const NKikimrKqp::TQueryRequest& queryRequest, 
+        const TActorContext& ctx) 
+    { 
+        switch (queryRequest.GetType()) { 
+            case NKikimrKqp::QUERY_TYPE_UNDEFINED: 
+                switch (queryRequest.GetAction()) { 
+                    case NKikimrKqp::QUERY_ACTION_EXECUTE: 
+                    case NKikimrKqp::QUERY_ACTION_EXPLAIN: 
                     case NKikimrKqp::QUERY_ACTION_PARSE:
-                    case NKikimrKqp::QUERY_ACTION_VALIDATE:
-                    case NKikimrKqp::QUERY_ACTION_PREPARE:
-                    case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED:
-                        break;
-
-                    default:
-                        return true;
-                }
-                break;
-
-            default:
-                return true;
-        }
-
-        LOG_NOTICE_S(ctx, NKikimrServices::KQP_WORKER, requestInfo << "Legacy YQL request"
-            << ", action: " << (ui32)queryRequest.GetAction()
-            << ", type: " << (ui32)queryRequest.GetType()
-            << ", query: \"" << queryRequest.GetQuery().substr(0, 1000) << "\"");
-
+                    case NKikimrKqp::QUERY_ACTION_VALIDATE: 
+                    case NKikimrKqp::QUERY_ACTION_PREPARE: 
+                    case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED: 
+                        break; 
+ 
+                    default: 
+                        return true; 
+                } 
+                break; 
+ 
+            default: 
+                return true; 
+        } 
+ 
+        LOG_NOTICE_S(ctx, NKikimrServices::KQP_WORKER, requestInfo << "Legacy YQL request" 
+            << ", action: " << (ui32)queryRequest.GetAction() 
+            << ", type: " << (ui32)queryRequest.GetType() 
+            << ", query: \"" << queryRequest.GetQuery().substr(0, 1000) << "\""); 
+ 
         return false;
-    }
-
-    IKqpHost::TBeginTxResult BeginTransaction(const Ydb::Table::TransactionSettings& settings) {
-        NKikimrKqp::EIsolationLevel isolation = NKikimrKqp::ISOLATION_LEVEL_UNDEFINED;
-        bool readonly = true;
-
-        switch (settings.tx_mode_case()) {
-            case Ydb::Table::TransactionSettings::kSerializableReadWrite:
-                isolation = NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE;
-                readonly = false;
-                break;
-
-            case Ydb::Table::TransactionSettings::kOnlineReadOnly:
-                isolation = settings.online_read_only().allow_inconsistent_reads()
-                    ? NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED
-                    : NKikimrKqp::ISOLATION_LEVEL_READ_COMMITTED;
-                readonly = true;
-                break;
-
-            case Ydb::Table::TransactionSettings::kStaleReadOnly:
-                isolation = NKikimrKqp::ISOLATION_LEVEL_READ_STALE;
-                readonly = true;
-                break;
-
-            default:
-                break;
-        };
-
-        return KqpHost->BeginTransaction(isolation, readonly);
-    }
-
+    } 
+ 
+    IKqpHost::TBeginTxResult BeginTransaction(const Ydb::Table::TransactionSettings& settings) { 
+        NKikimrKqp::EIsolationLevel isolation = NKikimrKqp::ISOLATION_LEVEL_UNDEFINED; 
+        bool readonly = true; 
+ 
+        switch (settings.tx_mode_case()) { 
+            case Ydb::Table::TransactionSettings::kSerializableReadWrite: 
+                isolation = NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE; 
+                readonly = false; 
+                break; 
+ 
+            case Ydb::Table::TransactionSettings::kOnlineReadOnly: 
+                isolation = settings.online_read_only().allow_inconsistent_reads() 
+                    ? NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED 
+                    : NKikimrKqp::ISOLATION_LEVEL_READ_COMMITTED; 
+                readonly = true; 
+                break; 
+ 
+            case Ydb::Table::TransactionSettings::kStaleReadOnly: 
+                isolation = NKikimrKqp::ISOLATION_LEVEL_READ_STALE; 
+                readonly = true; 
+                break; 
+ 
+            default: 
+                break; 
+        }; 
+ 
+        return KqpHost->BeginTransaction(isolation, readonly); 
+    } 
+ 
     bool CompileQuery(const TActorContext& ctx) {
-        if (!Settings.LongSession) {
-            return false;
-        }
-
-        Y_VERIFY(QueryState);
-        auto& queryRequest = QueryState->Request;
-
-        switch (queryRequest.GetType()) {
-            case NKikimrKqp::QUERY_TYPE_SQL_DML:
-            case NKikimrKqp::QUERY_TYPE_PREPARED_DML:
-                break;
-
-            default:
-                return false;
-        }
-
-        TMaybe<TKqpQueryId> query;
-        TMaybe<TString> uid;
-
-        bool keepInCache = false;
-        switch (queryRequest.GetAction()) {
-            case NKikimrKqp::QUERY_ACTION_EXECUTE:
-                query = TKqpQueryId(Settings.Cluster, Settings.Database, queryRequest.GetQuery());
-                keepInCache = queryRequest.GetQueryCachePolicy().keep_in_cache();
-                break;
-
-            case NKikimrKqp::QUERY_ACTION_PREPARE:
-                query = TKqpQueryId(Settings.Cluster, Settings.Database, queryRequest.GetQuery());
-                keepInCache = true;
-                break;
-
-            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED:
-                uid = queryRequest.GetPreparedQuery();
-                keepInCache = queryRequest.GetQueryCachePolicy().keep_in_cache();
-                break;
-
-            default:
-                return false;
-        }
-
-        if (query) {
-            query->Settings.DocumentApiRestricted = IsDocumentApiRestricted(QueryState->RequestType);
-        }
-
-        auto compileDeadline = QueryState->QueryDeadlines.TimeoutAt;
-        if (QueryState->QueryDeadlines.CancelAt) {
-            compileDeadline = Min(compileDeadline, QueryState->QueryDeadlines.CancelAt);
-        }
-
-        auto compileRequestActor = CreateKqpCompileRequestActor(ctx.SelfID, QueryState->UserToken, uid,
+        if (!Settings.LongSession) { 
+            return false; 
+        } 
+ 
+        Y_VERIFY(QueryState); 
+        auto& queryRequest = QueryState->Request; 
+ 
+        switch (queryRequest.GetType()) { 
+            case NKikimrKqp::QUERY_TYPE_SQL_DML: 
+            case NKikimrKqp::QUERY_TYPE_PREPARED_DML: 
+                break; 
+ 
+            default: 
+                return false; 
+        } 
+ 
+        TMaybe<TKqpQueryId> query; 
+        TMaybe<TString> uid; 
+ 
+        bool keepInCache = false; 
+        switch (queryRequest.GetAction()) { 
+            case NKikimrKqp::QUERY_ACTION_EXECUTE: 
+                query = TKqpQueryId(Settings.Cluster, Settings.Database, queryRequest.GetQuery()); 
+                keepInCache = queryRequest.GetQueryCachePolicy().keep_in_cache(); 
+                break; 
+ 
+            case NKikimrKqp::QUERY_ACTION_PREPARE: 
+                query = TKqpQueryId(Settings.Cluster, Settings.Database, queryRequest.GetQuery()); 
+                keepInCache = true; 
+                break; 
+ 
+            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED: 
+                uid = queryRequest.GetPreparedQuery(); 
+                keepInCache = queryRequest.GetQueryCachePolicy().keep_in_cache(); 
+                break; 
+ 
+            default: 
+                return false; 
+        } 
+ 
+        if (query) { 
+            query->Settings.DocumentApiRestricted = IsDocumentApiRestricted(QueryState->RequestType); 
+        } 
+ 
+        auto compileDeadline = QueryState->QueryDeadlines.TimeoutAt; 
+        if (QueryState->QueryDeadlines.CancelAt) { 
+            compileDeadline = Min(compileDeadline, QueryState->QueryDeadlines.CancelAt); 
+        } 
+ 
+        auto compileRequestActor = CreateKqpCompileRequestActor(ctx.SelfID, QueryState->UserToken, uid, 
             std::move(query), keepInCache, compileDeadline, Settings.DbCounters);
-        ctx.ExecutorThread.RegisterActor(compileRequestActor);
-
-        Become(&TKqpWorkerActor::CompileQueryState);
-        return true;
-    }
-
+        ctx.ExecutorThread.RegisterActor(compileRequestActor); 
+ 
+        Become(&TKqpWorkerActor::CompileQueryState); 
+        return true; 
+    } 
+ 
     void PerformQuery(const TActorContext& ctx) {
-        Y_VERIFY(QueryState);
-        auto requestInfo = TKqpRequestInfo(QueryState->TraceId, SessionId);
+        Y_VERIFY(QueryState); 
+        auto requestInfo = TKqpRequestInfo(QueryState->TraceId, SessionId); 
         TYqlLogScope logScope(ctx, NKikimrServices::KQP_YQL, SessionId, QueryState->TraceId);
-
-        Gateway->SetToken(Settings.Cluster, QueryState->UserToken);
-        auto& queryRequest = QueryState->Request;
-
-        IKqpHost::TBeginTxResult beginTxResult;
-        auto onError = [this, &ctx, &requestInfo, &beginTxResult]
-            (Ydb::StatusIds::StatusCode status, const TString& message) {
-                ReplyProcessError(QueryState->Sender, QueryState->ProxyRequestId, requestInfo, status, message, ctx);
-
-                if (beginTxResult.Success()) {
-                    auto deleteResult = KqpHost->DeleteTransaction(beginTxResult.TxId);
-                    if (!deleteResult.Success()) {
-                        LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, "Failed to delete empty tx: "
-                            << beginTxResult.TxId << ", error: " << deleteResult.Issues().ToString());
-                    }
-                }
-
-                if (Settings.LongSession) {
-                    QueryState.Reset();
-                } else {
+ 
+        Gateway->SetToken(Settings.Cluster, QueryState->UserToken); 
+        auto& queryRequest = QueryState->Request; 
+ 
+        IKqpHost::TBeginTxResult beginTxResult; 
+        auto onError = [this, &ctx, &requestInfo, &beginTxResult] 
+            (Ydb::StatusIds::StatusCode status, const TString& message) { 
+                ReplyProcessError(QueryState->Sender, QueryState->ProxyRequestId, requestInfo, status, message, ctx); 
+ 
+                if (beginTxResult.Success()) { 
+                    auto deleteResult = KqpHost->DeleteTransaction(beginTxResult.TxId); 
+                    if (!deleteResult.Success()) { 
+                        LOG_ERROR_S(ctx, NKikimrServices::KQP_WORKER, "Failed to delete empty tx: " 
+                            << beginTxResult.TxId << ", error: " << deleteResult.Issues().ToString()); 
+                    } 
+                } 
+ 
+                if (Settings.LongSession) { 
+                    QueryState.Reset(); 
+                } else { 
                     Counters->ReportWorkerClosedError(Settings.DbCounters);
-                    FinalCleanup(ctx);
-                }
-            };
-
-        auto onBadRequest = [onError] (const TString& message) {
-            onError(Ydb::StatusIds::BAD_REQUEST, message);
-        };
-
+                    FinalCleanup(ctx); 
+                } 
+            }; 
+ 
+        auto onBadRequest = [onError] (const TString& message) { 
+            onError(Ydb::StatusIds::BAD_REQUEST, message); 
+        }; 
+ 
         bool commit = false;
-
-        if (queryRequest.HasTxControl()) {
+ 
+        if (queryRequest.HasTxControl()) { 
             const auto& txControl = queryRequest.GetTxControl();
-            commit = txControl.commit_tx();
-
-            switch (txControl.tx_selector_case()) {
+            commit = txControl.commit_tx(); 
+ 
+            switch (txControl.tx_selector_case()) { 
                 case Ydb::Table::TransactionControl::kTxId: {
                     Y_VERIFY_DEBUG(!QueryState->TxId.empty());
-                    break;
+                    break; 
                 }
-
-                case Ydb::Table::TransactionControl::kBeginTx: {
-                    beginTxResult = BeginTransaction(txControl.begin_tx());
-
+ 
+                case Ydb::Table::TransactionControl::kBeginTx: { 
+                    beginTxResult = BeginTransaction(txControl.begin_tx()); 
+ 
                     Counters->ReportBeginTransaction(Settings.DbCounters,
                         beginTxResult.EvictedTx,
                         beginTxResult.CurrentActiveTx,
                         beginTxResult.CurrentAbortedTx);
 
-                    if (!beginTxResult.Success()) {
-                        QueryState->AsyncQueryResult = MakeKikimrResultHolder(
-                            NCommon::ResultFromErrors<TQueryResult>(beginTxResult.Issues()));
-                        ContinueQueryProcess(ctx);
-                        Become(&TKqpWorkerActor::PerformQueryState);
-                        return;
-                    }
-
+                    if (!beginTxResult.Success()) { 
+                        QueryState->AsyncQueryResult = MakeKikimrResultHolder( 
+                            NCommon::ResultFromErrors<TQueryResult>(beginTxResult.Issues())); 
+                        ContinueQueryProcess(ctx); 
+                        Become(&TKqpWorkerActor::PerformQueryState); 
+                        return; 
+                    } 
+ 
                     Counters->ReportTxCreated(Settings.DbCounters);
-
-                    QueryState->TxId = beginTxResult.TxId;
+ 
+                    QueryState->TxId = beginTxResult.TxId; 
                     if (commit) {
                         QueryState->InteractiveTx = false;
                     }
 
-                    break;
-                }
-
-                default:
-                    onBadRequest("Unexpected transaction selector value");
-                    return;
-            }
-        }
-
-        auto action = queryRequest.GetAction();
-        auto queryType = queryRequest.GetType();
-        if (QueryState->QueryCompileResult) {
-            if (action == NKikimrKqp::QUERY_ACTION_EXECUTE) {
-                Y_VERIFY(queryType == NKikimrKqp::QUERY_TYPE_SQL_DML);
-                queryType = NKikimrKqp::QUERY_TYPE_PREPARED_DML;
-                action = NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED;
-            }
-        }
-
-        switch (action) {
-            case NKikimrKqp::QUERY_ACTION_EXECUTE: {
+                    break; 
+                } 
+ 
+                default: 
+                    onBadRequest("Unexpected transaction selector value"); 
+                    return; 
+            } 
+        } 
+ 
+        auto action = queryRequest.GetAction(); 
+        auto queryType = queryRequest.GetType(); 
+        if (QueryState->QueryCompileResult) { 
+            if (action == NKikimrKqp::QUERY_ACTION_EXECUTE) { 
+                Y_VERIFY(queryType == NKikimrKqp::QUERY_TYPE_SQL_DML); 
+                queryType = NKikimrKqp::QUERY_TYPE_PREPARED_DML; 
+                action = NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED; 
+            } 
+        } 
+ 
+        switch (action) { 
+            case NKikimrKqp::QUERY_ACTION_EXECUTE: { 
                 if (!ExecuteQuery(queryRequest, queryType, commit, QueryState->RequestActorId)) {
-                    onBadRequest(QueryState->Error);
-                    return;
-                }
-                break;
-            }
-
-            case NKikimrKqp::QUERY_ACTION_EXPLAIN: {
-                // Force reply flags
-                QueryState->ReplyFlags |= NKikimrKqp::QUERY_REPLY_FLAG_PLAN | NKikimrKqp::QUERY_REPLY_FLAG_AST;
+                    onBadRequest(QueryState->Error); 
+                    return; 
+                } 
+                break; 
+            } 
+ 
+            case NKikimrKqp::QUERY_ACTION_EXPLAIN: { 
+                // Force reply flags 
+                QueryState->ReplyFlags |= NKikimrKqp::QUERY_REPLY_FLAG_PLAN | NKikimrKqp::QUERY_REPLY_FLAG_AST; 
                 if (!ExplainQuery(ctx, queryRequest.GetQuery(), queryType)) {
-                    onBadRequest(QueryState->Error);
-                    return;
-                }
-                break;
-            }
-
+                    onBadRequest(QueryState->Error); 
+                    return; 
+                } 
+                break; 
+            } 
+ 
             case NKikimrKqp::QUERY_ACTION_PARSE: {
                 onBadRequest("Parse mode is not supported yet");
                 return;
             }
 
-            case NKikimrKqp::QUERY_ACTION_VALIDATE: {
+            case NKikimrKqp::QUERY_ACTION_VALIDATE: { 
                 if (!ValidateQuery(ctx, queryRequest.GetQuery(), queryType)) {
-                    onBadRequest(QueryState->Error);
-                    return;
-                }
-                break;
-            }
-
-            case NKikimrKqp::QUERY_ACTION_PREPARE: {
-                if (!PrepareQuery(ctx, queryRequest.GetQuery(), queryType, commit)) {
-                    onBadRequest(QueryState->Error);
-                    return;
-                }
-                break;
-            }
-
-            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED: {
-                // NOTE: For compatibility with old clients, remove once not used.
+                    onBadRequest(QueryState->Error); 
+                    return; 
+                } 
+                break; 
+            } 
+ 
+            case NKikimrKqp::QUERY_ACTION_PREPARE: { 
+                if (!PrepareQuery(ctx, queryRequest.GetQuery(), queryType, commit)) { 
+                    onBadRequest(QueryState->Error); 
+                    return; 
+                } 
+                break; 
+            } 
+ 
+            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED: { 
+                // NOTE: For compatibility with old clients, remove once not used. 
                 const TString& query = queryRequest.HasPreparedQuery()
-                     ? queryRequest.GetPreparedQuery()
-                     : queryRequest.GetQuery();
-
+                     ? queryRequest.GetPreparedQuery() 
+                     : queryRequest.GetQuery(); 
+ 
                 TPreparedQueryConstPtr preparedQuery;
-
-                if (QueryState->QueryCompileResult) {
-                    Y_VERIFY(queryType == NKikimrKqp::QUERY_TYPE_PREPARED_DML);
+ 
+                if (QueryState->QueryCompileResult) { 
+                    Y_VERIFY(queryType == NKikimrKqp::QUERY_TYPE_PREPARED_DML); 
 
                     bool newEngineCompatibleTx = !QueryState->OldEngineFallback
                         && QueryState->ForceNewEngineState.ForceNewEnginePercent > 0;
@@ -1137,178 +1137,178 @@ private:
                     } else {
                         preparedQuery = QueryState->QueryCompileResult->PreparedQuery;
                     }
-                } else if (Settings.LongSession) {
-                    onError(Ydb::StatusIds::NOT_FOUND, TStringBuilder() << "Prepared query not found: " << query);
+                } else if (Settings.LongSession) { 
+                    onError(Ydb::StatusIds::NOT_FOUND, TStringBuilder() << "Prepared query not found: " << query); 
                     return;
-                } else {
+                } else { 
                     NKikimrKqp::TPreparedQuery tmp;
                     if (!tmp.ParseFromString(query)) {
-                        onBadRequest("Failed to parse prepared query.");
-                        return;
-                    }
+                        onBadRequest("Failed to parse prepared query."); 
+                        return; 
+                    } 
                     preparedQuery = std::make_shared<const NKikimrKqp::TPreparedQuery>(std::move(tmp));
-                }
-
+                } 
+ 
                 YQL_ENSURE(preparedQuery);
-
+ 
                 QueryState->Request.SetQuery(preparedQuery->GetText());
-
+ 
                 if (!ExecutePreparedQuery(preparedQuery, queryType, std::move(*QueryState->Request.MutableParameters()),
-                    commit, GetStatsMode(queryRequest, EKikimrStatsMode::Basic)))
-                {
-                    onBadRequest(QueryState->Error);
-                    return;
-                }
-                break;
-            }
-
-            case NKikimrKqp::QUERY_ACTION_BEGIN_TX: {
-                TQueryResult result;
-                result.SetSuccess();
+                    commit, GetStatsMode(queryRequest, EKikimrStatsMode::Basic))) 
+                { 
+                    onBadRequest(QueryState->Error); 
+                    return; 
+                } 
+                break; 
+            } 
+ 
+            case NKikimrKqp::QUERY_ACTION_BEGIN_TX: { 
+                TQueryResult result; 
+                result.SetSuccess(); 
                 QueryState->AsyncQueryResult = MakeKikimrResultHolder(std::move(result));
-                ContinueQueryProcess(ctx);
-                Become(&TKqpWorkerActor::PerformQueryState);
-                return;
-            }
-
-            case NKikimrKqp::QUERY_ACTION_COMMIT_TX: {
+                ContinueQueryProcess(ctx); 
+                Become(&TKqpWorkerActor::PerformQueryState); 
+                return; 
+            } 
+ 
+            case NKikimrKqp::QUERY_ACTION_COMMIT_TX: { 
                 if (!CommitTx(commit, GetStatsMode(queryRequest, EKikimrStatsMode::Basic))) {
-                    onBadRequest(QueryState->Error);
-                    return;
-                }
-                break;
-            }
-
-            case NKikimrKqp::QUERY_ACTION_ROLLBACK_TX: {
-                if (!RollbackTx(commit)) {
-                    onBadRequest(QueryState->Error);
-                    return;
-                }
-                break;
-            }
-
-            default: {
-                onBadRequest("Unknown query action");
-                return;
-            }
-        }
-
-        Become(&TKqpWorkerActor::PerformQueryState);
-        ContinueQueryProcess(ctx);
-    }
-
-    void Cleanup(const TActorContext &ctx, bool isFinal) {
-        Become(&TKqpWorkerActor::PerformCleanupState);
-
-        CleanupState.Reset(MakeHolder<TKqpCleanupState>());
-        CleanupState->Final = isFinal;
-        CleanupState->Start = TInstant::Now();
-
-        if (isFinal) {
-            StopIdleTimer(ctx);
+                    onBadRequest(QueryState->Error); 
+                    return; 
+                } 
+                break; 
+            } 
+ 
+            case NKikimrKqp::QUERY_ACTION_ROLLBACK_TX: { 
+                if (!RollbackTx(commit)) { 
+                    onBadRequest(QueryState->Error); 
+                    return; 
+                } 
+                break; 
+            } 
+ 
+            default: { 
+                onBadRequest("Unknown query action"); 
+                return; 
+            } 
+        } 
+ 
+        Become(&TKqpWorkerActor::PerformQueryState); 
+        ContinueQueryProcess(ctx); 
+    } 
+ 
+    void Cleanup(const TActorContext &ctx, bool isFinal) { 
+        Become(&TKqpWorkerActor::PerformCleanupState); 
+ 
+        CleanupState.Reset(MakeHolder<TKqpCleanupState>()); 
+        CleanupState->Final = isFinal; 
+        CleanupState->Start = TInstant::Now(); 
+ 
+        if (isFinal) { 
+            StopIdleTimer(ctx); 
             Counters->ReportQueriesPerWorker(Settings.DbCounters, QueryId);
-
-            MakeNewQueryState();
-        }
-
-        if (Settings.LongSession) {
-            if (isFinal) {
-                auto abortedCount = KqpHost->AbortAll();
+ 
+            MakeNewQueryState(); 
+        } 
+ 
+        if (Settings.LongSession) { 
+            if (isFinal) { 
+                auto abortedCount = KqpHost->AbortAll(); 
                 Counters->ReportTxAborted(Settings.DbCounters, abortedCount);
-            }
+            } 
             CleanupState->AsyncResult = KqpHost->RollbackAborted();
-        } else {
+        } else { 
             if (isFinal && QueryState->TxId) {
                 CleanupState->AsyncResult = KqpHost->RollbackTransaction(QueryState->TxId, CreateRollbackSettings());
-            }
-        }
-
-        if (!CleanupState->AsyncResult) {
-            EndCleanup(ctx);
-        } else {
-            ContinueCleanup(ctx);
-        }
-    }
-
-    void EndCleanup(const TActorContext &ctx) {
-        Y_VERIFY(CleanupState);
-
-        if (CleanupState->AsyncResult) {
+            } 
+        } 
+ 
+        if (!CleanupState->AsyncResult) { 
+            EndCleanup(ctx); 
+        } else { 
+            ContinueCleanup(ctx); 
+        } 
+    } 
+ 
+    void EndCleanup(const TActorContext &ctx) { 
+        Y_VERIFY(CleanupState); 
+ 
+        if (CleanupState->AsyncResult) { 
             auto cleanupTime = TInstant::Now() - CleanupState->Start;
             Counters->ReportWorkerCleanupLatency(Settings.DbCounters, cleanupTime);
-        }
-
-        bool isFinal = CleanupState->Final;
-        CleanupState.Reset();
-
-        if (isFinal) {
+        } 
+ 
+        bool isFinal = CleanupState->Final; 
+        CleanupState.Reset(); 
+ 
+        if (isFinal) { 
             auto lifeSpan = TInstant::Now() - CreationTime;
             Counters->ReportWorkerFinished(Settings.DbCounters, lifeSpan);
-
-            auto closeEv = MakeHolder<TEvKqp::TEvCloseSessionResponse>();
-            closeEv->Record.SetStatus(Ydb::StatusIds::SUCCESS);
-            closeEv->Record.MutableResponse()->SetSessionId(SessionId);
-            closeEv->Record.MutableResponse()->SetClosed(true);
-            ctx.Send(Owner, closeEv.Release());
-
-            Die(ctx);
-        } else {
-            if (ReplyQueryResult(ctx)) {
-                StartIdleTimer(ctx);
-                Become(&TKqpWorkerActor::ReadyState);
-            } else {
-                FinalCleanup(ctx);
-            }
-        }
-    }
-
-    void QueryCleanup(const TActorContext &ctx) {
-        Cleanup(ctx, false);
-    }
-
-    void FinalCleanup(const TActorContext &ctx) {
-        Cleanup(ctx, true);
-    }
-
+ 
+            auto closeEv = MakeHolder<TEvKqp::TEvCloseSessionResponse>(); 
+            closeEv->Record.SetStatus(Ydb::StatusIds::SUCCESS); 
+            closeEv->Record.MutableResponse()->SetSessionId(SessionId); 
+            closeEv->Record.MutableResponse()->SetClosed(true); 
+            ctx.Send(Owner, closeEv.Release()); 
+ 
+            Die(ctx); 
+        } else { 
+            if (ReplyQueryResult(ctx)) { 
+                StartIdleTimer(ctx); 
+                Become(&TKqpWorkerActor::ReadyState); 
+            } else { 
+                FinalCleanup(ctx); 
+            } 
+        } 
+    } 
+ 
+    void QueryCleanup(const TActorContext &ctx) { 
+        Cleanup(ctx, false); 
+    } 
+ 
+    void FinalCleanup(const TActorContext &ctx) { 
+        Cleanup(ctx, true); 
+    } 
+ 
     bool ExecuteQuery(NKikimrKqp::TQueryRequest& queryRequest, NKikimrKqp::EQueryType type, bool commit,
         const TActorId& requestActorId)
-    {
+    { 
         const auto& query = queryRequest.GetQuery();
         auto* parameters = queryRequest.MutableParameters();
         auto statsMode = GetStatsMode(queryRequest, EKikimrStatsMode::Basic);
 
-        switch (type) {
-            case NKikimrKqp::QUERY_TYPE_SQL_DML:
-            case NKikimrKqp::QUERY_TYPE_AST_DML: {
-                bool isSql = (type == NKikimrKqp::QUERY_TYPE_SQL_DML);
-
-                NYql::IKikimrQueryExecutor::TExecuteSettings execSettings;
-                execSettings.CommitTx = commit;
-                execSettings.StatsMode = statsMode;
-                execSettings.Deadlines = QueryState->QueryDeadlines;
-                execSettings.Limits = GetQueryLimits(Settings);
+        switch (type) { 
+            case NKikimrKqp::QUERY_TYPE_SQL_DML: 
+            case NKikimrKqp::QUERY_TYPE_AST_DML: { 
+                bool isSql = (type == NKikimrKqp::QUERY_TYPE_SQL_DML); 
+ 
+                NYql::IKikimrQueryExecutor::TExecuteSettings execSettings; 
+                execSettings.CommitTx = commit; 
+                execSettings.StatsMode = statsMode; 
+                execSettings.Deadlines = QueryState->QueryDeadlines; 
+                execSettings.Limits = GetQueryLimits(Settings); 
                 execSettings.StrictDml = false;
                 execSettings.UseNewEngine = UseNewEngine();
-                execSettings.DocumentApiRestricted = IsDocumentApiRestricted(QueryState->RequestType);
-
-                QueryState->AsyncQueryResult = KqpHost->ExecuteDataQuery(QueryState->TxId, query, isSql,
+                execSettings.DocumentApiRestricted = IsDocumentApiRestricted(QueryState->RequestType); 
+ 
+                QueryState->AsyncQueryResult = KqpHost->ExecuteDataQuery(QueryState->TxId, query, isSql, 
                     std::move(*parameters), execSettings);
-                break;
-            }
+                break; 
+            } 
 
             case NKikimrKqp::QUERY_TYPE_SQL_DDL: {
-                QueryState->AsyncQueryResult = KqpHost->ExecuteSchemeQuery(query, true);
-                break;
+                QueryState->AsyncQueryResult = KqpHost->ExecuteSchemeQuery(query, true); 
+                break; 
             }
-
+ 
             case NKikimrKqp::QUERY_TYPE_SQL_SCRIPT: {
-                IKqpHost::TExecScriptSettings execSettings;
-                execSettings.Deadlines = QueryState->QueryDeadlines;
-                execSettings.StatsMode = statsMode;
-                QueryState->AsyncQueryResult = KqpHost->ExecuteYqlScript(query, std::move(*parameters), execSettings);
-                break;
+                IKqpHost::TExecScriptSettings execSettings; 
+                execSettings.Deadlines = QueryState->QueryDeadlines; 
+                execSettings.StatsMode = statsMode; 
+                QueryState->AsyncQueryResult = KqpHost->ExecuteYqlScript(query, std::move(*parameters), execSettings); 
+                break; 
             }
-
+ 
             case NKikimrKqp::QUERY_TYPE_SQL_SCRIPT_STREAMING: {
                 IKqpHost::TExecScriptSettings execSettings;
                 execSettings.Deadlines = QueryState->QueryDeadlines;
@@ -1318,40 +1318,40 @@ private:
                 break;
             }
 
-            case NKikimrKqp::QUERY_TYPE_SQL_SCAN:
-            case NKikimrKqp::QUERY_TYPE_AST_SCAN: {
-                bool isSql = (type == NKikimrKqp::QUERY_TYPE_SQL_SCAN);
-
+            case NKikimrKqp::QUERY_TYPE_SQL_SCAN: 
+            case NKikimrKqp::QUERY_TYPE_AST_SCAN: { 
+                bool isSql = (type == NKikimrKqp::QUERY_TYPE_SQL_SCAN); 
+ 
                 NYql::IKikimrQueryExecutor::TExecuteSettings execSettings;
-                execSettings.StatsMode = statsMode;
+                execSettings.StatsMode = statsMode; 
                 execSettings.Deadlines = QueryState->QueryDeadlines;
-                execSettings.Limits = GetQueryLimits(Settings);
+                execSettings.Limits = GetQueryLimits(Settings); 
                 execSettings.RlPath = QueryState->RlPath;
 
-                QueryState->AsyncQueryResult = KqpHost->ExecuteScanQuery(query, isSql, std::move(*parameters),
+                QueryState->AsyncQueryResult = KqpHost->ExecuteScanQuery(query, isSql, std::move(*parameters), 
                     requestActorId, execSettings);
-                break;
+                break; 
             }
-
+ 
             default: {
-                QueryState->Error = "Unexpected query type.";
-                return false;
+                QueryState->Error = "Unexpected query type."; 
+                return false; 
             }
-        }
-
-        return true;
-    }
-
+        } 
+ 
+        return true; 
+    } 
+ 
     bool ExplainQuery(const TActorContext&, const TString& query, NKikimrKqp::EQueryType type) {
-        switch (type) {
-            case NKikimrKqp::QUERY_TYPE_SQL_DML:
-            case NKikimrKqp::QUERY_TYPE_AST_DML: {
-                bool isSql = (type == NKikimrKqp::QUERY_TYPE_SQL_DML);
-
-                QueryState->AsyncQueryResult = KqpHost->ExplainDataQuery(query, isSql);
-                break;
-            }
-
+        switch (type) { 
+            case NKikimrKqp::QUERY_TYPE_SQL_DML: 
+            case NKikimrKqp::QUERY_TYPE_AST_DML: { 
+                bool isSql = (type == NKikimrKqp::QUERY_TYPE_SQL_DML); 
+ 
+                QueryState->AsyncQueryResult = KqpHost->ExplainDataQuery(query, isSql); 
+                break; 
+            } 
+ 
             case NKikimrKqp::QUERY_TYPE_SQL_SCAN:
             case NKikimrKqp::QUERY_TYPE_AST_SCAN: {
                 bool isSql = (type == NKikimrKqp::QUERY_TYPE_SQL_SCAN);
@@ -1365,14 +1365,14 @@ private:
                 break;
             }
 
-            default:
-                QueryState->Error = "Unexpected query type.";
-                return false;
-        }
-
-        return true;
-    }
-
+            default: 
+                QueryState->Error = "Unexpected query type."; 
+                return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
     bool ValidateQuery(const TActorContext&, const TString& query, NKikimrKqp::EQueryType type) {
         switch (type) {
             case NKikimrKqp::QUERY_TYPE_SQL_SCRIPT:
@@ -1384,34 +1384,34 @@ private:
             default:
                 QueryState->Error = "Unexpected query type.";
                 return false;
-        }
-
-        return true;
-    }
-
+        } 
+ 
+        return true; 
+    } 
+ 
     bool PrepareQuery(const TActorContext&, const TString& query, NKikimrKqp::EQueryType type, bool sqlAutoCommit) {
-        if (sqlAutoCommit) {
-            QueryState->Error = "Expected SqlAutoCommit=false for query prepare.";
-            return false;
-        }
-
-        switch (type) {
-            case NKikimrKqp::QUERY_TYPE_SQL_DML: {
-                IKqpHost::TPrepareSettings prepareSettings;
+        if (sqlAutoCommit) { 
+            QueryState->Error = "Expected SqlAutoCommit=false for query prepare."; 
+            return false; 
+        } 
+ 
+        switch (type) { 
+            case NKikimrKqp::QUERY_TYPE_SQL_DML: { 
+                IKqpHost::TPrepareSettings prepareSettings; 
                 // prepareSettings.UseNewEngine = use default settings
-                prepareSettings.DocumentApiRestricted = IsDocumentApiRestricted(QueryState->RequestType);
-                QueryState->AsyncQueryResult = KqpHost->PrepareDataQuery(query, prepareSettings);
-                break;
-            }
-
-            default:
-                QueryState->Error = "Unexpected query type.";
-                return false;
-        }
-
-        return true;
-    }
-
+                prepareSettings.DocumentApiRestricted = IsDocumentApiRestricted(QueryState->RequestType); 
+                QueryState->AsyncQueryResult = KqpHost->PrepareDataQuery(query, prepareSettings); 
+                break; 
+            } 
+ 
+            default: 
+                QueryState->Error = "Unexpected query type."; 
+                return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
     bool ExecutePreparedQuery(TPreparedQueryConstPtr& query, NKikimrKqp::EQueryType type,
         NKikimrMiniKQL::TParams&& parameters, bool commit, EKikimrStatsMode statsMode)
     {
@@ -1421,158 +1421,158 @@ private:
             execSettings.StatsMode = statsMode;
             execSettings.Deadlines = QueryState->QueryDeadlines;
             execSettings.Limits = GetQueryLimits(Settings);
-
+ 
             QueryState->AsyncQueryResult = KqpHost->ExecuteDataQuery(QueryState->TxId, query, std::move(parameters),
                 execSettings);
             return true;
-        } else {
+        } else { 
             QueryState->Error = "Unexpected query type.";
             return false;
-        }
-    }
-
-    bool CommitTx(bool commit, EKikimrStatsMode statsMode) {
-        if (!commit) {
-            QueryState->Error = "Commit should be true for commit transaction request.";
-            return false;
-        }
-        if (QueryState->TxId.empty()) {
-            QueryState->Error = "Empty tx_id for commit transaction request.";
-            return false;
-        }
-
+        } 
+    } 
+ 
+    bool CommitTx(bool commit, EKikimrStatsMode statsMode) { 
+        if (!commit) { 
+            QueryState->Error = "Commit should be true for commit transaction request."; 
+            return false; 
+        } 
+        if (QueryState->TxId.empty()) { 
+            QueryState->Error = "Empty tx_id for commit transaction request."; 
+            return false; 
+        } 
+ 
         IKikimrQueryExecutor::TExecuteSettings execSettings;
         execSettings.CommitTx = true;
-        execSettings.StatsMode = statsMode;
-        execSettings.Deadlines = QueryState->QueryDeadlines;
-        execSettings.Limits = GetQueryLimits(Settings);
+        execSettings.StatsMode = statsMode; 
+        execSettings.Deadlines = QueryState->QueryDeadlines; 
+        execSettings.Limits = GetQueryLimits(Settings); 
         execSettings.UseNewEngine = UseNewEngine();
-
-        QueryState->AsyncQueryResult = KqpHost->CommitTransaction(QueryState->TxId, execSettings);
-        return true;
-    }
-
-    bool RollbackTx(bool commit) {
-        if (commit) {
-            QueryState->Error = "Commit should be false for rollback transaction request.";
-            return false;
-        }
-        if (QueryState->TxId.empty()) {
-            QueryState->Error = "Empty tx_id for rollback transaction request.";
-            return false;
-        }
-
+ 
+        QueryState->AsyncQueryResult = KqpHost->CommitTransaction(QueryState->TxId, execSettings); 
+        return true; 
+    } 
+ 
+    bool RollbackTx(bool commit) { 
+        if (commit) { 
+            QueryState->Error = "Commit should be false for rollback transaction request."; 
+            return false; 
+        } 
+        if (QueryState->TxId.empty()) { 
+            QueryState->Error = "Empty tx_id for rollback transaction request."; 
+            return false; 
+        } 
+ 
         QueryState->AsyncQueryResult = KqpHost->RollbackTransaction(QueryState->TxId, CreateRollbackSettings());
-        return true;
-    }
-
-    void ContinueQueryProcess(const TActorContext &ctx) {
-        Y_VERIFY(QueryState);
-
-        TActorSystem* actorSystem = ctx.ExecutorThread.ActorSystem;
+        return true; 
+    } 
+ 
+    void ContinueQueryProcess(const TActorContext &ctx) { 
+        Y_VERIFY(QueryState); 
+ 
+        TActorSystem* actorSystem = ctx.ExecutorThread.ActorSystem; 
         TActorId selfId = ctx.SelfID;
-        ui32 queryId = QueryId;
-
-        auto callback = [actorSystem, selfId, queryId](const TFuture<bool>& future) {
-            bool finished = future.GetValue();
-            auto processEv = MakeHolder<TEvKqp::TEvContinueProcess>(queryId, finished);
-            actorSystem->Send(selfId, processEv.Release());
-        };
-
-        QueryState->AsyncQueryResult->Continue().Apply(callback);
-    }
-
-    void ContinueCleanup(const TActorContext &ctx) {
-        Y_VERIFY(CleanupState);
-
-        TActorSystem* actorSystem = ctx.ExecutorThread.ActorSystem;
+        ui32 queryId = QueryId; 
+ 
+        auto callback = [actorSystem, selfId, queryId](const TFuture<bool>& future) { 
+            bool finished = future.GetValue(); 
+            auto processEv = MakeHolder<TEvKqp::TEvContinueProcess>(queryId, finished); 
+            actorSystem->Send(selfId, processEv.Release()); 
+        }; 
+ 
+        QueryState->AsyncQueryResult->Continue().Apply(callback); 
+    } 
+ 
+    void ContinueCleanup(const TActorContext &ctx) { 
+        Y_VERIFY(CleanupState); 
+ 
+        TActorSystem* actorSystem = ctx.ExecutorThread.ActorSystem; 
         TActorId selfId = ctx.SelfID;
-        ui32 queryId = QueryId;
-
-        auto callback = [actorSystem, selfId, queryId](const TFuture<bool>& future) {
-            bool finished = future.GetValue();
-            auto processEv = MakeHolder<TEvKqp::TEvContinueProcess>(queryId, finished);
-            actorSystem->Send(selfId, processEv.Release());
-        };
-
-        CleanupState->AsyncResult->Continue().Apply(callback);
-    }
-
-    bool Reply(THolder<TEvKqp::TEvQueryResponse>&& responseEv, const TActorContext &ctx) {
-        Y_VERIFY(QueryState);
-
-        auto requestInfo = TKqpRequestInfo(QueryState->TraceId, SessionId);
-
-        auto& record = responseEv->Record.GetRef();
-        auto& response = *record.MutableResponse();
-        const auto& status = record.GetYdbStatus();
-
-        bool keepSession = QueryState->KeepSession;
-        if (keepSession) {
-            response.SetSessionId(SessionId);
-        }
-
-        ctx.Send(QueryState->Sender, responseEv.Release(), 0, QueryState->ProxyRequestId);
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo
-            << "Sent query response back to proxy, proxyRequestId: " << QueryState->ProxyRequestId
-            << ", proxyId: " << QueryState->Sender.ToString());
-
-        QueryState.Reset();
-
-        if (Settings.LongSession) {
-            if (status == Ydb::StatusIds::INTERNAL_ERROR) {
-                LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo
-                    << "Worker destroyed due to internal error");
+        ui32 queryId = QueryId; 
+ 
+        auto callback = [actorSystem, selfId, queryId](const TFuture<bool>& future) { 
+            bool finished = future.GetValue(); 
+            auto processEv = MakeHolder<TEvKqp::TEvContinueProcess>(queryId, finished); 
+            actorSystem->Send(selfId, processEv.Release()); 
+        }; 
+ 
+        CleanupState->AsyncResult->Continue().Apply(callback); 
+    } 
+ 
+    bool Reply(THolder<TEvKqp::TEvQueryResponse>&& responseEv, const TActorContext &ctx) { 
+        Y_VERIFY(QueryState); 
+ 
+        auto requestInfo = TKqpRequestInfo(QueryState->TraceId, SessionId); 
+ 
+        auto& record = responseEv->Record.GetRef(); 
+        auto& response = *record.MutableResponse(); 
+        const auto& status = record.GetYdbStatus(); 
+ 
+        bool keepSession = QueryState->KeepSession; 
+        if (keepSession) { 
+            response.SetSessionId(SessionId); 
+        } 
+ 
+        ctx.Send(QueryState->Sender, responseEv.Release(), 0, QueryState->ProxyRequestId); 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo 
+            << "Sent query response back to proxy, proxyRequestId: " << QueryState->ProxyRequestId 
+            << ", proxyId: " << QueryState->Sender.ToString()); 
+ 
+        QueryState.Reset(); 
+ 
+        if (Settings.LongSession) { 
+            if (status == Ydb::StatusIds::INTERNAL_ERROR) { 
+                LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo 
+                    << "Worker destroyed due to internal error"); 
                 Counters->ReportWorkerClosedError(Settings.DbCounters);
-                return false;
-            }
-            if (status == Ydb::StatusIds::BAD_SESSION) {
-                LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo
-                    << "Worker destroyed due to session error");
+                return false; 
+            } 
+            if (status == Ydb::StatusIds::BAD_SESSION) { 
+                LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo 
+                    << "Worker destroyed due to session error"); 
                 Counters->ReportWorkerClosedError(Settings.DbCounters);
-                return false;
-            }
-        } else {
-            if (status != Ydb::StatusIds::SUCCESS) {
-                LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo
-                    << "Worker destroyed due to query error");
+                return false; 
+            } 
+        } else { 
+            if (status != Ydb::StatusIds::SUCCESS) { 
+                LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo 
+                    << "Worker destroyed due to query error"); 
                 Counters->ReportWorkerClosedError(Settings.DbCounters);
-                return false;
-            }
-        }
-
-        if (!keepSession) {
-            LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo
-                << "Worker destroyed due to negative keep session flag");
+                return false; 
+            } 
+        } 
+ 
+        if (!keepSession) { 
+            LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, requestInfo 
+                << "Worker destroyed due to negative keep session flag"); 
             Counters->ReportWorkerClosedRequest(Settings.DbCounters);
-            return false;
-        }
-
-        return true;
-    }
-
-    bool ReplyPrepareResult(const TKqpCompileResult::TConstPtr& compileResult, const TActorContext &ctx) {
-        auto responseEv = MakeHolder<TEvKqp::TEvQueryResponse>();
-        FillCompileStatus(compileResult, responseEv->Record);
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+    bool ReplyPrepareResult(const TKqpCompileResult::TConstPtr& compileResult, const TActorContext &ctx) { 
+        auto responseEv = MakeHolder<TEvKqp::TEvQueryResponse>(); 
+        FillCompileStatus(compileResult, responseEv->Record); 
 
         auto ru = CpuTimeToUnit(TDuration::MicroSeconds(QueryState->CompileStats.GetCpuTimeUs()));
         responseEv->Record.GetRef().SetConsumedRu(ru);
 
-        return Reply(std::move(responseEv), ctx);
-    }
-
-    bool ReplyQueryCompileError(const TKqpCompileResult::TConstPtr& compileResult, const TActorContext &ctx) {
-        auto responseEv = MakeHolder<TEvKqp::TEvQueryResponse>();
-        FillCompileStatus(compileResult, responseEv->Record);
-
-        KqpHost->AbortTransaction(QueryState->TxId);
-        FillTxInfo(responseEv->Record);
-
+        return Reply(std::move(responseEv), ctx); 
+    } 
+ 
+    bool ReplyQueryCompileError(const TKqpCompileResult::TConstPtr& compileResult, const TActorContext &ctx) { 
+        auto responseEv = MakeHolder<TEvKqp::TEvQueryResponse>(); 
+        FillCompileStatus(compileResult, responseEv->Record); 
+ 
+        KqpHost->AbortTransaction(QueryState->TxId); 
+        FillTxInfo(responseEv->Record); 
+ 
         responseEv->Record.GetRef().SetConsumedRu(1);
 
-        return Reply(std::move(responseEv), ctx);
-    }
-
+        return Reply(std::move(responseEv), ctx); 
+    } 
+ 
     ETableReadType ExtractMostHeavyReadType(const TString& queryPlan) {
         ETableReadType maxReadType = ETableReadType::Other;
 
@@ -1605,21 +1605,21 @@ private:
         return maxReadType;
     }
 
-    bool ReplyQueryResult(const TActorContext& ctx) {
-        Y_VERIFY(QueryState);
-        auto& queryRequest = QueryState->Request;
-        auto& queryResult = QueryState->QueryResult;
-
-        auto responseEv = MakeHolder<TEvKqp::TEvQueryResponse>();
-        FillResponse(responseEv->Record);
-
-        auto& record = responseEv->Record.GetRef();
-        auto status = record.GetYdbStatus();
-
+    bool ReplyQueryResult(const TActorContext& ctx) { 
+        Y_VERIFY(QueryState); 
+        auto& queryRequest = QueryState->Request; 
+        auto& queryResult = QueryState->QueryResult; 
+ 
+        auto responseEv = MakeHolder<TEvKqp::TEvQueryResponse>(); 
+        FillResponse(responseEv->Record); 
+ 
+        auto& record = responseEv->Record.GetRef(); 
+        auto status = record.GetYdbStatus(); 
+ 
         auto now = TInstant::Now();
         auto queryDuration = now - QueryState->StartTime;
-
-        if (status == Ydb::StatusIds::SUCCESS) {
+ 
+        if (status == Ydb::StatusIds::SUCCESS) { 
             Counters->ReportQueryLatency(Settings.DbCounters, queryRequest.GetAction(), queryDuration);
 
             auto maxReadType = ExtractMostHeavyReadType(queryResult.QueryPlan);
@@ -1662,80 +1662,80 @@ private:
                     Counters->ReportNewEngineCompatibleQueryStats(queryRequest.GetAction(), queryDuration, computeCpuTimeUs);
                 }
             }
-        }
-
-        if (queryResult.SqlVersion) {
+        } 
+ 
+        if (queryResult.SqlVersion) { 
             Counters->ReportSqlVersion(Settings.DbCounters, *queryResult.SqlVersion);
-        }
-
-        if (Settings.LongSession && status != Ydb::StatusIds::SUCCESS) {
-            bool isQueryById = queryRequest.GetAction() == NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED;
-
-            TMaybe<TString> invalidatedId;
-            if (HasSchemeOrFatalIssues(queryResult.Issues())) {
-                auto compileResult = QueryState->QueryCompileResult;
-
-                if (compileResult) {
-                    invalidatedId = InvalidateQuery(*compileResult, ctx);
-                }
-            }
-
-            if (invalidatedId) {
-                LOG_NOTICE_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo(QueryState->TraceId, SessionId)
-                    << "Invalidating query due to scheme error: " << *invalidatedId);
-
-                TIssues issues;
-                issues.AddIssue(YqlIssue(TPosition(), TIssuesIds::KIKIMR_QUERY_INVALIDATED,
-                    TStringBuilder() << "Query invalidated due to scheme error."));
-
-                AddQueryIssues(*record.MutableResponse(), issues);
-
-                if (isQueryById) {
-                    // Avoid double retry for client on query invalidation. Return NOT_FOUND immediately on
-                    // query invalidation.
-                    status = Ydb::StatusIds::NOT_FOUND;
-                    record.SetYdbStatus(status);
-                }
-            }
-        }
-
-        FillTxInfo(responseEv->Record);
-
-        auto& stats = queryResult.QueryStats;
-        stats.SetDurationUs(queryDuration.MicroSeconds());
+        } 
+ 
+        if (Settings.LongSession && status != Ydb::StatusIds::SUCCESS) { 
+            bool isQueryById = queryRequest.GetAction() == NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED; 
+
+            TMaybe<TString> invalidatedId; 
+            if (HasSchemeOrFatalIssues(queryResult.Issues())) { 
+                auto compileResult = QueryState->QueryCompileResult; 
+ 
+                if (compileResult) { 
+                    invalidatedId = InvalidateQuery(*compileResult, ctx); 
+                } 
+            } 
+ 
+            if (invalidatedId) { 
+                LOG_NOTICE_S(ctx, NKikimrServices::KQP_WORKER, TKqpRequestInfo(QueryState->TraceId, SessionId) 
+                    << "Invalidating query due to scheme error: " << *invalidatedId); 
+ 
+                TIssues issues; 
+                issues.AddIssue(YqlIssue(TPosition(), TIssuesIds::KIKIMR_QUERY_INVALIDATED, 
+                    TStringBuilder() << "Query invalidated due to scheme error.")); 
+ 
+                AddQueryIssues(*record.MutableResponse(), issues); 
+ 
+                if (isQueryById) { 
+                    // Avoid double retry for client on query invalidation. Return NOT_FOUND immediately on 
+                    // query invalidation. 
+                    status = Ydb::StatusIds::NOT_FOUND; 
+                    record.SetYdbStatus(status); 
+                } 
+            } 
+        } 
+ 
+        FillTxInfo(responseEv->Record); 
+ 
+        auto& stats = queryResult.QueryStats; 
+        stats.SetDurationUs(queryDuration.MicroSeconds()); 
         stats.SetWorkerCpuTimeUs(QueryState->CpuTime.MicroSeconds());
-        if (QueryState->QueryCompileResult) {
-            stats.MutableCompilation()->Swap(&QueryState->CompileStats);
-        }
-
-        auto requestInfo = TKqpRequestInfo(QueryState->TraceId, SessionId);
-        if (IsExecuteAction(queryRequest.GetAction())) {
+        if (QueryState->QueryCompileResult) { 
+            stats.MutableCompilation()->Swap(&QueryState->CompileStats); 
+        } 
+ 
+        auto requestInfo = TKqpRequestInfo(QueryState->TraceId, SessionId); 
+        if (IsExecuteAction(queryRequest.GetAction())) { 
             auto ru = CalcRequestUnit(stats);
             record.SetConsumedRu(ru);
             CollectSystemViewQueryStats(ctx, &stats, queryDuration, queryRequest.GetDatabase(), ru);
-            SlowLogQuery(ctx, requestInfo, queryDuration, status, [&record](){
-                ui64 resultsSize = 0;
-                for (auto& result : record.GetResponse().GetResults()) {
-                    resultsSize += result.ByteSize();
-                }
-                return resultsSize;
-            });
-        }
-
+            SlowLogQuery(ctx, requestInfo, queryDuration, status, [&record](){ 
+                ui64 resultsSize = 0; 
+                for (auto& result : record.GetResponse().GetResults()) { 
+                    resultsSize += result.ByteSize(); 
+                } 
+                return resultsSize; 
+            }); 
+        } 
+ 
         bool reportStats = (GetStatsMode(queryRequest, EKikimrStatsMode::None) != EKikimrStatsMode::None);
-
-        if (reportStats) {
-            // TODO: For compatibility with old rpc handlers, deprecate.
-            FillQueryProfile(stats, *record.MutableResponse());
-
-            record.MutableResponse()->MutableQueryStats()->Swap(&stats);
+ 
+        if (reportStats) { 
+            // TODO: For compatibility with old rpc handlers, deprecate. 
+            FillQueryProfile(stats, *record.MutableResponse()); 
+ 
+            record.MutableResponse()->MutableQueryStats()->Swap(&stats); 
             record.MutableResponse()->SetQueryPlan(queryResult.QueryPlan);
-        }
-
+        } 
+ 
         AddTrailingInfo(responseEv->Record.GetRef());
-        return Reply(std::move(responseEv), ctx);
-    }
-
+        return Reply(std::move(responseEv), ctx); 
+    } 
+ 
     template<class TEvRecord>
     void AddTrailingInfo(TEvRecord& record) {
         if (ShutdownState) {
@@ -1745,57 +1745,57 @@ private:
     }
 
     bool ReplyPingStatus(const TActorId& sender, ui64 proxyRequestId, bool ready, const TActorContext& ctx) {
-        auto ev = MakeHolder<TEvKqp::TEvPingSessionResponse>();
-        auto& record = ev->Record;
-        record.SetStatus(Ydb::StatusIds::SUCCESS);
-        record.MutableResponse()->SetSessionStatus(ready
-            ? Ydb::Table::KeepAliveResult::SESSION_STATUS_READY
-            : Ydb::Table::KeepAliveResult::SESSION_STATUS_BUSY);
-
+        auto ev = MakeHolder<TEvKqp::TEvPingSessionResponse>(); 
+        auto& record = ev->Record; 
+        record.SetStatus(Ydb::StatusIds::SUCCESS); 
+        record.MutableResponse()->SetSessionStatus(ready 
+            ? Ydb::Table::KeepAliveResult::SESSION_STATUS_READY 
+            : Ydb::Table::KeepAliveResult::SESSION_STATUS_BUSY); 
+ 
         AddTrailingInfo(record);
-        return ctx.Send(sender, ev.Release(), 0, proxyRequestId);
-    }
-
+        return ctx.Send(sender, ev.Release(), 0, proxyRequestId); 
+    } 
+ 
     bool ReplyProcessError(const TActorId& sender, ui64 proxyRequestId, const TKqpRequestInfo& requestInfo,
-        Ydb::StatusIds::StatusCode ydbStatus, const TString& message, const TActorContext& ctx)
-    {
-        LOG_WARN_S(ctx, NKikimrServices::KQP_WORKER, requestInfo << message);
-
-        auto response = TEvKqp::TEvProcessResponse::Error(ydbStatus, message);
+        Ydb::StatusIds::StatusCode ydbStatus, const TString& message, const TActorContext& ctx) 
+    { 
+        LOG_WARN_S(ctx, NKikimrServices::KQP_WORKER, requestInfo << message); 
+ 
+        auto response = TEvKqp::TEvProcessResponse::Error(ydbStatus, message); 
 
         AddTrailingInfo(response->Record);
-        return ctx.Send(sender, response.Release(), 0, proxyRequestId);
-    }
-
+        return ctx.Send(sender, response.Release(), 0, proxyRequestId); 
+    } 
+ 
     bool CheckRequest(const TKqpRequestInfo& requestInfo, const TActorId& sender, ui64 proxyRequestId,
-        const TActorContext& ctx)
-    {
-        if (requestInfo.GetSessionId() != SessionId) {
-            TString error = TStringBuilder() << "Invalid session, expected: " << SessionId << ", request ignored";
-            ReplyProcessError(sender, proxyRequestId, requestInfo, Ydb::StatusIds::BAD_SESSION, error, ctx);
-            return false;
-        }
-
-        return true;
-    }
-
-    void ReplyBusy(TEvKqp::TEvQueryRequest::TPtr& ev, const TActorContext& ctx) {
-        ui64 proxyRequestId = ev->Cookie;
-        auto& event = ev->Get()->Record;
-        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId());
-
-        if (!CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) {
-            return;
-        }
-
-        auto busyStatus = Settings.Service.GetUseSessionBusyStatus()
-            ? Ydb::StatusIds::SESSION_BUSY
-            : Ydb::StatusIds::PRECONDITION_FAILED;
-
-        ReplyProcessError(ev->Sender, proxyRequestId, requestInfo, busyStatus,
-            "Pending previous query completion", ctx);
-    }
-
+        const TActorContext& ctx) 
+    { 
+        if (requestInfo.GetSessionId() != SessionId) { 
+            TString error = TStringBuilder() << "Invalid session, expected: " << SessionId << ", request ignored"; 
+            ReplyProcessError(sender, proxyRequestId, requestInfo, Ydb::StatusIds::BAD_SESSION, error, ctx); 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+    void ReplyBusy(TEvKqp::TEvQueryRequest::TPtr& ev, const TActorContext& ctx) { 
+        ui64 proxyRequestId = ev->Cookie; 
+        auto& event = ev->Get()->Record; 
+        auto requestInfo = TKqpRequestInfo(event.GetTraceId(), event.GetRequest().GetSessionId()); 
+ 
+        if (!CheckRequest(requestInfo, ev->Sender, proxyRequestId, ctx)) { 
+            return; 
+        } 
+ 
+        auto busyStatus = Settings.Service.GetUseSessionBusyStatus() 
+            ? Ydb::StatusIds::SESSION_BUSY 
+            : Ydb::StatusIds::PRECONDITION_FAILED; 
+ 
+        ReplyProcessError(ev->Sender, proxyRequestId, requestInfo, busyStatus, 
+            "Pending previous query completion", ctx); 
+    } 
+ 
     void CollectSystemViewQueryStats(const TActorContext& ctx,
         const NKqpProto::TKqpStatsQuery* stats, TDuration queryDuration,
         const TString& database, ui64 requestUnits)
@@ -1828,143 +1828,143 @@ private:
         return QueryState->Request.GetQuery();
     }
 
-    void SlowLogQuery(const TActorContext &ctx, const TKqpRequestInfo& requestInfo, const TDuration& duration,
-        Ydb::StatusIds::StatusCode status, const std::function<ui64()>& resultsSizeFunc)
-    {
-        auto logSettings = ctx.LoggerSettings();
-        if (!logSettings) {
-            return;
-        }
-
-        ui32 thresholdMs = 0;
-        NActors::NLog::EPriority priority;
-
-        if (logSettings->Satisfies(NActors::NLog::PRI_TRACE, NKikimrServices::KQP_SLOW_LOG)) {
-            priority = NActors::NLog::PRI_TRACE;
-            thresholdMs = Config->_KqpSlowLogTraceThresholdMs.Get().GetRef();
-        } else if (logSettings->Satisfies(NActors::NLog::PRI_NOTICE, NKikimrServices::KQP_SLOW_LOG)) {
-            priority = NActors::NLog::PRI_NOTICE;
-            thresholdMs = Config->_KqpSlowLogNoticeThresholdMs.Get().GetRef();
-        } else if (logSettings->Satisfies(NActors::NLog::PRI_WARN, NKikimrServices::KQP_SLOW_LOG)) {
-            priority = NActors::NLog::PRI_WARN;
-            thresholdMs = Config->_KqpSlowLogWarningThresholdMs.Get().GetRef();
-        } else {
-            return;
-        }
-
-        if (duration >= TDuration::MilliSeconds(thresholdMs)) {
-            auto username = NACLib::TUserToken(QueryState->UserToken).GetUserSID();
-            if (username.empty()) {
-                username = "UNAUTHENTICATED";
-            }
-
+    void SlowLogQuery(const TActorContext &ctx, const TKqpRequestInfo& requestInfo, const TDuration& duration, 
+        Ydb::StatusIds::StatusCode status, const std::function<ui64()>& resultsSizeFunc) 
+    { 
+        auto logSettings = ctx.LoggerSettings(); 
+        if (!logSettings) { 
+            return; 
+        } 
+ 
+        ui32 thresholdMs = 0; 
+        NActors::NLog::EPriority priority; 
+ 
+        if (logSettings->Satisfies(NActors::NLog::PRI_TRACE, NKikimrServices::KQP_SLOW_LOG)) { 
+            priority = NActors::NLog::PRI_TRACE; 
+            thresholdMs = Config->_KqpSlowLogTraceThresholdMs.Get().GetRef(); 
+        } else if (logSettings->Satisfies(NActors::NLog::PRI_NOTICE, NKikimrServices::KQP_SLOW_LOG)) { 
+            priority = NActors::NLog::PRI_NOTICE; 
+            thresholdMs = Config->_KqpSlowLogNoticeThresholdMs.Get().GetRef(); 
+        } else if (logSettings->Satisfies(NActors::NLog::PRI_WARN, NKikimrServices::KQP_SLOW_LOG)) { 
+            priority = NActors::NLog::PRI_WARN; 
+            thresholdMs = Config->_KqpSlowLogWarningThresholdMs.Get().GetRef(); 
+        } else { 
+            return; 
+        } 
+ 
+        if (duration >= TDuration::MilliSeconds(thresholdMs)) { 
+            auto username = NACLib::TUserToken(QueryState->UserToken).GetUserSID(); 
+            if (username.empty()) { 
+                username = "UNAUTHENTICATED"; 
+            } 
+ 
             auto queryText = ExtractQueryText();
-
-            auto paramsText = TStringBuilder()
-                << ToString(QueryState->ParametersSize)
-                << 'b';
-
-            ui64 resultsSize = 0;
-            if (resultsSizeFunc) {
-                resultsSize = resultsSizeFunc();
-            }
-
-            LOG_LOG_S(ctx, priority, NKikimrServices::KQP_SLOW_LOG, requestInfo
-                << "Slow query, duration: " << duration.ToString()
-                << ", status: " << status
-                << ", user: " << username
-                << ", results: " << resultsSize << 'b'
-                << ", text: \"" << EscapeC(queryText) << '"'
-                << ", parameters: " << paramsText);
-        }
-    }
-
-    void FillCompileStatus(const TKqpCompileResult::TConstPtr& compileResult,
-        TEvKqp::TProtoArenaHolder<NKikimrKqp::TEvQueryResponse>& record)
-    {
-        auto& ev = record.GetRef();
-
-        ev.SetYdbStatus(compileResult->Status);
-
-        auto& response = *ev.MutableResponse();
-        AddQueryIssues(response, compileResult->Issues);
-
-        if (compileResult->Status == Ydb::StatusIds::SUCCESS) {
-            response.SetPreparedQuery(compileResult->Uid);
-
-            auto& preparedQuery = compileResult->PreparedQuery;
+ 
+            auto paramsText = TStringBuilder() 
+                << ToString(QueryState->ParametersSize) 
+                << 'b'; 
+ 
+            ui64 resultsSize = 0; 
+            if (resultsSizeFunc) { 
+                resultsSize = resultsSizeFunc(); 
+            } 
+ 
+            LOG_LOG_S(ctx, priority, NKikimrServices::KQP_SLOW_LOG, requestInfo 
+                << "Slow query, duration: " << duration.ToString() 
+                << ", status: " << status 
+                << ", user: " << username 
+                << ", results: " << resultsSize << 'b' 
+                << ", text: \"" << EscapeC(queryText) << '"' 
+                << ", parameters: " << paramsText); 
+        } 
+    } 
+ 
+    void FillCompileStatus(const TKqpCompileResult::TConstPtr& compileResult, 
+        TEvKqp::TProtoArenaHolder<NKikimrKqp::TEvQueryResponse>& record) 
+    { 
+        auto& ev = record.GetRef(); 
+ 
+        ev.SetYdbStatus(compileResult->Status); 
+ 
+        auto& response = *ev.MutableResponse(); 
+        AddQueryIssues(response, compileResult->Issues); 
+ 
+        if (compileResult->Status == Ydb::StatusIds::SUCCESS) { 
+            response.SetPreparedQuery(compileResult->Uid); 
+ 
+            auto& preparedQuery = compileResult->PreparedQuery; 
             response.MutableQueryParameters()->CopyFrom(preparedQuery->GetParameters());
-
+ 
             if (preparedQuery->KqlsSize() > 0) {
                 response.SetQueryAst(preparedQuery->GetKqls(0).GetAst());
                 response.SetQueryPlan(preparedQuery->GetKqls(0).GetPlan());
-            }
-        }
-    }
-
-    void FillQueryProfile(const NKqpProto::TKqpStatsQuery& stats, NKikimrKqp::TQueryResponse& response) {
-        auto& kqlProfile = *response.MutableProfile()->AddKqlProfiles();
-        for (auto& execStats : stats.GetExecutions()) {
-            auto& txStats = *kqlProfile.AddMkqlProfiles()->MutableTxStats();
-
+            } 
+        } 
+    } 
+ 
+    void FillQueryProfile(const NKqpProto::TKqpStatsQuery& stats, NKikimrKqp::TQueryResponse& response) { 
+        auto& kqlProfile = *response.MutableProfile()->AddKqlProfiles(); 
+        for (auto& execStats : stats.GetExecutions()) { 
+            auto& txStats = *kqlProfile.AddMkqlProfiles()->MutableTxStats(); 
+ 
             txStats.SetDurationUs(execStats.GetDurationUs());
-            for (auto& tableStats : execStats.GetTables()) {
-                auto& txTableStats = *txStats.AddTableAccessStats();
-
-                txTableStats.MutableTableInfo()->SetName(tableStats.GetTablePath());
-                if (tableStats.GetReadRows() > 0) {
-                    txTableStats.MutableSelectRange()->SetRows(tableStats.GetReadRows());
-                    txTableStats.MutableSelectRange()->SetBytes(tableStats.GetReadBytes());
-                }
-                if (tableStats.GetWriteRows() > 0) {
-                    txTableStats.MutableUpdateRow()->SetCount(tableStats.GetWriteRows());
-                    txTableStats.MutableUpdateRow()->SetBytes(tableStats.GetWriteBytes());
-                }
-                if (tableStats.GetEraseRows() > 0) {
-                    txTableStats.MutableEraseRow()->SetCount(tableStats.GetEraseRows());
-                }
-            }
-        }
-    }
-
-    void FillResponse(TEvKqp::TProtoArenaHolder<NKikimrKqp::TEvQueryResponse>& record) {
-        Y_VERIFY(QueryState);
-        auto& queryRequest = QueryState->Request;
-
-        auto& queryResult = QueryState->QueryResult;
+            for (auto& tableStats : execStats.GetTables()) { 
+                auto& txTableStats = *txStats.AddTableAccessStats(); 
+ 
+                txTableStats.MutableTableInfo()->SetName(tableStats.GetTablePath()); 
+                if (tableStats.GetReadRows() > 0) { 
+                    txTableStats.MutableSelectRange()->SetRows(tableStats.GetReadRows()); 
+                    txTableStats.MutableSelectRange()->SetBytes(tableStats.GetReadBytes()); 
+                } 
+                if (tableStats.GetWriteRows() > 0) { 
+                    txTableStats.MutableUpdateRow()->SetCount(tableStats.GetWriteRows()); 
+                    txTableStats.MutableUpdateRow()->SetBytes(tableStats.GetWriteBytes()); 
+                } 
+                if (tableStats.GetEraseRows() > 0) { 
+                    txTableStats.MutableEraseRow()->SetCount(tableStats.GetEraseRows()); 
+                } 
+            } 
+        } 
+    } 
+ 
+    void FillResponse(TEvKqp::TProtoArenaHolder<NKikimrKqp::TEvQueryResponse>& record) { 
+        Y_VERIFY(QueryState); 
+        auto& queryRequest = QueryState->Request; 
+ 
+        auto& queryResult = QueryState->QueryResult; 
         auto arena = queryResult.ProtobufArenaPtr;
         if (arena) {
             record.Realloc(arena);
         }
         auto& ev = record.GetRef();
-
-        bool replyResults = IsExecuteAction(queryRequest.GetAction());
-        bool replyPlan = true;
-        bool replyAst = true;
-
-        // TODO: Handle in KQP to avoid generation of redundant data
-        replyResults = replyResults && (QueryState->ReplyFlags & NKikimrKqp::QUERY_REPLY_FLAG_RESULTS);
-        replyPlan = replyPlan && (QueryState->ReplyFlags & NKikimrKqp::QUERY_REPLY_FLAG_PLAN);
-        replyAst = replyAst && (QueryState->ReplyFlags & NKikimrKqp::QUERY_REPLY_FLAG_AST);
-
-        auto ydbStatus = GetYdbStatus(queryResult);
-        auto issues = queryResult.Issues();
-
-        ev.SetYdbStatus(ydbStatus);
-        if (QueryState->QueryCompileResult) {
-            AddQueryIssues(*ev.MutableResponse(), QueryState->QueryCompileResult->Issues);
-        }
-        AddQueryIssues(*ev.MutableResponse(), issues);
-
-        if (replyResults) {
-            for (auto& result : queryResult.Results) {
+ 
+        bool replyResults = IsExecuteAction(queryRequest.GetAction()); 
+        bool replyPlan = true; 
+        bool replyAst = true; 
+ 
+        // TODO: Handle in KQP to avoid generation of redundant data 
+        replyResults = replyResults && (QueryState->ReplyFlags & NKikimrKqp::QUERY_REPLY_FLAG_RESULTS); 
+        replyPlan = replyPlan && (QueryState->ReplyFlags & NKikimrKqp::QUERY_REPLY_FLAG_PLAN); 
+        replyAst = replyAst && (QueryState->ReplyFlags & NKikimrKqp::QUERY_REPLY_FLAG_AST); 
+ 
+        auto ydbStatus = GetYdbStatus(queryResult); 
+        auto issues = queryResult.Issues(); 
+ 
+        ev.SetYdbStatus(ydbStatus); 
+        if (QueryState->QueryCompileResult) { 
+            AddQueryIssues(*ev.MutableResponse(), QueryState->QueryCompileResult->Issues); 
+        } 
+        AddQueryIssues(*ev.MutableResponse(), issues); 
+ 
+        if (replyResults) { 
+            for (auto& result : queryResult.Results) { 
                 // If we have result it must be allocated on protobuf arena
                 Y_ASSERT(result->GetArena());
                 Y_ASSERT(ev.MutableResponse()->GetArena() == result->GetArena());
                 ev.MutableResponse()->AddResults()->Swap(result);
-            }
-        }
-
+            } 
+        } 
+ 
         /*
          * TODO:
          * For Scan/NewEngine plan will be set later on rpc_* level from stats and execution profiles, so
@@ -1979,18 +1979,18 @@ private:
             ev.MutableResponse()->SetQueryPlan(queryResult.QueryPlan);
         }
 
-        if (ydbStatus != Ydb::StatusIds::SUCCESS) {
+        if (ydbStatus != Ydb::StatusIds::SUCCESS) { 
             return;
         }
 
-        bool replyQueryId = false;
+        bool replyQueryId = false; 
         bool replyQueryParameters = false;
-        switch (queryRequest.GetAction()) {
+        switch (queryRequest.GetAction()) { 
         case NKikimrKqp::QUERY_ACTION_PREPARE:
             replyQueryId = true;
             replyQueryParameters = true;
             break;
-
+ 
         case NKikimrKqp::QUERY_ACTION_EXECUTE:
             replyQueryParameters = replyQueryId = queryRequest.GetQueryCachePolicy().keep_in_cache();
             break;
@@ -2002,67 +2002,67 @@ private:
 
         default:
             break;
-        }
-
-        if (replyQueryParameters) {
-            if (QueryState->QueryCompileResult) {
-                ev.MutableResponse()->MutableQueryParameters()->CopyFrom(
+        } 
+ 
+        if (replyQueryParameters) { 
+            if (QueryState->QueryCompileResult) { 
+                ev.MutableResponse()->MutableQueryParameters()->CopyFrom( 
                     QueryState->QueryCompileResult->PreparedQuery->GetParameters());
-            } else {
+            } else { 
                 YQL_ENSURE(queryResult.PreparedQuery);
                 ev.MutableResponse()->MutableQueryParameters()->CopyFrom(
                     queryResult.PreparedQuery->GetParameters());
-            }
-        }
-
+            } 
+        } 
+ 
         if (replyQueryId) {
-            TString queryId;
-            if (QueryState->QueryCompileResult) {
-                queryId = QueryState->QueryCompileResult->Uid;
-            } else {
+            TString queryId; 
+            if (QueryState->QueryCompileResult) { 
+                queryId = QueryState->QueryCompileResult->Uid; 
+            } else { 
                 YQL_ENSURE(!Settings.LongSession);
                 Y_PROTOBUF_SUPPRESS_NODISCARD queryResult.PreparedQuery->SerializeToString(&queryId);
-            }
-
-            ev.MutableResponse()->SetPreparedQuery(queryId);
-        }
-    }
-
-    void FillTxInfo(TEvKqp::TProtoArenaHolder<NKikimrKqp::TEvQueryResponse>& record) {
-        auto& ev = record.GetRef();
-
-        auto txInfo = QueryState->TxId.empty()
-            ? KqpHost->GetTransactionInfo()
-            : KqpHost->GetTransactionInfo(QueryState->TxId);
-
-        TString replyTxId;
-        if (txInfo) {
+            } 
+ 
+            ev.MutableResponse()->SetPreparedQuery(queryId); 
+        } 
+    } 
+ 
+    void FillTxInfo(TEvKqp::TProtoArenaHolder<NKikimrKqp::TEvQueryResponse>& record) { 
+        auto& ev = record.GetRef(); 
+ 
+        auto txInfo = QueryState->TxId.empty() 
+            ? KqpHost->GetTransactionInfo() 
+            : KqpHost->GetTransactionInfo(QueryState->TxId); 
+ 
+        TString replyTxId; 
+        if (txInfo) { 
             Counters->ReportTransaction(Settings.DbCounters, *txInfo);
-
-            switch (txInfo->Status) {
-                case TKqpTransactionInfo::EStatus::Active:
-                    replyTxId = QueryState->TxId;
-                    break;
-                default:
-                    break;
-            }
-        }
-
-        ev.MutableResponse()->MutableTxMeta()->set_id(replyTxId);
-    }
-
-    void MakeNewQueryState() {
-        ++QueryId;
-        QueryState.Reset(MakeHolder<TKqpQueryState>());
-    }
-
-    TString InvalidateQuery(const TKqpCompileResult& compileResult, const TActorContext& ctx) {
+ 
+            switch (txInfo->Status) { 
+                case TKqpTransactionInfo::EStatus::Active: 
+                    replyTxId = QueryState->TxId; 
+                    break; 
+                default: 
+                    break; 
+            } 
+        } 
+ 
+        ev.MutableResponse()->MutableTxMeta()->set_id(replyTxId); 
+    } 
+ 
+    void MakeNewQueryState() { 
+        ++QueryId; 
+        QueryState.Reset(MakeHolder<TKqpQueryState>()); 
+    } 
+ 
+    TString InvalidateQuery(const TKqpCompileResult& compileResult, const TActorContext& ctx) { 
         auto invalidateEv = MakeHolder<TEvKqp::TEvCompileInvalidateRequest>(compileResult.Uid, Settings.DbCounters);
-        ctx.Send(MakeKqpCompileServiceID(ctx.SelfID.NodeId()), invalidateEv.Release());
-
-        return compileResult.Uid;
-    }
-
+        ctx.Send(MakeKqpCompileServiceID(ctx.SelfID.NodeId()), invalidateEv.Release()); 
+ 
+        return compileResult.Uid; 
+    } 
+ 
     void ScheduleNextShutdownTick(const TActorContext& ctx) {
         ctx.Schedule(TDuration::MilliSeconds(ShutdownState->GetNextTickMs()), new TEvKqp::TEvContinueShutdown());
     }
@@ -2085,30 +2085,30 @@ private:
 
         } else {
             ScheduleNextShutdownTick(ctx);
-            LOG_INFO_S(ctx, NKikimrServices::KQP_WORKER, "Schedule next shutdown tick " << TKqpRequestInfo("", SessionId));
-        }
-    }
-
-    void StartIdleTimer(const TActorContext& ctx) {
-        StopIdleTimer(ctx);
-
-        ++IdleTimerId;
-        auto idleDuration = TDuration::Seconds(Config->_KqpSessionIdleTimeoutSec.Get().GetRef());
-        IdleTimerActorId = CreateLongTimer(ctx, idleDuration,
-            new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvKqp::TEvIdleTimeout(IdleTimerId)));
-        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, "Created long timer for idle timeout, timer id: " << IdleTimerId
-            << ", duration: " << idleDuration << ", actor: " << IdleTimerActorId);
-    }
-
-    void StopIdleTimer(const TActorContext& ctx) {
-        if (IdleTimerActorId) {
-            LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, "Destroying long timer actor for idle timout: "
-                << IdleTimerActorId);
-            ctx.Send(IdleTimerActorId, new TEvents::TEvPoisonPill());
-        }
+            LOG_INFO_S(ctx, NKikimrServices::KQP_WORKER, "Schedule next shutdown tick " << TKqpRequestInfo("", SessionId)); 
+        }
+    }
+
+    void StartIdleTimer(const TActorContext& ctx) { 
+        StopIdleTimer(ctx); 
+ 
+        ++IdleTimerId; 
+        auto idleDuration = TDuration::Seconds(Config->_KqpSessionIdleTimeoutSec.Get().GetRef()); 
+        IdleTimerActorId = CreateLongTimer(ctx, idleDuration, 
+            new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvKqp::TEvIdleTimeout(IdleTimerId))); 
+        LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, "Created long timer for idle timeout, timer id: " << IdleTimerId 
+            << ", duration: " << idleDuration << ", actor: " << IdleTimerActorId); 
+    } 
+ 
+    void StopIdleTimer(const TActorContext& ctx) { 
+        if (IdleTimerActorId) { 
+            LOG_DEBUG_S(ctx, NKikimrServices::KQP_WORKER, "Destroying long timer actor for idle timout: " 
+                << IdleTimerActorId); 
+            ctx.Send(IdleTimerActorId, new TEvents::TEvPoisonPill()); 
+        } 
         IdleTimerActorId = TActorId();
-    }
-
+    } 
+ 
     IKikimrQueryExecutor::TExecuteSettings CreateRollbackSettings() {
         YQL_ENSURE(QueryState);
 
@@ -2132,62 +2132,62 @@ private:
         return Nothing();
     }
 
-    static bool IsExecuteAction(const NKikimrKqp::EQueryAction& action) {
-        switch (action) {
-            case NKikimrKqp::QUERY_ACTION_EXECUTE:
-            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED:
-                return true;
-
-            default:
-                return false;
-        }
-    }
-
-    static bool IsDocumentApiRestricted(const TString& requestType) {
-        return requestType != DocumentApiRequestType;
-    }
-
-    static TKikimrQueryLimits GetQueryLimits(const TKqpWorkerSettings& settings) {
-        const auto& queryLimitsProto = settings.Service.GetQueryLimits();
-        const auto& phaseLimitsProto = queryLimitsProto.GetPhaseLimits();
-
-        TKikimrQueryLimits queryLimits;
-        auto& phaseLimits = queryLimits.PhaseLimits;
-        phaseLimits.AffectedShardsLimit = phaseLimitsProto.GetAffectedShardsLimit();
-        phaseLimits.ReadsetCountLimit = phaseLimitsProto.GetReadsetCountLimit();
-        phaseLimits.ComputeNodeMemoryLimitBytes = phaseLimitsProto.GetComputeNodeMemoryLimitBytes();
-        phaseLimits.TotalReadSizeLimitBytes = phaseLimitsProto.GetTotalReadSizeLimitBytes();
-
-        return queryLimits;
-    }
-
-private:
+    static bool IsExecuteAction(const NKikimrKqp::EQueryAction& action) { 
+        switch (action) { 
+            case NKikimrKqp::QUERY_ACTION_EXECUTE: 
+            case NKikimrKqp::QUERY_ACTION_EXECUTE_PREPARED: 
+                return true; 
+ 
+            default: 
+                return false; 
+        } 
+    } 
+ 
+    static bool IsDocumentApiRestricted(const TString& requestType) { 
+        return requestType != DocumentApiRequestType; 
+    } 
+ 
+    static TKikimrQueryLimits GetQueryLimits(const TKqpWorkerSettings& settings) { 
+        const auto& queryLimitsProto = settings.Service.GetQueryLimits(); 
+        const auto& phaseLimitsProto = queryLimitsProto.GetPhaseLimits(); 
+ 
+        TKikimrQueryLimits queryLimits; 
+        auto& phaseLimits = queryLimits.PhaseLimits; 
+        phaseLimits.AffectedShardsLimit = phaseLimitsProto.GetAffectedShardsLimit(); 
+        phaseLimits.ReadsetCountLimit = phaseLimitsProto.GetReadsetCountLimit(); 
+        phaseLimits.ComputeNodeMemoryLimitBytes = phaseLimitsProto.GetComputeNodeMemoryLimitBytes(); 
+        phaseLimits.TotalReadSizeLimitBytes = phaseLimitsProto.GetTotalReadSizeLimitBytes(); 
+ 
+        return queryLimits; 
+    } 
+ 
+private: 
     TActorId Owner;
-    TString SessionId;
-    TKqpWorkerSettings Settings;
-    TIntrusivePtr<TModuleResolverState> ModuleResolverState;
-    TIntrusivePtr<TKqpCounters> Counters;
+    TString SessionId; 
+    TKqpWorkerSettings Settings; 
+    TIntrusivePtr<TModuleResolverState> ModuleResolverState; 
+    TIntrusivePtr<TKqpCounters> Counters; 
     TIntrusivePtr<TKqpRequestCounters> RequestCounters;
-    TKikimrConfiguration::TPtr Config;
-    TInstant CreationTime;
-    TIntrusivePtr<IKqpGateway> Gateway;
-    TIntrusivePtr<IKqpHost> KqpHost;
-    ui32 QueryId;
-    THolder<TKqpQueryState> QueryState;
-    THolder<TKqpCleanupState> CleanupState;
-    ui32 IdleTimerId;
+    TKikimrConfiguration::TPtr Config; 
+    TInstant CreationTime; 
+    TIntrusivePtr<IKqpGateway> Gateway; 
+    TIntrusivePtr<IKqpHost> KqpHost; 
+    ui32 QueryId; 
+    THolder<TKqpQueryState> QueryState; 
+    THolder<TKqpCleanupState> CleanupState; 
+    ui32 IdleTimerId; 
     TActorId IdleTimerActorId;
     std::optional<TSessionShutdownState> ShutdownState;
-};
-
-} // namespace
-
+}; 
+ 
+} // namespace 
+ 
 IActor* CreateKqpWorkerActor(const TActorId& owner, const TString& sessionId,
-    const TKqpSettings::TConstPtr& kqpSettings, const TKqpWorkerSettings& workerSettings,
-    TIntrusivePtr<TModuleResolverState> moduleResolverState, TIntrusivePtr<TKqpCounters> counters)
-{
-    return new TKqpWorkerActor(owner, sessionId, kqpSettings, workerSettings, moduleResolverState, counters);
-}
-
+    const TKqpSettings::TConstPtr& kqpSettings, const TKqpWorkerSettings& workerSettings, 
+    TIntrusivePtr<TModuleResolverState> moduleResolverState, TIntrusivePtr<TKqpCounters> counters) 
+{ 
+    return new TKqpWorkerActor(owner, sessionId, kqpSettings, workerSettings, moduleResolverState, counters); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/node/kqp_node_ut.cpp b/ydb/core/kqp/node/kqp_node_ut.cpp
index 4decee6bd3..0baf50c04b 100644
--- a/ydb/core/kqp/node/kqp_node_ut.cpp
+++ b/ydb/core/kqp/node/kqp_node_ut.cpp
@@ -171,8 +171,8 @@ public:
 
     IActor* CreateKqpNode(const NKikimrConfig::TTableServiceConfig& config = {}) {
         auto rm = CreateKqpResourceManagerActor(config.GetResourceManager(), KqpCounters, ResourceBrokerActorId);
-        ResourceManagerActorId = Runtime->Register(rm);
-        Runtime->EnableScheduleForActor(ResourceManagerActorId, true);
+        ResourceManagerActorId = Runtime->Register(rm); 
+        Runtime->EnableScheduleForActor(ResourceManagerActorId, true); 
         WaitForBootstrap();
 
         auto kqpNode = CreateKqpNodeService(config, KqpCounters, CompFactory.Get());
@@ -189,7 +189,7 @@ public:
         ev->Record.SetTxId(txId);
         ActorIdToProto(executer ? executer : requester, ev->Record.MutableExecuterActorId());
         ev->Record.SetStartAllOrFail(true);
-        ev->Record.MutableRuntimeSettings()->SetExecType(NYql::NDqProto::TComputeRuntimeSettings::SCAN);
+        ev->Record.MutableRuntimeSettings()->SetExecType(NYql::NDqProto::TComputeRuntimeSettings::SCAN); 
 
         for (ui64 taskId : taskIds) {
             auto* task = ev->Record.AddTasks();
@@ -263,7 +263,7 @@ private:
     TIntrusivePtr<TKqpCounters> KqpCounters;
     THolder<TMockKqpComputeActorFactory> CompFactory;
     TActorId ResourceBrokerActorId;
-    TActorId ResourceManagerActorId;
+    TActorId ResourceManagerActorId; 
     TActorId KqpNodeActorId;
 };
 UNIT_TEST_SUITE_REGISTRATION(KqpNode);
@@ -308,11 +308,11 @@ void KqpNode::CommonCase() {
     {
         TVector<NKikimrKqp::TKqpNodeResources> snapshot;
         std::atomic<int> ready = 0;
-        GetKqpResourceManager(ResourceManagerActorId.NodeId())->RequestClusterResourcesInfo(
-            [&](TVector<NKikimrKqp::TKqpNodeResources>&& resources) {
-                snapshot = std::move(resources);
-                ready = 1;
-            });
+        GetKqpResourceManager(ResourceManagerActorId.NodeId())->RequestClusterResourcesInfo( 
+            [&](TVector<NKikimrKqp::TKqpNodeResources>&& resources) { 
+                snapshot = std::move(resources); 
+                ready = 1; 
+            }); 
 
         while (ready.load() != 1) {
             Runtime->DispatchEvents(TDispatchOptions(), TDuration::MilliSeconds(100));
@@ -371,7 +371,7 @@ void KqpNode::CommonCase() {
         NKikimr::TActorSystemStub stub;
 
         auto& task4ExtraAlloc = CompFactory->Task2Actor[4].MemoryLimits.AllocateMemoryFn;
-        bool allocated = task4ExtraAlloc(/* txId */ (ui64)2, /* taskId */ 4, /* memory */ 100);
+        bool allocated = task4ExtraAlloc(/* txId */ (ui64)2, /* taskId */ 4, /* memory */ 100); 
         UNIT_ASSERT(allocated);
         DispatchKqpNodePostponedEvents(sender1);
         UNIT_ASSERT_VALUES_EQUAL(KqpCounters->RmComputeActors->Val(), 4);
@@ -416,7 +416,7 @@ void KqpNode::ExtraAllocation() {
     {
         NKikimr::TActorSystemStub stub;
 
-        bool allocated = task1ExtraAlloc(/* txId */ (ui64)1, /* taskId */ 1, /* memory */ 100);
+        bool allocated = task1ExtraAlloc(/* txId */ (ui64)1, /* taskId */ 1, /* memory */ 100); 
         UNIT_ASSERT(allocated);
         DispatchKqpNodePostponedEvents(sender1);
 
@@ -429,7 +429,7 @@ void KqpNode::ExtraAllocation() {
     {
         NKikimr::TActorSystemStub stub;
 
-        bool allocated = task1ExtraAlloc(/* txId */ (ui64)1, /* taskId */ 1, /* memory */ 50'000);
+        bool allocated = task1ExtraAlloc(/* txId */ (ui64)1, /* taskId */ 1, /* memory */ 50'000); 
         UNIT_ASSERT(!allocated);
         DispatchKqpNodePostponedEvents(sender1);
 
@@ -471,7 +471,7 @@ void KqpNode::NotEnoughMemory_Extra() {
     const ui64 taskSize = 1'000 + 2 * 10;
 
     // first request
-    SendStartTasksRequest(sender1, /* txId */ (ui64)1, /* taskIds */ {1, 2});
+    SendStartTasksRequest(sender1, /* txId */ (ui64)1, /* taskIds */ {1, 2}); 
     {
         auto answer = Runtime->GrabEdgeEvent<TEvKqpNode::TEvStartKqpTasksResponse>(sender1);
         auto& record = answer->Get()->Record;
@@ -500,7 +500,7 @@ void KqpNode::NotEnoughMemory_Extra() {
         NKikimr::TActorSystemStub stub;
 
         auto& task1ExtraAlloc = CompFactory->Task2Actor[1].MemoryLimits.AllocateMemoryFn;
-        bool allocated = task1ExtraAlloc((ui64)1, 1, 1'000'000);
+        bool allocated = task1ExtraAlloc((ui64)1, 1, 1'000'000); 
         UNIT_ASSERT(!allocated);
     }
 
@@ -521,7 +521,7 @@ void KqpNode::NotEnoughComputeActors() {
 
     TActorId sender1 = Runtime->AllocateEdgeActor();
 
-    SendStartTasksRequest(sender1, /* txId */ (ui64)1, /* taskIds */ {1, 2, 3, 4, 5});
+    SendStartTasksRequest(sender1, /* txId */ (ui64)1, /* taskIds */ {1, 2, 3, 4, 5}); 
     {
         auto answer = Runtime->GrabEdgeEvent<TEvKqpNode::TEvStartKqpTasksResponse>(sender1);
         auto& record = answer->Get()->Record;
@@ -586,7 +586,7 @@ void KqpNode::ResourceBrokerNotEnoughResources_Extra() {
         NKikimr::TActorSystemStub stub;
 
         auto& task1ExtraAlloc = CompFactory->Task2Actor[1].MemoryLimits.AllocateMemoryFn;
-        bool allocated = task1ExtraAlloc((ui64)1, 1, 26'000);
+        bool allocated = task1ExtraAlloc((ui64)1, 1, 26'000); 
         UNIT_ASSERT(!allocated);
     }
 
@@ -605,7 +605,7 @@ void KqpNode::ExecuterLost() {
         NKikimr::TActorSystemStub stub;
 
         auto& task1ExtraAlloc = CompFactory->Task2Actor[1].MemoryLimits.AllocateMemoryFn;
-        bool allocated = task1ExtraAlloc((ui64)1, 1, 100);
+        bool allocated = task1ExtraAlloc((ui64)1, 1, 100); 
         UNIT_ASSERT(allocated);
         DispatchKqpNodePostponedEvents(sender1);
     }
@@ -645,7 +645,7 @@ void KqpNode::TerminateTx() {
         NKikimr::TActorSystemStub stub;
 
         auto& task1ExtraAlloc = CompFactory->Task2Actor[1].MemoryLimits.AllocateMemoryFn;
-        bool allocated = task1ExtraAlloc((ui64)1, 1, 100);
+        bool allocated = task1ExtraAlloc((ui64)1, 1, 100); 
         UNIT_ASSERT(allocated);
         DispatchKqpNodePostponedEvents(sender1);
     }
diff --git a/ydb/core/kqp/node/ya.make b/ydb/core/kqp/node/ya.make
index 6d2c60982b..801b4e19f1 100644
--- a/ydb/core/kqp/node/ya.make
+++ b/ydb/core/kqp/node/ya.make
@@ -23,6 +23,6 @@ YQL_LAST_ABI_VERSION()
 
 END()
 
-RECURSE_FOR_TESTS(
-    ut
-)
+RECURSE_FOR_TESTS( 
+    ut 
+) 
diff --git a/ydb/core/kqp/opt/kqp_opt.cpp b/ydb/core/kqp/opt/kqp_opt.cpp
index 1bd771ece1..eb3319ecc8 100644
--- a/ydb/core/kqp/opt/kqp_opt.cpp
+++ b/ydb/core/kqp/opt/kqp_opt.cpp
@@ -1,51 +1,51 @@
-#include "kqp_opt_impl.h"
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-
-namespace {
-
-template<typename T>
-TExprBase ProjectColumnsInternal(const TExprBase& input, const T& columnNames, TExprContext& ctx) {
-    const auto rowArgument = Build<TCoArgument>(ctx, input.Pos())
-        .Name("row")
-        .Done();
-
-    TVector<TExprBase> columnGetters;
-    columnGetters.reserve(columnNames.size());
-    for (const auto& column : columnNames) {
-        const auto tuple = Build<TCoNameValueTuple>(ctx, input.Pos())
-            .Name().Build(column)
-            .template Value<TCoMember>()
-                .Struct(rowArgument)
-                .Name().Build(column)
-                .Build()
-            .Done();
-
-        columnGetters.emplace_back(std::move(tuple));
-    }
-
-    return Build<TCoMap>(ctx, input.Pos())
-        .Input(input)
-        .Lambda()
-            .Args({rowArgument})
-            .Body<TCoAsStruct>()
-                .Add(columnGetters)
-                .Build()
-            .Build()
-        .Done();
-}
-
-} // namespace
-
-bool IsKqpPureLambda(const TCoLambda& lambda) {
-    return !FindNode(lambda.Body().Ptr(), [](const TExprNode::TPtr& node) {
-        if (TMaybeNode<TKqlReadTableBase>(node)) {
-            return true;
-        }
-
+#include "kqp_opt_impl.h" 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+template<typename T> 
+TExprBase ProjectColumnsInternal(const TExprBase& input, const T& columnNames, TExprContext& ctx) { 
+    const auto rowArgument = Build<TCoArgument>(ctx, input.Pos()) 
+        .Name("row") 
+        .Done(); 
+ 
+    TVector<TExprBase> columnGetters; 
+    columnGetters.reserve(columnNames.size()); 
+    for (const auto& column : columnNames) { 
+        const auto tuple = Build<TCoNameValueTuple>(ctx, input.Pos()) 
+            .Name().Build(column) 
+            .template Value<TCoMember>() 
+                .Struct(rowArgument) 
+                .Name().Build(column) 
+                .Build() 
+            .Done(); 
+ 
+        columnGetters.emplace_back(std::move(tuple)); 
+    } 
+ 
+    return Build<TCoMap>(ctx, input.Pos()) 
+        .Input(input) 
+        .Lambda() 
+            .Args({rowArgument}) 
+            .Body<TCoAsStruct>() 
+                .Add(columnGetters) 
+                .Build() 
+            .Build() 
+        .Done(); 
+} 
+ 
+} // namespace 
+ 
+bool IsKqpPureLambda(const TCoLambda& lambda) { 
+    return !FindNode(lambda.Body().Ptr(), [](const TExprNode::TPtr& node) { 
+        if (TMaybeNode<TKqlReadTableBase>(node)) { 
+            return true; 
+        } 
+ 
         if (TMaybeNode<TKqlReadTableRangesBase>(node)) {
             return true;
         }
@@ -54,38 +54,38 @@ bool IsKqpPureLambda(const TCoLambda& lambda) {
             return true;
         }
 
-        if (TMaybeNode<TKqlTableEffect>(node)) {
-            return true;
-        }
-
-        return false;
-    });
-}
-
-bool IsKqpEffectsStage(const TDqStageBase& stage) {
-    return stage.Program().Body().Maybe<TKqpEffects>().IsValid();
-}
-
-TExprBase ProjectColumns(const TExprBase& input, const TVector<TString>& columnNames, TExprContext& ctx) {
-    return ProjectColumnsInternal(input, columnNames, ctx);
-}
-
-TExprBase ProjectColumns(const TExprBase& input, const THashSet<TStringBuf>& columnNames, TExprContext& ctx) {
-    return ProjectColumnsInternal(input, columnNames, ctx);
-}
-
+        if (TMaybeNode<TKqlTableEffect>(node)) { 
+            return true; 
+        } 
+ 
+        return false; 
+    }); 
+} 
+ 
+bool IsKqpEffectsStage(const TDqStageBase& stage) { 
+    return stage.Program().Body().Maybe<TKqpEffects>().IsValid(); 
+} 
+ 
+TExprBase ProjectColumns(const TExprBase& input, const TVector<TString>& columnNames, TExprContext& ctx) { 
+    return ProjectColumnsInternal(input, columnNames, ctx); 
+} 
+ 
+TExprBase ProjectColumns(const TExprBase& input, const THashSet<TStringBuf>& columnNames, TExprContext& ctx) { 
+    return ProjectColumnsInternal(input, columnNames, ctx); 
+} 
+ 
 TKqpTable BuildTableMeta(const TKikimrTableMetadata& meta, const TPositionHandle& pos, TExprContext& ctx) {
-    return Build<TKqpTable>(ctx, pos)
-        .Path().Build(meta.Name)
-        .PathId().Build(meta.PathId.ToString())
-        .SysView().Build(meta.SysView)
-        .Version().Build(meta.SchemaVersion)
-        .Done();
-}
-
+    return Build<TKqpTable>(ctx, pos) 
+        .Path().Build(meta.Name) 
+        .PathId().Build(meta.PathId.ToString()) 
+        .SysView().Build(meta.SysView) 
+        .Version().Build(meta.SchemaVersion) 
+        .Done(); 
+} 
+ 
 TKqpTable BuildTableMeta(const TKikimrTableDescription& tableDesc, const TPositionHandle& pos, TExprContext& ctx) {
     YQL_ENSURE(tableDesc.Metadata);
     return BuildTableMeta(*tableDesc.Metadata, pos, ctx);
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/kqp_opt.h b/ydb/core/kqp/opt/kqp_opt.h
index a86561d0c4..756e8ab8ba 100644
--- a/ydb/core/kqp/opt/kqp_opt.h
+++ b/ydb/core/kqp/opt/kqp_opt.h
@@ -1,60 +1,60 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/common/kqp_transform.h>
 #include <ydb/core/kqp/opt/logical/kqp_opt_log.h>
 #include <ydb/core/kqp/opt/peephole/kqp_opt_peephole.h>
 #include <ydb/core/kqp/opt/physical/kqp_opt_phy.h>
-
-namespace NKikimr::NKqp::NOpt {
-
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
 struct TKqpOptimizeContext : public TSimpleRefCount<TKqpOptimizeContext> {
-    TKqpOptimizeContext(const TString& cluster, const NYql::TKikimrConfiguration::TPtr& config,
-        const TIntrusivePtr<NYql::TKikimrQueryContext> queryCtx, const TIntrusivePtr<NYql::TKikimrTablesData>& tables)
-        : Cluster(cluster)
-        , Config(config)
-        , QueryCtx(queryCtx)
-        , Tables(tables)
-    {
-        YQL_ENSURE(QueryCtx);
-        YQL_ENSURE(Tables);
-    }
-
-    TString Cluster;
-    const NYql::TKikimrConfiguration::TPtr Config;
-    const TIntrusivePtr<NYql::TKikimrQueryContext> QueryCtx;
-    const TIntrusivePtr<NYql::TKikimrTablesData> Tables;
-
-    bool IsDataQuery() const {
-        return QueryCtx->Type == NYql::EKikimrQueryType::Dml;
-    }
-
-    bool IsScanQuery() const {
-        return QueryCtx->Type == NYql::EKikimrQueryType::Scan;
-    }
-};
-
-struct TKqpBuildQueryContext : TThrRefBase {
-    TKqpBuildQueryContext() {}
-
-    TVector<NYql::NNodes::TKqpPhysicalTx> PhysicalTxs;
-
-    void Reset() {
-        PhysicalTxs.clear();
-    }
-};
-
-bool IsKqpEffectsStage(const NYql::NNodes::TDqStageBase& stage);
-
+    TKqpOptimizeContext(const TString& cluster, const NYql::TKikimrConfiguration::TPtr& config, 
+        const TIntrusivePtr<NYql::TKikimrQueryContext> queryCtx, const TIntrusivePtr<NYql::TKikimrTablesData>& tables) 
+        : Cluster(cluster) 
+        , Config(config) 
+        , QueryCtx(queryCtx) 
+        , Tables(tables) 
+    { 
+        YQL_ENSURE(QueryCtx); 
+        YQL_ENSURE(Tables); 
+    } 
+ 
+    TString Cluster; 
+    const NYql::TKikimrConfiguration::TPtr Config; 
+    const TIntrusivePtr<NYql::TKikimrQueryContext> QueryCtx; 
+    const TIntrusivePtr<NYql::TKikimrTablesData> Tables; 
+ 
+    bool IsDataQuery() const { 
+        return QueryCtx->Type == NYql::EKikimrQueryType::Dml; 
+    } 
+ 
+    bool IsScanQuery() const { 
+        return QueryCtx->Type == NYql::EKikimrQueryType::Scan; 
+    } 
+}; 
+ 
+struct TKqpBuildQueryContext : TThrRefBase { 
+    TKqpBuildQueryContext() {} 
+ 
+    TVector<NYql::NNodes::TKqpPhysicalTx> PhysicalTxs; 
+ 
+    void Reset() { 
+        PhysicalTxs.clear(); 
+    } 
+}; 
+ 
+bool IsKqpEffectsStage(const NYql::NNodes::TDqStageBase& stage); 
+ 
 TMaybe<NYql::NNodes::TKqlQuery> BuildKqlQuery(NYql::NNodes::TKiDataQuery query, const NYql::TKikimrTablesData& tablesData,
     NYql::TExprContext& ctx, bool withSystemColumns, const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx);
-
+ 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpFinalizingOptTransformer();
-TAutoPtr<NYql::IGraphTransformer> CreateKqpQueryPhasesTransformer();
-TAutoPtr<NYql::IGraphTransformer> CreateKqpQueryEffectsTransformer(const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx);
+TAutoPtr<NYql::IGraphTransformer> CreateKqpQueryPhasesTransformer(); 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpQueryEffectsTransformer(const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx); 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpCheckPhysicalQueryTransformer();
-
+ 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpBuildTxsTransformer(const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx,
     const TIntrusivePtr<TKqpBuildQueryContext>& buildCtx, TAutoPtr<NYql::IGraphTransformer>&& typeAnnTransformer,
     NYql::TTypeAnnotationContext& typesCtx, NYql::TKikimrConfiguration::TPtr& config);
-
-} // namespace NKikimr::NKqp::NOpt
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/kqp_opt_build_txs.cpp b/ydb/core/kqp/opt/kqp_opt_build_txs.cpp
index f35ba23f66..5d7f826a0f 100644
--- a/ydb/core/kqp/opt/kqp_opt_build_txs.cpp
+++ b/ydb/core/kqp/opt/kqp_opt_build_txs.cpp
@@ -9,7 +9,7 @@
 #include <ydb/library/yql/core/services/yql_transform_pipeline.h>
 #include <ydb/library/yql/providers/common/provider/yql_provider.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NNodes;
@@ -18,8 +18,8 @@ using TStatus = IGraphTransformer::TStatus;
 
 namespace {
 
-TAutoPtr<NYql::IGraphTransformer> CreateKqpBuildPhyStagesTransformer(bool allowDependantConsumers) {
-    return NDq::CreateDqBuildPhyStagesTransformer(allowDependantConsumers);
+TAutoPtr<NYql::IGraphTransformer> CreateKqpBuildPhyStagesTransformer(bool allowDependantConsumers) { 
+    return NDq::CreateDqBuildPhyStagesTransformer(allowDependantConsumers); 
 }
 
 class TKqpBuildTxTransformer : public TSyncTransformerBase {
@@ -402,7 +402,7 @@ public:
             .Add(TExprLogTransformer::Sync("TxOpt", NLog::EComponent::ProviderKqp, NLog::ELevel::TRACE), "TxOpt")
             .Add(*TypeAnnTransformer, "TypeAnnotation")
             .AddPostTypeAnnotation(/* forSubgraph */ true)
-            .Add(CreateKqpBuildPhyStagesTransformer(/* allowDependantConsumers */ false), "BuildPhysicalStages")
+            .Add(CreateKqpBuildPhyStagesTransformer(/* allowDependantConsumers */ false), "BuildPhysicalStages") 
             .Add(*BuildTxTransformer, "BuildPhysicalTx")
             .Add(CreateKqpTxPeepholeTransformer(TypeAnnTransformer.Get(), typesCtx, config), "Peephole")
             .Build(false);
@@ -461,10 +461,10 @@ public:
                 return TStatus::Error;
             }
 
-            if (!CheckEffectsTx(tx.Cast(), ctx)) {
-                return TStatus::Error;
-            }
-
+            if (!CheckEffectsTx(tx.Cast(), ctx)) { 
+                return TStatus::Error; 
+            } 
+ 
             BuildCtx->PhysicalTxs.emplace_back(tx.Cast());
         }
 
@@ -505,37 +505,37 @@ public:
     }
 
 private:
-    bool CheckEffectsTx(TKqpPhysicalTx tx, TExprContext& ctx) const {
-        TMaybeNode<TExprBase> blackistedNode;
-        VisitExpr(tx.Ptr(), [&blackistedNode](const TExprNode::TPtr& exprNode) {
-            if (blackistedNode) {
-                return false;
-            }
-
-            if (auto maybeCallable = TMaybeNode<TCallable>(exprNode)) {
-                auto callable = maybeCallable.Cast();
-
+    bool CheckEffectsTx(TKqpPhysicalTx tx, TExprContext& ctx) const { 
+        TMaybeNode<TExprBase> blackistedNode; 
+        VisitExpr(tx.Ptr(), [&blackistedNode](const TExprNode::TPtr& exprNode) { 
+            if (blackistedNode) { 
+                return false; 
+            } 
+ 
+            if (auto maybeCallable = TMaybeNode<TCallable>(exprNode)) { 
+                auto callable = maybeCallable.Cast(); 
+ 
                 if (callable.Maybe<TCoUdf>() || callable.Maybe<TCoScriptUdf>() ||
-                    callable.Maybe<TCoUnwrap>() ||
+                    callable.Maybe<TCoUnwrap>() || 
                     callable.Maybe<TCoEnsure>() || callable.Maybe<TKqpEnsure>())
-                {
-                    blackistedNode = callable;
-                    return false;
-                }
-            }
-
-            return true;
-        });
-
-        if (blackistedNode) {
-            ctx.AddError(TIssue(ctx.GetPosition(blackistedNode.Cast().Pos()), TStringBuilder()
-                << "Callable not expected in effects tx: " << blackistedNode.Cast<TCallable>().CallableName()));
-            return false;
-        }
-
-        return true;
-    }
-
+                { 
+                    blackistedNode = callable; 
+                    return false; 
+                } 
+            } 
+ 
+            return true; 
+        }); 
+ 
+        if (blackistedNode) { 
+            ctx.AddError(TIssue(ctx.GetPosition(blackistedNode.Cast().Pos()), TStringBuilder() 
+                << "Callable not expected in effects tx: " << blackistedNode.Cast<TCallable>().CallableName())); 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
     std::pair<TNodeOnNodeOwnedMap, TNodeOnNodeOwnedMap> GatherPrecomputeDependencies(const TKqlQuery& query) {
         TNodeOnNodeOwnedMap precomputes;
         TNodeOnNodeOwnedMap dependencies;
@@ -718,4 +718,4 @@ TAutoPtr<IGraphTransformer> CreateKqpBuildTxsTransformer(const TIntrusivePtr<TKq
     return new TKqpBuildTxsTransformer(kqpCtx, buildCtx, std::move(typeAnnTransformer), typesCtx, config);
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/kqp_opt_effects.cpp b/ydb/core/kqp/opt/kqp_opt_effects.cpp
index f5f2401ce9..f8f468d8c7 100644
--- a/ydb/core/kqp/opt/kqp_opt_effects.cpp
+++ b/ydb/core/kqp/opt/kqp_opt_effects.cpp
@@ -1,60 +1,60 @@
-#include "kqp_opt_impl.h"
-
+#include "kqp_opt_impl.h" 
+ 
 #include <ydb/library/yql/core/yql_opt_utils.h>
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
 using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-using TStatus = IGraphTransformer::TStatus;
-
-namespace {
-
-bool InplaceUpdateEnabled(const TKikimrConfiguration& config) {
-    if (!config.HasAllowKqpUnsafeCommit()) {
-        return false;
-    }
-
-    if (!config.HasOptEnableInplaceUpdate()) {
-        return false;
-    }
-
-    return true;
-}
-
-bool IsMapWrite(const TKikimrTableDescription& table, TExprBase input) {
-    // TODO: Check for non-deterministic & unsafe functions (like UDF).
-    // TODO: Once we have partitioning constraints implemented in query optimizer,
-    // use them to detect map writes.
+using namespace NYql::NNodes; 
+ 
+using TStatus = IGraphTransformer::TStatus; 
+ 
+namespace { 
+ 
+bool InplaceUpdateEnabled(const TKikimrConfiguration& config) { 
+    if (!config.HasAllowKqpUnsafeCommit()) { 
+        return false; 
+    } 
+ 
+    if (!config.HasOptEnableInplaceUpdate()) { 
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
+bool IsMapWrite(const TKikimrTableDescription& table, TExprBase input) { 
+    // TODO: Check for non-deterministic & unsafe functions (like UDF). 
+    // TODO: Once we have partitioning constraints implemented in query optimizer, 
+    // use them to detect map writes. 
     if (!input.Maybe<TCoFlatMap>().Input().Maybe<TKqlReadTableBase>()) {
-        return false;
-    }
-
-    auto flatmap = input.Cast<TCoFlatMap>();
+        return false; 
+    } 
+ 
+    auto flatmap = input.Cast<TCoFlatMap>(); 
     auto read = flatmap.Input().Cast<TKqlReadTableBase>();
-
-    if (table.Metadata->PathId.ToString() != read.Table().PathId().Value()) {
-        return false;
-    }
-
-    TMaybe<THashSet<TStringBuf>> passthroughFields;
-    if (!IsPassthroughFlatMap(flatmap, &passthroughFields)) {
-        return false;
-    }
-
-    if (passthroughFields) {
-        for (auto& keyColumn : table.Metadata->KeyColumnNames) {
-            if (!passthroughFields->contains(keyColumn)) {
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
+ 
+    if (table.Metadata->PathId.ToString() != read.Table().PathId().Value()) { 
+        return false; 
+    } 
+ 
+    TMaybe<THashSet<TStringBuf>> passthroughFields; 
+    if (!IsPassthroughFlatMap(flatmap, &passthroughFields)) { 
+        return false; 
+    } 
+ 
+    if (passthroughFields) { 
+        for (auto& keyColumn : table.Metadata->KeyColumnNames) { 
+            if (!passthroughFields->contains(keyColumn)) { 
+                return false; 
+            } 
+        } 
+    } 
+ 
+    return true; 
+} 
+ 
 TDqPhyPrecompute BuildPrecomputeStage(TExprBase expr, TExprContext& ctx) {
     Y_VERIFY_DEBUG(IsDqPureExpr(expr));
 
@@ -84,55 +84,55 @@ TDqPhyPrecompute BuildPrecomputeStage(TExprBase expr, TExprContext& ctx) {
         .Done();
 }
 
-bool BuildUpsertRowsEffect(const TKqlUpsertRows& node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx,
-    const TCoArgument& inputArg, TMaybeNode<TExprBase>& stageInput, TMaybeNode<TExprBase>& effect)
-{
-    if (IsDqPureExpr(node.Input())) {
+bool BuildUpsertRowsEffect(const TKqlUpsertRows& node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx, 
+    const TCoArgument& inputArg, TMaybeNode<TExprBase>& stageInput, TMaybeNode<TExprBase>& effect) 
+{ 
+    if (IsDqPureExpr(node.Input())) { 
         stageInput = BuildPrecomputeStage(node.Input(), ctx);
 
-        effect = Build<TKqpUpsertRows>(ctx, node.Pos())
+        effect = Build<TKqpUpsertRows>(ctx, node.Pos()) 
             .Table(node.Table())
             .Input<TCoIterator>()
                 .List(inputArg)
                 .Build()
             .Columns(node.Columns())
-            .Settings().Build()
+            .Settings().Build() 
             .Done();
-        return true;
-    }
-
+        return true; 
+    } 
+ 
     if (!EnsureDqUnion(node.Input(), ctx)) {
-        return false;
-    }
-
-    auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, node.Table().Path());
-
+        return false; 
+    } 
+ 
+    auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, node.Table().Path()); 
+ 
     auto dqUnion = node.Input().Cast<TDqCnUnionAll>();
-    auto input = dqUnion.Output().Stage().Program().Body();
-
-    if (InplaceUpdateEnabled(*kqpCtx.Config) && IsMapWrite(table, input)) {
+    auto input = dqUnion.Output().Stage().Program().Body(); 
+ 
+    if (InplaceUpdateEnabled(*kqpCtx.Config) && IsMapWrite(table, input)) { 
         stageInput = Build<TKqpCnMapShard>(ctx, node.Pos())
-            .Output()
-                .Stage(dqUnion.Output().Stage())
-                .Index(dqUnion.Output().Index())
-                .Build()
-            .Done();
-
-        TKqpUpsertRowsSettings settings;
-        settings.SetInplace();
-
+            .Output() 
+                .Stage(dqUnion.Output().Stage()) 
+                .Index(dqUnion.Output().Index()) 
+                .Build() 
+            .Done(); 
+
+        TKqpUpsertRowsSettings settings; 
+        settings.SetInplace(); 
+ 
         effect = Build<TKqpUpsertRows>(ctx, node.Pos())
             .Table(node.Table())
             .Input<TCoFromFlow>()
                 .Input(inputArg)
                 .Build()
             .Columns(node.Columns())
-            .Settings(settings.BuildNode(ctx, node.Pos()))
+            .Settings(settings.BuildNode(ctx, node.Pos())) 
             .Done();
-    } else {
+    } else { 
         stageInput = Build<TDqPhyPrecompute>(ctx, node.Pos())
-            .Connection(dqUnion)
-            .Done();
+            .Connection(dqUnion) 
+            .Done(); 
 
         effect = Build<TKqpUpsertRows>(ctx, node.Pos())
             .Table(node.Table())
@@ -140,13 +140,13 @@ bool BuildUpsertRowsEffect(const TKqlUpsertRows& node, TExprContext& ctx, const
                 .List(inputArg)
                 .Build()
             .Columns(node.Columns())
-            .Settings().Build()
+            .Settings().Build() 
             .Done();
-    }
-
-    return true;
-}
-
+    } 
+ 
+    return true; 
+} 
+ 
 bool BuildDeleteRowsEffect(const TKqlDeleteRows& node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx,
     const TCoArgument& inputArg, TMaybeNode<TExprBase>& stageInput, TMaybeNode<TExprBase>& effect)
 {
@@ -171,7 +171,7 @@ bool BuildDeleteRowsEffect(const TKqlDeleteRows& node, TExprContext& ctx, const
     auto dqUnion = node.Input().Cast<TDqCnUnionAll>();
     auto input = dqUnion.Output().Stage().Program().Body();
 
-    if (InplaceUpdateEnabled(*kqpCtx.Config) && IsMapWrite(table, input)) {
+    if (InplaceUpdateEnabled(*kqpCtx.Config) && IsMapWrite(table, input)) { 
         stageInput = Build<TKqpCnMapShard>(ctx, node.Pos())
             .Output()
                 .Stage(dqUnion.Output().Stage())
@@ -201,74 +201,74 @@ bool BuildDeleteRowsEffect(const TKqlDeleteRows& node, TExprContext& ctx, const
     return true;
 }
 
-bool BuildEffects(TPositionHandle pos, const TVector<TKqlTableEffect>& effects,
-    TExprContext& ctx, const TKqpOptimizeContext& kqpCtx, TVector<TExprBase>& builtEffects)
-{
-    TVector<TCoArgument> inputArgs;
-    TVector<TExprBase> inputs;
-    TVector<TExprBase> newEffects;
-    newEffects.reserve(effects.size());
-
-    for (const auto& effect : effects) {
-        TCoArgument inputArg = Build<TCoArgument>(ctx, pos)
-            .Name("inputArg")
-            .Done();
-
-        TMaybeNode<TExprBase> input;
-        TMaybeNode<TExprBase> newEffect;
-
-        if (auto maybeUpsertRows = effect.Maybe<TKqlUpsertRows>()) {
-            if (!BuildUpsertRowsEffect(maybeUpsertRows.Cast(), ctx, kqpCtx, inputArg, input, newEffect)) {
-                return false;
-            }
-        }
-
+bool BuildEffects(TPositionHandle pos, const TVector<TKqlTableEffect>& effects, 
+    TExprContext& ctx, const TKqpOptimizeContext& kqpCtx, TVector<TExprBase>& builtEffects) 
+{ 
+    TVector<TCoArgument> inputArgs; 
+    TVector<TExprBase> inputs; 
+    TVector<TExprBase> newEffects; 
+    newEffects.reserve(effects.size()); 
+ 
+    for (const auto& effect : effects) { 
+        TCoArgument inputArg = Build<TCoArgument>(ctx, pos) 
+            .Name("inputArg") 
+            .Done(); 
+ 
+        TMaybeNode<TExprBase> input; 
+        TMaybeNode<TExprBase> newEffect; 
+ 
+        if (auto maybeUpsertRows = effect.Maybe<TKqlUpsertRows>()) { 
+            if (!BuildUpsertRowsEffect(maybeUpsertRows.Cast(), ctx, kqpCtx, inputArg, input, newEffect)) { 
+                return false; 
+            } 
+        } 
+ 
         if (auto maybeDeleteRows = effect.Maybe<TKqlDeleteRows>()) {
             if (!BuildDeleteRowsEffect(maybeDeleteRows.Cast(), ctx, kqpCtx, inputArg, input, newEffect)) {
                 return false;
             }
         }
 
-        YQL_ENSURE(newEffect);
-        newEffects.push_back(newEffect.Cast());
-
-        if (input) {
-            inputArgs.push_back(inputArg);
-            inputs.push_back(input.Cast());
-        }
-    }
-
+        YQL_ENSURE(newEffect); 
+        newEffects.push_back(newEffect.Cast()); 
+ 
+        if (input) { 
+            inputArgs.push_back(inputArg); 
+            inputs.push_back(input.Cast()); 
+        } 
+    } 
+ 
     auto stage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(inputs)
-            .Build()
-        .Program()
-            .Args(inputArgs)
-            .Body<TKqpEffects>()
-                .Add(newEffects)
-                .Build()
-            .Build()
+        .Inputs() 
+            .Add(inputs) 
+            .Build() 
+        .Program() 
+            .Args(inputArgs) 
+            .Body<TKqpEffects>() 
+                .Add(newEffects) 
+                .Build() 
+            .Build() 
         .Settings().Build()
-        .Done();
-
-    for (ui32 i = 0; i < newEffects.size(); ++i) {
-        auto effect = Build<TDqOutput>(ctx, pos)
-            .Stage(stage)
+        .Done(); 
+ 
+    for (ui32 i = 0; i < newEffects.size(); ++i) { 
+        auto effect = Build<TDqOutput>(ctx, pos) 
+            .Stage(stage) 
             .Index().Build(ToString(0))
-            .Done();
-
-        builtEffects.push_back(effect);
-    }
-
-    return true;
-}
-
+            .Done(); 
+ 
+        builtEffects.push_back(effect); 
+    } 
+ 
+    return true; 
+} 
+ 
 template <bool GroupEffectsByTable>
-TMaybeNode<TKqlQuery> BuildEffects(const TKqlQuery& query, TExprContext& ctx,
-    const TKqpOptimizeContext& kqpCtx)
-{
+TMaybeNode<TKqlQuery> BuildEffects(const TKqlQuery& query, TExprContext& ctx, 
+    const TKqpOptimizeContext& kqpCtx) 
+{ 
     TVector<TExprBase> builtEffects;
-
+ 
     if constexpr (GroupEffectsByTable) {
         TMap<TStringBuf, TVector<TKqlTableEffect>> tableEffectsMap;
         for (const auto& maybeEffect: query.Effects()) {
@@ -276,7 +276,7 @@ TMaybeNode<TKqlQuery> BuildEffects(const TKqlQuery& query, TExprContext& ctx,
                 for (const auto effect : maybeList.Cast()) {
                     YQL_ENSURE(effect.Maybe<TKqlTableEffect>());
                     auto tableEffect = effect.Cast<TKqlTableEffect>();
-
+ 
                     tableEffectsMap[tableEffect.Table().Path()].push_back(tableEffect);
                 }
             } else {
@@ -285,7 +285,7 @@ TMaybeNode<TKqlQuery> BuildEffects(const TKqlQuery& query, TExprContext& ctx,
 
                 tableEffectsMap[tableEffect.Table().Path()].push_back(tableEffect);
             }
-        }
+        } 
 
         for (const auto& pair: tableEffectsMap) {
             if (!BuildEffects(query.Pos(), pair.second, ctx, kqpCtx, builtEffects)) {
@@ -314,58 +314,58 @@ TMaybeNode<TKqlQuery> BuildEffects(const TKqlQuery& query, TExprContext& ctx,
                 }
             }
         }
-    }
-
-    return Build<TKqlQuery>(ctx, query.Pos())
-        .Results(query.Results())
-        .Effects()
-            .Add(builtEffects)
-            .Build()
-        .Done();
-}
-
-} // namespace
-
-TAutoPtr<IGraphTransformer> CreateKqpQueryEffectsTransformer(const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx) {
-    return CreateFunctorTransformer([kqpCtx](const TExprNode::TPtr& input, TExprNode::TPtr& output,
-        TExprContext& ctx) -> TStatus
-    {
-        output = input;
-
-        TExprBase inputNode(input);
-        YQL_ENSURE(inputNode.Maybe<TKqlQuery>());
-
-        TKqlQuery query = inputNode.Cast<TKqlQuery>();
-
-        bool requireBuild = false;
-        bool hasBuilt = false;
-        for (const auto& effect : query.Effects()) {
-            if (!effect.Maybe<TDqOutput>()) {
-                requireBuild = true;
-            } else {
-                hasBuilt = true;
-            }
-        }
-
-        if (hasBuilt) {
-            YQL_ENSURE(!requireBuild);
-        }
-
-        if (!requireBuild) {
-            return TStatus::Ok;
-        }
-
-        TParentsMap parentsMap;
-        GatherParents(*input, parentsMap);
-
+    } 
+ 
+    return Build<TKqlQuery>(ctx, query.Pos()) 
+        .Results(query.Results()) 
+        .Effects() 
+            .Add(builtEffects) 
+            .Build() 
+        .Done(); 
+} 
+ 
+} // namespace 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpQueryEffectsTransformer(const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx) { 
+    return CreateFunctorTransformer([kqpCtx](const TExprNode::TPtr& input, TExprNode::TPtr& output, 
+        TExprContext& ctx) -> TStatus 
+    { 
+        output = input; 
+ 
+        TExprBase inputNode(input); 
+        YQL_ENSURE(inputNode.Maybe<TKqlQuery>()); 
+ 
+        TKqlQuery query = inputNode.Cast<TKqlQuery>(); 
+ 
+        bool requireBuild = false; 
+        bool hasBuilt = false; 
+        for (const auto& effect : query.Effects()) { 
+            if (!effect.Maybe<TDqOutput>()) { 
+                requireBuild = true; 
+            } else { 
+                hasBuilt = true; 
+            } 
+        } 
+ 
+        if (hasBuilt) { 
+            YQL_ENSURE(!requireBuild); 
+        } 
+ 
+        if (!requireBuild) { 
+            return TStatus::Ok; 
+        } 
+ 
+        TParentsMap parentsMap; 
+        GatherParents(*input, parentsMap); 
+ 
         auto result = BuildEffects<false>(query, ctx, *kqpCtx);
-        if (!result) {
-            return TStatus::Error;
-        }
-
-        output = result.Cast().Ptr();
-        return TStatus(TStatus::Repeat, true);
-    });
-}
-
-} // namespace NKikimr::NKqp::NOpt
+        if (!result) { 
+            return TStatus::Error; 
+        } 
+ 
+        output = result.Cast().Ptr(); 
+        return TStatus(TStatus::Repeat, true); 
+    }); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/kqp_opt_impl.h b/ydb/core/kqp/opt/kqp_opt_impl.h
index 927aa910e8..9f61ad8c3b 100644
--- a/ydb/core/kqp/opt/kqp_opt_impl.h
+++ b/ydb/core/kqp/opt/kqp_opt_impl.h
@@ -1,14 +1,14 @@
-#pragma once
-
-#include "kqp_opt.h"
-
+#pragma once 
+ 
+#include "kqp_opt.h" 
+ 
 #include <ydb/core/kqp/common/kqp_yql.h>
 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 #include <ydb/library/yql/dq/opt/dq_opt.h>
 
-namespace NKikimr::NKqp::NOpt {
-
+namespace NKikimr::NKqp::NOpt { 
+ 
 static inline void DumpAppliedRule(const TString& name, const NYql::TExprNode::TPtr& input,
     const NYql::TExprNode::TPtr& output, NYql::TExprContext& ctx)
 {
@@ -30,26 +30,26 @@ static inline void DumpAppliedRule(const TString& name, const NYql::TExprNode::T
 #endif
 }
 
-bool IsKqpPureLambda(const NYql::NNodes::TCoLambda& lambda);
-
-const NYql::TKikimrTableDescription& GetTableData(const NYql::TKikimrTablesData& tablesData,
-    TStringBuf cluster, TStringBuf table);
-
-NYql::NNodes::TExprBase ProjectColumns(const NYql::NNodes::TExprBase& input, const TVector<TString>& columnNames,
-    NYql::TExprContext& ctx);
-NYql::NNodes::TExprBase ProjectColumns(const NYql::NNodes::TExprBase& input, const THashSet<TStringBuf>& columnNames,
-    NYql::TExprContext& ctx);
-
-NYql::NNodes::TKqpTable BuildTableMeta(const NYql::TKikimrTableDescription& tableDesc,
-    const NYql::TPositionHandle& pos, NYql::TExprContext& ctx);
-NYql::NNodes::TKqpTable BuildTableMeta(const NYql::TKikimrTableMetadata& tableMeta,
-    const NYql::TPositionHandle& pos, NYql::TExprContext& ctx);
-
-NYql::NNodes::TExprBase KqpBuildJoin(const NYql::NNodes::TExprBase& node, NYql::TExprContext& ctx,
-    const TKqpOptimizeContext& kqpCtx, NYql::IOptimizationContext& optCtx, const NYql::TParentsMap& parentsMap,
-    bool allowStageMultiUsage);
+bool IsKqpPureLambda(const NYql::NNodes::TCoLambda& lambda); 
+ 
+const NYql::TKikimrTableDescription& GetTableData(const NYql::TKikimrTablesData& tablesData, 
+    TStringBuf cluster, TStringBuf table); 
+ 
+NYql::NNodes::TExprBase ProjectColumns(const NYql::NNodes::TExprBase& input, const TVector<TString>& columnNames, 
+    NYql::TExprContext& ctx); 
+NYql::NNodes::TExprBase ProjectColumns(const NYql::NNodes::TExprBase& input, const THashSet<TStringBuf>& columnNames, 
+    NYql::TExprContext& ctx); 
+
+NYql::NNodes::TKqpTable BuildTableMeta(const NYql::TKikimrTableDescription& tableDesc, 
+    const NYql::TPositionHandle& pos, NYql::TExprContext& ctx); 
+NYql::NNodes::TKqpTable BuildTableMeta(const NYql::TKikimrTableMetadata& tableMeta, 
+    const NYql::TPositionHandle& pos, NYql::TExprContext& ctx); 
+
+NYql::NNodes::TExprBase KqpBuildJoin(const NYql::NNodes::TExprBase& node, NYql::TExprContext& ctx, 
+    const TKqpOptimizeContext& kqpCtx, NYql::IOptimizationContext& optCtx, const NYql::TParentsMap& parentsMap, 
+    bool allowStageMultiUsage); 
 
 TIntrusivePtr<NYql::TKikimrTableMetadata> GetIndexMetadata(const NYql::NNodes::TKqlReadTableIndex& index,
     const NYql::TKikimrTablesData& tables, TStringBuf cluster);
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/kqp_opt_join.cpp b/ydb/core/kqp/opt/kqp_opt_join.cpp
index 650dc64104..f93bb324de 100644
--- a/ydb/core/kqp/opt/kqp_opt_join.cpp
+++ b/ydb/core/kqp/opt/kqp_opt_join.cpp
@@ -1,10 +1,10 @@
 #include "kqp_opt_impl.h"
 
 #include <ydb/core/kqp/common/kqp_yql.h>
-
+ 
 #include <ydb/library/yql/dq/opt/dq_opt_phy.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NDq;
@@ -40,8 +40,8 @@ bool ValidateJoinInputs(const TExprBase& left, const TExprBase& right, const TPa
 TMaybeNode<TDqJoin> FlipJoin(const TDqJoin& join, TExprContext& ctx) {
     auto joinType = join.JoinType().Value();
 
-    if (joinType == "Inner"sv || joinType == "Full"sv || joinType == "Exclusion"sv || joinType == "Cross"sv) {
-        // pass
+    if (joinType == "Inner"sv || joinType == "Full"sv || joinType == "Exclusion"sv || joinType == "Cross"sv) { 
+        // pass 
     } else if (joinType == "Right"sv) {
         joinType = "Left"sv;
     } else if (joinType == "Left"sv) {
@@ -80,14 +80,14 @@ TMaybeNode<TDqJoin> FlipJoin(const TDqJoin& join, TExprContext& ctx) {
 
 } // anonymous namespace
 
-TExprBase KqpBuildJoin(const TExprBase& node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx,
-    IOptimizationContext& optCtx, const TParentsMap& parentsMap, bool allowStageMultiUsage)
+TExprBase KqpBuildJoin(const TExprBase& node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx, 
+    IOptimizationContext& optCtx, const TParentsMap& parentsMap, bool allowStageMultiUsage) 
 {
-    if (!node.Maybe<TDqJoin>()) {
+    if (!node.Maybe<TDqJoin>()) { 
         return node;
     }
 
-    auto join = node.Cast<TDqJoin>();
+    auto join = node.Cast<TDqJoin>(); 
 
     if (ValidateJoinInputs(join.LeftInput(), join.RightInput(), parentsMap, allowStageMultiUsage)) {
         // pass
@@ -107,12 +107,12 @@ TExprBase KqpBuildJoin(const TExprBase& node, TExprContext& ctx, const TKqpOptim
         return DqBuildJoinDict(join, ctx);
     }
 
-    // NOTE: We don't want to broadcast table data via readsets for data queries, so we need to create a
-    // separate stage to receive data from both sides of join.
-    // TODO: We can push MapJoin to existing stage for data query, if it doesn't have table reads. This
+    // NOTE: We don't want to broadcast table data via readsets for data queries, so we need to create a 
+    // separate stage to receive data from both sides of join. 
+    // TODO: We can push MapJoin to existing stage for data query, if it doesn't have table reads. This 
     //       requires some additional knowledge, probably with use of constraints.
-    bool pushLeftStage = !kqpCtx.IsDataQuery();
+    bool pushLeftStage = !kqpCtx.IsDataQuery(); 
     return DqBuildPhyJoin(join, pushLeftStage, ctx, optCtx);
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/kqp_opt_kql.cpp b/ydb/core/kqp/opt/kqp_opt_kql.cpp
index 1eeb95daee..46384f113e 100644
--- a/ydb/core/kqp/opt/kqp_opt_kql.cpp
+++ b/ydb/core/kqp/opt/kqp_opt_kql.cpp
@@ -1,17 +1,17 @@
-#include "kqp_opt_impl.h"
-
+#include "kqp_opt_impl.h" 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
 #include <ydb/core/kqp/provider/kqp_opt_helpers.h>
-
+ 
 #include <ydb/library/yql/core/yql_opt_utils.h>
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-
-namespace {
-
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
 bool UseReadTableRanges(const TKikimrTableDescription& tableData, const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx) {
     /*
      * OLAP tables can not work with ordinary ReadTable in case there is no support in physical
@@ -35,31 +35,31 @@ bool UseReadTableRanges(const TKikimrTableDescription& tableData, const TIntrusi
         return false;
     }
 
-    if (kqpCtx->IsScanQuery() && kqpCtx->Config->FeatureFlags.GetEnablePredicateExtractForScanQueries()) {
+    if (kqpCtx->IsScanQuery() && kqpCtx->Config->FeatureFlags.GetEnablePredicateExtractForScanQueries()) { 
         return true;
     }
 
     return false;
 }
 
-bool HasIndexesToWrite(const TKikimrTableDescription& tableData) {
-    bool hasIndexesToWrite = false;
-    YQL_ENSURE(tableData.Metadata->Indexes.size() == tableData.Metadata->SecondaryGlobalIndexMetadata.size());
-    for (const auto& index : tableData.Metadata->Indexes) {
-        if (index.ItUsedForWrite()) {
-            hasIndexesToWrite = true;
-            break;
-        }
-    }
-
-    return hasIndexesToWrite;
-}
-
-TExprBase BuildReadTable(const TKiReadTable& read, const TKikimrTableDescription& tableData,
+bool HasIndexesToWrite(const TKikimrTableDescription& tableData) { 
+    bool hasIndexesToWrite = false; 
+    YQL_ENSURE(tableData.Metadata->Indexes.size() == tableData.Metadata->SecondaryGlobalIndexMetadata.size()); 
+    for (const auto& index : tableData.Metadata->Indexes) { 
+        if (index.ItUsedForWrite()) { 
+            hasIndexesToWrite = true; 
+            break; 
+        } 
+    } 
+ 
+    return hasIndexesToWrite; 
+} 
+ 
+TExprBase BuildReadTable(const TKiReadTable& read, const TKikimrTableDescription& tableData, 
     bool withSystemColumns, TExprContext& ctx, const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx)
-{
+{ 
     bool unwrapValues = HasSetting(read.Settings().Ref(), "unwrap_values");
-
+ 
     TExprNode::TPtr readTable;
     const auto& columns = read.GetSelectColumns(ctx, tableData, withSystemColumns);
     const auto& tableMeta = BuildTableMeta(tableData, read.Pos(), ctx);
@@ -83,20 +83,20 @@ TExprBase BuildReadTable(const TKiReadTable& read, const TKikimrTableDescription
                     .Build()
                 .To<TKqlKeyInc>()
                     .Build()
-                .Build()
+                .Build() 
             .Columns(columns)
             .Settings()
-                .Build()
+                .Build() 
             .Done().Ptr();
     }
-
+ 
     auto readNode = TExprBase(readTable);
 
-    return unwrapValues
+    return unwrapValues 
         ? UnwrapKiReadTableValues(readNode, tableData, columns, ctx)
         : readNode;
-}
-
+} 
+ 
 TExprBase BuildReadTableIndex(const TKiReadTable& read, const TKikimrTableDescription& tableData,
     const TString& indexName, bool withSystemColumns, TExprContext& ctx)
 {
@@ -121,56 +121,56 @@ TExprBase BuildReadTableIndex(const TKiReadTable& read, const TKikimrTableDescri
         : kqlReadTable;
 }
 
-TExprBase BuildUpsertTable(const TKiWriteTable& write, const TCoAtomList& inputColumns,
-    const TKikimrTableDescription& tableData, TExprContext& ctx)
-{
-    auto effect = Build<TKqlUpsertRows>(ctx, write.Pos())
-        .Table(BuildTableMeta(tableData, write.Pos(), ctx))
-        .Input(write.Input())
-        .Columns(inputColumns)
-        .Done();
-
-    return effect;
-}
-
+TExprBase BuildUpsertTable(const TKiWriteTable& write, const TCoAtomList& inputColumns, 
+    const TKikimrTableDescription& tableData, TExprContext& ctx) 
+{ 
+    auto effect = Build<TKqlUpsertRows>(ctx, write.Pos()) 
+        .Table(BuildTableMeta(tableData, write.Pos(), ctx)) 
+        .Input(write.Input()) 
+        .Columns(inputColumns) 
+        .Done(); 
+ 
+    return effect; 
+} 
+ 
 TExprBase BuildUpsertTableWithIndex(const TKiWriteTable& write, const TCoAtomList& inputColumns,
-    const TKikimrTableDescription& tableData, TExprContext& ctx)
-{
+    const TKikimrTableDescription& tableData, TExprContext& ctx) 
+{ 
     auto effect = Build<TKqlUpsertRowsIndex>(ctx, write.Pos())
         .Table(BuildTableMeta(tableData, write.Pos(), ctx))
         .Input(write.Input())
         .Columns(inputColumns)
-        .Done();
-
+        .Done(); 
+ 
     return effect;
 }
-
+ 
 TExprBase BuildReplaceTable(const TKiWriteTable& write, const TCoAtomList& inputColumns,
     const TKikimrTableDescription& tableData, TExprContext& ctx)
 {
     const auto [data, columns] = CreateRowsToReplace(write.Input(), inputColumns, tableData, write.Pos(), ctx);
-
+ 
     return Build<TKqlUpsertRows>(ctx, write.Pos())
         .Table(BuildTableMeta(tableData, write.Pos(), ctx))
         .Input(data)
         .Columns(columns)
-        .Done();
+        .Done(); 
 }
-
+ 
 TExprBase BuildReplaceTableWithIndex(const TKiWriteTable& write, const TCoAtomList& inputColumns,
     const TKikimrTableDescription& tableData, TExprContext& ctx)
 {
-    const auto [data, columns] = CreateRowsToReplace(write.Input(), inputColumns, tableData, write.Pos(), ctx);
-
-    auto effect = Build<TKqlUpsertRowsIndex>(ctx, write.Pos())
-        .Table(BuildTableMeta(tableData, write.Pos(), ctx))
-        .Input(data)
-        .Columns(columns)
-        .Done();
-
-    return effect;
-}
-
+    const auto [data, columns] = CreateRowsToReplace(write.Input(), inputColumns, tableData, write.Pos(), ctx); 
+ 
+    auto effect = Build<TKqlUpsertRowsIndex>(ctx, write.Pos()) 
+        .Table(BuildTableMeta(tableData, write.Pos(), ctx)) 
+        .Input(data) 
+        .Columns(columns) 
+        .Done(); 
+ 
+    return effect; 
+} 
+ 
 TExprBase BuildInsertTable(const TKiWriteTable& write, bool abort, const TCoAtomList& inputColumns,
     const TKikimrTableDescription& tableData, TExprContext& ctx)
 {
@@ -239,13 +239,13 @@ TExprBase BuildDeleteTableWithIndex(const TKiWriteTable& write, const TKikimrTab
         .Done();
 }
 
-TExprBase BuildRowsToDelete(const TKikimrTableDescription& tableData, bool withSystemColumns, const TCoLambda& filter,
-    const TPositionHandle pos, TExprContext& ctx)
+TExprBase BuildRowsToDelete(const TKikimrTableDescription& tableData, bool withSystemColumns, const TCoLambda& filter, 
+    const TPositionHandle pos, TExprContext& ctx) 
 {
-    const auto tableMeta = BuildTableMeta(tableData, pos, ctx);
-    const auto tableColumns = BuildColumnsList(tableData, pos, ctx, withSystemColumns);
+    const auto tableMeta = BuildTableMeta(tableData, pos, ctx); 
+    const auto tableColumns = BuildColumnsList(tableData, pos, ctx, withSystemColumns); 
 
-    const auto allRows = Build<TKqlReadTable>(ctx, pos)
+    const auto allRows = Build<TKqlReadTable>(ctx, pos) 
         .Table(tableMeta)
         .Range()
             .From<TKqlKeyInc>()
@@ -253,283 +253,283 @@ TExprBase BuildRowsToDelete(const TKikimrTableDescription& tableData, bool withS
             .To<TKqlKeyInc>()
                 .Build()
             .Build()
-        .Columns(tableColumns)
+        .Columns(tableColumns) 
         .Settings()
             .Build()
         .Done();
 
-    return Build<TCoFilter>(ctx, pos)
+    return Build<TCoFilter>(ctx, pos) 
         .Input(allRows)
-        .Lambda(filter)
+        .Lambda(filter) 
         .Done();
-}
+} 
 
-TExprBase BuildDeleteTable(const TKiDeleteTable& del, const TKikimrTableDescription& tableData, bool withSystemColumns,
-    TExprContext& ctx)
-{
-    auto rowsToDelete = BuildRowsToDelete(tableData, withSystemColumns, del.Filter(), del.Pos(), ctx);
-    auto keysToDelete = ProjectColumns(rowsToDelete, tableData.Metadata->KeyColumnNames, ctx);
+TExprBase BuildDeleteTable(const TKiDeleteTable& del, const TKikimrTableDescription& tableData, bool withSystemColumns, 
+    TExprContext& ctx) 
+{ 
+    auto rowsToDelete = BuildRowsToDelete(tableData, withSystemColumns, del.Filter(), del.Pos(), ctx); 
+    auto keysToDelete = ProjectColumns(rowsToDelete, tableData.Metadata->KeyColumnNames, ctx); 
 
-    return Build<TKqlDeleteRows>(ctx, del.Pos())
-        .Table(BuildTableMeta(tableData, del.Pos(), ctx))
+    return Build<TKqlDeleteRows>(ctx, del.Pos()) 
+        .Table(BuildTableMeta(tableData, del.Pos(), ctx)) 
         .Input(keysToDelete)
         .Done();
 }
 
-TVector<TExprBase> BuildDeleteTableWithIndex(const TKiDeleteTable& del, const TKikimrTableDescription& tableData,
+TVector<TExprBase> BuildDeleteTableWithIndex(const TKiDeleteTable& del, const TKikimrTableDescription& tableData, 
     bool withSystemColumns, TExprContext& ctx)
-{
-    auto rowsToDelete = BuildRowsToDelete(tableData, withSystemColumns, del.Filter(), del.Pos(), ctx);
-
-    auto indexes = BuildSecondaryIndexVector(tableData, del.Pos(), ctx, nullptr,
-        [] (const TKikimrTableMetadata& meta, TPositionHandle pos, TExprContext& ctx) -> TExprBase {
-            return BuildTableMeta(meta, pos, ctx);
-        });
-    YQL_ENSURE(indexes);
-
-    const auto& pk = tableData.Metadata->KeyColumnNames;
-
-    auto tableDelete = Build<TKqlDeleteRows>(ctx, del.Pos())
-        .Table(BuildTableMeta(tableData, del.Pos(), ctx))
-        .Input(ProjectColumns(rowsToDelete, pk, ctx))
-        .Done();
-
-    TVector<TExprBase> effects;
-    effects.push_back(tableDelete);
-
-    for (const auto& [indexMeta, indexDesc] : indexes) {
-        THashSet<TStringBuf> indexTableColumns;
-
-        THashSet<TString> keyColumns;
-        for (const auto& column : indexDesc->KeyColumns) {
-            YQL_ENSURE(keyColumns.emplace(column).second);
-            indexTableColumns.emplace(column);
-        }
-
-        for (const auto& column : pk) {
-            if (keyColumns.insert(column).second) {
-                indexTableColumns.emplace(column);
-            }
-        }
-
-        auto indexDelete = Build<TKqlDeleteRows>(ctx, del.Pos())
-            .Table(indexMeta)
-            .Input(ProjectColumns(rowsToDelete, indexTableColumns, ctx))
-            .Done();
-
-        effects.push_back(indexDelete);
-    }
-
-    return effects;
-}
-
-TExprBase BuildRowsToUpdate(const TKikimrTableDescription& tableData, bool withSystemColumns, const TCoLambda& filter,
-    const TPositionHandle pos, TExprContext& ctx)
-{
-    auto kqlReadTable = Build<TKqlReadTable>(ctx, pos)
-        .Table(BuildTableMeta(tableData, pos, ctx))
-        .Range()
-            .From<TKqlKeyInc>()
-                .Build()
-            .To<TKqlKeyInc>()
-                .Build()
-            .Build()
-        .Columns(BuildColumnsList(tableData, pos, ctx, withSystemColumns))
+{ 
+    auto rowsToDelete = BuildRowsToDelete(tableData, withSystemColumns, del.Filter(), del.Pos(), ctx); 
+ 
+    auto indexes = BuildSecondaryIndexVector(tableData, del.Pos(), ctx, nullptr, 
+        [] (const TKikimrTableMetadata& meta, TPositionHandle pos, TExprContext& ctx) -> TExprBase { 
+            return BuildTableMeta(meta, pos, ctx); 
+        }); 
+    YQL_ENSURE(indexes); 
+ 
+    const auto& pk = tableData.Metadata->KeyColumnNames; 
+ 
+    auto tableDelete = Build<TKqlDeleteRows>(ctx, del.Pos()) 
+        .Table(BuildTableMeta(tableData, del.Pos(), ctx)) 
+        .Input(ProjectColumns(rowsToDelete, pk, ctx)) 
+        .Done(); 
+ 
+    TVector<TExprBase> effects; 
+    effects.push_back(tableDelete); 
+ 
+    for (const auto& [indexMeta, indexDesc] : indexes) { 
+        THashSet<TStringBuf> indexTableColumns; 
+ 
+        THashSet<TString> keyColumns; 
+        for (const auto& column : indexDesc->KeyColumns) { 
+            YQL_ENSURE(keyColumns.emplace(column).second); 
+            indexTableColumns.emplace(column); 
+        } 
+ 
+        for (const auto& column : pk) { 
+            if (keyColumns.insert(column).second) { 
+                indexTableColumns.emplace(column); 
+            } 
+        } 
+ 
+        auto indexDelete = Build<TKqlDeleteRows>(ctx, del.Pos()) 
+            .Table(indexMeta) 
+            .Input(ProjectColumns(rowsToDelete, indexTableColumns, ctx)) 
+            .Done(); 
+ 
+        effects.push_back(indexDelete); 
+    } 
+ 
+    return effects; 
+} 
+ 
+TExprBase BuildRowsToUpdate(const TKikimrTableDescription& tableData, bool withSystemColumns, const TCoLambda& filter, 
+    const TPositionHandle pos, TExprContext& ctx) 
+{ 
+    auto kqlReadTable = Build<TKqlReadTable>(ctx, pos) 
+        .Table(BuildTableMeta(tableData, pos, ctx)) 
+        .Range() 
+            .From<TKqlKeyInc>() 
+                .Build() 
+            .To<TKqlKeyInc>() 
+                .Build() 
+            .Build() 
+        .Columns(BuildColumnsList(tableData, pos, ctx, withSystemColumns)) 
         .Settings()
             .Build()
-        .Done();
-
-    return Build<TCoFilter>(ctx, pos)
-        .Input(kqlReadTable)
-        .Lambda(filter)
-        .Done();
-}
-
-TExprBase BuildUpdatedRows(const TExprBase& rows, const TCoLambda& update, const THashSet<TStringBuf>& columns,
-    const TPositionHandle pos, TExprContext& ctx) {
-    auto rowArg = Build<TCoArgument>(ctx, pos)
-        .Name("row")
-        .Done();
-
-    auto updateStruct = Build<TExprApplier>(ctx, pos)
-        .Apply(update)
-        .With(0, rowArg)
-        .Done();
-
-    const auto& updateStructType = update.Ref().GetTypeAnn()->Cast<TStructExprType>();
-    TVector<TExprBase> updateTuples;
-    for (const auto& column : columns) {
-        TCoAtom columnAtom(ctx.NewAtom(pos, column));
-
-        TExprBase valueSource = updateStructType->FindItem(column)
-            ? updateStruct
-            : TExprBase(rowArg);
-
-        auto tuple = Build<TCoNameValueTuple>(ctx, pos)
-            .Name(columnAtom)
-            .Value<TCoMember>()
-                .Struct(valueSource)
-                .Name(columnAtom)
-                .Build()
-            .Done();
-
-        updateTuples.push_back(tuple);
-    }
-
-    return Build<TCoMap>(ctx, pos)
-        .Input(rows)
-        .Lambda()
-            .Args({rowArg})
-            .Body<TCoAsStruct>()
-                .Add(updateTuples)
-                .Build()
-            .Build()
-        .Done();
-}
-
-THashSet<TStringBuf> GetUpdateColumns(const TKikimrTableDescription& tableData, const TCoLambda& update) {
-    THashSet<TStringBuf> updateColumns;
-    for (const auto& keyColumn : tableData.Metadata->KeyColumnNames) {
-        updateColumns.emplace(keyColumn);
-    }
-
-    const auto& updateStructType = update.Ref().GetTypeAnn()->Cast<TStructExprType>();
-    for (const auto& item : updateStructType->GetItems()) {
-        updateColumns.emplace(item->GetName());
-    }
-
-    return updateColumns;
-}
-
-TExprBase BuildUpdateTable(const TKiUpdateTable& update, const TKikimrTableDescription& tableData,
-    bool withSystemColumns, TExprContext& ctx)
-{
-    auto rowsToUpdate = BuildRowsToUpdate(tableData, withSystemColumns, update.Filter(), update.Pos(), ctx);
-
-    auto updateColumns = GetUpdateColumns(tableData, update.Update());
-    auto updatedRows = BuildUpdatedRows(rowsToUpdate, update.Update(), updateColumns, update.Pos(), ctx);
-
-    TVector<TCoAtom> updateColumnsList;
-    for (const auto& column : updateColumns) {
-        updateColumnsList.push_back(TCoAtom(ctx.NewAtom(update.Pos(), column)));
-    }
-
-    return Build<TKqlUpsertRows>(ctx, update.Pos())
-        .Table(BuildTableMeta(tableData, update.Pos(), ctx))
-        .Input(updatedRows)
-        .Columns()
-            .Add(updateColumnsList)
-            .Build()
-        .Done();
-}
-
-TVector<TExprBase> BuildUpdateTableWithIndex(const TKiUpdateTable& update, const TKikimrTableDescription& tableData,
-    bool withSystemColumns, TExprContext& ctx)
-{
-    auto rowsToUpdate = BuildRowsToUpdate(tableData, withSystemColumns, update.Filter(), update.Pos(), ctx);
-
-    auto indexes = BuildSecondaryIndexVector(tableData, update.Pos(), ctx, nullptr,
-        [] (const TKikimrTableMetadata& meta, TPositionHandle pos, TExprContext& ctx) -> TExprBase {
-            return BuildTableMeta(meta, pos, ctx);
-        });
-    YQL_ENSURE(indexes);
-
-    const auto& pk = tableData.Metadata->KeyColumnNames;
-    auto updateColumns = GetUpdateColumns(tableData, update.Update());
-
-    auto updatedRows = BuildUpdatedRows(rowsToUpdate, update.Update(), updateColumns, update.Pos(), ctx);
-
-    TVector<TCoAtom> updateColumnsList;
-    for (const auto& column : updateColumns) {
-        updateColumnsList.push_back(TCoAtom(ctx.NewAtom(update.Pos(), column)));
-    }
-
-    auto tableUpsert = Build<TKqlUpsertRows>(ctx, update.Pos())
-        .Table(BuildTableMeta(tableData, update.Pos(), ctx))
-        .Input(updatedRows)
-        .Columns()
-            .Add(updateColumnsList)
-            .Build()
-        .Done();
-
-    TVector<TExprBase> effects;
-    effects.push_back(tableUpsert);
-
-    for (const auto& [indexMeta, indexDesc] : indexes) {
-        THashSet<TStringBuf> indexTableColumns;
-
-        bool indexKeyColumnsUpdated = false;
-        THashSet<TString> keyColumns;
-        for (const auto& column : indexDesc->KeyColumns) {
-            YQL_ENSURE(keyColumns.emplace(column).second);
-
-            // Check if user specified one of index columns - can't skip index update in this case
-            if (updateColumns.contains(column)) {
-                indexKeyColumnsUpdated = true;
-            }
-
-            indexTableColumns.emplace(column);
-        }
-
-        for (const auto& column : pk) {
-            if (keyColumns.insert(column).second) {
-                indexTableColumns.emplace(column);
-            }
-        }
-
-        if (indexKeyColumnsUpdated) {
-            // Have to delete old index value from index table in case when index key columns were updated
-            auto indexDelete = Build<TKqlDeleteRows>(ctx, update.Pos())
-                .Table(indexMeta)
-                .Input(ProjectColumns(rowsToUpdate, indexTableColumns, ctx))
-                .Done();
-
-            effects.push_back(indexDelete);
-        }
-
-        bool indexDataColumnsUpdated = false;
-        for (const auto& column : indexDesc->DataColumns) {
-            if (updateColumns.contains(column)) {
-                indexDataColumnsUpdated = true;
-            }
-
-            indexTableColumns.emplace(column);
-        }
-
-        // Index table update required in case when index key or data columns were updated
-        bool needIndexTableUpdate = indexKeyColumnsUpdated || indexDataColumnsUpdated;
-
-        if (needIndexTableUpdate) {
-            auto indexRows = BuildUpdatedRows(rowsToUpdate, update.Update(), indexTableColumns, update.Pos(), ctx);
-
-            TVector<TCoAtom> indexColumnsList;
-            for (const auto& column : indexTableColumns) {
-                indexColumnsList.push_back(TCoAtom(ctx.NewAtom(update.Pos(), column)));
-            }
-
-            auto indexUpsert = Build<TKqlUpsertRows>(ctx, update.Pos())
-                .Table(indexMeta)
-                .Input(indexRows)
-                .Columns()
-                    .Add(indexColumnsList)
-                    .Build()
-                .Done();
-
-            effects.push_back(indexUpsert);
-        }
-    }
-
-    return effects;
-}
-
+        .Done(); 
+ 
+    return Build<TCoFilter>(ctx, pos) 
+        .Input(kqlReadTable) 
+        .Lambda(filter) 
+        .Done(); 
+} 
+ 
+TExprBase BuildUpdatedRows(const TExprBase& rows, const TCoLambda& update, const THashSet<TStringBuf>& columns, 
+    const TPositionHandle pos, TExprContext& ctx) { 
+    auto rowArg = Build<TCoArgument>(ctx, pos) 
+        .Name("row") 
+        .Done(); 
+ 
+    auto updateStruct = Build<TExprApplier>(ctx, pos) 
+        .Apply(update) 
+        .With(0, rowArg) 
+        .Done(); 
+ 
+    const auto& updateStructType = update.Ref().GetTypeAnn()->Cast<TStructExprType>(); 
+    TVector<TExprBase> updateTuples; 
+    for (const auto& column : columns) { 
+        TCoAtom columnAtom(ctx.NewAtom(pos, column)); 
+ 
+        TExprBase valueSource = updateStructType->FindItem(column) 
+            ? updateStruct 
+            : TExprBase(rowArg); 
+ 
+        auto tuple = Build<TCoNameValueTuple>(ctx, pos) 
+            .Name(columnAtom) 
+            .Value<TCoMember>() 
+                .Struct(valueSource) 
+                .Name(columnAtom) 
+                .Build() 
+            .Done(); 
+ 
+        updateTuples.push_back(tuple); 
+    } 
+ 
+    return Build<TCoMap>(ctx, pos) 
+        .Input(rows) 
+        .Lambda() 
+            .Args({rowArg}) 
+            .Body<TCoAsStruct>() 
+                .Add(updateTuples) 
+                .Build() 
+            .Build() 
+        .Done(); 
+} 
+ 
+THashSet<TStringBuf> GetUpdateColumns(const TKikimrTableDescription& tableData, const TCoLambda& update) { 
+    THashSet<TStringBuf> updateColumns; 
+    for (const auto& keyColumn : tableData.Metadata->KeyColumnNames) { 
+        updateColumns.emplace(keyColumn); 
+    } 
+ 
+    const auto& updateStructType = update.Ref().GetTypeAnn()->Cast<TStructExprType>(); 
+    for (const auto& item : updateStructType->GetItems()) { 
+        updateColumns.emplace(item->GetName()); 
+    } 
+ 
+    return updateColumns; 
+} 
+ 
+TExprBase BuildUpdateTable(const TKiUpdateTable& update, const TKikimrTableDescription& tableData, 
+    bool withSystemColumns, TExprContext& ctx) 
+{ 
+    auto rowsToUpdate = BuildRowsToUpdate(tableData, withSystemColumns, update.Filter(), update.Pos(), ctx); 
+ 
+    auto updateColumns = GetUpdateColumns(tableData, update.Update()); 
+    auto updatedRows = BuildUpdatedRows(rowsToUpdate, update.Update(), updateColumns, update.Pos(), ctx); 
+ 
+    TVector<TCoAtom> updateColumnsList; 
+    for (const auto& column : updateColumns) { 
+        updateColumnsList.push_back(TCoAtom(ctx.NewAtom(update.Pos(), column))); 
+    } 
+ 
+    return Build<TKqlUpsertRows>(ctx, update.Pos()) 
+        .Table(BuildTableMeta(tableData, update.Pos(), ctx)) 
+        .Input(updatedRows) 
+        .Columns() 
+            .Add(updateColumnsList) 
+            .Build() 
+        .Done(); 
+} 
+ 
+TVector<TExprBase> BuildUpdateTableWithIndex(const TKiUpdateTable& update, const TKikimrTableDescription& tableData, 
+    bool withSystemColumns, TExprContext& ctx) 
+{ 
+    auto rowsToUpdate = BuildRowsToUpdate(tableData, withSystemColumns, update.Filter(), update.Pos(), ctx); 
+ 
+    auto indexes = BuildSecondaryIndexVector(tableData, update.Pos(), ctx, nullptr, 
+        [] (const TKikimrTableMetadata& meta, TPositionHandle pos, TExprContext& ctx) -> TExprBase { 
+            return BuildTableMeta(meta, pos, ctx); 
+        }); 
+    YQL_ENSURE(indexes); 
+ 
+    const auto& pk = tableData.Metadata->KeyColumnNames; 
+    auto updateColumns = GetUpdateColumns(tableData, update.Update()); 
+ 
+    auto updatedRows = BuildUpdatedRows(rowsToUpdate, update.Update(), updateColumns, update.Pos(), ctx); 
+ 
+    TVector<TCoAtom> updateColumnsList; 
+    for (const auto& column : updateColumns) { 
+        updateColumnsList.push_back(TCoAtom(ctx.NewAtom(update.Pos(), column))); 
+    } 
+ 
+    auto tableUpsert = Build<TKqlUpsertRows>(ctx, update.Pos()) 
+        .Table(BuildTableMeta(tableData, update.Pos(), ctx)) 
+        .Input(updatedRows) 
+        .Columns() 
+            .Add(updateColumnsList) 
+            .Build() 
+        .Done(); 
+ 
+    TVector<TExprBase> effects; 
+    effects.push_back(tableUpsert); 
+ 
+    for (const auto& [indexMeta, indexDesc] : indexes) { 
+        THashSet<TStringBuf> indexTableColumns; 
+ 
+        bool indexKeyColumnsUpdated = false; 
+        THashSet<TString> keyColumns; 
+        for (const auto& column : indexDesc->KeyColumns) { 
+            YQL_ENSURE(keyColumns.emplace(column).second); 
+ 
+            // Check if user specified one of index columns - can't skip index update in this case 
+            if (updateColumns.contains(column)) { 
+                indexKeyColumnsUpdated = true; 
+            } 
+ 
+            indexTableColumns.emplace(column); 
+        } 
+ 
+        for (const auto& column : pk) { 
+            if (keyColumns.insert(column).second) { 
+                indexTableColumns.emplace(column); 
+            } 
+        } 
+ 
+        if (indexKeyColumnsUpdated) { 
+            // Have to delete old index value from index table in case when index key columns were updated 
+            auto indexDelete = Build<TKqlDeleteRows>(ctx, update.Pos()) 
+                .Table(indexMeta) 
+                .Input(ProjectColumns(rowsToUpdate, indexTableColumns, ctx)) 
+                .Done(); 
+ 
+            effects.push_back(indexDelete); 
+        } 
+ 
+        bool indexDataColumnsUpdated = false; 
+        for (const auto& column : indexDesc->DataColumns) { 
+            if (updateColumns.contains(column)) { 
+                indexDataColumnsUpdated = true; 
+            } 
+ 
+            indexTableColumns.emplace(column); 
+        } 
+ 
+        // Index table update required in case when index key or data columns were updated 
+        bool needIndexTableUpdate = indexKeyColumnsUpdated || indexDataColumnsUpdated; 
+ 
+        if (needIndexTableUpdate) { 
+            auto indexRows = BuildUpdatedRows(rowsToUpdate, update.Update(), indexTableColumns, update.Pos(), ctx); 
+ 
+            TVector<TCoAtom> indexColumnsList; 
+            for (const auto& column : indexTableColumns) { 
+                indexColumnsList.push_back(TCoAtom(ctx.NewAtom(update.Pos(), column))); 
+            } 
+ 
+            auto indexUpsert = Build<TKqlUpsertRows>(ctx, update.Pos()) 
+                .Table(indexMeta) 
+                .Input(indexRows) 
+                .Columns() 
+                    .Add(indexColumnsList) 
+                    .Build() 
+                .Done(); 
+ 
+            effects.push_back(indexUpsert); 
+        } 
+    } 
+ 
+    return effects; 
+} 
+ 
 TExprNode::TPtr HandleReadTable(const TKiReadTable& read, TExprContext& ctx, const TKikimrTablesData& tablesData,
     bool withSystemColumns, const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx)
-{
-    TKikimrKey key(ctx);
-    YQL_ENSURE(key.Extract(read.TableKey().Ref()));
-    YQL_ENSURE(key.GetKeyType() == TKikimrKey::Type::Table);
-    auto& tableData = GetTableData(tablesData, read.DataSource().Cluster(), key.GetTablePath());
-
+{ 
+    TKikimrKey key(ctx); 
+    YQL_ENSURE(key.Extract(read.TableKey().Ref())); 
+    YQL_ENSURE(key.GetKeyType() == TKikimrKey::Type::Table); 
+    auto& tableData = GetTableData(tablesData, read.DataSource().Cluster(), key.GetTablePath()); 
+ 
     if (key.GetView()) {
         const auto& indexName = key.GetView().GetRef();
         if (!ValidateTableHasIndex(tableData.Metadata, ctx, read.Pos())) {
@@ -559,17 +559,17 @@ TExprNode::TPtr HandleReadTable(const TKiReadTable& read, TExprContext& ctx, con
     }
 
     return BuildReadTable(read, tableData, withSystemColumns, ctx, kqpCtx).Ptr();
-}
-
+} 
+ 
 TExprBase WriteTableSimple(const TKiWriteTable& write, const TCoAtomList& inputColumns,
     const TKikimrTableDescription& tableData, TExprContext& ctx)
 {
-    auto op = GetTableOp(write);
-    switch (op) {
+    auto op = GetTableOp(write); 
+    switch (op) { 
         case TYdbOperation::Upsert:
-            return BuildUpsertTable(write, inputColumns, tableData, ctx);
+            return BuildUpsertTable(write, inputColumns, tableData, ctx); 
         case TYdbOperation::Replace:
-            return BuildReplaceTable(write, inputColumns, tableData, ctx);
+            return BuildReplaceTable(write, inputColumns, tableData, ctx); 
         case TYdbOperation::InsertAbort:
         case TYdbOperation::InsertRevert:
             return BuildInsertTable(write, op == TYdbOperation::InsertAbort, inputColumns, tableData, ctx);
@@ -579,11 +579,11 @@ TExprBase WriteTableSimple(const TKiWriteTable& write, const TCoAtomList& inputC
             return BuildDeleteTable(write, tableData, ctx);
         case TYdbOperation::DeleteOn:
             return BuildDeleteTable(write, tableData, ctx);
-        default:
+        default: 
             YQL_ENSURE(false, "Unsupported table operation: " << op << ", table: " << tableData.Metadata->Name);
-    }
-}
-
+    } 
+} 
+ 
 TExprBase WriteTableWithIndexUpdate(const TKiWriteTable& write, const TCoAtomList& inputColumns,
     const TKikimrTableDescription& tableData, TExprContext& ctx)
 {
@@ -614,118 +614,118 @@ TExprBase HandleWriteTable(const TKiWriteTable& write, TExprContext& ctx, const
     YQL_ENSURE(inputColumnsSetting);
     auto inputColumns = TCoNameValueTuple(inputColumnsSetting).Value().Cast<TCoAtomList>();
 
-    if (HasIndexesToWrite(tableData)) {
+    if (HasIndexesToWrite(tableData)) { 
         return WriteTableWithIndexUpdate(write, inputColumns, tableData, ctx);
     } else {
         return WriteTableSimple(write, inputColumns, tableData, ctx);
     }
 }
 
-TVector<TExprBase> HandleUpdateTable(const TKiUpdateTable& update, TExprContext& ctx,
-    const TKikimrTablesData& tablesData, bool withSystemColumns)
+TVector<TExprBase> HandleUpdateTable(const TKiUpdateTable& update, TExprContext& ctx, 
+    const TKikimrTablesData& tablesData, bool withSystemColumns) 
 {
     const auto& tableData = GetTableData(tablesData, update.DataSink().Cluster(), update.Table().Value());
-
-    if (HasIndexesToWrite(tableData)) {
-        return BuildUpdateTableWithIndex(update, tableData, withSystemColumns, ctx);
-    } else {
-        return { BuildUpdateTable(update, tableData, withSystemColumns, ctx) };
+ 
+    if (HasIndexesToWrite(tableData)) { 
+        return BuildUpdateTableWithIndex(update, tableData, withSystemColumns, ctx); 
+    } else { 
+        return { BuildUpdateTable(update, tableData, withSystemColumns, ctx) }; 
     }
-}
-
-TVector<TExprBase> HandleDeleteTable(const TKiDeleteTable& del, TExprContext& ctx, const TKikimrTablesData& tablesData,
+} 
+ 
+TVector<TExprBase> HandleDeleteTable(const TKiDeleteTable& del, TExprContext& ctx, const TKikimrTablesData& tablesData, 
     bool withSystemColumns)
 {
     auto& tableData = GetTableData(tablesData, del.DataSink().Cluster(), del.Table().Value());
-    if (HasIndexesToWrite(tableData)) {
-        return BuildDeleteTableWithIndex(del, tableData, withSystemColumns, ctx);
-    } else {
-        return { BuildDeleteTable(del, tableData, withSystemColumns, ctx) };
+    if (HasIndexesToWrite(tableData)) { 
+        return BuildDeleteTableWithIndex(del, tableData, withSystemColumns, ctx); 
+    } else { 
+        return { BuildDeleteTable(del, tableData, withSystemColumns, ctx) }; 
     }
-}
-
-} // namespace
-
-const TKikimrTableDescription& GetTableData(const TKikimrTablesData& tablesData,
-    TStringBuf cluster, TStringBuf table)
-{
-    const auto& tableData = tablesData.ExistingTable(cluster, table);
-    YQL_ENSURE(tableData.Metadata);
-
-    return tableData;
-}
-
-TIntrusivePtr<TKikimrTableMetadata> GetIndexMetadata(const TKqlReadTableIndex& read,
-    const TKikimrTablesData& tables, TStringBuf cluster)
-{
-    const auto& tableDesc = GetTableData(tables, cluster, read.Table().Path());
-    const auto& [indexMeta, _ ] = tableDesc.Metadata->GetIndexMetadata(read.Index().StringValue());
-    return indexMeta;
-}
-
+} 
+ 
+} // namespace 
+ 
+const TKikimrTableDescription& GetTableData(const TKikimrTablesData& tablesData, 
+    TStringBuf cluster, TStringBuf table) 
+{ 
+    const auto& tableData = tablesData.ExistingTable(cluster, table); 
+    YQL_ENSURE(tableData.Metadata); 
+ 
+    return tableData; 
+} 
+ 
+TIntrusivePtr<TKikimrTableMetadata> GetIndexMetadata(const TKqlReadTableIndex& read, 
+    const TKikimrTablesData& tables, TStringBuf cluster) 
+{ 
+    const auto& tableDesc = GetTableData(tables, cluster, read.Table().Path()); 
+    const auto& [indexMeta, _ ] = tableDesc.Metadata->GetIndexMetadata(read.Index().StringValue()); 
+    return indexMeta; 
+} 
+ 
 TMaybe<TKqlQuery> BuildKqlQuery(TKiDataQuery query, const TKikimrTablesData& tablesData, TExprContext& ctx,
     bool withSystemColumns, const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx)
-{
-    TVector<TExprBase> kqlEffects;
-    for (const auto& effect : query.Effects()) {
-        if (auto maybeWrite = effect.Maybe<TKiWriteTable>()) {
-            auto result = HandleWriteTable(maybeWrite.Cast(), ctx, tablesData);
-            kqlEffects.push_back(result);
-        }
-
-        if (auto maybeUpdate = effect.Maybe<TKiUpdateTable>()) {
-            auto results = HandleUpdateTable(maybeUpdate.Cast(), ctx, tablesData, withSystemColumns);
-            kqlEffects.insert(kqlEffects.end(), results.begin(), results.end());
-        }
-
-        if (auto maybeDelete = effect.Maybe<TKiDeleteTable>()) {
-            auto results = HandleDeleteTable(maybeDelete.Cast(), ctx, tablesData, withSystemColumns);
-            kqlEffects.insert(kqlEffects.end(), results.begin(), results.end());
-        }
-    }
-
-    TVector<TKqlQueryResult> kqlResults;
-    kqlResults.reserve(query.Results().Size());
-    for (const auto& kiResult : query.Results()) {
-        kqlResults.emplace_back(
+{ 
+    TVector<TExprBase> kqlEffects; 
+    for (const auto& effect : query.Effects()) { 
+        if (auto maybeWrite = effect.Maybe<TKiWriteTable>()) { 
+            auto result = HandleWriteTable(maybeWrite.Cast(), ctx, tablesData); 
+            kqlEffects.push_back(result); 
+        } 
+
+        if (auto maybeUpdate = effect.Maybe<TKiUpdateTable>()) { 
+            auto results = HandleUpdateTable(maybeUpdate.Cast(), ctx, tablesData, withSystemColumns); 
+            kqlEffects.insert(kqlEffects.end(), results.begin(), results.end()); 
+        } 
+ 
+        if (auto maybeDelete = effect.Maybe<TKiDeleteTable>()) { 
+            auto results = HandleDeleteTable(maybeDelete.Cast(), ctx, tablesData, withSystemColumns); 
+            kqlEffects.insert(kqlEffects.end(), results.begin(), results.end()); 
+        } 
+    } 
+ 
+    TVector<TKqlQueryResult> kqlResults; 
+    kqlResults.reserve(query.Results().Size()); 
+    for (const auto& kiResult : query.Results()) { 
+        kqlResults.emplace_back( 
             Build<TKqlQueryResult>(ctx, kiResult.Pos())
                 .Value(kiResult.Value())
                 .ColumnHints(kiResult.Columns())
                 .Done());
-    }
-
-    TKqlQuery kqlQuery = Build<TKqlQuery>(ctx, query.Pos())
-        .Results()
-            .Add(kqlResults)
-            .Build()
-        .Effects()
-            .Add(kqlEffects)
-            .Build()
-        .Done();
-
-    TExprNode::TPtr optResult;
-    TOptimizeExprSettings optSettings(nullptr);
-    optSettings.VisitChanges = true;
-    auto status = OptimizeExpr(kqlQuery.Ptr(), optResult,
+    } 
+ 
+    TKqlQuery kqlQuery = Build<TKqlQuery>(ctx, query.Pos()) 
+        .Results() 
+            .Add(kqlResults) 
+            .Build() 
+        .Effects() 
+            .Add(kqlEffects) 
+            .Build() 
+        .Done(); 
+ 
+    TExprNode::TPtr optResult; 
+    TOptimizeExprSettings optSettings(nullptr); 
+    optSettings.VisitChanges = true; 
+    auto status = OptimizeExpr(kqlQuery.Ptr(), optResult, 
         [&tablesData, withSystemColumns, &kqpCtx](const TExprNode::TPtr& input, TExprContext& ctx) {
-            auto node = TExprBase(input);
-            TExprNode::TPtr effect;
-
-            if (auto maybeRead = node.Maybe<TCoRight>().Input().Maybe<TKiReadTable>()) {
+            auto node = TExprBase(input); 
+            TExprNode::TPtr effect; 
+ 
+            if (auto maybeRead = node.Maybe<TCoRight>().Input().Maybe<TKiReadTable>()) { 
                 return HandleReadTable(maybeRead.Cast(), ctx, tablesData, withSystemColumns, kqpCtx);
-            }
-
-            return input;
-        }, ctx, optSettings);
+            } 
+ 
+            return input; 
+        }, ctx, optSettings); 
 
     if (status == IGraphTransformer::TStatus::Error) {
         return {};
     }
 
-    YQL_ENSURE(status == IGraphTransformer::TStatus::Ok);
-
-    YQL_ENSURE(TMaybeNode<TKqlQuery>(optResult));
-    return TKqlQuery(optResult);
-}
-
-} // namespace NKikimr::NKqp::NOpt
+    YQL_ENSURE(status == IGraphTransformer::TStatus::Ok); 
+ 
+    YQL_ENSURE(TMaybeNode<TKqlQuery>(optResult)); 
+    return TKqlQuery(optResult); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/kqp_opt_phase.cpp b/ydb/core/kqp/opt/kqp_opt_phase.cpp
index 47d3e6148c..fed9e8d6b5 100644
--- a/ydb/core/kqp/opt/kqp_opt_phase.cpp
+++ b/ydb/core/kqp/opt/kqp_opt_phase.cpp
@@ -1,24 +1,24 @@
-#include "kqp_opt_impl.h"
-
+#include "kqp_opt_impl.h" 
+ 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/utils/log/log.h>
 #include <ydb/library/yql/providers/common/provider/yql_provider.h>
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-
-using TStatus = IGraphTransformer::TStatus;
-
-TAutoPtr<IGraphTransformer> CreateKqpQueryPhasesTransformer() {
-    return CreateFunctorTransformer([](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
-        Y_UNUSED(ctx);
-        output = input;
-
-        return TStatus::Ok;
-    });
-}
-
-} // namespace NKikimr::NKqp::NOpt
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+using TStatus = IGraphTransformer::TStatus; 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpQueryPhasesTransformer() { 
+    return CreateFunctorTransformer([](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) { 
+        Y_UNUSED(ctx); 
+        output = input; 
+ 
+        return TStatus::Ok; 
+    }); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/kqp_opt_phy_check.cpp b/ydb/core/kqp/opt/kqp_opt_phy_check.cpp
index c34a094ff3..ced7dc799f 100644
--- a/ydb/core/kqp/opt/kqp_opt_phy_check.cpp
+++ b/ydb/core/kqp/opt/kqp_opt_phy_check.cpp
@@ -3,7 +3,7 @@
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NDq;
@@ -123,4 +123,4 @@ TAutoPtr<IGraphTransformer> CreateKqpCheckPhysicalQueryTransformer() {
         });
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/kqp_opt_phy_finalize.cpp b/ydb/core/kqp/opt/kqp_opt_phy_finalize.cpp
index ee827ddb39..5be820cd28 100644
--- a/ydb/core/kqp/opt/kqp_opt_phy_finalize.cpp
+++ b/ydb/core/kqp/opt/kqp_opt_phy_finalize.cpp
@@ -4,7 +4,7 @@
 #include <ydb/library/yql/dq/opt/dq_opt_phy.h>
 #include <ydb/library/yql/dq/opt/dq_opt_phy_finalizing.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NDq;
@@ -41,7 +41,7 @@ TStatus KqpBuildUnionResult(const TExprNode::TPtr& input, TExprNode::TPtr& outpu
     for (const auto& queryResult: query.Results()) {
         TExprBase node(queryResult.Value());
 
-        auto result = DqBuildExtendStage(node, ctx);
+        auto result = DqBuildExtendStage(node, ctx); 
         if (result.Raw() != node.Raw()) {
             YQL_CLOG(DEBUG, ProviderKqp) << "Building stage out of union #" << node.Raw()->UniqueId();
             replaces[node.Raw()] = result.Ptr();
@@ -150,22 +150,22 @@ TStatus KqpDuplicateResults(const TExprNode::TPtr& input, TExprNode::TPtr& outpu
     return TStatus::Ok;
 }
 
-template <typename TFunctor>
-NYql::IGraphTransformer::TStatus PerformGlobalRule(const TString& ruleName, const NYql::TExprNode::TPtr& input,
-    NYql::TExprNode::TPtr& output, NYql::TExprContext& ctx, TFunctor func)
-{
-    auto status = func(input, output, ctx);
-
-    if (output == input) {
-        return status;
-    }
-
-    DumpAppliedRule(ruleName, input, output, ctx);
-
-    // restart pipeline
-    return NYql::IGraphTransformer::TStatus(NYql::IGraphTransformer::TStatus::Repeat, true);
-}
-
+template <typename TFunctor> 
+NYql::IGraphTransformer::TStatus PerformGlobalRule(const TString& ruleName, const NYql::TExprNode::TPtr& input, 
+    NYql::TExprNode::TPtr& output, NYql::TExprContext& ctx, TFunctor func) 
+{ 
+    auto status = func(input, output, ctx); 
+ 
+    if (output == input) { 
+        return status; 
+    } 
+ 
+    DumpAppliedRule(ruleName, input, output, ctx); 
+ 
+    // restart pipeline 
+    return NYql::IGraphTransformer::TStatus(NYql::IGraphTransformer::TStatus::Repeat, true); 
+} 
+ 
 } // anonymous namespace
 
 #define PERFORM_GLOBAL_RULE(id, input, output, ctx, ...) \
@@ -177,23 +177,23 @@ NYql::IGraphTransformer::TStatus PerformGlobalRule(const TString& ruleName, cons
 TAutoPtr<IGraphTransformer> CreateKqpFinalizingOptTransformer() {
     return CreateFunctorTransformer(
         [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) -> TStatus {
-            PERFORM_GLOBAL_RULE("ReplicateMultiUsedConnection", input, output, ctx,
+            PERFORM_GLOBAL_RULE("ReplicateMultiUsedConnection", input, output, ctx, 
                 [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
                     YQL_ENSURE(TKqlQuery::Match(input.Get()));
                     return NDq::DqReplicateStageMultiOutput(input, output, ctx);
                 });
 
-            PERFORM_GLOBAL_RULE("BuildPureExprStages", input, output, ctx,
+            PERFORM_GLOBAL_RULE("BuildPureExprStages", input, output, ctx, 
                 [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
                     return KqpBuildPureExprStagesResult(input, output, ctx);
                 });
 
-            PERFORM_GLOBAL_RULE("BuildUnion", input, output, ctx,
+            PERFORM_GLOBAL_RULE("BuildUnion", input, output, ctx, 
                 [] (const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
                     return KqpBuildUnionResult(input, output, ctx);
                 });
 
-            PERFORM_GLOBAL_RULE("ExtractPrecomputeToInputs", input, output, ctx,
+            PERFORM_GLOBAL_RULE("ExtractPrecomputeToInputs", input, output, ctx, 
                 [] (const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
                     return DqExtractPrecomputeToStageInput(input, output, ctx);
                 });
@@ -211,4 +211,4 @@ TAutoPtr<IGraphTransformer> CreateKqpFinalizingOptTransformer() {
 
 #undef PERFORM_GLOBAL_RULE
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log.cpp b/ydb/core/kqp/opt/logical/kqp_opt_log.cpp
index d951c5ce30..763da1746a 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log.cpp
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log.cpp
@@ -8,7 +8,7 @@
 #include <ydb/library/yql/dq/opt/dq_opt_log.h>
 #include <ydb/library/yql/providers/common/transform/yql_optimize.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NCommon;
@@ -41,8 +41,8 @@ public:
         AddHandler(0, &TCoTopSort::Match, HNDL(RewriteTopSortOverIndexRead));
         AddHandler(0, &TCoTake::Match, HNDL(RewriteTakeOverIndexRead));
         AddHandler(0, &TCoFlatMapBase::Match, HNDL(RewriteFlatMapOverExtend));
-        AddHandler(0, &TKqlDeleteRows::Match, HNDL(DeleteOverLookup));
-        AddHandler(0, &TKqlUpsertRowsBase::Match, HNDL(ExcessUpsertInputColumns));
+        AddHandler(0, &TKqlDeleteRows::Match, HNDL(DeleteOverLookup)); 
+        AddHandler(0, &TKqlUpsertRowsBase::Match, HNDL(ExcessUpsertInputColumns)); 
 
         AddHandler(1, &TKqlReadTableIndex::Match, HNDL(RewriteIndexRead));
         AddHandler(1, &TKqlLookupIndex::Match, HNDL(RewriteLookupIndex));
@@ -153,18 +153,18 @@ protected:
         return output;
     }
 
-    TMaybeNode<TExprBase> DeleteOverLookup(TExprBase node, TExprContext& ctx) {
-        TExprBase output = KqpDeleteOverLookup(node, ctx, KqpCtx);
-        DumpAppliedRule("DeleteOverLookup", node.Ptr(), output.Ptr(), ctx);
-        return output;
-    }
-
-    TMaybeNode<TExprBase> ExcessUpsertInputColumns(TExprBase node, TExprContext& ctx) {
-        TExprBase output = KqpExcessUpsertInputColumns(node, ctx);
-        DumpAppliedRule("ExcessUpsertInputColumns", node.Ptr(), output.Ptr(), ctx);
-        return output;
-    }
-
+    TMaybeNode<TExprBase> DeleteOverLookup(TExprBase node, TExprContext& ctx) { 
+        TExprBase output = KqpDeleteOverLookup(node, ctx, KqpCtx); 
+        DumpAppliedRule("DeleteOverLookup", node.Ptr(), output.Ptr(), ctx); 
+        return output; 
+    } 
+ 
+    TMaybeNode<TExprBase> ExcessUpsertInputColumns(TExprBase node, TExprContext& ctx) { 
+        TExprBase output = KqpExcessUpsertInputColumns(node, ctx); 
+        DumpAppliedRule("ExcessUpsertInputColumns", node.Ptr(), output.Ptr(), ctx); 
+        return output; 
+    } 
+ 
 private:
     TTypeAnnotationContext& TypesCtx;
     const TKqpOptimizeContext& KqpCtx;
@@ -177,4 +177,4 @@ TAutoPtr<IGraphTransformer> CreateKqpLogOptTransformer(const TIntrusivePtr<TKqpO
     return THolder<IGraphTransformer>(new TKqpLogicalOptTransformer(typesCtx, kqpCtx, config));
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log.h b/ydb/core/kqp/opt/logical/kqp_opt_log.h
index 2739a63805..d7c6a97b70 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log.h
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log.h
@@ -3,11 +3,11 @@
 #include <ydb/core/kqp/common/kqp_transform.h>
 #include <ydb/core/kqp/opt/kqp_opt.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 struct TKqpOptimizeContext;
 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpLogOptTransformer(const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx,
     NYql::TTypeAnnotationContext& typesCtx, const NYql::TKikimrConfiguration::TPtr& config);
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log_effects.cpp b/ydb/core/kqp/opt/logical/kqp_opt_log_effects.cpp
index 5a074509b2..e74e61afb8 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log_effects.cpp
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log_effects.cpp
@@ -1,83 +1,83 @@
-#include "kqp_opt_log_rules.h"
-
+#include "kqp_opt_log_rules.h" 
+ 
 #include <ydb/core/kqp/opt/kqp_opt_impl.h>
 #include <ydb/core/kqp/common/kqp_yql.h>
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-
-TExprBase KqpDeleteOverLookup(const TExprBase& node, TExprContext& ctx, const TKqpOptimizeContext &kqpCtx) {
-    if (!node.Maybe<TKqlDeleteRows>()) {
-        return node;
-    }
-
-    auto deleteRows = node.Cast<TKqlDeleteRows>();
-
-    TMaybeNode<TKqlLookupTable> lookup;
-    TMaybeNode<TCoSkipNullMembers> skipNulMembers;
-
-    if (deleteRows.Input().Maybe<TKqlLookupTable>()) {
-        lookup = deleteRows.Input().Cast<TKqlLookupTable>();
-    } else if (deleteRows.Input().Maybe<TCoSkipNullMembers>().Input().Maybe<TKqlLookupTable>()) {
-        skipNulMembers = deleteRows.Input().Cast<TCoSkipNullMembers>();
-        lookup = skipNulMembers.Input().Cast<TKqlLookupTable>();
-    } else {
-        return node;
-    }
-
-    YQL_ENSURE(lookup);
-    if (deleteRows.Table().Raw() != lookup.Cast().Table().Raw()) {
-        return node;
-    }
-
-    auto lookupKeysType = lookup.Cast().LookupKeys().Ref().GetTypeAnn();
-    auto lookupKeyType = lookupKeysType->Cast<TListExprType>()->GetItemType()->Cast<TStructExprType>();
-    YQL_ENSURE(lookupKeyType);
-
-    // Only consider complete PK lookups
-    const auto& tableDesc = GetTableData(*kqpCtx.Tables, kqpCtx.Cluster, deleteRows.Table().Path());
-    if (lookupKeyType->GetSize() != tableDesc.Metadata->KeyColumnNames.size()) {
-        return node;
-    }
-
-    TExprBase deleteInput = lookup.Cast().LookupKeys();
-    if (skipNulMembers) {
-        deleteInput = Build<TCoSkipNullMembers>(ctx, skipNulMembers.Cast().Pos())
-            .Input(deleteInput)
-            .Members(skipNulMembers.Cast().Members())
-            .Done();
-    }
-
-    return Build<TKqlDeleteRows>(ctx, deleteRows.Pos())
-        .Table(deleteRows.Table())
-        .Input(deleteInput)
-        .Done();
-}
-
-TExprBase KqpExcessUpsertInputColumns(const TExprBase& node, TExprContext& ctx) {
-    if (!node.Maybe<TKqlUpsertRows>() &&
-        !node.Maybe<TKqlUpsertRowsIndex>())
-    {
-        return node;
-    }
-
-    auto upsertRows = node.Cast<TKqlUpsertRowsBase>();
-    auto inputItemType = upsertRows.Input().Ref().GetTypeAnn()->Cast<TListExprType>()->GetItemType();
-    auto inputRowType = inputItemType->Cast<TStructExprType>();
-
-    if (inputRowType->GetItems().size() <= upsertRows.Columns().Size()) {
-        return node;
-    }
-
-    auto newInput = Build<TCoExtractMembers>(ctx, node.Pos())
-        .Input(upsertRows.Input())
-        .Members(upsertRows.Columns())
-        .Done();
-
-    auto newUpsert = ctx.ChangeChild(upsertRows.Ref(), TKqlUpsertRowsBase::idx_Input, newInput.Ptr());
-    return TExprBase(newUpsert);
-}
-
-} // namespace NKikimr::NKqp::NOpt
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+TExprBase KqpDeleteOverLookup(const TExprBase& node, TExprContext& ctx, const TKqpOptimizeContext &kqpCtx) { 
+    if (!node.Maybe<TKqlDeleteRows>()) { 
+        return node; 
+    } 
+ 
+    auto deleteRows = node.Cast<TKqlDeleteRows>(); 
+ 
+    TMaybeNode<TKqlLookupTable> lookup; 
+    TMaybeNode<TCoSkipNullMembers> skipNulMembers; 
+ 
+    if (deleteRows.Input().Maybe<TKqlLookupTable>()) { 
+        lookup = deleteRows.Input().Cast<TKqlLookupTable>(); 
+    } else if (deleteRows.Input().Maybe<TCoSkipNullMembers>().Input().Maybe<TKqlLookupTable>()) { 
+        skipNulMembers = deleteRows.Input().Cast<TCoSkipNullMembers>(); 
+        lookup = skipNulMembers.Input().Cast<TKqlLookupTable>(); 
+    } else { 
+        return node; 
+    } 
+ 
+    YQL_ENSURE(lookup); 
+    if (deleteRows.Table().Raw() != lookup.Cast().Table().Raw()) { 
+        return node; 
+    } 
+ 
+    auto lookupKeysType = lookup.Cast().LookupKeys().Ref().GetTypeAnn(); 
+    auto lookupKeyType = lookupKeysType->Cast<TListExprType>()->GetItemType()->Cast<TStructExprType>(); 
+    YQL_ENSURE(lookupKeyType); 
+ 
+    // Only consider complete PK lookups 
+    const auto& tableDesc = GetTableData(*kqpCtx.Tables, kqpCtx.Cluster, deleteRows.Table().Path()); 
+    if (lookupKeyType->GetSize() != tableDesc.Metadata->KeyColumnNames.size()) { 
+        return node; 
+    } 
+ 
+    TExprBase deleteInput = lookup.Cast().LookupKeys(); 
+    if (skipNulMembers) { 
+        deleteInput = Build<TCoSkipNullMembers>(ctx, skipNulMembers.Cast().Pos()) 
+            .Input(deleteInput) 
+            .Members(skipNulMembers.Cast().Members()) 
+            .Done(); 
+    } 
+ 
+    return Build<TKqlDeleteRows>(ctx, deleteRows.Pos()) 
+        .Table(deleteRows.Table()) 
+        .Input(deleteInput) 
+        .Done(); 
+} 
+ 
+TExprBase KqpExcessUpsertInputColumns(const TExprBase& node, TExprContext& ctx) { 
+    if (!node.Maybe<TKqlUpsertRows>() && 
+        !node.Maybe<TKqlUpsertRowsIndex>()) 
+    { 
+        return node; 
+    } 
+ 
+    auto upsertRows = node.Cast<TKqlUpsertRowsBase>(); 
+    auto inputItemType = upsertRows.Input().Ref().GetTypeAnn()->Cast<TListExprType>()->GetItemType(); 
+    auto inputRowType = inputItemType->Cast<TStructExprType>(); 
+ 
+    if (inputRowType->GetItems().size() <= upsertRows.Columns().Size()) { 
+        return node; 
+    } 
+ 
+    auto newInput = Build<TCoExtractMembers>(ctx, node.Pos()) 
+        .Input(upsertRows.Input()) 
+        .Members(upsertRows.Columns()) 
+        .Done(); 
+ 
+    auto newUpsert = ctx.ChangeChild(upsertRows.Ref(), TKqlUpsertRowsBase::idx_Input, newInput.Ptr()); 
+    return TExprBase(newUpsert); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log_extract.cpp b/ydb/core/kqp/opt/logical/kqp_opt_log_extract.cpp
index 96642998db..ce129178a1 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log_extract.cpp
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log_extract.cpp
@@ -8,7 +8,7 @@
 #include <ydb/library/yql/dq/opt/dq_opt_log.h>
 #include <ydb/library/yql/providers/common/provider/yql_table_lookup.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NCommon;
@@ -111,5 +111,5 @@ TExprBase KqpApplyExtractMembersToReadOlapTable(TExprBase node, TExprContext& ct
         .Done();
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log_indexes.cpp b/ydb/core/kqp/opt/logical/kqp_opt_log_indexes.cpp
index 4bb48475a7..0a8a6b3c2f 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log_indexes.cpp
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log_indexes.cpp
@@ -4,7 +4,7 @@
 
 #include <ydb/library/yql/dq/opt/dq_opt_phy.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NDq;
@@ -235,4 +235,4 @@ TExprBase KqpRewriteTakeOverIndexRead(const TExprBase& node, TExprContext& ctx,
     return node;
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log_join.cpp b/ydb/core/kqp/opt/logical/kqp_opt_log_join.cpp
index ac0fe0bc39..4a9bd35173 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log_join.cpp
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log_join.cpp
@@ -7,7 +7,7 @@
 
 #include <ydb/library/yql/core/yql_opt_utils.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NCommon;
@@ -281,10 +281,10 @@ TMaybeNode<TExprBase> KqpJoinToIndexLookupImpl(const TDqJoin& join, TExprContext
                 }
                 if (canCast) {
                     DBG("------ cast " << leftDataType->GetName() << " to " << rightDataType->GetName());
-                    member = Build<TCoConvert>(ctx, join.Pos())
-                        .Input(member)
-                        .Type().Build(rightDataType->GetName())
-                        .Done().Ptr();
+                    member = Build<TCoConvert>(ctx, join.Pos()) 
+                        .Input(member) 
+                        .Type().Build(rightDataType->GetName()) 
+                        .Done().Ptr(); 
                 } else {
                     DBG("------ can not cast " << leftDataType->GetName() << " to " << rightDataType->GetName());
                     return {};
@@ -435,23 +435,23 @@ TExprBase KqpJoinToIndexLookup(const TExprBase& node, TExprContext& ctx, const T
 
     DBG("-- Join: " << KqpExprToPrettyString(join, ctx));
 
-    // SqlIn support (preferred lookup direction)
+    // SqlIn support (preferred lookup direction) 
     if (join.JoinType().Value() == "LeftSemi" && !config->HasOptDisableJoinReverseTableLookupLeftSemi()) {
-        auto flipJoin = FlipLeftSemiJoin(join, ctx);
+        auto flipJoin = FlipLeftSemiJoin(join, ctx); 
         DBG("-- Flip join");
 
-        if (auto indexLookupJoin = KqpJoinToIndexLookupImpl(flipJoin, ctx, kqpCtx)) {
+        if (auto indexLookupJoin = KqpJoinToIndexLookupImpl(flipJoin, ctx, kqpCtx)) { 
             return indexLookupJoin.Cast();
         }
     }
 
-    if (auto indexLookupJoin = KqpJoinToIndexLookupImpl(join, ctx, kqpCtx)) {
-        return indexLookupJoin.Cast();
-    }
-
+    if (auto indexLookupJoin = KqpJoinToIndexLookupImpl(join, ctx, kqpCtx)) { 
+        return indexLookupJoin.Cast(); 
+    } 
+ 
     return node;
 }
 
 #undef DBG
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log_ranges.cpp b/ydb/core/kqp/opt/logical/kqp_opt_log_ranges.cpp
index 38933b19fb..4de508c702 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log_ranges.cpp
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log_ranges.cpp
@@ -8,8 +8,8 @@
 #include <ydb/library/yql/dq/opt/dq_opt_log.h>
 #include <ydb/library/yql/providers/common/provider/yql_table_lookup.h>
 
-namespace NKikimr::NKqp::NOpt {
-
+namespace NKikimr::NKqp::NOpt { 
+ 
 namespace {
 
 using namespace NYql;
@@ -113,7 +113,7 @@ TKqlKeyRange BuildKeyRangeExpr(const TKeyRange& keyRange, const TKikimrTableDesc
         .Done();
 }
 
-} // namespace
+} // namespace 
 
 TExprBase KqpPushPredicateToReadTable(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) {
     if (!node.Maybe<TCoFlatMap>()) {
@@ -293,5 +293,5 @@ TExprBase KqpPushPredicateToReadTable(TExprBase node, TExprContext& ctx, const T
         .Done();
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log_ranges_predext.cpp b/ydb/core/kqp/opt/logical/kqp_opt_log_ranges_predext.cpp
index a4a4a0b3e0..8671e31876 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log_ranges_predext.cpp
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log_ranges_predext.cpp
@@ -9,7 +9,7 @@
 #include <ydb/library/yql/providers/common/provider/yql_table_lookup.h>
 #include <ydb/library/yql/core/extract_predicate/extract_predicate.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NCommon;
@@ -133,5 +133,5 @@ TExprBase KqpPushExtractedPredicateToReadTable(TExprBase node, TExprContext& ctx
         .Done();
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log_rules.h b/ydb/core/kqp/opt/logical/kqp_opt_log_rules.h
index 9e84d83d82..0435a5f0f6 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log_rules.h
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log_rules.h
@@ -9,7 +9,7 @@
  * This file contains declaration of all rule functions for logical optimizer
  */
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 NYql::NNodes::TExprBase KqpPushPredicateToReadTable(NYql::NNodes::TExprBase node, NYql::TExprContext &ctx,
     const TKqpOptimizeContext &kqpCtx);
@@ -43,9 +43,9 @@ NYql::NNodes::TExprBase KqpRewriteTopSortOverIndexRead(const NYql::NNodes::TExpr
 NYql::NNodes::TExprBase KqpRewriteTakeOverIndexRead(const NYql::NNodes::TExprBase& node, NYql::TExprContext&,
     const TKqpOptimizeContext& kqpCtx);
 
-NYql::NNodes::TExprBase KqpDeleteOverLookup(const NYql::NNodes::TExprBase& node, NYql::TExprContext& ctx,
-    const TKqpOptimizeContext &kqpCtx);
-
-NYql::NNodes::TExprBase KqpExcessUpsertInputColumns(const NYql::NNodes::TExprBase& node, NYql::TExprContext& ctx);
-
-} // namespace NKikimr::NKqp::NOpt
+NYql::NNodes::TExprBase KqpDeleteOverLookup(const NYql::NNodes::TExprBase& node, NYql::TExprContext& ctx, 
+    const TKqpOptimizeContext &kqpCtx); 
+ 
+NYql::NNodes::TExprBase KqpExcessUpsertInputColumns(const NYql::NNodes::TExprBase& node, NYql::TExprContext& ctx); 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log_sqlin.cpp b/ydb/core/kqp/opt/logical/kqp_opt_log_sqlin.cpp
index fd5d213001..6102d8369d 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log_sqlin.cpp
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log_sqlin.cpp
@@ -7,7 +7,7 @@
 
 #include <ydb/library/yql/core/common_opt/yql_co_sqlin.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NDq;
@@ -145,4 +145,4 @@ TExprBase KqpRewriteSqlInToEquiJoin(const TExprBase& node, TExprContext& ctx, co
     return node;
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/logical/kqp_opt_log_sqlin_compact.cpp b/ydb/core/kqp/opt/logical/kqp_opt_log_sqlin_compact.cpp
index f3ffaa1ec0..eaa29a44e5 100644
--- a/ydb/core/kqp/opt/logical/kqp_opt_log_sqlin_compact.cpp
+++ b/ydb/core/kqp/opt/logical/kqp_opt_log_sqlin_compact.cpp
@@ -8,7 +8,7 @@
 #include <ydb/library/yql/core/common_opt/yql_co_sqlin.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NNodes;
@@ -228,5 +228,5 @@ TExprBase KqpRewriteSqlInCompactToJoin(const TExprBase& node, TExprContext& ctx)
         .Done();
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
 
diff --git a/ydb/core/kqp/opt/logical/ya.make b/ydb/core/kqp/opt/logical/ya.make
index b9811606c1..8e45848ad2 100644
--- a/ydb/core/kqp/opt/logical/ya.make
+++ b/ydb/core/kqp/opt/logical/ya.make
@@ -6,7 +6,7 @@ OWNER(
 )
 
 SRCS(
-    kqp_opt_log_effects.cpp
+    kqp_opt_log_effects.cpp 
     kqp_opt_log_extract.cpp
     kqp_opt_log_join.cpp
     kqp_opt_log_indexes.cpp
@@ -14,7 +14,7 @@ SRCS(
     kqp_opt_log_ranges_predext.cpp
     kqp_opt_log_sqlin.cpp
     kqp_opt_log_sqlin_compact.cpp
-    kqp_opt_log.cpp
+    kqp_opt_log.cpp 
 )
 
 PEERDIR(
diff --git a/ydb/core/kqp/opt/peephole/kqp_opt_peephole.cpp b/ydb/core/kqp/opt/peephole/kqp_opt_peephole.cpp
index 55aca64df8..4110a2990d 100644
--- a/ydb/core/kqp/opt/peephole/kqp_opt_peephole.cpp
+++ b/ydb/core/kqp/opt/peephole/kqp_opt_peephole.cpp
@@ -15,7 +15,7 @@
 #include <util/generic/size_literals.h>
 #include <util/string/cast.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 namespace {
 
@@ -25,58 +25,58 @@ using namespace NYql::NNodes;
 
 using TStatus = IGraphTransformer::TStatus;
 
-class TKqpPeepholeTransformer : public TOptimizeTransformerBase {
-public:
-    TKqpPeepholeTransformer()
-        : TOptimizeTransformerBase(nullptr, NLog::EComponent::ProviderKqp, {})
-    {
-#define HNDL(name) "KqpPeephole-"#name, Hndl(&TKqpPeepholeTransformer::name)
-        AddHandler(0, &TDqReplicate::Match, HNDL(RewriteReplicate));
-        AddHandler(0, &TDqPhyMapJoin::Match, HNDL(RewriteMapJoin));
-        AddHandler(0, &TDqPhyCrossJoin::Match, HNDL(RewriteCrossJoin));
-        AddHandler(0, &TDqPhyJoinDict::Match, HNDL(RewriteDictJoin));
-        AddHandler(0, &TDqJoin::Match, HNDL(RewritePureJoin));
-        AddHandler(0, TOptimizeTransformerBase::Any(), HNDL(BuildWideReadTable));
-#undef HNDL
-    }
-
-protected:
-    TMaybeNode<TExprBase> RewriteReplicate(TExprBase node, TExprContext& ctx) {
-        TExprBase output = DqPeepholeRewriteReplicate(node, ctx);
-        DumpAppliedRule("RewriteReplicate", node.Ptr(), output.Ptr(), ctx);
-        return output;
-    }
-
-    TMaybeNode<TExprBase> RewriteMapJoin(TExprBase node, TExprContext& ctx) {
-        TExprBase output = DqPeepholeRewriteMapJoin(node, ctx);
-        DumpAppliedRule("RewriteMapJoin", node.Ptr(), output.Ptr(), ctx);
-        return output;
-    }
-
-    TMaybeNode<TExprBase> RewriteCrossJoin(TExprBase node, TExprContext& ctx) {
-        TExprBase output = DqPeepholeRewriteCrossJoin(node, ctx);
-        DumpAppliedRule("RewriteCrossJoin", node.Ptr(), output.Ptr(), ctx);
-        return output;
-    }
-
-    TMaybeNode<TExprBase> RewriteDictJoin(TExprBase node, TExprContext& ctx) {
-        TExprBase output = DqPeepholeRewriteJoinDict(node, ctx);
-        DumpAppliedRule("RewriteDictJoin", node.Ptr(), output.Ptr(), ctx);
-        return output;
-    }
-
-    TMaybeNode<TExprBase> RewritePureJoin(TExprBase node, TExprContext& ctx) {
-        TExprBase output = DqPeepholeRewritePureJoin(node, ctx);
-        DumpAppliedRule("RewritePureJoin", node.Ptr(), output.Ptr(), ctx);
-        return output;
-    }
-
-    TMaybeNode<TExprBase> BuildWideReadTable(TExprBase node, TExprContext& ctx) {
-        TExprBase output = KqpBuildWideReadTable(node, ctx);
-        DumpAppliedRule("BuildWideReadTable", node.Ptr(), output.Ptr(), ctx);
-        return output;
-    }
-};
+class TKqpPeepholeTransformer : public TOptimizeTransformerBase { 
+public: 
+    TKqpPeepholeTransformer() 
+        : TOptimizeTransformerBase(nullptr, NLog::EComponent::ProviderKqp, {}) 
+    { 
+#define HNDL(name) "KqpPeephole-"#name, Hndl(&TKqpPeepholeTransformer::name) 
+        AddHandler(0, &TDqReplicate::Match, HNDL(RewriteReplicate)); 
+        AddHandler(0, &TDqPhyMapJoin::Match, HNDL(RewriteMapJoin)); 
+        AddHandler(0, &TDqPhyCrossJoin::Match, HNDL(RewriteCrossJoin)); 
+        AddHandler(0, &TDqPhyJoinDict::Match, HNDL(RewriteDictJoin)); 
+        AddHandler(0, &TDqJoin::Match, HNDL(RewritePureJoin)); 
+        AddHandler(0, TOptimizeTransformerBase::Any(), HNDL(BuildWideReadTable)); 
+#undef HNDL 
+    } 
+
+protected: 
+    TMaybeNode<TExprBase> RewriteReplicate(TExprBase node, TExprContext& ctx) { 
+        TExprBase output = DqPeepholeRewriteReplicate(node, ctx); 
+        DumpAppliedRule("RewriteReplicate", node.Ptr(), output.Ptr(), ctx); 
+        return output; 
+    } 
+
+    TMaybeNode<TExprBase> RewriteMapJoin(TExprBase node, TExprContext& ctx) { 
+        TExprBase output = DqPeepholeRewriteMapJoin(node, ctx); 
+        DumpAppliedRule("RewriteMapJoin", node.Ptr(), output.Ptr(), ctx); 
+        return output; 
+    } 
+
+    TMaybeNode<TExprBase> RewriteCrossJoin(TExprBase node, TExprContext& ctx) { 
+        TExprBase output = DqPeepholeRewriteCrossJoin(node, ctx); 
+        DumpAppliedRule("RewriteCrossJoin", node.Ptr(), output.Ptr(), ctx); 
+        return output; 
+    } 
+
+    TMaybeNode<TExprBase> RewriteDictJoin(TExprBase node, TExprContext& ctx) { 
+        TExprBase output = DqPeepholeRewriteJoinDict(node, ctx); 
+        DumpAppliedRule("RewriteDictJoin", node.Ptr(), output.Ptr(), ctx); 
+        return output; 
+    } 
+
+    TMaybeNode<TExprBase> RewritePureJoin(TExprBase node, TExprContext& ctx) { 
+        TExprBase output = DqPeepholeRewritePureJoin(node, ctx); 
+        DumpAppliedRule("RewritePureJoin", node.Ptr(), output.Ptr(), ctx); 
+        return output; 
+    } 
+
+    TMaybeNode<TExprBase> BuildWideReadTable(TExprBase node, TExprContext& ctx) { 
+        TExprBase output = KqpBuildWideReadTable(node, ctx); 
+        DumpAppliedRule("BuildWideReadTable", node.Ptr(), output.Ptr(), ctx); 
+        return output; 
+    } 
+}; 
 
 struct TKqpPeepholePipelineConfigurator : IPipelineConfigurator {
     TKqpPeepholePipelineConfigurator(TKikimrConfiguration::TPtr config)
@@ -90,8 +90,8 @@ struct TKqpPeepholePipelineConfigurator : IPipelineConfigurator {
     }
 
     void AfterOptimize(TTransformationPipeline* pipeline) const override {
-
-        pipeline->Add(new TKqpPeepholeTransformer(), "KqpPeephole");
+ 
+        pipeline->Add(new TKqpPeepholeTransformer(), "KqpPeephole"); 
     }
 
 private:
@@ -99,7 +99,7 @@ private:
 };
 
 TStatus PeepHoleOptimize(const TExprBase& program, TExprNode::TPtr& newProgram, TExprContext& ctx,
-    IGraphTransformer& typeAnnTransformer, TTypeAnnotationContext& typesCtx, TKikimrConfiguration::TPtr config,
+    IGraphTransformer& typeAnnTransformer, TTypeAnnotationContext& typesCtx, TKikimrConfiguration::TPtr config, 
     bool allowNonDeterministicFunctions, bool withFinalStageRules)
 {
     TKqpPeepholePipelineConfigurator kqpPeephole(config);
@@ -115,8 +115,8 @@ TStatus PeepHoleOptimize(const TExprBase& program, TExprNode::TPtr& newProgram,
         return status;
     }
 
-    if (!allowNonDeterministicFunctions && hasNonDeterministicFunctions) {
-        ctx.AddError(TIssue(ctx.GetPosition(program.Pos()), "Unexpected non-deterministic functions in KQP program"));
+    if (!allowNonDeterministicFunctions && hasNonDeterministicFunctions) { 
+        ctx.AddError(TIssue(ctx.GetPosition(program.Pos()), "Unexpected non-deterministic functions in KQP program")); 
         return TStatus::Error;
     }
 
@@ -149,10 +149,10 @@ TMaybeNode<TKqpPhysicalTx> PeepholeOptimize(const TKqpPhysicalTx& tx, TExprConte
             .ArgsType(ExpandType(stage.Pos(), *ctx.MakeType<TTupleExprType>(argTypes), ctx))
             .Done();
 
-        bool allowNonDeterministicFunctions = !stage.Program().Body().Maybe<TKqpEffects>();
-
+        bool allowNonDeterministicFunctions = !stage.Program().Body().Maybe<TKqpEffects>(); 
+ 
         TExprNode::TPtr newProgram;
-        auto status = PeepHoleOptimize(program, newProgram, ctx, typeAnnTransformer, typesCtx, config,
+        auto status = PeepHoleOptimize(program, newProgram, ctx, typeAnnTransformer, typesCtx, config, 
             allowNonDeterministicFunctions, withFinalStageRules);
         if (status != TStatus::Ok) {
             ctx.AddError(TIssue(ctx.GetPosition(stage.Pos()), "Peephole optimization failed for KQP transaction"));
@@ -380,4 +380,4 @@ TStatus ReplaceNonDetFunctionsWithParams(TExprNode::TPtr& input, TExprContext& c
     return status;
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/peephole/kqp_opt_peephole.h b/ydb/core/kqp/opt/peephole/kqp_opt_peephole.h
index a0602bb07d..f84a078ba3 100644
--- a/ydb/core/kqp/opt/peephole/kqp_opt_peephole.h
+++ b/ydb/core/kqp/opt/peephole/kqp_opt_peephole.h
@@ -3,7 +3,7 @@
 #include <ydb/core/kqp/common/kqp_transform.h>
 #include <ydb/core/kqp/opt/kqp_opt.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpTxPeepholeTransformer(NYql::IGraphTransformer* typeAnnTransformer,
     NYql::TTypeAnnotationContext& typesCtx, const NYql::TKikimrConfiguration::TPtr& config, bool withFinalStageRules = true);
@@ -14,4 +14,4 @@ TAutoPtr<NYql::IGraphTransformer> CreateKqpTxsPeepholeTransformer(TAutoPtr<NYql:
 NYql::IGraphTransformer::TStatus ReplaceNonDetFunctionsWithParams(NYql::TExprNode::TPtr& input, NYql::TExprContext& ctx,
     TVector<NYql::NNodes::TKqpParamBinding>* paramBindings = nullptr);
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/peephole/kqp_opt_peephole_rules.h b/ydb/core/kqp/opt/peephole/kqp_opt_peephole_rules.h
index 489a2afe1e..e8a0cf484b 100644
--- a/ydb/core/kqp/opt/peephole/kqp_opt_peephole_rules.h
+++ b/ydb/core/kqp/opt/peephole/kqp_opt_peephole_rules.h
@@ -9,8 +9,8 @@
  * This file contains declaration of all rule functions for peephole optimizer
  */
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 NYql::NNodes::TExprBase KqpBuildWideReadTable(const NYql::NNodes::TExprBase& node, NYql::TExprContext& ctx);
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/peephole/kqp_opt_peephole_wide_read.cpp b/ydb/core/kqp/opt/peephole/kqp_opt_peephole_wide_read.cpp
index 75d76930bd..d6a5ba5f7a 100644
--- a/ydb/core/kqp/opt/peephole/kqp_opt_peephole_wide_read.cpp
+++ b/ydb/core/kqp/opt/peephole/kqp_opt_peephole_wide_read.cpp
@@ -3,7 +3,7 @@
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/opt/kqp_opt_impl.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NDq;
@@ -81,4 +81,4 @@ TExprBase KqpBuildWideReadTable(const TExprBase& node, TExprContext& ctx) {
         .Done();
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/peephole/ya.make b/ydb/core/kqp/opt/peephole/ya.make
index b6608c6462..4ad92e0fe7 100644
--- a/ydb/core/kqp/opt/peephole/ya.make
+++ b/ydb/core/kqp/opt/peephole/ya.make
@@ -7,7 +7,7 @@ OWNER(
 
 SRCS(
     kqp_opt_peephole_wide_read.cpp
-    kqp_opt_peephole.cpp
+    kqp_opt_peephole.cpp 
 )
 
 PEERDIR(
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_delete_index.cpp b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_delete_index.cpp
index 005e84f838..579ae52ac1 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_delete_index.cpp
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_delete_index.cpp
@@ -1,109 +1,109 @@
-#include "kqp_opt_phy_effects_rules.h"
-#include "kqp_opt_phy_effects_impl.h"
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-namespace {
-
-TDqPhyPrecompute PrecomputeDictKeys(const TCondenseInputResult& condenseResult, TPositionHandle pos,
-    TExprContext& ctx)
-{
-    auto computeDictKeysStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(condenseResult.StageInputs)
-            .Build()
-        .Program()
-            .Args(condenseResult.StageArgs)
-            .Body<TCoMap>()
-                .Input(condenseResult.Stream)
-                .Lambda()
-                    .Args({"dict"})
-                    .Body<TCoDictKeys>()
-                        .Dict("dict")
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    return Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-           .Output()
-               .Stage(computeDictKeysStage)
-               .Index().Build("0")
-               .Build()
-           .Build()
-        .Done();
-}
-
-} // namespace
-
-TExprBase KqpBuildDeleteIndexStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) {
-    if (!node.Maybe<TKqlDeleteRowsIndex>()) {
-        return node;
-    }
-
-    auto del = node.Cast<TKqlDeleteRowsIndex>();
-    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, del.Table().Path());
-    const auto& pk = table.Metadata->KeyColumnNames;
-
-    auto payloadSelector = Build<TCoLambda>(ctx, del.Pos())
-        .Args({"stub"})
-        .Body<TCoVoid>().Build()
-        .Done();
-
-    auto condenseResult = CondenseInputToDictByPk(del.Input(), table, payloadSelector, ctx);
-    if (!condenseResult) {
-        return node;
-    }
-
-    auto lookupKeys = PrecomputeDictKeys(*condenseResult, del.Pos(), ctx);
-
-    const auto indexes = BuildSecondaryIndexVector(table, del.Pos(), ctx);
-    YQL_ENSURE(indexes);
-
-    auto lookupDict = PrecomputeTableLookupDict(lookupKeys, table, {}, indexes, del.Pos(), ctx);
-    if (!lookupDict) {
-        return node;
-    }
-
-    auto tableDelete = Build<TKqlDeleteRows>(ctx, del.Pos())
-        .Table(del.Table())
-        .Input(lookupKeys)
-        .Done();
-
-    TVector<TExprBase> effects;
-    effects.emplace_back(tableDelete);
-
-    for (const auto& [tableNode, indexDesc] : indexes) {
-        THashSet<TStringBuf> indexTableColumns;
-
-        for (const auto& column : indexDesc->KeyColumns) {
-            YQL_ENSURE(indexTableColumns.emplace(column).second);
-        }
-
-        for (const auto& column : pk) {
-            indexTableColumns.insert(column);
-        }
-
-        auto deleteIndexKeys = MakeRowsFromDict(lookupDict.Cast(), pk, indexTableColumns, del.Pos(), ctx);
-
-        auto indexDelete = Build<TKqlDeleteRows>(ctx, del.Pos())
-            .Table(tableNode)
-            .Input(deleteIndexKeys)
-            .Done();
-
-        effects.emplace_back(std::move(indexDelete));
-    }
-
-    return Build<TExprList>(ctx, del.Pos())
-        .Add(effects)
-        .Done();
-}
-
-} // namespace NKikimr::NKqp::NOpt
+#include "kqp_opt_phy_effects_rules.h" 
+#include "kqp_opt_phy_effects_impl.h" 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NDq; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+TDqPhyPrecompute PrecomputeDictKeys(const TCondenseInputResult& condenseResult, TPositionHandle pos, 
+    TExprContext& ctx) 
+{ 
+    auto computeDictKeysStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(condenseResult.StageInputs) 
+            .Build() 
+        .Program() 
+            .Args(condenseResult.StageArgs) 
+            .Body<TCoMap>() 
+                .Input(condenseResult.Stream) 
+                .Lambda() 
+                    .Args({"dict"}) 
+                    .Body<TCoDictKeys>() 
+                        .Dict("dict") 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    return Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+           .Output() 
+               .Stage(computeDictKeysStage) 
+               .Index().Build("0") 
+               .Build() 
+           .Build() 
+        .Done(); 
+} 
+ 
+} // namespace 
+ 
+TExprBase KqpBuildDeleteIndexStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) { 
+    if (!node.Maybe<TKqlDeleteRowsIndex>()) { 
+        return node; 
+    } 
+ 
+    auto del = node.Cast<TKqlDeleteRowsIndex>(); 
+    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, del.Table().Path()); 
+    const auto& pk = table.Metadata->KeyColumnNames; 
+ 
+    auto payloadSelector = Build<TCoLambda>(ctx, del.Pos()) 
+        .Args({"stub"}) 
+        .Body<TCoVoid>().Build() 
+        .Done(); 
+ 
+    auto condenseResult = CondenseInputToDictByPk(del.Input(), table, payloadSelector, ctx); 
+    if (!condenseResult) { 
+        return node; 
+    } 
+ 
+    auto lookupKeys = PrecomputeDictKeys(*condenseResult, del.Pos(), ctx); 
+ 
+    const auto indexes = BuildSecondaryIndexVector(table, del.Pos(), ctx); 
+    YQL_ENSURE(indexes); 
+ 
+    auto lookupDict = PrecomputeTableLookupDict(lookupKeys, table, {}, indexes, del.Pos(), ctx); 
+    if (!lookupDict) { 
+        return node; 
+    } 
+ 
+    auto tableDelete = Build<TKqlDeleteRows>(ctx, del.Pos()) 
+        .Table(del.Table()) 
+        .Input(lookupKeys) 
+        .Done(); 
+ 
+    TVector<TExprBase> effects; 
+    effects.emplace_back(tableDelete); 
+ 
+    for (const auto& [tableNode, indexDesc] : indexes) { 
+        THashSet<TStringBuf> indexTableColumns; 
+ 
+        for (const auto& column : indexDesc->KeyColumns) { 
+            YQL_ENSURE(indexTableColumns.emplace(column).second); 
+        } 
+ 
+        for (const auto& column : pk) { 
+            indexTableColumns.insert(column); 
+        } 
+ 
+        auto deleteIndexKeys = MakeRowsFromDict(lookupDict.Cast(), pk, indexTableColumns, del.Pos(), ctx); 
+ 
+        auto indexDelete = Build<TKqlDeleteRows>(ctx, del.Pos()) 
+            .Table(tableNode) 
+            .Input(deleteIndexKeys) 
+            .Done(); 
+ 
+        effects.emplace_back(std::move(indexDelete)); 
+    } 
+ 
+    return Build<TExprList>(ctx, del.Pos()) 
+        .Add(effects) 
+        .Done(); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects.cpp b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects.cpp
index ac8a95c6f9..4c1285ca8b 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects.cpp
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects.cpp
@@ -1,182 +1,182 @@
-#include "kqp_opt_phy_effects_impl.h"
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-TExprNode::TPtr MakeMessage(TStringBuf message, TPositionHandle pos, TExprContext& ctx) {
-    return ctx.NewCallable(pos, "Utf8", { ctx.NewAtom(pos, message) });
-}
-
-TMaybe<TCondenseInputResult> CondenseInput(const TExprBase& input, TExprContext& ctx) {
-    TVector<TExprBase> stageInputs;
-    TVector<TCoArgument> stageArguments;
-
-    if (IsDqPureExpr(input)) {
-        YQL_ENSURE(input.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::List, "" << input.Ref().Dump());
-        auto stream = Build<TCoToStream>(ctx, input.Pos())
-            .Input<TCoJust>()
-                .Input(input)
-                .Build()
-            .Done();
-
-        return TCondenseInputResult { .Stream = stream };
-    }
-
-    if (!input.Maybe<TDqCnUnionAll>()) {
-        return {};
-    }
-
-    auto arg = Build<TCoArgument>(ctx, input.Pos())
-        .Name("input_rows")
-        .Done();
-
-    stageInputs.push_back(input);
-    stageArguments.push_back(arg);
-
-    auto condense = Build<TCoCondense>(ctx, input.Pos())
-        .Input(arg)
-        .State<TCoList>()
-            .ListType<TCoTypeOf>()
-                .Value(input)
-                .Build()
-            .Build()
-        .SwitchHandler()
-            .Args({"item", "state"})
-            .Body(MakeBool<false>(input.Pos(), ctx))
-            .Build()
-        .UpdateHandler()
-            .Args({"item", "state"})
-            .Body<TCoAppend>()
-                .List("state")
-                .Item("item")
-                .Build()
-            .Build()
-        .Done();
-
-    return TCondenseInputResult {
-        .Stream = condense,
-        .StageInputs = stageInputs,
-        .StageArgs = stageArguments
-    };
-}
-
-TMaybe<TCondenseInputResult> CondenseAndDeduplicateInput(const TExprBase& input, const TKikimrTableDescription& table,
-    TExprContext& ctx)
-{
-    auto condenseResult = CondenseInput(input, ctx);
-    if (!condenseResult) {
-        return {};
-    }
-
-    auto listArg = TCoArgument(ctx.NewArgument(input.Pos(), "list_arg"));
-
-    auto deduplicated = Build<TCoFlatMap>(ctx, input.Pos())
-        .Input(condenseResult->Stream)
-        .Lambda()
-            .Args({listArg})
-            .Body<TCoJust>()
-                .Input(RemoveDuplicateKeyFromInput(listArg, table, input.Pos(), ctx))
-                .Build()
-            .Build()
-        .Done();
-
-    return TCondenseInputResult {
-        .Stream = deduplicated,
-        .StageInputs = condenseResult->StageInputs,
-        .StageArgs = condenseResult->StageArgs
-    };
-}
-
-TMaybe<TCondenseInputResult> CondenseInputToDictByPk(const TExprBase& input, const TKikimrTableDescription& table,
-    const TCoLambda& payloadSelector, TExprContext& ctx)
-{
-    auto condenseResult = CondenseInput(input, ctx);
-    if (!condenseResult) {
-        return {};
-    }
-
-    auto dictStream = Build<TCoMap>(ctx, input.Pos())
-        .Input(condenseResult->Stream)
-        .Lambda()
-            .Args({"row_list"})
-            .Body<TCoToDict>()
-                .List("row_list")
-                .KeySelector(MakeTableKeySelector(table, input.Pos(), ctx))
-                .PayloadSelector(payloadSelector)
-                .Settings()
-                    .Add().Build("One")
-                    .Add().Build("Hashed")
-                    .Build()
-                .Build()
-            .Build()
-        .Done();
-
-    return TCondenseInputResult {
-        .Stream = dictStream,
-        .StageInputs = condenseResult->StageInputs,
-        .StageArgs = condenseResult->StageArgs
-    };
-}
-
-TCoLambda MakeTableKeySelector(const TKikimrTableDescription& table, TPositionHandle pos, TExprContext& ctx) {
-    auto keySelectorArg = TCoArgument(ctx.NewArgument(pos, "key_selector"));
-
-    TVector<TExprBase> keyTuples;
-    for (const auto& key : table.Metadata->KeyColumnNames) {
-        auto tuple = Build<TCoNameValueTuple>(ctx, pos)
-            .Name().Build(key)
-            .Value<TCoMember>()
-                .Struct(keySelectorArg)
-                .Name().Build(key)
-                .Build()
-            .Done();
-
-        keyTuples.emplace_back(tuple);
-    }
-
-    return Build<TCoLambda>(ctx, pos)
-        .Args({keySelectorArg})
-        .Body<TCoAsStruct>()
-            .Add(keyTuples)
-            .Build()
-        .Done();
-}
-
-TCoLambda MakeRowsPayloadSelector(const TCoAtomList& columns, const TKikimrTableDescription& table,
-    TPositionHandle pos, TExprContext& ctx)
-{
-    for (const auto& key : table.Metadata->KeyColumnNames) {
-        auto it = std::find_if(columns.begin(), columns.end(), [&key](const auto& x) { return x.Value() == key; });
-        YQL_ENSURE(it != columns.end(), "Key column not found in columns list: " << key);
-    }
-
-    auto payloadSelectorArg = TCoArgument(ctx.NewArgument(pos, "payload_selector_row"));
-    TVector<TExprBase> payloadTuples;
-    payloadTuples.reserve(columns.Size() - table.Metadata->KeyColumnNames.size());
-    for (const auto& column : columns) {
-        if (table.GetKeyColumnIndex(TString(column))) {
-            continue;
-        }
-
-        payloadTuples.emplace_back(
-            Build<TCoNameValueTuple>(ctx, pos)
-                .Name(column)
-                .Value<TCoMember>()
-                    .Struct(payloadSelectorArg)
-                    .Name(column)
-                    .Build()
-                .Done());
-    }
-
-    return Build<TCoLambda>(ctx, pos)
-        .Args({payloadSelectorArg})
-        .Body<TCoAsStruct>()
-            .Add(payloadTuples)
-            .Build()
-        .Done();
-}
-
-} // namespace NKikimr::NKqp::NOpt
+#include "kqp_opt_phy_effects_impl.h" 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NDq; 
+using namespace NYql::NNodes; 
+ 
+TExprNode::TPtr MakeMessage(TStringBuf message, TPositionHandle pos, TExprContext& ctx) { 
+    return ctx.NewCallable(pos, "Utf8", { ctx.NewAtom(pos, message) }); 
+} 
+ 
+TMaybe<TCondenseInputResult> CondenseInput(const TExprBase& input, TExprContext& ctx) { 
+    TVector<TExprBase> stageInputs; 
+    TVector<TCoArgument> stageArguments; 
+ 
+    if (IsDqPureExpr(input)) { 
+        YQL_ENSURE(input.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::List, "" << input.Ref().Dump()); 
+        auto stream = Build<TCoToStream>(ctx, input.Pos()) 
+            .Input<TCoJust>() 
+                .Input(input) 
+                .Build() 
+            .Done(); 
+ 
+        return TCondenseInputResult { .Stream = stream }; 
+    } 
+ 
+    if (!input.Maybe<TDqCnUnionAll>()) { 
+        return {}; 
+    } 
+ 
+    auto arg = Build<TCoArgument>(ctx, input.Pos()) 
+        .Name("input_rows") 
+        .Done(); 
+ 
+    stageInputs.push_back(input); 
+    stageArguments.push_back(arg); 
+ 
+    auto condense = Build<TCoCondense>(ctx, input.Pos()) 
+        .Input(arg) 
+        .State<TCoList>() 
+            .ListType<TCoTypeOf>() 
+                .Value(input) 
+                .Build() 
+            .Build() 
+        .SwitchHandler() 
+            .Args({"item", "state"}) 
+            .Body(MakeBool<false>(input.Pos(), ctx)) 
+            .Build() 
+        .UpdateHandler() 
+            .Args({"item", "state"}) 
+            .Body<TCoAppend>() 
+                .List("state") 
+                .Item("item") 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    return TCondenseInputResult { 
+        .Stream = condense, 
+        .StageInputs = stageInputs, 
+        .StageArgs = stageArguments 
+    }; 
+} 
+ 
+TMaybe<TCondenseInputResult> CondenseAndDeduplicateInput(const TExprBase& input, const TKikimrTableDescription& table, 
+    TExprContext& ctx) 
+{ 
+    auto condenseResult = CondenseInput(input, ctx); 
+    if (!condenseResult) { 
+        return {}; 
+    } 
+ 
+    auto listArg = TCoArgument(ctx.NewArgument(input.Pos(), "list_arg")); 
+ 
+    auto deduplicated = Build<TCoFlatMap>(ctx, input.Pos()) 
+        .Input(condenseResult->Stream) 
+        .Lambda() 
+            .Args({listArg}) 
+            .Body<TCoJust>() 
+                .Input(RemoveDuplicateKeyFromInput(listArg, table, input.Pos(), ctx)) 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    return TCondenseInputResult { 
+        .Stream = deduplicated, 
+        .StageInputs = condenseResult->StageInputs, 
+        .StageArgs = condenseResult->StageArgs 
+    }; 
+} 
+ 
+TMaybe<TCondenseInputResult> CondenseInputToDictByPk(const TExprBase& input, const TKikimrTableDescription& table, 
+    const TCoLambda& payloadSelector, TExprContext& ctx) 
+{ 
+    auto condenseResult = CondenseInput(input, ctx); 
+    if (!condenseResult) { 
+        return {}; 
+    } 
+ 
+    auto dictStream = Build<TCoMap>(ctx, input.Pos()) 
+        .Input(condenseResult->Stream) 
+        .Lambda() 
+            .Args({"row_list"}) 
+            .Body<TCoToDict>() 
+                .List("row_list") 
+                .KeySelector(MakeTableKeySelector(table, input.Pos(), ctx)) 
+                .PayloadSelector(payloadSelector) 
+                .Settings() 
+                    .Add().Build("One") 
+                    .Add().Build("Hashed") 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    return TCondenseInputResult { 
+        .Stream = dictStream, 
+        .StageInputs = condenseResult->StageInputs, 
+        .StageArgs = condenseResult->StageArgs 
+    }; 
+} 
+ 
+TCoLambda MakeTableKeySelector(const TKikimrTableDescription& table, TPositionHandle pos, TExprContext& ctx) { 
+    auto keySelectorArg = TCoArgument(ctx.NewArgument(pos, "key_selector")); 
+ 
+    TVector<TExprBase> keyTuples; 
+    for (const auto& key : table.Metadata->KeyColumnNames) { 
+        auto tuple = Build<TCoNameValueTuple>(ctx, pos) 
+            .Name().Build(key) 
+            .Value<TCoMember>() 
+                .Struct(keySelectorArg) 
+                .Name().Build(key) 
+                .Build() 
+            .Done(); 
+ 
+        keyTuples.emplace_back(tuple); 
+    } 
+ 
+    return Build<TCoLambda>(ctx, pos) 
+        .Args({keySelectorArg}) 
+        .Body<TCoAsStruct>() 
+            .Add(keyTuples) 
+            .Build() 
+        .Done(); 
+} 
+ 
+TCoLambda MakeRowsPayloadSelector(const TCoAtomList& columns, const TKikimrTableDescription& table, 
+    TPositionHandle pos, TExprContext& ctx) 
+{ 
+    for (const auto& key : table.Metadata->KeyColumnNames) { 
+        auto it = std::find_if(columns.begin(), columns.end(), [&key](const auto& x) { return x.Value() == key; }); 
+        YQL_ENSURE(it != columns.end(), "Key column not found in columns list: " << key); 
+    } 
+ 
+    auto payloadSelectorArg = TCoArgument(ctx.NewArgument(pos, "payload_selector_row")); 
+    TVector<TExprBase> payloadTuples; 
+    payloadTuples.reserve(columns.Size() - table.Metadata->KeyColumnNames.size()); 
+    for (const auto& column : columns) { 
+        if (table.GetKeyColumnIndex(TString(column))) { 
+            continue; 
+        } 
+ 
+        payloadTuples.emplace_back( 
+            Build<TCoNameValueTuple>(ctx, pos) 
+                .Name(column) 
+                .Value<TCoMember>() 
+                    .Struct(payloadSelectorArg) 
+                    .Name(column) 
+                    .Build() 
+                .Done()); 
+    } 
+ 
+    return Build<TCoLambda>(ctx, pos) 
+        .Args({payloadSelectorArg}) 
+        .Body<TCoAsStruct>() 
+            .Add(payloadTuples) 
+            .Build() 
+        .Done(); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_impl.h b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_impl.h
index 6712d94a19..a2815d8057 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_impl.h
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_impl.h
@@ -1,65 +1,65 @@
-#pragma once
-
-#include <ydb/core/kqp/opt/kqp_opt_impl.h>
-#include <ydb/core/kqp/opt/physical/kqp_opt_phy_impl.h>
-#include <ydb/core/kqp/provider/kqp_opt_helpers.h>
-
+#pragma once 
+ 
+#include <ydb/core/kqp/opt/kqp_opt_impl.h> 
+#include <ydb/core/kqp/opt/physical/kqp_opt_phy_impl.h> 
+#include <ydb/core/kqp/provider/kqp_opt_helpers.h> 
+ 
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/dq/opt/dq_opt.h>
-
-namespace NKikimr::NKqp::NOpt {
-
-using TSecondaryIndexes = TVector<std::pair<
-    NYql::TExprNode::TPtr,
-    const NYql::TIndexDescription*>>;
-
-TSecondaryIndexes BuildSecondaryIndexVector(const NYql::TKikimrTableDescription& table, NYql::TPositionHandle pos,
-    NYql::TExprContext& ctx, const THashSet<TStringBuf>* filter = nullptr);
-
-NYql::TExprNode::TPtr MakeMessage(TStringBuf message, NYql::TPositionHandle pos, NYql::TExprContext& ctx);
-
-struct TCondenseInputResult {
-    NYql::NNodes::TExprBase Stream;
-    TVector<NYql::NNodes::TExprBase> StageInputs;
-    TVector<NYql::NNodes::TCoArgument> StageArgs;
-};
-
-TMaybe<TCondenseInputResult> CondenseInput(const NYql::NNodes::TExprBase& input, NYql::TExprContext& ctx);
-
-TMaybe<TCondenseInputResult> CondenseAndDeduplicateInput(const NYql::NNodes::TExprBase& input,
-    const NYql::TKikimrTableDescription& table, NYql::TExprContext& ctx);
-
-TMaybe<TCondenseInputResult> CondenseInputToDictByPk(const NYql::NNodes::TExprBase& input,
-    const NYql::TKikimrTableDescription& table, const NYql::NNodes::TCoLambda& payloadSelector,
-    NYql::TExprContext& ctx);
-
-NYql::NNodes::TMaybeNode<NYql::NNodes::TDqPhyPrecompute> PrecomputeTableLookupDict(
-    const NYql::NNodes::TDqPhyPrecompute& lookupKeys, const NYql::TKikimrTableDescription& table,
-    const THashSet<TString>& dataColumns, const TSecondaryIndexes& indexes, NYql::TPositionHandle pos,
-    NYql::TExprContext& ctx);
-
-NYql::NNodes::TCoLambda MakeTableKeySelector(const NYql::TKikimrTableDescription& table, NYql::TPositionHandle pos,
-    NYql::TExprContext& ctx);
-
-NYql::NNodes::TCoLambda MakeRowsPayloadSelector(const NYql::NNodes::TCoAtomList& columns,
-    const NYql::TKikimrTableDescription& table, NYql::TPositionHandle pos, NYql::TExprContext& ctx);
-
-NYql::NNodes::TExprBase MakeRowsFromDict(const NYql::NNodes::TDqPhyPrecompute& dict, const TVector<TString>& dictKeys,
-    const THashSet<TStringBuf>& columns, NYql::TPositionHandle pos, NYql::TExprContext& ctx);
-
-NYql::NNodes::TMaybeNode<NYql::NNodes::TDqCnUnionAll> MakeConditionalInsertRows(const NYql::NNodes::TExprBase& input,
-    const NYql::TKikimrTableDescription& table, bool abortOnError, NYql::TPositionHandle pos, NYql::TExprContext& ctx);
-
-enum class TKqpPhyUpsertIndexMode {
-    Upsert,
-    UpdateOn
-};
-
-NYql::NNodes::TMaybeNode<NYql::NNodes::TExprList> KqpPhyUpsertIndexEffectsImpl(TKqpPhyUpsertIndexMode mode,
-    const NYql::NNodes::TExprBase& inputRows, const NYql::NNodes::TCoAtomList& inputColumns,
-    const NYql::TKikimrTableDescription& table, NYql::TPositionHandle pos, NYql::TExprContext& ctx);
-
-} // NKikimr::NKqp::NOpt
-
-
-
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using TSecondaryIndexes = TVector<std::pair< 
+    NYql::TExprNode::TPtr, 
+    const NYql::TIndexDescription*>>; 
+ 
+TSecondaryIndexes BuildSecondaryIndexVector(const NYql::TKikimrTableDescription& table, NYql::TPositionHandle pos, 
+    NYql::TExprContext& ctx, const THashSet<TStringBuf>* filter = nullptr); 
+ 
+NYql::TExprNode::TPtr MakeMessage(TStringBuf message, NYql::TPositionHandle pos, NYql::TExprContext& ctx); 
+ 
+struct TCondenseInputResult { 
+    NYql::NNodes::TExprBase Stream; 
+    TVector<NYql::NNodes::TExprBase> StageInputs; 
+    TVector<NYql::NNodes::TCoArgument> StageArgs; 
+}; 
+ 
+TMaybe<TCondenseInputResult> CondenseInput(const NYql::NNodes::TExprBase& input, NYql::TExprContext& ctx); 
+ 
+TMaybe<TCondenseInputResult> CondenseAndDeduplicateInput(const NYql::NNodes::TExprBase& input, 
+    const NYql::TKikimrTableDescription& table, NYql::TExprContext& ctx); 
+ 
+TMaybe<TCondenseInputResult> CondenseInputToDictByPk(const NYql::NNodes::TExprBase& input, 
+    const NYql::TKikimrTableDescription& table, const NYql::NNodes::TCoLambda& payloadSelector, 
+    NYql::TExprContext& ctx); 
+ 
+NYql::NNodes::TMaybeNode<NYql::NNodes::TDqPhyPrecompute> PrecomputeTableLookupDict( 
+    const NYql::NNodes::TDqPhyPrecompute& lookupKeys, const NYql::TKikimrTableDescription& table, 
+    const THashSet<TString>& dataColumns, const TSecondaryIndexes& indexes, NYql::TPositionHandle pos, 
+    NYql::TExprContext& ctx); 
+ 
+NYql::NNodes::TCoLambda MakeTableKeySelector(const NYql::TKikimrTableDescription& table, NYql::TPositionHandle pos, 
+    NYql::TExprContext& ctx); 
+ 
+NYql::NNodes::TCoLambda MakeRowsPayloadSelector(const NYql::NNodes::TCoAtomList& columns, 
+    const NYql::TKikimrTableDescription& table, NYql::TPositionHandle pos, NYql::TExprContext& ctx); 
+ 
+NYql::NNodes::TExprBase MakeRowsFromDict(const NYql::NNodes::TDqPhyPrecompute& dict, const TVector<TString>& dictKeys, 
+    const THashSet<TStringBuf>& columns, NYql::TPositionHandle pos, NYql::TExprContext& ctx); 
+ 
+NYql::NNodes::TMaybeNode<NYql::NNodes::TDqCnUnionAll> MakeConditionalInsertRows(const NYql::NNodes::TExprBase& input, 
+    const NYql::TKikimrTableDescription& table, bool abortOnError, NYql::TPositionHandle pos, NYql::TExprContext& ctx); 
+ 
+enum class TKqpPhyUpsertIndexMode { 
+    Upsert, 
+    UpdateOn 
+}; 
+ 
+NYql::NNodes::TMaybeNode<NYql::NNodes::TExprList> KqpPhyUpsertIndexEffectsImpl(TKqpPhyUpsertIndexMode mode, 
+    const NYql::NNodes::TExprBase& inputRows, const NYql::NNodes::TCoAtomList& inputColumns, 
+    const NYql::TKikimrTableDescription& table, NYql::TPositionHandle pos, NYql::TExprContext& ctx); 
+ 
+} // NKikimr::NKqp::NOpt 
+ 
+ 
+ 
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_rules.h b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_rules.h
index 42910d5879..e8edd2aabc 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_rules.h
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_rules.h
@@ -1,31 +1,31 @@
-#pragma once
-
-#include <ydb/core/kqp/opt/kqp_opt.h>
-#include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.h>
-
-#include <ydb/library/yql/ast/yql_expr.h>
-
-namespace NKikimr::NKqp::NOpt {
-
-NYql::NNodes::TExprBase KqpBuildUpdateStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx,
-    const TKqpOptimizeContext& kqpCtx);
-
-NYql::NNodes::TExprBase KqpBuildInsertStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx,
-    const TKqpOptimizeContext& kqpCtx);
-
-NYql::NNodes::TExprBase KqpBuildUpsertIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx,
-    const TKqpOptimizeContext& kqpCtx);
-
-NYql::NNodes::TExprBase KqpBuildReplaceIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx,
-    const TKqpOptimizeContext& kqpCtx);
-
-NYql::NNodes::TExprBase KqpBuildUpdateIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx,
-    const TKqpOptimizeContext& kqpCtx);
-
-NYql::NNodes::TExprBase KqpBuildInsertIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx,
-    const TKqpOptimizeContext& kqpCtx);
-
-NYql::NNodes::TExprBase KqpBuildDeleteIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx,
-    const TKqpOptimizeContext& kqpCtx);
-
-} // NKikimr::NKqp::NOpt
+#pragma once 
+ 
+#include <ydb/core/kqp/opt/kqp_opt.h> 
+#include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.h> 
+ 
+#include <ydb/library/yql/ast/yql_expr.h> 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+NYql::NNodes::TExprBase KqpBuildUpdateStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx, 
+    const TKqpOptimizeContext& kqpCtx); 
+ 
+NYql::NNodes::TExprBase KqpBuildInsertStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx, 
+    const TKqpOptimizeContext& kqpCtx); 
+ 
+NYql::NNodes::TExprBase KqpBuildUpsertIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx, 
+    const TKqpOptimizeContext& kqpCtx); 
+ 
+NYql::NNodes::TExprBase KqpBuildReplaceIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx, 
+    const TKqpOptimizeContext& kqpCtx); 
+ 
+NYql::NNodes::TExprBase KqpBuildUpdateIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx, 
+    const TKqpOptimizeContext& kqpCtx); 
+ 
+NYql::NNodes::TExprBase KqpBuildInsertIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx, 
+    const TKqpOptimizeContext& kqpCtx); 
+ 
+NYql::NNodes::TExprBase KqpBuildDeleteIndexStages(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx, 
+    const TKqpOptimizeContext& kqpCtx); 
+ 
+} // NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_indexes.cpp b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_indexes.cpp
index e0315a4c99..96c2fb09b2 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_indexes.cpp
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_indexes.cpp
@@ -1,147 +1,147 @@
-#include "kqp_opt_phy_effects_impl.h"
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-namespace {
-
-TDqPhyPrecompute PrecomputeDict(const TCondenseInputResult& condenseResult, TPositionHandle pos, TExprContext& ctx) {
-    auto computeDictStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(condenseResult.StageInputs)
-            .Build()
-        .Program()
-            .Args(condenseResult.StageArgs)
-            .Body(condenseResult.Stream)
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    return Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-            .Output()
-                .Stage(computeDictStage)
-                .Index().Build("0")
-                .Build()
-            .Build()
-        .Done();
-}
-
-} // namespace
-
-TSecondaryIndexes BuildSecondaryIndexVector(const TKikimrTableDescription& table, TPositionHandle pos,
-    TExprContext& ctx, const THashSet<TStringBuf>* filter)
-{
-    static auto cb = [] (const TKikimrTableMetadata& meta, TPositionHandle pos, TExprContext& ctx) -> TExprBase {
-        return BuildTableMeta(meta, pos, ctx);
-    };
-
-    return ::NKikimr::NKqp::BuildSecondaryIndexVector(table, pos, ctx, filter, cb);
-}
-
-TMaybeNode<TDqPhyPrecompute> PrecomputeTableLookupDict(const TDqPhyPrecompute& lookupKeys,
-    const TKikimrTableDescription& table, const THashSet<TString>& dataColumns, const TSecondaryIndexes& indexes,
-    TPositionHandle pos, TExprContext& ctx)
-{
-    auto lookupColumns = CreateColumnsToSelectToUpdateIndex(indexes, table.Metadata->KeyColumnNames, dataColumns,
-        pos, ctx);
-
-    auto lookupColumnsList = Build<TCoAtomList>(ctx, pos)
-        .Add(lookupColumns)
-        .Done();
-
-    auto lookupStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(lookupKeys)
-            .Build()
-        .Program()
-            .Args({"keys_list"})
-            .Body<TKqpLookupTable>()
-                .Table(BuildTableMeta(table, pos, ctx))
-                .LookupKeys<TCoIterator>()
-                    .List("keys_list")
-                    .Build()
-                .Columns(lookupColumnsList)
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    auto lookup = Build<TDqCnUnionAll>(ctx, pos)
-        .Output()
-            .Stage(lookupStage)
-            .Index().Build("0")
-            .Build()
-        .Done();
-
-    auto lookupPayloadSelector = MakeRowsPayloadSelector(lookupColumnsList, table, lookupKeys.Pos(), ctx);
-    auto condenseLookupResult = CondenseInputToDictByPk(lookup, table, lookupPayloadSelector, ctx);
-    if (!condenseLookupResult) {
-        return {};
-    }
-
-    return PrecomputeDict(*condenseLookupResult, lookupKeys.Pos(), ctx);
-}
-
-TExprBase MakeRowsFromDict(const TDqPhyPrecompute& dict, const TVector<TString>& dictKeys,
-    const THashSet<TStringBuf>& columns, TPositionHandle pos, TExprContext& ctx)
-{
-    THashSet<TString> dictKeysSet(dictKeys.begin(), dictKeys.end());
-    auto dictTupleArg = TCoArgument(ctx.NewArgument(pos, "dict_tuple"));
-
-    TVector<TExprBase> rowTuples;
-    for (const auto& column : columns) {
-        auto columnAtom = ctx.NewAtom(pos, column);
-        auto tupleIndex = dictKeysSet.contains(column)
-            ? 0  // Key
-            : 1; // Payload
-
-        auto tuple = Build<TCoNameValueTuple>(ctx, pos)
-            .Name(columnAtom)
-            .Value<TCoMember>()
-                .Struct<TCoNth>()
-                    .Tuple(dictTupleArg)
-                    .Index().Build(tupleIndex)
-                    .Build()
-                .Name(columnAtom)
-                .Build()
-            .Done();
-
-        rowTuples.emplace_back(std::move(tuple));
-    }
-
-    auto computeRowsStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(dict)
-            .Build()
-        .Program()
-            .Args({"dict"})
-            .Body<TCoIterator>()
-                .List<TCoMap>()
-                    .Input<TCoDictItems>()
-                        .Dict("dict")
-                        .Build()
-                    .Lambda()
-                        .Args(dictTupleArg)
-                        .Body<TCoAsStruct>()
-                            .Add(rowTuples)
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    return Build<TDqCnUnionAll>(ctx, pos)
-        .Output()
-            .Stage(computeRowsStage)
-            .Index().Build("0")
-            .Build()
-        .Done();
-}
-
-} // namespace NKikimr::NKqp::NOpt
+#include "kqp_opt_phy_effects_impl.h" 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NDq; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+TDqPhyPrecompute PrecomputeDict(const TCondenseInputResult& condenseResult, TPositionHandle pos, TExprContext& ctx) { 
+    auto computeDictStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(condenseResult.StageInputs) 
+            .Build() 
+        .Program() 
+            .Args(condenseResult.StageArgs) 
+            .Body(condenseResult.Stream) 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    return Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+            .Output() 
+                .Stage(computeDictStage) 
+                .Index().Build("0") 
+                .Build() 
+            .Build() 
+        .Done(); 
+} 
+ 
+} // namespace 
+ 
+TSecondaryIndexes BuildSecondaryIndexVector(const TKikimrTableDescription& table, TPositionHandle pos, 
+    TExprContext& ctx, const THashSet<TStringBuf>* filter) 
+{ 
+    static auto cb = [] (const TKikimrTableMetadata& meta, TPositionHandle pos, TExprContext& ctx) -> TExprBase { 
+        return BuildTableMeta(meta, pos, ctx); 
+    }; 
+ 
+    return ::NKikimr::NKqp::BuildSecondaryIndexVector(table, pos, ctx, filter, cb); 
+} 
+ 
+TMaybeNode<TDqPhyPrecompute> PrecomputeTableLookupDict(const TDqPhyPrecompute& lookupKeys, 
+    const TKikimrTableDescription& table, const THashSet<TString>& dataColumns, const TSecondaryIndexes& indexes, 
+    TPositionHandle pos, TExprContext& ctx) 
+{ 
+    auto lookupColumns = CreateColumnsToSelectToUpdateIndex(indexes, table.Metadata->KeyColumnNames, dataColumns, 
+        pos, ctx); 
+ 
+    auto lookupColumnsList = Build<TCoAtomList>(ctx, pos) 
+        .Add(lookupColumns) 
+        .Done(); 
+ 
+    auto lookupStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(lookupKeys) 
+            .Build() 
+        .Program() 
+            .Args({"keys_list"}) 
+            .Body<TKqpLookupTable>() 
+                .Table(BuildTableMeta(table, pos, ctx)) 
+                .LookupKeys<TCoIterator>() 
+                    .List("keys_list") 
+                    .Build() 
+                .Columns(lookupColumnsList) 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    auto lookup = Build<TDqCnUnionAll>(ctx, pos) 
+        .Output() 
+            .Stage(lookupStage) 
+            .Index().Build("0") 
+            .Build() 
+        .Done(); 
+ 
+    auto lookupPayloadSelector = MakeRowsPayloadSelector(lookupColumnsList, table, lookupKeys.Pos(), ctx); 
+    auto condenseLookupResult = CondenseInputToDictByPk(lookup, table, lookupPayloadSelector, ctx); 
+    if (!condenseLookupResult) { 
+        return {}; 
+    } 
+ 
+    return PrecomputeDict(*condenseLookupResult, lookupKeys.Pos(), ctx); 
+} 
+ 
+TExprBase MakeRowsFromDict(const TDqPhyPrecompute& dict, const TVector<TString>& dictKeys, 
+    const THashSet<TStringBuf>& columns, TPositionHandle pos, TExprContext& ctx) 
+{ 
+    THashSet<TString> dictKeysSet(dictKeys.begin(), dictKeys.end()); 
+    auto dictTupleArg = TCoArgument(ctx.NewArgument(pos, "dict_tuple")); 
+ 
+    TVector<TExprBase> rowTuples; 
+    for (const auto& column : columns) { 
+        auto columnAtom = ctx.NewAtom(pos, column); 
+        auto tupleIndex = dictKeysSet.contains(column) 
+            ? 0  // Key 
+            : 1; // Payload 
+ 
+        auto tuple = Build<TCoNameValueTuple>(ctx, pos) 
+            .Name(columnAtom) 
+            .Value<TCoMember>() 
+                .Struct<TCoNth>() 
+                    .Tuple(dictTupleArg) 
+                    .Index().Build(tupleIndex) 
+                    .Build() 
+                .Name(columnAtom) 
+                .Build() 
+            .Done(); 
+ 
+        rowTuples.emplace_back(std::move(tuple)); 
+    } 
+ 
+    auto computeRowsStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(dict) 
+            .Build() 
+        .Program() 
+            .Args({"dict"}) 
+            .Body<TCoIterator>() 
+                .List<TCoMap>() 
+                    .Input<TCoDictItems>() 
+                        .Dict("dict") 
+                        .Build() 
+                    .Lambda() 
+                        .Args(dictTupleArg) 
+                        .Body<TCoAsStruct>() 
+                            .Add(rowTuples) 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    return Build<TDqCnUnionAll>(ctx, pos) 
+        .Output() 
+            .Stage(computeRowsStage) 
+            .Index().Build("0") 
+            .Build() 
+        .Done(); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_insert.cpp b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_insert.cpp
index c6782b6c03..6e8419c03e 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_insert.cpp
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_insert.cpp
@@ -1,277 +1,277 @@
-#include "kqp_opt_phy_effects_rules.h"
-#include "kqp_opt_phy_effects_impl.h"
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-TMaybeNode<TDqCnUnionAll> MakeConditionalInsertRows(const TExprBase& input, const TKikimrTableDescription& table,
-    bool abortOnError, TPositionHandle pos, TExprContext& ctx)
-{
-    auto condenseResult = CondenseInput(input, ctx);
-    if (!condenseResult) {
-        return {};
-    }
-
-    TCoArgument rowsListArg(ctx.NewArgument(pos, "rows_list"));
-
-    auto dict = Build<TCoToDict>(ctx, pos)
-        .List(rowsListArg)
-        .KeySelector(MakeTableKeySelector(table, pos, ctx))
-        .PayloadSelector()
-            .Args({"stub"})
-            .Body<TCoVoid>()
-                .Build()
-            .Build()
-        .Settings()
-            .Add().Build("One")
-            .Add().Build("Hashed")
-            .Build()
-        .Done();
-
-    auto dictKeys = Build<TCoDictKeys>(ctx, pos)
-        .Dict(dict)
-        .Done();
-
-    auto areKeysUniqueValue = Build<TCoCmpEqual>(ctx, pos)
-        .Left<TCoLength>()
-            .List(rowsListArg)
-            .Build()
-        .Right<TCoLength>()
-            .List(dict)
-            .Build()
-        .Done();
-
-    auto variantType = Build<TCoVariantType>(ctx, pos)
-        .UnderlyingType<TCoTupleType>()
-            .Add<TCoTypeOf>()
-                .Value(rowsListArg)
-                .Build()
-            .Add<TCoTypeOf>()
-                .Value(dictKeys)
-                .Build()
-            .Add<TCoTypeOf>()
-                .Value(areKeysUniqueValue)
-                .Build()
-            .Build()
-        .Done();
-
-    auto computeKeysStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(condenseResult->StageInputs)
-            .Build()
-        .Program()
-            .Args(condenseResult->StageArgs)
-            .Body<TCoFlatMap>()
-                .Input(condenseResult->Stream)
-                .Lambda()
-                    .Args({rowsListArg})
-                    .Body<TCoAsList>()
-                        .Add<TCoVariant>()
-                            .Item(rowsListArg)
-                            .Index().Build("0")
-                            .VarType(variantType)
-                            .Build()
-                        .Add<TCoVariant>()
-                            .Item(dictKeys)
-                            .Index().Build("1")
-                            .VarType(variantType)
-                            .Build()
-                        .Add<TCoVariant>()
-                            .Item(areKeysUniqueValue)
-                            .Index().Build("2")
-                            .VarType(variantType)
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    auto inputPrecompute = Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-           .Output()
-               .Stage(computeKeysStage)
-               .Index().Build("0")
-               .Build()
-           .Build()
-        .Done();
-
-    auto lookupKeysPrecompute = Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-           .Output()
-               .Stage(computeKeysStage)
-               .Index().Build("1")
-               .Build()
-           .Build()
-        .Done();
-
-    auto areKeysUniquePrecompute = Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-           .Output()
-               .Stage(computeKeysStage)
-               .Index().Build("2")
-               .Build()
-           .Build()
-        .Done();
-
-    auto _true = MakeBool(pos, true, ctx);
-    auto _false = MakeBool(pos, false, ctx);
-
-    // Returns optional<bool>: <none> - nothing found, <false> - at least one key exists
-    auto lookupStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(lookupKeysPrecompute)
-            .Build()
-        .Program()
-            .Args({"keys_list"})
-            .Body<TCoFlatMap>()
-                .Input<TCoTake>()
-                    .Input<TKqpLookupTable>()
-                        .Table(BuildTableMeta(table, pos, ctx))
-                        .LookupKeys<TCoIterator>()
-                            .List("keys_list")
-                            .Build()
-                        .Columns()
-                            .Build()
-                        .Build()
-                    .Count<TCoUint64>()
-                        .Literal().Build("1")
-                        .Build()
-                    .Build()
-                .Lambda()
-                    .Args({"row"})
-                    .Body<TCoJust>()
-                        .Input(_false)
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    // Returns <bool>: <true> - nothing found, <false> - at least one key exists
-    auto aggrStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add<TDqCnUnionAll>()
-                .Output()
-                    .Stage(lookupStage)
-                    .Index().Build("0")
-                    .Build()
-                .Build()
-            .Build()
-        .Program()
-            .Args({"row"})
-            .Body<TCoCondense>()
-                .Input("row")
-                .State(_true)
-                .SwitchHandler()
-                    .Args({"item", "state"})
-                    .Body(_false)
-                    .Build()
-                .UpdateHandler()
-                    .Args({"item", "state"})
-                    .Body(_false)
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    // Returns <bool>: <true> - no existing keys, <false> - at least one key exists
-    auto noExistingKeysPrecompute = Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-            .Output()
-                .Stage(aggrStage)
-                .Index().Build("0")
-                .Build()
-            .Build()
-        .Done();
-
-    // Build condition checks depending on INSERT kind
-    TCoArgument inputRowsArg(ctx.NewArgument(pos, "input_rows"));
-    TCoArgument areKeysUniquesArg(ctx.NewArgument(pos, "are_keys_unique"));
-    TCoArgument noExistingKeysArg(ctx.NewArgument(pos, "no_existing_keys"));
-
-    TExprNode::TPtr uniqueKeysCheck;
-    TExprNode::TPtr noExistingKeysCheck;
-
-    if (abortOnError) {
-        uniqueKeysCheck = Build<TKqpEnsure>(ctx, pos)
-            .Value(_true)
-            .Predicate(areKeysUniquesArg)
-            .IssueCode().Build(ToString((ui32) TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION))
-            .Message(MakeMessage("Duplicated keys found.", pos, ctx))
-            .Done().Ptr();
-
-        noExistingKeysCheck = Build<TKqpEnsure>(ctx, pos)
-            .Value(_true)
-            .Predicate(noExistingKeysArg)
-            .IssueCode().Build(ToString((ui32) TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION))
-            .Message(MakeMessage("Conflict with existing key.", pos, ctx))
-            .Done().Ptr();
-    } else {
-        uniqueKeysCheck = areKeysUniquesArg.Ptr();
-        noExistingKeysCheck = noExistingKeysArg.Ptr();
-    }
-
-    // Final pure compute stage to compute rows to insert and check for both conditions:
-    // 1. No rows were found in table PK from input
-    // 2. No duplicate PKs were found in input
-    auto conditionStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(inputPrecompute)
-            .Add(areKeysUniquePrecompute)
-            .Add(noExistingKeysPrecompute)
-            .Build()
-        .Program()
-            .Args({inputRowsArg, areKeysUniquesArg, noExistingKeysArg})
-            .Body<TCoToStream>()
-                .Input<TCoIfStrict>()
-                    .Predicate<TCoAnd>()
-                        .Add(uniqueKeysCheck)
-                        .Add(noExistingKeysCheck)
-                        .Build()
-                    .ThenValue(inputRowsArg)
-                    .ElseValue<TCoList>()
-                        .ListType(ExpandType(pos, *input.Ref().GetTypeAnn(), ctx))
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    return Build<TDqCnUnionAll>(ctx, pos)
-        .Output()
-            .Stage(conditionStage)
-            .Index().Build("0")
-            .Build()
-        .Done();
-}
-
-TExprBase KqpBuildInsertStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) {
-    if (!node.Maybe<TKqlInsertRows>()) {
-        return node;
-    }
-
-    auto insert = node.Cast<TKqlInsertRows>();
-    bool abortOnError = insert.OnConflict().Value() == "abort"sv;
-    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, insert.Table().Path());
-
-    auto insertRows = MakeConditionalInsertRows(insert.Input(), table, abortOnError, insert.Pos(), ctx);
-    if (!insertRows) {
-        return node;
-    }
-
-    return Build<TKqlUpsertRows>(ctx, insert.Pos())
-        .Table(insert.Table())
-        .Input(insertRows.Cast())
-        .Columns(insert.Columns())
-        .Done();
-}
-
-} // namespace NKikimr::NKqp::NOpt
+#include "kqp_opt_phy_effects_rules.h" 
+#include "kqp_opt_phy_effects_impl.h" 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NDq; 
+using namespace NYql::NNodes; 
+ 
+TMaybeNode<TDqCnUnionAll> MakeConditionalInsertRows(const TExprBase& input, const TKikimrTableDescription& table, 
+    bool abortOnError, TPositionHandle pos, TExprContext& ctx) 
+{ 
+    auto condenseResult = CondenseInput(input, ctx); 
+    if (!condenseResult) { 
+        return {}; 
+    } 
+ 
+    TCoArgument rowsListArg(ctx.NewArgument(pos, "rows_list")); 
+ 
+    auto dict = Build<TCoToDict>(ctx, pos) 
+        .List(rowsListArg) 
+        .KeySelector(MakeTableKeySelector(table, pos, ctx)) 
+        .PayloadSelector() 
+            .Args({"stub"}) 
+            .Body<TCoVoid>() 
+                .Build() 
+            .Build() 
+        .Settings() 
+            .Add().Build("One") 
+            .Add().Build("Hashed") 
+            .Build() 
+        .Done(); 
+ 
+    auto dictKeys = Build<TCoDictKeys>(ctx, pos) 
+        .Dict(dict) 
+        .Done(); 
+ 
+    auto areKeysUniqueValue = Build<TCoCmpEqual>(ctx, pos) 
+        .Left<TCoLength>() 
+            .List(rowsListArg) 
+            .Build() 
+        .Right<TCoLength>() 
+            .List(dict) 
+            .Build() 
+        .Done(); 
+ 
+    auto variantType = Build<TCoVariantType>(ctx, pos) 
+        .UnderlyingType<TCoTupleType>() 
+            .Add<TCoTypeOf>() 
+                .Value(rowsListArg) 
+                .Build() 
+            .Add<TCoTypeOf>() 
+                .Value(dictKeys) 
+                .Build() 
+            .Add<TCoTypeOf>() 
+                .Value(areKeysUniqueValue) 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    auto computeKeysStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(condenseResult->StageInputs) 
+            .Build() 
+        .Program() 
+            .Args(condenseResult->StageArgs) 
+            .Body<TCoFlatMap>() 
+                .Input(condenseResult->Stream) 
+                .Lambda() 
+                    .Args({rowsListArg}) 
+                    .Body<TCoAsList>() 
+                        .Add<TCoVariant>() 
+                            .Item(rowsListArg) 
+                            .Index().Build("0") 
+                            .VarType(variantType) 
+                            .Build() 
+                        .Add<TCoVariant>() 
+                            .Item(dictKeys) 
+                            .Index().Build("1") 
+                            .VarType(variantType) 
+                            .Build() 
+                        .Add<TCoVariant>() 
+                            .Item(areKeysUniqueValue) 
+                            .Index().Build("2") 
+                            .VarType(variantType) 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    auto inputPrecompute = Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+           .Output() 
+               .Stage(computeKeysStage) 
+               .Index().Build("0") 
+               .Build() 
+           .Build() 
+        .Done(); 
+ 
+    auto lookupKeysPrecompute = Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+           .Output() 
+               .Stage(computeKeysStage) 
+               .Index().Build("1") 
+               .Build() 
+           .Build() 
+        .Done(); 
+ 
+    auto areKeysUniquePrecompute = Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+           .Output() 
+               .Stage(computeKeysStage) 
+               .Index().Build("2") 
+               .Build() 
+           .Build() 
+        .Done(); 
+ 
+    auto _true = MakeBool(pos, true, ctx); 
+    auto _false = MakeBool(pos, false, ctx); 
+ 
+    // Returns optional<bool>: <none> - nothing found, <false> - at least one key exists 
+    auto lookupStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(lookupKeysPrecompute) 
+            .Build() 
+        .Program() 
+            .Args({"keys_list"}) 
+            .Body<TCoFlatMap>() 
+                .Input<TCoTake>() 
+                    .Input<TKqpLookupTable>() 
+                        .Table(BuildTableMeta(table, pos, ctx)) 
+                        .LookupKeys<TCoIterator>() 
+                            .List("keys_list") 
+                            .Build() 
+                        .Columns() 
+                            .Build() 
+                        .Build() 
+                    .Count<TCoUint64>() 
+                        .Literal().Build("1") 
+                        .Build() 
+                    .Build() 
+                .Lambda() 
+                    .Args({"row"}) 
+                    .Body<TCoJust>() 
+                        .Input(_false) 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    // Returns <bool>: <true> - nothing found, <false> - at least one key exists 
+    auto aggrStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add<TDqCnUnionAll>() 
+                .Output() 
+                    .Stage(lookupStage) 
+                    .Index().Build("0") 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Program() 
+            .Args({"row"}) 
+            .Body<TCoCondense>() 
+                .Input("row") 
+                .State(_true) 
+                .SwitchHandler() 
+                    .Args({"item", "state"}) 
+                    .Body(_false) 
+                    .Build() 
+                .UpdateHandler() 
+                    .Args({"item", "state"}) 
+                    .Body(_false) 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    // Returns <bool>: <true> - no existing keys, <false> - at least one key exists 
+    auto noExistingKeysPrecompute = Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+            .Output() 
+                .Stage(aggrStage) 
+                .Index().Build("0") 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    // Build condition checks depending on INSERT kind 
+    TCoArgument inputRowsArg(ctx.NewArgument(pos, "input_rows")); 
+    TCoArgument areKeysUniquesArg(ctx.NewArgument(pos, "are_keys_unique")); 
+    TCoArgument noExistingKeysArg(ctx.NewArgument(pos, "no_existing_keys")); 
+ 
+    TExprNode::TPtr uniqueKeysCheck; 
+    TExprNode::TPtr noExistingKeysCheck; 
+ 
+    if (abortOnError) { 
+        uniqueKeysCheck = Build<TKqpEnsure>(ctx, pos) 
+            .Value(_true) 
+            .Predicate(areKeysUniquesArg) 
+            .IssueCode().Build(ToString((ui32) TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION)) 
+            .Message(MakeMessage("Duplicated keys found.", pos, ctx)) 
+            .Done().Ptr(); 
+ 
+        noExistingKeysCheck = Build<TKqpEnsure>(ctx, pos) 
+            .Value(_true) 
+            .Predicate(noExistingKeysArg) 
+            .IssueCode().Build(ToString((ui32) TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION)) 
+            .Message(MakeMessage("Conflict with existing key.", pos, ctx)) 
+            .Done().Ptr(); 
+    } else { 
+        uniqueKeysCheck = areKeysUniquesArg.Ptr(); 
+        noExistingKeysCheck = noExistingKeysArg.Ptr(); 
+    } 
+ 
+    // Final pure compute stage to compute rows to insert and check for both conditions: 
+    // 1. No rows were found in table PK from input 
+    // 2. No duplicate PKs were found in input 
+    auto conditionStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(inputPrecompute) 
+            .Add(areKeysUniquePrecompute) 
+            .Add(noExistingKeysPrecompute) 
+            .Build() 
+        .Program() 
+            .Args({inputRowsArg, areKeysUniquesArg, noExistingKeysArg}) 
+            .Body<TCoToStream>() 
+                .Input<TCoIfStrict>() 
+                    .Predicate<TCoAnd>() 
+                        .Add(uniqueKeysCheck) 
+                        .Add(noExistingKeysCheck) 
+                        .Build() 
+                    .ThenValue(inputRowsArg) 
+                    .ElseValue<TCoList>() 
+                        .ListType(ExpandType(pos, *input.Ref().GetTypeAnn(), ctx)) 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    return Build<TDqCnUnionAll>(ctx, pos) 
+        .Output() 
+            .Stage(conditionStage) 
+            .Index().Build("0") 
+            .Build() 
+        .Done(); 
+} 
+ 
+TExprBase KqpBuildInsertStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) { 
+    if (!node.Maybe<TKqlInsertRows>()) { 
+        return node; 
+    } 
+ 
+    auto insert = node.Cast<TKqlInsertRows>(); 
+    bool abortOnError = insert.OnConflict().Value() == "abort"sv; 
+    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, insert.Table().Path()); 
+ 
+    auto insertRows = MakeConditionalInsertRows(insert.Input(), table, abortOnError, insert.Pos(), ctx); 
+    if (!insertRows) { 
+        return node; 
+    } 
+ 
+    return Build<TKqlUpsertRows>(ctx, insert.Pos()) 
+        .Table(insert.Table()) 
+        .Input(insertRows.Cast()) 
+        .Columns(insert.Columns()) 
+        .Done(); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_insert_index.cpp b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_insert_index.cpp
index 205929f7fa..47e67372ba 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_insert_index.cpp
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_insert_index.cpp
@@ -1,148 +1,148 @@
-#include "kqp_opt_phy_effects_rules.h"
-#include "kqp_opt_phy_effects_impl.h"
-
+#include "kqp_opt_phy_effects_rules.h" 
+#include "kqp_opt_phy_effects_impl.h" 
+ 
 #include <ydb/library/yql/providers/common/provider/yql_provider.h>
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-namespace {
-
-TExprBase MakeInsertIndexRows(const TDqPhyPrecompute& inputRows, const TKikimrTableDescription& table,
-    const THashSet<TStringBuf>& inputColumns, const THashSet<TStringBuf>& indexColumns,
-    TPositionHandle pos, TExprContext& ctx)
-{
-    auto inputRowArg = TCoArgument(ctx.NewArgument(pos, "input_row"));
-
-    TVector<TExprBase> rowTuples;
-    for (const auto& column : indexColumns) {
-        auto columnAtom = ctx.NewAtom(pos, column);
-
-        if (inputColumns.contains(column)) {
-            auto tuple = Build<TCoNameValueTuple>(ctx, pos)
-                .Name(columnAtom)
-                .Value<TCoMember>()
-                    .Struct(inputRowArg)
-                    .Name(columnAtom)
-                    .Build()
-                .Done();
-
-            rowTuples.emplace_back(tuple);
-        } else {
-            auto columnType = table.GetColumnType(TString(column));
-
-            auto tuple = Build<TCoNameValueTuple>(ctx, pos)
-                .Name(columnAtom)
-                .Value<TCoNothing>()
-                    .OptionalType(NCommon::BuildTypeExpr(pos, *columnType, ctx))
-                    .Build()
-                .Done();
-
-            rowTuples.emplace_back(tuple);
-        }
-    }
-
-    auto computeRowsStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(inputRows)
-            .Build()
-        .Program()
-            .Args({"rows"})
-            .Body<TCoIterator>()
-                .List<TCoMap>()
-                    .Input("rows")
-                    .Lambda()
-                        .Args(inputRowArg)
-                        .Body<TCoAsStruct>()
-                            .Add(rowTuples)
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    return Build<TDqCnUnionAll>(ctx, pos)
-        .Output()
-            .Stage(computeRowsStage)
-            .Index().Build("0")
-            .Build()
-        .Done();
-}
-
-} // namespace
-
-TExprBase KqpBuildInsertIndexStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) {
-    if (!node.Maybe<TKqlInsertRowsIndex>()) {
-        return node;
-    }
-
-    auto insert = node.Cast<TKqlInsertRowsIndex>();
-    bool abortOnError = insert.OnConflict().Value() == "abort"sv;
-    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, insert.Table().Path());
-
-    auto insertRows = MakeConditionalInsertRows(insert.Input(), table, abortOnError, insert.Pos(), ctx);
-    if (!insertRows) {
-        return node;
-    }
-
-    auto insertRowsPrecompute = Build<TDqPhyPrecompute>(ctx, node.Pos())
-        .Connection(insertRows.Cast())
-        .Done();
-
-    THashSet<TStringBuf> inputColumnsSet;
-    for (const auto& column : insert.Columns()) {
-        inputColumnsSet.emplace(column.Value());
-    }
-
-    auto indexes = BuildSecondaryIndexVector(table, insert.Pos(), ctx);
-    YQL_ENSURE(indexes);
-
-    auto upsertTable = Build<TKqlUpsertRows>(ctx, insert.Pos())
-        .Table(insert.Table())
-        .Input(insertRowsPrecompute)
-        .Columns(insert.Columns())
-        .Done();
-
-    TVector<TExprBase> effects;
-    effects.emplace_back(upsertTable);
-
-    for (const auto& [tableNode, indexDesc] : indexes) {
-        THashSet<TStringBuf> indexTableColumns;
-
-        for (const auto& column : indexDesc->KeyColumns) {
-            YQL_ENSURE(indexTableColumns.emplace(column).second);
-        }
-
-        for (const auto& column : table.Metadata->KeyColumnNames) {
-            indexTableColumns.insert(column);
-        }
-
-        for (const auto& column : indexDesc->DataColumns) {
-            if (inputColumnsSet.contains(column)) {
-                YQL_ENSURE(indexTableColumns.emplace(column).second);
-            }
-        }
-
-        auto upsertIndexRows = MakeInsertIndexRows(insertRowsPrecompute, table, inputColumnsSet, indexTableColumns,
-            insert.Pos(), ctx);
-
-        auto upsertIndex = Build<TKqlUpsertRows>(ctx, insert.Pos())
-            .Table(tableNode)
-            .Input(upsertIndexRows)
-            .Columns(BuildColumnsList(indexTableColumns, insert.Pos(), ctx))
-            .Done();
-
-        effects.emplace_back(upsertIndex);
-    }
-
-    return Build<TExprList>(ctx, insert.Pos())
-        .Add(effects)
-        .Done();
-}
-
-} // namespace NKikimr::NKqp::NOpt
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NDq; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+TExprBase MakeInsertIndexRows(const TDqPhyPrecompute& inputRows, const TKikimrTableDescription& table, 
+    const THashSet<TStringBuf>& inputColumns, const THashSet<TStringBuf>& indexColumns, 
+    TPositionHandle pos, TExprContext& ctx) 
+{ 
+    auto inputRowArg = TCoArgument(ctx.NewArgument(pos, "input_row")); 
+ 
+    TVector<TExprBase> rowTuples; 
+    for (const auto& column : indexColumns) { 
+        auto columnAtom = ctx.NewAtom(pos, column); 
+ 
+        if (inputColumns.contains(column)) { 
+            auto tuple = Build<TCoNameValueTuple>(ctx, pos) 
+                .Name(columnAtom) 
+                .Value<TCoMember>() 
+                    .Struct(inputRowArg) 
+                    .Name(columnAtom) 
+                    .Build() 
+                .Done(); 
+ 
+            rowTuples.emplace_back(tuple); 
+        } else { 
+            auto columnType = table.GetColumnType(TString(column)); 
+ 
+            auto tuple = Build<TCoNameValueTuple>(ctx, pos) 
+                .Name(columnAtom) 
+                .Value<TCoNothing>() 
+                    .OptionalType(NCommon::BuildTypeExpr(pos, *columnType, ctx)) 
+                    .Build() 
+                .Done(); 
+ 
+            rowTuples.emplace_back(tuple); 
+        } 
+    } 
+ 
+    auto computeRowsStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(inputRows) 
+            .Build() 
+        .Program() 
+            .Args({"rows"}) 
+            .Body<TCoIterator>() 
+                .List<TCoMap>() 
+                    .Input("rows") 
+                    .Lambda() 
+                        .Args(inputRowArg) 
+                        .Body<TCoAsStruct>() 
+                            .Add(rowTuples) 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    return Build<TDqCnUnionAll>(ctx, pos) 
+        .Output() 
+            .Stage(computeRowsStage) 
+            .Index().Build("0") 
+            .Build() 
+        .Done(); 
+} 
+ 
+} // namespace 
+ 
+TExprBase KqpBuildInsertIndexStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) { 
+    if (!node.Maybe<TKqlInsertRowsIndex>()) { 
+        return node; 
+    } 
+ 
+    auto insert = node.Cast<TKqlInsertRowsIndex>(); 
+    bool abortOnError = insert.OnConflict().Value() == "abort"sv; 
+    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, insert.Table().Path()); 
+ 
+    auto insertRows = MakeConditionalInsertRows(insert.Input(), table, abortOnError, insert.Pos(), ctx); 
+    if (!insertRows) { 
+        return node; 
+    } 
+ 
+    auto insertRowsPrecompute = Build<TDqPhyPrecompute>(ctx, node.Pos()) 
+        .Connection(insertRows.Cast()) 
+        .Done(); 
+ 
+    THashSet<TStringBuf> inputColumnsSet; 
+    for (const auto& column : insert.Columns()) { 
+        inputColumnsSet.emplace(column.Value()); 
+    } 
+ 
+    auto indexes = BuildSecondaryIndexVector(table, insert.Pos(), ctx); 
+    YQL_ENSURE(indexes); 
+ 
+    auto upsertTable = Build<TKqlUpsertRows>(ctx, insert.Pos()) 
+        .Table(insert.Table()) 
+        .Input(insertRowsPrecompute) 
+        .Columns(insert.Columns()) 
+        .Done(); 
+ 
+    TVector<TExprBase> effects; 
+    effects.emplace_back(upsertTable); 
+ 
+    for (const auto& [tableNode, indexDesc] : indexes) { 
+        THashSet<TStringBuf> indexTableColumns; 
+ 
+        for (const auto& column : indexDesc->KeyColumns) { 
+            YQL_ENSURE(indexTableColumns.emplace(column).second); 
+        } 
+ 
+        for (const auto& column : table.Metadata->KeyColumnNames) { 
+            indexTableColumns.insert(column); 
+        } 
+ 
+        for (const auto& column : indexDesc->DataColumns) { 
+            if (inputColumnsSet.contains(column)) { 
+                YQL_ENSURE(indexTableColumns.emplace(column).second); 
+            } 
+        } 
+ 
+        auto upsertIndexRows = MakeInsertIndexRows(insertRowsPrecompute, table, inputColumnsSet, indexTableColumns, 
+            insert.Pos(), ctx); 
+ 
+        auto upsertIndex = Build<TKqlUpsertRows>(ctx, insert.Pos()) 
+            .Table(tableNode) 
+            .Input(upsertIndexRows) 
+            .Columns(BuildColumnsList(indexTableColumns, insert.Pos(), ctx)) 
+            .Done(); 
+ 
+        effects.emplace_back(upsertIndex); 
+    } 
+ 
+    return Build<TExprList>(ctx, insert.Pos()) 
+        .Add(effects) 
+        .Done(); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_update.cpp b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_update.cpp
index 06d4714c14..fdf6b062a7 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_update.cpp
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_update.cpp
@@ -1,167 +1,167 @@
-#include "kqp_opt_phy_effects_rules.h"
-#include "kqp_opt_phy_effects_impl.h"
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-namespace {
-
-struct TDictAndKeysResult {
-    TDqPhyPrecompute DictPrecompute;
-    TDqPhyPrecompute KeysPrecompute;
-};
-
-TDictAndKeysResult PrecomputeDictAndKeys(const TCondenseInputResult& condenseResult, TPositionHandle pos,
-    TExprContext& ctx)
-{
-    auto dictType = Build<TCoListItemType>(ctx, pos)
-        .ListType<TCoTypeOf>()
-            .Value<TCoCollect>()
-                .Input(condenseResult.Stream)
-                .Build()
-            .Build()
-        .Done();
-
-    auto variantType = Build<TCoVariantType>(ctx, pos)
-        .UnderlyingType<TCoTupleType>()
-            .Add(dictType)
-            .Add<TCoListType>()
-                .ItemType<TCoDictKeyType>()
-                    .DictType(dictType)
-                    .Build()
-                .Build()
-            .Build()
-        .Done();
-
-    auto computeKeysStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(condenseResult.StageInputs)
-            .Build()
-        .Program()
-            .Args(condenseResult.StageArgs)
-            .Body<TCoFlatMap>()
-                .Input(condenseResult.Stream)
-                .Lambda()
-                    .Args({"dict"})
-                    .Body<TCoAsList>()
-                        .Add<TCoVariant>()
-                            .Item("dict")
-                            .Index().Build("0")
-                            .VarType(variantType)
-                            .Build()
-                        .Add<TCoVariant>()
-                            .Item<TCoDictKeys>()
-                                .Dict("dict")
-                                .Build()
-                            .Index().Build("1")
-                            .VarType(variantType)
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    auto dictPrecompute = Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-            .Output()
-                .Stage(computeKeysStage)
-                .Index().Build("0")
-                .Build()
-            .Build()
-        .Done();
-
-    auto keysPrecompute = Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-            .Output()
-                .Stage(computeKeysStage)
-                .Index().Build("1")
-                .Build()
-            .Build()
-        .Done();
-
-    return TDictAndKeysResult {
-        .DictPrecompute = dictPrecompute,
-        .KeysPrecompute = keysPrecompute
-    };
-}
-
-} // namespace
-
-TExprBase KqpBuildUpdateStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) {
-    if (!node.Maybe<TKqlUpdateRows>()) {
-        return node;
-    }
-    auto update = node.Cast<TKqlUpdateRows>();
-
-    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, update.Table().Path());
-
-    auto payloadSelector = MakeRowsPayloadSelector(update.Columns(), table, update.Pos(), ctx);
-    auto condenseResult = CondenseInputToDictByPk(update.Input(), table, payloadSelector, ctx);
-    if (!condenseResult) {
-        return node;
-    }
-
-    auto inputDictAndKeys = PrecomputeDictAndKeys(*condenseResult, update.Pos(), ctx);
-
-    auto prepareUpdateStage = Build<TDqStage>(ctx, update.Pos())
-        .Inputs()
-            .Add(inputDictAndKeys.KeysPrecompute)
-            .Add(inputDictAndKeys.DictPrecompute)
-            .Build()
-        .Program()
-            .Args({"keys_list", "dict"})
-            .Body<TCoFlatMap>()
-                .Input<TKqpLookupTable>()
-                    .Table(update.Table())
-                    .LookupKeys<TCoIterator>()
-                        .List("keys_list")
-                        .Build()
-                    .Columns(BuildColumnsList(table.Metadata->KeyColumnNames, update.Pos(), ctx))
-                    .Build()
-                .Lambda()
-                    .Args({"existingKey"})
-                    .Body<TCoJust>()
-                        .Input<TCoFlattenMembers>()
-                            .Add()
-                                .Name().Build("")
-                                .Value<TCoUnwrap>() // Key should always exist in the dict
-                                    .Optional<TCoLookup>()
-                                        .Collection("dict")
-                                        .Lookup("existingKey")
-                                        .Build()
-                                    .Build()
-                                .Build()
-                            .Add()
-                                .Name().Build("")
-                                .Value("existingKey")
-                                .Build()
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    auto prepareUpdate = Build<TDqCnUnionAll>(ctx, update.Pos())
-        .Output()
-            .Stage(prepareUpdateStage)
-            .Index().Build("0")
-            .Build()
-        .Done();
-
-    return Build<TKqlUpsertRows>(ctx, node.Pos())
-        .Table(update.Table())
-        .Input(prepareUpdate)
-        .Columns(update.Columns())
-        .Done();
-
-    return node;
-}
-
-} // namespace NKikimr::NKqp::NOpt
+#include "kqp_opt_phy_effects_rules.h" 
+#include "kqp_opt_phy_effects_impl.h" 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NDq; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+struct TDictAndKeysResult { 
+    TDqPhyPrecompute DictPrecompute; 
+    TDqPhyPrecompute KeysPrecompute; 
+}; 
+ 
+TDictAndKeysResult PrecomputeDictAndKeys(const TCondenseInputResult& condenseResult, TPositionHandle pos, 
+    TExprContext& ctx) 
+{ 
+    auto dictType = Build<TCoListItemType>(ctx, pos) 
+        .ListType<TCoTypeOf>() 
+            .Value<TCoCollect>() 
+                .Input(condenseResult.Stream) 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    auto variantType = Build<TCoVariantType>(ctx, pos) 
+        .UnderlyingType<TCoTupleType>() 
+            .Add(dictType) 
+            .Add<TCoListType>() 
+                .ItemType<TCoDictKeyType>() 
+                    .DictType(dictType) 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    auto computeKeysStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(condenseResult.StageInputs) 
+            .Build() 
+        .Program() 
+            .Args(condenseResult.StageArgs) 
+            .Body<TCoFlatMap>() 
+                .Input(condenseResult.Stream) 
+                .Lambda() 
+                    .Args({"dict"}) 
+                    .Body<TCoAsList>() 
+                        .Add<TCoVariant>() 
+                            .Item("dict") 
+                            .Index().Build("0") 
+                            .VarType(variantType) 
+                            .Build() 
+                        .Add<TCoVariant>() 
+                            .Item<TCoDictKeys>() 
+                                .Dict("dict") 
+                                .Build() 
+                            .Index().Build("1") 
+                            .VarType(variantType) 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    auto dictPrecompute = Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+            .Output() 
+                .Stage(computeKeysStage) 
+                .Index().Build("0") 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    auto keysPrecompute = Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+            .Output() 
+                .Stage(computeKeysStage) 
+                .Index().Build("1") 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    return TDictAndKeysResult { 
+        .DictPrecompute = dictPrecompute, 
+        .KeysPrecompute = keysPrecompute 
+    }; 
+} 
+ 
+} // namespace 
+ 
+TExprBase KqpBuildUpdateStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) { 
+    if (!node.Maybe<TKqlUpdateRows>()) { 
+        return node; 
+    } 
+    auto update = node.Cast<TKqlUpdateRows>(); 
+ 
+    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, update.Table().Path()); 
+ 
+    auto payloadSelector = MakeRowsPayloadSelector(update.Columns(), table, update.Pos(), ctx); 
+    auto condenseResult = CondenseInputToDictByPk(update.Input(), table, payloadSelector, ctx); 
+    if (!condenseResult) { 
+        return node; 
+    } 
+ 
+    auto inputDictAndKeys = PrecomputeDictAndKeys(*condenseResult, update.Pos(), ctx); 
+ 
+    auto prepareUpdateStage = Build<TDqStage>(ctx, update.Pos()) 
+        .Inputs() 
+            .Add(inputDictAndKeys.KeysPrecompute) 
+            .Add(inputDictAndKeys.DictPrecompute) 
+            .Build() 
+        .Program() 
+            .Args({"keys_list", "dict"}) 
+            .Body<TCoFlatMap>() 
+                .Input<TKqpLookupTable>() 
+                    .Table(update.Table()) 
+                    .LookupKeys<TCoIterator>() 
+                        .List("keys_list") 
+                        .Build() 
+                    .Columns(BuildColumnsList(table.Metadata->KeyColumnNames, update.Pos(), ctx)) 
+                    .Build() 
+                .Lambda() 
+                    .Args({"existingKey"}) 
+                    .Body<TCoJust>() 
+                        .Input<TCoFlattenMembers>() 
+                            .Add() 
+                                .Name().Build("") 
+                                .Value<TCoUnwrap>() // Key should always exist in the dict 
+                                    .Optional<TCoLookup>() 
+                                        .Collection("dict") 
+                                        .Lookup("existingKey") 
+                                        .Build() 
+                                    .Build() 
+                                .Build() 
+                            .Add() 
+                                .Name().Build("") 
+                                .Value("existingKey") 
+                                .Build() 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    auto prepareUpdate = Build<TDqCnUnionAll>(ctx, update.Pos()) 
+        .Output() 
+            .Stage(prepareUpdateStage) 
+            .Index().Build("0") 
+            .Build() 
+        .Done(); 
+ 
+    return Build<TKqlUpsertRows>(ctx, node.Pos()) 
+        .Table(update.Table()) 
+        .Input(prepareUpdate) 
+        .Columns(update.Columns()) 
+        .Done(); 
+ 
+    return node; 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_update_index.cpp b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_update_index.cpp
index 0d1e7440cf..61ad329440 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_update_index.cpp
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_update_index.cpp
@@ -1,28 +1,28 @@
-#include "kqp_opt_phy_effects_rules.h"
-#include "kqp_opt_phy_effects_impl.h"
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-TExprBase KqpBuildUpdateIndexStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) {
-    if (!node.Maybe<TKqlUpdateRowsIndex>()) {
-        return node;
-    }
-
-    auto update = node.Cast<TKqlUpdateRowsIndex>();
-    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, update.Table().Path());
-
-    auto effects = KqpPhyUpsertIndexEffectsImpl(TKqpPhyUpsertIndexMode::UpdateOn, update.Input(), update.Columns(),
-        table, update.Pos(), ctx);
-
-    if (!effects) {
-        return node;
-    }
-
-    return effects.Cast();
-}
-
-} // namespace NKikimr::NKqp::NOpt
+#include "kqp_opt_phy_effects_rules.h" 
+#include "kqp_opt_phy_effects_impl.h" 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NDq; 
+using namespace NYql::NNodes; 
+ 
+TExprBase KqpBuildUpdateIndexStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) { 
+    if (!node.Maybe<TKqlUpdateRowsIndex>()) { 
+        return node; 
+    } 
+ 
+    auto update = node.Cast<TKqlUpdateRowsIndex>(); 
+    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, update.Table().Path()); 
+ 
+    auto effects = KqpPhyUpsertIndexEffectsImpl(TKqpPhyUpsertIndexMode::UpdateOn, update.Input(), update.Columns(), 
+        table, update.Pos(), ctx); 
+ 
+    if (!effects) { 
+        return node; 
+    } 
+ 
+    return effects.Cast(); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_upsert_index.cpp b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_upsert_index.cpp
index 884fd0667f..01a954bf55 100644
--- a/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_upsert_index.cpp
+++ b/ydb/core/kqp/opt/physical/effects/kqp_opt_phy_upsert_index.cpp
@@ -1,400 +1,400 @@
-#include "kqp_opt_phy_effects_rules.h"
-#include "kqp_opt_phy_effects_impl.h"
-
-#include <ydb/library/yql/providers/common/provider/yql_provider.h>
-
-namespace NKikimr::NKqp::NOpt {
-
-using namespace NYql;
-using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-namespace {
-
-struct TRowsAndKeysResult {
-    TDqPhyPrecompute RowsPrecompute;
-    TDqPhyPrecompute KeysPrecompute;
-};
-
-TRowsAndKeysResult PrecomputeRowsAndKeys(const TCondenseInputResult& condenseResult,
-    const TKikimrTableDescription& table, TPositionHandle pos, TExprContext& ctx)
-{
-    TCoArgument rowsListArg(ctx.NewArgument(pos, "rows_list"));
-
-    auto extractKeys = Build<TCoMap>(ctx, pos)
-        .Input(rowsListArg)
-        .Lambda(MakeTableKeySelector(table, pos, ctx))
-        .Done();
-
-    auto variantType = Build<TCoVariantType>(ctx, pos)
-        .UnderlyingType<TCoTupleType>()
-            .Add<TCoTypeOf>()
-                .Value(rowsListArg)
-                .Build()
-            .Add<TCoTypeOf>()
-                .Value(extractKeys)
-                .Build()
-            .Build()
-        .Done();
-
-    auto computeStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(condenseResult.StageInputs)
-            .Build()
-        .Program()
-            .Args(condenseResult.StageArgs)
-            .Body<TCoFlatMap>()
-                .Input(condenseResult.Stream)
-                .Lambda()
-                    .Args({rowsListArg})
-                    .Body<TCoAsList>()
-                        .Add<TCoVariant>()
-                            .Item(rowsListArg)
-                            .Index().Build("0")
-                            .VarType(variantType)
-                            .Build()
-                        .Add<TCoVariant>()
-                            .Item(extractKeys)
-                            .Index().Build("1")
-                            .VarType(variantType)
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    auto rowsPrecompute = Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-           .Output()
-               .Stage(computeStage)
-               .Index().Build("0")
-               .Build()
-           .Build()
-        .Done();
-
-    auto keysPrecompute = Build<TDqPhyPrecompute>(ctx, pos)
-        .Connection<TDqCnValue>()
-           .Output()
-               .Stage(computeStage)
-               .Index().Build("1")
-               .Build()
-           .Build()
-        .Done();
-
-    return TRowsAndKeysResult {
-        .RowsPrecompute = rowsPrecompute,
-        .KeysPrecompute = keysPrecompute
-    };
-}
-
-TExprBase MakeNonexistingRowsFilter(const TDqPhyPrecompute& inputRows, const TDqPhyPrecompute& lookupDict,
-    const TVector<TString>& dictKeys, TPositionHandle pos, TExprContext& ctx)
-{
-    auto inputRowsArg = TCoArgument(ctx.NewArgument(pos, "input_rows"));
-    auto inputRowArg = TCoArgument(ctx.NewArgument(pos, "input_row"));
-    auto lookupDictArg = TCoArgument(ctx.NewArgument(pos, "lookup_dict"));
-
-    TVector<TExprBase> dictLookupKeyTuples;
-    for (const auto& key : dictKeys) {
-        dictLookupKeyTuples.emplace_back(
-            Build<TCoNameValueTuple>(ctx, pos)
-                .Name().Build(key)
-                .Value<TCoMember>()
-                    .Struct(inputRowArg)
-                    .Name().Build(key)
-                    .Build()
-                .Done());
-    }
-
-    auto filterStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(inputRows)
-            .Add(lookupDict)
-            .Build()
-        .Program()
-            .Args({inputRowsArg, lookupDictArg})
-            .Body<TCoIterator>()
-                .List<TCoFlatMap>()
-                    .Input(inputRowsArg)
-                    .Lambda()
-                        .Args(inputRowArg)
-                        .Body<TCoOptionalIf>()
-                            .Predicate<TCoContains>()
-                                .Collection(lookupDictArg)
-                                .Lookup<TCoAsStruct>()
-                                    .Add(dictLookupKeyTuples)
-                                    .Build()
-                                .Build()
-                            .Value(inputRowArg)
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    return Build<TDqCnUnionAll>(ctx, pos)
-        .Output()
-            .Stage(filterStage)
-            .Index().Build("0")
-            .Build()
-        .Done();
-}
-
-TExprBase MakeUpsertIndexRows(TKqpPhyUpsertIndexMode mode, const TDqPhyPrecompute& inputRows,
-    const TDqPhyPrecompute& lookupDict, const THashSet<TStringBuf>& inputColumns,
-    const THashSet<TStringBuf>& indexColumns, const TKikimrTableDescription& table, TPositionHandle pos,
-    TExprContext& ctx)
-{
-    // Check if we can update index table from just input data
-    bool allColumnFromInput = true;
-    for (const auto& column : indexColumns) {
-        allColumnFromInput = allColumnFromInput && inputColumns.contains(column);
-    }
-
-    if (allColumnFromInput) {
-        return mode == TKqpPhyUpsertIndexMode::UpdateOn
-            ? MakeNonexistingRowsFilter(inputRows, lookupDict, table.Metadata->KeyColumnNames, pos, ctx)
-            : TExprBase(inputRows);
-    }
-
-    auto inputRowsArg = TCoArgument(ctx.NewArgument(pos, "input_rows"));
-    auto inputRowArg = TCoArgument(ctx.NewArgument(pos, "input_row"));
-    auto lookupDictArg = TCoArgument(ctx.NewArgument(pos, "lookup_dict"));
-
-    TVector<TExprBase> dictLookupKeyTuples;
-    for (const auto& key : table.Metadata->KeyColumnNames) {
-        YQL_ENSURE(inputColumns.contains(key));
-
-        dictLookupKeyTuples.emplace_back(
-            Build<TCoNameValueTuple>(ctx, pos)
-                .Name().Build(key)
-                .Value<TCoMember>()
-                    .Struct(inputRowArg)
-                    .Name().Build(key)
-                    .Build()
-                .Done());
-    }
-
-    auto lookup = Build<TCoLookup>(ctx, pos)
-        .Collection(lookupDictArg)
-        .Lookup<TCoAsStruct>()
-            .Add(dictLookupKeyTuples)
-            .Build()
-        .Done();
-
-    TVector<TExprBase> rowTuples;
-    for (const auto& column : indexColumns) {
-        auto columnAtom = ctx.NewAtom(pos, column);
-
-        if (inputColumns.contains(column)) {
-            auto tuple = Build<TCoNameValueTuple>(ctx, pos)
-                .Name(columnAtom)
-                .Value<TCoMember>()
-                    .Struct(inputRowArg)
-                    .Name(columnAtom)
-                    .Build()
-                .Done();
-
-            rowTuples.emplace_back(tuple);
-        } else {
-            auto columnType = table.GetColumnType(TString(column));
-
-            auto tuple = Build<TCoNameValueTuple>(ctx, pos)
-                .Name(columnAtom)
-                .Value<TCoIfPresent>()
-                    .Optional(lookup)
-                    .PresentHandler<TCoLambda>()
-                        .Args({"payload"})
-                        .Body<TCoMember>()
-                            .Struct("payload")
-                            .Name(columnAtom)
-                            .Build()
-                        .Build()
-                    .MissingValue<TCoNothing>()
-                        .OptionalType(NCommon::BuildTypeExpr(pos, *columnType, ctx))
-                        .Build()
-                    .Build()
-                .Done();
-
-            rowTuples.emplace_back(tuple);
-        }
-    }
-
-    TExprBase flatmapBody = Build<TCoJust>(ctx, pos)
-        .Input<TCoAsStruct>()
-            .Add(rowTuples)
-            .Build()
-        .Done();
-
-    if (mode == TKqpPhyUpsertIndexMode::UpdateOn) {
-        // Filter non-existing rows
-        flatmapBody = Build<TCoFlatOptionalIf>(ctx, pos)
-            .Predicate<TCoExists>()
-                .Optional(lookup)
-                .Build()
-            .Value(flatmapBody)
-            .Done();
-    }
-
-    auto computeRowsStage = Build<TDqStage>(ctx, pos)
-        .Inputs()
-            .Add(inputRows)
-            .Add(lookupDict)
-            .Build()
-        .Program()
-            .Args({inputRowsArg, lookupDictArg})
-            .Body<TCoIterator>()
-                .List<TCoFlatMap>()
-                    .Input(inputRowsArg)
-                    .Lambda()
-                        .Args(inputRowArg)
-                        .Body(flatmapBody)
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Settings().Build()
-        .Done();
-
-    return Build<TDqCnUnionAll>(ctx, pos)
-        .Output()
-            .Stage(computeRowsStage)
-            .Index().Build("0")
-            .Build()
-        .Done();
-}
-
-} // namespace
-
-TMaybeNode<TExprList> KqpPhyUpsertIndexEffectsImpl(TKqpPhyUpsertIndexMode mode, const TExprBase& inputRows,
-    const TCoAtomList& inputColumns, const TKikimrTableDescription& table, TPositionHandle pos, TExprContext& ctx)
-{
-    switch (mode) {
-        case TKqpPhyUpsertIndexMode::Upsert:
-        case TKqpPhyUpsertIndexMode::UpdateOn:
-            break;
-
-        default:
-            YQL_ENSURE(false, "Unexpected phy index upsert mode: " << (ui32) mode);
-    }
-
-    const auto& pk = table.Metadata->KeyColumnNames;
-
-    auto condenseInputResult = CondenseAndDeduplicateInput(inputRows, table, ctx);
-    if (!condenseInputResult) {
-        return {};
-    }
-
-    auto inputRowsAndKeys = PrecomputeRowsAndKeys(*condenseInputResult, table, pos, ctx);
-
-    const auto indexes = BuildSecondaryIndexVector(table, pos, ctx);
-    YQL_ENSURE(indexes);
-
-    THashSet<TStringBuf> inputColumnsSet;
-    for (const auto& column : inputColumns) {
-        inputColumnsSet.emplace(column.Value());
-    }
-
-    auto dataColumns = CreateDataColumnSetToRead(indexes, inputColumnsSet);
-    auto lookupDict = PrecomputeTableLookupDict(inputRowsAndKeys.KeysPrecompute, table, dataColumns, indexes, pos, ctx);
-    if (!lookupDict) {
-        return {};
-    }
-
-    TExprBase tableUpsertRows = (mode == TKqpPhyUpsertIndexMode::UpdateOn)
-        ? MakeNonexistingRowsFilter(inputRowsAndKeys.RowsPrecompute, lookupDict.Cast(), pk, pos, ctx)
-        : inputRowsAndKeys.RowsPrecompute;
-
-    auto tableUpsert = Build<TKqlUpsertRows>(ctx, pos)
-        .Table(BuildTableMeta(table, pos, ctx))
-        .Input(tableUpsertRows)
-        .Columns(inputColumns)
-        .Done();
-
-    TVector<TExprBase> effects;
-    effects.emplace_back(tableUpsert);
-
-    for (const auto& [tableNode, indexDesc] : indexes) {
-        bool indexKeyColumnsUpdated = false;
-        THashSet<TStringBuf> indexTableColumns;
-        for (const auto& column : indexDesc->KeyColumns) {
-            YQL_ENSURE(indexTableColumns.emplace(column).second);
-
-            if (inputColumnsSet.contains(column)) {
-                indexKeyColumnsUpdated = true;
-            }
-        }
-
-        for (const auto& column : pk) {
-            indexTableColumns.insert(column);
-        }
-
-        if (indexKeyColumnsUpdated) {
-            // Have to delete old index value from index table in case when index key columns were updated
-            auto deleteIndexKeys = MakeRowsFromDict(lookupDict.Cast(), pk, indexTableColumns, pos, ctx);
-
-            auto indexDelete = Build<TKqlDeleteRows>(ctx, pos)
-                .Table(tableNode)
-                .Input(deleteIndexKeys)
-                .Done();
-
-            effects.emplace_back(indexDelete);
-        }
-
-        bool indexDataColumnsUpdated = false;
-        for (const auto& column : indexDesc->DataColumns) {
-            // TODO: Conder not fetching/updating data columns without input value.
-            YQL_ENSURE(indexTableColumns.emplace(column).second);
-
-            if (inputColumnsSet.contains(column)) {
-                indexDataColumnsUpdated = true;
-            }
-        }
-
-        // Index update always required for UPSERT operations as they can introduce new table rows
-        bool needIndexTableUpdate = mode != TKqpPhyUpsertIndexMode::UpdateOn;
-        // Index table update required in case when index key or data columns were updated
-        needIndexTableUpdate = needIndexTableUpdate || indexKeyColumnsUpdated || indexDataColumnsUpdated;
-
-        if (needIndexTableUpdate) {
-            auto upsertIndexRows = MakeUpsertIndexRows(mode, inputRowsAndKeys.RowsPrecompute, lookupDict.Cast(),
-                inputColumnsSet, indexTableColumns, table, pos, ctx);
-
-            auto indexUpsert = Build<TKqlUpsertRows>(ctx, pos)
-                .Table(tableNode)
-                .Input(upsertIndexRows)
-                .Columns(BuildColumnsList(indexTableColumns, pos, ctx))
-                .Done();
-
-            effects.emplace_back(indexUpsert);
-        }
-    }
-
-    return Build<TExprList>(ctx, pos)
-        .Add(effects)
-        .Done();
-}
-
-TExprBase KqpBuildUpsertIndexStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) {
-    if (!node.Maybe<TKqlUpsertRowsIndex>()) {
-        return node;
-    }
-
-    auto upsert = node.Cast<TKqlUpsertRowsIndex>();
-    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, upsert.Table().Path());
-
-    auto effects = KqpPhyUpsertIndexEffectsImpl(TKqpPhyUpsertIndexMode::Upsert, upsert.Input(), upsert.Columns(),
-        table, upsert.Pos(), ctx);
-
-    if (!effects) {
-        return node;
-    }
-
-    return effects.Cast();
-}
-
-} // namespace NKikimr::NKqp::NOpt
+#include "kqp_opt_phy_effects_rules.h" 
+#include "kqp_opt_phy_effects_impl.h" 
+ 
+#include <ydb/library/yql/providers/common/provider/yql_provider.h> 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+using namespace NYql; 
+using namespace NYql::NDq; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+struct TRowsAndKeysResult { 
+    TDqPhyPrecompute RowsPrecompute; 
+    TDqPhyPrecompute KeysPrecompute; 
+}; 
+ 
+TRowsAndKeysResult PrecomputeRowsAndKeys(const TCondenseInputResult& condenseResult, 
+    const TKikimrTableDescription& table, TPositionHandle pos, TExprContext& ctx) 
+{ 
+    TCoArgument rowsListArg(ctx.NewArgument(pos, "rows_list")); 
+ 
+    auto extractKeys = Build<TCoMap>(ctx, pos) 
+        .Input(rowsListArg) 
+        .Lambda(MakeTableKeySelector(table, pos, ctx)) 
+        .Done(); 
+ 
+    auto variantType = Build<TCoVariantType>(ctx, pos) 
+        .UnderlyingType<TCoTupleType>() 
+            .Add<TCoTypeOf>() 
+                .Value(rowsListArg) 
+                .Build() 
+            .Add<TCoTypeOf>() 
+                .Value(extractKeys) 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    auto computeStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(condenseResult.StageInputs) 
+            .Build() 
+        .Program() 
+            .Args(condenseResult.StageArgs) 
+            .Body<TCoFlatMap>() 
+                .Input(condenseResult.Stream) 
+                .Lambda() 
+                    .Args({rowsListArg}) 
+                    .Body<TCoAsList>() 
+                        .Add<TCoVariant>() 
+                            .Item(rowsListArg) 
+                            .Index().Build("0") 
+                            .VarType(variantType) 
+                            .Build() 
+                        .Add<TCoVariant>() 
+                            .Item(extractKeys) 
+                            .Index().Build("1") 
+                            .VarType(variantType) 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    auto rowsPrecompute = Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+           .Output() 
+               .Stage(computeStage) 
+               .Index().Build("0") 
+               .Build() 
+           .Build() 
+        .Done(); 
+ 
+    auto keysPrecompute = Build<TDqPhyPrecompute>(ctx, pos) 
+        .Connection<TDqCnValue>() 
+           .Output() 
+               .Stage(computeStage) 
+               .Index().Build("1") 
+               .Build() 
+           .Build() 
+        .Done(); 
+ 
+    return TRowsAndKeysResult { 
+        .RowsPrecompute = rowsPrecompute, 
+        .KeysPrecompute = keysPrecompute 
+    }; 
+} 
+ 
+TExprBase MakeNonexistingRowsFilter(const TDqPhyPrecompute& inputRows, const TDqPhyPrecompute& lookupDict, 
+    const TVector<TString>& dictKeys, TPositionHandle pos, TExprContext& ctx) 
+{ 
+    auto inputRowsArg = TCoArgument(ctx.NewArgument(pos, "input_rows")); 
+    auto inputRowArg = TCoArgument(ctx.NewArgument(pos, "input_row")); 
+    auto lookupDictArg = TCoArgument(ctx.NewArgument(pos, "lookup_dict")); 
+ 
+    TVector<TExprBase> dictLookupKeyTuples; 
+    for (const auto& key : dictKeys) { 
+        dictLookupKeyTuples.emplace_back( 
+            Build<TCoNameValueTuple>(ctx, pos) 
+                .Name().Build(key) 
+                .Value<TCoMember>() 
+                    .Struct(inputRowArg) 
+                    .Name().Build(key) 
+                    .Build() 
+                .Done()); 
+    } 
+ 
+    auto filterStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(inputRows) 
+            .Add(lookupDict) 
+            .Build() 
+        .Program() 
+            .Args({inputRowsArg, lookupDictArg}) 
+            .Body<TCoIterator>() 
+                .List<TCoFlatMap>() 
+                    .Input(inputRowsArg) 
+                    .Lambda() 
+                        .Args(inputRowArg) 
+                        .Body<TCoOptionalIf>() 
+                            .Predicate<TCoContains>() 
+                                .Collection(lookupDictArg) 
+                                .Lookup<TCoAsStruct>() 
+                                    .Add(dictLookupKeyTuples) 
+                                    .Build() 
+                                .Build() 
+                            .Value(inputRowArg) 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    return Build<TDqCnUnionAll>(ctx, pos) 
+        .Output() 
+            .Stage(filterStage) 
+            .Index().Build("0") 
+            .Build() 
+        .Done(); 
+} 
+ 
+TExprBase MakeUpsertIndexRows(TKqpPhyUpsertIndexMode mode, const TDqPhyPrecompute& inputRows, 
+    const TDqPhyPrecompute& lookupDict, const THashSet<TStringBuf>& inputColumns, 
+    const THashSet<TStringBuf>& indexColumns, const TKikimrTableDescription& table, TPositionHandle pos, 
+    TExprContext& ctx) 
+{ 
+    // Check if we can update index table from just input data 
+    bool allColumnFromInput = true; 
+    for (const auto& column : indexColumns) { 
+        allColumnFromInput = allColumnFromInput && inputColumns.contains(column); 
+    } 
+ 
+    if (allColumnFromInput) { 
+        return mode == TKqpPhyUpsertIndexMode::UpdateOn 
+            ? MakeNonexistingRowsFilter(inputRows, lookupDict, table.Metadata->KeyColumnNames, pos, ctx) 
+            : TExprBase(inputRows); 
+    } 
+ 
+    auto inputRowsArg = TCoArgument(ctx.NewArgument(pos, "input_rows")); 
+    auto inputRowArg = TCoArgument(ctx.NewArgument(pos, "input_row")); 
+    auto lookupDictArg = TCoArgument(ctx.NewArgument(pos, "lookup_dict")); 
+ 
+    TVector<TExprBase> dictLookupKeyTuples; 
+    for (const auto& key : table.Metadata->KeyColumnNames) { 
+        YQL_ENSURE(inputColumns.contains(key)); 
+ 
+        dictLookupKeyTuples.emplace_back( 
+            Build<TCoNameValueTuple>(ctx, pos) 
+                .Name().Build(key) 
+                .Value<TCoMember>() 
+                    .Struct(inputRowArg) 
+                    .Name().Build(key) 
+                    .Build() 
+                .Done()); 
+    } 
+ 
+    auto lookup = Build<TCoLookup>(ctx, pos) 
+        .Collection(lookupDictArg) 
+        .Lookup<TCoAsStruct>() 
+            .Add(dictLookupKeyTuples) 
+            .Build() 
+        .Done(); 
+ 
+    TVector<TExprBase> rowTuples; 
+    for (const auto& column : indexColumns) { 
+        auto columnAtom = ctx.NewAtom(pos, column); 
+ 
+        if (inputColumns.contains(column)) { 
+            auto tuple = Build<TCoNameValueTuple>(ctx, pos) 
+                .Name(columnAtom) 
+                .Value<TCoMember>() 
+                    .Struct(inputRowArg) 
+                    .Name(columnAtom) 
+                    .Build() 
+                .Done(); 
+ 
+            rowTuples.emplace_back(tuple); 
+        } else { 
+            auto columnType = table.GetColumnType(TString(column)); 
+ 
+            auto tuple = Build<TCoNameValueTuple>(ctx, pos) 
+                .Name(columnAtom) 
+                .Value<TCoIfPresent>() 
+                    .Optional(lookup) 
+                    .PresentHandler<TCoLambda>() 
+                        .Args({"payload"}) 
+                        .Body<TCoMember>() 
+                            .Struct("payload") 
+                            .Name(columnAtom) 
+                            .Build() 
+                        .Build() 
+                    .MissingValue<TCoNothing>() 
+                        .OptionalType(NCommon::BuildTypeExpr(pos, *columnType, ctx)) 
+                        .Build() 
+                    .Build() 
+                .Done(); 
+ 
+            rowTuples.emplace_back(tuple); 
+        } 
+    } 
+ 
+    TExprBase flatmapBody = Build<TCoJust>(ctx, pos) 
+        .Input<TCoAsStruct>() 
+            .Add(rowTuples) 
+            .Build() 
+        .Done(); 
+ 
+    if (mode == TKqpPhyUpsertIndexMode::UpdateOn) { 
+        // Filter non-existing rows 
+        flatmapBody = Build<TCoFlatOptionalIf>(ctx, pos) 
+            .Predicate<TCoExists>() 
+                .Optional(lookup) 
+                .Build() 
+            .Value(flatmapBody) 
+            .Done(); 
+    } 
+ 
+    auto computeRowsStage = Build<TDqStage>(ctx, pos) 
+        .Inputs() 
+            .Add(inputRows) 
+            .Add(lookupDict) 
+            .Build() 
+        .Program() 
+            .Args({inputRowsArg, lookupDictArg}) 
+            .Body<TCoIterator>() 
+                .List<TCoFlatMap>() 
+                    .Input(inputRowsArg) 
+                    .Lambda() 
+                        .Args(inputRowArg) 
+                        .Body(flatmapBody) 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Settings().Build() 
+        .Done(); 
+ 
+    return Build<TDqCnUnionAll>(ctx, pos) 
+        .Output() 
+            .Stage(computeRowsStage) 
+            .Index().Build("0") 
+            .Build() 
+        .Done(); 
+} 
+ 
+} // namespace 
+ 
+TMaybeNode<TExprList> KqpPhyUpsertIndexEffectsImpl(TKqpPhyUpsertIndexMode mode, const TExprBase& inputRows, 
+    const TCoAtomList& inputColumns, const TKikimrTableDescription& table, TPositionHandle pos, TExprContext& ctx) 
+{ 
+    switch (mode) { 
+        case TKqpPhyUpsertIndexMode::Upsert: 
+        case TKqpPhyUpsertIndexMode::UpdateOn: 
+            break; 
+ 
+        default: 
+            YQL_ENSURE(false, "Unexpected phy index upsert mode: " << (ui32) mode); 
+    } 
+ 
+    const auto& pk = table.Metadata->KeyColumnNames; 
+ 
+    auto condenseInputResult = CondenseAndDeduplicateInput(inputRows, table, ctx); 
+    if (!condenseInputResult) { 
+        return {}; 
+    } 
+ 
+    auto inputRowsAndKeys = PrecomputeRowsAndKeys(*condenseInputResult, table, pos, ctx); 
+ 
+    const auto indexes = BuildSecondaryIndexVector(table, pos, ctx); 
+    YQL_ENSURE(indexes); 
+ 
+    THashSet<TStringBuf> inputColumnsSet; 
+    for (const auto& column : inputColumns) { 
+        inputColumnsSet.emplace(column.Value()); 
+    } 
+ 
+    auto dataColumns = CreateDataColumnSetToRead(indexes, inputColumnsSet); 
+    auto lookupDict = PrecomputeTableLookupDict(inputRowsAndKeys.KeysPrecompute, table, dataColumns, indexes, pos, ctx); 
+    if (!lookupDict) { 
+        return {}; 
+    } 
+ 
+    TExprBase tableUpsertRows = (mode == TKqpPhyUpsertIndexMode::UpdateOn) 
+        ? MakeNonexistingRowsFilter(inputRowsAndKeys.RowsPrecompute, lookupDict.Cast(), pk, pos, ctx) 
+        : inputRowsAndKeys.RowsPrecompute; 
+ 
+    auto tableUpsert = Build<TKqlUpsertRows>(ctx, pos) 
+        .Table(BuildTableMeta(table, pos, ctx)) 
+        .Input(tableUpsertRows) 
+        .Columns(inputColumns) 
+        .Done(); 
+ 
+    TVector<TExprBase> effects; 
+    effects.emplace_back(tableUpsert); 
+ 
+    for (const auto& [tableNode, indexDesc] : indexes) { 
+        bool indexKeyColumnsUpdated = false; 
+        THashSet<TStringBuf> indexTableColumns; 
+        for (const auto& column : indexDesc->KeyColumns) { 
+            YQL_ENSURE(indexTableColumns.emplace(column).second); 
+ 
+            if (inputColumnsSet.contains(column)) { 
+                indexKeyColumnsUpdated = true; 
+            } 
+        } 
+ 
+        for (const auto& column : pk) { 
+            indexTableColumns.insert(column); 
+        } 
+ 
+        if (indexKeyColumnsUpdated) { 
+            // Have to delete old index value from index table in case when index key columns were updated 
+            auto deleteIndexKeys = MakeRowsFromDict(lookupDict.Cast(), pk, indexTableColumns, pos, ctx); 
+ 
+            auto indexDelete = Build<TKqlDeleteRows>(ctx, pos) 
+                .Table(tableNode) 
+                .Input(deleteIndexKeys) 
+                .Done(); 
+ 
+            effects.emplace_back(indexDelete); 
+        } 
+ 
+        bool indexDataColumnsUpdated = false; 
+        for (const auto& column : indexDesc->DataColumns) { 
+            // TODO: Conder not fetching/updating data columns without input value. 
+            YQL_ENSURE(indexTableColumns.emplace(column).second); 
+ 
+            if (inputColumnsSet.contains(column)) { 
+                indexDataColumnsUpdated = true; 
+            } 
+        } 
+ 
+        // Index update always required for UPSERT operations as they can introduce new table rows 
+        bool needIndexTableUpdate = mode != TKqpPhyUpsertIndexMode::UpdateOn; 
+        // Index table update required in case when index key or data columns were updated 
+        needIndexTableUpdate = needIndexTableUpdate || indexKeyColumnsUpdated || indexDataColumnsUpdated; 
+ 
+        if (needIndexTableUpdate) { 
+            auto upsertIndexRows = MakeUpsertIndexRows(mode, inputRowsAndKeys.RowsPrecompute, lookupDict.Cast(), 
+                inputColumnsSet, indexTableColumns, table, pos, ctx); 
+ 
+            auto indexUpsert = Build<TKqlUpsertRows>(ctx, pos) 
+                .Table(tableNode) 
+                .Input(upsertIndexRows) 
+                .Columns(BuildColumnsList(indexTableColumns, pos, ctx)) 
+                .Done(); 
+ 
+            effects.emplace_back(indexUpsert); 
+        } 
+    } 
+ 
+    return Build<TExprList>(ctx, pos) 
+        .Add(effects) 
+        .Done(); 
+} 
+ 
+TExprBase KqpBuildUpsertIndexStages(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) { 
+    if (!node.Maybe<TKqlUpsertRowsIndex>()) { 
+        return node; 
+    } 
+ 
+    auto upsert = node.Cast<TKqlUpsertRowsIndex>(); 
+    const auto& table = kqpCtx.Tables->ExistingTable(kqpCtx.Cluster, upsert.Table().Path()); 
+ 
+    auto effects = KqpPhyUpsertIndexEffectsImpl(TKqpPhyUpsertIndexMode::Upsert, upsert.Input(), upsert.Columns(), 
+        table, upsert.Pos(), ctx); 
+ 
+    if (!effects) { 
+        return node; 
+    } 
+ 
+    return effects.Cast(); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/effects/ya.make b/ydb/core/kqp/opt/physical/effects/ya.make
index 3424504bb8..abd5807d16 100644
--- a/ydb/core/kqp/opt/physical/effects/ya.make
+++ b/ydb/core/kqp/opt/physical/effects/ya.make
@@ -1,26 +1,26 @@
-LIBRARY()
-
-OWNER(
-    g:kikimr
-)
-
-SRCS(
-    kqp_opt_phy_delete_index.cpp
-    kqp_opt_phy_effects.cpp
-    kqp_opt_phy_indexes.cpp
-    kqp_opt_phy_insert_index.cpp
-    kqp_opt_phy_insert.cpp
-    kqp_opt_phy_update_index.cpp
-    kqp_opt_phy_update.cpp
-    kqp_opt_phy_upsert_index.cpp
-)
-
-PEERDIR(
-    ydb/core/kqp/common
+LIBRARY() 
+ 
+OWNER( 
+    g:kikimr 
+) 
+ 
+SRCS( 
+    kqp_opt_phy_delete_index.cpp 
+    kqp_opt_phy_effects.cpp 
+    kqp_opt_phy_indexes.cpp 
+    kqp_opt_phy_insert_index.cpp 
+    kqp_opt_phy_insert.cpp 
+    kqp_opt_phy_update_index.cpp 
+    kqp_opt_phy_update.cpp 
+    kqp_opt_phy_upsert_index.cpp 
+) 
+ 
+PEERDIR( 
+    ydb/core/kqp/common 
     ydb/library/yql/dq/common
     ydb/library/yql/dq/opt
-)
-
-YQL_LAST_ABI_VERSION()
-
-END()
+) 
+ 
+YQL_LAST_ABI_VERSION() 
+ 
+END() 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy.cpp b/ydb/core/kqp/opt/physical/kqp_opt_phy.cpp
index 11e1af7ae8..02adfca1c4 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy.cpp
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy.cpp
@@ -2,7 +2,7 @@
 
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/opt/kqp_opt_impl.h>
-#include <ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_rules.h>
+#include <ydb/core/kqp/opt/physical/effects/kqp_opt_phy_effects_rules.h> 
 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
@@ -10,7 +10,7 @@
 #include <ydb/library/yql/dq/opt/dq_opt_phy.h>
 #include <ydb/library/yql/providers/common/transform/yql_optimize.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NDq;
@@ -29,13 +29,13 @@ public:
         AddHandler(0, &TKqlReadTable::Match, HNDL(BuildReadTableStage));
         AddHandler(0, &TKqlReadTableRanges::Match, HNDL(BuildReadTableRangesStage));
         AddHandler(0, &TKqlLookupTable::Match, HNDL(BuildLookupTableStage));
-        AddHandler(0, [](const TExprNode* node) { return TCoSort::Match(node) || TCoTopSort::Match(node); },
+        AddHandler(0, [](const TExprNode* node) { return TCoSort::Match(node) || TCoTopSort::Match(node); }, 
             HNDL(RemoveRedundantSortByPk));
         AddHandler(0, &TCoTake::Match, HNDL(ApplyLimitToReadTable));
         AddHandler(0, &TCoFlatMap::Match, HNDL(PushOlapFilter));
         AddHandler(0, &TCoSkipNullMembers::Match, HNDL(PushSkipNullMembersToStage<false>));
         AddHandler(0, &TCoExtractMembers::Match, HNDL(PushExtractMembersToStage<false>));
-        AddHandler(0, &TCoFlatMapBase::Match, HNDL(BuildFlatmapStage<false>));
+        AddHandler(0, &TCoFlatMapBase::Match, HNDL(BuildFlatmapStage<false>)); 
         AddHandler(0, &TCoCombineByKey::Match, HNDL(PushCombineToStage<false>));
         AddHandler(0, &TCoPartitionsByKeys::Match, HNDL(BuildPartitionsStage));
         AddHandler(0, &TCoPartitionByKey::Match, HNDL(BuildPartitionStage));
@@ -47,7 +47,7 @@ public:
         AddHandler(0, &TCoExtendBase::Match, HNDL(BuildExtendStage));
         AddHandler(0, &TDqJoin::Match, HNDL(RewriteRightJoinToLeft));
         AddHandler(0, &TDqJoin::Match, HNDL(PushJoinToStage<false>));
-        AddHandler(0, &TDqJoin::Match, HNDL(BuildJoin<false>));
+        AddHandler(0, &TDqJoin::Match, HNDL(BuildJoin<false>)); 
         AddHandler(0, &TDqPrecompute::Match, HNDL(BuildPrecomputeStage));
         AddHandler(0, &TCoLMap::Match, HNDL(PushLMapToStage<false>));
         AddHandler(0, &TCoOrderedLMap::Match, HNDL(PushOrderedLMapToStage<false>));
@@ -63,14 +63,14 @@ public:
 
         AddHandler(1, &TCoSkipNullMembers::Match, HNDL(PushSkipNullMembersToStage<true>));
         AddHandler(1, &TCoExtractMembers::Match, HNDL(PushExtractMembersToStage<true>));
-        AddHandler(1, &TCoFlatMapBase::Match, HNDL(BuildFlatmapStage<true>));
+        AddHandler(1, &TCoFlatMapBase::Match, HNDL(BuildFlatmapStage<true>)); 
         AddHandler(1, &TCoCombineByKey::Match, HNDL(PushCombineToStage<true>));
         AddHandler(1, &TCoTopSort::Match, HNDL(BuildTopSortStage<true>));
         AddHandler(1, &TCoTake::Match, HNDL(BuildTakeSkipStage<true>));
         AddHandler(1, &TCoSortBase::Match, HNDL(BuildSortStage<true>));
         AddHandler(1, &TCoTake::Match, HNDL(BuildTakeStage<true>));
         AddHandler(1, &TDqJoin::Match, HNDL(PushJoinToStage<true>));
-        AddHandler(1, &TDqJoin::Match, HNDL(BuildJoin<true>));
+        AddHandler(1, &TDqJoin::Match, HNDL(BuildJoin<true>)); 
         AddHandler(1, &TCoLMap::Match, HNDL(PushLMapToStage<true>));
         AddHandler(1, &TCoOrderedLMap::Match, HNDL(PushOrderedLMapToStage<true>));
 #undef HNDL
@@ -115,7 +115,7 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> PushSkipNullMembersToStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> PushSkipNullMembersToStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqPushSkipNullMembersToStage(node, ctx, optCtx, *getParents(), IsGlobal);
@@ -124,7 +124,7 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> PushExtractMembersToStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> PushExtractMembersToStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqPushExtractMembersToStage(node, ctx, optCtx, *getParents(), IsGlobal);
@@ -133,16 +133,16 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> BuildFlatmapStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> BuildFlatmapStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqBuildFlatmapStage(node, ctx, optCtx, *getParents(), IsGlobal);
-        DumpAppliedRule("BuildFlatmapStage", node.Ptr(), output.Ptr(), ctx);
+        DumpAppliedRule("BuildFlatmapStage", node.Ptr(), output.Ptr(), ctx); 
         return output;
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> PushCombineToStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> PushCombineToStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqPushCombineToStage(node, ctx, optCtx, *getParents(), IsGlobal);
@@ -163,7 +163,7 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> BuildTopSortStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> BuildTopSortStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqBuildTopSortStage(node, ctx, optCtx, *getParents(), IsGlobal);
@@ -172,7 +172,7 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> BuildTakeSkipStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> BuildTakeSkipStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqBuildTakeSkipStage(node, ctx, optCtx, *getParents(), IsGlobal);
@@ -181,7 +181,7 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> BuildSortStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> BuildSortStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqBuildSortStage(node, ctx, optCtx, *getParents(), IsGlobal);
@@ -190,14 +190,14 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> BuildTakeStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> BuildTakeStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqBuildTakeStage(node, ctx, optCtx, *getParents(), IsGlobal);
         DumpAppliedRule("BuildTakeStage", node.Ptr(), output.Ptr(), ctx);
         return output;
     }
-
+ 
     TMaybeNode<TExprBase> RewriteLengthOfStageOutput(TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx) {
         TExprBase output = DqRewriteLengthOfStageOutput(node, ctx, optCtx);
         DumpAppliedRule("RewriteLengthOfStageOutput", node.Ptr(), output.Ptr(), ctx);
@@ -205,7 +205,7 @@ protected:
     }
 
     TMaybeNode<TExprBase> BuildExtendStage(TExprBase node, TExprContext& ctx) {
-        TExprBase output = DqBuildExtendStage(node, ctx);
+        TExprBase output = DqBuildExtendStage(node, ctx); 
         DumpAppliedRule("BuildExtendStage", node.Ptr(), output.Ptr(), ctx);
         return output;
     }
@@ -215,9 +215,9 @@ protected:
         DumpAppliedRule("RewriteRightJoinToLeft", node.Ptr(), output.Ptr(), ctx);
         return output;
     }
-
+ 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> PushJoinToStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> PushJoinToStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqPushJoinToStage(node, ctx, optCtx, *getParents(), IsGlobal);
@@ -225,23 +225,23 @@ protected:
         return output;
     }
 
-    template <bool IsGlobal>
-    TMaybeNode<TExprBase> BuildJoin(TExprBase node, TExprContext& ctx,
+    template <bool IsGlobal> 
+    TMaybeNode<TExprBase> BuildJoin(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
-        TExprBase output = KqpBuildJoin(node, ctx, KqpCtx, optCtx, *getParents(), IsGlobal);
+        TExprBase output = KqpBuildJoin(node, ctx, KqpCtx, optCtx, *getParents(), IsGlobal); 
         DumpAppliedRule("BuildJoin", node.Ptr(), output.Ptr(), ctx);
         return output;
     }
-
+ 
     TMaybeNode<TExprBase> BuildPrecomputeStage(TExprBase node, TExprContext& ctx) {
         TExprBase output = DqBuildPrecomputeStage(node, ctx);
         DumpAppliedRule("BuildPrecomputeStage", node.Ptr(), output.Ptr(), ctx);
         return output;
     }
-
+ 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> PushLMapToStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> PushLMapToStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqPushLMapToStage(node, ctx, optCtx, *getParents(), IsGlobal);
@@ -250,14 +250,14 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> PushOrderedLMapToStage(TExprBase node, TExprContext& ctx,
+    TMaybeNode<TExprBase> PushOrderedLMapToStage(TExprBase node, TExprContext& ctx, 
         IOptimizationContext& optCtx, const TGetParents& getParents)
     {
         TExprBase output = DqPushOrderedLMapToStage(node, ctx, optCtx, *getParents(), IsGlobal);
         DumpAppliedRule("PushOrderedLMapToStage", node.Ptr(), output.Ptr(), ctx);
         return output;
     }
-
+ 
     TMaybeNode<TExprBase> BuildInsertStages(TExprBase node, TExprContext& ctx) {
         TExprBase output = KqpBuildInsertStages(node, ctx, KqpCtx);
         DumpAppliedRule("BuildInsertStages", node.Ptr(), output.Ptr(), ctx);
@@ -323,4 +323,4 @@ TAutoPtr<IGraphTransformer> CreateKqpPhyOptTransformer(const TIntrusivePtr<TKqpO
     return THolder<IGraphTransformer>(new TKqpPhysicalOptTransformer(typesCtx, kqpCtx));
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy.h b/ydb/core/kqp/opt/physical/kqp_opt_phy.h
index 06d4d18826..bc79279676 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy.h
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy.h
@@ -3,11 +3,11 @@
 #include <ydb/core/kqp/common/kqp_transform.h>
 #include <ydb/core/kqp/opt/kqp_opt.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 struct TKqpOptimizeContext;
 
 TAutoPtr<NYql::IGraphTransformer> CreateKqpPhyOptTransformer(const TIntrusivePtr<TKqpOptimizeContext>& kqpCtx,
     NYql::TTypeAnnotationContext& typesCtx);
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy_build_stage.cpp b/ydb/core/kqp/opt/physical/kqp_opt_phy_build_stage.cpp
index f49aff031f..db853abf1b 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy_build_stage.cpp
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy_build_stage.cpp
@@ -1,8 +1,8 @@
 #include "kqp_opt_phy_rules.h"
 
 #include <ydb/core/kqp/common/kqp_yql.h>
-#include <ydb/core/kqp/opt/kqp_opt_impl.h>
-#include <ydb/core/kqp/opt/physical/kqp_opt_phy_impl.h>
+#include <ydb/core/kqp/opt/kqp_opt_impl.h> 
+#include <ydb/core/kqp/opt/physical/kqp_opt_phy_impl.h> 
 #include <ydb/core/kqp/provider/kqp_opt_helpers.h>
 #include <ydb/core/tx/schemeshard/schemeshard_utils.h>
 
@@ -11,50 +11,50 @@
 #include <ydb/library/yql/dq/opt/dq_opt.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NDq;
 using namespace NYql::NNodes;
 
-TMaybeNode<TDqPhyPrecompute> BuildLookupKeysPrecompute(const TExprBase& input, TExprContext& ctx) {
-    TMaybeNode<TDqConnection> precomputeInput;
-
-    if (IsDqPureExpr(input)) {
-        YQL_ENSURE(input.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::List, "" << input.Ref().Dump());
-
-        auto computeStage = Build<TDqStage>(ctx, input.Pos())
-            .Inputs()
-                .Build()
-            .Program()
-                .Args({})
-                .Body<TCoToStream>()
-                    .Input<TCoJust>()
-                        .Input(input)
-                        .Build()
-                    .Build()
-                .Build()
-            .Settings().Build()
-            .Done();
-
-        precomputeInput = Build<TDqCnValue>(ctx, input.Pos())
-            .Output()
-                .Stage(computeStage)
-                .Index().Build("0")
-                .Build()
-            .Done();
-
-    } else if (input.Maybe<TDqCnUnionAll>()) {
-        precomputeInput = input.Cast<TDqCnUnionAll>();
-    } else {
-        return {};
-    }
-
-    return Build<TDqPhyPrecompute>(ctx, input.Pos())
-        .Connection(precomputeInput.Cast())
-        .Done();
-}
-
+TMaybeNode<TDqPhyPrecompute> BuildLookupKeysPrecompute(const TExprBase& input, TExprContext& ctx) { 
+    TMaybeNode<TDqConnection> precomputeInput; 
+ 
+    if (IsDqPureExpr(input)) { 
+        YQL_ENSURE(input.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::List, "" << input.Ref().Dump()); 
+ 
+        auto computeStage = Build<TDqStage>(ctx, input.Pos()) 
+            .Inputs() 
+                .Build() 
+            .Program() 
+                .Args({}) 
+                .Body<TCoToStream>() 
+                    .Input<TCoJust>() 
+                        .Input(input) 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Settings().Build() 
+            .Done(); 
+ 
+        precomputeInput = Build<TDqCnValue>(ctx, input.Pos()) 
+            .Output() 
+                .Stage(computeStage) 
+                .Index().Build("0") 
+                .Build() 
+            .Done(); 
+ 
+    } else if (input.Maybe<TDqCnUnionAll>()) { 
+        precomputeInput = input.Cast<TDqCnUnionAll>(); 
+    } else { 
+        return {}; 
+    } 
+ 
+    return Build<TDqPhyPrecompute>(ctx, input.Pos()) 
+        .Connection(precomputeInput.Cast()) 
+        .Done(); 
+} 
+ 
 TExprBase KqpBuildReadTableStage(TExprBase node, TExprContext& ctx, const TKqpOptimizeContext& kqpCtx) {
     if (!node.Maybe<TKqlReadTable>()) {
         return node;
@@ -369,4 +369,4 @@ TExprBase KqpBuildLookupTableStage(TExprBase node, TExprContext& ctx) {
         .Done();
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy_helpers.cpp b/ydb/core/kqp/opt/physical/kqp_opt_phy_helpers.cpp
index bdb7029c64..a6adb7b697 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy_helpers.cpp
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy_helpers.cpp
@@ -1,27 +1,27 @@
 #include <ydb/core/kqp/common/kqp_yql.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NNodes;
 
-namespace {
-
-template <typename TContainer>
-TCoAtomList BuildColumnsListImpl(const TContainer& columns, TPositionHandle pos, TExprContext& ctx) {
-    TVector<TCoAtom> columnsList;
-    for (const auto& column : columns) {
-        auto atom = ctx.NewAtom(pos, column);
-        columnsList.push_back(TCoAtom(atom));
-    }
-
-    return Build<TCoAtomList>(ctx, pos)
-        .Add(columnsList)
-        .Done();
-}
-
-} // namespace
-
+namespace { 
+ 
+template <typename TContainer> 
+TCoAtomList BuildColumnsListImpl(const TContainer& columns, TPositionHandle pos, TExprContext& ctx) { 
+    TVector<TCoAtom> columnsList; 
+    for (const auto& column : columns) { 
+        auto atom = ctx.NewAtom(pos, column); 
+        columnsList.push_back(TCoAtom(atom)); 
+    } 
+ 
+    return Build<TCoAtomList>(ctx, pos) 
+        .Add(columnsList) 
+        .Done(); 
+} 
+ 
+} // namespace 
+ 
 TExprBase BuildReadNode(TPositionHandle pos, TExprContext& ctx, TExprBase input, TKqpReadTableSettings& settings) {
     TCoNameValueTupleList settingsNode = settings.BuildNode(ctx, pos);
 
@@ -76,12 +76,12 @@ TKqpReadTableSettings GetReadTableSettings(TExprBase input, bool isReadRanges) {
     return TKqpReadTableSettings::Parse(input.Cast<TKqpReadTable>());
 };
 
-TCoAtomList BuildColumnsList(const THashSet<TStringBuf>& columns, TPositionHandle pos, TExprContext& ctx) {
-    return BuildColumnsListImpl(columns, pos, ctx);
-}
-
-TCoAtomList BuildColumnsList(const TVector<TString>& columns, TPositionHandle pos, TExprContext& ctx) {
-    return BuildColumnsListImpl(columns, pos, ctx);
-}
-
-} // namespace NKikimr::NKqp::NOpt
+TCoAtomList BuildColumnsList(const THashSet<TStringBuf>& columns, TPositionHandle pos, TExprContext& ctx) { 
+    return BuildColumnsListImpl(columns, pos, ctx); 
+} 
+ 
+TCoAtomList BuildColumnsList(const TVector<TString>& columns, TPositionHandle pos, TExprContext& ctx) { 
+    return BuildColumnsListImpl(columns, pos, ctx); 
+} 
+ 
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy_impl.h b/ydb/core/kqp/opt/physical/kqp_opt_phy_impl.h
index 7d0547984b..486224bc70 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy_impl.h
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy_impl.h
@@ -1,26 +1,26 @@
-#pragma once
-
-#include <ydb/core/kqp/opt/kqp_opt_impl.h>
-
-namespace NKikimr::NKqp::NOpt {
-
-NYql::NNodes::TExprBase BuildReadNode(NYql::TPositionHandle pos, NYql::TExprContext& ctx,
-    NYql::NNodes::TExprBase input, NYql::TKqpReadTableSettings& settings);
-
-NYql::NNodes::TCoAtom GetReadTablePath(NYql::NNodes::TExprBase input, bool isReadRanges);
-
-NYql::TKqpReadTableSettings GetReadTableSettings(NYql::NNodes::TExprBase input, bool isReadRanges);
-
-NYql::NNodes::TMaybeNode<NYql::NNodes::TDqPhyPrecompute> BuildLookupKeysPrecompute(
-    const NYql::NNodes::TExprBase& input, NYql::TExprContext& ctx);
-
-NYql::NNodes::TCoAtomList BuildColumnsList(const THashSet<TStringBuf>& columns, NYql::TPositionHandle pos,
-    NYql::TExprContext& ctx);
-
-NYql::NNodes::TCoAtomList BuildColumnsList(const TVector<TString>& columns, NYql::TPositionHandle pos,
-    NYql::TExprContext& ctx);
-
-} // NKikimr::NKqp::NOpt
-
-
-
+#pragma once 
+ 
+#include <ydb/core/kqp/opt/kqp_opt_impl.h> 
+ 
+namespace NKikimr::NKqp::NOpt { 
+ 
+NYql::NNodes::TExprBase BuildReadNode(NYql::TPositionHandle pos, NYql::TExprContext& ctx, 
+    NYql::NNodes::TExprBase input, NYql::TKqpReadTableSettings& settings); 
+ 
+NYql::NNodes::TCoAtom GetReadTablePath(NYql::NNodes::TExprBase input, bool isReadRanges); 
+ 
+NYql::TKqpReadTableSettings GetReadTableSettings(NYql::NNodes::TExprBase input, bool isReadRanges); 
+ 
+NYql::NNodes::TMaybeNode<NYql::NNodes::TDqPhyPrecompute> BuildLookupKeysPrecompute( 
+    const NYql::NNodes::TExprBase& input, NYql::TExprContext& ctx); 
+ 
+NYql::NNodes::TCoAtomList BuildColumnsList(const THashSet<TStringBuf>& columns, NYql::TPositionHandle pos, 
+    NYql::TExprContext& ctx); 
+ 
+NYql::NNodes::TCoAtomList BuildColumnsList(const TVector<TString>& columns, NYql::TPositionHandle pos, 
+    NYql::TExprContext& ctx); 
+ 
+} // NKikimr::NKqp::NOpt 
+ 
+ 
+ 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy_limit.cpp b/ydb/core/kqp/opt/physical/kqp_opt_phy_limit.cpp
index e09357ea69..f31b329db1 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy_limit.cpp
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy_limit.cpp
@@ -1,9 +1,9 @@
 #include "kqp_opt_phy_rules.h"
-#include "kqp_opt_phy_impl.h"
+#include "kqp_opt_phy_impl.h" 
 
 #include <ydb/core/kqp/common/kqp_yql.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NNodes;
@@ -88,5 +88,5 @@ TExprBase KqpApplyLimitToReadTable(TExprBase node, TExprContext& ctx, const TKqp
         .Done();
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy_olap_filter.cpp b/ydb/core/kqp/opt/physical/kqp_opt_phy_olap_filter.cpp
index fa0bb9cc80..4e0564ff2b 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy_olap_filter.cpp
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy_olap_filter.cpp
@@ -3,7 +3,7 @@
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/library/yql/core/extract_predicate/extract_predicate.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NNodes;
@@ -718,4 +718,4 @@ TExprBase KqpPushOlapFilter(TExprBase node, TExprContext& ctx, const TKqpOptimiz
 #endif
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy_rules.h b/ydb/core/kqp/opt/physical/kqp_opt_phy_rules.h
index 83e1114b17..64d745227f 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy_rules.h
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy_rules.h
@@ -9,7 +9,7 @@
  * This file contains declaration of all rule functions for physical optimizer
  */
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 NYql::NNodes::TExprBase KqpBuildReadTableStage(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx,
     const TKqpOptimizeContext& kqpCtx);
@@ -30,4 +30,4 @@ NYql::NNodes::TExprBase KqpPushOlapFilter(NYql::NNodes::TExprBase node, NYql::TE
 
 NYql::NNodes::TExprBase KqpFloatUpStage(NYql::NNodes::TExprBase node, NYql::TExprContext& ctx);
 
-} // NKikimr::NKqp::NOpt
+} // NKikimr::NKqp::NOpt 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy_sort.cpp b/ydb/core/kqp/opt/physical/kqp_opt_phy_sort.cpp
index 97b416f7a8..9f05668cd2 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy_sort.cpp
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy_sort.cpp
@@ -1,12 +1,12 @@
 #include "kqp_opt_phy_rules.h"
-#include "kqp_opt_phy_impl.h"
+#include "kqp_opt_phy_impl.h" 
 
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/opt/kqp_opt_impl.h>
 
 #include <ydb/library/yql/core/yql_opt_utils.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NNodes;
@@ -156,5 +156,5 @@ TExprBase KqpRemoveRedundantSortByPk(TExprBase node, TExprContext& ctx, const TK
     }
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
 
diff --git a/ydb/core/kqp/opt/physical/kqp_opt_phy_stage_float_up.cpp b/ydb/core/kqp/opt/physical/kqp_opt_phy_stage_float_up.cpp
index 020a2f9572..9a70ce5549 100644
--- a/ydb/core/kqp/opt/physical/kqp_opt_phy_stage_float_up.cpp
+++ b/ydb/core/kqp/opt/physical/kqp_opt_phy_stage_float_up.cpp
@@ -1,5 +1,5 @@
 #include "kqp_opt_phy_rules.h"
-#include "kqp_opt_phy_impl.h"
+#include "kqp_opt_phy_impl.h" 
 
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/opt/kqp_opt_impl.h>
@@ -7,7 +7,7 @@
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 
-namespace NKikimr::NKqp::NOpt {
+namespace NKikimr::NKqp::NOpt { 
 
 using namespace NYql;
 using namespace NYql::NNodes;
@@ -203,5 +203,5 @@ TExprBase KqpFloatUpStage(TExprBase node, TExprContext& ctx) {
         .Done();
 }
 
-} // namespace NKikimr::NKqp::NOpt
+} // namespace NKikimr::NKqp::NOpt 
 
diff --git a/ydb/core/kqp/opt/physical/ya.make b/ydb/core/kqp/opt/physical/ya.make
index 81c4b319b9..22cb476ece 100644
--- a/ydb/core/kqp/opt/physical/ya.make
+++ b/ydb/core/kqp/opt/physical/ya.make
@@ -12,12 +12,12 @@ SRCS(
     kqp_opt_phy_sort.cpp
     kqp_opt_phy_helpers.cpp
     kqp_opt_phy_stage_float_up.cpp
-    kqp_opt_phy.cpp
+    kqp_opt_phy.cpp 
 )
 
 PEERDIR(
     ydb/core/kqp/common
-    ydb/core/kqp/opt/physical/effects
+    ydb/core/kqp/opt/physical/effects 
     ydb/library/yql/dq/common
     ydb/library/yql/dq/opt
 )
diff --git a/ydb/core/kqp/opt/ya.make b/ydb/core/kqp/opt/ya.make
index 6287365b19..74b68ccff1 100644
--- a/ydb/core/kqp/opt/ya.make
+++ b/ydb/core/kqp/opt/ya.make
@@ -1,30 +1,30 @@
-LIBRARY()
-
-OWNER(
-    spuchin
-    g:kikimr
-)
-
-SRCS(
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
+    g:kikimr 
+) 
+ 
+SRCS( 
     kqp_opt.cpp
     kqp_opt_build_txs.cpp
-    kqp_opt_effects.cpp
-    kqp_opt_join.cpp
-    kqp_opt_kql.cpp
-    kqp_opt_phase.cpp
+    kqp_opt_effects.cpp 
+    kqp_opt_join.cpp 
+    kqp_opt_kql.cpp 
+    kqp_opt_phase.cpp 
     kqp_opt_phy_check.cpp
     kqp_opt_phy_finalize.cpp
-)
-
-PEERDIR(
+) 
+ 
+PEERDIR( 
     ydb/core/kqp/common
     ydb/core/kqp/opt/logical
     ydb/core/kqp/opt/peephole
     ydb/core/kqp/opt/physical
     ydb/library/yql/dq/common
     ydb/library/yql/dq/opt
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-END()
+END() 
diff --git a/ydb/core/kqp/prepare/kqp_prepare.h b/ydb/core/kqp/prepare/kqp_prepare.h
index d114a44945..5695ac4de4 100644
--- a/ydb/core/kqp/prepare/kqp_prepare.h
+++ b/ydb/core/kqp/prepare/kqp_prepare.h
@@ -1,193 +1,193 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/common/kqp_gateway.h>
 #include <ydb/core/kqp/common/kqp_transform.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-enum class ECommitSafety {
-    Full,
-    Safe,
-    Moderate
-};
-
-struct TExprScope {
-    NYql::NNodes::TCallable Callable;
-    NYql::NNodes::TCoLambda Lambda;
-    ui32 Depth;
-
-    TExprScope(NYql::NNodes::TCallable callable, NYql::NNodes::TCoLambda Lambda, ui32 depth)
-        : Callable(callable)
-        , Lambda(Lambda)
-        , Depth(depth) {}
-};
-
-struct TNodeInfo {
-    TMaybe<TExprScope> Scope;
-    bool IsImmediate;
-    bool RequireImmediate;
-    bool IsExecutable;
-    bool AreInputsExecutable;
-
-    TNodeInfo()
-        : IsImmediate(false)
-        , RequireImmediate(false)
-        , IsExecutable(false)
-        , AreInputsExecutable(false) {}
-};
-
-using TExprToExprListMap = THashMap<const NYql::TExprNode*, TVector<NYql::NNodes::TExprBase>>;
-using TExprToNodeInfoMap = THashMap<const NYql::TExprNode*, TNodeInfo>;
-
-struct TScopedNode {
-    NYql::NNodes::TExprBase Node;
-    TMaybe<TExprScope> Scope;
-
-    TScopedNode(NYql::NNodes::TExprBase node, TMaybe<TExprScope> scope = {})
-        : Node(node)
-        , Scope(scope) {}
-};
-
-struct TKqpAnalyzeResults {
-    bool CanExecute;
-    TVector<TScopedNode> ExecutionRoots;
-    TExprToNodeInfoMap ExprToNodeInfoMap;
-    TExprToExprListMap LambdaToExecRootsMap;
-    TExprToExprListMap CallableToExecRootsMap;
-};
-
-using TMkqlResult = NKikimrMiniKQL::TResult;
-
-struct TMkqlExecuteResult {
-    TString Program;
-    NThreading::TFuture<IKqpGateway::TMkqlResult> Future;
-
-    TMkqlExecuteResult(const TString& program, const NThreading::TFuture<IKqpGateway::TMkqlResult>& future)
-        : Program(program)
-        , Future(future) {}
-
-    TMkqlExecuteResult(const NThreading::TFuture<IKqpGateway::TMkqlResult>& future)
-        : Program()
-        , Future(future) {}
-
-    TMkqlExecuteResult() {}
-};
-
-struct TKqlTransformContext : TThrRefBase {
-    TKqlTransformContext(NYql::TKikimrConfiguration::TPtr& config, TIntrusivePtr<NYql::TKikimrQueryContext> queryCtx,
-        TIntrusivePtr<NYql::TKikimrTablesData> tables)
-        : Config(config)
-        , QueryCtx(queryCtx)
-        , Tables(tables) {}
-
-    NYql::TKikimrConfiguration::TPtr Config;
-    TIntrusivePtr<NYql::TKikimrQueryContext> QueryCtx;
-    TIntrusivePtr<NYql::TKikimrTablesData> Tables;
-    NKikimrKqp::TKqlSettings Settings;
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+enum class ECommitSafety { 
+    Full, 
+    Safe, 
+    Moderate 
+}; 
+ 
+struct TExprScope { 
+    NYql::NNodes::TCallable Callable; 
+    NYql::NNodes::TCoLambda Lambda; 
+    ui32 Depth; 
+ 
+    TExprScope(NYql::NNodes::TCallable callable, NYql::NNodes::TCoLambda Lambda, ui32 depth) 
+        : Callable(callable) 
+        , Lambda(Lambda) 
+        , Depth(depth) {} 
+}; 
+ 
+struct TNodeInfo { 
+    TMaybe<TExprScope> Scope; 
+    bool IsImmediate; 
+    bool RequireImmediate; 
+    bool IsExecutable; 
+    bool AreInputsExecutable; 
+ 
+    TNodeInfo() 
+        : IsImmediate(false) 
+        , RequireImmediate(false) 
+        , IsExecutable(false) 
+        , AreInputsExecutable(false) {} 
+}; 
+ 
+using TExprToExprListMap = THashMap<const NYql::TExprNode*, TVector<NYql::NNodes::TExprBase>>; 
+using TExprToNodeInfoMap = THashMap<const NYql::TExprNode*, TNodeInfo>; 
+ 
+struct TScopedNode { 
+    NYql::NNodes::TExprBase Node; 
+    TMaybe<TExprScope> Scope; 
+ 
+    TScopedNode(NYql::NNodes::TExprBase node, TMaybe<TExprScope> scope = {}) 
+        : Node(node) 
+        , Scope(scope) {} 
+}; 
+ 
+struct TKqpAnalyzeResults { 
+    bool CanExecute; 
+    TVector<TScopedNode> ExecutionRoots; 
+    TExprToNodeInfoMap ExprToNodeInfoMap; 
+    TExprToExprListMap LambdaToExecRootsMap; 
+    TExprToExprListMap CallableToExecRootsMap; 
+}; 
+ 
+using TMkqlResult = NKikimrMiniKQL::TResult; 
+ 
+struct TMkqlExecuteResult { 
+    TString Program; 
+    NThreading::TFuture<IKqpGateway::TMkqlResult> Future; 
+ 
+    TMkqlExecuteResult(const TString& program, const NThreading::TFuture<IKqpGateway::TMkqlResult>& future) 
+        : Program(program) 
+        , Future(future) {} 
+ 
+    TMkqlExecuteResult(const NThreading::TFuture<IKqpGateway::TMkqlResult>& future) 
+        : Program() 
+        , Future(future) {} 
+ 
+    TMkqlExecuteResult() {} 
+}; 
+ 
+struct TKqlTransformContext : TThrRefBase { 
+    TKqlTransformContext(NYql::TKikimrConfiguration::TPtr& config, TIntrusivePtr<NYql::TKikimrQueryContext> queryCtx, 
+        TIntrusivePtr<NYql::TKikimrTablesData> tables) 
+        : Config(config) 
+        , QueryCtx(queryCtx) 
+        , Tables(tables) {} 
+ 
+    NYql::TKikimrConfiguration::TPtr Config; 
+    TIntrusivePtr<NYql::TKikimrQueryContext> QueryCtx; 
+    TIntrusivePtr<NYql::TKikimrTablesData> Tables; 
+    NKikimrKqp::TKqlSettings Settings; 
     NActors::TActorId ReplyTarget;
-
-    TKqpAnalyzeResults AnalyzeResults;
+ 
+    TKqpAnalyzeResults AnalyzeResults; 
     NKikimrKqp::TPreparedKql* PreparingKql = nullptr;
     const NKikimrKqp::TPreparedKql* PreparedKql;
-    NKqpProto::TKqpStatsQuery QueryStats;
-    const NKqpProto::TKqpPhyQuery* PhysicalQuery;
-
-    TVector<TSimpleSharedPtr<NKikimrMiniKQL::TResult>> MkqlResults;
-    TVector<NKikimrMiniKQL::TResult> PhysicalQueryResults;
-
-    ECommitSafety CommitSafety() const {
-        auto safetyValue = Config->CommitSafety.Get().GetRef();
-        if (safetyValue == "Full") {
-            return ECommitSafety::Full;
-        } else if (safetyValue == "Safe") {
-            return ECommitSafety::Safe;
-        } else if (safetyValue == "Moderate") {
-            return ECommitSafety::Moderate;
-        }
-
-        YQL_ENSURE(false, "Unexpected value for CommitSafety.");
-    }
-
+    NKqpProto::TKqpStatsQuery QueryStats; 
+    const NKqpProto::TKqpPhyQuery* PhysicalQuery; 
+ 
+    TVector<TSimpleSharedPtr<NKikimrMiniKQL::TResult>> MkqlResults; 
+    TVector<NKikimrMiniKQL::TResult> PhysicalQueryResults; 
+ 
+    ECommitSafety CommitSafety() const { 
+        auto safetyValue = Config->CommitSafety.Get().GetRef(); 
+        if (safetyValue == "Full") { 
+            return ECommitSafety::Full; 
+        } else if (safetyValue == "Safe") { 
+            return ECommitSafety::Safe; 
+        } else if (safetyValue == "Moderate") { 
+            return ECommitSafety::Moderate; 
+        } 
+ 
+        YQL_ENSURE(false, "Unexpected value for CommitSafety."); 
+    } 
+ 
     NKikimrKqp::TPreparedKql& GetPreparingKql() {
         YQL_ENSURE(PreparingKql);
         return *PreparingKql;
     }
 
     const NKikimrKqp::TPreparedKql& GetPreparedKql() {
-        YQL_ENSURE(PreparedKql);
-        return *PreparedKql;
-    }
-
+        YQL_ENSURE(PreparedKql); 
+        return *PreparedKql; 
+    } 
+ 
     IKqpGateway::TMkqlSettings GetMkqlSettings(bool hasDataEffects, TInstant now) const;
-    void AddMkqlStats(const TString& program, NKikimrQueryStats::TTxStats&& txStats);
-
-    void Reset() {
-        Settings = {};
-        ReplyTarget = {};
-        AnalyzeResults = {};
-        MkqlResults.clear();
+    void AddMkqlStats(const TString& program, NKikimrQueryStats::TTxStats&& txStats); 
+ 
+    void Reset() { 
+        Settings = {}; 
+        ReplyTarget = {}; 
+        AnalyzeResults = {}; 
+        MkqlResults.clear(); 
         QueryStats = {};
         PreparingKql = nullptr;
-        PreparedKql = nullptr;
-        PhysicalQuery = nullptr;
-        PhysicalQueryResults.clear();
-    }
-};
-
-class TKqpTransactionState : public TThrRefBase {
-public:
-    TKqpTransactionState(TIntrusivePtr<NYql::TKikimrSessionContext> sessionCtx)
-        : SessionCtx(sessionCtx) {}
-
-    TKqpTransactionContext& Tx() { return static_cast<TKqpTransactionContext&>(SessionCtx->Tx()); }
-    const TKqpTransactionContext& Tx() const { return static_cast<TKqpTransactionContext&>(SessionCtx->Tx()); }
-
-private:
-    TIntrusivePtr<NYql::TKikimrSessionContext> SessionCtx;
-};
-
-bool AddDeferredEffect(NYql::NNodes::TExprBase effect, const TVector<NKikimrKqp::TParameterBinding>& bindings,
-    NYql::TExprContext& ctx, TKqpTransactionState& txState, TKqlTransformContext& transformCtx,
-    bool preserveParamValues);
-
-bool AddDeferredEffect(NYql::NNodes::TExprBase effect, NYql::TExprContext& ctx, TKqpTransactionState& txState,
-    TKqlTransformContext& transformCtx, bool preserveParamValues);
-
+        PreparedKql = nullptr; 
+        PhysicalQuery = nullptr; 
+        PhysicalQueryResults.clear(); 
+    } 
+}; 
+ 
+class TKqpTransactionState : public TThrRefBase { 
+public: 
+    TKqpTransactionState(TIntrusivePtr<NYql::TKikimrSessionContext> sessionCtx) 
+        : SessionCtx(sessionCtx) {} 
+ 
+    TKqpTransactionContext& Tx() { return static_cast<TKqpTransactionContext&>(SessionCtx->Tx()); } 
+    const TKqpTransactionContext& Tx() const { return static_cast<TKqpTransactionContext&>(SessionCtx->Tx()); } 
+ 
+private: 
+    TIntrusivePtr<NYql::TKikimrSessionContext> SessionCtx; 
+}; 
+ 
+bool AddDeferredEffect(NYql::NNodes::TExprBase effect, const TVector<NKikimrKqp::TParameterBinding>& bindings, 
+    NYql::TExprContext& ctx, TKqpTransactionState& txState, TKqlTransformContext& transformCtx, 
+    bool preserveParamValues); 
+ 
+bool AddDeferredEffect(NYql::NNodes::TExprBase effect, NYql::TExprContext& ctx, TKqpTransactionState& txState, 
+    TKqlTransformContext& transformCtx, bool preserveParamValues); 
+ 
 NYql::TIssue GetLocksInvalidatedIssue(const TKqpTransactionContext& txCtx, const TMaybe<TKqpTxLock>& invalidatedLock);
-
+ 
 bool MergeLocks(const NKikimrMiniKQL::TType& type, const NKikimrMiniKQL::TValue& value, TKqpTransactionContext& txCtx,
         NYql::TExprContext& ctx);
-
+ 
 std::pair<bool, std::vector<NYql::TIssue>> MergeLocks(const NKikimrMiniKQL::TType& type, const NKikimrMiniKQL::TValue& value,
         TKqpTransactionContext& txCtx);
-
+ 
 bool UnpackMergeLocks(const NKikimrMiniKQL::TResult& result, TKqpTransactionContext& txCtx, NYql::TExprContext& ctx);
 
-TKqpParamsMap BuildParamsMap(const TVector<NKikimrKqp::TParameterBinding>& bindings,
-    TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx, bool acquireLocks);
-
-TVector<NKikimrKqp::TParameterBinding> CollectParams(NYql::NNodes::TExprBase query);
-
-NKikimrMiniKQL::TParams GetLocksParamValue(const TKqpTxLocks& locks);
-
-TAutoPtr<NYql::IGraphTransformer> CreateKqpSimplifyTransformer();
-TAutoPtr<NYql::IGraphTransformer> CreateKqpAnalyzeTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx);
-TAutoPtr<NYql::IGraphTransformer> CreateKqpRewriteTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx);
-TAutoPtr<NYql::IGraphTransformer> CreateKqpExecTransformer(TIntrusivePtr<IKqpGateway> gateway,
-    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx);
-TAutoPtr<NYql::IGraphTransformer> CreateKqpSubstituteTransformer(TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx);
-TAutoPtr<NYql::IGraphTransformer> CreateKqpFinalizeTransformer(TIntrusivePtr<IKqpGateway> gateway,
-    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx);
-
-TAutoPtr<NYql::IGraphTransformer> CreateKqpTypeAnnotationTransformer(const TString& cluster,
+TKqpParamsMap BuildParamsMap(const TVector<NKikimrKqp::TParameterBinding>& bindings, 
+    TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx, bool acquireLocks); 
+ 
+TVector<NKikimrKqp::TParameterBinding> CollectParams(NYql::NNodes::TExprBase query); 
+ 
+NKikimrMiniKQL::TParams GetLocksParamValue(const TKqpTxLocks& locks); 
+ 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpSimplifyTransformer(); 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpAnalyzeTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx); 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpRewriteTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx); 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpExecTransformer(TIntrusivePtr<IKqpGateway> gateway, 
+    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx); 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpSubstituteTransformer(TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx); 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpFinalizeTransformer(TIntrusivePtr<IKqpGateway> gateway, 
+    const TString& cluster, TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx); 
+ 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpTypeAnnotationTransformer(const TString& cluster, 
     TIntrusivePtr<NYql::TKikimrTablesData> tablesData, NYql::TTypeAnnotationContext& typesCtx,
     NYql::TKikimrConfiguration::TPtr config);
-TAutoPtr<NYql::IGraphTransformer> CreateKqpCheckKiProgramTransformer();
-TAutoPtr<NYql::IGraphTransformer> CreateKqpCheckQueryTransformer();
-
+TAutoPtr<NYql::IGraphTransformer> CreateKqpCheckKiProgramTransformer(); 
+TAutoPtr<NYql::IGraphTransformer> CreateKqpCheckQueryTransformer(); 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/kqp_prepare_impl.h b/ydb/core/kqp/prepare/kqp_prepare_impl.h
index 1d6e4c5064..c56fd4d6e9 100644
--- a/ydb/core/kqp/prepare/kqp_prepare_impl.h
+++ b/ydb/core/kqp/prepare/kqp_prepare_impl.h
@@ -1,36 +1,36 @@
-#pragma once
-
-#include "kqp_prepare.h"
-
-namespace NKikimr {
-namespace NKqp {
-
-enum class ETableReadType {
-    Unspecified,
-    FullScan,
-    Scan,
-    Lookup,
-    MultiLookup,
-};
-
-enum class ETableWriteType {
-    Unspecified,
-    Upsert,
-    MultiUpsert,
-    Erase,
-    MultiErase,
-};
-
-bool HasEffects(const NYql::NNodes::TKiProgram& program);
-bool HasResults(const NYql::NNodes::TKiProgram& program);
-
+#pragma once 
+ 
+#include "kqp_prepare.h" 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+enum class ETableReadType { 
+    Unspecified, 
+    FullScan, 
+    Scan, 
+    Lookup, 
+    MultiLookup, 
+}; 
+ 
+enum class ETableWriteType { 
+    Unspecified, 
+    Upsert, 
+    MultiUpsert, 
+    Erase, 
+    MultiErase, 
+}; 
+ 
+bool HasEffects(const NYql::NNodes::TKiProgram& program); 
+bool HasResults(const NYql::NNodes::TKiProgram& program); 
+ 
 NYql::NNodes::TCoList GetEmptyEffectsList(NYql::TPositionHandle pos, NYql::TExprContext& ctx);
-
-TMkqlExecuteResult ExecuteMkql(NYql::NNodes::TKiProgram program, TIntrusivePtr<IKqpGateway> gateway,
-    const TString& cluster, NYql::TExprContext& ctx, TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx, bool hasDataEffects);
-
-void LogMkqlResult(const NKikimrMiniKQL::TResult& result, NYql::TExprContext& ctx);
-
+ 
+TMkqlExecuteResult ExecuteMkql(NYql::NNodes::TKiProgram program, TIntrusivePtr<IKqpGateway> gateway, 
+    const TString& cluster, NYql::TExprContext& ctx, TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx, bool hasDataEffects); 
+ 
+void LogMkqlResult(const NKikimrMiniKQL::TResult& result, NYql::TExprContext& ctx); 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/kqp_query_analyze.cpp b/ydb/core/kqp/prepare/kqp_query_analyze.cpp
index b37e4eb058..29b8b119e3 100644
--- a/ydb/core/kqp/prepare/kqp_query_analyze.cpp
+++ b/ydb/core/kqp/prepare/kqp_query_analyze.cpp
@@ -1,566 +1,566 @@
-#include "kqp_prepare_impl.h"
-
+#include "kqp_prepare_impl.h" 
+ 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 #include <ydb/library/yql/core/yql_expr_type_annotation.h>
 #include <ydb/library/yql/utils/log/log.h>
 
-#include <util/generic/queue.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-
-namespace {
-
-const THashSet<TStringBuf> SafeCallables {
-    TCoJust::CallableName(),
-    TCoCoalesce::CallableName(),
-    TCoToOptional::CallableName(),
+#include <util/generic/queue.h> 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+const THashSet<TStringBuf> SafeCallables { 
+    TCoJust::CallableName(), 
+    TCoCoalesce::CallableName(), 
+    TCoToOptional::CallableName(), 
     TCoHead::CallableName(),
     TCoLast::CallableName(),
-    TCoToList::CallableName(),
-
-    TCoMember::CallableName(),
-    TCoAsStruct::CallableName(),
-
-    TCoNothing::CallableName(),
-    TCoNull::CallableName(),
-    TCoDefault::CallableName(),
-    TCoExists::CallableName(),
-
-    TCoNth::CallableName()
-};
-
-const THashSet<TStringBuf> ModerateCallables {
-    TCoAddMember::CallableName(),
-    TCoReplaceMember::CallableName(),
-};
-
-bool IsSafePayloadCallable(const TCallable& callable) {
-    if (callable.Maybe<TCoDataCtor>()) {
-        return true;
-    }
-
-    if (callable.Maybe<TCoCompare>()) {
-        return true;
-    }
-
+    TCoToList::CallableName(), 
+ 
+    TCoMember::CallableName(), 
+    TCoAsStruct::CallableName(), 
+ 
+    TCoNothing::CallableName(), 
+    TCoNull::CallableName(), 
+    TCoDefault::CallableName(), 
+    TCoExists::CallableName(), 
+ 
+    TCoNth::CallableName() 
+}; 
+ 
+const THashSet<TStringBuf> ModerateCallables { 
+    TCoAddMember::CallableName(), 
+    TCoReplaceMember::CallableName(), 
+}; 
+ 
+bool IsSafePayloadCallable(const TCallable& callable) { 
+    if (callable.Maybe<TCoDataCtor>()) { 
+        return true; 
+    } 
+ 
+    if (callable.Maybe<TCoCompare>()) { 
+        return true; 
+    } 
+ 
     if (callable.Maybe<TCoAnd>()) {
-        return true;
-    }
-
+        return true; 
+    } 
+ 
     if (callable.Maybe<TCoOr>()) {
         return true;
     }
 
-    if (callable.Maybe<TCoBinaryArithmetic>()) {
-        return true;
-    }
-
-    if (callable.Maybe<TCoCountBase>()) {
-        return true;
-    }
-
-    auto isOptInput = [](TExprBase input) {
-        return input.Maybe<TCoToList>() || input.Maybe<TCoTake>().Input().Maybe<TCoToList>();
-    };
-
-    if (auto maybeFilter = callable.Maybe<TCoFilterBase>()) {
-        auto filter = maybeFilter.Cast();
-
+    if (callable.Maybe<TCoBinaryArithmetic>()) { 
+        return true; 
+    } 
+ 
+    if (callable.Maybe<TCoCountBase>()) { 
+        return true; 
+    } 
+ 
+    auto isOptInput = [](TExprBase input) { 
+        return input.Maybe<TCoToList>() || input.Maybe<TCoTake>().Input().Maybe<TCoToList>(); 
+    }; 
+ 
+    if (auto maybeFilter = callable.Maybe<TCoFilterBase>()) { 
+        auto filter = maybeFilter.Cast(); 
+ 
         if (filter.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Optional) {
-            return true;
-        }
-
-        if (isOptInput(filter.Input())) {
-            return true;
-        }
-
-        return false;
-    }
-
-    if (auto maybeMap = callable.Maybe<TCoMapBase>()) {
-        auto map = maybeMap.Cast();
-
+            return true; 
+        } 
+ 
+        if (isOptInput(filter.Input())) { 
+            return true; 
+        } 
+ 
+        return false; 
+    } 
+ 
+    if (auto maybeMap = callable.Maybe<TCoMapBase>()) { 
+        auto map = maybeMap.Cast(); 
+ 
         if (map.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Optional) {
-            return true;
-        }
-
-        if (isOptInput(map.Input())) {
-            if (maybeMap.Maybe<TCoMap>()) {
-                return true;
-            } else {
-                auto body = map.Lambda().Body();
-
+            return true; 
+        } 
+ 
+        if (isOptInput(map.Input())) { 
+            if (maybeMap.Maybe<TCoMap>()) { 
+                return true; 
+            } else { 
+                auto body = map.Lambda().Body(); 
+ 
                 return body.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Optional ||
-                    body.Maybe<TCoToList>() || body.Maybe<TCoAsList>();
-            }
-        }
-
-        return false;
-    }
-
+                    body.Maybe<TCoToList>() || body.Maybe<TCoAsList>(); 
+            } 
+        } 
+ 
+        return false; 
+    } 
+ 
     return SafeCallables.contains(callable.CallableName());
-}
-
-bool IsModeratePayloadCallable(TCoNameValueTupleList key, const TCallable& callable) {
-    if (IsSafePayloadCallable(callable)) {
-        return true;
-    }
-
-    if (auto selectRow = callable.Maybe<TKiSelectRow>()) {
-        return selectRow.Cast().Key().Raw() == key.Raw();
-    }
-
+} 
+ 
+bool IsModeratePayloadCallable(TCoNameValueTupleList key, const TCallable& callable) { 
+    if (IsSafePayloadCallable(callable)) { 
+        return true; 
+    } 
+ 
+    if (auto selectRow = callable.Maybe<TKiSelectRow>()) { 
+        return selectRow.Cast().Key().Raw() == key.Raw(); 
+    } 
+ 
     return ModerateCallables.contains(callable.CallableName());
-}
-
-struct TAnalyzeTxContext {
-    TExprToNodeInfoMap NodesInfo;
-    TVector<TScopedNode> ExecutionRoots;
-};
-
-void GatherNodeScopes(TExprBase root, TAnalyzeTxContext& analyzeCtx) {
-    TNodeSet visitedNodes;
-
-    TQueue<TMaybe<TExprScope>> scopesQueue;
-    scopesQueue.push(TMaybe<TExprScope>());
-
-    while (!scopesQueue.empty()) {
-        auto scope = scopesQueue.front();
-        scopesQueue.pop();
-
-        auto scopeRoot = scope
-            ? scope->Lambda.Body()
-            : root;
-
-        VisitExpr(scopeRoot.Ptr(), [scope, &scopesQueue, &analyzeCtx] (const TExprNode::TPtr& exprNode) {
-            auto node = TExprBase(exprNode);
-
-            if (node.Maybe<TCoLambda>()) {
-                return false;
-            }
-
-            if (auto callable = node.Maybe<TCallable>()) {
-                auto scopeDepth = scope ? scope->Depth : 0;
-
-                for (const auto& arg : node.Cast<TVarArgCallable<TExprBase>>()) {
-                    if (auto lambda = arg.Maybe<TCoLambda>()) {
-                        TExprScope newScope(callable.Cast(), lambda.Cast(), scopeDepth + 1);
-                        scopesQueue.push(newScope);
-
-                        for (const auto& lambdaArg : lambda.Cast().Args()) {
-                            analyzeCtx.NodesInfo[lambdaArg.Raw()].Scope = newScope;
-                        }
-                    }
-                }
-            }
-
-            return true;
-        }, visitedNodes);
-    };
-
-
-    VisitExpr(root.Ptr(),
-        [] (const TExprNode::TPtr& exprNode) {
-            Y_UNUSED(exprNode);
-            return true;
-        },
-        [&analyzeCtx] (const TExprNode::TPtr& exprNode) {
-            auto node = TExprBase(exprNode);
-
-            auto& nodeInfo = analyzeCtx.NodesInfo[node.Raw()];
-            if (!node.Maybe<TCoArgument>()) {
-                YQL_ENSURE(!nodeInfo.Scope);
-            }
-
-            TMaybe<TExprScope> scope = nodeInfo.Scope;
-            for (const auto& child : exprNode->Children()) {
-                if (TMaybeNode<TCoLambda>(child)) {
-                    continue;
-                }
-
-                auto childScope = analyzeCtx.NodesInfo[child.Get()].Scope;
-                if (childScope) {
-                    if (scope) {
-                        scope = childScope->Depth > scope->Depth
-                            ? childScope
-                            : scope;
-                    } else {
-                        scope = childScope;
-                    }
-                }
-            }
-
-            analyzeCtx.NodesInfo[node.Raw()].Scope = scope;
-            return true;
-        });
-}
-
-void RequireImmediate(TExprBase node, TAnalyzeTxContext& ctx) {
-    ctx.NodesInfo[node.Raw()].RequireImmediate = true;
-}
-
+} 
+ 
+struct TAnalyzeTxContext { 
+    TExprToNodeInfoMap NodesInfo; 
+    TVector<TScopedNode> ExecutionRoots; 
+}; 
+ 
+void GatherNodeScopes(TExprBase root, TAnalyzeTxContext& analyzeCtx) { 
+    TNodeSet visitedNodes; 
+ 
+    TQueue<TMaybe<TExprScope>> scopesQueue; 
+    scopesQueue.push(TMaybe<TExprScope>()); 
+ 
+    while (!scopesQueue.empty()) { 
+        auto scope = scopesQueue.front(); 
+        scopesQueue.pop(); 
+ 
+        auto scopeRoot = scope 
+            ? scope->Lambda.Body() 
+            : root; 
+ 
+        VisitExpr(scopeRoot.Ptr(), [scope, &scopesQueue, &analyzeCtx] (const TExprNode::TPtr& exprNode) { 
+            auto node = TExprBase(exprNode); 
+ 
+            if (node.Maybe<TCoLambda>()) { 
+                return false; 
+            } 
+ 
+            if (auto callable = node.Maybe<TCallable>()) { 
+                auto scopeDepth = scope ? scope->Depth : 0; 
+ 
+                for (const auto& arg : node.Cast<TVarArgCallable<TExprBase>>()) { 
+                    if (auto lambda = arg.Maybe<TCoLambda>()) { 
+                        TExprScope newScope(callable.Cast(), lambda.Cast(), scopeDepth + 1); 
+                        scopesQueue.push(newScope); 
+ 
+                        for (const auto& lambdaArg : lambda.Cast().Args()) { 
+                            analyzeCtx.NodesInfo[lambdaArg.Raw()].Scope = newScope; 
+                        } 
+                    } 
+                } 
+            } 
+ 
+            return true; 
+        }, visitedNodes); 
+    }; 
+ 
+ 
+    VisitExpr(root.Ptr(), 
+        [] (const TExprNode::TPtr& exprNode) { 
+            Y_UNUSED(exprNode); 
+            return true; 
+        }, 
+        [&analyzeCtx] (const TExprNode::TPtr& exprNode) { 
+            auto node = TExprBase(exprNode); 
+ 
+            auto& nodeInfo = analyzeCtx.NodesInfo[node.Raw()]; 
+            if (!node.Maybe<TCoArgument>()) { 
+                YQL_ENSURE(!nodeInfo.Scope); 
+            } 
+ 
+            TMaybe<TExprScope> scope = nodeInfo.Scope; 
+            for (const auto& child : exprNode->Children()) { 
+                if (TMaybeNode<TCoLambda>(child)) { 
+                    continue; 
+                } 
+ 
+                auto childScope = analyzeCtx.NodesInfo[child.Get()].Scope; 
+                if (childScope) { 
+                    if (scope) { 
+                        scope = childScope->Depth > scope->Depth 
+                            ? childScope 
+                            : scope; 
+                    } else { 
+                        scope = childScope; 
+                    } 
+                } 
+            } 
+ 
+            analyzeCtx.NodesInfo[node.Raw()].Scope = scope; 
+            return true; 
+        }); 
+} 
+ 
+void RequireImmediate(TExprBase node, TAnalyzeTxContext& ctx) { 
+    ctx.NodesInfo[node.Raw()].RequireImmediate = true; 
+} 
+ 
 void RequireImmediateKey(TCoNameValueTupleList key, TAnalyzeTxContext& ctx) {
-    for (auto tuple : key) {
-        YQL_ENSURE(tuple.Value().IsValid());
-        RequireImmediate(tuple.Value().Cast(), ctx);
-    }
-}
-
-void RequireImmediateRange(TExprList range, TAnalyzeTxContext& ctx) {
-    for (auto tuple : range) {
-        if (auto columnRange = tuple.Maybe<TKiColumnRangeTuple>()) {
-            RequireImmediate(columnRange.Cast().From(), ctx);
-            RequireImmediate(columnRange.Cast().To(), ctx);
-        }
-    }
-}
-
-void RequireImmediateSettings(TCoNameValueTupleList settings, TAnalyzeTxContext& ctx) {
-    for (auto setting : settings) {
-        if (setting.Value() && setting.Value().Ref().IsComputable()) {
-            RequireImmediate(setting.Value().Cast(), ctx);
-        }
-    }
-}
-
-void RequireEffectPayloadSafety(TCoNameValueTupleList key, TCoNameValueTupleList payload, TAnalyzeTxContext& ctx,
-    ECommitSafety commitSafety)
-{
-    switch (commitSafety) {
-        case ECommitSafety::Full:
-            for (auto tuple : payload) {
-                YQL_ENSURE(tuple.Value().IsValid());
-                RequireImmediate(tuple.Value().Cast(), ctx);
-            }
-            return;
-
-        case ECommitSafety::Safe:
-        case ECommitSafety::Moderate:
-            break;
-
-        default:
-            YQL_ENSURE(false, "Unexpected commit safety level.");
-    }
-
-    VisitExpr(payload.Ptr(), [&ctx, key, commitSafety] (const TExprNode::TPtr& exprNode) {
-        TExprBase node(exprNode);
-
-        if (node.Maybe<TCoLambda>()) {
-            return false;
-        }
-
-        if (node.Maybe<TCoArgument>()) {
-            return false;
-        }
-
-        if (!node.Ref().IsComputable()) {
-            return true;
-        }
-
-        if (ctx.NodesInfo[node.Raw()].IsImmediate) {
-            return false;
-        }
-
-        if (auto maybeList = node.Maybe<TExprList>()) {
-            return true;
-        }
-
-        if (auto maybeCallable = node.Maybe<TCallable>()) {
-            auto callable = maybeCallable.Cast();
-
-            bool safeCallable = commitSafety == ECommitSafety::Safe
-                ? IsSafePayloadCallable(callable)
-                : IsModeratePayloadCallable(key, callable);
-
-            if (!safeCallable) {
-                RequireImmediate(callable, ctx);
-                return false;
-            }
-
-            for (const auto& arg : callable.Cast<TVarArgCallable<TExprBase>>()) {
-                if (auto lambda = arg.Maybe<TCoLambda>()) {
-                    auto badNode = FindNode(lambda.Cast().Body().Ptr(),
-                        [key, commitSafety] (const TExprNode::TPtr& node) {
-                            if (!node->IsCallable()) {
-                                return false;
-                            }
-
-                            auto callable = TCallable(node);
-                            bool safeCallable = commitSafety == ECommitSafety::Safe
-                                ? IsSafePayloadCallable(callable)
-                                : IsModeratePayloadCallable(key, callable);
-
-                            return !safeCallable;
-                        });
-
-                    if (badNode) {
-                        RequireImmediate(callable, ctx);
-                        return false;
-                    }
-                }
-            }
-
-            return true;
-        }
-
-        RequireImmediate(node, ctx);
-        return false;
-    });
-}
-
-void MarkImmediateNodes(TExprBase node, TAnalyzeTxContext& ctx) {
+    for (auto tuple : key) { 
+        YQL_ENSURE(tuple.Value().IsValid()); 
+        RequireImmediate(tuple.Value().Cast(), ctx); 
+    } 
+} 
+ 
+void RequireImmediateRange(TExprList range, TAnalyzeTxContext& ctx) { 
+    for (auto tuple : range) { 
+        if (auto columnRange = tuple.Maybe<TKiColumnRangeTuple>()) { 
+            RequireImmediate(columnRange.Cast().From(), ctx); 
+            RequireImmediate(columnRange.Cast().To(), ctx); 
+        } 
+    } 
+} 
+ 
+void RequireImmediateSettings(TCoNameValueTupleList settings, TAnalyzeTxContext& ctx) { 
+    for (auto setting : settings) { 
+        if (setting.Value() && setting.Value().Ref().IsComputable()) { 
+            RequireImmediate(setting.Value().Cast(), ctx); 
+        } 
+    } 
+} 
+ 
+void RequireEffectPayloadSafety(TCoNameValueTupleList key, TCoNameValueTupleList payload, TAnalyzeTxContext& ctx, 
+    ECommitSafety commitSafety) 
+{ 
+    switch (commitSafety) { 
+        case ECommitSafety::Full: 
+            for (auto tuple : payload) { 
+                YQL_ENSURE(tuple.Value().IsValid()); 
+                RequireImmediate(tuple.Value().Cast(), ctx); 
+            } 
+            return; 
+ 
+        case ECommitSafety::Safe: 
+        case ECommitSafety::Moderate: 
+            break; 
+ 
+        default: 
+            YQL_ENSURE(false, "Unexpected commit safety level."); 
+    } 
+ 
+    VisitExpr(payload.Ptr(), [&ctx, key, commitSafety] (const TExprNode::TPtr& exprNode) { 
+        TExprBase node(exprNode); 
+ 
+        if (node.Maybe<TCoLambda>()) { 
+            return false; 
+        } 
+ 
+        if (node.Maybe<TCoArgument>()) { 
+            return false; 
+        } 
+ 
+        if (!node.Ref().IsComputable()) { 
+            return true; 
+        } 
+ 
+        if (ctx.NodesInfo[node.Raw()].IsImmediate) { 
+            return false; 
+        } 
+ 
+        if (auto maybeList = node.Maybe<TExprList>()) { 
+            return true; 
+        } 
+ 
+        if (auto maybeCallable = node.Maybe<TCallable>()) { 
+            auto callable = maybeCallable.Cast(); 
+ 
+            bool safeCallable = commitSafety == ECommitSafety::Safe 
+                ? IsSafePayloadCallable(callable) 
+                : IsModeratePayloadCallable(key, callable); 
+ 
+            if (!safeCallable) { 
+                RequireImmediate(callable, ctx); 
+                return false; 
+            } 
+ 
+            for (const auto& arg : callable.Cast<TVarArgCallable<TExprBase>>()) { 
+                if (auto lambda = arg.Maybe<TCoLambda>()) { 
+                    auto badNode = FindNode(lambda.Cast().Body().Ptr(), 
+                        [key, commitSafety] (const TExprNode::TPtr& node) { 
+                            if (!node->IsCallable()) { 
+                                return false; 
+                            } 
+ 
+                            auto callable = TCallable(node); 
+                            bool safeCallable = commitSafety == ECommitSafety::Safe 
+                                ? IsSafePayloadCallable(callable) 
+                                : IsModeratePayloadCallable(key, callable); 
+ 
+                            return !safeCallable; 
+                        }); 
+ 
+                    if (badNode) { 
+                        RequireImmediate(callable, ctx); 
+                        return false; 
+                    } 
+                } 
+            } 
+ 
+            return true; 
+        } 
+ 
+        RequireImmediate(node, ctx); 
+        return false; 
+    }); 
+} 
+ 
+void MarkImmediateNodes(TExprBase node, TAnalyzeTxContext& ctx) { 
     if (node.Maybe<TCoDataType>() ||
         node.Maybe<TCoOptionalType>())
-    {
-        ctx.NodesInfo[node.Raw()].IsImmediate = true;
-    }
-
-    if (node.Maybe<TCoDataCtor>() || node.Maybe<TCoVoid>() || node.Maybe<TCoNothing>() || node.Maybe<TCoNull>()) {
-        ctx.NodesInfo[node.Raw()].IsImmediate = true;
-    }
-
+    { 
+        ctx.NodesInfo[node.Raw()].IsImmediate = true; 
+    } 
+ 
+    if (node.Maybe<TCoDataCtor>() || node.Maybe<TCoVoid>() || node.Maybe<TCoNothing>() || node.Maybe<TCoNull>()) { 
+        ctx.NodesInfo[node.Raw()].IsImmediate = true; 
+    } 
+ 
     if (node.Maybe<TCoParameter>()) {
-        ctx.NodesInfo[node.Raw()].IsImmediate = true;
-    }
-
-    if (node.Maybe<TKiMapParameter>() || node.Maybe<TKiFlatMapParameter>()) {
-        auto mapLambda = node.Maybe<TKiMapParameter>()
-            ? node.Cast<TKiMapParameter>().Lambda()
-            : node.Cast<TKiFlatMapParameter>().Lambda();
-
-        ctx.NodesInfo[mapLambda.Args().Arg(0).Raw()].IsImmediate = true;
-    }
-}
-
-void MarkRequireImmediateNodes(TExprBase node, TAnalyzeTxContext& ctx) {
-    if (auto selectRow = node.Maybe<TKiSelectRow>()) {
-        RequireImmediateKey(selectRow.Cast().Key(), ctx);
-    }
-
-    if (auto selectRange = node.Maybe<TKiSelectRange>()) {
-        RequireImmediateRange(selectRange.Cast().Range(), ctx);
-        RequireImmediateSettings(selectRange.Cast().Settings(), ctx);
-    }
-
-    if (auto updateRow = node.Maybe<TKiUpdateRow>()) {
-        RequireImmediateKey(updateRow.Cast().Key(), ctx);
-    }
-
-    if (auto eraseRow = node.Maybe<TKiEraseRow>()) {
-        RequireImmediateKey(eraseRow.Cast().Key(), ctx);
-    }
-
-    if (node.Maybe<TKiMapParameter>() || node.Maybe<TKiFlatMapParameter>()) {
-        TExprBase input = node.Maybe<TKiMapParameter>()
-            ? node.Cast<TKiMapParameter>().Input()
-            : node.Cast<TKiFlatMapParameter>().Input();
-
-        ctx.NodesInfo[input.Raw()].RequireImmediate = true;
-    }
-
-    if (auto condEffect = node.Maybe<TKiConditionalEffect>()) {
-        ctx.NodesInfo[condEffect.Cast().Predicate().Raw()].RequireImmediate = true;
-    }
-}
-
-void PropagateImmediateNodes(TExprBase node, TAnalyzeTxContext& ctx) {
+        ctx.NodesInfo[node.Raw()].IsImmediate = true; 
+    } 
+ 
+    if (node.Maybe<TKiMapParameter>() || node.Maybe<TKiFlatMapParameter>()) { 
+        auto mapLambda = node.Maybe<TKiMapParameter>() 
+            ? node.Cast<TKiMapParameter>().Lambda() 
+            : node.Cast<TKiFlatMapParameter>().Lambda(); 
+ 
+        ctx.NodesInfo[mapLambda.Args().Arg(0).Raw()].IsImmediate = true; 
+    } 
+} 
+ 
+void MarkRequireImmediateNodes(TExprBase node, TAnalyzeTxContext& ctx) { 
+    if (auto selectRow = node.Maybe<TKiSelectRow>()) { 
+        RequireImmediateKey(selectRow.Cast().Key(), ctx); 
+    } 
+ 
+    if (auto selectRange = node.Maybe<TKiSelectRange>()) { 
+        RequireImmediateRange(selectRange.Cast().Range(), ctx); 
+        RequireImmediateSettings(selectRange.Cast().Settings(), ctx); 
+    } 
+ 
+    if (auto updateRow = node.Maybe<TKiUpdateRow>()) { 
+        RequireImmediateKey(updateRow.Cast().Key(), ctx); 
+    } 
+ 
+    if (auto eraseRow = node.Maybe<TKiEraseRow>()) { 
+        RequireImmediateKey(eraseRow.Cast().Key(), ctx); 
+    } 
+ 
+    if (node.Maybe<TKiMapParameter>() || node.Maybe<TKiFlatMapParameter>()) { 
+        TExprBase input = node.Maybe<TKiMapParameter>() 
+            ? node.Cast<TKiMapParameter>().Input() 
+            : node.Cast<TKiFlatMapParameter>().Input(); 
+ 
+        ctx.NodesInfo[input.Raw()].RequireImmediate = true; 
+    } 
+ 
+    if (auto condEffect = node.Maybe<TKiConditionalEffect>()) { 
+        ctx.NodesInfo[condEffect.Cast().Predicate().Raw()].RequireImmediate = true; 
+    } 
+} 
+ 
+void PropagateImmediateNodes(TExprBase node, TAnalyzeTxContext& ctx) { 
     if (auto just = node.Maybe<TCoJust>()) {
-        if (ctx.NodesInfo[just.Cast().Input().Raw()].IsImmediate) {
-            ctx.NodesInfo[node.Raw()].IsImmediate = true;
-        }
-    }
-
+        if (ctx.NodesInfo[just.Cast().Input().Raw()].IsImmediate) { 
+            ctx.NodesInfo[node.Raw()].IsImmediate = true; 
+        } 
+    } 
+ 
     if (auto nth = node.Maybe<TCoNth>()) {
-        if (ctx.NodesInfo[nth.Cast().Tuple().Raw()].IsImmediate) {
-            ctx.NodesInfo[node.Raw()].IsImmediate = true;
-        }
-    }
-
-    if (auto member = node.Maybe<TCoMember>()) {
-        if (ctx.NodesInfo[member.Cast().Struct().Raw()].IsImmediate) {
-            ctx.NodesInfo[node.Raw()].IsImmediate = true;
-        }
-    }
-}
-
-void EnsureNodesSafety(TExprBase node, TAnalyzeTxContext& ctx, ECommitSafety commitSafety, bool topLevel) {
-    if (auto updateRow = node.Maybe<TKiUpdateRow>()) {
-        RequireEffectPayloadSafety(updateRow.Cast().Key(), updateRow.Cast().Update(), ctx,
-            topLevel ? commitSafety : ECommitSafety::Full);
-    }
-}
-
-bool EnsureEffectsSafety(TExprBase node, TAnalyzeTxContext& ctx) {
-    bool hasNewRequirements = false;
-
-    VisitExpr(node.Ptr(), [&ctx, &hasNewRequirements] (const TExprNode::TPtr& exprNode) {
-        auto node = TExprBase(exprNode);
-        auto& nodeInfo = ctx.NodesInfo[node.Raw()];
-
-        if (nodeInfo.IsImmediate || nodeInfo.RequireImmediate) {
-            return false;
-        }
-
-        if (node.Maybe<TKiUpdateRow>() || node.Maybe<TKiEraseRow>()) {
-            return false;
-        }
-
-        if (node.Maybe<TKiSelectRow>() || node.Maybe<TKiSelectRange>()) {
-            hasNewRequirements = true;
-            RequireImmediate(node, ctx);
-            return false;
-        }
-
-        return true;
-    });
-
-    return !hasNewRequirements;
-}
-
-void AnalyzeNode(TExprBase node, TAnalyzeTxContext& ctx) {
-    auto& nodeInfo = *ctx.NodesInfo.FindPtr(node.Raw());
-
-    nodeInfo.IsExecutable = true;
-    nodeInfo.AreInputsExecutable = true;
-
-    for (const auto& child : node.Ptr()->Children()) {
-        const auto& childInfo = *ctx.NodesInfo.FindPtr(child.Get());
-
-        bool canExecute = childInfo.IsExecutable;
-        if (canExecute) {
-            if (childInfo.RequireImmediate && !childInfo.IsImmediate) {
-                ctx.ExecutionRoots.emplace_back(TExprBase(child), childInfo.Scope);
-                canExecute = false;
-            }
-        }
-
-        nodeInfo.IsExecutable = nodeInfo.IsExecutable && canExecute;
-
+        if (ctx.NodesInfo[nth.Cast().Tuple().Raw()].IsImmediate) { 
+            ctx.NodesInfo[node.Raw()].IsImmediate = true; 
+        } 
+    } 
+ 
+    if (auto member = node.Maybe<TCoMember>()) { 
+        if (ctx.NodesInfo[member.Cast().Struct().Raw()].IsImmediate) { 
+            ctx.NodesInfo[node.Raw()].IsImmediate = true; 
+        } 
+    } 
+} 
+ 
+void EnsureNodesSafety(TExprBase node, TAnalyzeTxContext& ctx, ECommitSafety commitSafety, bool topLevel) { 
+    if (auto updateRow = node.Maybe<TKiUpdateRow>()) { 
+        RequireEffectPayloadSafety(updateRow.Cast().Key(), updateRow.Cast().Update(), ctx, 
+            topLevel ? commitSafety : ECommitSafety::Full); 
+    } 
+} 
+ 
+bool EnsureEffectsSafety(TExprBase node, TAnalyzeTxContext& ctx) { 
+    bool hasNewRequirements = false; 
+ 
+    VisitExpr(node.Ptr(), [&ctx, &hasNewRequirements] (const TExprNode::TPtr& exprNode) { 
+        auto node = TExprBase(exprNode); 
+        auto& nodeInfo = ctx.NodesInfo[node.Raw()]; 
+ 
+        if (nodeInfo.IsImmediate || nodeInfo.RequireImmediate) { 
+            return false; 
+        } 
+ 
+        if (node.Maybe<TKiUpdateRow>() || node.Maybe<TKiEraseRow>()) { 
+            return false; 
+        } 
+ 
+        if (node.Maybe<TKiSelectRow>() || node.Maybe<TKiSelectRange>()) { 
+            hasNewRequirements = true; 
+            RequireImmediate(node, ctx); 
+            return false; 
+        } 
+ 
+        return true; 
+    }); 
+ 
+    return !hasNewRequirements; 
+} 
+ 
+void AnalyzeNode(TExprBase node, TAnalyzeTxContext& ctx) { 
+    auto& nodeInfo = *ctx.NodesInfo.FindPtr(node.Raw()); 
+ 
+    nodeInfo.IsExecutable = true; 
+    nodeInfo.AreInputsExecutable = true; 
+ 
+    for (const auto& child : node.Ptr()->Children()) { 
+        const auto& childInfo = *ctx.NodesInfo.FindPtr(child.Get()); 
+ 
+        bool canExecute = childInfo.IsExecutable; 
+        if (canExecute) { 
+            if (childInfo.RequireImmediate && !childInfo.IsImmediate) { 
+                ctx.ExecutionRoots.emplace_back(TExprBase(child), childInfo.Scope); 
+                canExecute = false; 
+            } 
+        } 
+ 
+        nodeInfo.IsExecutable = nodeInfo.IsExecutable && canExecute; 
+ 
         if (!TMaybeNode<TCoLambda>(child)) {
-            nodeInfo.AreInputsExecutable = nodeInfo.AreInputsExecutable && canExecute;
-        }
-
-        if (!nodeInfo.IsExecutable && !nodeInfo.AreInputsExecutable) {
-            break;
-        }
-    }
-}
-
-void AnalyzeNodes(const TVector<TExprBase>& nodes, TAnalyzeTxContext& ctx) {
-    YQL_ENSURE(ctx.ExecutionRoots.empty());
-
-    for (auto& node : nodes) {
-        AnalyzeNode(node, ctx);
-    }
-}
-
-bool Analyze(const TExprNode::TPtr& exprRoot, TKqpAnalyzeResults& results, ECommitSafety commitSafety) {
-    TAnalyzeTxContext analyzeCtx;
+            nodeInfo.AreInputsExecutable = nodeInfo.AreInputsExecutable && canExecute; 
+        } 
+ 
+        if (!nodeInfo.IsExecutable && !nodeInfo.AreInputsExecutable) { 
+            break; 
+        } 
+    } 
+} 
+ 
+void AnalyzeNodes(const TVector<TExprBase>& nodes, TAnalyzeTxContext& ctx) { 
+    YQL_ENSURE(ctx.ExecutionRoots.empty()); 
+ 
+    for (auto& node : nodes) { 
+        AnalyzeNode(node, ctx); 
+    } 
+} 
+ 
+bool Analyze(const TExprNode::TPtr& exprRoot, TKqpAnalyzeResults& results, ECommitSafety commitSafety) { 
+    TAnalyzeTxContext analyzeCtx; 
     TVector<TExprBase> nodes;
-
-    GatherNodeScopes(TExprBase(exprRoot), analyzeCtx);
-
-    VisitExpr(exprRoot,
-        [&analyzeCtx] (const TExprNode::TPtr& exprNode) {
-            auto node = TExprBase(exprNode);
-
-            MarkImmediateNodes(node, analyzeCtx);
-            MarkRequireImmediateNodes(node, analyzeCtx);
-            return true;
-        },
-        [&analyzeCtx, &nodes, commitSafety] (const TExprNode::TPtr& exprNode) {
-            auto node = TExprBase(exprNode);
-            auto scope = analyzeCtx.NodesInfo[exprNode.Get()].Scope;
-
-            PropagateImmediateNodes(node, analyzeCtx);
-            EnsureNodesSafety(node, analyzeCtx, commitSafety, !scope);
-
-            nodes.push_back(node);
-            return true;
-        });
-
-    AnalyzeNodes(nodes, analyzeCtx);
-
-    auto& rootInfo = analyzeCtx.NodesInfo[exprRoot.Get()];
-
-    if (rootInfo.IsExecutable) {
-        if (!EnsureEffectsSafety(TKiProgram(exprRoot).Effects(), analyzeCtx)) {
-            AnalyzeNodes(nodes, analyzeCtx);
-        }
-    }
-
-    results.CanExecute = rootInfo.IsExecutable;
-    results.ExprToNodeInfoMap = std::move(analyzeCtx.NodesInfo);
-
-    results.ExecutionRoots.clear();
-    results.CallableToExecRootsMap.clear();
-    results.LambdaToExecRootsMap.clear();
-    for (auto& execRoot : analyzeCtx.ExecutionRoots) {
-        if (execRoot.Scope) {
-            auto callableInfo = results.ExprToNodeInfoMap.FindPtr(execRoot.Scope->Callable.Raw());
-            YQL_ENSURE(callableInfo);
-
-            if (!callableInfo->AreInputsExecutable) {
-                continue;
-            }
-
-            results.LambdaToExecRootsMap[execRoot.Scope->Lambda.Raw()].push_back(execRoot.Node);
-            results.CallableToExecRootsMap[execRoot.Scope->Callable.Raw()].push_back(execRoot.Node);
-        }
-
-        results.ExecutionRoots.push_back(execRoot);
-    }
-
-    YQL_ENSURE(results.CanExecute || !results.ExecutionRoots.empty());
-
-    return true;
-}
-
-class TKqpAnalyzeTransformer : public TSyncTransformerBase {
-public:
-    TKqpAnalyzeTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : TransformCtx(transformCtx) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        Y_UNUSED(ctx);
+ 
+    GatherNodeScopes(TExprBase(exprRoot), analyzeCtx); 
+ 
+    VisitExpr(exprRoot, 
+        [&analyzeCtx] (const TExprNode::TPtr& exprNode) { 
+            auto node = TExprBase(exprNode); 
+ 
+            MarkImmediateNodes(node, analyzeCtx); 
+            MarkRequireImmediateNodes(node, analyzeCtx); 
+            return true; 
+        }, 
+        [&analyzeCtx, &nodes, commitSafety] (const TExprNode::TPtr& exprNode) { 
+            auto node = TExprBase(exprNode); 
+            auto scope = analyzeCtx.NodesInfo[exprNode.Get()].Scope; 
+ 
+            PropagateImmediateNodes(node, analyzeCtx); 
+            EnsureNodesSafety(node, analyzeCtx, commitSafety, !scope); 
+ 
+            nodes.push_back(node); 
+            return true; 
+        }); 
+ 
+    AnalyzeNodes(nodes, analyzeCtx); 
+ 
+    auto& rootInfo = analyzeCtx.NodesInfo[exprRoot.Get()]; 
+ 
+    if (rootInfo.IsExecutable) { 
+        if (!EnsureEffectsSafety(TKiProgram(exprRoot).Effects(), analyzeCtx)) { 
+            AnalyzeNodes(nodes, analyzeCtx); 
+        } 
+    } 
+ 
+    results.CanExecute = rootInfo.IsExecutable; 
+    results.ExprToNodeInfoMap = std::move(analyzeCtx.NodesInfo); 
+ 
+    results.ExecutionRoots.clear(); 
+    results.CallableToExecRootsMap.clear(); 
+    results.LambdaToExecRootsMap.clear(); 
+    for (auto& execRoot : analyzeCtx.ExecutionRoots) { 
+        if (execRoot.Scope) { 
+            auto callableInfo = results.ExprToNodeInfoMap.FindPtr(execRoot.Scope->Callable.Raw()); 
+            YQL_ENSURE(callableInfo); 
+ 
+            if (!callableInfo->AreInputsExecutable) { 
+                continue; 
+            } 
+ 
+            results.LambdaToExecRootsMap[execRoot.Scope->Lambda.Raw()].push_back(execRoot.Node); 
+            results.CallableToExecRootsMap[execRoot.Scope->Callable.Raw()].push_back(execRoot.Node); 
+        } 
+ 
+        results.ExecutionRoots.push_back(execRoot); 
+    } 
+ 
+    YQL_ENSURE(results.CanExecute || !results.ExecutionRoots.empty()); 
+ 
+    return true; 
+} 
+ 
+class TKqpAnalyzeTransformer : public TSyncTransformerBase { 
+public: 
+    TKqpAnalyzeTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : TransformCtx(transformCtx) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        Y_UNUSED(ctx); 
         output = input;
-
-        auto commitSafety = TransformCtx->CommitSafety();
-        if (!TransformCtx->Config->HasAllowKqpUnsafeCommit()) {
-            switch (commitSafety) {
-                case ECommitSafety::Full:
-                case ECommitSafety::Safe:
-                    break;
-                default:
-                    ctx.AddError(YqlIssue(ctx.GetPosition(input->Pos()), TIssuesIds::KIKIMR_BAD_OPERATION,
-                        "Unsafe commits not allowed for current database."));
-                    return TStatus::Error;
-            }
-        }
-
-        if (!Analyze(input.Get(), TransformCtx->AnalyzeResults, commitSafety)) {
-            return TStatus::Error;
-        }
-
-        YQL_CLOG(DEBUG, ProviderKqp) << "Analyze results:" << Endl
-            << "CanExecute: " << TransformCtx->AnalyzeResults.CanExecute << Endl
-            << "ExecutionRoots: " << TransformCtx->AnalyzeResults.ExecutionRoots.size();
-        return TStatus::Ok;
-    }
-
-private:
-    TIntrusivePtr<TKqlTransformContext> TransformCtx;
-};
-
-} // namespace
-
-TAutoPtr<IGraphTransformer> CreateKqpAnalyzeTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx) {
-    return new TKqpAnalyzeTransformer(transformCtx);
-}
-
+ 
+        auto commitSafety = TransformCtx->CommitSafety(); 
+        if (!TransformCtx->Config->HasAllowKqpUnsafeCommit()) { 
+            switch (commitSafety) { 
+                case ECommitSafety::Full: 
+                case ECommitSafety::Safe: 
+                    break; 
+                default: 
+                    ctx.AddError(YqlIssue(ctx.GetPosition(input->Pos()), TIssuesIds::KIKIMR_BAD_OPERATION, 
+                        "Unsafe commits not allowed for current database.")); 
+                    return TStatus::Error; 
+            } 
+        } 
+ 
+        if (!Analyze(input.Get(), TransformCtx->AnalyzeResults, commitSafety)) { 
+            return TStatus::Error; 
+        } 
+ 
+        YQL_CLOG(DEBUG, ProviderKqp) << "Analyze results:" << Endl 
+            << "CanExecute: " << TransformCtx->AnalyzeResults.CanExecute << Endl 
+            << "ExecutionRoots: " << TransformCtx->AnalyzeResults.ExecutionRoots.size(); 
+        return TStatus::Ok; 
+    } 
+ 
+private: 
+    TIntrusivePtr<TKqlTransformContext> TransformCtx; 
+}; 
+ 
+} // namespace 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpAnalyzeTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx) { 
+    return new TKqpAnalyzeTransformer(transformCtx); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/kqp_query_exec.cpp b/ydb/core/kqp/prepare/kqp_query_exec.cpp
index bc2d4e94ce..b9dc19cc05 100644
--- a/ydb/core/kqp/prepare/kqp_query_exec.cpp
+++ b/ydb/core/kqp/prepare/kqp_query_exec.cpp
@@ -1,402 +1,402 @@
-#include "kqp_prepare_impl.h"
-
+#include "kqp_prepare_impl.h" 
+ 
 #include <ydb/core/engine/mkql_engine_flat.h>
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
 #include <ydb/core/tx/datashard/sys_tables.h>
-
+ 
 #include <ydb/library/yql/utils/log/log.h>
-
+ 
 #include <google/protobuf/text_format.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-using namespace NYql::NCommon;
-using namespace NThreading;
-
-namespace {
-
-struct TTransformState {
-    TTransformState(TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : ParamsState(txState->Tx().ParamsState)
-        , TransformCtx(transformCtx) {}
-
-    TIntrusivePtr<TKqpTransactionContext::TParamsState> ParamsState;
-    TIntrusivePtr<TKqlTransformContext> TransformCtx;
-};
-
-struct TParamBinding {
-    TString Name;
-    TMaybe<ui32> ResultIndex;
-
-    TParamBinding(const TString& name, TMaybe<ui32> resultIndex = {})
-        : Name(name)
-        , ResultIndex(resultIndex) {}
-};
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+using namespace NYql::NCommon; 
+using namespace NThreading; 
+ 
+namespace { 
+ 
+struct TTransformState { 
+    TTransformState(TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : ParamsState(txState->Tx().ParamsState) 
+        , TransformCtx(transformCtx) {} 
+ 
+    TIntrusivePtr<TKqpTransactionContext::TParamsState> ParamsState; 
+    TIntrusivePtr<TKqlTransformContext> TransformCtx; 
+}; 
+ 
+struct TParamBinding { 
+    TString Name; 
+    TMaybe<ui32> ResultIndex; 
+ 
+    TParamBinding(const TString& name, TMaybe<ui32> resultIndex = {}) 
+        : Name(name) 
+        , ResultIndex(resultIndex) {} 
+}; 
+ 
 NKikimrKqp::TParameterBinding GetParameterBinding(TCoParameter param) {
-    auto name = TString(param.Name().Value());
-
-    NKikimrKqp::TParameterBinding binding;
-    binding.SetName(name);
-    if (param.Ref().HasResult()) {
+    auto name = TString(param.Name().Value()); 
+ 
+    NKikimrKqp::TParameterBinding binding; 
+    binding.SetName(name); 
+    if (param.Ref().HasResult()) { 
         auto indexTuple = TCoAtomList(TExprNode::GetResult(param.Ptr()));
-        ui32 mkqlIndex = FromString<ui32>(indexTuple.Item(0).Value());
-        ui32 resultIndex = FromString<ui32>(indexTuple.Item(1).Value());
-        binding.SetMkqlIndex(mkqlIndex);
-        binding.SetResultIndex(resultIndex);
-    }
-
-    return binding;
-}
-
+        ui32 mkqlIndex = FromString<ui32>(indexTuple.Item(0).Value()); 
+        ui32 resultIndex = FromString<ui32>(indexTuple.Item(1).Value()); 
+        binding.SetMkqlIndex(mkqlIndex); 
+        binding.SetResultIndex(resultIndex); 
+    } 
+ 
+    return binding; 
+} 
+ 
 NDq::TMkqlValueRef GetParamFromResult(const NKikimrKqp::TParameterBinding& binding,
-    const TKqlTransformContext& transformCtx)
-{
-    YQL_ENSURE(binding.HasMkqlIndex());
-    YQL_ENSURE(binding.HasResultIndex());
-    YQL_ENSURE(binding.GetMkqlIndex() < transformCtx.MkqlResults.size());
-
-    const NKikimrMiniKQL::TType* type;
-    const NKikimrMiniKQL::TValue* value;
-    GetKikimrUnpackedRunResult(*transformCtx.MkqlResults[binding.GetMkqlIndex()], binding.GetResultIndex(),
-        type, value);
-    YQL_ENSURE(type);
-    YQL_ENSURE(value);
-
+    const TKqlTransformContext& transformCtx) 
+{ 
+    YQL_ENSURE(binding.HasMkqlIndex()); 
+    YQL_ENSURE(binding.HasResultIndex()); 
+    YQL_ENSURE(binding.GetMkqlIndex() < transformCtx.MkqlResults.size()); 
+ 
+    const NKikimrMiniKQL::TType* type; 
+    const NKikimrMiniKQL::TValue* value; 
+    GetKikimrUnpackedRunResult(*transformCtx.MkqlResults[binding.GetMkqlIndex()], binding.GetResultIndex(), 
+        type, value); 
+    YQL_ENSURE(type); 
+    YQL_ENSURE(value); 
+ 
     return NDq::TMkqlValueRef(*type, *value);
-}
-
-NKikimrMiniKQL::TParams BuildParamFromResult(const NKikimrKqp::TParameterBinding& binding,
-    const TKqlTransformContext& transformCtx)
-{
-    auto valueRef = GetParamFromResult(binding, transformCtx);
-
-    NKikimrMiniKQL::TParams param;
-    param.MutableType()->CopyFrom(valueRef.GetType());
-    param.MutableValue()->CopyFrom(valueRef.GetValue());
-    return param;
-}
-
-bool GetPredicateValue(const TKiConditionalEffect& effect, const TKqlTransformContext& transformCtx,
-    const THashMap<TString, NKikimrKqp::TParameterBinding>& bindingsMap)
-{
+} 
+ 
+NKikimrMiniKQL::TParams BuildParamFromResult(const NKikimrKqp::TParameterBinding& binding, 
+    const TKqlTransformContext& transformCtx) 
+{ 
+    auto valueRef = GetParamFromResult(binding, transformCtx); 
+ 
+    NKikimrMiniKQL::TParams param; 
+    param.MutableType()->CopyFrom(valueRef.GetType()); 
+    param.MutableValue()->CopyFrom(valueRef.GetValue()); 
+    return param; 
+} 
+ 
+bool GetPredicateValue(const TKiConditionalEffect& effect, const TKqlTransformContext& transformCtx, 
+    const THashMap<TString, NKikimrKqp::TParameterBinding>& bindingsMap) 
+{ 
     YQL_ENSURE(effect.Predicate().Maybe<TCoParameter>());
     auto paramName = effect.Predicate().Cast<TCoParameter>().Name().Value();
-
-    auto binding = bindingsMap.FindPtr(paramName);
-    YQL_ENSURE(binding);
-    YQL_ENSURE(binding->HasMkqlIndex());
-
-    auto paramValue = GetParamFromResult(*binding, transformCtx);
-    YQL_ENSURE(paramValue.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::Data);
-    YQL_ENSURE(paramValue.GetType().GetData().GetScheme() == NKikimr::NScheme::NTypeIds::Bool);
-    return paramValue.GetValue().GetBool();
-}
-
-bool ProcessEffect(TExprBase& effect, const THashMap<TString, NKikimrKqp::TParameterBinding>& bindingsMap,
-    const TKqlTransformContext& transformCtx, TExprContext& ctx)
-{
+ 
+    auto binding = bindingsMap.FindPtr(paramName); 
+    YQL_ENSURE(binding); 
+    YQL_ENSURE(binding->HasMkqlIndex()); 
+ 
+    auto paramValue = GetParamFromResult(*binding, transformCtx); 
+    YQL_ENSURE(paramValue.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::Data); 
+    YQL_ENSURE(paramValue.GetType().GetData().GetScheme() == NKikimr::NScheme::NTypeIds::Bool); 
+    return paramValue.GetValue().GetBool(); 
+} 
+ 
+bool ProcessEffect(TExprBase& effect, const THashMap<TString, NKikimrKqp::TParameterBinding>& bindingsMap, 
+    const TKqlTransformContext& transformCtx, TExprContext& ctx) 
+{ 
     TOptimizeExprSettings optSettings(nullptr);
-    optSettings.VisitChanges = true;
-    TExprNode::TPtr output;
-    auto status = OptimizeExpr(effect.Ptr(), output,
-        [&bindingsMap, &transformCtx](const TExprNode::TPtr& input, TExprContext& ctx) {
-            TExprBase node(input);
-
-            if (auto maybeRevert = node.Maybe<TKiRevertIf>()) {
-                auto revert = maybeRevert.Cast();
-                auto predicateValue = GetPredicateValue(revert, transformCtx, bindingsMap);
-
-                if (predicateValue) {
+    optSettings.VisitChanges = true; 
+    TExprNode::TPtr output; 
+    auto status = OptimizeExpr(effect.Ptr(), output, 
+        [&bindingsMap, &transformCtx](const TExprNode::TPtr& input, TExprContext& ctx) { 
+            TExprBase node(input); 
+ 
+            if (auto maybeRevert = node.Maybe<TKiRevertIf>()) { 
+                auto revert = maybeRevert.Cast(); 
+                auto predicateValue = GetPredicateValue(revert, transformCtx, bindingsMap); 
+ 
+                if (predicateValue) { 
                     ctx.AddWarning(YqlIssue(ctx.GetPosition(revert.Pos()), TIssuesIds::KIKIMR_OPERATION_REVERTED, TStringBuilder()
-                        << "Operation reverted due to constraint violation: " << revert.Constraint().Value()));
-
-                    return GetEmptyEffectsList(revert.Pos(), ctx).Ptr();
-                }
-
-                return revert.Effect().Ptr();
-            }
-
-            if (auto maybeAbort = node.Maybe<TKiAbortIf>()) {
-                auto abort = maybeAbort.Cast();
-                auto predicateValue = GetPredicateValue(abort, transformCtx, bindingsMap);
-
-                if (predicateValue) {
+                        << "Operation reverted due to constraint violation: " << revert.Constraint().Value())); 
+ 
+                    return GetEmptyEffectsList(revert.Pos(), ctx).Ptr(); 
+                } 
+ 
+                return revert.Effect().Ptr(); 
+            } 
+ 
+            if (auto maybeAbort = node.Maybe<TKiAbortIf>()) { 
+                auto abort = maybeAbort.Cast(); 
+                auto predicateValue = GetPredicateValue(abort, transformCtx, bindingsMap); 
+ 
+                if (predicateValue) { 
                     ctx.AddError(YqlIssue(ctx.GetPosition(abort.Pos()), TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION, TStringBuilder()
-                        << "Operation aborted due to constraint violation: " << abort.Constraint().Value()));
-
-                    return TExprNode::TPtr();
-                }
-
-                return abort.Effect().Ptr();
-            }
-
-            return input;
-        }, ctx, optSettings);
-
-    if (status == IGraphTransformer::TStatus::Ok) {
-        effect = TExprBase(output);
-        return true;
-    }
-
-    YQL_ENSURE(status == IGraphTransformer::TStatus::Error);
-    return false;
-}
-
-NNodes::TExprBase PreserveParams(NNodes::TExprBase node,
-    const THashMap<TString, NKikimrKqp::TParameterBinding>& bindingsMap, TExprContext& ctx,
-    TKqpTransactionState& txState, const TKqlTransformContext& transformCtx, bool preserveValues)
-{
-    TNodeOnNodeOwnedMap replaceMap;
-    THashMap<TString, TExprBase> resultsMap;
-    VisitExpr(node.Ptr(), [&replaceMap, &resultsMap, &ctx, &bindingsMap, &txState, &transformCtx, preserveValues] (const TExprNode::TPtr& node) {
-        if (auto maybeParam = TMaybeNode<TCoParameter>(node)) {
-            auto param = maybeParam.Cast();
-            auto name = TString(param.Name().Value());
-
-            auto bindingPtr = bindingsMap.FindPtr(name);
-            YQL_ENSURE(bindingPtr);
-
-            auto& binding = *bindingPtr;
-
-            TMaybe<NKikimrMiniKQL::TParams> paramValue;
-            TMaybeNode<TExprBase> resultNode;
-            if (preserveValues) {
-                if (binding.HasMkqlIndex()) {
-                    paramValue = BuildParamFromResult(binding, transformCtx);
-                } else {
-                    if (!txState.Tx().ParamsState->Values.contains(binding.GetName())) {
-                        auto clientParam = transformCtx.QueryCtx->Parameters.FindPtr(binding.GetName());
-                        YQL_ENSURE(clientParam);
-                        paramValue = *clientParam;
-                    }
-                }
-            } else {
-                if (!param.Ref().HasResult() && binding.HasMkqlIndex()) {
-                    resultNode = Build<TCoAtomList>(ctx, param.Pos())
-                        .Add().Build(ToString(binding.GetMkqlIndex()))
-                        .Add().Build(ToString(binding.GetResultIndex()))
-                        .Done();
-                }
-            }
-
-            if (!paramValue && !resultNode) {
-                return true;
-            }
-
-            auto newParamName = txState.Tx().NewParamName();
-
-            auto newParamNode = Build<TCoParameter>(ctx, node->Pos())
-                .Name().Build(newParamName)
-                .Type(param.Type())
-                .Done();
-
-            replaceMap.emplace(node.Get(), newParamNode.Ptr());
-
-            if (paramValue) {
-                YQL_ENSURE(txState.Tx().ParamsState->Values.emplace(std::make_pair(newParamName, *paramValue)).second);
-            }
-
-            if (resultNode) {
-                YQL_ENSURE(resultsMap.emplace(std::make_pair(newParamName, resultNode.Cast())).second);
-            }
-        }
-
-        return true;
-    });
-
+                        << "Operation aborted due to constraint violation: " << abort.Constraint().Value())); 
+ 
+                    return TExprNode::TPtr(); 
+                } 
+ 
+                return abort.Effect().Ptr(); 
+            } 
+ 
+            return input; 
+        }, ctx, optSettings); 
+ 
+    if (status == IGraphTransformer::TStatus::Ok) { 
+        effect = TExprBase(output); 
+        return true; 
+    } 
+ 
+    YQL_ENSURE(status == IGraphTransformer::TStatus::Error); 
+    return false; 
+} 
+ 
+NNodes::TExprBase PreserveParams(NNodes::TExprBase node, 
+    const THashMap<TString, NKikimrKqp::TParameterBinding>& bindingsMap, TExprContext& ctx, 
+    TKqpTransactionState& txState, const TKqlTransformContext& transformCtx, bool preserveValues) 
+{ 
+    TNodeOnNodeOwnedMap replaceMap; 
+    THashMap<TString, TExprBase> resultsMap; 
+    VisitExpr(node.Ptr(), [&replaceMap, &resultsMap, &ctx, &bindingsMap, &txState, &transformCtx, preserveValues] (const TExprNode::TPtr& node) { 
+        if (auto maybeParam = TMaybeNode<TCoParameter>(node)) { 
+            auto param = maybeParam.Cast(); 
+            auto name = TString(param.Name().Value()); 
+ 
+            auto bindingPtr = bindingsMap.FindPtr(name); 
+            YQL_ENSURE(bindingPtr); 
+ 
+            auto& binding = *bindingPtr; 
+ 
+            TMaybe<NKikimrMiniKQL::TParams> paramValue; 
+            TMaybeNode<TExprBase> resultNode; 
+            if (preserveValues) { 
+                if (binding.HasMkqlIndex()) { 
+                    paramValue = BuildParamFromResult(binding, transformCtx); 
+                } else { 
+                    if (!txState.Tx().ParamsState->Values.contains(binding.GetName())) { 
+                        auto clientParam = transformCtx.QueryCtx->Parameters.FindPtr(binding.GetName()); 
+                        YQL_ENSURE(clientParam); 
+                        paramValue = *clientParam; 
+                    } 
+                } 
+            } else { 
+                if (!param.Ref().HasResult() && binding.HasMkqlIndex()) { 
+                    resultNode = Build<TCoAtomList>(ctx, param.Pos()) 
+                        .Add().Build(ToString(binding.GetMkqlIndex())) 
+                        .Add().Build(ToString(binding.GetResultIndex())) 
+                        .Done(); 
+                } 
+            } 
+ 
+            if (!paramValue && !resultNode) { 
+                return true; 
+            } 
+ 
+            auto newParamName = txState.Tx().NewParamName(); 
+ 
+            auto newParamNode = Build<TCoParameter>(ctx, node->Pos()) 
+                .Name().Build(newParamName) 
+                .Type(param.Type()) 
+                .Done(); 
+ 
+            replaceMap.emplace(node.Get(), newParamNode.Ptr()); 
+ 
+            if (paramValue) { 
+                YQL_ENSURE(txState.Tx().ParamsState->Values.emplace(std::make_pair(newParamName, *paramValue)).second); 
+            } 
+ 
+            if (resultNode) { 
+                YQL_ENSURE(resultsMap.emplace(std::make_pair(newParamName, resultNode.Cast())).second); 
+            } 
+        } 
+ 
+        return true; 
+    }); 
+ 
     auto newNode = TExprBase(ctx.ReplaceNodes(node.Ptr(), replaceMap));
-
-    if (!resultsMap.empty()) {
-        VisitExpr(newNode.Ptr(), [&resultsMap] (const TExprNode::TPtr& node) {
-            if (auto maybeParam = TMaybeNode<TCoParameter>(node)) {
-                auto param = maybeParam.Cast();
-                auto name = TString(param.Name().Value());
-
-                auto result = resultsMap.FindPtr(name);
-                if (result) {
-                    param.Ptr()->SetResult(result->Ptr());
-                }
-            }
-
-            return true;
-        });
-    }
-
-    return newNode;
-}
-
-class TKqpExecTransformer : public TGraphTransformerBase {
-public:
-    TKqpExecTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : Gateway(gateway)
-        , Cluster(cluster)
-        , TxState(txState)
-        , TransformCtx(transformCtx) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+ 
+    if (!resultsMap.empty()) { 
+        VisitExpr(newNode.Ptr(), [&resultsMap] (const TExprNode::TPtr& node) { 
+            if (auto maybeParam = TMaybeNode<TCoParameter>(node)) { 
+                auto param = maybeParam.Cast(); 
+                auto name = TString(param.Name().Value()); 
+ 
+                auto result = resultsMap.FindPtr(name); 
+                if (result) { 
+                    param.Ptr()->SetResult(result->Ptr()); 
+                } 
+            } 
+ 
+            return true; 
+        }); 
+    } 
+ 
+    return newNode; 
+} 
+ 
+class TKqpExecTransformer : public TGraphTransformerBase { 
+public: 
+    TKqpExecTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : Gateway(gateway) 
+        , Cluster(cluster) 
+        , TxState(txState) 
+        , TransformCtx(transformCtx) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         output = input;
-
-        const auto& analyzeResults = TransformCtx->AnalyzeResults;
-
+ 
+        const auto& analyzeResults = TransformCtx->AnalyzeResults; 
+ 
         TVector<TExprBase> results;
-        for (auto& root : analyzeResults.ExecutionRoots) {
-            if (root.Scope) {
+        for (auto& root : analyzeResults.ExecutionRoots) { 
+            if (root.Scope) { 
                 ctx.AddError(TIssue(ctx.GetPosition(root.Node.Pos()), TStringBuilder()
-                    << "Unexpected nested execution roots in rewritten program."));
-                return TStatus::Error;
-            }
-
-            results.push_back(TExprBase(root.Node));
-        }
-
-        TMaybeNode<TExprList> resultsNode;
-        if (analyzeResults.CanExecute) {
-            auto kqpProgram = TKiProgram(input);
-
-            if (HasEffects(kqpProgram)) {
-                bool preserveParams = !TransformCtx->Settings.GetCommitTx();
-                if (!AddDeferredEffect(kqpProgram.Effects(), ctx, *TxState, *TransformCtx, preserveParams)) {
-                    return TStatus::Error;
-                }
-            }
-
-            if (!HasResults(kqpProgram)) {
-                TransformCtx->MkqlResults.push_back(nullptr);
-                return TStatus::Ok;
-            }
-
-            if (TransformCtx->Settings.GetCommitTx() && !TransformCtx->QueryCtx->PrepareOnly) {
+                    << "Unexpected nested execution roots in rewritten program.")); 
+                return TStatus::Error; 
+            } 
+ 
+            results.push_back(TExprBase(root.Node)); 
+        } 
+ 
+        TMaybeNode<TExprList> resultsNode; 
+        if (analyzeResults.CanExecute) { 
+            auto kqpProgram = TKiProgram(input); 
+ 
+            if (HasEffects(kqpProgram)) { 
+                bool preserveParams = !TransformCtx->Settings.GetCommitTx(); 
+                if (!AddDeferredEffect(kqpProgram.Effects(), ctx, *TxState, *TransformCtx, preserveParams)) { 
+                    return TStatus::Error; 
+                } 
+            } 
+ 
+            if (!HasResults(kqpProgram)) { 
+                TransformCtx->MkqlResults.push_back(nullptr); 
+                return TStatus::Ok; 
+            } 
+ 
+            if (TransformCtx->Settings.GetCommitTx() && !TransformCtx->QueryCtx->PrepareOnly) { 
                 if (TxState->Tx().DeferredEffects.Empty()) {
-                    // Merge read-only query with commit tx
-                    return TStatus::Ok;
-                }
-            }
-
-            resultsNode = kqpProgram.Results();
-        } else {
-            YQL_ENSURE(!results.empty());
-            resultsNode = Build<TExprList>(ctx, input->Pos())
-                .Add(results)
-                .Done();
-        }
-
-        auto effectsNode = Build<TCoAsList>(ctx, input->Pos())
-            .Add<TCoIf>()
-                .Predicate<TCoParameter>()
-                    .Name().Build(LocksAcquireParamName)
-                    .Type<TCoDataType>()
-                        .Type().Build("Bool")
-                        .Build()
-                    .Build()
-                .ThenValue<TKiAcquireLocks>()
-                    .LockTxId<TCoParameter>()
-                        .Name().Build(LocksTxIdParamName)
-                        .Type<TCoDataType>()
-                            .Type().Build("Uint64")
-                            .Build()
-                        .Build()
-                    .Build()
-                .ElseValue<TCoVoid>()
-                    .Build()
-                .Build()
-            .Done();
-
-        YQL_ENSURE(resultsNode);
-        auto program = Build<TKiProgram>(ctx, input->Pos())
-            .Results(resultsNode.Cast())
-            .Effects(effectsNode)
-            .Done();
-
-        Promise = NewPromise();
-        MkqlExecuteResult = ExecuteMkql(program, Gateway, Cluster, ctx, TxState, TransformCtx, false);
-
-        auto promise = Promise;
-        MkqlExecuteResult.Future.Apply([promise](const TFuture<IKqpGateway::TMkqlResult> future) mutable {
-            YQL_ENSURE(future.HasValue());
-            promise.SetValue();
-        });
-
-        return TStatus::Async;
-    }
-
-    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
-        Y_UNUSED(input);
-        return Promise.GetFuture();
-    }
-
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+                    // Merge read-only query with commit tx 
+                    return TStatus::Ok; 
+                } 
+            } 
+ 
+            resultsNode = kqpProgram.Results(); 
+        } else { 
+            YQL_ENSURE(!results.empty()); 
+            resultsNode = Build<TExprList>(ctx, input->Pos()) 
+                .Add(results) 
+                .Done(); 
+        } 
+ 
+        auto effectsNode = Build<TCoAsList>(ctx, input->Pos()) 
+            .Add<TCoIf>() 
+                .Predicate<TCoParameter>() 
+                    .Name().Build(LocksAcquireParamName) 
+                    .Type<TCoDataType>() 
+                        .Type().Build("Bool") 
+                        .Build() 
+                    .Build() 
+                .ThenValue<TKiAcquireLocks>() 
+                    .LockTxId<TCoParameter>() 
+                        .Name().Build(LocksTxIdParamName) 
+                        .Type<TCoDataType>() 
+                            .Type().Build("Uint64") 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .ElseValue<TCoVoid>() 
+                    .Build() 
+                .Build() 
+            .Done(); 
+ 
+        YQL_ENSURE(resultsNode); 
+        auto program = Build<TKiProgram>(ctx, input->Pos()) 
+            .Results(resultsNode.Cast()) 
+            .Effects(effectsNode) 
+            .Done(); 
+ 
+        Promise = NewPromise(); 
+        MkqlExecuteResult = ExecuteMkql(program, Gateway, Cluster, ctx, TxState, TransformCtx, false); 
+ 
+        auto promise = Promise; 
+        MkqlExecuteResult.Future.Apply([promise](const TFuture<IKqpGateway::TMkqlResult> future) mutable { 
+            YQL_ENSURE(future.HasValue()); 
+            promise.SetValue(); 
+        }); 
+ 
+        return TStatus::Async; 
+    } 
+ 
+    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
+        Y_UNUSED(input); 
+        return Promise.GetFuture(); 
+    } 
+ 
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         output = input;
-
-        NKikimr::NKqp::IKqpGateway::TMkqlResult result(MkqlExecuteResult.Future.ExtractValue());
-
-        result.ReportIssues(ctx.IssueManager);
-        if (!result.Success()) {
-            return TStatus::Error;
-        }
-
-        auto mkqlResult = MakeSimpleShared<NKikimrMiniKQL::TResult>();
-        mkqlResult->Swap(&result.Result);
-
-        TransformCtx->MkqlResults.push_back(mkqlResult);
-
-        if (TransformCtx->QueryCtx->PrepareOnly) {
+ 
+        NKikimr::NKqp::IKqpGateway::TMkqlResult result(MkqlExecuteResult.Future.ExtractValue()); 
+ 
+        result.ReportIssues(ctx.IssueManager); 
+        if (!result.Success()) { 
+            return TStatus::Error; 
+        } 
+ 
+        auto mkqlResult = MakeSimpleShared<NKikimrMiniKQL::TResult>(); 
+        mkqlResult->Swap(&result.Result); 
+ 
+        TransformCtx->MkqlResults.push_back(mkqlResult); 
+ 
+        if (TransformCtx->QueryCtx->PrepareOnly) { 
             YQL_ENSURE(!TransformCtx->GetPreparingKql().GetMkqls().empty());
             auto& mkql = *TransformCtx->GetPreparingKql().MutableMkqls()->rbegin();
-            mkql.SetProgram(result.CompiledProgram);
-            mkql.SetProgramText(MkqlExecuteResult.Program);
-        } else {
-            LogMkqlResult(*mkqlResult, ctx);
-            TransformCtx->AddMkqlStats(MkqlExecuteResult.Program, std::move(result.TxStats));
-
-            if (TxState->Tx().EffectiveIsolationLevel == NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE) {
+            mkql.SetProgram(result.CompiledProgram); 
+            mkql.SetProgramText(MkqlExecuteResult.Program); 
+        } else { 
+            LogMkqlResult(*mkqlResult, ctx); 
+            TransformCtx->AddMkqlStats(MkqlExecuteResult.Program, std::move(result.TxStats)); 
+ 
+            if (TxState->Tx().EffectiveIsolationLevel == NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE) { 
                 if (!UnpackMergeLocks(*mkqlResult, TxState->Tx(), ctx)) {
                     return TStatus::Error;
-                }
-            }
-        }
-
-        if (TransformCtx->AnalyzeResults.CanExecute) {
-            output = Build<TKiProgram>(ctx, input->Pos())
-                .Results()
-                    .Build()
-                .Effects(TKiProgram(input).Effects())
-                .Done()
-                .Ptr();
-        }
-
-        return TStatus::Ok;
-    }
-
-    void Rewind() override {}
-
-private:
-    TIntrusivePtr<IKqpGateway> Gateway;
+                } 
+            } 
+        } 
+ 
+        if (TransformCtx->AnalyzeResults.CanExecute) { 
+            output = Build<TKiProgram>(ctx, input->Pos()) 
+                .Results() 
+                    .Build() 
+                .Effects(TKiProgram(input).Effects()) 
+                .Done() 
+                .Ptr(); 
+        } 
+ 
+        return TStatus::Ok; 
+    } 
+ 
+    void Rewind() override {} 
+ 
+private: 
+    TIntrusivePtr<IKqpGateway> Gateway; 
     TString Cluster;
-    TIntrusivePtr<TKqpTransactionState> TxState;
-    TIntrusivePtr<TKqlTransformContext> TransformCtx;
-    TMkqlExecuteResult MkqlExecuteResult;
-    TPromise<void> Promise;
-};
-
-void ExtractQueryStats(NKqpProto::TKqpStatsQuery& dst, const NKikimrQueryStats::TTxStats& txStats) {
-    auto& dstExec = *dst.AddExecutions();
+    TIntrusivePtr<TKqpTransactionState> TxState; 
+    TIntrusivePtr<TKqlTransformContext> TransformCtx; 
+    TMkqlExecuteResult MkqlExecuteResult; 
+    TPromise<void> Promise; 
+}; 
+ 
+void ExtractQueryStats(NKqpProto::TKqpStatsQuery& dst, const NKikimrQueryStats::TTxStats& txStats) { 
+    auto& dstExec = *dst.AddExecutions(); 
     NKqpProto::TKqpExecutionExtraStats executionExtraStats;
 
     dstExec.SetDurationUs(txStats.GetDurationUs());
     dstExec.SetCpuTimeUs(txStats.GetComputeCpuTimeUsec());
 
     auto& dstComputeTime = *executionExtraStats.MutableComputeCpuTimeUs();
-    dstComputeTime.SetMin(txStats.GetComputeCpuTimeUsec());
-    dstComputeTime.SetMax(txStats.GetComputeCpuTimeUsec());
-    dstComputeTime.SetSum(txStats.GetComputeCpuTimeUsec());
-    dstComputeTime.SetCnt(1);
-
+    dstComputeTime.SetMin(txStats.GetComputeCpuTimeUsec()); 
+    dstComputeTime.SetMax(txStats.GetComputeCpuTimeUsec()); 
+    dstComputeTime.SetSum(txStats.GetComputeCpuTimeUsec()); 
+    dstComputeTime.SetCnt(1); 
+ 
     {
         i64 cnt = 0;
         ui64 minCpu = Max<ui64>();
@@ -430,20 +430,20 @@ void ExtractQueryStats(NKqpProto::TKqpStatsQuery& dst, const NKikimrQueryStats::
         }
     }
 
-    ui32 affectedShards = 0;
-    for (auto& table : txStats.GetTableAccessStats()) {
-        auto& dstTable = *dstExec.AddTables();
-        dstTable.SetTablePath(table.GetTableInfo().GetName());
-        dstTable.SetReadRows(table.GetSelectRow().GetRows() + table.GetSelectRange().GetRows());
-        dstTable.SetReadBytes(table.GetSelectRow().GetBytes() + table.GetSelectRange().GetBytes());
-        dstTable.SetWriteRows(table.GetUpdateRow().GetRows());
-        dstTable.SetWriteBytes(table.GetUpdateRow().GetBytes());
-        dstTable.SetEraseRows(table.GetEraseRow().GetRows());
+    ui32 affectedShards = 0; 
+    for (auto& table : txStats.GetTableAccessStats()) { 
+        auto& dstTable = *dstExec.AddTables(); 
+        dstTable.SetTablePath(table.GetTableInfo().GetName()); 
+        dstTable.SetReadRows(table.GetSelectRow().GetRows() + table.GetSelectRange().GetRows()); 
+        dstTable.SetReadBytes(table.GetSelectRow().GetBytes() + table.GetSelectRange().GetBytes()); 
+        dstTable.SetWriteRows(table.GetUpdateRow().GetRows()); 
+        dstTable.SetWriteBytes(table.GetUpdateRow().GetBytes()); 
+        dstTable.SetEraseRows(table.GetEraseRow().GetRows()); 
         dstTable.SetAffectedPartitions(table.GetShardCount());
-
-        // NOTE: This might be incorrect in case when single shard has several
-        // tables, i.e. collocated tables.
-        affectedShards += table.GetShardCount();
+ 
+        // NOTE: This might be incorrect in case when single shard has several 
+        // tables, i.e. collocated tables. 
+        affectedShards += table.GetShardCount(); 
     }
 
     executionExtraStats.SetAffectedShards(affectedShards);
@@ -451,167 +451,167 @@ void ExtractQueryStats(NKqpProto::TKqpStatsQuery& dst, const NKikimrQueryStats::
     dstExec.MutableExtra()->PackFrom(executionExtraStats);
 }
 
-} // namespace
-
-void TKqlTransformContext::AddMkqlStats(const TString& program, NKikimrQueryStats::TTxStats&& txStats) {
-    Y_UNUSED(program);
-
-    ExtractQueryStats(QueryStats, txStats);
-}
+} // namespace 
+ 
+void TKqlTransformContext::AddMkqlStats(const TString& program, NKikimrQueryStats::TTxStats&& txStats) { 
+    Y_UNUSED(program); 
 
+    ExtractQueryStats(QueryStats, txStats); 
+} 
+ 
 IKqpGateway::TMkqlSettings TKqlTransformContext::GetMkqlSettings(bool hasDataEffects, TInstant now) const {
-    IKqpGateway::TMkqlSettings mkqlSettings;
+    IKqpGateway::TMkqlSettings mkqlSettings; 
     mkqlSettings.LlvmRuntime = false;
-    mkqlSettings.CollectStats = QueryCtx->StatsMode >= EKikimrStatsMode::Basic;
-
-    if (hasDataEffects) {
-        mkqlSettings.PerShardKeysSizeLimitBytes = Config->_CommitPerShardKeysSizeLimitBytes.Get().GetRef();
-    }
-
-    auto& deadlines = QueryCtx->Deadlines;
-    if (deadlines.CancelAt) {
-        mkqlSettings.CancelAfterMs = now < deadlines.CancelAt ? (deadlines.CancelAt - now).MilliSeconds() : 1;
-    }
-    if (deadlines.TimeoutAt) {
-        mkqlSettings.TimeoutMs = now < deadlines.TimeoutAt ? (deadlines.TimeoutAt - now).MilliSeconds() : 1;
-    }
-
-    mkqlSettings.Limits = QueryCtx->Limits.PhaseLimits;
-
-    return mkqlSettings;
-}
-
-TMkqlExecuteResult ExecuteMkql(TKiProgram program, TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-    TExprContext& ctx, TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx,
-    bool hasDataEffects)
-{
-    auto mkqlProgram = TranslateToMkql(program, ctx, TString(ReadTargetParamName));
-    if (!mkqlProgram) {
-        return TMkqlExecuteResult(MakeFuture(ResultFromError<IKqpGateway::TMkqlResult>(
+    mkqlSettings.CollectStats = QueryCtx->StatsMode >= EKikimrStatsMode::Basic; 
+ 
+    if (hasDataEffects) { 
+        mkqlSettings.PerShardKeysSizeLimitBytes = Config->_CommitPerShardKeysSizeLimitBytes.Get().GetRef(); 
+    } 
+ 
+    auto& deadlines = QueryCtx->Deadlines; 
+    if (deadlines.CancelAt) { 
+        mkqlSettings.CancelAfterMs = now < deadlines.CancelAt ? (deadlines.CancelAt - now).MilliSeconds() : 1; 
+    } 
+    if (deadlines.TimeoutAt) { 
+        mkqlSettings.TimeoutMs = now < deadlines.TimeoutAt ? (deadlines.TimeoutAt - now).MilliSeconds() : 1; 
+    } 
+ 
+    mkqlSettings.Limits = QueryCtx->Limits.PhaseLimits; 
+ 
+    return mkqlSettings; 
+} 
+ 
+TMkqlExecuteResult ExecuteMkql(TKiProgram program, TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+    TExprContext& ctx, TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx, 
+    bool hasDataEffects) 
+{ 
+    auto mkqlProgram = TranslateToMkql(program, ctx, TString(ReadTargetParamName)); 
+    if (!mkqlProgram) { 
+        return TMkqlExecuteResult(MakeFuture(ResultFromError<IKqpGateway::TMkqlResult>( 
             "Mkql translation failed.", ctx.GetPosition(program.Pos()))));
-    }
-
+    } 
+ 
     auto mkqlProgramText = NCommon::SerializeExpr(ctx, mkqlProgram.Cast().Ref());
-    TFuture<IKqpGateway::TMkqlResult> future;
-
-    auto paramBindings = CollectParams(mkqlProgram.Cast());
-
-    if (transformCtx->QueryCtx->PrepareOnly) {
-        YQL_CLOG(INFO, ProviderKqp) << "Preparing MiniKQL program:" << Endl << mkqlProgramText;
-
+    TFuture<IKqpGateway::TMkqlResult> future; 
+ 
+    auto paramBindings = CollectParams(mkqlProgram.Cast()); 
+ 
+    if (transformCtx->QueryCtx->PrepareOnly) { 
+        YQL_CLOG(INFO, ProviderKqp) << "Preparing MiniKQL program:" << Endl << mkqlProgramText; 
+ 
         auto& mkql = *transformCtx->GetPreparingKql().AddMkqls();
-        for (auto& binding : paramBindings) {
-            mkql.AddBindings()->CopyFrom(binding);
-        }
-
-        mkql.SetIsPure(!hasDataEffects && IsKqlPureExpr(program));
-
-        future = gateway->PrepareMkql(cluster, mkqlProgramText);
-    } else {
-        YQL_CLOG(INFO, ProviderKqp) << "Executing MiniKQL program:" << Endl << mkqlProgramText;
-
-        bool acquireLocks = *txState->Tx().EffectiveIsolationLevel == NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE
-            && !txState->Tx().Locks.Broken();
-        auto execParams = BuildParamsMap(paramBindings, txState, transformCtx, acquireLocks);
-
-        if (YQL_CLOG_ACTIVE(TRACE, ProviderKqp)) {
-            TStringBuilder paramsTextBuilder;
-            for (auto& pair : execParams.Values) {
-                TString paramText;
-                NProtoBuf::TextFormat::PrintToString(pair.second.GetValue(), &paramText);
-                paramsTextBuilder << pair.first << ": " << paramText << Endl;
-            }
-
-            YQL_CLOG(TRACE, ProviderKqp) << "MiniKQL parameters:" << Endl << paramsTextBuilder;
-        }
-
-        future = gateway->ExecuteMkql(cluster, mkqlProgramText, std::move(execParams),
-            transformCtx->GetMkqlSettings(hasDataEffects, gateway->GetCurrentTime()), txState->Tx().GetSnapshot());
-    }
-
-    return TMkqlExecuteResult(mkqlProgramText, future);
-}
-
-bool AddDeferredEffect(NNodes::TExprBase effect, const TVector<NKikimrKqp::TParameterBinding>& bindings,
-    TExprContext& ctx, TKqpTransactionState& txState, TKqlTransformContext& transformCtx, bool preserveParamValues)
-{
-    if (transformCtx.QueryCtx->PrepareOnly) {
+        for (auto& binding : paramBindings) { 
+            mkql.AddBindings()->CopyFrom(binding); 
+        } 
+ 
+        mkql.SetIsPure(!hasDataEffects && IsKqlPureExpr(program)); 
+ 
+        future = gateway->PrepareMkql(cluster, mkqlProgramText); 
+    } else { 
+        YQL_CLOG(INFO, ProviderKqp) << "Executing MiniKQL program:" << Endl << mkqlProgramText; 
+ 
+        bool acquireLocks = *txState->Tx().EffectiveIsolationLevel == NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE 
+            && !txState->Tx().Locks.Broken(); 
+        auto execParams = BuildParamsMap(paramBindings, txState, transformCtx, acquireLocks); 
+ 
+        if (YQL_CLOG_ACTIVE(TRACE, ProviderKqp)) { 
+            TStringBuilder paramsTextBuilder; 
+            for (auto& pair : execParams.Values) { 
+                TString paramText; 
+                NProtoBuf::TextFormat::PrintToString(pair.second.GetValue(), &paramText); 
+                paramsTextBuilder << pair.first << ": " << paramText << Endl; 
+            } 
+ 
+            YQL_CLOG(TRACE, ProviderKqp) << "MiniKQL parameters:" << Endl << paramsTextBuilder; 
+        } 
+ 
+        future = gateway->ExecuteMkql(cluster, mkqlProgramText, std::move(execParams), 
+            transformCtx->GetMkqlSettings(hasDataEffects, gateway->GetCurrentTime()), txState->Tx().GetSnapshot()); 
+    } 
+ 
+    return TMkqlExecuteResult(mkqlProgramText, future); 
+} 
+ 
+bool AddDeferredEffect(NNodes::TExprBase effect, const TVector<NKikimrKqp::TParameterBinding>& bindings, 
+    TExprContext& ctx, TKqpTransactionState& txState, TKqlTransformContext& transformCtx, bool preserveParamValues) 
+{ 
+    if (transformCtx.QueryCtx->PrepareOnly) { 
         auto& newEffect = *transformCtx.GetPreparingKql().AddEffects();
         newEffect.SetNodeAst(NCommon::SerializeExpr(ctx, effect.Ref()));
-        for (auto& binding : bindings) {
-            newEffect.AddBindings()->CopyFrom(binding);
-        }
-    } else {
+        for (auto& binding : bindings) { 
+            newEffect.AddBindings()->CopyFrom(binding); 
+        } 
+    } else { 
         if (txState.Tx().Locks.Broken()) {
             txState.Tx().Locks.ReportIssues(ctx);
             return false;
         }
-        THashMap<TString, NKikimrKqp::TParameterBinding> bindingsMap;
-        for (auto& binding : bindings) {
-            bindingsMap.emplace(binding.GetName(), binding);
-        }
-
-        if (!ProcessEffect(effect, bindingsMap, transformCtx, ctx)) {
-            return false;
-        }
-
-        effect = PreserveParams(effect, bindingsMap, ctx, txState, transformCtx, preserveParamValues);
-    }
-
+        THashMap<TString, NKikimrKqp::TParameterBinding> bindingsMap; 
+        for (auto& binding : bindings) { 
+            bindingsMap.emplace(binding.GetName(), binding); 
+        } 
+ 
+        if (!ProcessEffect(effect, bindingsMap, transformCtx, ctx)) { 
+            return false; 
+        } 
+ 
+        effect = PreserveParams(effect, bindingsMap, ctx, txState, transformCtx, preserveParamValues); 
+    } 
+ 
     bool added = txState.Tx().AddDeferredEffect(effect);
     YQL_ENSURE(added, "Cannot execute new- and old- execution engine queries in the same transaction");
-
+ 
     YQL_CLOG(INFO, ProviderKqp) << "Adding deferred effect, total " << txState.Tx().DeferredEffects.Size() << ": "
-        << Endl << KqpExprToPrettyString(effect, ctx);
-    return true;
-}
-
-bool AddDeferredEffect(NNodes::TExprBase effect, TExprContext& ctx, TKqpTransactionState& txState,
-    TKqlTransformContext& transformCtx, bool preserveParamValues)
-{
-    return AddDeferredEffect(effect, CollectParams(effect), ctx, txState, transformCtx, preserveParamValues);
-}
-
-TKqpParamsMap BuildParamsMap(const TVector<NKikimrKqp::TParameterBinding>& bindings,
-    TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx, bool acquireLocks)
-{
-    TKqpParamsMap paramsMap(std::make_shared<TTransformState>(txState, transformCtx));
-
-    for (auto& binding : bindings) {
-        auto name = binding.GetName();
-
+        << Endl << KqpExprToPrettyString(effect, ctx); 
+    return true; 
+} 
+ 
+bool AddDeferredEffect(NNodes::TExprBase effect, TExprContext& ctx, TKqpTransactionState& txState, 
+    TKqlTransformContext& transformCtx, bool preserveParamValues) 
+{ 
+    return AddDeferredEffect(effect, CollectParams(effect), ctx, txState, transformCtx, preserveParamValues); 
+} 
+ 
+TKqpParamsMap BuildParamsMap(const TVector<NKikimrKqp::TParameterBinding>& bindings, 
+    TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx, bool acquireLocks) 
+{ 
+    TKqpParamsMap paramsMap(std::make_shared<TTransformState>(txState, transformCtx)); 
+ 
+    for (auto& binding : bindings) { 
+        auto name = binding.GetName(); 
+ 
         TMaybe<NDq::TMkqlValueRef> paramRef;
-        if (binding.GetName() == LocksAcquireParamName) {
-            auto& param = txState->Tx().ParamsState->Values[LocksAcquireParamName];
-            param.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data);
-            param.MutableType()->MutableData()->SetScheme(NKikimr::NUdf::TDataType<bool>::Id);
-            param.MutableValue()->SetBool(acquireLocks);
+        if (binding.GetName() == LocksAcquireParamName) { 
+            auto& param = txState->Tx().ParamsState->Values[LocksAcquireParamName]; 
+            param.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+            param.MutableType()->MutableData()->SetScheme(NKikimr::NUdf::TDataType<bool>::Id); 
+            param.MutableValue()->SetBool(acquireLocks); 
             paramRef = NDq::TMkqlValueRef(param);
-        } else if (binding.GetName() == LocksTxIdParamName) {
-            auto& param = txState->Tx().ParamsState->Values[LocksTxIdParamName];
-            param.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data);
-            param.MutableType()->MutableData()->SetScheme(NKikimr::NUdf::TDataType<ui64>::Id);
-            param.MutableValue()->SetUint64(txState->Tx().Locks.GetLockTxId());
+        } else if (binding.GetName() == LocksTxIdParamName) { 
+            auto& param = txState->Tx().ParamsState->Values[LocksTxIdParamName]; 
+            param.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+            param.MutableType()->MutableData()->SetScheme(NKikimr::NUdf::TDataType<ui64>::Id); 
+            param.MutableValue()->SetUint64(txState->Tx().Locks.GetLockTxId()); 
             paramRef = NDq::TMkqlValueRef(param);
-        } else if (binding.GetName() == ReadTargetParamName) {
-            YQL_ENSURE(txState->Tx().EffectiveIsolationLevel);
-
-            ui32 readTarget = (ui32)NKikimr::TReadTarget::EMode::Online;
-            switch (*txState->Tx().EffectiveIsolationLevel) {
-                case NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED:
-                    readTarget = (ui32)NKikimr::TReadTarget::EMode::Head;
-                    break;
-                case NKikimrKqp::ISOLATION_LEVEL_READ_STALE:
+        } else if (binding.GetName() == ReadTargetParamName) { 
+            YQL_ENSURE(txState->Tx().EffectiveIsolationLevel); 
+ 
+            ui32 readTarget = (ui32)NKikimr::TReadTarget::EMode::Online; 
+            switch (*txState->Tx().EffectiveIsolationLevel) { 
+                case NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED: 
+                    readTarget = (ui32)NKikimr::TReadTarget::EMode::Head; 
+                    break; 
+                case NKikimrKqp::ISOLATION_LEVEL_READ_STALE: 
                     readTarget = (ui32)NKikimr::TReadTarget::EMode::Follower;
-                    break;
-                default:
-                    break;
-            }
-
-            auto& param = txState->Tx().ParamsState->Values[ReadTargetParamName];
-            param.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data);
-            param.MutableType()->MutableData()->SetScheme(NKikimr::NUdf::TDataType<ui32>::Id);
-            param.MutableValue()->SetUint32(readTarget);
+                    break; 
+                default: 
+                    break; 
+            } 
+ 
+            auto& param = txState->Tx().ParamsState->Values[ReadTargetParamName]; 
+            param.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+            param.MutableType()->MutableData()->SetScheme(NKikimr::NUdf::TDataType<ui32>::Id); 
+            param.MutableValue()->SetUint32(readTarget); 
             paramRef = NDq::TMkqlValueRef(param);
         } else if (binding.GetName() == NowParamName) {
             auto& param = txState->Tx().ParamsState->Values[binding.GetName()];
@@ -660,101 +660,101 @@ TKqpParamsMap BuildParamsMap(const TVector<NKikimrKqp::TParameterBinding>& bindi
             auto uuid = transformCtx->QueryCtx->GetCachedRandom<TGUID>();
             param.MutableValue()->SetBytes(uuid.dw, sizeof(TGUID));
             paramRef = NDq::TMkqlValueRef(param);
-        } else if (binding.HasMkqlIndex()) {
-            paramRef = GetParamFromResult(binding, *transformCtx);
-        } else {
-            auto clientParam = transformCtx->QueryCtx->Parameters.FindPtr(binding.GetName());
-            if (clientParam) {
+        } else if (binding.HasMkqlIndex()) { 
+            paramRef = GetParamFromResult(binding, *transformCtx); 
+        } else { 
+            auto clientParam = transformCtx->QueryCtx->Parameters.FindPtr(binding.GetName()); 
+            if (clientParam) { 
                 paramRef = NDq::TMkqlValueRef(*clientParam);
-            } else {
-                auto paramValue = txState->Tx().ParamsState->Values.FindPtr(binding.GetName());
-                YQL_ENSURE(paramValue, "Parameter not found: " << binding.GetName());
-
+            } else { 
+                auto paramValue = txState->Tx().ParamsState->Values.FindPtr(binding.GetName()); 
+                YQL_ENSURE(paramValue, "Parameter not found: " << binding.GetName()); 
+ 
                 paramRef = NDq::TMkqlValueRef(*paramValue);
-            }
-        }
-
-        YQL_ENSURE(paramRef);
-        auto result = paramsMap.Values.emplace(std::make_pair(name, *paramRef));
-        YQL_ENSURE(result.second);
-    }
-
-    return paramsMap;
-}
-
+            } 
+        } 
+ 
+        YQL_ENSURE(paramRef); 
+        auto result = paramsMap.Values.emplace(std::make_pair(name, *paramRef)); 
+        YQL_ENSURE(result.second); 
+    } 
+ 
+    return paramsMap; 
+} 
+ 
 TIssue GetLocksInvalidatedIssue(const TKqpTransactionContext& txCtx, const TMaybe<TKqpTxLock>& invalidatedLock) {
-    TStringBuilder message;
-    message << "Transaction locks invalidated.";
-
-    TMaybe<TString> tableName;
-    if (invalidatedLock) {
-        TKikimrPathId id(invalidatedLock->GetSchemeShard(), invalidatedLock->GetPathId());
+    TStringBuilder message; 
+    message << "Transaction locks invalidated."; 
+ 
+    TMaybe<TString> tableName; 
+    if (invalidatedLock) { 
+        TKikimrPathId id(invalidatedLock->GetSchemeShard(), invalidatedLock->GetPathId()); 
         auto table = txCtx.TableByIdMap.FindPtr(id);
-        if (table) {
-            tableName = *table;
-        }
-    }
-
-    if (tableName) {
-        message << " Table: " << *tableName;
-    }
-
-    return YqlIssue(TPosition(), TIssuesIds::KIKIMR_LOCKS_INVALIDATED, message);
-}
-
+        if (table) { 
+            tableName = *table; 
+        } 
+    } 
+ 
+    if (tableName) { 
+        message << " Table: " << *tableName; 
+    } 
+ 
+    return YqlIssue(TPosition(), TIssuesIds::KIKIMR_LOCKS_INVALIDATED, message); 
+} 
+ 
 std::pair<bool, std::vector<TIssue>> MergeLocks(const NKikimrMiniKQL::TType& type, const NKikimrMiniKQL::TValue& value,
         TKqpTransactionContext& txCtx) {
-
+ 
     std::pair<bool, std::vector<TIssue>> res;
     auto& locks = txCtx.Locks;
 
-    YQL_ENSURE(type.GetKind() == NKikimrMiniKQL::ETypeKind::List);
-    auto locksListType = type.GetList();
-
-    if (!locks.HasLocks()) {
-        locks.LockType = locksListType.GetItem();
-        locks.LocksListType = locksListType;
-    }
-
-    YQL_ENSURE(locksListType.GetItem().GetKind() == NKikimrMiniKQL::ETypeKind::Struct);
-    auto lockType = locksListType.GetItem().GetStruct();
-    YQL_ENSURE(lockType.MemberSize() == 6);
-    YQL_ENSURE(lockType.GetMember(0).GetName() == "Counter");
-    YQL_ENSURE(lockType.GetMember(1).GetName() == "DataShard");
-    YQL_ENSURE(lockType.GetMember(2).GetName() == "Generation");
-    YQL_ENSURE(lockType.GetMember(3).GetName() == "LockId");
-    YQL_ENSURE(lockType.GetMember(4).GetName() == "PathId");
-    YQL_ENSURE(lockType.GetMember(5).GetName() == "SchemeShard");
-
+    YQL_ENSURE(type.GetKind() == NKikimrMiniKQL::ETypeKind::List); 
+    auto locksListType = type.GetList(); 
+ 
+    if (!locks.HasLocks()) { 
+        locks.LockType = locksListType.GetItem(); 
+        locks.LocksListType = locksListType; 
+    } 
+ 
+    YQL_ENSURE(locksListType.GetItem().GetKind() == NKikimrMiniKQL::ETypeKind::Struct); 
+    auto lockType = locksListType.GetItem().GetStruct(); 
+    YQL_ENSURE(lockType.MemberSize() == 6); 
+    YQL_ENSURE(lockType.GetMember(0).GetName() == "Counter"); 
+    YQL_ENSURE(lockType.GetMember(1).GetName() == "DataShard"); 
+    YQL_ENSURE(lockType.GetMember(2).GetName() == "Generation"); 
+    YQL_ENSURE(lockType.GetMember(3).GetName() == "LockId"); 
+    YQL_ENSURE(lockType.GetMember(4).GetName() == "PathId"); 
+    YQL_ENSURE(lockType.GetMember(5).GetName() == "SchemeShard"); 
+ 
     res.first = true;
     for (auto& lockValue : value.GetList()) {
         TKqpTxLock txLock(lockValue);
         if (auto counter = txLock.GetCounter(); counter >= NKikimr::TSysTables::TLocksTable::TLock::ErrorMin) {
-            switch (counter) {
+            switch (counter) { 
                 case NKikimr::TSysTables::TLocksTable::TLock::ErrorAlreadyBroken:
-                case NKikimr::TSysTables::TLocksTable::TLock::ErrorBroken:
+                case NKikimr::TSysTables::TLocksTable::TLock::ErrorBroken: 
                     res.second.emplace_back(GetLocksInvalidatedIssue(txCtx, txLock));
-                    break;
-                default:
+                    break; 
+                default: 
                     res.second.emplace_back(YqlIssue(TPosition(), TIssuesIds::KIKIMR_LOCKS_ACQUIRE_FAILURE));
-                    break;
-            }
+                    break; 
+            } 
             res.first = false;
-
+ 
         } else if (auto curTxLock = locks.LocksMap.FindPtr(txLock.GetKey())) {
-            if (curTxLock->Invalidated(txLock)) {
+            if (curTxLock->Invalidated(txLock)) { 
                 res.second.emplace_back(GetLocksInvalidatedIssue(txCtx, txLock));
                 res.first = false;
-            }
-        } else {
+            } 
+        } else { 
             // despite there were some errors we need to proceed merge to erase remaining locks properly
-            locks.LocksMap.insert(std::make_pair(txLock.GetKey(), txLock));
-        }
-    }
-
+            locks.LocksMap.insert(std::make_pair(txLock.GetKey(), txLock)); 
+        } 
+    } 
+ 
     return res;
-}
-
+} 
+ 
 bool MergeLocks(const NKikimrMiniKQL::TType& type, const NKikimrMiniKQL::TValue& value, TKqpTransactionContext& txCtx,
         TExprContext& ctx) {
     auto [success, issues] = MergeLocks(type, value, txCtx);
@@ -776,69 +776,69 @@ bool MergeLocks(const NKikimrMiniKQL::TType& type, const NKikimrMiniKQL::TValue&
 }
 
 bool UnpackMergeLocks(const NKikimrMiniKQL::TResult& result, TKqpTransactionContext& txCtx, TExprContext& ctx) {
-    auto structType = result.GetType().GetStruct();
-    ui32 locksIndex;
+    auto structType = result.GetType().GetStruct(); 
+    ui32 locksIndex; 
     bool found = GetRunResultIndex(structType, TString(NKikimr::NMiniKQL::TxLocksResultLabel2), locksIndex);
     YQL_ENSURE(found ^ txCtx.Locks.Broken());
-
+ 
     if (found) {
         auto locksType = structType.GetMember(locksIndex).GetType().GetOptional().GetItem();
         auto locksValue = result.GetValue().GetStruct(locksIndex).GetOptional();
-
+ 
         return MergeLocks(locksType, locksValue, txCtx, ctx);
     }
 
     return false;
-}
-
-void LogMkqlResult(const NKikimrMiniKQL::TResult& result, TExprContext& ctx) {
-    Y_UNUSED(ctx);
-
-    if (YQL_CLOG_ACTIVE(TRACE, ProviderKqp)) {
+} 
+ 
+void LogMkqlResult(const NKikimrMiniKQL::TResult& result, TExprContext& ctx) { 
+    Y_UNUSED(ctx); 
+ 
+    if (YQL_CLOG_ACTIVE(TRACE, ProviderKqp)) { 
         TString resultType;
         TString resultValue;
-
-        NProtoBuf::TextFormat::PrintToString(result.GetType(), &resultType);
-        NProtoBuf::TextFormat::PrintToString(result.GetValue(), &resultValue);
-
-        YQL_CLOG(TRACE, ProviderKqp) << "MiniKQL results\n"
+ 
+        NProtoBuf::TextFormat::PrintToString(result.GetType(), &resultType); 
+        NProtoBuf::TextFormat::PrintToString(result.GetValue(), &resultValue); 
+ 
+        YQL_CLOG(TRACE, ProviderKqp) << "MiniKQL results\n" 
                 << "Type:\n" << resultType
                 << "Value:\n" << resultValue;
-    }
-}
-
-bool HasEffects(const TKiProgram& program) {
+    } 
+} 
+ 
+bool HasEffects(const TKiProgram& program) { 
     return !program.Effects().Maybe<TCoList>();
-}
-
-bool HasResults(const TKiProgram& program) {
-    return !program.Results().Empty();
-}
-
-TVector<NKikimrKqp::TParameterBinding> CollectParams(TExprBase query) {
-    TSet<TStringBuf> parametersSet;
-    TVector<NKikimrKqp::TParameterBinding> bindings;
-
-    VisitExpr(query.Ptr(), [&bindings, &parametersSet] (const TExprNode::TPtr& node) {
-        if (auto maybeParam = TMaybeNode<TCoParameter>(node)) {
-            auto param = maybeParam.Cast();
-            auto result = parametersSet.insert(param.Name());
-            if (result.second) {
-                bindings.push_back(GetParameterBinding(param));
-            }
-        }
-
-        return true;
-    });
-
-    return bindings;
-}
-
-TAutoPtr<IGraphTransformer> CreateKqpExecTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-    TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx)
-{
-    return new TKqpExecTransformer(gateway, cluster, txState, transformCtx);
-}
-
+} 
+ 
+bool HasResults(const TKiProgram& program) { 
+    return !program.Results().Empty(); 
+} 
+ 
+TVector<NKikimrKqp::TParameterBinding> CollectParams(TExprBase query) { 
+    TSet<TStringBuf> parametersSet; 
+    TVector<NKikimrKqp::TParameterBinding> bindings; 
+ 
+    VisitExpr(query.Ptr(), [&bindings, &parametersSet] (const TExprNode::TPtr& node) { 
+        if (auto maybeParam = TMaybeNode<TCoParameter>(node)) { 
+            auto param = maybeParam.Cast(); 
+            auto result = parametersSet.insert(param.Name()); 
+            if (result.second) { 
+                bindings.push_back(GetParameterBinding(param)); 
+            } 
+        } 
+ 
+        return true; 
+    }); 
+ 
+    return bindings; 
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpExecTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+    TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx) 
+{ 
+    return new TKqpExecTransformer(gateway, cluster, txState, transformCtx); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/kqp_query_finalize.cpp b/ydb/core/kqp/prepare/kqp_query_finalize.cpp
index 5e442780f7..348d1fe0f2 100644
--- a/ydb/core/kqp/prepare/kqp_query_finalize.cpp
+++ b/ydb/core/kqp/prepare/kqp_query_finalize.cpp
@@ -1,501 +1,501 @@
-#include "kqp_prepare_impl.h"
-
+#include "kqp_prepare_impl.h" 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
 #include <ydb/core/tx/datashard/sys_tables.h>
 
 #include <ydb/library/yql/utils/log/log.h>
 #include <ydb/library/yql/core/issue/yql_issue.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NCommon;
-using namespace NYql::NNodes;
-using namespace NThreading;
-
-namespace {
-
-const TStringBuf LocksInvalidatedResultName = "tx_locks_invalidated";
-const TStringBuf LocksInvalidatedListName = "tx_locks_invalidated_list";
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NCommon; 
+using namespace NYql::NNodes; 
+using namespace NThreading; 
+ 
+namespace { 
+ 
+const TStringBuf LocksInvalidatedResultName = "tx_locks_invalidated"; 
+const TStringBuf LocksInvalidatedListName = "tx_locks_invalidated_list"; 
 const TStringBuf LocksTableName = "/sys/locks2";
 const TStringBuf LocksTableVersion = "0";
 const TString LocksTablePathId = TKikimrPathId(TSysTables::SysSchemeShard, TSysTables::SysTableLocks2).ToString();
-const ui64 LocksInvalidatedCount = 1;
-
+const ui64 LocksInvalidatedCount = 1; 
+ 
 TExprBase GetDeferredEffectsList(const TDeferredEffects& effects, TPositionHandle pos, TExprContext& ctx) {
     if (effects.Empty()) {
-        return GetEmptyEffectsList(pos, ctx);
-    }
-
-    TVector<TExprBase> effectNodes;
+        return GetEmptyEffectsList(pos, ctx); 
+    } 
+ 
+    TVector<TExprBase> effectNodes; 
     effectNodes.reserve(effects.Size());
     for (const auto& effect : effects) {
-        YQL_ENSURE(effect.Params.empty());
-        YQL_ENSURE(effect.Node);
-        effectNodes.push_back(effect.Node.Cast());
-    }
-
+        YQL_ENSURE(effect.Params.empty()); 
+        YQL_ENSURE(effect.Node); 
+        effectNodes.push_back(effect.Node.Cast()); 
+    } 
+ 
     return Build<TCoExtend>(ctx, pos)
-        .Add(effectNodes)
-        .Done();
-}
-
+        .Add(effectNodes) 
+        .Done(); 
+} 
+ 
 TExprBase GetEraseLocksEffects(const TString& cluster, TPositionHandle pos, TCoParameter locksList, TExprContext& ctx) {
-    return Build<TKiMapParameter>(ctx, pos)
-        .Input(locksList)
-        .Lambda()
-            .Args({"lockItem"})
-            .Body<TKiEraseRow>()
-                .Cluster().Build(cluster)
+    return Build<TKiMapParameter>(ctx, pos) 
+        .Input(locksList) 
+        .Lambda() 
+            .Args({"lockItem"}) 
+            .Body<TKiEraseRow>() 
+                .Cluster().Build(cluster) 
                 .Table<TKiVersionedTable>()
                     .Path<TCoAtom>().Build(LocksTableName)
                     .SchemaVersion<TCoAtom>().Build(LocksTableVersion)
                     .PathId<TCoAtom>().Build(LocksTablePathId)
                 .Build()
-                .Key()
-                    .Add()
-                        .Name().Build("LockId")
-                        .Value<TCoMember>()
-                            .Struct("lockItem")
-                            .Name().Build("LockId")
-                            .Build()
-                        .Build()
-                    .Add()
-                        .Name().Build("DataShard")
-                        .Value<TCoMember>()
-                            .Struct("lockItem")
-                            .Name().Build("DataShard")
-                            .Build()
-                        .Build()
-                    .Add()
-                        .Name().Build("SchemeShard")
+                .Key() 
+                    .Add() 
+                        .Name().Build("LockId") 
                         .Value<TCoMember>()
-                            .Struct("lockItem")
-                            .Name().Build("SchemeShard")
-                            .Build()
-                        .Build()
-                    .Add()
-                        .Name().Build("PathId")
+                            .Struct("lockItem") 
+                            .Name().Build("LockId") 
+                            .Build() 
+                        .Build() 
+                    .Add() 
+                        .Name().Build("DataShard") 
                         .Value<TCoMember>()
-                            .Struct("lockItem")
-                            .Name().Build("PathId")
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Done();
-}
-
-const TTypeAnnotationNode* GetTxLockListType(TExprContext& ctx) {
+                            .Struct("lockItem") 
+                            .Name().Build("DataShard") 
+                            .Build() 
+                        .Build() 
+                    .Add() 
+                        .Name().Build("SchemeShard") 
+                        .Value<TCoMember>() 
+                            .Struct("lockItem") 
+                            .Name().Build("SchemeShard") 
+                            .Build() 
+                        .Build() 
+                    .Add() 
+                        .Name().Build("PathId") 
+                        .Value<TCoMember>() 
+                            .Struct("lockItem") 
+                            .Name().Build("PathId") 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Done(); 
+} 
+ 
+const TTypeAnnotationNode* GetTxLockListType(TExprContext& ctx) { 
     auto ui32Type = ctx.MakeType<TDataExprType>(EDataSlot::Uint32);
     auto ui64Type = ctx.MakeType<TDataExprType>(EDataSlot::Uint64);
     TVector<const TItemExprType*> lockItems;
     lockItems.reserve(6);
-    lockItems.push_back(ctx.MakeType<TItemExprType>("LockId", ui64Type));
-    lockItems.push_back(ctx.MakeType<TItemExprType>("DataShard", ui64Type));
-    lockItems.push_back(ctx.MakeType<TItemExprType>("SchemeShard", ui64Type));
-    lockItems.push_back(ctx.MakeType<TItemExprType>("PathId", ui64Type));
-    lockItems.push_back(ctx.MakeType<TItemExprType>("Generation", ui32Type));
-    lockItems.push_back(ctx.MakeType<TItemExprType>("Counter", ui64Type));
-    auto lockType = ctx.MakeType<TStructExprType>(lockItems);
-    auto lockListType = ctx.MakeType<TListExprType>(lockType);
-    return lockListType;
-}
-
-class TKqpFinalizeTransformer : public TGraphTransformerBase {
-public:
-    TKqpFinalizeTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : Gateway(gateway)
-        , Cluster(cluster)
-        , TxState(txState)
-        , TransformCtx(transformCtx)
-        , HasProgramResults(false) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    lockItems.push_back(ctx.MakeType<TItemExprType>("LockId", ui64Type)); 
+    lockItems.push_back(ctx.MakeType<TItemExprType>("DataShard", ui64Type)); 
+    lockItems.push_back(ctx.MakeType<TItemExprType>("SchemeShard", ui64Type)); 
+    lockItems.push_back(ctx.MakeType<TItemExprType>("PathId", ui64Type)); 
+    lockItems.push_back(ctx.MakeType<TItemExprType>("Generation", ui32Type)); 
+    lockItems.push_back(ctx.MakeType<TItemExprType>("Counter", ui64Type)); 
+    auto lockType = ctx.MakeType<TStructExprType>(lockItems); 
+    auto lockListType = ctx.MakeType<TListExprType>(lockType); 
+    return lockListType; 
+} 
+ 
+class TKqpFinalizeTransformer : public TGraphTransformerBase { 
+public: 
+    TKqpFinalizeTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+        TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : Gateway(gateway) 
+        , Cluster(cluster) 
+        , TxState(txState) 
+        , TransformCtx(transformCtx) 
+        , HasProgramResults(false) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         output = input;
-
-        YQL_ENSURE(State == EFinalizeState::Initial);
-
-        auto resultsNode = GetResultsNode(TExprBase(input), ctx);
-        TExprBase effectsNode = GetEmptyEffectsList(input->Pos(), ctx);
-
-        auto settings = TransformCtx->Settings;
-
-        if (settings.GetRollbackTx()) {
-            YQL_ENSURE(!settings.GetCommitTx());
-
-            YQL_CLOG(INFO, ProviderKqp) << "Rollback Tx"
+ 
+        YQL_ENSURE(State == EFinalizeState::Initial); 
+ 
+        auto resultsNode = GetResultsNode(TExprBase(input), ctx); 
+        TExprBase effectsNode = GetEmptyEffectsList(input->Pos(), ctx); 
+ 
+        auto settings = TransformCtx->Settings; 
+ 
+        if (settings.GetRollbackTx()) { 
+            YQL_ENSURE(!settings.GetCommitTx()); 
+ 
+            YQL_CLOG(INFO, ProviderKqp) << "Rollback Tx" 
                 << ", deferred effects count: " << TxState->Tx().DeferredEffects.Size()
-                << ", locks count: " << TxState->Tx().Locks.Size();
-
-            effectsNode = GetRollbackEffects(input->Pos(), ctx);
-            State = EFinalizeState::RollbackInProgress;
-        }
-
-        bool hasDataEffects = false;
-        if (settings.GetCommitTx()) {
-            YQL_ENSURE(!settings.GetRollbackTx());
-
-            effectsNode = GetCommitEffects(input->Pos(), ctx, hasDataEffects);
-
-            {
-                if (!CheckCommitEffects(effectsNode, ctx)) {
-                    return RollbackOnError(ctx);
-                }
-
-                if (TxState->Tx().IsInvalidated()) {
+                << ", locks count: " << TxState->Tx().Locks.Size(); 
+
+            effectsNode = GetRollbackEffects(input->Pos(), ctx); 
+            State = EFinalizeState::RollbackInProgress; 
+        } 
+ 
+        bool hasDataEffects = false; 
+        if (settings.GetCommitTx()) { 
+            YQL_ENSURE(!settings.GetRollbackTx()); 
+ 
+            effectsNode = GetCommitEffects(input->Pos(), ctx, hasDataEffects); 
+ 
+            { 
+                if (!CheckCommitEffects(effectsNode, ctx)) { 
+                    return RollbackOnError(ctx); 
+                } 
+ 
+                if (TxState->Tx().IsInvalidated()) { 
                     ctx.AddError(YqlIssue(ctx.GetPosition(input->Pos()), TIssuesIds::KIKIMR_OPERATION_ABORTED, TStringBuilder()
-                        << "Failed to commit transaction due to previous errors."));
-                    return RollbackOnError(ctx);
-                }
-            }
-
-            YQL_CLOG(INFO, ProviderKqp) << "Commit Tx"
+                        << "Failed to commit transaction due to previous errors.")); 
+                    return RollbackOnError(ctx); 
+                } 
+            } 
+ 
+            YQL_CLOG(INFO, ProviderKqp) << "Commit Tx" 
                 << ", deferred effects count: " << TxState->Tx().DeferredEffects.Size()
-                << ", locks count: " << TxState->Tx().Locks.Size();
-
-            State = EFinalizeState::CommitInProgress;
-        }
-
-        auto program = Build<TKiProgram>(ctx, input->Pos())
-            .Results(resultsNode)
-            .Effects(effectsNode)
-            .Done();
-
-        HasProgramResults = HasResults(program);
-        if (!HasProgramResults && !HasEffects(program)) {
-            if (State != EFinalizeState::Initial) {
-                ResetTxState(State == EFinalizeState::CommitInProgress);
-            }
-
-            State = EFinalizeState::Initial;
-            return TStatus::Ok;
-        }
-
-        if (TransformCtx->QueryCtx->PrepareOnly) {
-            YQL_ENSURE(!HasProgramResults);
-            State = EFinalizeState::Initial;
-            return TStatus::Ok;
-        }
-
+                << ", locks count: " << TxState->Tx().Locks.Size(); 
+ 
+            State = EFinalizeState::CommitInProgress; 
+        } 
+ 
+        auto program = Build<TKiProgram>(ctx, input->Pos()) 
+            .Results(resultsNode) 
+            .Effects(effectsNode) 
+            .Done(); 
+ 
+        HasProgramResults = HasResults(program); 
+        if (!HasProgramResults && !HasEffects(program)) { 
+            if (State != EFinalizeState::Initial) { 
+                ResetTxState(State == EFinalizeState::CommitInProgress); 
+            } 
+ 
+            State = EFinalizeState::Initial; 
+            return TStatus::Ok; 
+        } 
+ 
+        if (TransformCtx->QueryCtx->PrepareOnly) { 
+            YQL_ENSURE(!HasProgramResults); 
+            State = EFinalizeState::Initial; 
+            return TStatus::Ok; 
+        } 
+ 
         return ExecuteProgram(program, ctx, hasDataEffects, ShouldWaitForResults(hasDataEffects));
-    }
-
-    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
-        Y_UNUSED(input);
-        return Promise.GetFuture();
-    }
-
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        output = input;
-
-        NKikimr::NKqp::IKqpGateway::TMkqlResult result(MkqlExecuteResult.Future.ExtractValue());
-        bool success = result.Success();
-
-        if (success) {
-            LogMkqlResult(result.Result, ctx);
-            TransformCtx->AddMkqlStats(MkqlExecuteResult.Program, std::move(result.TxStats));
-        }
-
-        switch (State) {
-            case EFinalizeState::CommitInProgress: {
-                TMaybe<TKqpTxLock> invalidatedLock;
-                bool locksOk = success
-                    ? CheckInvalidatedLocks(result.Result, invalidatedLock)
-                    : true;
-
-                success = success && locksOk;
-
-                if (!success) {
-                    result.ReportIssues(ctx.IssueManager);
-
-                    if (!locksOk) {
+    } 
+ 
+    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
+        Y_UNUSED(input); 
+        return Promise.GetFuture(); 
+    } 
+ 
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        output = input; 
+ 
+        NKikimr::NKqp::IKqpGateway::TMkqlResult result(MkqlExecuteResult.Future.ExtractValue()); 
+        bool success = result.Success(); 
+ 
+        if (success) { 
+            LogMkqlResult(result.Result, ctx); 
+            TransformCtx->AddMkqlStats(MkqlExecuteResult.Program, std::move(result.TxStats)); 
+        } 
+ 
+        switch (State) { 
+            case EFinalizeState::CommitInProgress: { 
+                TMaybe<TKqpTxLock> invalidatedLock; 
+                bool locksOk = success 
+                    ? CheckInvalidatedLocks(result.Result, invalidatedLock) 
+                    : true; 
+ 
+                success = success && locksOk; 
+ 
+                if (!success) { 
+                    result.ReportIssues(ctx.IssueManager); 
+ 
+                    if (!locksOk) { 
                         ctx.AddError(GetLocksInvalidatedIssue(TxState->Tx(), invalidatedLock));
-                    }
-                } else {
-                    result.ReportIssues(ctx.IssueManager);
-
-                    auto mkqlResult = MakeSimpleShared<NKikimrMiniKQL::TResult>();
-                    mkqlResult->Swap(&result.Result);
-
-                    if (HasProgramResults) {
-                        TransformCtx->MkqlResults.push_back(mkqlResult);
-                    }
-                }
-
-                break;
-            }
-
-            case EFinalizeState::RollbackInProgress: {
-                success = true;
-                break;
-            }
-
-            case EFinalizeState::RollbackOnErrorInProgress: {
-                success = false;
-                break;
-            }
-
-            default:
-                YQL_ENSURE(false, "Unexpected state in finalize transformer.");
-                break;
-        }
-
-        ResetTxState(State == EFinalizeState::CommitInProgress);
-        State = EFinalizeState::Initial;
-
-        return success ? TStatus::Ok : TStatus::Error;
-    }
-
-    void Rewind() override {
-        State = EFinalizeState::Initial;
-    }
-
-private:
-    enum class EFinalizeState {
-        Initial,
-        CommitInProgress,
-        RollbackInProgress,
-        RollbackOnErrorInProgress
-    };
-
+                    } 
+                } else { 
+                    result.ReportIssues(ctx.IssueManager); 
+ 
+                    auto mkqlResult = MakeSimpleShared<NKikimrMiniKQL::TResult>(); 
+                    mkqlResult->Swap(&result.Result); 
+ 
+                    if (HasProgramResults) { 
+                        TransformCtx->MkqlResults.push_back(mkqlResult); 
+                    } 
+                } 
+ 
+                break; 
+            } 
+ 
+            case EFinalizeState::RollbackInProgress: { 
+                success = true; 
+                break; 
+            } 
+ 
+            case EFinalizeState::RollbackOnErrorInProgress: { 
+                success = false; 
+                break; 
+            } 
+ 
+            default: 
+                YQL_ENSURE(false, "Unexpected state in finalize transformer."); 
+                break; 
+        } 
+ 
+        ResetTxState(State == EFinalizeState::CommitInProgress); 
+        State = EFinalizeState::Initial; 
+ 
+        return success ? TStatus::Ok : TStatus::Error; 
+    } 
+ 
+    void Rewind() override { 
+        State = EFinalizeState::Initial; 
+    } 
+ 
+private: 
+    enum class EFinalizeState { 
+        Initial, 
+        CommitInProgress, 
+        RollbackInProgress, 
+        RollbackOnErrorInProgress 
+    }; 
+ 
     TStatus ExecuteProgram(TKiProgram program, TExprContext& ctx, bool hasDataEffects, bool waitForResults) {
         if (waitForResults) {
             Promise = NewPromise();
-            MkqlExecuteResult = ExecuteMkql(program, Gateway, Cluster, ctx, TxState, TransformCtx, hasDataEffects);
-
+            MkqlExecuteResult = ExecuteMkql(program, Gateway, Cluster, ctx, TxState, TransformCtx, hasDataEffects); 
+ 
             auto promise = Promise;
             MkqlExecuteResult.Future.Apply([promise](const TFuture<IKqpGateway::TMkqlResult> future) mutable {
                 YQL_ENSURE(future.HasValue());
                 promise.SetValue();
             });
-
+ 
             return TStatus::Async;
         }
 
         YQL_ENSURE(!hasDataEffects);
 
-        ExecuteMkql(program, Gateway, Cluster, ctx, TxState, TransformCtx, false);
+        ExecuteMkql(program, Gateway, Cluster, ctx, TxState, TransformCtx, false); 
 
         ResetTxState(true);
         State = EFinalizeState::Initial;
 
         return TStatus::Ok;
-    }
-
-    TStatus RollbackOnError(TExprContext& ctx) {
-        YQL_ENSURE(State == EFinalizeState::Initial);
-
-        YQL_CLOG(INFO, ProviderKqp) << "Rollback Tx On Error"
+    } 
+ 
+    TStatus RollbackOnError(TExprContext& ctx) { 
+        YQL_ENSURE(State == EFinalizeState::Initial); 
+ 
+        YQL_CLOG(INFO, ProviderKqp) << "Rollback Tx On Error" 
             << ", deferred effects count: " << TxState->Tx().DeferredEffects.Size()
-            << ", locks count: " << TxState->Tx().Locks.Size();
-
+            << ", locks count: " << TxState->Tx().Locks.Size(); 
+ 
         auto program = Build<TKiProgram>(ctx, TPositionHandle())
-            .Results()
-                .Build()
+            .Results() 
+                .Build() 
             .Effects(GetRollbackEffects(TPositionHandle(), ctx))
-            .Done();
-
-        if (!HasEffects(program)) {
-            ResetTxState(false);
-
-            return TStatus::Error;
-        }
-
-        State = EFinalizeState::RollbackOnErrorInProgress;
+            .Done(); 
+ 
+        if (!HasEffects(program)) { 
+            ResetTxState(false); 
+ 
+            return TStatus::Error; 
+        } 
+ 
+        State = EFinalizeState::RollbackOnErrorInProgress; 
         return ExecuteProgram(program, ctx, false, true);
-    }
-
-    TExprList GetResultsNode(TExprBase program, TExprContext& ctx) {
-        TMaybeNode<TExprList> resultsNode;
-
-        if (program.Maybe<TCoWorld>()) {
-            resultsNode = Build<TExprList>(ctx, program.Pos()).Done();
-        } else {
-            const auto& analyzeResults = TransformCtx->AnalyzeResults;
-            YQL_ENSURE(analyzeResults.CanExecute);
-
-            resultsNode = program.Cast<TKiProgram>().Results();
-        }
-
-        return resultsNode.Cast();
-    }
-
-    bool CheckCommitEffects(TExprBase effects, TExprContext& ctx) const {
+    } 
+ 
+    TExprList GetResultsNode(TExprBase program, TExprContext& ctx) { 
+        TMaybeNode<TExprList> resultsNode; 
+ 
+        if (program.Maybe<TCoWorld>()) { 
+            resultsNode = Build<TExprList>(ctx, program.Pos()).Done(); 
+        } else { 
+            const auto& analyzeResults = TransformCtx->AnalyzeResults; 
+            YQL_ENSURE(analyzeResults.CanExecute); 
+ 
+            resultsNode = program.Cast<TKiProgram>().Results(); 
+        } 
+ 
+        return resultsNode.Cast(); 
+    } 
+ 
+    bool CheckCommitEffects(TExprBase effects, TExprContext& ctx) const { 
         TIssueScopeGuard issueScope(ctx.IssueManager, [effects, &ctx]() {
             return MakeIntrusive<TIssue>(YqlIssue(ctx.GetPosition(effects.Pos()), TIssuesIds::DEFAULT_ERROR,
-                "Failed to commit transaction"));
-        });
-
-        TMaybeNode<TExprBase> blackistedNode;
-        ui32 readsCount = 0;
-        VisitExpr(effects.Ptr(), [&blackistedNode, &readsCount](const TExprNode::TPtr& exprNode) {
-            if (blackistedNode) {
-                return false;
-            }
-
-            if (auto maybeCallable = TMaybeNode<TCallable>(exprNode)) {
-                auto callable = maybeCallable.Cast();
-
-                if (callable.CallableName() == "Udf" ||
-                    callable.Maybe<TKiSelectRange>())
-                {
-                    blackistedNode = callable;
-                    return false;
-                }
-
-                if (callable.Maybe<TKiSelectRow>()) {
-                    ++readsCount;
-                }
-            }
-
-            return true;
-        });
-
-        if (blackistedNode) {
+                "Failed to commit transaction")); 
+        }); 
+ 
+        TMaybeNode<TExprBase> blackistedNode; 
+        ui32 readsCount = 0; 
+        VisitExpr(effects.Ptr(), [&blackistedNode, &readsCount](const TExprNode::TPtr& exprNode) { 
+            if (blackistedNode) { 
+                return false; 
+            } 
+ 
+            if (auto maybeCallable = TMaybeNode<TCallable>(exprNode)) { 
+                auto callable = maybeCallable.Cast(); 
+ 
+                if (callable.CallableName() == "Udf" || 
+                    callable.Maybe<TKiSelectRange>()) 
+                { 
+                    blackistedNode = callable; 
+                    return false; 
+                } 
+ 
+                if (callable.Maybe<TKiSelectRow>()) { 
+                    ++readsCount; 
+                } 
+            } 
+ 
+            return true; 
+        }); 
+ 
+        if (blackistedNode) { 
             ctx.AddError(TIssue(ctx.GetPosition(blackistedNode.Cast().Pos()), TStringBuilder()
-                << "Callable not expected in commit tx: " << blackistedNode.Cast<TCallable>().CallableName()));
-            return false;
-        }
-
-        ui32 maxReadsCount = TransformCtx->Config->_CommitReadsLimit.Get().GetRef();
-        if (readsCount > maxReadsCount) {
+                << "Callable not expected in commit tx: " << blackistedNode.Cast<TCallable>().CallableName())); 
+            return false; 
+        } 
+ 
+        ui32 maxReadsCount = TransformCtx->Config->_CommitReadsLimit.Get().GetRef(); 
+        if (readsCount > maxReadsCount) { 
             ctx.AddError(TIssue(ctx.GetPosition(effects.Pos()), TStringBuilder()
-                << "Reads limit exceeded in commit tx: " << readsCount << " > " << maxReadsCount));
-            return false;
-        }
-
-        return true;
-    }
-
-    static bool CheckInvalidatedLocks(const NKikimrMiniKQL::TResult& result, TMaybe<TKqpTxLock>& invalidatedLock) {
-        auto structType = result.GetType().GetStruct();
-
-        ui32 resultIndex;
-        if (!GetRunResultIndex(structType, TString(LocksInvalidatedResultName), resultIndex)) {
-            return true;
-        }
-
-        auto locksResult = result.GetValue().GetStruct(resultIndex);
-        if (locksResult.HasOptional()) {
-            bool invalidated = locksResult.GetOptional().GetBool();
-            YQL_ENSURE(invalidated);
-
-            ui32 listIndex;
-            if (GetRunResultIndex(structType, TString(LocksInvalidatedListName), listIndex)) {
-                auto& locksResult = result.GetValue().GetStruct(listIndex);
-                auto& list = locksResult.GetOptional().GetList();
-                if (!list.empty()) {
-                    invalidatedLock = TKqpTxLock(list.Get(0));
-                }
-            }
-
-            return false;
-        }
-
-        return true;
-    }
-
+                << "Reads limit exceeded in commit tx: " << readsCount << " > " << maxReadsCount)); 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+    static bool CheckInvalidatedLocks(const NKikimrMiniKQL::TResult& result, TMaybe<TKqpTxLock>& invalidatedLock) { 
+        auto structType = result.GetType().GetStruct(); 
+ 
+        ui32 resultIndex; 
+        if (!GetRunResultIndex(structType, TString(LocksInvalidatedResultName), resultIndex)) { 
+            return true; 
+        } 
+ 
+        auto locksResult = result.GetValue().GetStruct(resultIndex); 
+        if (locksResult.HasOptional()) { 
+            bool invalidated = locksResult.GetOptional().GetBool(); 
+            YQL_ENSURE(invalidated); 
+ 
+            ui32 listIndex; 
+            if (GetRunResultIndex(structType, TString(LocksInvalidatedListName), listIndex)) { 
+                auto& locksResult = result.GetValue().GetStruct(listIndex); 
+                auto& list = locksResult.GetOptional().GetList(); 
+                if (!list.empty()) { 
+                    invalidatedLock = TKqpTxLock(list.Get(0)); 
+                } 
+            } 
+ 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
     void ResetTxState(bool committed) {
         if (!committed) {
-            TxState->Tx().Invalidate();
-        }
-
+            TxState->Tx().Invalidate(); 
+        } 
+ 
         TxState->Tx().ClearDeferredEffects();
-        TxState->Tx().Locks.Clear();
-        TxState->Tx().Finish();
-    }
-
+        TxState->Tx().Locks.Clear(); 
+        TxState->Tx().Finish(); 
+    } 
+ 
     TExprBase GetRollbackEffects(TPositionHandle pos, TExprContext& ctx) {
-        if (!TxState->Tx().Locks.HasLocks()) {
-            return GetEmptyEffectsList(pos, ctx);
-        }
-
-        auto locksParamName = TxState->Tx().NewParamName();
-        YQL_ENSURE(TxState->Tx().ParamsState->Values.emplace(std::make_pair(locksParamName,
-            GetLocksParamValue(TxState->Tx().Locks))).second);
-
+        if (!TxState->Tx().Locks.HasLocks()) { 
+            return GetEmptyEffectsList(pos, ctx); 
+        } 
+ 
+        auto locksParamName = TxState->Tx().NewParamName(); 
+        YQL_ENSURE(TxState->Tx().ParamsState->Values.emplace(std::make_pair(locksParamName, 
+            GetLocksParamValue(TxState->Tx().Locks))).second); 
+ 
         auto locksParamNode = Build<TCoParameter>(ctx, pos)
-            .Name().Build(locksParamName)
-            .Type(ExpandType(pos, *GetTxLockListType(ctx), ctx))
-            .Done();
-
-        return GetEraseLocksEffects(Cluster, pos, locksParamNode, ctx);
-    }
-
+            .Name().Build(locksParamName) 
+            .Type(ExpandType(pos, *GetTxLockListType(ctx), ctx)) 
+            .Done(); 
+ 
+        return GetEraseLocksEffects(Cluster, pos, locksParamNode, ctx); 
+    } 
+ 
     TExprBase GetCommitEffects(TPositionHandle pos, TExprContext& ctx, bool& hasDataEffects) {
         hasDataEffects = !TxState->Tx().DeferredEffects.Empty();
-
+ 
         Y_VERIFY_DEBUG(!hasDataEffects || !TxState->Tx().Locks.Broken());
 
-        auto deferredEffects = GetDeferredEffectsList(TxState->Tx().DeferredEffects, pos, ctx);
-
-        if (!TxState->Tx().Locks.HasLocks()) {
-            return deferredEffects;
-        }
-
-        auto locksParamName = TxState->Tx().NewParamName();
-        YQL_ENSURE(TxState->Tx().ParamsState->Values.emplace(std::make_pair(locksParamName,
-            GetLocksParamValue(TxState->Tx().Locks))).second);
-
+        auto deferredEffects = GetDeferredEffectsList(TxState->Tx().DeferredEffects, pos, ctx); 
+ 
+        if (!TxState->Tx().Locks.HasLocks()) { 
+            return deferredEffects; 
+        } 
+ 
+        auto locksParamName = TxState->Tx().NewParamName(); 
+        YQL_ENSURE(TxState->Tx().ParamsState->Values.emplace(std::make_pair(locksParamName, 
+            GetLocksParamValue(TxState->Tx().Locks))).second); 
+ 
         auto locksParamNode = Build<TCoParameter>(ctx, pos)
-            .Name().Build(locksParamName)
-            .Type(ExpandType(pos, *GetTxLockListType(ctx), ctx))
-            .Done();
-
+            .Name().Build(locksParamName) 
+            .Type(ExpandType(pos, *GetTxLockListType(ctx), ctx)) 
+            .Done(); 
+ 
         if (!hasDataEffects && TxState->Tx().GetSnapshot().IsValid())
             return GetEraseLocksEffects(Cluster, pos, locksParamNode, ctx);
 
         auto lockArg = Build<TCoArgument>(ctx, pos)
-            .Name("lockArg")
-            .Done();
-
-        auto selectLock = Build<TKiSelectRow>(ctx, pos)
-            .Cluster().Build(Cluster)
+            .Name("lockArg") 
+            .Done(); 
+ 
+        auto selectLock = Build<TKiSelectRow>(ctx, pos) 
+            .Cluster().Build(Cluster) 
             .Table<TKiVersionedTable>()
                 .Path<TCoAtom>().Build(LocksTableName)
                 .SchemaVersion<TCoAtom>().Build(LocksTableVersion)
                 .PathId<TCoAtom>().Build(LocksTablePathId)
             .Build()
-            .Key()
-                .Add()
-                    .Name().Build("LockId")
-                    .Value<TCoMember>()
-                        .Struct(lockArg)
-                        .Name().Build("LockId")
-                        .Build()
-                    .Build()
-                .Add()
-                    .Name().Build("DataShard")
-                    .Value<TCoMember>()
-                        .Struct(lockArg)
-                        .Name().Build("DataShard")
-                        .Build()
-                    .Build()
-                .Add()
-                    .Name().Build("SchemeShard")
+            .Key() 
+                .Add() 
+                    .Name().Build("LockId") 
                     .Value<TCoMember>()
-                        .Struct(lockArg)
-                        .Name().Build("SchemeShard")
-                        .Build()
-                    .Build()
-                .Add()
-                    .Name().Build("PathId")
+                        .Struct(lockArg) 
+                        .Name().Build("LockId") 
+                        .Build() 
+                    .Build() 
+                .Add() 
+                    .Name().Build("DataShard") 
                     .Value<TCoMember>()
-                        .Struct(lockArg)
-                        .Name().Build("PathId")
-                        .Build()
-                    .Build()
-                .Build()
-            .Select()
-                .Add().Build("Generation")
-                .Add().Build("Counter")
-                .Build()
-            .Done();
-
+                        .Struct(lockArg) 
+                        .Name().Build("DataShard") 
+                        .Build() 
+                    .Build() 
+                .Add() 
+                    .Name().Build("SchemeShard") 
+                    .Value<TCoMember>() 
+                        .Struct(lockArg) 
+                        .Name().Build("SchemeShard") 
+                        .Build() 
+                    .Build() 
+                .Add() 
+                    .Name().Build("PathId") 
+                    .Value<TCoMember>() 
+                        .Struct(lockArg) 
+                        .Name().Build("PathId") 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Select() 
+                .Add().Build("Generation") 
+                .Add().Build("Counter") 
+                .Build() 
+            .Done(); 
+ 
         TVector<TExprBase> args = {
             Build<TCoCmpEqual>(ctx, pos)
                 .Left<TCoMember>()
@@ -522,54 +522,54 @@ private:
             .Value<TCoCoalesce>()
                 .Predicate<TCoAnd>()
                     .Add(args)
-                    .Build()
+                    .Build() 
                 .Value<TCoBool>()
-                    .Literal().Build("false")
-                    .Build()
-                .Build()
-            .Done();
-
-        auto locksInvalidatedList = Build<TKiFlatMapParameter>(ctx, pos)
-            .Input(locksParamNode)
-            .Lambda()
-                .Args(lockArg)
-                .Body<TCoListIf>()
-                    .Predicate(lockPredicate)
-                    .Value(lockArg)
-                    .Build()
-                .Build()
-            .Done();
-
-        auto locksInvalidatedPredicate = Build<TCoHasItems>(ctx, pos)
-            .List(locksInvalidatedList)
-            .Done();
-
+                    .Literal().Build("false") 
+                    .Build() 
+                .Build() 
+            .Done(); 
+ 
+        auto locksInvalidatedList = Build<TKiFlatMapParameter>(ctx, pos) 
+            .Input(locksParamNode) 
+            .Lambda() 
+                .Args(lockArg) 
+                .Body<TCoListIf>() 
+                    .Predicate(lockPredicate) 
+                    .Value(lockArg) 
+                    .Build() 
+                .Build() 
+            .Done(); 
+ 
+        auto locksInvalidatedPredicate = Build<TCoHasItems>(ctx, pos) 
+            .List(locksInvalidatedList) 
+            .Done(); 
+ 
         auto effects = Build<TCoExtend>(ctx, pos)
             .Add<TCoIf>()
-                .Predicate(locksInvalidatedPredicate)
+                .Predicate(locksInvalidatedPredicate) 
                 .ThenValue<TCoAsList>()
-                    .Add<TKiSetResult>()
-                        .Name().Build(LocksInvalidatedResultName)
-                        .Data(locksInvalidatedPredicate)
-                        .Build()
-                    .Add<TKiSetResult>()
-                        .Name().Build(LocksInvalidatedListName)
-                        .Data<TCoTake>()
-                            .Input(locksInvalidatedList)
-                            .Count<TCoUint64>()
-                                .Literal().Build(ToString(LocksInvalidatedCount))
-                                .Build()
-                            .Build()
-                        .Build()
-                    .Build()
-                .ElseValue(deferredEffects)
-                .Build()
-            .Add(GetEraseLocksEffects(Cluster, pos, locksParamNode, ctx))
-            .Done();
-
-        return effects;
-    }
-
+                    .Add<TKiSetResult>() 
+                        .Name().Build(LocksInvalidatedResultName) 
+                        .Data(locksInvalidatedPredicate) 
+                        .Build() 
+                    .Add<TKiSetResult>() 
+                        .Name().Build(LocksInvalidatedListName) 
+                        .Data<TCoTake>() 
+                            .Input(locksInvalidatedList) 
+                            .Count<TCoUint64>() 
+                                .Literal().Build(ToString(LocksInvalidatedCount)) 
+                                .Build() 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .ElseValue(deferredEffects) 
+                .Build() 
+            .Add(GetEraseLocksEffects(Cluster, pos, locksParamNode, ctx)) 
+            .Done(); 
+ 
+        return effects; 
+    } 
+ 
     bool ShouldWaitForResults(bool hasDataEffects) {
         if (State != EFinalizeState::CommitInProgress) {
             return true;
@@ -590,49 +590,49 @@ private:
         return false;
     }
 
-private:
-    TIntrusivePtr<IKqpGateway> Gateway;
+private: 
+    TIntrusivePtr<IKqpGateway> Gateway; 
     TString Cluster;
-    TIntrusivePtr<TKqpTransactionState> TxState;
-    TIntrusivePtr<TKqlTransformContext> TransformCtx;
-    EFinalizeState State;
-    bool HasProgramResults;
-    TMkqlExecuteResult MkqlExecuteResult;
-    TPromise<void> Promise;
-};
-
-} // namespace
-
+    TIntrusivePtr<TKqpTransactionState> TxState; 
+    TIntrusivePtr<TKqlTransformContext> TransformCtx; 
+    EFinalizeState State; 
+    bool HasProgramResults; 
+    TMkqlExecuteResult MkqlExecuteResult; 
+    TPromise<void> Promise; 
+}; 
+ 
+} // namespace 
+ 
 TCoList GetEmptyEffectsList(const TPositionHandle pos, TExprContext& ctx) {
     return Build<TCoList>(ctx, pos)
         .ListType<TCoListType>()
             .ItemType<TCoVoidType>()
-                .Build()
-            .Build()
-        .Done();
-}
-
-NKikimrMiniKQL::TParams GetLocksParamValue(const TKqpTxLocks& locks) {
-    YQL_ENSURE(locks.HasLocks());
-
-    NKikimrMiniKQL::TParams locksResult;
-    auto type = locksResult.MutableType();
-    type->SetKind(NKikimrMiniKQL::ETypeKind::List);
-    type->MutableList()->CopyFrom(locks.LocksListType);
-    auto value = locksResult.MutableValue();
-    for (auto& pair : locks.LocksMap) {
-        auto lockValue = value->AddList();
-        lockValue->CopyFrom(pair.second.GetValue());
-    }
-
-    return locksResult;
-}
-
-TAutoPtr<IGraphTransformer> CreateKqpFinalizeTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster,
-    TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx)
-{
-    return new TKqpFinalizeTransformer(gateway, cluster, txState, transformCtx);
-}
-
+                .Build() 
+            .Build() 
+        .Done(); 
+} 
+ 
+NKikimrMiniKQL::TParams GetLocksParamValue(const TKqpTxLocks& locks) { 
+    YQL_ENSURE(locks.HasLocks()); 
+ 
+    NKikimrMiniKQL::TParams locksResult; 
+    auto type = locksResult.MutableType(); 
+    type->SetKind(NKikimrMiniKQL::ETypeKind::List); 
+    type->MutableList()->CopyFrom(locks.LocksListType); 
+    auto value = locksResult.MutableValue(); 
+    for (auto& pair : locks.LocksMap) { 
+        auto lockValue = value->AddList(); 
+        lockValue->CopyFrom(pair.second.GetValue()); 
+    } 
+ 
+    return locksResult; 
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpFinalizeTransformer(TIntrusivePtr<IKqpGateway> gateway, const TString& cluster, 
+    TIntrusivePtr<TKqpTransactionState> txState, TIntrusivePtr<TKqlTransformContext> transformCtx) 
+{ 
+    return new TKqpFinalizeTransformer(gateway, cluster, txState, transformCtx); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/kqp_query_plan.cpp b/ydb/core/kqp/prepare/kqp_query_plan.cpp
index 346a8b15cb..a06b42fb24 100644
--- a/ydb/core/kqp/prepare/kqp_query_plan.cpp
+++ b/ydb/core/kqp/prepare/kqp_query_plan.cpp
@@ -1,5 +1,5 @@
-#include "kqp_prepare_impl.h"
-
+#include "kqp_prepare_impl.h" 
+ 
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
 #include <ydb/public/lib/value/value.h>
@@ -9,46 +9,46 @@
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/dq/opt/dq_opt.h>
 #include <ydb/library/yql/dq/tasks/dq_tasks_graph.h>
-
+ 
 #include <library/cpp/json/writer/json.h>
 #include <library/cpp/json/json_reader.h>
 
-#include <util/generic/queue.h>
-#include <util/string/strip.h>
+#include <util/generic/queue.h> 
+#include <util/string/strip.h> 
 #include <util/string/vector.h>
-
+ 
 #include <regex>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
 using namespace NYql::NDq;
 using namespace NClient;
-
-namespace {
-
-struct TTableRead {
-    ETableReadType Type = ETableReadType::Unspecified;
-    TVector<TString> LookupBy;
-    TVector<TString> ScanBy;
+ 
+namespace { 
+ 
+struct TTableRead { 
+    ETableReadType Type = ETableReadType::Unspecified; 
+    TVector<TString> LookupBy; 
+    TVector<TString> ScanBy; 
     TVector<TString> Columns;
-    TMaybe<TString> Limit;
+    TMaybe<TString> Limit; 
     bool Reverse = false;
-};
-
-struct TTableWrite {
-    ETableWriteType Type = ETableWriteType::Unspecified;
-    TVector<TString> Keys;
-    TVector<TString> Columns;
-};
-
-struct TTableInfo {
-    TVector<TTableRead> Reads;
-    TVector<TTableWrite> Writes;
-};
-
+}; 
+ 
+struct TTableWrite { 
+    ETableWriteType Type = ETableWriteType::Unspecified; 
+    TVector<TString> Keys; 
+    TVector<TString> Columns; 
+}; 
+ 
+struct TTableInfo { 
+    TVector<TTableRead> Reads; 
+    TVector<TTableWrite> Writes; 
+}; 
+ 
 struct TSerializerCtx {
     TSerializerCtx(TExprContext& exprCtx, const TString& cluster,
         const TIntrusivePtr<NYql::TKikimrTablesData> tablesData,
@@ -76,212 +76,212 @@ struct TSerializerCtx {
     THashMap<ui32, TVector<NKikimrMiniKQL::TResult>> PureTxResults;
 };
 
-TString GetExprStr(const TExprBase& scalar) {
-    if (auto maybeData = scalar.Maybe<TCoDataCtor>()) {
-        auto literal = TString(maybeData.Cast().Literal());
-        CollapseText(literal, 32);
-
-        return TStringBuilder() << '"' << literal << '"';
-    }
-
-    if (auto maybeParam = scalar.Maybe<TCoParameter>()) {
-        return TString(maybeParam.Cast().Name());
-    }
-
-    return "expr";
-}
-
-void FillTablesInfo(const TExprNode::TPtr& query, TMap<TString, TTableInfo>& tables) {
-    TNodeSet visitedNodes;
-    TQueue<TMaybe<TExprScope>> scopesQueue;
-    scopesQueue.push(TMaybe<TExprScope>());
-
-    while (!scopesQueue.empty()) {
-        auto scope = scopesQueue.front();
-        scopesQueue.pop();
-
-        auto scopeRoot = scope
-            ? scope->Lambda.Body()
-            : TExprBase(query);
-
-        VisitExpr(scopeRoot.Ptr(), [scope, &scopesQueue, &tables] (const TExprNode::TPtr& exprNode) {
-            auto node = TExprBase(exprNode);
-            auto mapDepth = scope ? scope->Depth : 0;
-
-            if (node.Maybe<TCoLambda>()) {
-                return false;
-            }
-
-            if (auto callable = node.Maybe<TCallable>()) {
-                bool isMap = callable.Maybe<TCoMapBase>().IsValid() ||
-                             callable.Maybe<TCoFlatMapBase>().IsValid() ||
-                             callable.Maybe<TCoFilterBase>().IsValid();
-
-                for (const auto& arg : node.Cast<TVarArgCallable<TExprBase>>()) {
-                    if (auto lambda = arg.Maybe<TCoLambda>()) {
-                        TExprScope newScope(callable.Cast(), lambda.Cast(), isMap ? mapDepth + 1 : mapDepth);
-                        scopesQueue.push(newScope);
-                    }
-                }
-            }
-
-            if (auto maybeSelectRange = node.Maybe<TKiSelectRange>()) {
-                auto selectRange = maybeSelectRange.Cast();
-
-                TTableRead read;
-
-                auto isBoundDefined = [](const TExprBase& bound) -> bool {
-                    return !bound.Maybe<TCoNothing>() && !bound.Maybe<TCoVoid>();
-                };
-
-                auto getBoundStr = [](const TExprBase& bound) -> TString {
-                    if (bound.Maybe<TCoNothing>()) {
-                        return "-inf";
-                    }
-
-                    if (bound.Maybe<TCoVoid>()) {
-                        return "+inf";
-                    }
-
-                    return GetExprStr(bound);
-                };
-
-                bool incFrom = false;
-                bool incTo = false;
-                for (const auto& node : selectRange.Range()) {
-                    if (auto maybeAtom = node.Maybe<TCoAtom>()) {
-                        auto value = maybeAtom.Cast().Value();
-
-                        if (value == "IncFrom") {
-                            incFrom = true;
-                        }
-
-                        if (value == "IncTo") {
-                            incTo = true;
-                        }
-                    }
-                }
-
-                bool isScan = false;
-                for (const auto& node : selectRange.Range()) {
-                    if (auto maybeColumnRange = node.Maybe<TKiColumnRangeTuple>()) {
-                        auto columnRange = maybeColumnRange.Cast();
-
-                        if (!isScan && columnRange.From().Raw() == columnRange.To().Raw()) {
-                            auto lookup = TStringBuilder() << columnRange.Column().Value()
-                                << " (" << GetExprStr(columnRange.From()) << ")";
-                            read.LookupBy.push_back(lookup);
-                        } else {
-                            isScan = true;
-
-                            TStringBuilder scanBuilder;
-                            scanBuilder << columnRange.Column().Value();
-
-                            if (isBoundDefined(columnRange.From()) || isBoundDefined(columnRange.To())) {
-                                scanBuilder
-                                    << (incFrom ? " [" : " (")
-                                    << getBoundStr(columnRange.From()) << ", "
-                                    << getBoundStr(columnRange.To())
-                                    << (incTo ? "]" : ")");
-                            }
-
-                            read.ScanBy.push_back(scanBuilder);
-                        }
-                    }
-                }
-
-                auto limitSetting = GetSetting(selectRange.Settings().Ref(), "ItemsLimit");
-                if (limitSetting && TMaybeNode<TCoNameValueTuple>(limitSetting)) {
-                    read.Limit = GetExprStr(TCoNameValueTuple(limitSetting).Value().Cast());
-                }
-
+TString GetExprStr(const TExprBase& scalar) { 
+    if (auto maybeData = scalar.Maybe<TCoDataCtor>()) { 
+        auto literal = TString(maybeData.Cast().Literal()); 
+        CollapseText(literal, 32); 
+ 
+        return TStringBuilder() << '"' << literal << '"'; 
+    } 
+ 
+    if (auto maybeParam = scalar.Maybe<TCoParameter>()) { 
+        return TString(maybeParam.Cast().Name()); 
+    } 
+ 
+    return "expr"; 
+} 
+ 
+void FillTablesInfo(const TExprNode::TPtr& query, TMap<TString, TTableInfo>& tables) { 
+    TNodeSet visitedNodes; 
+    TQueue<TMaybe<TExprScope>> scopesQueue; 
+    scopesQueue.push(TMaybe<TExprScope>()); 
+ 
+    while (!scopesQueue.empty()) { 
+        auto scope = scopesQueue.front(); 
+        scopesQueue.pop(); 
+ 
+        auto scopeRoot = scope 
+            ? scope->Lambda.Body() 
+            : TExprBase(query); 
+ 
+        VisitExpr(scopeRoot.Ptr(), [scope, &scopesQueue, &tables] (const TExprNode::TPtr& exprNode) { 
+            auto node = TExprBase(exprNode); 
+            auto mapDepth = scope ? scope->Depth : 0; 
+ 
+            if (node.Maybe<TCoLambda>()) { 
+                return false; 
+            } 
+ 
+            if (auto callable = node.Maybe<TCallable>()) { 
+                bool isMap = callable.Maybe<TCoMapBase>().IsValid() || 
+                             callable.Maybe<TCoFlatMapBase>().IsValid() || 
+                             callable.Maybe<TCoFilterBase>().IsValid(); 
+ 
+                for (const auto& arg : node.Cast<TVarArgCallable<TExprBase>>()) { 
+                    if (auto lambda = arg.Maybe<TCoLambda>()) { 
+                        TExprScope newScope(callable.Cast(), lambda.Cast(), isMap ? mapDepth + 1 : mapDepth); 
+                        scopesQueue.push(newScope); 
+                    } 
+                } 
+            } 
+ 
+            if (auto maybeSelectRange = node.Maybe<TKiSelectRange>()) { 
+                auto selectRange = maybeSelectRange.Cast(); 
+ 
+                TTableRead read; 
+ 
+                auto isBoundDefined = [](const TExprBase& bound) -> bool { 
+                    return !bound.Maybe<TCoNothing>() && !bound.Maybe<TCoVoid>(); 
+                }; 
+ 
+                auto getBoundStr = [](const TExprBase& bound) -> TString { 
+                    if (bound.Maybe<TCoNothing>()) { 
+                        return "-inf"; 
+                    } 
+ 
+                    if (bound.Maybe<TCoVoid>()) { 
+                        return "+inf"; 
+                    } 
+ 
+                    return GetExprStr(bound); 
+                }; 
+ 
+                bool incFrom = false; 
+                bool incTo = false; 
+                for (const auto& node : selectRange.Range()) { 
+                    if (auto maybeAtom = node.Maybe<TCoAtom>()) { 
+                        auto value = maybeAtom.Cast().Value(); 
+ 
+                        if (value == "IncFrom") { 
+                            incFrom = true; 
+                        } 
+ 
+                        if (value == "IncTo") { 
+                            incTo = true; 
+                        } 
+                    } 
+                } 
+ 
+                bool isScan = false; 
+                for (const auto& node : selectRange.Range()) { 
+                    if (auto maybeColumnRange = node.Maybe<TKiColumnRangeTuple>()) { 
+                        auto columnRange = maybeColumnRange.Cast(); 
+ 
+                        if (!isScan && columnRange.From().Raw() == columnRange.To().Raw()) { 
+                            auto lookup = TStringBuilder() << columnRange.Column().Value() 
+                                << " (" << GetExprStr(columnRange.From()) << ")"; 
+                            read.LookupBy.push_back(lookup); 
+                        } else { 
+                            isScan = true; 
+ 
+                            TStringBuilder scanBuilder; 
+                            scanBuilder << columnRange.Column().Value(); 
+ 
+                            if (isBoundDefined(columnRange.From()) || isBoundDefined(columnRange.To())) { 
+                                scanBuilder 
+                                    << (incFrom ? " [" : " (") 
+                                    << getBoundStr(columnRange.From()) << ", " 
+                                    << getBoundStr(columnRange.To()) 
+                                    << (incTo ? "]" : ")"); 
+                            } 
+ 
+                            read.ScanBy.push_back(scanBuilder); 
+                        } 
+                    } 
+                } 
+ 
+                auto limitSetting = GetSetting(selectRange.Settings().Ref(), "ItemsLimit"); 
+                if (limitSetting && TMaybeNode<TCoNameValueTuple>(limitSetting)) { 
+                    read.Limit = GetExprStr(TCoNameValueTuple(limitSetting).Value().Cast()); 
+                } 
+ 
                 auto reverseSettings = GetSetting(selectRange.Settings().Ref(), "Reverse");
                 if (reverseSettings) {
                     read.Reverse = true;
                 }
 
-                for (const auto& column : selectRange.Select()) {
-                    read.Columns.emplace_back(column);
-                }
-
-                if (read.LookupBy.empty()) {
-                    read.Type = TKikimrKeyRange::IsFull(selectRange.Range())
-                        ? ETableReadType::FullScan
-                        : ETableReadType::Scan;
-                } else {
-                    read.Type = mapDepth > 0
-                        ? ETableReadType::MultiLookup
-                        : ETableReadType::Lookup;
-                }
-
-                tables[TString(selectRange.Table().Path())].Reads.push_back(read);
-            }
-
-            if (auto maybeSelectRow = node.Maybe<TKiSelectRow>()) {
-                auto selectRow = maybeSelectRow.Cast();
-
-                TTableRead read;
-                read.Type = mapDepth > 0
-                    ? ETableReadType::MultiLookup
-                    : ETableReadType::Lookup;
-
-                for (const auto& key : selectRow.Key()) {
-                    auto lookup = TStringBuilder() << key.Name().Value()
-                        << " (" << GetExprStr(key.Value().Cast()) << ")";
-                    read.LookupBy.push_back(lookup);
-                }
-
-                for (const auto& column : selectRow.Select()) {
-                    read.Columns.emplace_back(column);
-                }
-
-                tables[TString(selectRow.Table().Path())].Reads.push_back(read);
-            }
-
-            if (auto maybeUpdateRow = node.Maybe<TKiUpdateRow>()) {
-                auto updateRow = maybeUpdateRow.Cast();
-
-                TTableWrite write;
-                write.Type = mapDepth > 0
-                    ? ETableWriteType::MultiUpsert
-                    : ETableWriteType::Upsert;
-
-
-                for (const auto& tuple : updateRow.Key()) {
-                    auto key = TStringBuilder() << tuple.Name().Value()
-                        << " (" << GetExprStr(tuple.Value().Cast()) << ")";
-                    write.Keys.push_back(key);
-                }
-
-                for (const auto& tuple : updateRow.Update()) {
-                    write.Columns.emplace_back(tuple.Name());
-                }
-
-                tables[TString(updateRow.Table().Path())].Writes.push_back(write);
-            }
-
-            if (auto maybeEraseRow = node.Maybe<TKiEraseRow>()) {
-                auto eraseRow = maybeEraseRow.Cast();
-
-                TTableWrite write;
-                write.Type = mapDepth > 0
-                    ? ETableWriteType::MultiErase
-                    : ETableWriteType::Erase;
-
-                for (const auto& tuple : eraseRow.Key()) {
-                    auto key = TStringBuilder() << tuple.Name().Value()
-                        << " (" << GetExprStr(tuple.Value().Cast()) << ")";
-                    write.Keys.push_back(key);
-                }
-
-                tables[TString(eraseRow.Table().Path())].Writes.push_back(write);
-            }
-
-            return true;
-        }, visitedNodes);
-    }
-};
-
+                for (const auto& column : selectRange.Select()) { 
+                    read.Columns.emplace_back(column); 
+                } 
+ 
+                if (read.LookupBy.empty()) { 
+                    read.Type = TKikimrKeyRange::IsFull(selectRange.Range()) 
+                        ? ETableReadType::FullScan 
+                        : ETableReadType::Scan; 
+                } else { 
+                    read.Type = mapDepth > 0 
+                        ? ETableReadType::MultiLookup 
+                        : ETableReadType::Lookup; 
+                } 
+ 
+                tables[TString(selectRange.Table().Path())].Reads.push_back(read); 
+            } 
+ 
+            if (auto maybeSelectRow = node.Maybe<TKiSelectRow>()) { 
+                auto selectRow = maybeSelectRow.Cast(); 
+ 
+                TTableRead read; 
+                read.Type = mapDepth > 0 
+                    ? ETableReadType::MultiLookup 
+                    : ETableReadType::Lookup; 
+ 
+                for (const auto& key : selectRow.Key()) { 
+                    auto lookup = TStringBuilder() << key.Name().Value() 
+                        << " (" << GetExprStr(key.Value().Cast()) << ")"; 
+                    read.LookupBy.push_back(lookup); 
+                } 
+ 
+                for (const auto& column : selectRow.Select()) { 
+                    read.Columns.emplace_back(column); 
+                } 
+ 
+                tables[TString(selectRow.Table().Path())].Reads.push_back(read); 
+            } 
+ 
+            if (auto maybeUpdateRow = node.Maybe<TKiUpdateRow>()) { 
+                auto updateRow = maybeUpdateRow.Cast(); 
+ 
+                TTableWrite write; 
+                write.Type = mapDepth > 0 
+                    ? ETableWriteType::MultiUpsert 
+                    : ETableWriteType::Upsert; 
+ 
+ 
+                for (const auto& tuple : updateRow.Key()) { 
+                    auto key = TStringBuilder() << tuple.Name().Value() 
+                        << " (" << GetExprStr(tuple.Value().Cast()) << ")"; 
+                    write.Keys.push_back(key); 
+                } 
+ 
+                for (const auto& tuple : updateRow.Update()) { 
+                    write.Columns.emplace_back(tuple.Name()); 
+                } 
+ 
+                tables[TString(updateRow.Table().Path())].Writes.push_back(write); 
+            } 
+ 
+            if (auto maybeEraseRow = node.Maybe<TKiEraseRow>()) { 
+                auto eraseRow = maybeEraseRow.Cast(); 
+ 
+                TTableWrite write; 
+                write.Type = mapDepth > 0 
+                    ? ETableWriteType::MultiErase 
+                    : ETableWriteType::Erase; 
+ 
+                for (const auto& tuple : eraseRow.Key()) { 
+                    auto key = TStringBuilder() << tuple.Name().Value() 
+                        << " (" << GetExprStr(tuple.Value().Cast()) << ")"; 
+                    write.Keys.push_back(key); 
+                } 
+ 
+                tables[TString(eraseRow.Table().Path())].Writes.push_back(write); 
+            } 
+ 
+            return true; 
+        }, visitedNodes); 
+    } 
+}; 
+ 
 class TxPlanSerializer {
 public:
     TxPlanSerializer(TSerializerCtx& serializerCtx, ui32 txId, const TKqpPhysicalTx& tx) : SerializerCtx(serializerCtx), TxId(txId), Tx(tx) {}
@@ -681,7 +681,7 @@ private:
 
                 auto& inputPlanNode = AddPlanNode(stagePlanNode);
                 inputPlanNode.Type = EPlanNodeType::Connection;
-
+ 
                 if (inputCn.Maybe<TDqCnUnionAll>()) {
                     inputPlanNode.TypeName = "UnionAll";
                 } else if (inputCn.Maybe<TDqCnBroadcast>()) {
@@ -695,15 +695,15 @@ private:
                 } else {
                     inputPlanNode.TypeName = inputCn.Ref().Content();
                 }
-
+ 
                 Visit(inputCn.Output().Stage(), inputPlanNode);
-            }
+            } 
         } else {
             Visit(expr.Ptr(),  planNode);
-
+ 
             if (planNode.TypeName.Empty()) {
                 planNode.TypeName = "Stage";
-            }
+            } 
         }
     }
 
@@ -1240,113 +1240,113 @@ void ModifyPlan(NJson::TJsonValue& plan, const ModifyFunction& modify) {
 
 void WriteCommonTablesInfo(NJsonWriter::TBuf& writer, TMap<TString, TTableInfo>& tables) {
 
-    for (auto& pair : tables) {
-        auto& info = pair.second;
-
-        std::sort(info.Reads.begin(), info.Reads.end(), [](const auto& l, const auto& r) {
-            return std::tie(l.Type, l.LookupBy, l.ScanBy, l.Limit, l.Columns) <
-                   std::tie(r.Type, r.LookupBy, r.ScanBy, r.Limit, r.Columns);
-        });
-
-        std::sort(info.Writes.begin(), info.Writes.end(), [](const auto& l, const auto& r) {
-            return std::tie(l.Type, l.Keys, l.Columns) <
-                   std::tie(r.Type, r.Keys, r.Columns);
-        });
-    }
-
-    writer.BeginList();
-
-    for (auto& pair : tables) {
-        auto& name = pair.first;
-        auto& table = pair.second;
-
-        writer.BeginObject();
-        writer.WriteKey("name").WriteString(name);
-
-        if (!table.Reads.empty()) {
-            writer.WriteKey("reads");
-            writer.BeginList();
-
-            for (auto& read : table.Reads) {
-                writer.BeginObject();
-                writer.WriteKey("type").WriteString(ToString(read.Type));
-
-                if (!read.LookupBy.empty()) {
-                    writer.WriteKey("lookup_by");
-                    writer.BeginList();
-                    for (auto& column : read.LookupBy) {
-                        writer.WriteString(column);
-                    }
-                    writer.EndList();
-                }
-
-                if (!read.ScanBy.empty()) {
-                    writer.WriteKey("scan_by");
-                    writer.BeginList();
-                    for (auto& column : read.ScanBy) {
-                        writer.WriteString(column);
-                    }
-                    writer.EndList();
-                }
-
-                if (read.Limit) {
-                    writer.WriteKey("limit").WriteString(*read.Limit);
-                }
+    for (auto& pair : tables) { 
+        auto& info = pair.second; 
+ 
+        std::sort(info.Reads.begin(), info.Reads.end(), [](const auto& l, const auto& r) { 
+            return std::tie(l.Type, l.LookupBy, l.ScanBy, l.Limit, l.Columns) < 
+                   std::tie(r.Type, r.LookupBy, r.ScanBy, r.Limit, r.Columns); 
+        }); 
+ 
+        std::sort(info.Writes.begin(), info.Writes.end(), [](const auto& l, const auto& r) { 
+            return std::tie(l.Type, l.Keys, l.Columns) < 
+                   std::tie(r.Type, r.Keys, r.Columns); 
+        }); 
+    } 
+ 
+    writer.BeginList(); 
+ 
+    for (auto& pair : tables) { 
+        auto& name = pair.first; 
+        auto& table = pair.second; 
+ 
+        writer.BeginObject(); 
+        writer.WriteKey("name").WriteString(name); 
+ 
+        if (!table.Reads.empty()) { 
+            writer.WriteKey("reads"); 
+            writer.BeginList(); 
+ 
+            for (auto& read : table.Reads) { 
+                writer.BeginObject(); 
+                writer.WriteKey("type").WriteString(ToString(read.Type)); 
+ 
+                if (!read.LookupBy.empty()) { 
+                    writer.WriteKey("lookup_by"); 
+                    writer.BeginList(); 
+                    for (auto& column : read.LookupBy) { 
+                        writer.WriteString(column); 
+                    } 
+                    writer.EndList(); 
+                } 
+ 
+                if (!read.ScanBy.empty()) { 
+                    writer.WriteKey("scan_by"); 
+                    writer.BeginList(); 
+                    for (auto& column : read.ScanBy) { 
+                        writer.WriteString(column); 
+                    } 
+                    writer.EndList(); 
+                } 
+ 
+                if (read.Limit) { 
+                    writer.WriteKey("limit").WriteString(*read.Limit); 
+                } 
                 if (read.Reverse) {
                     writer.WriteKey("reverse").WriteBool(true);
                 }
-
-                if (!read.Columns.empty()) {
-                    writer.WriteKey("columns");
-                    writer.BeginList();
-                    for (auto& column : read.Columns) {
-                        writer.WriteString(column);
-                    }
-                    writer.EndList();
-                }
-
-                writer.EndObject();
-            }
-
-            writer.EndList();
-        }
-
-        if (!table.Writes.empty()) {
-            writer.WriteKey("writes");
-            writer.BeginList();
-
-            for (auto& write : table.Writes) {
-                writer.BeginObject();
-                writer.WriteKey("type").WriteString(ToString(write.Type));
-
-                if (!write.Keys.empty()) {
-                    writer.WriteKey("key");
-                    writer.BeginList();
-                    for (auto& column : write.Keys) {
-                        writer.WriteString(column);
-                    }
-                    writer.EndList();
-                }
-
-                if (!write.Columns.empty()) {
-                    writer.WriteKey("columns");
-                    writer.BeginList();
-                    for (auto& column : write.Columns) {
-                        writer.WriteString(column);
-                    }
-                    writer.EndList();
-                }
-
-                writer.EndObject();
-            }
-
-            writer.EndList();
-        }
-
-        writer.EndObject();
-    }
-
-    writer.EndList();
+ 
+                if (!read.Columns.empty()) { 
+                    writer.WriteKey("columns"); 
+                    writer.BeginList(); 
+                    for (auto& column : read.Columns) { 
+                        writer.WriteString(column); 
+                    } 
+                    writer.EndList(); 
+                } 
+ 
+                writer.EndObject(); 
+            } 
+ 
+            writer.EndList(); 
+        } 
+ 
+        if (!table.Writes.empty()) { 
+            writer.WriteKey("writes"); 
+            writer.BeginList(); 
+ 
+            for (auto& write : table.Writes) { 
+                writer.BeginObject(); 
+                writer.WriteKey("type").WriteString(ToString(write.Type)); 
+ 
+                if (!write.Keys.empty()) { 
+                    writer.WriteKey("key"); 
+                    writer.BeginList(); 
+                    for (auto& column : write.Keys) { 
+                        writer.WriteString(column); 
+                    } 
+                    writer.EndList(); 
+                } 
+ 
+                if (!write.Columns.empty()) { 
+                    writer.WriteKey("columns"); 
+                    writer.BeginList(); 
+                    for (auto& column : write.Columns) { 
+                        writer.WriteString(column); 
+                    } 
+                    writer.EndList(); 
+                } 
+ 
+                writer.EndObject(); 
+            } 
+ 
+            writer.EndList(); 
+        } 
+ 
+        writer.EndObject(); 
+    } 
+ 
+    writer.EndList(); 
 
 }
 
@@ -1361,15 +1361,15 @@ void WriteKqlPlan(NJsonWriter::TBuf& writer, const TExprNode::TPtr& query) {
     writer.BeginObject();
     writer.WriteKey("version").WriteString("0.1");
     writer.WriteKey("type").WriteString("query");
-    writer.EndObject();
-
+    writer.EndObject(); 
+ 
     writer.WriteKey("tables");
     FillTablesInfo(query, tables);
     WriteCommonTablesInfo(writer, tables);
 
     writer.EndObject();
-}
-
+} 
+ 
 // TODO(sk): check prepared statements params in read ranges
 // TODO(sk): check params from correlated subqueries // lookup join
 void PhyQuerySetTxPlans(NKqpProto::TKqpPhyQuery& queryProto, const TKqpPhysicalQuery& query,
@@ -1570,4 +1570,4 @@ TString SerializeScriptPlan(const TVector<const TString>& queryPlans) {
 }
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/kqp_query_rewrite.cpp b/ydb/core/kqp/prepare/kqp_query_rewrite.cpp
index cb24a1b8a1..561fd071b7 100644
--- a/ydb/core/kqp/prepare/kqp_query_rewrite.cpp
+++ b/ydb/core/kqp/prepare/kqp_query_rewrite.cpp
@@ -1,83 +1,83 @@
-#include "kqp_prepare_impl.h"
-
+#include "kqp_prepare_impl.h" 
+ 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-
-namespace {
-
-template<typename TMapNode>
-TExprBase RebuildMapToList(TMapNode map, TExprContext& ctx) {
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+template<typename TMapNode> 
+TExprBase RebuildMapToList(TMapNode map, TExprContext& ctx) { 
     if (map.Lambda().Ptr()->GetTypeAnn()->GetKind() == ETypeAnnotationKind::List &&
         map.Input().Ptr()->GetTypeAnn()->GetKind() == ETypeAnnotationKind::List)
-    {
-        return map;
-    }
-
+    { 
+        return map; 
+    } 
+ 
     bool isOptional = map.Ptr()->GetTypeAnn()->GetKind() == ETypeAnnotationKind::Optional;
-
+ 
     if (map.Lambda().Ptr()->GetTypeAnn()->GetKind() == ETypeAnnotationKind::Optional) {
         auto newBody = Build<TCoToList>(ctx, map.Pos())
-            .Optional(map.Lambda().Body())
-            .Done();
-
-        map = Build<TMapNode>(ctx, map.Pos())
-            .Input(map.Input())
-            .Lambda()
-                .Args({"item"})
-                .template Body<TExprApplier>()
-                    .Apply(newBody)
-                    .With(map.Lambda().Args().Arg(0), "item")
-                    .Build()
-                .Build()
-            .Done();
-    }
-
+            .Optional(map.Lambda().Body()) 
+            .Done(); 
+ 
+        map = Build<TMapNode>(ctx, map.Pos()) 
+            .Input(map.Input()) 
+            .Lambda() 
+                .Args({"item"}) 
+                .template Body<TExprApplier>() 
+                    .Apply(newBody) 
+                    .With(map.Lambda().Args().Arg(0), "item") 
+                    .Build() 
+                .Build() 
+            .Done(); 
+    } 
+ 
     if (map.Input().Ptr()->GetTypeAnn()->GetKind() == ETypeAnnotationKind::Optional) {
-        map = Build<TMapNode>(ctx, map.Pos())
+        map = Build<TMapNode>(ctx, map.Pos()) 
             .template Input<TCoToList>()
-                .Optional(map.Input())
-                .Build()
-            .Lambda(map.Lambda())
-            .Done();
-    }
-
-    if (isOptional) {
+                .Optional(map.Input()) 
+                .Build() 
+            .Lambda(map.Lambda()) 
+            .Done(); 
+    } 
+ 
+    if (isOptional) { 
         return Build<TCoToOptional>(ctx, map.Pos())
-            .List(map)
-            .Done();
-    }
-
-    YQL_CLOG(INFO, ProviderKqp) << "RebuildMapToList";
-    return map;
-}
-
-TExprNode::TPtr NormalizeCallables(TExprBase node, TExprContext& ctx, const TKqpAnalyzeResults& analyzeResults) {
+            .List(map) 
+            .Done(); 
+    } 
+ 
+    YQL_CLOG(INFO, ProviderKqp) << "RebuildMapToList"; 
+    return map; 
+} 
+ 
+TExprNode::TPtr NormalizeCallables(TExprBase node, TExprContext& ctx, const TKqpAnalyzeResults& analyzeResults) { 
     if (!analyzeResults.CallableToExecRootsMap.contains(node.Raw())) {
         return node.Ptr();
-    }
-
+    } 
+ 
     if (node.Maybe<TCoMap>() || node.Maybe<TCoFlatMap>()) {
         return node.Maybe<TCoMap>()
             ? RebuildMapToList<TCoMap>(node.Cast<TCoMap>(), ctx).Ptr()
             : RebuildMapToList<TCoFlatMap>(node.Cast<TCoFlatMap>(), ctx).Ptr();
-    }
-
+    } 
+ 
     if (auto filter = node.Maybe<TCoFilter>()) {
-        YQL_CLOG(INFO, ProviderKqp) << "NormalizeCallables: Filter";
+        YQL_CLOG(INFO, ProviderKqp) << "NormalizeCallables: Filter"; 
         return Build<TCoFlatMap>(ctx, node.Pos())
-            .Input(filter.Cast().Input())
-            .Lambda()
-                .Args({"item"})
+            .Input(filter.Cast().Input()) 
+            .Lambda() 
+                .Args({"item"}) 
                 .Body<TCoIf>()
-                    .Predicate<TExprApplier>()
-                        .Apply(filter.Cast().Lambda())
-                        .With(0, "item")
-                        .Build()
+                    .Predicate<TExprApplier>() 
+                        .Apply(filter.Cast().Lambda()) 
+                        .With(0, "item") 
+                        .Build() 
                     .ThenValue<TCoJust>()
                         .Input("item")
                         .Build()
@@ -88,23 +88,23 @@ TExprNode::TPtr NormalizeCallables(TExprBase node, TExprContext& ctx, const TKqp
                                 .Build()
                             .Build()
                         .Build()
-                .Build()
+                .Build() 
             .Build()
-            .Done()
-            .Ptr();
-    }
-
-    return node.Ptr();
-}
-
-TExprNode::TPtr ToListOverToOptional(TExprBase node, TExprContext& ctx) {
-    Y_UNUSED(ctx);
-
+            .Done() 
+            .Ptr(); 
+    } 
+ 
+    return node.Ptr(); 
+} 
+ 
+TExprNode::TPtr ToListOverToOptional(TExprBase node, TExprContext& ctx) { 
+    Y_UNUSED(ctx); 
+ 
     if (auto toList = node.Maybe<TCoToList>()) {
         if (auto toOpt = toList.Cast().Optional().Maybe<TCoToOptional>()) {
-            YQL_CLOG(INFO, ProviderKqp) << "ToListOverToOptional";
-            return toOpt.Cast().List().Ptr();
-        }
+            YQL_CLOG(INFO, ProviderKqp) << "ToListOverToOptional"; 
+            return toOpt.Cast().List().Ptr(); 
+        } 
         if (auto toOpt = toList.Cast().Optional().Maybe<TCoHead>()) {
             YQL_CLOG(INFO, ProviderKqp) << "ToListOverHead";
             return toOpt.Cast().Input().Ptr();
@@ -113,286 +113,286 @@ TExprNode::TPtr ToListOverToOptional(TExprBase node, TExprContext& ctx) {
             YQL_CLOG(INFO, ProviderKqp) << "ToListOverLast";
             return toOpt.Cast().Input().Ptr();
         }
-    }
-
-    return node.Ptr();
-}
-
-template<typename TInner, typename TOuter>
+    } 
+ 
+    return node.Ptr(); 
+} 
+ 
+template<typename TInner, typename TOuter> 
 TExprBase SplitMap(TExprBase input, TCoLambda lambda, TExprContext& ctx, const TVector<TExprBase> execRoots,
-    const TKqpAnalyzeResults& analyzeResults)
-{
-    auto exprRootsTuple = Build<TExprList>(ctx, lambda.Pos())
-        .Add(execRoots)
-        .Done();
-
-    auto isSameScope = [lambda] (const TNodeInfo* nodeInfo) {
-        if (!nodeInfo) {
-            return true;
-        }
-
-        if (!nodeInfo->Scope || nodeInfo->Scope->Lambda.Raw() != lambda.Raw()) {
-            return false;
-        }
-
-        return true;
-    };
-
+    const TKqpAnalyzeResults& analyzeResults) 
+{ 
+    auto exprRootsTuple = Build<TExprList>(ctx, lambda.Pos()) 
+        .Add(execRoots) 
+        .Done(); 
+ 
+    auto isSameScope = [lambda] (const TNodeInfo* nodeInfo) { 
+        if (!nodeInfo) { 
+            return true; 
+        } 
+ 
+        if (!nodeInfo->Scope || nodeInfo->Scope->Lambda.Raw() != lambda.Raw()) { 
+            return false; 
+        } 
+ 
+        return true; 
+    }; 
+ 
     THashSet<const TExprNode*> innerNodes;
-    innerNodes.insert(lambda.Args().Arg(0).Raw());
-    VisitExpr(exprRootsTuple.Ptr(),
-        [&innerNodes, &isSameScope, &analyzeResults] (const TExprNode::TPtr& node) {
-            auto* nodeInfo = analyzeResults.ExprToNodeInfoMap.FindPtr(node.Get());
-
-            if (!isSameScope(nodeInfo)) {
-                return false;
-            }
-
-            if (node->IsCallable()) {
-                innerNodes.insert(node.Get());
-            }
-
-            return true;
-        });
-
+    innerNodes.insert(lambda.Args().Arg(0).Raw()); 
+    VisitExpr(exprRootsTuple.Ptr(), 
+        [&innerNodes, &isSameScope, &analyzeResults] (const TExprNode::TPtr& node) { 
+            auto* nodeInfo = analyzeResults.ExprToNodeInfoMap.FindPtr(node.Get()); 
+ 
+            if (!isSameScope(nodeInfo)) { 
+                return false; 
+            } 
+ 
+            if (node->IsCallable()) { 
+                innerNodes.insert(node.Get()); 
+            } 
+ 
+            return true; 
+        }); 
+ 
     THashMap<const TExprNode*, TExprBase> jointsMap;
-    for (TExprBase root : execRoots) {
-        jointsMap.insert(std::make_pair(root.Raw(), root));
-    }
-
-    VisitExpr(lambda.Body().Ptr(),
-        [&innerNodes, &jointsMap, isSameScope, &analyzeResults] (const TExprNode::TPtr& node) {
-            auto* nodeInfo = analyzeResults.ExprToNodeInfoMap.FindPtr(node.Get());
-            YQL_ENSURE(nodeInfo);
-
+    for (TExprBase root : execRoots) { 
+        jointsMap.insert(std::make_pair(root.Raw(), root)); 
+    } 
+ 
+    VisitExpr(lambda.Body().Ptr(), 
+        [&innerNodes, &jointsMap, isSameScope, &analyzeResults] (const TExprNode::TPtr& node) { 
+            auto* nodeInfo = analyzeResults.ExprToNodeInfoMap.FindPtr(node.Get()); 
+            YQL_ENSURE(nodeInfo); 
+ 
             YQL_ENSURE(node->GetTypeAnn());
-            bool isComputable = node->IsComputable();
-
+            bool isComputable = node->IsComputable(); 
+ 
             if (innerNodes.contains(node.Get())) {
-                if (isComputable) {
-                    jointsMap.insert(std::make_pair(node.Get(), TExprBase(node)));
-                }
-
-                return false;
-            }
-
-            bool hasInnerChild = false;
-            if (isComputable && !node->Children().empty() && nodeInfo->IsExecutable) {
-                for (const auto& child : node->Children()) {
+                if (isComputable) { 
+                    jointsMap.insert(std::make_pair(node.Get(), TExprBase(node))); 
+                } 
+ 
+                return false; 
+            } 
+ 
+            bool hasInnerChild = false; 
+            if (isComputable && !node->Children().empty() && nodeInfo->IsExecutable) { 
+                for (const auto& child : node->Children()) { 
                     if (jointsMap.contains(child.Get())) {
-                        return true;
-                    }
-
+                        return true; 
+                    } 
+ 
                     bool innerChild = innerNodes.contains(child.Get());
-                    hasInnerChild = hasInnerChild | innerChild;
-
+                    hasInnerChild = hasInnerChild | innerChild; 
+ 
                     YQL_ENSURE(child->GetTypeAnn());
                     if (child->GetTypeAnn()->IsComputable() && !innerChild) {
-                        return true;
-                    }
-                }
-
-                if (hasInnerChild) {
-                    jointsMap.insert(std::make_pair(node.Get(), TExprBase(node)));
-                    return false;
-                }
-            }
-
-            return true;
-        });
-
+                        return true; 
+                    } 
+                } 
+ 
+                if (hasInnerChild) { 
+                    jointsMap.insert(std::make_pair(node.Get(), TExprBase(node))); 
+                    return false; 
+                } 
+            } 
+ 
+            return true; 
+        }); 
+ 
     TVector<TExprBase> jointNodes;
     jointNodes.reserve(jointsMap.size());
-    for (auto& pair : jointsMap) {
-        jointNodes.push_back(pair.second);
-    }
-
-    auto innerLambdaBody = Build<TExprList>(ctx, lambda.Pos())
-        .Add(jointNodes)
-        .Done();
-
+    for (auto& pair : jointsMap) { 
+        jointNodes.push_back(pair.second); 
+    } 
+ 
+    auto innerLambdaBody = Build<TExprList>(ctx, lambda.Pos()) 
+        .Add(jointNodes) 
+        .Done(); 
+ 
     auto innerLambda = Build<TCoLambda>(ctx, lambda.Pos())
-        .Args({"item"})
-        .Body<TExprApplier>()
-            .Apply(innerLambdaBody)
-            .With(lambda.Args().Arg(0), "item")
-            .Build()
-        .Done();
-
+        .Args({"item"}) 
+        .Body<TExprApplier>() 
+            .Apply(innerLambdaBody) 
+            .With(lambda.Args().Arg(0), "item") 
+            .Build() 
+        .Done(); 
+ 
     TCoArgument outerLambdaArg = Build<TCoArgument>(ctx, lambda.Pos())
-        .Name("item")
-        .Done();
-
-    TNodeOnNodeOwnedMap replaceMap;
-    for (size_t i = 0; i < jointNodes.size(); ++i) {
+        .Name("item") 
+        .Done(); 
+ 
+    TNodeOnNodeOwnedMap replaceMap; 
+    for (size_t i = 0; i < jointNodes.size(); ++i) { 
         auto node = Build<TCoNth>(ctx, lambda.Pos())
-            .Tuple(outerLambdaArg)
-            .Index().Build(i)
-            .Done();
-
-        replaceMap.emplace(jointNodes[i].Raw(), node.Ptr());
-    }
-
+            .Tuple(outerLambdaArg) 
+            .Index().Build(i) 
+            .Done(); 
+ 
+        replaceMap.emplace(jointNodes[i].Raw(), node.Ptr()); 
+    } 
+ 
     auto outerLambdaBody = ctx.ReplaceNodes(lambda.Body().Ptr(), replaceMap);
     auto outerLambda = Build<TCoLambda>(ctx, lambda.Pos())
-        .Args({outerLambdaArg})
-        .Body(TExprBase(outerLambdaBody))
-        .Done();
-
-    return Build<TOuter>(ctx, input.Pos())
-        .template Input<TInner>()
-            .Input(input)
-            .Lambda(innerLambda)
-            .Build()
-        .Lambda(outerLambda)
-        .Done();
-}
-
+        .Args({outerLambdaArg}) 
+        .Body(TExprBase(outerLambdaBody)) 
+        .Done(); 
+ 
+    return Build<TOuter>(ctx, input.Pos()) 
+        .template Input<TInner>() 
+            .Input(input) 
+            .Lambda(innerLambda) 
+            .Build() 
+        .Lambda(outerLambda) 
+        .Done(); 
+} 
+ 
 TExprNode::TPtr SplitMap(TExprBase mapNode, TExprContext& ctx, const TVector<TExprBase>& execRoots,
-    const TKqpAnalyzeResults& analyzeResults)
-{
+    const TKqpAnalyzeResults& analyzeResults) 
+{ 
     YQL_ENSURE(mapNode.Ptr()->GetTypeAnn()->GetKind() == ETypeAnnotationKind::List);
-
+ 
     if (auto map = mapNode.Maybe<TCoMap>()) {
-        YQL_CLOG(INFO, ProviderKqp) << "SplitMap: Map, MapParameter";
+        YQL_CLOG(INFO, ProviderKqp) << "SplitMap: Map, MapParameter"; 
         return SplitMap<TCoMap, TKiMapParameter>(map.Cast().Input(), map.Cast().Lambda(), ctx, execRoots,
-            analyzeResults).Ptr();
-    }
-
+            analyzeResults).Ptr(); 
+    } 
+ 
     if (auto map = mapNode.Maybe<TCoFlatMap>()) {
-        YQL_CLOG(INFO, ProviderKqp) << "SplitMap: Map, FlatMapParameter";
+        YQL_CLOG(INFO, ProviderKqp) << "SplitMap: Map, FlatMapParameter"; 
         YQL_ENSURE(map.Cast().Lambda().Ptr()->GetTypeAnn()->GetKind() == ETypeAnnotationKind::List);
         return SplitMap<TCoMap, TKiFlatMapParameter>(map.Cast().Input(), map.Cast().Lambda(), ctx, execRoots,
-            analyzeResults).Ptr();
-    }
-
-    if (auto map = mapNode.Maybe<TKiMapParameter>()) {
-        YQL_CLOG(INFO, ProviderKqp) << "SplitMap: MapParameter, MapParameter";
-        return SplitMap<TKiMapParameter, TKiMapParameter>(map.Cast().Input(), map.Cast().Lambda(),
-            ctx, execRoots, analyzeResults).Ptr();
-    }
-
-    if (auto map = mapNode.Maybe<TKiFlatMapParameter>()) {
-        YQL_CLOG(INFO, ProviderKqp) << "SplitMap: MapParameter, FlatMapParameter";
-        return SplitMap<TKiMapParameter, TKiFlatMapParameter>(map.Cast().Input(), map.Cast().Lambda(),
-            ctx, execRoots, analyzeResults).Ptr();
-    }
-
-    YQL_ENSURE(false);
-    return nullptr;
-}
-
-TExprNode::TPtr UnnestExecutionRoots(TExprBase node, TExprContext& ctx, const TKqpAnalyzeResults& analyzeResults) {
-    auto execRoots = analyzeResults.CallableToExecRootsMap.FindPtr(node.Raw());
-
-    if (!execRoots) {
-        return node.Ptr();
-    }
-
-    if (auto maybeMap = node.Maybe<TCoMap>()) {
-        auto map = maybeMap.Cast();
-        if (map.Input().Maybe<TCoParameter>()) {
-            YQL_CLOG(INFO, ProviderKqp) << "UnnestExecutionRoots: Map parameter";
-            return Build<TKiMapParameter>(ctx, node.Pos())
-                .Input(map.Input())
-                .Lambda(map.Lambda())
-                .Done()
-                .Ptr();
-        }
-    }
-
-    if (auto maybeFlatMap = node.Maybe<TCoFlatMap>()) {
-        auto flatMap = maybeFlatMap.Cast();
-        if (flatMap.Input().Maybe<TCoParameter>()) {
-            YQL_CLOG(INFO, ProviderKqp) << "UnnestExecutionRoots: FlatMap parameter";
-            return Build<TKiFlatMapParameter>(ctx, node.Pos())
-                .Input(flatMap.Input())
-                .Lambda(flatMap.Lambda())
-                .Done()
-                .Ptr();
-        }
-    }
-
+            analyzeResults).Ptr(); 
+    } 
+ 
+    if (auto map = mapNode.Maybe<TKiMapParameter>()) { 
+        YQL_CLOG(INFO, ProviderKqp) << "SplitMap: MapParameter, MapParameter"; 
+        return SplitMap<TKiMapParameter, TKiMapParameter>(map.Cast().Input(), map.Cast().Lambda(), 
+            ctx, execRoots, analyzeResults).Ptr(); 
+    } 
+ 
+    if (auto map = mapNode.Maybe<TKiFlatMapParameter>()) { 
+        YQL_CLOG(INFO, ProviderKqp) << "SplitMap: MapParameter, FlatMapParameter"; 
+        return SplitMap<TKiMapParameter, TKiFlatMapParameter>(map.Cast().Input(), map.Cast().Lambda(), 
+            ctx, execRoots, analyzeResults).Ptr(); 
+    } 
+ 
+    YQL_ENSURE(false); 
+    return nullptr; 
+} 
+ 
+TExprNode::TPtr UnnestExecutionRoots(TExprBase node, TExprContext& ctx, const TKqpAnalyzeResults& analyzeResults) { 
+    auto execRoots = analyzeResults.CallableToExecRootsMap.FindPtr(node.Raw()); 
+ 
+    if (!execRoots) { 
+        return node.Ptr(); 
+    } 
+ 
+    if (auto maybeMap = node.Maybe<TCoMap>()) { 
+        auto map = maybeMap.Cast(); 
+        if (map.Input().Maybe<TCoParameter>()) { 
+            YQL_CLOG(INFO, ProviderKqp) << "UnnestExecutionRoots: Map parameter"; 
+            return Build<TKiMapParameter>(ctx, node.Pos()) 
+                .Input(map.Input()) 
+                .Lambda(map.Lambda()) 
+                .Done() 
+                .Ptr(); 
+        } 
+    } 
+ 
+    if (auto maybeFlatMap = node.Maybe<TCoFlatMap>()) { 
+        auto flatMap = maybeFlatMap.Cast(); 
+        if (flatMap.Input().Maybe<TCoParameter>()) { 
+            YQL_CLOG(INFO, ProviderKqp) << "UnnestExecutionRoots: FlatMap parameter"; 
+            return Build<TKiFlatMapParameter>(ctx, node.Pos()) 
+                .Input(flatMap.Input()) 
+                .Lambda(flatMap.Lambda()) 
+                .Done() 
+                .Ptr(); 
+        } 
+    } 
+ 
     if (node.Maybe<TCoMap>() ||
         node.Maybe<TCoFlatMap>() ||
-        node.Maybe<TKiMapParameter>() ||
-        node.Maybe<TKiFlatMapParameter>())
-    {
-        return SplitMap(node, ctx, *execRoots, analyzeResults);
-    }
-
+        node.Maybe<TKiMapParameter>() || 
+        node.Maybe<TKiFlatMapParameter>()) 
+    { 
+        return SplitMap(node, ctx, *execRoots, analyzeResults); 
+    } 
+ 
     ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-        << "Can't rewrite callable for KQP execution: " << node.Ptr()->Content()));
-    YQL_ENSURE(false);
-    return nullptr;
-}
-
-class TKqpRewriteTransformer : public TSyncTransformerBase {
-public:
-    TKqpRewriteTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : TransformCtx(transformCtx) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        const auto& analyzeResults = TransformCtx->AnalyzeResults;
-
-        if (analyzeResults.CallableToExecRootsMap.empty()) {
-            return TStatus::Ok;
-        }
-
+        << "Can't rewrite callable for KQP execution: " << node.Ptr()->Content())); 
+    YQL_ENSURE(false); 
+    return nullptr; 
+} 
+ 
+class TKqpRewriteTransformer : public TSyncTransformerBase { 
+public: 
+    TKqpRewriteTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : TransformCtx(transformCtx) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        const auto& analyzeResults = TransformCtx->AnalyzeResults; 
+ 
+        if (analyzeResults.CallableToExecRootsMap.empty()) { 
+            return TStatus::Ok; 
+        } 
+ 
         TOptimizeExprSettings optSettings(nullptr);
-        optSettings.VisitChanges = true;
-        TStatus status = TStatus::Error;
-
-        status = OptimizeExpr(input, output,
-            [&analyzeResults](const TExprNode::TPtr& input, TExprContext& ctx) {
-                auto ret = input;
-                TExprBase node(input);
-
-                ret = NormalizeCallables(node, ctx, analyzeResults);
-                if (ret != input) {
-                    return ret;
-                }
-
-                ret = ToListOverToOptional(node, ctx);
+        optSettings.VisitChanges = true; 
+        TStatus status = TStatus::Error; 
+ 
+        status = OptimizeExpr(input, output, 
+            [&analyzeResults](const TExprNode::TPtr& input, TExprContext& ctx) { 
+                auto ret = input; 
+                TExprBase node(input); 
+ 
+                ret = NormalizeCallables(node, ctx, analyzeResults); 
                 if (ret != input) {
-                    return ret;
-                }
-
-                return ret;
-            }, ctx, optSettings);
-        YQL_ENSURE(status == TStatus::Ok);
-
+                    return ret; 
+                } 
+ 
+                ret = ToListOverToOptional(node, ctx); 
+                if (ret != input) { 
+                    return ret; 
+                } 
+ 
+                return ret; 
+            }, ctx, optSettings); 
+        YQL_ENSURE(status == TStatus::Ok); 
+ 
         if (input != output) {
-            return TStatus(TStatus::Repeat, true);
-        }
-
-        status = OptimizeExpr(input, output,
+            return TStatus(TStatus::Repeat, true); 
+        } 
+ 
+        status = OptimizeExpr(input, output, 
             [&analyzeResults](const TExprNode::TPtr& input, TExprContext& ctx) {
                 auto ret = input;
                 TExprBase node(input);
-
-                ret = UnnestExecutionRoots(node, ctx, analyzeResults);
+ 
+                ret = UnnestExecutionRoots(node, ctx, analyzeResults); 
                 if (ret != input) {
-                    return ret;
-                }
-
-                return ret;
-            }, ctx, optSettings);
-        YQL_ENSURE(status == TStatus::Ok);
-
+                    return ret; 
+                } 
+ 
+                return ret; 
+            }, ctx, optSettings); 
+        YQL_ENSURE(status == TStatus::Ok); 
+ 
         YQL_ENSURE(input != output);
-        return TStatus(TStatus::Repeat, true);
-    }
-
-private:
-    TIntrusivePtr<TKqlTransformContext> TransformCtx;
-};
-
-} // namespace
-
-TAutoPtr<IGraphTransformer> CreateKqpRewriteTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx) {
-    return new TKqpRewriteTransformer(transformCtx);
-}
-
+        return TStatus(TStatus::Repeat, true); 
+    } 
+ 
+private: 
+    TIntrusivePtr<TKqlTransformContext> TransformCtx; 
+}; 
+ 
+} // namespace 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpRewriteTransformer(TIntrusivePtr<TKqlTransformContext> transformCtx) { 
+    return new TKqpRewriteTransformer(transformCtx); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/kqp_query_simplify.cpp b/ydb/core/kqp/prepare/kqp_query_simplify.cpp
index d8fefeb939..e99d95bcd5 100644
--- a/ydb/core/kqp/prepare/kqp_query_simplify.cpp
+++ b/ydb/core/kqp/prepare/kqp_query_simplify.cpp
@@ -1,264 +1,264 @@
-#include "kqp_prepare_impl.h"
-
+#include "kqp_prepare_impl.h" 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
-
+ 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-
-namespace {
-
-template<typename TMapNode>
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+template<typename TMapNode> 
 TExprBase BuildMap(TExprBase input, TExprBase body, TCoArgument arg, TExprContext& ctx) {
-    return Build<TMapNode>(ctx, input.Pos())
-        .Input(input)
-        .Lambda()
-            .Args({"item"})
-            .template Body<TExprApplier>()
-                .Apply(body)
-                .With(arg, "item")
-                .Build()
-            .Build()
-        .Done();
-}
-
-TExprNode::TPtr ExtractFilter(TExprBase node, TExprContext& ctx) {
+    return Build<TMapNode>(ctx, input.Pos()) 
+        .Input(input) 
+        .Lambda() 
+            .Args({"item"}) 
+            .template Body<TExprApplier>() 
+                .Apply(body) 
+                .With(arg, "item") 
+                .Build() 
+            .Build() 
+        .Done(); 
+} 
+ 
+TExprNode::TPtr ExtractFilter(TExprBase node, TExprContext& ctx) { 
     if (!node.Maybe<TCoFlatMap>()) {
-        return node.Ptr();
-    }
-
+        return node.Ptr(); 
+    } 
+ 
     auto flatmap = node.Cast<TCoFlatMap>();
-    auto flatmapArg = flatmap.Lambda().Args().Arg(0);
-
+    auto flatmapArg = flatmap.Lambda().Args().Arg(0); 
+ 
     if (flatmap.Input().Ref().GetTypeAnn()->GetKind() != ETypeAnnotationKind::List) {
-        return node.Ptr();
-    }
-
+        return node.Ptr(); 
+    } 
+ 
     if (auto maybeConditional = flatmap.Lambda().Body().Maybe<TCoConditionalValueBase>()) {
-        auto conditional = maybeConditional.Cast();
-
-        auto blacklistedNode = FindNode(conditional.Predicate().Ptr(), [](const TExprNode::TPtr& exprNode) {
-            auto node = TExprBase(exprNode);
-
+        auto conditional = maybeConditional.Cast(); 
+ 
+        auto blacklistedNode = FindNode(conditional.Predicate().Ptr(), [](const TExprNode::TPtr& exprNode) { 
+            auto node = TExprBase(exprNode); 
+ 
             if (node.Maybe<TKiSelectRow>() || node.Maybe<TKiSelectRangeBase>()) {
-                return true;
-            }
-
-            return false;
-        });
-
-        if (blacklistedNode) {
-            return node.Ptr();
-        }
-
+                return true; 
+            } 
+ 
+            return false; 
+        }); 
+ 
+        if (blacklistedNode) { 
+            return node.Ptr(); 
+        } 
+ 
         auto filter = Build<TCoFilter>(ctx, node.Pos())
-            .Input(flatmap.Input())
-            .Lambda()
-                .Args({"item"})
-                .Body<TExprApplier>()
-                    .Apply(conditional.Predicate())
-                    .With(flatmapArg, "item")
-                    .Build()
-                .Build()
-            .Done();
-
-        auto value = conditional.Value();
-
+            .Input(flatmap.Input()) 
+            .Lambda() 
+                .Args({"item"}) 
+                .Body<TExprApplier>() 
+                    .Apply(conditional.Predicate()) 
+                    .With(flatmapArg, "item") 
+                    .Build() 
+                .Build() 
+            .Done(); 
+ 
+        auto value = conditional.Value(); 
+ 
         if (conditional.Maybe<TCoListIf>() || conditional.Maybe<TCoOptionalIf>()) {
             return BuildMap<TCoMap>(filter, value, flatmapArg, ctx).Ptr();
-        } else {
+        } else { 
             return BuildMap<TCoFlatMap>(filter, value, flatmapArg, ctx).Ptr();
-        }
-    }
-
-    if (auto maybeConditional = flatmap.Lambda().Body().Maybe<TCoIf>()) {
-        auto conditional = maybeConditional.Cast();
-
-        auto elseValue = conditional.ElseValue();
-        if (!elseValue.Maybe<TCoList>() && !elseValue.Maybe<TCoNothing>()) {
-            return node.Ptr();
-        }
-
-        auto blacklistedNode = FindNode(conditional.Predicate().Ptr(), [](const TExprNode::TPtr& exprNode) {
-            auto node = TExprBase(exprNode);
-
+        } 
+    } 
+ 
+    if (auto maybeConditional = flatmap.Lambda().Body().Maybe<TCoIf>()) { 
+        auto conditional = maybeConditional.Cast(); 
+ 
+        auto elseValue = conditional.ElseValue(); 
+        if (!elseValue.Maybe<TCoList>() && !elseValue.Maybe<TCoNothing>()) { 
+            return node.Ptr(); 
+        } 
+ 
+        auto blacklistedNode = FindNode(conditional.Predicate().Ptr(), [](const TExprNode::TPtr& exprNode) { 
+            auto node = TExprBase(exprNode); 
+ 
             if (node.Maybe<TKiSelectRow>() || node.Maybe<TKiSelectRangeBase>()) {
-                return true;
-            }
-
-            return false;
-        });
-
-        if (blacklistedNode) {
-            return node.Ptr();
-        }
-
-        auto filter = Build<TCoFilter>(ctx, node.Pos())
-            .Input(flatmap.Input())
-            .Lambda()
-                .Args({"item"})
-                .Body<TExprApplier>()
-                    .Apply(conditional.Predicate())
-                    .With(flatmapArg, "item")
-                    .Build()
-                .Build()
-            .Done();
-
-        auto value = conditional.ThenValue();
-
-        return BuildMap<TCoFlatMap>(filter, value, flatmapArg, ctx).Ptr();
-    }
-
-    return node.Ptr();
-}
-
-TExprNode::TPtr ExtractCombineByKeyPreMap(TExprBase node, TExprContext& ctx) {
+                return true; 
+            } 
+ 
+            return false; 
+        }); 
+ 
+        if (blacklistedNode) { 
+            return node.Ptr(); 
+        } 
+ 
+        auto filter = Build<TCoFilter>(ctx, node.Pos()) 
+            .Input(flatmap.Input()) 
+            .Lambda() 
+                .Args({"item"}) 
+                .Body<TExprApplier>() 
+                    .Apply(conditional.Predicate()) 
+                    .With(flatmapArg, "item") 
+                    .Build() 
+                .Build() 
+            .Done(); 
+ 
+        auto value = conditional.ThenValue(); 
+ 
+        return BuildMap<TCoFlatMap>(filter, value, flatmapArg, ctx).Ptr(); 
+    } 
+ 
+    return node.Ptr(); 
+} 
+ 
+TExprNode::TPtr ExtractCombineByKeyPreMap(TExprBase node, TExprContext& ctx) { 
     if (auto maybeCombine = node.Maybe<TCoCombineByKey>()) {
-        auto combine = maybeCombine.Cast();
-        if (!IsKqlPureLambda(combine.PreMapLambda())) {
+        auto combine = maybeCombine.Cast(); 
+        if (!IsKqlPureLambda(combine.PreMapLambda())) { 
             return Build<TCoCombineByKey>(ctx, node.Pos())
                 .Input<TCoMap>()
-                    .Input(combine.Input())
-                    .Lambda(combine.PreMapLambda())
-                    .Build()
-                .PreMapLambda()
-                    .Args({"item"})
-                    .Body("item")
-                    .Build()
-                .KeySelectorLambda(combine.KeySelectorLambda())
-                .InitHandlerLambda(combine.InitHandlerLambda())
-                .UpdateHandlerLambda(combine.UpdateHandlerLambda())
-                .FinishHandlerLambda(combine.FinishHandlerLambda())
-                .Done()
-                .Ptr();
-        }
-    }
-
-    return node.Ptr();
-}
-
+                    .Input(combine.Input()) 
+                    .Lambda(combine.PreMapLambda()) 
+                    .Build() 
+                .PreMapLambda() 
+                    .Args({"item"}) 
+                    .Body("item") 
+                    .Build() 
+                .KeySelectorLambda(combine.KeySelectorLambda()) 
+                .InitHandlerLambda(combine.InitHandlerLambda()) 
+                .UpdateHandlerLambda(combine.UpdateHandlerLambda()) 
+                .FinishHandlerLambda(combine.FinishHandlerLambda()) 
+                .Done() 
+                .Ptr(); 
+        } 
+    } 
+ 
+    return node.Ptr(); 
+} 
+ 
 template <class TPartitionsType>
-TExprNode::TPtr ExtractPartitionByKeyListHandler(TExprBase node, TExprContext& ctx) {
+TExprNode::TPtr ExtractPartitionByKeyListHandler(TExprBase node, TExprContext& ctx) { 
     if (auto maybePartition = node.Maybe<TPartitionsType>()) {
-        auto partition = maybePartition.Cast();
-        if (!IsKqlPureLambda(partition.ListHandlerLambda())) {
+        auto partition = maybePartition.Cast(); 
+        if (!IsKqlPureLambda(partition.ListHandlerLambda())) { 
             auto newPartition = Build<TPartitionsType>(ctx, node.Pos())
-                .Input(partition.Input())
-                .KeySelectorLambda(partition.KeySelectorLambda())
-                .SortDirections(partition.SortDirections())
-                .SortKeySelectorLambda(partition.SortKeySelectorLambda())
-                .ListHandlerLambda()
-                    .Args({"list"})
-                    .Body("list")
-                    .Build()
-                .Done();
-
-            return Build<TExprApplier>(ctx, node.Pos())
-                .Apply(partition.ListHandlerLambda().Body())
-                .With(partition.ListHandlerLambda().Args().Arg(0), newPartition)
-                .Done()
-                .Ptr();
-        }
-    }
-
-    return node.Ptr();
-}
-
-template<typename TMapType>
-TExprNode::TPtr MergeMapsWithSameLambda(TExprBase node, TExprContext& ctx) {
-    if (!node.Maybe<TCoExtend>()) {
-        return node.Ptr();
-    }
-
-    bool hasInputsToMerge = false;
-    TVector<std::pair<TMaybeNode<TCoLambda>, TVector<TExprBase>>> inputs;
-
-    auto extend = node.Cast<TCoExtend>();
-    for (const auto& list : extend) {
-        TMaybeNode<TExprBase> input;
-        TMaybeNode<TCoLambda> lambda;
-
-        bool buildList = false;
-        if (auto maybeMap = list.Maybe<TMapType>()) {
-            lambda = maybeMap.Cast().Lambda();
-            input = maybeMap.Cast().Input();
-
-            YQL_ENSURE(input.Ref().GetTypeAnn());
-            buildList = input.Cast().Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Optional;
-        } else if (auto maybeMap = list.Maybe<TCoToList>().Optional().Maybe<TMapType>()) {
-            lambda = maybeMap.Cast().Lambda();
-            input = maybeMap.Cast().Input();
-            buildList = true;
+                .Input(partition.Input()) 
+                .KeySelectorLambda(partition.KeySelectorLambda()) 
+                .SortDirections(partition.SortDirections()) 
+                .SortKeySelectorLambda(partition.SortKeySelectorLambda()) 
+                .ListHandlerLambda() 
+                    .Args({"list"}) 
+                    .Body("list") 
+                    .Build() 
+                .Done(); 
+ 
+            return Build<TExprApplier>(ctx, node.Pos()) 
+                .Apply(partition.ListHandlerLambda().Body()) 
+                .With(partition.ListHandlerLambda().Args().Arg(0), newPartition) 
+                .Done() 
+                .Ptr(); 
+        } 
+    } 
+ 
+    return node.Ptr(); 
+} 
+ 
+template<typename TMapType> 
+TExprNode::TPtr MergeMapsWithSameLambda(TExprBase node, TExprContext& ctx) { 
+    if (!node.Maybe<TCoExtend>()) { 
+        return node.Ptr(); 
+    } 
+
+    bool hasInputsToMerge = false; 
+    TVector<std::pair<TMaybeNode<TCoLambda>, TVector<TExprBase>>> inputs; 
+
+    auto extend = node.Cast<TCoExtend>(); 
+    for (const auto& list : extend) { 
+        TMaybeNode<TExprBase> input; 
+        TMaybeNode<TCoLambda> lambda; 
+ 
+        bool buildList = false; 
+        if (auto maybeMap = list.Maybe<TMapType>()) { 
+            lambda = maybeMap.Cast().Lambda(); 
+            input = maybeMap.Cast().Input(); 
+ 
+            YQL_ENSURE(input.Ref().GetTypeAnn()); 
+            buildList = input.Cast().Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Optional; 
+        } else if (auto maybeMap = list.Maybe<TCoToList>().Optional().Maybe<TMapType>()) { 
+            lambda = maybeMap.Cast().Lambda(); 
+            input = maybeMap.Cast().Input(); 
+            buildList = true; 
         }
 
-        if (buildList) {
-            input = Build<TCoToList>(ctx, node.Pos())
-                .Optional(input.Cast())
+        if (buildList) { 
+            input = Build<TCoToList>(ctx, node.Pos()) 
+                .Optional(input.Cast()) 
                 .Done();
         }
 
-        if (lambda && !IsKqlPureLambda(lambda.Cast())) {
-            if (!inputs.empty() && inputs.back().first && inputs.back().first.Cast().Raw() == lambda.Cast().Raw()) {
-                inputs.back().second.push_back(input.Cast());
-                hasInputsToMerge = true;
-            } else {
-                inputs.emplace_back(lambda, TVector<TExprBase>{input.Cast()});
-            }
+        if (lambda && !IsKqlPureLambda(lambda.Cast())) { 
+            if (!inputs.empty() && inputs.back().first && inputs.back().first.Cast().Raw() == lambda.Cast().Raw()) { 
+                inputs.back().second.push_back(input.Cast()); 
+                hasInputsToMerge = true; 
+            } else { 
+                inputs.emplace_back(lambda, TVector<TExprBase>{input.Cast()}); 
+            } 
         } else {
-            inputs.emplace_back(TMaybeNode<TCoLambda>(), TVector<TExprBase>{list});
+            inputs.emplace_back(TMaybeNode<TCoLambda>(), TVector<TExprBase>{list}); 
         }
     }
-
-    if (!hasInputsToMerge) {
-        return node.Ptr();
-    }
-
-    TVector<TExprBase> merged;
-    for (const auto& pair : inputs) {
-        const auto& lambda = pair.first;
-        const auto& lists = pair.second;
-
-        if (lambda) {
-            YQL_ENSURE(!lists.empty());
-            auto mergedInput = lists.front();
-
-            if (lists.size() > 1) {
-                mergedInput = Build<TCoExtend>(ctx, node.Pos())
-                    .Add(lists)
-                    .Done();
-            }
-
-            auto mergedMap = Build<TMapType>(ctx, node.Pos())
-                .Input(mergedInput)
-                .Lambda()
-                    .Args({"item"})
-                    .template Body<TExprApplier>()
-                        .Apply(lambda.Cast())
-                        .With(0, "item")
-                        .Build()
-                    .Build()
-                .Done();
-
-            merged.push_back(mergedMap);
-        } else {
-            YQL_ENSURE(lists.size() == 1);
-            merged.push_back(lists.front());
-        }
-    }
-
-    YQL_ENSURE(!merged.empty());
-    auto ret = merged.front();
-    if (merged.size() > 1) {
-        ret = Build<TCoExtend>(ctx, node.Pos())
-            .Add(merged)
-            .Done();
-    }
-
-    return ret.Ptr();
+ 
+    if (!hasInputsToMerge) { 
+        return node.Ptr(); 
+    } 
+ 
+    TVector<TExprBase> merged; 
+    for (const auto& pair : inputs) { 
+        const auto& lambda = pair.first; 
+        const auto& lists = pair.second; 
+ 
+        if (lambda) { 
+            YQL_ENSURE(!lists.empty()); 
+            auto mergedInput = lists.front(); 
+ 
+            if (lists.size() > 1) { 
+                mergedInput = Build<TCoExtend>(ctx, node.Pos()) 
+                    .Add(lists) 
+                    .Done(); 
+            } 
+ 
+            auto mergedMap = Build<TMapType>(ctx, node.Pos()) 
+                .Input(mergedInput) 
+                .Lambda() 
+                    .Args({"item"}) 
+                    .template Body<TExprApplier>() 
+                        .Apply(lambda.Cast()) 
+                        .With(0, "item") 
+                        .Build() 
+                    .Build() 
+                .Done(); 
+ 
+            merged.push_back(mergedMap); 
+        } else { 
+            YQL_ENSURE(lists.size() == 1); 
+            merged.push_back(lists.front()); 
+        } 
+    } 
+ 
+    YQL_ENSURE(!merged.empty()); 
+    auto ret = merged.front(); 
+    if (merged.size() > 1) { 
+        ret = Build<TCoExtend>(ctx, node.Pos()) 
+            .Add(merged) 
+            .Done(); 
+    } 
+ 
+    return ret.Ptr(); 
 }
 
 TExprNode::TPtr RewritePresentIfToFlatMap(TExprBase node, TExprContext& ctx) {
@@ -288,48 +288,48 @@ TExprNode::TPtr RewritePresentIfToFlatMap(TExprBase node, TExprContext& ctx) {
             .Ptr();
 }
 
-class TKqpSimplifyTransformer : public TSyncTransformerBase {
-public:
-    TKqpSimplifyTransformer()
-        : Simplified(false) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        if (Simplified) {
-            return TStatus::Ok;
-        }
-
+class TKqpSimplifyTransformer : public TSyncTransformerBase { 
+public: 
+    TKqpSimplifyTransformer() 
+        : Simplified(false) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        if (Simplified) { 
+            return TStatus::Ok; 
+        } 
+ 
         TOptimizeExprSettings optSettings(nullptr);
-        optSettings.VisitChanges = false;
-        TStatus status = OptimizeExpr(input, output,
-            [](const TExprNode::TPtr& input, TExprContext& ctx) {
-                auto ret = input;
-                TExprBase node(input);
-
-                ret = MergeMapsWithSameLambda<TCoMap>(node, ctx);
-                if (ret != input) {
-                    return ret;
-                }
-
-                ret = MergeMapsWithSameLambda<TCoFlatMap>(node, ctx);
-                if (ret != input) {
-                    return ret;
-                }
-
-                ret = ExtractFilter(node, ctx);
-                if (ret != input) {
-                    return ret;
-                }
-
-                ret = ExtractCombineByKeyPreMap(node, ctx);
+        optSettings.VisitChanges = false; 
+        TStatus status = OptimizeExpr(input, output, 
+            [](const TExprNode::TPtr& input, TExprContext& ctx) { 
+                auto ret = input; 
+                TExprBase node(input); 
+ 
+                ret = MergeMapsWithSameLambda<TCoMap>(node, ctx); 
                 if (ret != input) {
                     return ret;
                 }
 
+                ret = MergeMapsWithSameLambda<TCoFlatMap>(node, ctx); 
+                if (ret != input) { 
+                    return ret; 
+                } 
+ 
+                ret = ExtractFilter(node, ctx); 
+                if (ret != input) { 
+                    return ret; 
+                } 
+ 
+                ret = ExtractCombineByKeyPreMap(node, ctx); 
+                if (ret != input) { 
+                    return ret; 
+                } 
+ 
                 ret = ExtractPartitionByKeyListHandler<TCoPartitionByKey>(node, ctx);
-                if (ret != input) {
-                    return ret;
-                }
-
+                if (ret != input) { 
+                    return ret; 
+                } 
+ 
                 ret = ExtractPartitionByKeyListHandler<TCoPartitionsByKeys>(node, ctx);
                 if (ret != input) {
                     return ret;
@@ -340,33 +340,33 @@ public:
                     return ret;
                 }
 
-                return ret;
-            }, ctx, optSettings);
-
-        if (input != output) {
-            return TStatus(TStatus::Repeat, true);
-        }
-
-        if (status == TStatus::Ok) {
-            Simplified = true;
-        }
-
-        return status;
-    }
-
-    void Rewind() override {
-        Simplified = false;
-    }
-
-private:
-    bool Simplified;
-};
-
-} // namespace
-
-TAutoPtr<IGraphTransformer> CreateKqpSimplifyTransformer() {
-    return new TKqpSimplifyTransformer();
-}
-
+                return ret; 
+            }, ctx, optSettings); 
+ 
+        if (input != output) { 
+            return TStatus(TStatus::Repeat, true); 
+        } 
+ 
+        if (status == TStatus::Ok) { 
+            Simplified = true; 
+        } 
+ 
+        return status; 
+    } 
+ 
+    void Rewind() override { 
+        Simplified = false; 
+    } 
+ 
+private: 
+    bool Simplified; 
+}; 
+ 
+} // namespace 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpSimplifyTransformer() { 
+    return new TKqpSimplifyTransformer(); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/kqp_query_substitute.cpp b/ydb/core/kqp/prepare/kqp_query_substitute.cpp
index 6d289bf78b..8f072d1660 100644
--- a/ydb/core/kqp/prepare/kqp_query_substitute.cpp
+++ b/ydb/core/kqp/prepare/kqp_query_substitute.cpp
@@ -1,73 +1,73 @@
-#include "kqp_prepare_impl.h"
-
+#include "kqp_prepare_impl.h" 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
-
+ 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
-using namespace NYql::NNodes;
-
-namespace {
-
-class TKqpSubstituteTransformer : public TSyncTransformerBase {
-public:
-    TKqpSubstituteTransformer(TIntrusivePtr<TKqpTransactionState> txState,
-        TIntrusivePtr<TKqlTransformContext> transformCtx)
-        : TxState(txState)
-        , TransformCtx(transformCtx) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        const auto& analyzeResults = TransformCtx->AnalyzeResults;
-
-        if (analyzeResults.CanExecute) {
-            return TStatus::Ok;
-        }
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+class TKqpSubstituteTransformer : public TSyncTransformerBase { 
+public: 
+    TKqpSubstituteTransformer(TIntrusivePtr<TKqpTransactionState> txState, 
+        TIntrusivePtr<TKqlTransformContext> transformCtx) 
+        : TxState(txState) 
+        , TransformCtx(transformCtx) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        const auto& analyzeResults = TransformCtx->AnalyzeResults; 
+ 
+        if (analyzeResults.CanExecute) { 
+            return TStatus::Ok; 
+        } 
+ 
         TNodeOnNodeOwnedMap replaceMap;
-        for (size_t i = 0; i < analyzeResults.ExecutionRoots.size(); ++i) {
-            auto newParamName = TxState->Tx().NewParamName();
-
-            auto node = analyzeResults.ExecutionRoots[i].Node;
-
+        for (size_t i = 0; i < analyzeResults.ExecutionRoots.size(); ++i) { 
+            auto newParamName = TxState->Tx().NewParamName(); 
+ 
+            auto node = analyzeResults.ExecutionRoots[i].Node; 
+ 
             YQL_ENSURE(node.Ref().GetTypeAnn());
             auto paramNode = Build<TCoParameter>(ctx, node.Pos())
-                .Name().Build(newParamName)
+                .Name().Build(newParamName) 
                 .Type(ExpandType(node.Pos(), *node.Ref().GetTypeAnn(), ctx))
-                .Done();
-
-            YQL_ENSURE(!TransformCtx->MkqlResults.empty());
-            ui32 mkqlIndex = TransformCtx->MkqlResults.size() - 1;
-            ui32 resultIndex = i;
+                .Done(); 
+ 
+            YQL_ENSURE(!TransformCtx->MkqlResults.empty()); 
+            ui32 mkqlIndex = TransformCtx->MkqlResults.size() - 1; 
+            ui32 resultIndex = i; 
             auto indexTuple = Build<TCoAtomList>(ctx, paramNode.Pos())
-                .Add().Build(ToString(mkqlIndex))
-                .Add().Build(ToString(resultIndex))
-                .Done();
-
-            paramNode.Ptr()->SetResult(indexTuple.Ptr());
-
-            replaceMap.emplace(node.Raw(), paramNode.Ptr());
-        }
-
+                .Add().Build(ToString(mkqlIndex)) 
+                .Add().Build(ToString(resultIndex)) 
+                .Done(); 
+ 
+            paramNode.Ptr()->SetResult(indexTuple.Ptr()); 
+ 
+            replaceMap.emplace(node.Raw(), paramNode.Ptr()); 
+        } 
+ 
         output = ctx.ReplaceNodes(std::move(input), replaceMap);
-
-        return TStatus(TStatus::Repeat, true);
-    }
-
-private:
-    TIntrusivePtr<TKqpTransactionState> TxState;
-    TIntrusivePtr<TKqlTransformContext> TransformCtx;
-};
-
-} // namespace
-
-TAutoPtr<IGraphTransformer> CreateKqpSubstituteTransformer(TIntrusivePtr<TKqpTransactionState> txState,
-    TIntrusivePtr<TKqlTransformContext> transformCtx)
-{
-    return new TKqpSubstituteTransformer(txState, transformCtx);
-}
-
+ 
+        return TStatus(TStatus::Repeat, true); 
+    } 
+ 
+private: 
+    TIntrusivePtr<TKqpTransactionState> TxState; 
+    TIntrusivePtr<TKqlTransformContext> TransformCtx; 
+}; 
+ 
+} // namespace 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpSubstituteTransformer(TIntrusivePtr<TKqpTransactionState> txState, 
+    TIntrusivePtr<TKqlTransformContext> transformCtx) 
+{ 
+    return new TKqpSubstituteTransformer(txState, transformCtx); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/kqp_type_ann.cpp b/ydb/core/kqp/prepare/kqp_type_ann.cpp
index ee51c7349c..a50e47a9c4 100644
--- a/ydb/core/kqp/prepare/kqp_type_ann.cpp
+++ b/ydb/core/kqp/prepare/kqp_type_ann.cpp
@@ -1,67 +1,67 @@
-#include "kqp_prepare_impl.h"
-
+#include "kqp_prepare_impl.h" 
+ 
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider_impl.h>
-
+ 
 #include <ydb/library/yql/core/type_ann/type_ann_core.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/dq/type_ann/dq_type_ann.h>
 #include <ydb/library/yql/utils/log/log.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYql;
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYql; 
 using namespace NYql::NDq;
-using namespace NYql::NNodes;
-
-using TStatus = IGraphTransformer::TStatus;
-
-namespace {
-
-const TTypeAnnotationNode* MakeKqpEffectType(TExprContext& ctx) {
-    return ctx.MakeType<TResourceExprType>(KqpEffectTag);
-}
-
+using namespace NYql::NNodes; 
+ 
+using TStatus = IGraphTransformer::TStatus; 
+ 
+namespace { 
+ 
+const TTypeAnnotationNode* MakeKqpEffectType(TExprContext& ctx) { 
+    return ctx.MakeType<TResourceExprType>(KqpEffectTag); 
+} 
+ 
 bool CheckKeyTuple(const TKqlKeyTuple& tuple, const TKikimrTableDescription& tableDesc,
     const TKikimrTableMetadataPtr meta, TExprContext& ctx)
 {
     YQL_ENSURE(meta);
-
-    for (ui32 i = 0; i < tuple.ArgCount(); ++i) {
-        auto actualType = tuple.Arg(i).Ref().GetTypeAnn();
-        YQL_ENSURE(actualType);
-
+ 
+    for (ui32 i = 0; i < tuple.ArgCount(); ++i) { 
+        auto actualType = tuple.Arg(i).Ref().GetTypeAnn(); 
+        YQL_ENSURE(actualType); 
+ 
         YQL_ENSURE(i < meta->KeyColumnNames.size());
         auto expectedType = tableDesc.GetColumnType(meta->KeyColumnNames[i]);
-        YQL_ENSURE(expectedType);
-
-        if (IsSameAnnotation(*expectedType, *actualType)) {
-            continue;
-        }
-
-        if (expectedType->GetKind() == ETypeAnnotationKind::Optional) {
-            if (IsSameAnnotation(*expectedType->Cast<TOptionalExprType>()->GetItemType(), *actualType)) {
-                continue;
-            }
-        }
-
+        YQL_ENSURE(expectedType); 
+ 
+        if (IsSameAnnotation(*expectedType, *actualType)) { 
+            continue; 
+        } 
+ 
+        if (expectedType->GetKind() == ETypeAnnotationKind::Optional) { 
+            if (IsSameAnnotation(*expectedType->Cast<TOptionalExprType>()->GetItemType(), *actualType)) { 
+                continue; 
+            } 
+        } 
+ 
         ctx.AddError(TIssue(ctx.GetPosition(tuple.Pos()), TStringBuilder()
-            << "Table key type mismatch"
+            << "Table key type mismatch" 
             << ", column: " << meta->KeyColumnNames[i]
             << ", table: " << meta->Name
-            << ", expected: " << *expectedType
-            << ", actual: " << *actualType));
-
-        return false;
-    }
-
-    return true;
-}
-
+            << ", expected: " << *expectedType 
+            << ", actual: " << *actualType)); 
+ 
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
 TStatus AnnotateTable(const TExprNode::TPtr& node, TExprContext& ctx, const TString& cluster,
-    const TKikimrTablesData& tablesData)
-{
+    const TKikimrTablesData& tablesData) 
+{ 
     if (!EnsureArgsCount(*node, 4, ctx)) {
         return TStatus::Error;
     }
@@ -77,35 +77,35 @@ TStatus AnnotateTable(const TExprNode::TPtr& node, TExprContext& ctx, const TStr
 
     TString tablePath(path->Content());
     auto tableDesc = tablesData.EnsureTableExists(cluster, tablePath, node->Pos(), ctx);
-    if (!tableDesc) {
-        return TStatus::Error;
-    }
-
-    YQL_ENSURE(tableDesc->Metadata);
-    auto& meta  = *tableDesc->Metadata;
-
+    if (!tableDesc) { 
+        return TStatus::Error; 
+    } 
+ 
+    YQL_ENSURE(tableDesc->Metadata); 
+    auto& meta  = *tableDesc->Metadata; 
+ 
     if (meta.PathId.ToString() != pathId->Content()) {
         ctx.AddError(YqlIssue(ctx.GetPosition(node->Pos()), TIssuesIds::UNEXPECTED, TStringBuilder()
-            << "Query compilation, unexpected table id"
-            << ", table: " << meta.Name
-            << ", expected: " << meta.PathId.ToString()
+            << "Query compilation, unexpected table id" 
+            << ", table: " << meta.Name 
+            << ", expected: " << meta.PathId.ToString() 
             << ", actual: " << pathId->Content()));
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     if (meta.SchemaVersion != FromString<ui64>(version->Content())) {
         ctx.AddError(YqlIssue(ctx.GetPosition(node->Pos()), TIssuesIds::UNEXPECTED, TStringBuilder()
-            << "Query compilation, unexpected table version"
-            << ", table: " << meta.Name
-            << ", expected: " << meta.SchemaVersion
+            << "Query compilation, unexpected table version" 
+            << ", table: " << meta.Name 
+            << ", expected: " << meta.SchemaVersion 
             << ", actual: " << version->Content()));
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     node->SetTypeAnn(ctx.MakeType<TVoidExprType>());
-    return TStatus::Ok;
-}
-
+    return TStatus::Ok; 
+} 
+ 
 std::pair<TString, const TKikimrTableDescription*> ResolveTable(const TExprNode* kqpTableNode, TExprContext& ctx,
     const TString& cluster, const TKikimrTablesData& tablesData)
 {
@@ -168,7 +168,7 @@ bool CalcKeyColumnsCount(TExprContext& ctx, const TPositionHandle pos, const TSt
 
 TStatus AnnotateReadTable(const TExprNode::TPtr& node, TExprContext& ctx, const TString& cluster,
     const TKikimrTablesData& tablesData, bool withSystemColumns)
-{
+{ 
     const bool readIndex = TKqlReadTableIndex::Match(node.Get());
     if (readIndex && !EnsureArgsCount(*node, 5, ctx)) {
         return TStatus::Error;
@@ -202,38 +202,38 @@ TStatus AnnotateReadTable(const TExprNode::TPtr& node, TExprContext& ctx, const
     }
 
     auto rowType = GetReadTableRowType(ctx, tablesData, cluster, table.first, TCoAtomList(columns), withSystemColumns);
-    if (!rowType) {
-        return TStatus::Error;
-    }
-
+    if (!rowType) { 
+        return TStatus::Error; 
+    } 
+ 
     if (!TKqlKeyRange::Match(node->Child(TKqlReadTableBase::idx_Range))) {
         ctx.AddError(TIssue(ctx.GetPosition(node->Child(TKqlReadTableBase::idx_Range)->Pos()), "Expected TKqlKeyRange tuple"));
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     TKqlKeyRange range{node->ChildPtr(TKqlReadTableBase::idx_Range)};
 
     if (!CheckKeyTuple(range.From(), *table.second, meta, ctx)) {
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     if (!CheckKeyTuple(range.To(), *table.second, meta, ctx)) {
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     if (TKqlReadTable::Match(node.Get()) || TKqlReadTableIndex::Match(node.Get())) {
         node->SetTypeAnn(ctx.MakeType<TListExprType>(rowType));
     } else if (TKqpReadTable::Match(node.Get())) {
         node->SetTypeAnn(ctx.MakeType<TFlowExprType>(rowType));
     } else if (TKqpWideReadTable::Match(node.Get())) {
         node->SetTypeAnn(GetWideRowsType(ctx, rowType->Cast<TStructExprType>()));
-    } else {
+    } else { 
         YQL_ENSURE(false, "Unexpected ReadTable callable: " << node->Content());
     }
 
-    return TStatus::Ok;
-}
-
+    return TStatus::Ok; 
+} 
+ 
 TStatus AnnotateReadTableRanges(const TExprNode::TPtr& node, TExprContext& ctx, const TString& cluster,
     const TKikimrTablesData& tablesData, bool withSystemColumns)
 {
@@ -318,109 +318,109 @@ TStatus AnnotateReadTableRanges(const TExprNode::TPtr& node, TExprContext& ctx,
 }
 
 TStatus AnnotateLookupTable(const TExprNode::TPtr& node, TExprContext& ctx, const TString& cluster,
-    const TKikimrTablesData& tablesData, bool withSystemColumns)
-{
+    const TKikimrTablesData& tablesData, bool withSystemColumns) 
+{ 
     if (!EnsureArgsCount(*node, TKqlLookupIndex::Match(node.Get()) ? 4 : 3, ctx)) {
         return TStatus::Error;
     }
-
+ 
     auto table = ResolveTable(node->Child(TKqlLookupTableBase::idx_Table), ctx, cluster, tablesData);
     if (!table.second) {
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     if (!EnsureTupleOfAtoms(*node->Child(TKqlLookupTableBase::idx_Columns), ctx)) {
-        return TStatus::Error;
-    }
+        return TStatus::Error; 
+    } 
     TCoAtomList columns{node->ChildPtr(TKqlLookupTableBase::idx_Columns)};
-
+ 
     auto rowType = GetReadTableRowType(ctx, tablesData, cluster, table.first, columns, withSystemColumns);
     if (!rowType) {
         return TStatus::Error;
     }
-
+ 
     bool isPhysical = TKqpLookupTable::Match(node.Get());
 
-    const TTypeAnnotationNode* lookupType;
-    if (isPhysical) {
+    const TTypeAnnotationNode* lookupType; 
+    if (isPhysical) { 
         if (!EnsureNewSeqType<false, false, true>(*node->Child(TKqlLookupTableBase::idx_LookupKeys), ctx, &lookupType)) {
-            return TStatus::Error;
-        }
-
+            return TStatus::Error; 
+        } 
+ 
         if (node->Child(TKqlLookupTableBase::idx_LookupKeys)->GetTypeAnn()->GetKind() == ETypeAnnotationKind::Flow) {
             auto streamLookupKeys = Build<TCoFromFlow>(ctx, node->Pos())
                 .Input(node->ChildRef(TKqlLookupTableBase::idx_LookupKeys))
-                .Done();
-
+                .Done(); 
+ 
             node->ChildRef(TKqpLookupTable::idx_LookupKeys) = streamLookupKeys.Ptr();
-            return TStatus::Repeat;
-        }
-    } else {
+            return TStatus::Repeat; 
+        } 
+    } else { 
         if (!EnsureNewSeqType<false, true, false>(*node->Child(TKqlLookupTableBase::idx_LookupKeys), ctx, &lookupType)) {
-            return TStatus::Error;
-        }
-    }
-
-    YQL_ENSURE(lookupType);
+            return TStatus::Error; 
+        } 
+    } 
+ 
+    YQL_ENSURE(lookupType); 
     if (!EnsureStructType(node->Pos(), *lookupType, ctx)) {
-        return TStatus::Error;
-    }
-    auto structType = lookupType->Cast<TStructExprType>();
-
-    ui32 keyColumnsCount = 0;
+        return TStatus::Error; 
+    } 
+    auto structType = lookupType->Cast<TStructExprType>(); 
+ 
+    ui32 keyColumnsCount = 0; 
     if (TKqlLookupIndex::Match(node.Get())) {
         auto index = node->Child(TKqlLookupIndex::idx_Index);
         if (!EnsureAtom(*index, ctx)) {
             return TStatus::Error;
-        }
+        } 
         auto indexMeta = table.second->Metadata->GetIndexMetadata(TString(index->Content())).first;
-
+ 
         if (!CalcKeyColumnsCount(ctx, node->Pos(), *structType, *table.second, *indexMeta, keyColumnsCount)) {
             return TStatus::Error;
         }
-
+ 
     } else {
         if (!CalcKeyColumnsCount(ctx, node->Pos(), *structType, *table.second, *table.second->Metadata, keyColumnsCount)) {
-            return TStatus::Error;
-        }
-    }
-
-    if (!keyColumnsCount) {
+            return TStatus::Error; 
+        } 
+    } 
+ 
+    if (!keyColumnsCount) { 
         ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), "Table lookup has no key columns."));
-        return TStatus::Error;
-    }
-
-    if (structType->GetSize() != keyColumnsCount) {
+        return TStatus::Error; 
+    } 
+ 
+    if (structType->GetSize() != keyColumnsCount) { 
         ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), "Table lookup contains non-key columns."));
-        return TStatus::Error;
-    }
-
-    if (isPhysical) {
+        return TStatus::Error; 
+    } 
+ 
+    if (isPhysical) { 
         node->SetTypeAnn(ctx.MakeType<TFlowExprType>(rowType));
-    } else {
+    } else { 
         node->SetTypeAnn(ctx.MakeType<TListExprType>(rowType));
-    }
-    return TStatus::Ok;
-}
-
+    } 
+    return TStatus::Ok; 
+} 
+ 
 TStatus AnnotateKeyTuple(const TExprNode::TPtr& node, TExprContext& ctx) {
-    TVector<const TTypeAnnotationNode*> keyTypes;
+    TVector<const TTypeAnnotationNode*> keyTypes; 
     for (const auto& arg : node->ChildrenList()) {
         keyTypes.push_back(arg->GetTypeAnn());
-    }
-
-    auto tupleType = ctx.MakeType<TTupleExprType>(keyTypes);
+    } 
+ 
+    auto tupleType = ctx.MakeType<TTupleExprType>(keyTypes); 
     node->SetTypeAnn(tupleType);
-    return TStatus::Ok;
-}
-
+    return TStatus::Ok; 
+} 
+ 
 TStatus AnnotateUpsertRows(const TExprNode::TPtr& node, TExprContext& ctx, const TString& cluster,
-    const TKikimrTablesData& tablesData)
-{
-    if (!EnsureMinArgsCount(*node, 3, ctx)) {
-        return TStatus::Error;
-    }
-
+    const TKikimrTablesData& tablesData) 
+{ 
+    if (!EnsureMinArgsCount(*node, 3, ctx)) { 
+        return TStatus::Error; 
+    } 
+ 
     auto table = ResolveTable(node->Child(TKqlUpsertRowsBase::idx_Table), ctx, cluster, tablesData);
     if (!table.second) {
         return TStatus::Error;
@@ -433,7 +433,7 @@ TStatus AnnotateUpsertRows(const TExprNode::TPtr& node, TExprContext& ctx, const
 
     const TTypeAnnotationNode* itemType = nullptr;
     bool isStream;
-
+ 
     auto* input = node->Child(TKqlUpsertRowsBase::idx_Input);
 
     if (TKqpUpsertRows::Match(node.Get())) {
@@ -443,42 +443,42 @@ TStatus AnnotateUpsertRows(const TExprNode::TPtr& node, TExprContext& ctx, const
         itemType = input->GetTypeAnn()->Cast<TStreamExprType>()->GetItemType();
         isStream = true;
     } else {
-        YQL_ENSURE(TKqlUpsertRows::Match(node.Get()) || TKqlUpsertRowsIndex::Match(node.Get()));
-
+        YQL_ENSURE(TKqlUpsertRows::Match(node.Get()) || TKqlUpsertRowsIndex::Match(node.Get())); 
+ 
         if (!EnsureListType(*input, ctx)) {
             return TStatus::Error;
         }
         itemType = input->GetTypeAnn()->Cast<TListExprType>()->GetItemType();
         isStream = false;
-    }
-
+    } 
+ 
     if (!EnsureStructType(input->Pos(), *itemType, ctx)) {
-        return TStatus::Error;
-    }
-
-    auto rowType = itemType->Cast<TStructExprType>();
+        return TStatus::Error; 
+    } 
+ 
+    auto rowType = itemType->Cast<TStructExprType>(); 
     for (const auto& column : columns) {
         if (!rowType->FindItem(column.Value())) {
             ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), TStringBuilder()
                 << "Missing column in input type: " << column.Value()));
-            return TStatus::Error;
-        }
-    }
-
-    if (TKqpUpsertRows::Match(node.Get()) && rowType->GetItems().size() != columns.Size()) {
-        ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), TStringBuilder()
-            << "Input type contains excess columns"));
-        return TStatus::Error;
-    }
-
+            return TStatus::Error; 
+        } 
+    } 
+ 
+    if (TKqpUpsertRows::Match(node.Get()) && rowType->GetItems().size() != columns.Size()) { 
+        ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), TStringBuilder() 
+            << "Input type contains excess columns")); 
+        return TStatus::Error; 
+    } 
+ 
     for (auto& keyColumnName : table.second->Metadata->KeyColumnNames) {
-        if (!rowType->FindItem(keyColumnName)) {
+        if (!rowType->FindItem(keyColumnName)) { 
             ctx.AddError(YqlIssue(ctx.GetPosition(node->Pos()), TIssuesIds::KIKIMR_PRECONDITION_FAILED, TStringBuilder()
                 << "Missing key column in input type: " << keyColumnName));
-            return TStatus::Error;
-        }
-    }
-
+            return TStatus::Error; 
+        } 
+    } 
+ 
     for (auto& [name, meta] : table.second->Metadata->Columns) {
         if (meta.NotNull && !rowType->FindItem(name)) {
             ctx.AddError(YqlIssue(ctx.GetPosition(node->Pos()), TIssuesIds::KIKIMR_NO_COLUMN_DEFAULT_VALUE, TStringBuilder()
@@ -495,19 +495,19 @@ TStatus AnnotateUpsertRows(const TExprNode::TPtr& node, TExprContext& ctx, const
         }
     }
 
-    if (TKqlUpsertRowsIndex::Match(node.Get())) {
+    if (TKqlUpsertRowsIndex::Match(node.Get())) { 
         Y_ENSURE(!table.second->Metadata->SecondaryGlobalIndexMetadata.empty());
     }
 
-    auto effectType = MakeKqpEffectType(ctx);
+    auto effectType = MakeKqpEffectType(ctx); 
     if (isStream) {
         node->SetTypeAnn(ctx.MakeType<TStreamExprType>(effectType));
     } else {
         node->SetTypeAnn(ctx.MakeType<TListExprType>(effectType));
     }
-    return TStatus::Ok;
-}
-
+    return TStatus::Ok; 
+} 
+ 
 TStatus AnnotateInsertRows(const TExprNode::TPtr& node, TExprContext& ctx, const TString& cluster,
     const TKikimrTablesData& tablesData)
 {
@@ -727,16 +727,16 @@ TStatus AnnotateOlapFilterCompare(const TExprNode::TPtr& node, TExprContext& ctx
 
     auto* input = node->Child(TKqpOlapFilterCompare::idx_Input);
 
-    const TTypeAnnotationNode* itemType;
+    const TTypeAnnotationNode* itemType; 
 
     if (!EnsureNewSeqType<false, false, true>(*input, ctx, &itemType)) {
-        return TStatus::Error;
-    }
+        return TStatus::Error; 
+    } 
 
     if (!EnsureStructType(input->Pos(), *itemType, ctx)) {
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     auto validateNode = [itemType, &ctx](TExprNode* node) {
         // Column name, validate that it is present in Input node
         if (TCoAtom::Match(node)) {
@@ -782,18 +782,18 @@ TStatus AnnotateOlapFilterCompare(const TExprNode::TPtr& node, TExprContext& ctx
     auto rightNode = node->Child(TKqpOlapFilterCompare::idx_Right);
 
     if (!validateNode(leftNode)) {
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     if (!validateNode(rightNode)) {
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     node->SetTypeAnn(ctx.MakeType<TDataExprType>(EDataSlot::Bool));
 
-    return TStatus::Ok;
-}
-
+    return TStatus::Ok; 
+} 
+ 
 TStatus AnnotateOlapFilterExists(const TExprNode::TPtr& node, TExprContext& ctx) {
     if (!EnsureArgsCount(*node, 2, ctx)) {
         return TStatus::Error;
@@ -877,9 +877,9 @@ TStatus AnnotateKqpTxResultBinding(const TExprNode::TPtr& node, TExprContext& ct
     }
 
     node->SetTypeAnn(type->GetTypeAnn()->Cast<TTypeExprType>()->GetType());
-    return TStatus::Ok;
-}
-
+    return TStatus::Ok; 
+} 
+ 
 TStatus AnnotateKqpPhysicalTx(const TExprNode::TPtr& node, TExprContext& ctx) {
     if (!EnsureArgsCount(*node, 4, ctx)) {
         return TStatus::Error;
@@ -888,9 +888,9 @@ TStatus AnnotateKqpPhysicalTx(const TExprNode::TPtr& node, TExprContext& ctx) {
     // TODO: ???
 
     node->SetTypeAnn(ctx.MakeType<TVoidExprType>());
-    return TStatus::Ok;
-}
-
+    return TStatus::Ok; 
+} 
+ 
 TStatus AnnotateKqpPhysicalQuery(const TExprNode::TPtr& node, TExprContext& ctx) {
     if (!EnsureArgsCount(*node, 3, ctx)) {
         return TStatus::Error;
@@ -899,40 +899,40 @@ TStatus AnnotateKqpPhysicalQuery(const TExprNode::TPtr& node, TExprContext& ctx)
     // TODO: ???
 
     node->SetTypeAnn(ctx.MakeType<TVoidExprType>());
-    return TStatus::Ok;
-}
-
+    return TStatus::Ok; 
+} 
+ 
 TStatus AnnotateKqpEffects(const TExprNode::TPtr& node, TExprContext& ctx) {
-    auto kqpEffectType = MakeKqpEffectType(ctx);
-
+    auto kqpEffectType = MakeKqpEffectType(ctx); 
+ 
     for (const auto& arg : node->ChildrenList()) {
         if (!EnsureCallable(*arg, ctx)) {
-            return TStatus::Error;
-        }
-
+            return TStatus::Error; 
+        } 
+ 
         if (!TKqpUpsertRows::Match(arg.Get()) && !TKqpDeleteRows::Match(arg.Get())) {
             ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), TStringBuilder()
                 << "Unexpected effect: " << arg->Content()));
-            return TStatus::Error;
-        }
-
+            return TStatus::Error; 
+        } 
+ 
         if (!EnsureStreamType(*arg, ctx)) {
-            return TStatus::Error;
-        }
-
+            return TStatus::Error; 
+        } 
+ 
         auto itemType = arg->GetTypeAnn()->Cast<TStreamExprType>()->GetItemType();
-        if (!IsSameAnnotation(*kqpEffectType, *itemType)) {
+        if (!IsSameAnnotation(*kqpEffectType, *itemType)) { 
             ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), TStringBuilder()
-                << "Invalid YDB effect type, expected: " << FormatType(kqpEffectType)
-                << ", actual: " << FormatType(itemType)));
-            return TStatus::Error;
-        }
-    }
-
+                << "Invalid YDB effect type, expected: " << FormatType(kqpEffectType) 
+                << ", actual: " << FormatType(itemType))); 
+            return TStatus::Error; 
+        } 
+    } 
+ 
     node->SetTypeAnn(ctx.MakeType<TStreamExprType>(kqpEffectType));
-    return TStatus::Ok;
-}
-
+    return TStatus::Ok; 
+} 
+ 
 TStatus AnnotateKqpProgram(const TExprNode::TPtr& node, TExprContext& ctx) {
     if (!EnsureArgsCount(*node, 2, ctx)) {
         return TStatus::Error;
@@ -1024,18 +1024,18 @@ TStatus AnnotateKqpEnsure(const TExprNode::TPtr& node, TExprContext& ctx) {
     return TStatus::Ok;
 }
 
-} // namespace
-
-TAutoPtr<IGraphTransformer> CreateKqpTypeAnnotationTransformer(const TString& cluster,
+} // namespace 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpTypeAnnotationTransformer(const TString& cluster, 
     TIntrusivePtr<TKikimrTablesData> tablesData, TTypeAnnotationContext& typesCtx, TKikimrConfiguration::TPtr config)
-{
+{ 
     TAutoPtr<IGraphTransformer> dqTransformer = CreateDqTypeAnnotationTransformer(typesCtx);
-
-    return CreateFunctorTransformer(
+ 
+    return CreateFunctorTransformer( 
         [cluster, tablesData, dqTransformer, config](const TExprNode::TPtr& input, TExprNode::TPtr& output,
-            TExprContext& ctx) -> TStatus
-        {
-            output = input;
+            TExprContext& ctx) -> TStatus 
+        { 
+            output = input; 
 
             TIssueScopeGuard issueScope(ctx.IssueManager, [&input, &ctx] {
                 return MakeIntrusive<TIssue>(ctx.GetPosition(input->Pos()),
@@ -1044,12 +1044,12 @@ TAutoPtr<IGraphTransformer> CreateKqpTypeAnnotationTransformer(const TString& cl
 
             if (TKqpTable::Match(input.Get())) {
                 return AnnotateTable(input, ctx, cluster, *tablesData);
-            }
-
+            } 
+ 
             if (TKqlReadTableBase::Match(input.Get())) {
                 return AnnotateReadTable(input, ctx, cluster, *tablesData, config->SystemColumnsEnabled());
-            }
-
+            } 
+ 
             if (TKqlReadTableRangesBase::Match(input.Get())) {
                 return AnnotateReadTableRanges(input, ctx, cluster, *tablesData, config->SystemColumnsEnabled());
             }
@@ -1060,12 +1060,12 @@ TAutoPtr<IGraphTransformer> CreateKqpTypeAnnotationTransformer(const TString& cl
 
             if (TKqlKeyInc::Match(input.Get()) || TKqlKeyExc::Match(input.Get())) {
                 return AnnotateKeyTuple(input, ctx);
-            }
-
+            } 
+ 
             if (TKqlUpsertRowsBase::Match(input.Get())) {
                 return AnnotateUpsertRows(input, ctx, cluster, *tablesData);
-            }
-
+            } 
+ 
             if (TKqlInsertRowsBase::Match(input.Get())) {
                 return AnnotateInsertRows(input, ctx, cluster, *tablesData);
             }
@@ -1076,16 +1076,16 @@ TAutoPtr<IGraphTransformer> CreateKqpTypeAnnotationTransformer(const TString& cl
 
             if (TKqlDeleteRowsBase::Match(input.Get())) {
                 return AnnotateDeleteRows(input, ctx, cluster, *tablesData);
-            }
-
+            } 
+ 
             if (TKqpOlapFilter::Match(input.Get())) {
                 return AnnotateOlapFilter(input, ctx);
             }
 
             if (TKqpOlapFilterCompare::Match(input.Get())) {
                 return AnnotateOlapFilterCompare(input, ctx);
-            }
-
+            } 
+ 
             if (TKqpOlapFilterExists::Match(input.Get())) {
                 return AnnotateOlapFilterExists(input, ctx);
             }
@@ -1104,72 +1104,72 @@ TAutoPtr<IGraphTransformer> CreateKqpTypeAnnotationTransformer(const TString& cl
 
             if (TKqpPhysicalTx::Match(input.Get())) {
                 return AnnotateKqpPhysicalTx(input, ctx);
-            }
-
+            } 
+ 
             if (TKqpPhysicalQuery::Match(input.Get())) {
                 return AnnotateKqpPhysicalQuery(input, ctx);
-            }
-
+            } 
+ 
             if (TKqpEffects::Match(input.Get())) {
                 return AnnotateKqpEffects(input, ctx);
-            }
-
+            } 
+ 
             if (TKqpProgram::Match(input.Get())) {
                 return AnnotateKqpProgram(input, ctx);
-            }
-
+            } 
+ 
             if (TKqpEnsure::Match(input.Get())) {
                 return AnnotateKqpEnsure(input, ctx);
             }
 
             return dqTransformer->Transform(input, output, ctx);
-        });
-}
-
-TAutoPtr<IGraphTransformer> CreateKqpCheckQueryTransformer() {
-    return CreateFunctorTransformer(
-        [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) -> TStatus {
-            output = input;
-
-            YQL_ENSURE(TMaybeNode<TKqlQuery>(input));
-
-            auto query = TKqlQuery(input);
-            for (const auto& result : query.Results()) {
+        }); 
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpCheckQueryTransformer() { 
+    return CreateFunctorTransformer( 
+        [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) -> TStatus { 
+            output = input; 
+ 
+            YQL_ENSURE(TMaybeNode<TKqlQuery>(input)); 
+ 
+            auto query = TKqlQuery(input); 
+            for (const auto& result : query.Results()) { 
                 if (!EnsureTupleSize(result.Ref(), 2, ctx)) {
-                    return TStatus::Error;
-                }
+                    return TStatus::Error; 
+                } 
                 if (!EnsureListType(result.Value().Ref(), ctx)) {
                     return TStatus::Error;
                 }
-            }
-
-            return TStatus::Ok;
-        });
-}
-
-TAutoPtr<IGraphTransformer> CreateKqpCheckKiProgramTransformer() {
-    return CreateFunctorTransformer(
-        [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) -> TStatus {
-            output = input;
-
-            YQL_ENSURE(TMaybeNode<TKiProgram>(input));
-
-            auto program = TKiProgram(input);
+            } 
+ 
+            return TStatus::Ok; 
+        }); 
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKqpCheckKiProgramTransformer() { 
+    return CreateFunctorTransformer( 
+        [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) -> TStatus { 
+            output = input; 
+ 
+            YQL_ENSURE(TMaybeNode<TKiProgram>(input)); 
+ 
+            auto program = TKiProgram(input); 
             auto effectsType = program.Effects().Ptr()->GetTypeAnn();
-            bool typeOk = EnsureListType(input->Pos(), *effectsType, ctx);
-            if (typeOk) {
-                auto listType = effectsType->Cast<TListExprType>();
-                typeOk = listType->GetItemType()->GetKind() == ETypeAnnotationKind::Void;
-            }
-            if (!typeOk) {
+            bool typeOk = EnsureListType(input->Pos(), *effectsType, ctx); 
+            if (typeOk) { 
+                auto listType = effectsType->Cast<TListExprType>(); 
+                typeOk = listType->GetItemType()->GetKind() == ETypeAnnotationKind::Void; 
+            } 
+            if (!typeOk) { 
                 ctx.AddError(TIssue(ctx.GetPosition(input->Pos()), TStringBuilder()
-                    << "Invalid program effects type: " << FormatType(effectsType)));
-                return TStatus::Error;
-            }
-
-            return TStatus::Ok;
-        });
-}
-
+                    << "Invalid program effects type: " << FormatType(effectsType))); 
+                return TStatus::Error; 
+            } 
+ 
+            return TStatus::Ok; 
+        }); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/prepare/ya.make b/ydb/core/kqp/prepare/ya.make
index 292847cbe7..8c8e07ed3b 100644
--- a/ydb/core/kqp/prepare/ya.make
+++ b/ydb/core/kqp/prepare/ya.make
@@ -1,30 +1,30 @@
-LIBRARY()
-
-OWNER(
-    spuchin
-    g:kikimr
-)
-
-SRCS(
-    kqp_query_analyze.cpp
-    kqp_query_exec.cpp
-    kqp_query_finalize.cpp
-    kqp_query_plan.cpp
-    kqp_query_rewrite.cpp
-    kqp_query_simplify.cpp
-    kqp_query_substitute.cpp
-    kqp_type_ann.cpp
-)
-
-PEERDIR(
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
+    g:kikimr 
+) 
+ 
+SRCS( 
+    kqp_query_analyze.cpp 
+    kqp_query_exec.cpp 
+    kqp_query_finalize.cpp 
+    kqp_query_plan.cpp 
+    kqp_query_rewrite.cpp 
+    kqp_query_simplify.cpp 
+    kqp_query_substitute.cpp 
+    kqp_type_ann.cpp 
+) 
+ 
+PEERDIR( 
     ydb/core/engine
     ydb/core/kqp/common
     ydb/library/yql/dq/actors/protos
     ydb/library/yql/dq/type_ann
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-GENERATE_ENUM_SERIALIZATION(kqp_prepare_impl.h)
-
-END()
+GENERATE_ENUM_SERIALIZATION(kqp_prepare_impl.h) 
+ 
+END() 
diff --git a/ydb/core/kqp/provider/ut/ya.make b/ydb/core/kqp/provider/ut/ya.make
index b8762ed422..2f40492ba6 100644
--- a/ydb/core/kqp/provider/ut/ya.make
+++ b/ydb/core/kqp/provider/ut/ya.make
@@ -1,17 +1,17 @@
 UNITTEST_FOR(ydb/core/kqp/provider)
-
-OWNER(spuchin)
-
-SRCS(
-    yql_kikimr_gateway_ut.cpp
-)
-
-PEERDIR(
+ 
+OWNER(spuchin) 
+ 
+SRCS( 
+    yql_kikimr_gateway_ut.cpp 
+) 
+ 
+PEERDIR( 
     ydb/core/client/minikql_result_lib
     ydb/core/kqp/ut/common
-)
-
-YQL_LAST_ABI_VERSION()
+) 
+ 
+YQL_LAST_ABI_VERSION() 
 
 FORK_SUBTESTS()
 
@@ -24,4 +24,4 @@ ELSE()
     SIZE(MEDIUM)
 ENDIF()
 
-END()
+END() 
diff --git a/ydb/core/kqp/provider/ya.make b/ydb/core/kqp/provider/ya.make
index 19dd0db44b..8771e1c33c 100644
--- a/ydb/core/kqp/provider/ya.make
+++ b/ydb/core/kqp/provider/ya.make
@@ -1,35 +1,35 @@
-LIBRARY()
-
-OWNER(spuchin)
-
-SRCS(
+LIBRARY() 
+ 
+OWNER(spuchin) 
+ 
+SRCS( 
     kqp_opt_helpers.cpp
-    yql_kikimr_datasink.cpp
-    yql_kikimr_datasource.cpp
-    yql_kikimr_exec.cpp
-    yql_kikimr_expr_nodes.h
-    yql_kikimr_expr_nodes.cpp
-    yql_kikimr_gateway.h
-    yql_kikimr_gateway.cpp
-    yql_kikimr_kql.cpp
-    yql_kikimr_mkql.cpp
-    yql_kikimr_opt_build.cpp
-    yql_kikimr_opt_join.cpp
-    yql_kikimr_opt_range.cpp
+    yql_kikimr_datasink.cpp 
+    yql_kikimr_datasource.cpp 
+    yql_kikimr_exec.cpp 
+    yql_kikimr_expr_nodes.h 
+    yql_kikimr_expr_nodes.cpp 
+    yql_kikimr_gateway.h 
+    yql_kikimr_gateway.cpp 
+    yql_kikimr_kql.cpp 
+    yql_kikimr_mkql.cpp 
+    yql_kikimr_opt_build.cpp 
+    yql_kikimr_opt_join.cpp 
+    yql_kikimr_opt_range.cpp 
     yql_kikimr_opt_utils.cpp
-    yql_kikimr_opt.cpp
-    yql_kikimr_provider.h
-    yql_kikimr_provider.cpp
-    yql_kikimr_provider_impl.h
+    yql_kikimr_opt.cpp 
+    yql_kikimr_provider.h 
+    yql_kikimr_provider.cpp 
+    yql_kikimr_provider_impl.h 
     yql_kikimr_query_traits.cpp
-    yql_kikimr_results.cpp
-    yql_kikimr_results.h
-    yql_kikimr_settings.cpp
-    yql_kikimr_settings.h
-    yql_kikimr_type_ann.cpp
-)
-
-PEERDIR(
+    yql_kikimr_results.cpp 
+    yql_kikimr_results.h 
+    yql_kikimr_settings.cpp 
+    yql_kikimr_settings.h 
+    yql_kikimr_type_ann.cpp 
+) 
+ 
+PEERDIR( 
     ydb/core/base
     ydb/core/kqp/provider/mkql
     ydb/core/protos
@@ -50,28 +50,28 @@ PEERDIR(
     ydb/library/yql/providers/common/schema/expr
     ydb/library/yql/providers/result/expr_nodes
     ydb/library/yql/providers/result/provider
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
 SRCDIR(ydb/library/yql/core/expr_nodes_gen)
 
-RUN_PROGRAM(
+RUN_PROGRAM( 
     ydb/library/yql/core/expr_nodes_gen/gen yql_expr_nodes_gen.jnj yql_kikimr_expr_nodes.json
         yql_kikimr_expr_nodes.gen.h yql_kikimr_expr_nodes.decl.inl.h yql_kikimr_expr_nodes.defs.inl.h
-    IN yql_expr_nodes_gen.jnj
-    IN yql_kikimr_expr_nodes.json
-    OUT yql_kikimr_expr_nodes.gen.h
-    OUT yql_kikimr_expr_nodes.decl.inl.h
-    OUT yql_kikimr_expr_nodes.defs.inl.h
+    IN yql_expr_nodes_gen.jnj 
+    IN yql_kikimr_expr_nodes.json 
+    OUT yql_kikimr_expr_nodes.gen.h 
+    OUT yql_kikimr_expr_nodes.decl.inl.h 
+    OUT yql_kikimr_expr_nodes.defs.inl.h 
     OUTPUT_INCLUDES ${ARCADIA_ROOT}/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.h
         ${ARCADIA_ROOT}/util/generic/hash_set.h
-)
-
-GENERATE_ENUM_SERIALIZATION(yql_kikimr_provider.h)
-
-END()
-
+) 
+ 
+GENERATE_ENUM_SERIALIZATION(yql_kikimr_provider.h) 
+ 
+END() 
+ 
 RECURSE_FOR_TESTS(
     ut
 )
diff --git a/ydb/core/kqp/provider/yql_kikimr_datasink.cpp b/ydb/core/kqp/provider/yql_kikimr_datasink.cpp
index 035d6b7701..d839b80031 100644
--- a/ydb/core/kqp/provider/yql_kikimr_datasink.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_datasink.cpp
@@ -1,22 +1,22 @@
-#include "yql_kikimr_provider_impl.h"
-
+#include "yql_kikimr_provider_impl.h" 
+ 
 #include <ydb/library/yql/providers/common/provider/yql_data_provider_impl.h>
 #include <ydb/library/yql/providers/common/proto/gateways_config.pb.h>
 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
-
-namespace NYql {
-namespace {
-
-using namespace NKikimr;
-using namespace NNodes;
-
-class TKiSinkIntentDeterminationTransformer: public TKiSinkVisitorTransformer {
-public:
+ 
+namespace NYql { 
+namespace { 
+ 
+using namespace NKikimr; 
+using namespace NNodes; 
+ 
+class TKiSinkIntentDeterminationTransformer: public TKiSinkVisitorTransformer { 
+public: 
     TKiSinkIntentDeterminationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx)
         : SessionCtx(sessionCtx) {}
-
-private:
+ 
+private: 
     TStatus HandleClusterConfig(TKiClusterConfig node, TExprContext& ctx) override {
         Y_UNUSED(node);
         Y_UNUSED(ctx);
@@ -24,46 +24,46 @@ private:
         return TStatus::Ok;
     }
 
-    TStatus HandleWriteTable(TKiWriteTable node, TExprContext& ctx) override {
-        Y_UNUSED(ctx);
-
-        auto cluster = node.DataSink().Cluster();
-        auto table = node.Table();
-
+    TStatus HandleWriteTable(TKiWriteTable node, TExprContext& ctx) override { 
+        Y_UNUSED(ctx); 
+ 
+        auto cluster = node.DataSink().Cluster(); 
+        auto table = node.Table(); 
+ 
         SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table));
-        return TStatus::Ok;
-    }
-
-    TStatus HandleUpdateTable(TKiUpdateTable node, TExprContext& ctx) override {
-        Y_UNUSED(ctx);
-
-        auto cluster = node.DataSink().Cluster();
-        auto table = node.Table();
-
+        return TStatus::Ok; 
+    } 
+ 
+    TStatus HandleUpdateTable(TKiUpdateTable node, TExprContext& ctx) override { 
+        Y_UNUSED(ctx); 
+ 
+        auto cluster = node.DataSink().Cluster(); 
+        auto table = node.Table(); 
+ 
         SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table));
-        return TStatus::Ok;
-    }
-
-    TStatus HandleDeleteTable(TKiDeleteTable node, TExprContext& ctx) override {
-        Y_UNUSED(ctx);
-
-        auto cluster = node.DataSink().Cluster();
-        auto table = node.Table();
-
+        return TStatus::Ok; 
+    } 
+ 
+    TStatus HandleDeleteTable(TKiDeleteTable node, TExprContext& ctx) override { 
+        Y_UNUSED(ctx); 
+ 
+        auto cluster = node.DataSink().Cluster(); 
+        auto table = node.Table(); 
+ 
         SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table));
-        return TStatus::Ok;
-    }
-
-    TStatus HandleCreateTable(TKiCreateTable node, TExprContext& ctx) override {
-        Y_UNUSED(ctx);
-
-        auto cluster = node.DataSink().Cluster();
-        auto table = node.Table();
-
+        return TStatus::Ok; 
+    } 
+ 
+    TStatus HandleCreateTable(TKiCreateTable node, TExprContext& ctx) override { 
+        Y_UNUSED(ctx); 
+ 
+        auto cluster = node.DataSink().Cluster(); 
+        auto table = node.Table(); 
+ 
         SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table));
-        return TStatus::Ok;
-    }
-
+        return TStatus::Ok; 
+    } 
+ 
     TStatus HandleAlterTable(TKiAlterTable node, TExprContext& ctx) override {
         Y_UNUSED(ctx);
 
@@ -71,19 +71,19 @@ private:
         auto table = node.Table();
 
         SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table));
-        return TStatus::Ok;
+        return TStatus::Ok; 
     }
 
-    TStatus HandleDropTable(TKiDropTable node, TExprContext& ctx) override {
-        Y_UNUSED(ctx);
-
-        auto cluster = node.DataSink().Cluster();
-        auto table = node.Table();
-
+    TStatus HandleDropTable(TKiDropTable node, TExprContext& ctx) override { 
+        Y_UNUSED(ctx); 
+ 
+        auto cluster = node.DataSink().Cluster(); 
+        auto table = node.Table(); 
+ 
         SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table));
-        return TStatus::Ok;
-    }
-
+        return TStatus::Ok; 
+    } 
+ 
     TStatus HandleCreateUser(TKiCreateUser node, TExprContext& ctx) override {
         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
             << "CreateUser is not yet implemented for intent determination transformer"));
@@ -120,85 +120,85 @@ private:
         return TStatus::Error;
     }
 
-    TStatus HandleWrite(TExprBase node, TExprContext& ctx) override {
+    TStatus HandleWrite(TExprBase node, TExprContext& ctx) override { 
         auto cluster = node.Ref().Child(1)->Child(1)->Content();
-        TKikimrKey key(ctx);
+        TKikimrKey key(ctx); 
         if (!key.Extract(*node.Ref().Child(2))) {
-            return TStatus::Error;
-        }
-
-        switch (key.GetKeyType()) {
-            case TKikimrKey::Type::Table: {
+            return TStatus::Error; 
+        } 
+ 
+        switch (key.GetKeyType()) { 
+            case TKikimrKey::Type::Table: { 
                 NCommon::TWriteTableSettings settings = NCommon::ParseWriteTableSettings(
                     TExprList(node.Ref().ChildPtr(4)), ctx);
-                if (!settings.Mode) {
+                if (!settings.Mode) { 
                     ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-                        << "Mode option is required for Kikimr table writes."));
-                    return TStatus::Error;
-                }
-                auto mode = settings.Mode.Cast();
-
-                if (mode == "drop") {
+                        << "Mode option is required for Kikimr table writes.")); 
+                    return TStatus::Error; 
+                } 
+                auto mode = settings.Mode.Cast(); 
+ 
+                if (mode == "drop") { 
                     SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), key.GetTablePath());
-                    return TStatus::Ok;
-                } else if (
-                    mode == "upsert" ||
-                    mode == "replace" ||
-                    mode == "insert_revert" ||
-                    mode == "insert_abort" ||
-                    mode == "delete_on" ||
-                    mode == "update_on")
-                {
+                    return TStatus::Ok; 
+                } else if ( 
+                    mode == "upsert" || 
+                    mode == "replace" || 
+                    mode == "insert_revert" || 
+                    mode == "insert_abort" || 
+                    mode == "delete_on" || 
+                    mode == "update_on") 
+                { 
                     SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), key.GetTablePath());
-                    return TStatus::Ok;
-                } else if (mode == "insert_ignore") {
+                    return TStatus::Ok; 
+                } else if (mode == "insert_ignore") { 
                     ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-                        << "INSERT OR IGNORE is not yet supported for Kikimr."));
-                    return TStatus::Error;
-                } else if (mode == "update") {
-                    if (!settings.Filter) {
+                        << "INSERT OR IGNORE is not yet supported for Kikimr.")); 
+                    return TStatus::Error; 
+                } else if (mode == "update") { 
+                    if (!settings.Filter) { 
                         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), "Filter option is required for table update."));
-                        return TStatus::Error;
-                    }
-                    if (!settings.Update) {
+                        return TStatus::Error; 
+                    } 
+                    if (!settings.Update) { 
                         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), "Update option is required for table update."));
-                        return TStatus::Error;
-                    }
+                        return TStatus::Error; 
+                    } 
                     SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), key.GetTablePath());
-                    return TStatus::Ok;
-                } else if (mode == "delete") {
-                    if (!settings.Filter) {
+                    return TStatus::Ok; 
+                } else if (mode == "delete") { 
+                    if (!settings.Filter) { 
                         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), "Filter option is required for table delete."));
-                        return TStatus::Error;
-                    }
+                        return TStatus::Error; 
+                    } 
                     SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), key.GetTablePath());
-                    return TStatus::Ok;
-                } else {
+                    return TStatus::Ok; 
+                } else { 
                     ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-                        << "Unsupported Kikimr table write mode: " << settings.Mode.Cast().Value()));
-                    return TStatus::Error;
-                }
-            }
-
-            case TKikimrKey::Type::TableScheme: {
+                        << "Unsupported Kikimr table write mode: " << settings.Mode.Cast().Value())); 
+                    return TStatus::Error; 
+                } 
+            } 
+ 
+            case TKikimrKey::Type::TableScheme: { 
                 NCommon::TWriteTableSettings settings = NCommon::ParseWriteTableSettings(
                     TExprList(node.Ref().ChildPtr(4)), ctx);
-                if (!settings.Mode) {
+                if (!settings.Mode) { 
                     ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-                        << "Mode option is required for Kikimr scheme writes."));
-                    return TStatus::Error;
-                }
-
-                auto mode = settings.Mode.Cast();
+                        << "Mode option is required for Kikimr scheme writes.")); 
+                    return TStatus::Error; 
+                } 
+ 
+                auto mode = settings.Mode.Cast(); 
                 if (mode == "create") {
-                    if (!settings.Columns) {
+                    if (!settings.Columns) { 
                         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
                             << "No columns provided for create mode."));
                         return TStatus::Error;
                     }
 
                     SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), key.GetTablePath());
-                    return TStatus::Ok;
+                    return TStatus::Ok; 
                 } else if (mode == "alter") {
                     if (!settings.AlterActions) {
                         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
@@ -207,127 +207,127 @@ private:
                     }
 
                     SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), key.GetTablePath());
-                    return TStatus::Ok;
-                }
-
+                    return TStatus::Ok; 
+                } 
+ 
                 ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-                    << "Unsupported Kikimr scheme write mode: " << settings.Mode.Cast().Value()));
-                return TStatus::Error;
-            }
-
-            case TKikimrKey::Type::TableList:
-                break;
+                    << "Unsupported Kikimr scheme write mode: " << settings.Mode.Cast().Value())); 
+                return TStatus::Error; 
+            } 
+ 
+            case TKikimrKey::Type::TableList: 
+                break; 
 
             case TKikimrKey::Type::Role:
                 return TStatus::Ok;
-        }
-
+        } 
+ 
         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), "Invalid table key type."));
-        return TStatus::Error;
-    }
-
-    TStatus HandleCommit(TCoCommit node, TExprContext& ctx) override {
+        return TStatus::Error; 
+    } 
+ 
+    TStatus HandleCommit(TCoCommit node, TExprContext& ctx) override { 
         Y_UNUSED(node);
         Y_UNUSED(ctx);
-
-        return TStatus::Ok;
-    }
-
-    TStatus HandleDataQuery(TKiDataQuery node, TExprContext& ctx) override {
-        Y_UNUSED(ctx);
+ 
+        return TStatus::Ok; 
+    } 
+ 
+    TStatus HandleDataQuery(TKiDataQuery node, TExprContext& ctx) override { 
+        Y_UNUSED(ctx); 
         for (const auto& op : node.Operations()) {
             SessionCtx->Tables().GetOrAddTable(TString(op.Cluster()), SessionCtx->GetDatabase(), TString(op.Table()));
         }
-        return TStatus::Ok;
-    }
-
-    TStatus HandleExecDataQuery(TKiExecDataQuery node, TExprContext& ctx) override {
-        Y_UNUSED(node);
+        return TStatus::Ok; 
+    } 
+ 
+    TStatus HandleExecDataQuery(TKiExecDataQuery node, TExprContext& ctx) override { 
+        Y_UNUSED(node); 
+        Y_UNUSED(ctx); 
+ 
+        return TStatus::Ok; 
+    } 
+ 
+    TStatus HandleEffects(TKiEffects node, TExprContext& ctx) override { 
+        Y_UNUSED(node); 
+        Y_UNUSED(ctx); 
+ 
+        return TStatus::Ok; 
+    } 
+ 
+    TStatus HandleKql(TCallable node, TExprContext& ctx) override { 
         Y_UNUSED(ctx);
-
-        return TStatus::Ok;
-    }
-
-    TStatus HandleEffects(TKiEffects node, TExprContext& ctx) override {
-        Y_UNUSED(node);
-        Y_UNUSED(ctx);
-
-        return TStatus::Ok;
-    }
-
-    TStatus HandleKql(TCallable node, TExprContext& ctx) override {
-        Y_UNUSED(ctx);
-
-        if (auto call = node.Maybe<TKiSelectRow>()) {
-            auto cluster = call.Cast().Cluster().Value();
-            auto table = call.Cast().Table();
-
+ 
+        if (auto call = node.Maybe<TKiSelectRow>()) { 
+            auto cluster = call.Cast().Cluster().Value(); 
+            auto table = call.Cast().Table(); 
+ 
             SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table.Path()));
-            return TStatus::Ok;
-        }
-
-        if (auto call = node.Maybe<TKiSelectRangeBase>()) {
-            auto cluster = call.Cast().Cluster().Value();
-            auto table = call.Cast().Table();
-
+            return TStatus::Ok; 
+        } 
+ 
+        if (auto call = node.Maybe<TKiSelectRangeBase>()) { 
+            auto cluster = call.Cast().Cluster().Value(); 
+            auto table = call.Cast().Table(); 
+ 
             SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table.Path()));
-            return TStatus::Ok;
-        }
-
-        if (auto call = node.Maybe<TKiUpdateRow>()) {
-
-            auto cluster = call.Cast().Cluster().Value();
-            auto table = call.Cast().Table();
-
+            return TStatus::Ok; 
+        } 
+ 
+        if (auto call = node.Maybe<TKiUpdateRow>()) { 
+
+            auto cluster = call.Cast().Cluster().Value(); 
+            auto table = call.Cast().Table(); 
+ 
             SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table.Path()));
-            return TStatus::Ok;
-        }
-
-        if (auto call = node.Maybe<TKiEraseRow>()) {
-            auto cluster = call.Cast().Cluster().Value();
-            auto table = call.Cast().Table();
-
+            return TStatus::Ok; 
+        } 
+ 
+        if (auto call = node.Maybe<TKiEraseRow>()) { 
+            auto cluster = call.Cast().Cluster().Value(); 
+            auto table = call.Cast().Table(); 
+ 
             SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), TString(table.Path()));
-            return TStatus::Ok;
-        }
-
-        return TStatus::Ok;
-    }
-
-private:
+            return TStatus::Ok; 
+        } 
+ 
+        return TStatus::Ok; 
+    } 
+ 
+private: 
     TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-};
-
+}; 
+ 
 class TKikimrDataSink : public TDataProviderBase
-{
-public:
-    TKikimrDataSink(
-        const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
+{ 
+public: 
+    TKikimrDataSink( 
+        const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry, 
         TTypeAnnotationContext& types,
-        TIntrusivePtr<IKikimrGateway> gateway,
-        TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-        TIntrusivePtr<IKikimrQueryExecutor> queryExecutor)
+        TIntrusivePtr<IKikimrGateway> gateway, 
+        TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+        TIntrusivePtr<IKikimrQueryExecutor> queryExecutor) 
         : FunctionRegistry(functionRegistry)
-        , Types(types)
-        , Gateway(gateway)
-        , SessionCtx(sessionCtx)
-        , IntentDeterminationTransformer(CreateKiSinkIntentDeterminationTransformer(sessionCtx))
-        , TypeAnnotationTransformer(CreateKiSinkTypeAnnotationTransformer(gateway, sessionCtx))
-        , LogicalOptProposalTransformer(CreateKiLogicalOptProposalTransformer(sessionCtx))
-        , PhysicalOptProposalTransformer(CreateKiPhysicalOptProposalTransformer(sessionCtx))
+        , Types(types) 
+        , Gateway(gateway) 
+        , SessionCtx(sessionCtx) 
+        , IntentDeterminationTransformer(CreateKiSinkIntentDeterminationTransformer(sessionCtx)) 
+        , TypeAnnotationTransformer(CreateKiSinkTypeAnnotationTransformer(gateway, sessionCtx)) 
+        , LogicalOptProposalTransformer(CreateKiLogicalOptProposalTransformer(sessionCtx)) 
+        , PhysicalOptProposalTransformer(CreateKiPhysicalOptProposalTransformer(sessionCtx)) 
         , CallableExecutionTransformer(CreateKiSinkCallableExecutionTransformer(gateway, sessionCtx, queryExecutor))
-        , PlanInfoTransformer(CreateKiSinkPlanInfoTransformer(queryExecutor))
-    {
+        , PlanInfoTransformer(CreateKiSinkPlanInfoTransformer(queryExecutor)) 
+    { 
         Y_UNUSED(FunctionRegistry);
         Y_UNUSED(Types);
-
+ 
         Y_VERIFY_DEBUG(gateway);
-        Y_VERIFY_DEBUG(sessionCtx);
-        Y_VERIFY_DEBUG(queryExecutor);
-    }
-
-    ~TKikimrDataSink() {}
-
+        Y_VERIFY_DEBUG(sessionCtx); 
+        Y_VERIFY_DEBUG(queryExecutor); 
+    } 
+ 
+    ~TKikimrDataSink() {} 
+ 
     TStringBuf GetName() const override {
         return KikimrProviderName;
     }
@@ -361,73 +361,73 @@ public:
             .Done().Ptr();
     }
 
-    IGraphTransformer& GetIntentDeterminationTransformer() override {
-        return *IntentDeterminationTransformer;
-    }
-
-    IGraphTransformer& GetLogicalOptProposalTransformer() override {
-        return *LogicalOptProposalTransformer;
-    }
-
-    IGraphTransformer& GetPhysicalOptProposalTransformer() override {
-        return *PhysicalOptProposalTransformer;
-    }
-
+    IGraphTransformer& GetIntentDeterminationTransformer() override { 
+        return *IntentDeterminationTransformer; 
+    } 
+ 
+    IGraphTransformer& GetLogicalOptProposalTransformer() override { 
+        return *LogicalOptProposalTransformer; 
+    } 
+ 
+    IGraphTransformer& GetPhysicalOptProposalTransformer() override { 
+        return *PhysicalOptProposalTransformer; 
+    } 
+ 
     IGraphTransformer& GetTypeAnnotationTransformer(bool instantOnly) override {
         Y_UNUSED(instantOnly);
-        return *TypeAnnotationTransformer;
-    }
-
-    IGraphTransformer& GetCallableExecutionTransformer() override {
-        return *CallableExecutionTransformer;
-    }
-
-    IGraphTransformer& GetPlanInfoTransformer() override {
-        return *PlanInfoTransformer;
-    }
-
+        return *TypeAnnotationTransformer; 
+    } 
+ 
+    IGraphTransformer& GetCallableExecutionTransformer() override { 
+        return *CallableExecutionTransformer; 
+    } 
+ 
+    IGraphTransformer& GetPlanInfoTransformer() override { 
+        return *PlanInfoTransformer; 
+    } 
+ 
     bool ValidateParameters(TExprNode& node, TExprContext& ctx, TMaybe<TString>& cluster) override {
         if (node.IsCallable(TCoDataSink::CallableName())) {
             if (node.Child(0)->Content() == KikimrProviderName) {
                 if (node.Child(1)->Content().empty()) {
                     ctx.AddError(TIssue(ctx.GetPosition(node.Child(1)->Pos()), "Empty cluster name"));
-                    return false;
-                }
-
-                cluster = TString(node.Child(1)->Content());
-                return true;
-            }
-        }
-
+                    return false; 
+                } 
+ 
+                cluster = TString(node.Child(1)->Content()); 
+                return true; 
+            } 
+        } 
+ 
         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), "Invalid Kikimr DataSink parameters."));
-        return false;
-    }
-
-    bool CanParse(const TExprNode& node) override {
+        return false; 
+    } 
+ 
+    bool CanParse(const TExprNode& node) override { 
         if (node.IsCallable(WriteName)) {
             return node.Child(1)->Child(0)->Content() == KikimrProviderName;
-        }
-
+        } 
+ 
         if (KikimrDataSinkFunctions().contains(node.Content()) ||
             KikimrKqlFunctions().contains(node.Content()))
-        {
-            return true;
-        }
-
-        return false;
-    }
-
+        { 
+            return true; 
+        } 
+ 
+        return false; 
+    } 
+ 
     bool CanExecute(const TExprNode& node) override {
         if (node.IsCallable(TKiExecDataQuery::CallableName())) {
-            return true;
-        }
-
+            return true; 
+        } 
+ 
         if (node.IsCallable(TKiCreateTable::CallableName())
             || node.IsCallable(TKiDropTable::CallableName())
             || node.IsCallable(TKiAlterTable::CallableName())) {
-            return true;
-        }
-
+            return true; 
+        } 
+ 
         if (node.IsCallable(TKiCreateUser::CallableName())
             || node.IsCallable(TKiAlterUser::CallableName())
             || node.IsCallable(TKiDropUser::CallableName())
@@ -437,108 +437,108 @@ public:
             return true;
         }
 
-        if (auto maybeRight = TMaybeNode<TCoNth>(&node).Tuple().Maybe<TCoRight>()) {
+        if (auto maybeRight = TMaybeNode<TCoNth>(&node).Tuple().Maybe<TCoRight>()) { 
             if (maybeRight.Input().Maybe<TKiExecDataQuery>()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
+                return true; 
+            } 
+        } 
+ 
+        return false; 
+    } 
+ 
     bool CollectDiagnostics(NYson::TYsonWriter& writer) override {
-        auto& execResults = SessionCtx->Query().Results;
-        if (!std::find_if(execResults.begin(), execResults.end(),
-            [] (const auto& pair) { return pair.second.Profile; }))
-        {
-            return false;
-        }
-
-        writer.OnBeginMap();
-        writer.OnKeyedItem("KqlProfiles");
-        writer.OnBeginList();
-
-        for (auto& pair : execResults) {
-            auto& result = pair.second;
-            if (result.Profile) {
-                writer.OnListItem();
-
-                YQL_ENSURE(result.Profile->GetKqlProfiles().size() == 1);
-                auto& kqlProfile = result.Profile->GetKqlProfiles(0);
-
-                KikimrProfileToYson(kqlProfile, writer);
-            }
-        }
-
-        writer.OnEndList();
-        writer.OnEndMap();
-
-        return true;
-    }
-
+        auto& execResults = SessionCtx->Query().Results; 
+        if (!std::find_if(execResults.begin(), execResults.end(), 
+            [] (const auto& pair) { return pair.second.Profile; })) 
+        { 
+            return false; 
+        } 
+ 
+        writer.OnBeginMap(); 
+        writer.OnKeyedItem("KqlProfiles"); 
+        writer.OnBeginList(); 
+ 
+        for (auto& pair : execResults) { 
+            auto& result = pair.second; 
+            if (result.Profile) { 
+                writer.OnListItem(); 
+ 
+                YQL_ENSURE(result.Profile->GetKqlProfiles().size() == 1); 
+                auto& kqlProfile = result.Profile->GetKqlProfiles(0); 
+ 
+                KikimrProfileToYson(kqlProfile, writer); 
+            } 
+        } 
+ 
+        writer.OnEndList(); 
+        writer.OnEndMap(); 
+ 
+        return true; 
+    } 
+ 
     TExprNode::TPtr RewriteIO(const TExprNode::TPtr& node, TExprContext& ctx) override {
         YQL_ENSURE(node->IsCallable(WriteName), "Expected Write!, got: " << node->Content());
-
-        TKikimrKey key(ctx);
+ 
+        TKikimrKey key(ctx); 
         YQL_ENSURE(key.Extract(*node->Child(2)), "Failed to extract ydb key.");
-
-        switch (key.GetKeyType()) {
-            case TKikimrKey::Type::Table: {
+ 
+        switch (key.GetKeyType()) { 
+            case TKikimrKey::Type::Table: { 
                 NCommon::TWriteTableSettings settings = NCommon::ParseWriteTableSettings(TExprList(node->Child(4)), ctx);
-                YQL_ENSURE(settings.Mode);
-                auto mode = settings.Mode.Cast();
-
-                if (mode == "drop") {
-                    YQL_ENSURE(!settings.Columns);
+                YQL_ENSURE(settings.Mode); 
+                auto mode = settings.Mode.Cast(); 
+ 
+                if (mode == "drop") { 
+                    YQL_ENSURE(!settings.Columns); 
                     return Build<TKiDropTable>(ctx, node->Pos())
                         .World(node->Child(0))
                         .DataSink(node->Child(1))
-                        .Table().Build(key.GetTablePath())
-                        .Settings(settings.Other)
-                        .Done()
+                        .Table().Build(key.GetTablePath()) 
+                        .Settings(settings.Other) 
+                        .Done() 
                         .Ptr();
-                } else if (mode == "update") {
-                    YQL_ENSURE(settings.Filter);
-                    YQL_ENSURE(settings.Update);
+                } else if (mode == "update") { 
+                    YQL_ENSURE(settings.Filter); 
+                    YQL_ENSURE(settings.Update); 
                     return Build<TKiUpdateTable>(ctx, node->Pos())
                         .World(node->Child(0))
                         .DataSink(node->Child(1))
-                        .Table().Build(key.GetTablePath())
-                        .Filter(settings.Filter.Cast())
-                        .Update(settings.Update.Cast())
-                        .Done()
+                        .Table().Build(key.GetTablePath()) 
+                        .Filter(settings.Filter.Cast()) 
+                        .Update(settings.Update.Cast()) 
+                        .Done() 
                         .Ptr();
-                } else if (mode == "delete") {
-                    YQL_ENSURE(settings.Filter);
+                } else if (mode == "delete") { 
+                    YQL_ENSURE(settings.Filter); 
                     return Build<TKiDeleteTable>(ctx, node->Pos())
                         .World(node->Child(0))
                         .DataSink(node->Child(1))
-                        .Table().Build(key.GetTablePath())
-                        .Filter(settings.Filter.Cast())
-                        .Done()
+                        .Table().Build(key.GetTablePath()) 
+                        .Filter(settings.Filter.Cast()) 
+                        .Done() 
                         .Ptr();
-                } else {
+                } else { 
                     return Build<TKiWriteTable>(ctx, node->Pos())
                         .World(node->Child(0))
                         .DataSink(node->Child(1))
-                        .Table().Build(key.GetTablePath())
+                        .Table().Build(key.GetTablePath()) 
                         .Input(node->Child(3))
-                        .Mode(mode)
-                        .Settings(settings.Other)
-                        .Done()
+                        .Mode(mode) 
+                        .Settings(settings.Other) 
+                        .Done() 
                         .Ptr();
-                }
-            }
-
-            case TKikimrKey::Type::TableScheme: {
+                } 
+            } 
+ 
+            case TKikimrKey::Type::TableScheme: { 
                 NCommon::TWriteTableSettings settings = NCommon::ParseWriteTableSettings(TExprList(node->Child(4)), ctx);
-                YQL_ENSURE(settings.Mode);
-                auto mode = settings.Mode.Cast();
+                YQL_ENSURE(settings.Mode); 
+                auto mode = settings.Mode.Cast(); 
                 if (mode == "create") {
                     YQL_ENSURE(settings.Columns);
                     YQL_ENSURE(!settings.Columns.Cast().Empty());
-
-                    if (!settings.PrimaryKey) {
+ 
+                    if (!settings.PrimaryKey) { 
                         ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), "Primary key is required for ydb tables."));
                         return nullptr;
                     }
@@ -551,9 +551,9 @@ public:
                         .World(node->Child(0))
                         .DataSink(node->Child(1))
                         .Table().Build(key.GetTablePath())
-                        .Columns(settings.Columns.Cast())
-                        .PrimaryKey(settings.PrimaryKey.Cast())
-                        .Settings(settings.Other)
+                        .Columns(settings.Columns.Cast()) 
+                        .PrimaryKey(settings.PrimaryKey.Cast()) 
+                        .Settings(settings.Other) 
                         .Indexes(settings.Indexes.Cast())
                         .Changefeeds(settings.Changefeeds.Cast())
                         .PartitionBy(settings.PartitionBy.Cast())
@@ -562,8 +562,8 @@ public:
                         .Done()
                         .Ptr();
                 } else if (mode == "alter") {
-                    for (auto setting : settings.Other) {
-                        if (setting.Name().Value() == "intent") {
+                    for (auto setting : settings.Other) { 
+                        if (setting.Name().Value() == "intent") { 
                             ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), "Old AST format for AlterTable"));
                             return nullptr;
                         }
@@ -582,10 +582,10 @@ public:
                 } else {
                     YQL_ENSURE(false, "unknown TableScheme mode \"" << TString(mode) << "\"");
                 }
-            }
-
-            case TKikimrKey::Type::TableList:
-                break;
+            } 
+ 
+            case TKikimrKey::Type::TableList: 
+                break; 
 
             case TKikimrKey::Type::Role: {
                 NCommon::TWriteRoleSettings settings = NCommon::ParseWriteRoleSettings(TExprList(node->Child(4)), ctx);
@@ -645,87 +645,87 @@ public:
                 }
                 break;
             }
-        }
-
+        } 
+ 
         ctx.AddError(TIssue(ctx.GetPosition(node->Pos()), "Failed to rewrite IO."));
-        return nullptr;
-    }
-
+        return nullptr; 
+    } 
+ 
     bool GetDependencies(const TExprNode& node, TExprNode::TListType& children, bool compact) override {
         Y_UNUSED(compact);
-        if (CanExecute(node)) {
+        if (CanExecute(node)) { 
             children.push_back(node.ChildPtr(0));
-            return true;
-        }
-
-        return false;
-    }
-
+            return true; 
+        } 
+ 
+        return false; 
+    } 
+ 
     void GetInputs(const TExprNode&, TVector<TPinInfo>&) override {
-    }
-
+    } 
+ 
     void GetOutputs(const TExprNode&, TVector<TPinInfo>&) override {
-    }
-
+    } 
+ 
     void WritePlanDetails(const TExprNode&, NYson::TYsonWriter&) override {
-    }
-
+    } 
+ 
     TString GetProviderPath(const TExprNode&) override {
         return TString(KikimrProviderName);
-    }
-
-private:
-    const NKikimr::NMiniKQL::IFunctionRegistry& FunctionRegistry;
-    const TTypeAnnotationContext& Types;
-    TIntrusivePtr<IKikimrGateway> Gateway;
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-
-    TAutoPtr<IGraphTransformer> IntentDeterminationTransformer;
-    TAutoPtr<IGraphTransformer> TypeAnnotationTransformer;
-    TAutoPtr<IGraphTransformer> LogicalOptProposalTransformer;
-    TAutoPtr<IGraphTransformer> PhysicalOptProposalTransformer;
-    TAutoPtr<IGraphTransformer> CallableExecutionTransformer;
-    TAutoPtr<IGraphTransformer> PlanInfoTransformer;
-};
-
-} // namespace
-
-IGraphTransformer::TStatus TKiSinkVisitorTransformer::DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output,
-    TExprContext& ctx)
-{
+    } 
+ 
+private: 
+    const NKikimr::NMiniKQL::IFunctionRegistry& FunctionRegistry; 
+    const TTypeAnnotationContext& Types; 
+    TIntrusivePtr<IKikimrGateway> Gateway; 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+ 
+    TAutoPtr<IGraphTransformer> IntentDeterminationTransformer; 
+    TAutoPtr<IGraphTransformer> TypeAnnotationTransformer; 
+    TAutoPtr<IGraphTransformer> LogicalOptProposalTransformer; 
+    TAutoPtr<IGraphTransformer> PhysicalOptProposalTransformer; 
+    TAutoPtr<IGraphTransformer> CallableExecutionTransformer; 
+    TAutoPtr<IGraphTransformer> PlanInfoTransformer; 
+}; 
+ 
+} // namespace 
+ 
+IGraphTransformer::TStatus TKiSinkVisitorTransformer::DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, 
+    TExprContext& ctx) 
+{ 
     YQL_ENSURE(input->Type() == TExprNode::Callable);
     output = input;
-
+ 
     auto callable = TCallable(input);
-
+ 
     if (auto node = callable.Maybe<TKiClusterConfig>()) {
         return HandleClusterConfig(node.Cast(), ctx);
     }
 
-    if (auto node = callable.Maybe<TKiWriteTable>()) {
-        return HandleWriteTable(node.Cast(), ctx);
-    }
-
-    if (auto node = callable.Maybe<TKiUpdateTable>()) {
-        return HandleUpdateTable(node.Cast(), ctx);
-    }
-
-    if (auto node = callable.Maybe<TKiDeleteTable>()) {
-        return HandleDeleteTable(node.Cast(), ctx);
-    }
-
+    if (auto node = callable.Maybe<TKiWriteTable>()) { 
+        return HandleWriteTable(node.Cast(), ctx); 
+    } 
+ 
+    if (auto node = callable.Maybe<TKiUpdateTable>()) { 
+        return HandleUpdateTable(node.Cast(), ctx); 
+    } 
+ 
+    if (auto node = callable.Maybe<TKiDeleteTable>()) { 
+        return HandleDeleteTable(node.Cast(), ctx); 
+    } 
+ 
     if (auto node = TMaybeNode<TKiCreateTable>(input)) {
-        return HandleCreateTable(node.Cast(), ctx);
-    }
-
+        return HandleCreateTable(node.Cast(), ctx); 
+    } 
+ 
     if (auto node = TMaybeNode<TKiAlterTable>(input)) {
         return HandleAlterTable(node.Cast(), ctx);
     }
 
     if (auto node = TMaybeNode<TKiDropTable>(input)) {
-        return HandleDropTable(node.Cast(), ctx);
-    }
-
+        return HandleDropTable(node.Cast(), ctx); 
+    } 
+ 
     if (auto node = TMaybeNode<TKiCreateUser>(input)) {
         return HandleCreateUser(node.Cast(), ctx);
     }
@@ -752,47 +752,47 @@ IGraphTransformer::TStatus TKiSinkVisitorTransformer::DoTransform(TExprNode::TPt
 
     if (input->IsCallable(WriteName)) {
         return HandleWrite(TExprBase(input), ctx);
-    }
-
+    } 
+ 
     if (auto node = callable.Maybe<TCoCommit>()) {
-        return HandleCommit(node.Cast(), ctx);
-    }
-
-    if (auto node = callable.Maybe<TKiDataQuery>()) {
-        return HandleDataQuery(node.Cast(), ctx);
-    }
-
-    if (auto node = callable.Maybe<TKiExecDataQuery>()) {
-        return HandleExecDataQuery(node.Cast(), ctx);
-    }
-
-    if (auto node = callable.Maybe<TKiEffects>()) {
-        return HandleEffects(node.Cast(), ctx);
-    }
-
+        return HandleCommit(node.Cast(), ctx); 
+    } 
+ 
+    if (auto node = callable.Maybe<TKiDataQuery>()) { 
+        return HandleDataQuery(node.Cast(), ctx); 
+    } 
+ 
+    if (auto node = callable.Maybe<TKiExecDataQuery>()) { 
+        return HandleExecDataQuery(node.Cast(), ctx); 
+    } 
+ 
+    if (auto node = callable.Maybe<TKiEffects>()) { 
+        return HandleEffects(node.Cast(), ctx); 
+    } 
+ 
     if (KikimrKqlFunctions().contains(callable.CallableName())) {
-        return HandleKql(callable, ctx);
-    }
-
+        return HandleKql(callable, ctx); 
+    } 
+ 
     ctx.AddError(TIssue(ctx.GetPosition(input->Pos()), TStringBuilder() << "(Kikimr DataSink) Unsupported function: "
-        << callable.CallableName()));
-    return TStatus::Error;
-}
-
-TIntrusivePtr<IDataProvider> CreateKikimrDataSink(
-    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
+        << callable.CallableName())); 
+    return TStatus::Error; 
+} 
+ 
+TIntrusivePtr<IDataProvider> CreateKikimrDataSink( 
+    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry, 
     TTypeAnnotationContext& types,
-    TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-    TIntrusivePtr<IKikimrQueryExecutor> queryExecutor)
-{
-    return new TKikimrDataSink(functionRegistry, types, gateway, sessionCtx, queryExecutor);
-}
-
-TAutoPtr<IGraphTransformer> CreateKiSinkIntentDeterminationTransformer(
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx)
-{
+    TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+    TIntrusivePtr<IKikimrQueryExecutor> queryExecutor) 
+{ 
+    return new TKikimrDataSink(functionRegistry, types, gateway, sessionCtx, queryExecutor); 
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKiSinkIntentDeterminationTransformer( 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
+{ 
     return new TKiSinkIntentDeterminationTransformer(sessionCtx);
-}
-
-} // namespace NYql
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_datasource.cpp b/ydb/core/kqp/provider/yql_kikimr_datasource.cpp
index 65ef7eb932..08acbf5973 100644
--- a/ydb/core/kqp/provider/yql_kikimr_datasource.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_datasource.cpp
@@ -1,123 +1,123 @@
-#include "yql_kikimr_provider_impl.h"
-
+#include "yql_kikimr_provider_impl.h" 
+ 
 #include <ydb/library/yql/providers/common/provider/yql_data_provider_impl.h>
 #include <ydb/library/yql/providers/common/config/yql_configuration_transformer.h>
 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 #include <ydb/library/yql/core/yql_expr_type_annotation.h>
-
-namespace NYql {
-namespace {
-
-using namespace NKikimr;
-using namespace NNodes;
-
-class TKiSourceIntentDeterminationTransformer: public TKiSourceVisitorTransformer {
-public:
-    TKiSourceIntentDeterminationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx)
-        : SessionCtx(sessionCtx) {}
-
-private:
-    TStatus HandleKiRead(TKiReadBase node, TExprContext& ctx) override {
-        auto cluster = node.DataSource().Cluster();
-        TKikimrKey key(ctx);
+ 
+namespace NYql { 
+namespace { 
+ 
+using namespace NKikimr; 
+using namespace NNodes; 
+ 
+class TKiSourceIntentDeterminationTransformer: public TKiSourceVisitorTransformer { 
+public: 
+    TKiSourceIntentDeterminationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
+        : SessionCtx(sessionCtx) {} 
+ 
+private: 
+    TStatus HandleKiRead(TKiReadBase node, TExprContext& ctx) override { 
+        auto cluster = node.DataSource().Cluster(); 
+        TKikimrKey key(ctx); 
         if (!key.Extract(node.TableKey().Ref())) {
-            return TStatus::Error;
-        }
-
+            return TStatus::Error; 
+        } 
+ 
         return HandleKey(cluster, key);
-    }
-
-    TStatus HandleRead(TExprBase node, TExprContext& ctx) override {
+    } 
+ 
+    TStatus HandleRead(TExprBase node, TExprContext& ctx) override { 
         auto cluster = node.Ref().Child(1)->Child(1)->Content();
-        TKikimrKey key(ctx);
+        TKikimrKey key(ctx); 
         if (!key.Extract(*node.Ref().Child(2))) {
-            return TStatus::Error;
-        }
-
+            return TStatus::Error; 
+        } 
+ 
         return HandleKey(cluster, key);
-    }
-
-    TStatus HandleLength(TExprBase node, TExprContext& ctx) override {
+    } 
+ 
+    TStatus HandleLength(TExprBase node, TExprContext& ctx) override { 
         Y_UNUSED(node);
         Y_UNUSED(ctx);
-        return TStatus::Ok;
-    }
-
-    TStatus HandleConfigure(TExprBase node, TExprContext& ctx) override {
+        return TStatus::Ok; 
+    } 
+ 
+    TStatus HandleConfigure(TExprBase node, TExprContext& ctx) override { 
         Y_UNUSED(node);
         Y_UNUSED(ctx);
-        return TStatus::Ok;
-    }
-
-private:
+        return TStatus::Ok; 
+    } 
+ 
+private: 
     TStatus HandleKey(const TStringBuf& cluster, const TKikimrKey& key) {
-        switch (key.GetKeyType()) {
-            case TKikimrKey::Type::Table:
-            case TKikimrKey::Type::TableScheme: {
+        switch (key.GetKeyType()) { 
+            case TKikimrKey::Type::Table: 
+            case TKikimrKey::Type::TableScheme: { 
                 auto& table = SessionCtx->Tables().GetOrAddTable(TString(cluster), SessionCtx->GetDatabase(), key.GetTablePath());
-
-                if (key.GetKeyType() == TKikimrKey::Type::TableScheme) {
-                    table.RequireStats();
-                }
-
-                return TStatus::Ok;
-            }
-
-            case TKikimrKey::Type::TableList:
-                return TStatus::Ok;
+ 
+                if (key.GetKeyType() == TKikimrKey::Type::TableScheme) { 
+                    table.RequireStats(); 
+                } 
+ 
+                return TStatus::Ok; 
+            } 
+ 
+            case TKikimrKey::Type::TableList: 
+                return TStatus::Ok; 
 
             case TKikimrKey::Type::Role:
                 return TStatus::Ok;
-        }
-
+        } 
+ 
         return TStatus::Error;
-    }
-
-private:
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-};
-
-class TKiSourceLoadTableMetadataTransformer : public TGraphTransformerBase {
-public:
-    TKiSourceLoadTableMetadataTransformer(
-        TIntrusivePtr<IKikimrGateway> gateway,
-        TIntrusivePtr<TKikimrSessionContext> sessionCtx)
-        : Gateway(gateway)
-        , SessionCtx(sessionCtx) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    } 
+ 
+private: 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+}; 
+ 
+class TKiSourceLoadTableMetadataTransformer : public TGraphTransformerBase { 
+public: 
+    TKiSourceLoadTableMetadataTransformer( 
+        TIntrusivePtr<IKikimrGateway> gateway, 
+        TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
+        : Gateway(gateway) 
+        , SessionCtx(sessionCtx) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         output = input;
-
-        if (ctx.Step.IsDone(TExprStep::LoadTablesMetadata)) {
-            return TStatus::Ok;
-        }
-
-        size_t tablesCount = SessionCtx->Tables().GetTables().size();
-        TVector<NThreading::TFuture<void>> futures;
-        futures.reserve(tablesCount);
-
-        for (auto& it : SessionCtx->Tables().GetTables()) {
+ 
+        if (ctx.Step.IsDone(TExprStep::LoadTablesMetadata)) { 
+            return TStatus::Ok; 
+        } 
+ 
+        size_t tablesCount = SessionCtx->Tables().GetTables().size(); 
+        TVector<NThreading::TFuture<void>> futures; 
+        futures.reserve(tablesCount); 
+ 
+        for (auto& it : SessionCtx->Tables().GetTables()) { 
             const TString& clusterName = it.first.first;
             const TString& tableName = it.first.second;
-            TKikimrTableDescription& table = SessionCtx->Tables().GetTable(clusterName, tableName);
-
-            if (table.Metadata) {
-                continue;
-            }
-
-            auto emplaceResult = LoadResults.emplace(std::make_pair(clusterName, tableName),
+            TKikimrTableDescription& table = SessionCtx->Tables().GetTable(clusterName, tableName); 
+ 
+            if (table.Metadata) { 
+                continue; 
+            } 
+ 
+            auto emplaceResult = LoadResults.emplace(std::make_pair(clusterName, tableName), 
                 std::make_shared<IKikimrGateway::TTableMetadataResult>());
-
-            YQL_ENSURE(emplaceResult.second);
+ 
+            YQL_ENSURE(emplaceResult.second); 
             auto queryType = SessionCtx->Query().Type;
-            auto& result = emplaceResult.first->second;
-
+            auto& result = emplaceResult.first->second; 
+ 
             auto future = Gateway->LoadTableMetadata(clusterName, tableName,
                 IKikimrGateway::TLoadTableMetadataSettings().WithTableStats(table.GetNeedsStats()));
 
             futures.push_back(future.Apply([result, queryType]
-                (const NThreading::TFuture<IKikimrGateway::TTableMetadataResult>& future) {
+                (const NThreading::TFuture<IKikimrGateway::TTableMetadataResult>& future) { 
                     YQL_ENSURE(!future.HasException());
                     const auto& value = future.GetValue();
                     switch (queryType) {
@@ -136,37 +136,37 @@ public:
                         break;
                     }
                     *result = value;
-                }));
-        }
-
-        if (futures.empty()) {
-            return TStatus::Ok;
-        }
-
+                })); 
+        } 
+ 
+        if (futures.empty()) { 
+            return TStatus::Ok; 
+        } 
+ 
         AsyncFuture = NThreading::WaitExceptionOrAll(futures);
-        return TStatus::Async;
-    }
-
-    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
+        return TStatus::Async; 
+    } 
+ 
+    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
         Y_UNUSED(input);
-        return AsyncFuture;
-    }
-
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+        return AsyncFuture; 
+    } 
+ 
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         output = input;
         YQL_ENSURE(AsyncFuture.HasValue());
-
-        for (auto& it : LoadResults) {
-            const auto& table = it.first;
-            IKikimrGateway::TTableMetadataResult& res = *it.second;
-
-            if (res.Success()) {
-                res.ReportIssues(ctx.IssueManager);
-                auto& tableDesc = SessionCtx->Tables().GetTable(it.first.first, it.first.second);
-
+ 
+        for (auto& it : LoadResults) { 
+            const auto& table = it.first; 
+            IKikimrGateway::TTableMetadataResult& res = *it.second; 
+ 
+            if (res.Success()) { 
+                res.ReportIssues(ctx.IssueManager); 
+                auto& tableDesc = SessionCtx->Tables().GetTable(it.first.first, it.first.second); 
+ 
                 YQL_ENSURE(res.Metadata);
-                tableDesc.Metadata = res.Metadata;
-
+                tableDesc.Metadata = res.Metadata; 
+ 
                 bool sysColumnsEnabled = SessionCtx->Config().SystemColumnsEnabled();
                 YQL_ENSURE(res.Metadata->Indexes.size() == res.Metadata->SecondaryGlobalIndexMetadata.size());
                 for (const auto& indexMeta : res.Metadata->SecondaryGlobalIndexMetadata) {
@@ -177,220 +177,220 @@ public:
                 }
 
                 if (!tableDesc.Load(ctx, sysColumnsEnabled)) {
-                    LoadResults.clear();
-                    return TStatus::Error;
-                }
-            } else {
+                    LoadResults.clear(); 
+                    return TStatus::Error; 
+                } 
+            } else { 
                 TIssueScopeGuard issueScope(ctx.IssueManager, [input, &table, &ctx]() {
                     return MakeIntrusive<TIssue>(TIssue(ctx.GetPosition(input->Pos()), TStringBuilder()
-                        << "Failed to load metadata for table: "
-                        << NCommon::FullTableName(table.first, table.second)));
-                });
-
-                res.ReportIssues(ctx.IssueManager);
-                LoadResults.clear();
-                return TStatus::Error;
-            }
-        }
-
-        LoadResults.clear();
-        return TStatus::Ok;
-    }
-
-private:
-    TIntrusivePtr<IKikimrGateway> Gateway;
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-
+                        << "Failed to load metadata for table: " 
+                        << NCommon::FullTableName(table.first, table.second))); 
+                }); 
+ 
+                res.ReportIssues(ctx.IssueManager); 
+                LoadResults.clear(); 
+                return TStatus::Error; 
+            } 
+        } 
+ 
+        LoadResults.clear(); 
+        return TStatus::Ok; 
+    } 
+ 
+private: 
+    TIntrusivePtr<IKikimrGateway> Gateway; 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+ 
     THashMap<std::pair<TString, TString>, std::shared_ptr<IKikimrGateway::TTableMetadataResult>> LoadResults;
-    NThreading::TFuture<void> AsyncFuture;
-};
-
-class TKikimrConfigurationTransformer : public NCommon::TProviderConfigurationTransformer {
-public:
-    TKikimrConfigurationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-        const TTypeAnnotationContext& types)
-        : TProviderConfigurationTransformer(sessionCtx->ConfigPtr(), types, TString(KikimrProviderName))
-        , SessionCtx(sessionCtx) {}
-
-protected:
-    const THashSet<TStringBuf> AllowedScriptingPragmas = {
-        "scanquery"
-    };
-
+    NThreading::TFuture<void> AsyncFuture; 
+}; 
+ 
+class TKikimrConfigurationTransformer : public NCommon::TProviderConfigurationTransformer { 
+public: 
+    TKikimrConfigurationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+        const TTypeAnnotationContext& types) 
+        : TProviderConfigurationTransformer(sessionCtx->ConfigPtr(), types, TString(KikimrProviderName)) 
+        , SessionCtx(sessionCtx) {} 
+ 
+protected: 
+    const THashSet<TStringBuf> AllowedScriptingPragmas = { 
+        "scanquery" 
+    }; 
+ 
     bool HandleAttr(TPositionHandle pos, const TString& cluster, const TString& name, const TMaybe<TString>& value,
-        TExprContext& ctx) final
-    {
+        TExprContext& ctx) final 
+    { 
         YQL_ENSURE(SessionCtx->Query().Type != EKikimrQueryType::Unspecified);
-
-        bool applied = Dispatcher->Dispatch(cluster, name, value, NCommon::TSettingDispatcher::EStage::STATIC);
-
-        if (!applied) {
-            bool pragmaAllowed = false;
-
-            switch (SessionCtx->Query().Type) {
-                case EKikimrQueryType::YqlInternal:
-                    pragmaAllowed = true;
-                    break;
-
-                case EKikimrQueryType::YqlScript:
+ 
+        bool applied = Dispatcher->Dispatch(cluster, name, value, NCommon::TSettingDispatcher::EStage::STATIC); 
+ 
+        if (!applied) { 
+            bool pragmaAllowed = false; 
+ 
+            switch (SessionCtx->Query().Type) { 
+                case EKikimrQueryType::YqlInternal: 
+                    pragmaAllowed = true; 
+                    break; 
+ 
+                case EKikimrQueryType::YqlScript: 
                 case EKikimrQueryType::YqlScriptStreaming:
-                    pragmaAllowed = AllowedScriptingPragmas.contains(name);
-                    break;
-
-                default:
-                    break;
-            }
-
-            if (!pragmaAllowed) {
-                ctx.AddError(YqlIssue(ctx.GetPosition(pos), TIssuesIds::KIKIMR_PRAGMA_NOT_SUPPORTED, TStringBuilder()
-                    << "Pragma can't be set for YDB query in current execution mode: " << name));
-                return false;
-            }
-        }
-
-        return true;
-    }
-
+                    pragmaAllowed = AllowedScriptingPragmas.contains(name); 
+                    break; 
+ 
+                default: 
+                    break; 
+            } 
+ 
+            if (!pragmaAllowed) { 
+                ctx.AddError(YqlIssue(ctx.GetPosition(pos), TIssuesIds::KIKIMR_PRAGMA_NOT_SUPPORTED, TStringBuilder() 
+                    << "Pragma can't be set for YDB query in current execution mode: " << name)); 
+                return false; 
+            } 
+        } 
+ 
+        return true; 
+    } 
+ 
     bool HandleAuth(TPositionHandle pos, const TString& cluster, const TString& alias, TExprContext& ctx) final {
         YQL_ENSURE(SessionCtx->Query().Type != EKikimrQueryType::Unspecified);
 
         if (SessionCtx->Query().Type != EKikimrQueryType::YqlInternal) {
             ctx.AddError(YqlIssue(ctx.GetPosition(pos), TIssuesIds::KIKIMR_PRAGMA_NOT_SUPPORTED, TStringBuilder()
-                << "Pragma auth not supported inside Kikimr query."));
-            return false;
-        }
-
-        return TProviderConfigurationTransformer::HandleAuth(pos, cluster, alias, ctx);
-    }
-
-private:
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-};
-
+                << "Pragma auth not supported inside Kikimr query.")); 
+            return false; 
+        } 
+ 
+        return TProviderConfigurationTransformer::HandleAuth(pos, cluster, alias, ctx); 
+    } 
+ 
+private: 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+}; 
+ 
 class TKikimrDataSource : public TDataProviderBase {
-public:
-    TKikimrDataSource(
-        const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
-        TTypeAnnotationContext& types,
-        TIntrusivePtr<IKikimrGateway> gateway,
-        TIntrusivePtr<TKikimrSessionContext> sessionCtx)
+public: 
+    TKikimrDataSource( 
+        const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry, 
+        TTypeAnnotationContext& types, 
+        TIntrusivePtr<IKikimrGateway> gateway, 
+        TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
         : FunctionRegistry(functionRegistry)
-        , Types(types)
-        , Gateway(gateway)
-        , SessionCtx(sessionCtx)
-        , ConfigurationTransformer(new TKikimrConfigurationTransformer(sessionCtx, types))
-        , IntentDeterminationTransformer(new TKiSourceIntentDeterminationTransformer(sessionCtx))
-        , LoadTableMetadataTransformer(CreateKiSourceLoadTableMetadataTransformer(gateway, sessionCtx))
+        , Types(types) 
+        , Gateway(gateway) 
+        , SessionCtx(sessionCtx) 
+        , ConfigurationTransformer(new TKikimrConfigurationTransformer(sessionCtx, types)) 
+        , IntentDeterminationTransformer(new TKiSourceIntentDeterminationTransformer(sessionCtx)) 
+        , LoadTableMetadataTransformer(CreateKiSourceLoadTableMetadataTransformer(gateway, sessionCtx)) 
         , TypeAnnotationTransformer(CreateKiSourceTypeAnnotationTransformer(sessionCtx, types))
-        , CallableExecutionTransformer(CreateKiSourceCallableExecutionTransformer(gateway, sessionCtx))
-
-    {
+        , CallableExecutionTransformer(CreateKiSourceCallableExecutionTransformer(gateway, sessionCtx)) 
+ 
+    { 
         Y_UNUSED(FunctionRegistry);
         Y_UNUSED(Types);
-
+ 
         Y_VERIFY_DEBUG(gateway);
-        Y_VERIFY_DEBUG(sessionCtx);
-    }
-
-    ~TKikimrDataSource() {}
-
+        Y_VERIFY_DEBUG(sessionCtx); 
+    } 
+ 
+    ~TKikimrDataSource() {} 
+ 
     TStringBuf GetName() const override {
         return KikimrProviderName;
     }
 
-    bool Initialize(TExprContext& ctx) override {
-        TString defaultToken;
-        if (auto credential = Types.FindCredential(TString("default_") + KikimrProviderName)) {
-            if (credential->Category != KikimrProviderName) {
+    bool Initialize(TExprContext& ctx) override { 
+        TString defaultToken; 
+        if (auto credential = Types.FindCredential(TString("default_") + KikimrProviderName)) { 
+            if (credential->Category != KikimrProviderName) { 
                 ctx.AddError(TIssue({}, TStringBuilder()
-                    << "Mismatch default credential category, expected: " << KikimrProviderName
-                    << ", but found: " << credential->Category));
-                return false;
-            }
-
-            defaultToken = credential->Content;
-        }
-
+                    << "Mismatch default credential category, expected: " << KikimrProviderName 
+                    << ", but found: " << credential->Category)); 
+                return false; 
+            } 
+ 
+            defaultToken = credential->Content; 
+        } 
+ 
         if (defaultToken.empty()) {
             if (!Types.UserCredentials.OauthToken.empty()) {
                 defaultToken = Types.UserCredentials.OauthToken;
             }
         }
 
-        for (auto& cluster : Gateway->GetClusters()) {
-            auto token = defaultToken;
-
+        for (auto& cluster : Gateway->GetClusters()) { 
+            auto token = defaultToken; 
+ 
             if (auto credential = Types.FindCredential(TString("default_") + cluster)) {
-                if (credential->Category != KikimrProviderName) {
+                if (credential->Category != KikimrProviderName) { 
                     ctx.AddError(TIssue({}, TStringBuilder()
-                        << "Mismatch credential category, for cluster " << cluster
-                        << " expected: " << KikimrProviderName
-                        << ", but found: " << credential->Category));
-                    return false;
-                }
-
-                token = credential->Content;
-            }
-
-            if (!token.empty()) {
-                Gateway->SetToken(cluster, token);
-            }
-        }
-
-        return true;
-    }
-
-    IGraphTransformer& GetConfigurationTransformer() override {
-        return *ConfigurationTransformer;
-    }
-
-    IGraphTransformer& GetIntentDeterminationTransformer() override {
-        return *IntentDeterminationTransformer;
-    }
-
-    IGraphTransformer& GetLoadTableMetadataTransformer() override {
-        return *LoadTableMetadataTransformer;
-    }
-
+                        << "Mismatch credential category, for cluster " << cluster 
+                        << " expected: " << KikimrProviderName 
+                        << ", but found: " << credential->Category)); 
+                    return false; 
+                } 
+ 
+                token = credential->Content; 
+            } 
+ 
+            if (!token.empty()) { 
+                Gateway->SetToken(cluster, token); 
+            } 
+        } 
+ 
+        return true; 
+    } 
+ 
+    IGraphTransformer& GetConfigurationTransformer() override { 
+        return *ConfigurationTransformer; 
+    } 
+ 
+    IGraphTransformer& GetIntentDeterminationTransformer() override { 
+        return *IntentDeterminationTransformer; 
+    } 
+ 
+    IGraphTransformer& GetLoadTableMetadataTransformer() override { 
+        return *LoadTableMetadataTransformer; 
+    } 
+ 
     IGraphTransformer& GetTypeAnnotationTransformer(bool instantOnly) override {
         Y_UNUSED(instantOnly);
-        return *TypeAnnotationTransformer;
-    }
-
-    IGraphTransformer& GetCallableExecutionTransformer() override {
-        return *CallableExecutionTransformer;
-    }
-
+        return *TypeAnnotationTransformer; 
+    } 
+ 
+    IGraphTransformer& GetCallableExecutionTransformer() override { 
+        return *CallableExecutionTransformer; 
+    } 
+ 
     bool ValidateParameters(TExprNode& node, TExprContext& ctx, TMaybe<TString>& cluster) override {
         if (node.IsCallable(TCoDataSource::CallableName())) {
             if (node.Child(0)->Content() == KikimrProviderName) {
                 if (node.Child(1)->Content().empty()) {
                     ctx.AddError(TIssue(ctx.GetPosition(node.Child(1)->Pos()), "Empty cluster name"));
-                    return false;
-                }
-
-                cluster = TString(node.Child(1)->Content());
-                return true;
-            }
-        }
-
+                    return false; 
+                } 
+ 
+                cluster = TString(node.Child(1)->Content()); 
+                return true; 
+            } 
+        } 
+ 
         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), "Invalid Kikimr DataSource parameters."));
-        return false;
-    }
-
-    bool CanParse(const TExprNode& node) override {
+        return false; 
+    } 
+ 
+    bool CanParse(const TExprNode& node) override { 
         if (node.IsCallable(ReadName)) {
             return node.Child(1)->Child(0)->Content() == KikimrProviderName;
-        }
-
+        } 
+ 
         if (node.IsCallable(TKiReadTable::CallableName()) || node.IsCallable(TKiReadTableScheme::CallableName()) || node.IsCallable(TKiReadTableList::CallableName())) {
             return TKiDataSource(node.ChildPtr(1)).Category() == KikimrProviderName;
-        }
-
+        } 
+ 
         YQL_ENSURE(!KikimrDataSourceFunctions().contains(node.Content()));
-        return false;
-    }
-
+        return false; 
+    } 
+ 
     bool IsPersistent(const TExprNode& node) override {
         if (node.IsCallable(ReadName)) {
             return node.Child(1)->Child(0)->Content() == KikimrProviderName;
@@ -404,235 +404,235 @@ public:
     }
 
     bool CanPullResult(const TExprNode& node, TSyncMap& syncList, bool& canRef) override {
-        Y_UNUSED(syncList);
-        canRef = false;
-
+        Y_UNUSED(syncList); 
+        canRef = false; 
+ 
         if (node.IsCallable(TCoRight::CallableName())) {
             const auto input = node.Child(0);
             if (input->IsCallable(TKiReadTableList::CallableName())) {
                 return true;
             }
-
+ 
             if (input->IsCallable(TKiReadTableScheme::CallableName())) {
                 return true;
             }
-        }
-
-        if (auto maybeRight = TMaybeNode<TCoNth>(&node).Tuple().Maybe<TCoRight>()) {
+        } 
+ 
+        if (auto maybeRight = TMaybeNode<TCoNth>(&node).Tuple().Maybe<TCoRight>()) { 
             if (maybeRight.Input().Maybe<TKiExecDataQuery>()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
+                return true; 
+            } 
+        } 
+ 
+        return false; 
+    } 
+ 
     bool CanExecute(const TExprNode& node) override {
-        if (node.IsCallable(TKiReadTableScheme::CallableName()) || node.IsCallable(TKiReadTableList::CallableName())) {
-            return true;
-        }
-
+        if (node.IsCallable(TKiReadTableScheme::CallableName()) || node.IsCallable(TKiReadTableList::CallableName())) { 
+            return true; 
+        } 
+ 
         if (auto configure = TMaybeNode<TCoConfigure>(&node)) {
-            if (configure.DataSource().Maybe<TKiDataSource>()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
+            if (configure.DataSource().Maybe<TKiDataSource>()) { 
+                return true; 
+            } 
+        } 
+ 
+        return false; 
+    } 
+ 
     TExprNode::TPtr RewriteIO(const TExprNode::TPtr& node, TExprContext& ctx) override {
         auto read = node->Child(0);
         if (!read->IsCallable(ReadName)) {
-            ythrow yexception() << "Expected Read!";
-        }
-
-        TKikimrKey key(ctx);
+            ythrow yexception() << "Expected Read!"; 
+        } 
+ 
+        TKikimrKey key(ctx); 
         if (!key.Extract(*read->Child(2))) {
-            return nullptr;
-        }
-
+            return nullptr; 
+        } 
+ 
         TString newName;
-        switch (key.GetKeyType()) {
-            case TKikimrKey::Type::Table:
-                newName = TKiReadTable::CallableName();
-                break;
-            case TKikimrKey::Type::TableScheme:
-                newName = TKiReadTableScheme::CallableName();
-                break;
-            case TKikimrKey::Type::TableList:
-                newName = TKiReadTableList::CallableName();
-                break;
-            default:
+        switch (key.GetKeyType()) { 
+            case TKikimrKey::Type::Table: 
+                newName = TKiReadTable::CallableName(); 
+                break; 
+            case TKikimrKey::Type::TableScheme: 
+                newName = TKiReadTableScheme::CallableName(); 
+                break; 
+            case TKikimrKey::Type::TableList: 
+                newName = TKiReadTableList::CallableName(); 
+                break; 
+            default: 
                 YQL_ENSURE(false, "Unsupported Kikimr KeyType.");
-        }
-
+        } 
+ 
         auto newRead = ctx.RenameNode(*read, newName);
-
-        if (auto maybeRead = TMaybeNode<TKiReadTable>(newRead)) {
-            auto read = maybeRead.Cast();
-
-            if (SessionCtx->Config().HasUnwrapReadTableValues()) {
-                newRead = Build<TKiReadTable>(ctx, read.Pos())
-                    .World(read.World())
-                    .DataSource(read.DataSource())
-                    .TableKey(read.TableKey())
-                    .Select(read.Select())
-                    .Settings()
-                        .Add(read.Settings())
-                        .Add()
-                            .Name().Build("unwrap_values")
-                            .Build()
-                        .Build()
-                    .Done()
-                    .Ptr();
-            }
-        }
-
+ 
+        if (auto maybeRead = TMaybeNode<TKiReadTable>(newRead)) { 
+            auto read = maybeRead.Cast(); 
+ 
+            if (SessionCtx->Config().HasUnwrapReadTableValues()) { 
+                newRead = Build<TKiReadTable>(ctx, read.Pos()) 
+                    .World(read.World()) 
+                    .DataSource(read.DataSource()) 
+                    .TableKey(read.TableKey()) 
+                    .Select(read.Select()) 
+                    .Settings() 
+                        .Add(read.Settings()) 
+                        .Add() 
+                            .Name().Build("unwrap_values") 
+                            .Build() 
+                        .Build() 
+                    .Done() 
+                    .Ptr(); 
+            } 
+        } 
+ 
         auto retChildren = node->ChildrenList();
         retChildren[0] = newRead;
         auto ret = ctx.ChangeChildren(*node, std::move(retChildren));
-        return ret;
-    }
-
+        return ret; 
+    } 
+ 
     TExprNode::TPtr OptimizePull(const TExprNode::TPtr& source, const TFillSettings& fillSettings, TExprContext& ctx,
-        IOptimizationContext& optCtx) override
-    {
+        IOptimizationContext& optCtx) override 
+    { 
         auto queryType = SessionCtx->Query().Type;
-        if (queryType == EKikimrQueryType::Scan) {
+        if (queryType == EKikimrQueryType::Scan) { 
             return source;
         }
 
-        if (auto execQuery = TMaybeNode<TCoNth>(source).Tuple().Maybe<TCoRight>().Input().Maybe<TKiExecDataQuery>()) {
-            auto nth = TCoNth(source);
-            ui32 index = ::FromString<ui32>(nth.Index());
-
-            if (nth.Ref().GetTypeAnn()->GetKind() != ETypeAnnotationKind::List) {
-                return source;
-            }
-
-            auto exec = execQuery.Cast();
-            auto query = exec.Query();
-            auto results = query.Results();
-
-            auto result = results.Item(index);
-            ui64 rowsLimit = ::FromString<ui64>(result.RowsLimit());
-            if (!rowsLimit) {
-                if (!fillSettings.RowsLimitPerWrite) {
-                    return source;
-                }
-
-                // NOTE: RowsLimitPerWrite in OptimizePull already incremented by one, see result provider
-                // implementation for details
-                rowsLimit = *fillSettings.RowsLimitPerWrite - 1;
-            }
-
-            auto newResult = Build<TKiResult>(ctx, result.Pos())
-                .Value<TCoTake>()
-                    .Input(result.Value())
-                    .Count<TCoUint64>()
-                        .Literal().Build(ToString(rowsLimit + 1))
-                        .Build()
-                    .Build()
-                .Columns(result.Columns())
-                .RowsLimit().Build(ToString(rowsLimit))
-                .Done();
-
-            auto newResults = ctx.ChangeChild(results.Ref(), index, newResult.Ptr());
-
-            auto newQuery = Build<TKiDataQuery>(ctx, query.Pos())
-                .Operations(query.Operations())
-                .Results(newResults)
-                .Effects(query.Effects())
-                .Done();
-
-            auto newExec = Build<TKiExecDataQuery>(ctx, exec.Pos())
-                .World(exec.World())
-                .DataSink(exec.DataSink())
-                .Query(newQuery)
-                .Settings(exec.Settings())
-                .Ast(exec.Ast())
-                .Done();
-
-            auto ret = Build<TCoNth>(ctx, nth.Pos())
-                .Tuple<TCoRight>()
-                    .Input(newExec)
-                    .Build()
-                .Index(nth.Index())
-                .Done();
-
-            optCtx.RemapNode(exec.Ref(), newExec.Ptr());
-        }
-
+        if (auto execQuery = TMaybeNode<TCoNth>(source).Tuple().Maybe<TCoRight>().Input().Maybe<TKiExecDataQuery>()) { 
+            auto nth = TCoNth(source); 
+            ui32 index = ::FromString<ui32>(nth.Index()); 
+ 
+            if (nth.Ref().GetTypeAnn()->GetKind() != ETypeAnnotationKind::List) { 
+                return source; 
+            } 
+ 
+            auto exec = execQuery.Cast(); 
+            auto query = exec.Query(); 
+            auto results = query.Results(); 
+ 
+            auto result = results.Item(index); 
+            ui64 rowsLimit = ::FromString<ui64>(result.RowsLimit()); 
+            if (!rowsLimit) { 
+                if (!fillSettings.RowsLimitPerWrite) { 
+                    return source; 
+                } 
+ 
+                // NOTE: RowsLimitPerWrite in OptimizePull already incremented by one, see result provider 
+                // implementation for details 
+                rowsLimit = *fillSettings.RowsLimitPerWrite - 1; 
+            } 
+ 
+            auto newResult = Build<TKiResult>(ctx, result.Pos()) 
+                .Value<TCoTake>() 
+                    .Input(result.Value()) 
+                    .Count<TCoUint64>() 
+                        .Literal().Build(ToString(rowsLimit + 1)) 
+                        .Build() 
+                    .Build() 
+                .Columns(result.Columns()) 
+                .RowsLimit().Build(ToString(rowsLimit)) 
+                .Done(); 
+ 
+            auto newResults = ctx.ChangeChild(results.Ref(), index, newResult.Ptr()); 
+ 
+            auto newQuery = Build<TKiDataQuery>(ctx, query.Pos()) 
+                .Operations(query.Operations()) 
+                .Results(newResults) 
+                .Effects(query.Effects()) 
+                .Done(); 
+ 
+            auto newExec = Build<TKiExecDataQuery>(ctx, exec.Pos()) 
+                .World(exec.World()) 
+                .DataSink(exec.DataSink()) 
+                .Query(newQuery) 
+                .Settings(exec.Settings()) 
+                .Ast(exec.Ast()) 
+                .Done(); 
+ 
+            auto ret = Build<TCoNth>(ctx, nth.Pos()) 
+                .Tuple<TCoRight>() 
+                    .Input(newExec) 
+                    .Build() 
+                .Index(nth.Index()) 
+                .Done(); 
+ 
+            optCtx.RemapNode(exec.Ref(), newExec.Ptr()); 
+        } 
+ 
         return source;
-    }
-
+    } 
+ 
     bool GetDependencies(const TExprNode& node, TExprNode::TListType& children, bool compact) override {
         Y_UNUSED(compact);
-        if (CanExecute(node)) {
+        if (CanExecute(node)) { 
             children.push_back(node.ChildPtr(0));
-            return true;
-        }
-
-        return false;
-    }
-
+            return true; 
+        } 
+ 
+        return false; 
+    } 
+ 
     TString GetProviderPath(const TExprNode& node) override {
         Y_UNUSED(node);
-
+ 
         return TString(KikimrProviderName);
-    }
-
-private:
-    const NKikimr::NMiniKQL::IFunctionRegistry& FunctionRegistry;
-    TTypeAnnotationContext& Types;
-    TIntrusivePtr<IKikimrGateway> Gateway;
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-
-    TAutoPtr<IGraphTransformer> ConfigurationTransformer;
-    TAutoPtr<IGraphTransformer> IntentDeterminationTransformer;
-    TAutoPtr<IGraphTransformer> LoadTableMetadataTransformer;
-    TAutoPtr<IGraphTransformer> TypeAnnotationTransformer;
-    TAutoPtr<IGraphTransformer> CallableExecutionTransformer;
-};
-
-} // namespace
-
-IGraphTransformer::TStatus TKiSourceVisitorTransformer::DoTransform(TExprNode::TPtr input,
+    } 
+ 
+private: 
+    const NKikimr::NMiniKQL::IFunctionRegistry& FunctionRegistry; 
+    TTypeAnnotationContext& Types; 
+    TIntrusivePtr<IKikimrGateway> Gateway; 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+ 
+    TAutoPtr<IGraphTransformer> ConfigurationTransformer; 
+    TAutoPtr<IGraphTransformer> IntentDeterminationTransformer; 
+    TAutoPtr<IGraphTransformer> LoadTableMetadataTransformer; 
+    TAutoPtr<IGraphTransformer> TypeAnnotationTransformer; 
+    TAutoPtr<IGraphTransformer> CallableExecutionTransformer; 
+}; 
+ 
+} // namespace 
+ 
+IGraphTransformer::TStatus TKiSourceVisitorTransformer::DoTransform(TExprNode::TPtr input, 
     TExprNode::TPtr& output, TExprContext& ctx)
-{
+{ 
     YQL_ENSURE(input->Type() == TExprNode::Callable);
     output = input;
-
+ 
     if (auto node = TMaybeNode<TKiReadBase>(input)) {
-        return HandleKiRead(node.Cast(), ctx);
-    }
-
+        return HandleKiRead(node.Cast(), ctx); 
+    } 
+ 
     if (input->IsCallable(ReadName)) {
         return HandleRead(TExprBase(input), ctx);
-    }
-
+    } 
+ 
     if (input->IsCallable(ConfigureName)) {
         return HandleConfigure(TExprBase(input), ctx);
-    }
-
+    } 
+ 
     ctx.AddError(TIssue(ctx.GetPosition(input->Pos()), TStringBuilder() << "(Kikimr DataSource) Unsupported function: " << input->Content()));
-    return TStatus::Error;
-}
-
-TIntrusivePtr<IDataProvider> CreateKikimrDataSource(
-    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
-    TTypeAnnotationContext& types,
-    TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx)
-{
-    return new TKikimrDataSource(functionRegistry, types, gateway, sessionCtx);
-}
-
-TAutoPtr<IGraphTransformer> CreateKiSourceLoadTableMetadataTransformer(TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx)
-{
-    return new TKiSourceLoadTableMetadataTransformer(gateway, sessionCtx);
-}
-
-} // namespace NYql
+    return TStatus::Error; 
+} 
+ 
+TIntrusivePtr<IDataProvider> CreateKikimrDataSource( 
+    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry, 
+    TTypeAnnotationContext& types, 
+    TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
+{ 
+    return new TKikimrDataSource(functionRegistry, types, gateway, sessionCtx); 
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKiSourceLoadTableMetadataTransformer(TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
+{ 
+    return new TKiSourceLoadTableMetadataTransformer(gateway, sessionCtx); 
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_exec.cpp b/ydb/core/kqp/provider/yql_kikimr_exec.cpp
index ad360fcaeb..a4121559cc 100644
--- a/ydb/core/kqp/provider/yql_kikimr_exec.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_exec.cpp
@@ -1,5 +1,5 @@
-#include "yql_kikimr_provider_impl.h"
-
+#include "yql_kikimr_provider_impl.h" 
+ 
 #include <ydb/library/yql/utils/log/log.h>
 #include <ydb/library/yql/core/yql_execution.h>
 #include <ydb/library/yql/core/yql_graph_transformer.h>
@@ -8,14 +8,14 @@
 #include <ydb/library/yql/core/type_ann/type_ann_core.h>
 #include <ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.h>
 #include <ydb/library/yql/providers/result/expr_nodes/yql_res_expr_nodes.h>
-
-namespace NYql {
-namespace {
-
-using namespace NNodes;
-using namespace NCommon;
-using namespace NThreading;
-
+ 
+namespace NYql { 
+namespace { 
+ 
+using namespace NNodes; 
+using namespace NCommon; 
+using namespace NThreading; 
+ 
 namespace {
     bool EnsureNotPrepare(const TString featureName, TPositionHandle pos, const TKikimrQueryContext& queryCtx,
         TExprContext& ctx)
@@ -27,18 +27,18 @@ namespace {
         }
 
         return true;
-    }
-
+    } 
+ 
     void FillExecDataQueryAst(TKiExecDataQuery exec, const TString& ast, TExprContext& ctx) {
         auto astNode = Build<TCoAtom>(ctx, exec.Pos())
             .Value(ast)
             .Done();
-
+ 
         astNode.Ptr()->SetTypeAnn(ctx.MakeType<TUnitExprType>());
-
+ 
         exec.Ptr()->ChildRef(TKiExecDataQuery::idx_Ast) = astNode.Ptr();
     }
-
+ 
     TCreateUserSettings ParseCreateUserSettings(TKiCreateUser createUser) {
         TCreateUserSettings createUserSettings;
         createUserSettings.UserName = TString(createUser.UserName());
@@ -121,395 +121,395 @@ namespace {
         }
         return dropGroupSettings;
     }
-}
-
-class TKiSinkPlanInfoTransformer : public TGraphTransformerBase {
-public:
-    TKiSinkPlanInfoTransformer(TIntrusivePtr<IKikimrQueryExecutor> queryExecutor)
-        : QueryExecutor(queryExecutor) {}
-
+} 
+ 
+class TKiSinkPlanInfoTransformer : public TGraphTransformerBase { 
+public: 
+    TKiSinkPlanInfoTransformer(TIntrusivePtr<IKikimrQueryExecutor> queryExecutor) 
+        : QueryExecutor(queryExecutor) {} 
+ 
     TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ) final {
-        output = input;
+        output = input; 
         VisitExpr(input, [](const TExprNode::TPtr& node) {
-            if (auto maybeExec = TMaybeNode<TKiExecDataQuery>(node)) {
-                auto exec = maybeExec.Cast();
-                if (exec.Ast().Maybe<TCoVoid>()) {
+            if (auto maybeExec = TMaybeNode<TKiExecDataQuery>(node)) { 
+                auto exec = maybeExec.Cast(); 
+                if (exec.Ast().Maybe<TCoVoid>()) { 
                     YQL_ENSURE(false);
-                }
-            }
-
-            return true;
-        });
-
+                } 
+            } 
+ 
+            return true; 
+        }); 
+ 
         return TStatus::Ok;
-    }
-
-    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
-        Y_UNUSED(input);
+    } 
+ 
+    TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
+        Y_UNUSED(input); 
         return MakeFuture();
-    }
-
+    } 
+ 
     TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext&) final {
-        output = input;
+        output = input; 
         return TStatus::Ok;
-    }
-
-private:
-    struct TExecInfo {
-        TKiExecDataQuery Node;
-        TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult> Result;
-    };
-
-private:
-    TIntrusivePtr<IKikimrQueryExecutor> QueryExecutor;
-};
-
-class TKiSourceCallableExecutionTransformer : public TAsyncCallbackTransformer<TKiSourceCallableExecutionTransformer> {
-public:
-    TKiSourceCallableExecutionTransformer(TIntrusivePtr<IKikimrGateway> gateway,
-        TIntrusivePtr<TKikimrSessionContext> sessionCtx)
-        : Gateway(gateway)
-        , SessionCtx(sessionCtx) {}
-
-    std::pair<TStatus, TAsyncTransformCallbackFuture> CallbackTransform(const TExprNode::TPtr& input,
-        TExprNode::TPtr& output, TExprContext& ctx)
-    {
+    } 
+ 
+private: 
+    struct TExecInfo { 
+        TKiExecDataQuery Node; 
+        TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult> Result; 
+    }; 
+ 
+private: 
+    TIntrusivePtr<IKikimrQueryExecutor> QueryExecutor; 
+}; 
+ 
+class TKiSourceCallableExecutionTransformer : public TAsyncCallbackTransformer<TKiSourceCallableExecutionTransformer> { 
+public: 
+    TKiSourceCallableExecutionTransformer(TIntrusivePtr<IKikimrGateway> gateway, 
+        TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
+        : Gateway(gateway) 
+        , SessionCtx(sessionCtx) {} 
+ 
+    std::pair<TStatus, TAsyncTransformCallbackFuture> CallbackTransform(const TExprNode::TPtr& input, 
+        TExprNode::TPtr& output, TExprContext& ctx) 
+    { 
         YQL_ENSURE(input->Type() == TExprNode::Callable);
         output = input;
-
+ 
         if (input->Content() == "Pull") {
             auto pullInput = input->Child(0);
-
-            if (auto maybeNth = TMaybeNode<TCoNth>(pullInput)) {
-                ui32 index = FromString<ui32>(maybeNth.Cast().Index().Value());
-
-                if (auto maybeExecQuery = maybeNth.Tuple().Maybe<TCoRight>().Input().Maybe<TKiExecDataQuery>()) {
-                    return RunResOrPullForExec(TResOrPullBase(input), maybeExecQuery.Cast(), ctx, index);
-                }
-            }
-
+ 
+            if (auto maybeNth = TMaybeNode<TCoNth>(pullInput)) { 
+                ui32 index = FromString<ui32>(maybeNth.Cast().Index().Value()); 
+ 
+                if (auto maybeExecQuery = maybeNth.Tuple().Maybe<TCoRight>().Input().Maybe<TKiExecDataQuery>()) { 
+                    return RunResOrPullForExec(TResOrPullBase(input), maybeExecQuery.Cast(), ctx, index); 
+                } 
+            } 
+ 
             IDataProvider::TFillSettings fillSettings = NCommon::GetFillSettings(*input);
-
+ 
             if (auto maybeTableList = TMaybeNode<TCoRight>(pullInput).Input().Maybe<TKiReadTableList>()) {
-                if (!EnsureNotPrepare("tablelist", pullInput->Pos(), SessionCtx->Query(), ctx)) {
-                    return SyncError();
-                }
-
-                TKikimrKey key(ctx);
+                if (!EnsureNotPrepare("tablelist", pullInput->Pos(), SessionCtx->Query(), ctx)) { 
+                    return SyncError(); 
+                } 
+ 
+                TKikimrKey key(ctx); 
                 YQL_ENSURE(key.Extract(maybeTableList.Cast().TableKey().Ref()));
-                auto future = Gateway->ListPath(TString(maybeTableList.Cast().DataSource().Cluster()),
-                    key.GetFolderPath());
-
-                return WrapFuture(future, [fillSettings](const IKikimrGateway::TListPathResult& res,
-                    const TExprNode::TPtr& input, TExprContext& ctx)
-                {
-                    auto result = GetTableListResult(res, fillSettings, ctx);
-                    YQL_ENSURE(result);
-
-                    return ctx.NewAtom(input->Pos(), *result);
-                });
-            }
-
+                auto future = Gateway->ListPath(TString(maybeTableList.Cast().DataSource().Cluster()), 
+                    key.GetFolderPath()); 
+ 
+                return WrapFuture(future, [fillSettings](const IKikimrGateway::TListPathResult& res, 
+                    const TExprNode::TPtr& input, TExprContext& ctx) 
+                { 
+                    auto result = GetTableListResult(res, fillSettings, ctx); 
+                    YQL_ENSURE(result); 
+ 
+                    return ctx.NewAtom(input->Pos(), *result); 
+                }); 
+            } 
+ 
             if (auto maybeTableScheme = TMaybeNode<TCoRight>(pullInput).Input().Maybe<TKiReadTableScheme>()) {
-                if (!EnsureNotPrepare("tablescheme", pullInput->Pos(), SessionCtx->Query(), ctx)) {
-                    return SyncError();
-                }
-
-                TKikimrKey key(ctx);
-                auto cluster = maybeTableScheme.Cast().DataSource().Cluster();
+                if (!EnsureNotPrepare("tablescheme", pullInput->Pos(), SessionCtx->Query(), ctx)) { 
+                    return SyncError(); 
+                } 
+ 
+                TKikimrKey key(ctx); 
+                auto cluster = maybeTableScheme.Cast().DataSource().Cluster(); 
                 YQL_ENSURE(key.Extract(maybeTableScheme.Cast().TableKey().Ref()));
-
-                auto& tableDesc = SessionCtx->Tables().ExistingTable(TString(cluster), key.GetTablePath());
+ 
+                auto& tableDesc = SessionCtx->Tables().ExistingTable(TString(cluster), key.GetTablePath()); 
                 TKikimrTableDescription rawTableDesc;
                 rawTableDesc.Metadata = tableDesc.Metadata;
                 rawTableDesc.Load(ctx);
-
+ 
                 auto result = GetTableMetadataResult(rawTableDesc, fillSettings, ctx);
-                YQL_ENSURE(result);
-
-                auto resultNode = ctx.NewAtom(input->Pos(), *result);
-
-                return std::make_pair(
-                    IGraphTransformer::TStatus::Async,
-                    MakeFuture(TAsyncTransformCallback([resultNode](const TExprNode::TPtr& input,
-                        TExprNode::TPtr& output, TExprContext& ctx)
-                    {
+                YQL_ENSURE(result); 
+ 
+                auto resultNode = ctx.NewAtom(input->Pos(), *result); 
+ 
+                return std::make_pair( 
+                    IGraphTransformer::TStatus::Async, 
+                    MakeFuture(TAsyncTransformCallback([resultNode](const TExprNode::TPtr& input, 
+                        TExprNode::TPtr& output, TExprContext& ctx) 
+                    { 
                         Y_UNUSED(output);
                         Y_UNUSED(ctx);
-
+ 
                         input->SetState(TExprNode::EState::ExecutionComplete);
-                        input->SetResult(TExprNode::TPtr(resultNode));
-                        return IGraphTransformer::TStatus::Ok;
-                    })));
-            }
-        }
-
+                        input->SetResult(TExprNode::TPtr(resultNode)); 
+                        return IGraphTransformer::TStatus::Ok; 
+                    }))); 
+            } 
+        } 
+ 
         if (input->Content() == "Result") {
-            auto resultInput = TExprBase(input->ChildPtr(0));
-            auto exec = resultInput.Maybe<TCoNth>().Tuple().Maybe<TCoRight>().Input();
+            auto resultInput = TExprBase(input->ChildPtr(0)); 
+            auto exec = resultInput.Maybe<TCoNth>().Tuple().Maybe<TCoRight>().Input(); 
             YQL_ENSURE(exec.Maybe<TKiExecDataQuery>());
-
+ 
             ui32 index = FromString<ui32>(resultInput.Cast<TCoNth>().Index().Value());
-            YQL_ENSURE(index == 0);
-
-            return RunResOrPullForExec(TResOrPullBase(input), exec.Cast(), ctx, 0);
-        }
-
-        if (input->Content() == ConfigureName) {
-            auto requireStatus = RequireChild(*input, 0);
-            if (requireStatus.Level != TStatus::Ok) {
-                return SyncStatus(requireStatus);
-            }
-
+            YQL_ENSURE(index == 0); 
+ 
+            return RunResOrPullForExec(TResOrPullBase(input), exec.Cast(), ctx, 0); 
+        } 
+ 
+        if (input->Content() == ConfigureName) { 
+            auto requireStatus = RequireChild(*input, 0); 
+            if (requireStatus.Level != TStatus::Ok) { 
+                return SyncStatus(requireStatus); 
+            } 
+ 
             auto configure = TCoConfigure(input);
             auto clusterName = TString(configure.DataSource().Arg(1).Cast<TCoAtom>().Value());
             if (configure.Arg(2).Cast<TCoAtom>().Value() == TStringBuf("Attr")) {
                 auto name = TString(configure.Arg(3).Cast<TCoAtom>().Value());
-                TMaybe<TString> value;
-                if (configure.Args().Count() == 5) {
+                TMaybe<TString> value; 
+                if (configure.Args().Count() == 5) { 
                     value = TString(configure.Arg(4).Cast<TCoAtom>().Value());
-                }
-
-                SessionCtx->Config().Dispatch(clusterName, name, value, NCommon::TSettingDispatcher::EStage::RUNTIME);
-            }
-
+                } 
+ 
+                SessionCtx->Config().Dispatch(clusterName, name, value, NCommon::TSettingDispatcher::EStage::RUNTIME); 
+            } 
+ 
             input->SetState(TExprNode::EState::ExecutionComplete);
-            input->SetResult(ctx.NewWorld(input->Pos()));
-            return SyncOk();
-        }
-
+            input->SetResult(ctx.NewWorld(input->Pos())); 
+            return SyncOk(); 
+        } 
+ 
         if (input->Content() == "ClustersList") {
-            if (!EnsureNotPrepare("ClustersList", input->Pos(), SessionCtx->Query(), ctx)) {
-                return SyncError();
-            }
-
-            auto clusters = Gateway->GetClusters();
-            Sort(clusters);
-
+            if (!EnsureNotPrepare("ClustersList", input->Pos(), SessionCtx->Query(), ctx)) { 
+                return SyncError(); 
+            } 
+ 
+            auto clusters = Gateway->GetClusters(); 
+            Sort(clusters); 
+ 
             auto ysonFormat = (NYson::EYsonFormat)FromString<ui32>(input->Child(0)->Content());
-            TStringStream out;
+            TStringStream out; 
             NYson::TYsonWriter writer(&out, ysonFormat);
-            writer.OnBeginList();
-
-            for (auto& cluster : clusters) {
-                writer.OnListItem();
-                writer.OnStringScalar(cluster);
-            }
-
-            writer.OnEndList();
-
+            writer.OnBeginList(); 
+ 
+            for (auto& cluster : clusters) { 
+                writer.OnListItem(); 
+                writer.OnStringScalar(cluster); 
+            } 
+ 
+            writer.OnEndList(); 
+ 
             input->SetState(TExprNode::EState::ExecutionComplete);
-            input->SetResult(ctx.NewAtom(input->Pos(), out.Str()));
-            return SyncOk();
-        }
-
-        if (input->Content() == "KiReadTableList!" || input->Content() == "KiReadTableScheme!") {
+            input->SetResult(ctx.NewAtom(input->Pos(), out.Str())); 
+            return SyncOk(); 
+        } 
+ 
+        if (input->Content() == "KiReadTableList!" || input->Content() == "KiReadTableScheme!") { 
             auto requireStatus = RequireChild(*input, 0);
-            if (requireStatus.Level != TStatus::Ok) {
-                return SyncStatus(requireStatus);
-            }
-
+            if (requireStatus.Level != TStatus::Ok) { 
+                return SyncStatus(requireStatus); 
+            } 
+ 
             input->SetState(TExprNode::EState::ExecutionComplete);
             input->SetResult(ctx.NewWorld(input->Pos()));
-            return SyncOk();
-        }
-
+            return SyncOk(); 
+        } 
+ 
         ctx.AddError(TIssue(ctx.GetPosition(input->Pos()), TStringBuilder()
-            << "(Kikimr DataSource) Failed to execute node: " << input->Content()));
-        return SyncError();
-    }
-
-private:
+            << "(Kikimr DataSource) Failed to execute node: " << input->Content())); 
+        return SyncError(); 
+    } 
+ 
+private: 
     static TExprNode::TPtr GetResOrPullResult(const TExprNode& node, const IDataProvider::TFillSettings& fillSettings,
-        const TTypeAnnotationNode* resultType, const NKikimrMiniKQL::TResult& resultValue, TExprContext& ctx)
-    {
+        const TTypeAnnotationNode* resultType, const NKikimrMiniKQL::TResult& resultValue, TExprContext& ctx) 
+    { 
         TVector<TString> columnHints(NCommon::GetResOrPullColumnHints(node));
-
-        auto protoValue = &resultValue;
-        YQL_ENSURE(resultValue.GetArena());
-        if (IsRawKikimrResult(resultValue)) {
-            protoValue = KikimrResultToProto(resultValue, columnHints, fillSettings, resultValue.GetArena());
-        }
-
-        // TODO: Fix Void? and Null type difference
-        // YQL_ENSURE(CheckKqpResultType(*protoValue, *resultType, ctx));
-        Y_UNUSED(resultType);
-
+ 
+        auto protoValue = &resultValue; 
+        YQL_ENSURE(resultValue.GetArena()); 
+        if (IsRawKikimrResult(resultValue)) { 
+            protoValue = KikimrResultToProto(resultValue, columnHints, fillSettings, resultValue.GetArena()); 
+        } 
+ 
+        // TODO: Fix Void? and Null type difference 
+        // YQL_ENSURE(CheckKqpResultType(*protoValue, *resultType, ctx)); 
+        Y_UNUSED(resultType); 
+ 
         TExprNode::TPtr resultNode;
-        if (fillSettings.Format == IDataProvider::EResultFormat::Yson) {
+        if (fillSettings.Format == IDataProvider::EResultFormat::Yson) { 
             NYson::EYsonFormat ysonFormat = NCommon::GetYsonFormat(fillSettings);
-
-            auto yson = KqpResultToYson(*protoValue, ysonFormat, ctx);
-            if (!yson) {
-                return nullptr;
-            }
-
-            resultNode = ctx.NewAtom(node.Pos(), *yson);
-        } else {
-            YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Custom);
-            YQL_ENSURE(fillSettings.FormatDetails == KikimrMkqlProtoFormat);
-
-            TVector<char> buffer(protoValue->ByteSize());
+ 
+            auto yson = KqpResultToYson(*protoValue, ysonFormat, ctx); 
+            if (!yson) { 
+                return nullptr; 
+            } 
+ 
+            resultNode = ctx.NewAtom(node.Pos(), *yson); 
+        } else { 
+            YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Custom); 
+            YQL_ENSURE(fillSettings.FormatDetails == KikimrMkqlProtoFormat); 
+ 
+            TVector<char> buffer(protoValue->ByteSize()); 
             Y_PROTOBUF_SUPPRESS_NODISCARD protoValue->SerializeToArray(buffer.data(), buffer.size());
-            resultNode = ctx.NewAtom(node.Pos(), TStringBuf(buffer.data(), buffer.size()));
-        }
-
-        return resultNode;
-    }
-
-    std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture> RunResOrPullForExec(TResOrPullBase res,
-        TExprBase exec, TExprContext& ctx, ui32 resultIndex)
-    {
-        auto requireStatus = RequireChild(res.Ref(), 0);
-        if (requireStatus.Level != TStatus::Ok) {
-            return SyncStatus(requireStatus);
-        }
-
-        if (NCommon::HasResOrPullOption(res.Ref(), "ref")) {
+            resultNode = ctx.NewAtom(node.Pos(), TStringBuf(buffer.data(), buffer.size())); 
+        } 
+ 
+        return resultNode; 
+    } 
+ 
+    std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture> RunResOrPullForExec(TResOrPullBase res, 
+        TExprBase exec, TExprContext& ctx, ui32 resultIndex) 
+    { 
+        auto requireStatus = RequireChild(res.Ref(), 0); 
+        if (requireStatus.Level != TStatus::Ok) { 
+            return SyncStatus(requireStatus); 
+        } 
+ 
+        if (NCommon::HasResOrPullOption(res.Ref(), "ref")) { 
             ctx.AddError(TIssue(ctx.GetPosition(res.Pos()), TStringBuilder() << "refselect isn't supported for Kikimr provider."));
-            return SyncError();
-        }
-
-        IDataProvider::TFillSettings fillSettings = NCommon::GetFillSettings(res.Ref());
-
-        auto* runResult = SessionCtx->Query().Results.FindPtr(exec.Ref().UniqueId());
-        if (!runResult) {
+            return SyncError(); 
+        } 
+ 
+        IDataProvider::TFillSettings fillSettings = NCommon::GetFillSettings(res.Ref()); 
+ 
+        auto* runResult = SessionCtx->Query().Results.FindPtr(exec.Ref().UniqueId()); 
+        if (!runResult) { 
             ctx.AddError(TIssue(ctx.GetPosition(exec.Pos()), TStringBuilder() << "KiExecute run result not found."));
-            return SyncError();
-        }
-
-        if (SessionCtx->Query().PrepareOnly) {
-            res.Ptr()->SetResult(ctx.NewWorld(res.Pos()));
-            return SyncOk();
-        }
-
+            return SyncError(); 
+        } 
+ 
+        if (SessionCtx->Query().PrepareOnly) { 
+            res.Ptr()->SetResult(ctx.NewWorld(res.Pos())); 
+            return SyncOk(); 
+        } 
+ 
         auto executeRightType = exec.Ref().GetTypeAnn()->Cast<TTupleExprType>()->GetItems()[1];
-        auto resultType = executeRightType->Cast<TTupleExprType>()->GetItems()[resultIndex];
-
-        YQL_ENSURE(resultIndex < runResult->Results.size());
+        auto resultType = executeRightType->Cast<TTupleExprType>()->GetItems()[resultIndex]; 
+ 
+        YQL_ENSURE(resultIndex < runResult->Results.size()); 
         auto resultValue = runResult->Results[resultIndex];
         YQL_ENSURE(resultValue);
-
+ 
         auto resResultNode = GetResOrPullResult(res.Ref(), fillSettings, resultType, *resultValue, ctx);
-
-        res.Ptr()->SetResult(std::move(resResultNode));
-        return SyncOk();
-    }
-
-private:
-    TIntrusivePtr<IKikimrGateway> Gateway;
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-};
-
-class TKiSinkCallableExecutionTransformer : public TAsyncCallbackTransformer<TKiSinkCallableExecutionTransformer> {
-public:
-    TKiSinkCallableExecutionTransformer(
-        TIntrusivePtr<IKikimrGateway> gateway,
-        TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-        TIntrusivePtr<IKikimrQueryExecutor> queryExecutor)
+ 
+        res.Ptr()->SetResult(std::move(resResultNode)); 
+        return SyncOk(); 
+    } 
+ 
+private: 
+    TIntrusivePtr<IKikimrGateway> Gateway; 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+}; 
+ 
+class TKiSinkCallableExecutionTransformer : public TAsyncCallbackTransformer<TKiSinkCallableExecutionTransformer> { 
+public: 
+    TKiSinkCallableExecutionTransformer( 
+        TIntrusivePtr<IKikimrGateway> gateway, 
+        TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+        TIntrusivePtr<IKikimrQueryExecutor> queryExecutor) 
         : Gateway(gateway)
-        , SessionCtx(sessionCtx)
-        , QueryExecutor(queryExecutor) {}
-
-    std::pair<TStatus, TAsyncTransformCallbackFuture> CallbackTransform(const TExprNode::TPtr& input,
-        TExprNode::TPtr& output, TExprContext& ctx)
-    {
+        , SessionCtx(sessionCtx) 
+        , QueryExecutor(queryExecutor) {} 
+ 
+    std::pair<TStatus, TAsyncTransformCallbackFuture> CallbackTransform(const TExprNode::TPtr& input, 
+        TExprNode::TPtr& output, TExprContext& ctx) 
+    { 
         YQL_ENSURE(input->Type() == TExprNode::Callable);
         output = input;
-
+ 
         if (auto maybeCommit = TMaybeNode<TCoCommit>(input)) {
             auto requireStatus = RequireChild(*input, 0);
-            if (requireStatus.Level != TStatus::Ok) {
-                return SyncStatus(requireStatus);
-            }
-
-            if (SessionCtx->HasTx()) {
-                auto settings = NCommon::ParseCommitSettings(maybeCommit.Cast(), ctx);
-                if (settings.Mode && settings.Mode.Cast().Value() == KikimrCommitModeScheme()) {
-                    SessionCtx->Tx().Finish();
-                }
-            }
-
+            if (requireStatus.Level != TStatus::Ok) { 
+                return SyncStatus(requireStatus); 
+            } 
+ 
+            if (SessionCtx->HasTx()) { 
+                auto settings = NCommon::ParseCommitSettings(maybeCommit.Cast(), ctx); 
+                if (settings.Mode && settings.Mode.Cast().Value() == KikimrCommitModeScheme()) { 
+                    SessionCtx->Tx().Finish(); 
+                } 
+            } 
+ 
             input->SetState(TExprNode::EState::ExecutionComplete);
             input->SetResult(ctx.NewWorld(input->Pos()));
-            return SyncOk();
-        }
-
-        if (auto maybeExecQuery = TMaybeNode<TKiExecDataQuery>(input)) {
-            auto requireStatus = RequireChild(*input, TKiExecDataQuery::idx_World);
-            if (requireStatus.Level != TStatus::Ok) {
-                return SyncStatus(requireStatus);
-            }
-
-            return RunKiExecDataQuery(ctx, maybeExecQuery.Cast());
-        }
-
+            return SyncOk(); 
+        } 
+ 
+        if (auto maybeExecQuery = TMaybeNode<TKiExecDataQuery>(input)) { 
+            auto requireStatus = RequireChild(*input, TKiExecDataQuery::idx_World); 
+            if (requireStatus.Level != TStatus::Ok) { 
+                return SyncStatus(requireStatus); 
+            } 
+ 
+            return RunKiExecDataQuery(ctx, maybeExecQuery.Cast()); 
+        } 
+ 
         if (TMaybeNode<TCoNth>(input)) {
             input->SetState(TExprNode::EState::ExecutionComplete);
             input->SetResult(ctx.NewWorld(input->Pos()));
-            return SyncOk();
-        }
-
+            return SyncOk(); 
+        } 
+ 
         if (auto maybeCreate = TMaybeNode<TKiCreateTable>(input)) {
-            if (!EnsureNotPrepare("CREATE TABLE", input->Pos(), SessionCtx->Query(), ctx)) {
-                return SyncError();
-            }
-
+            if (!EnsureNotPrepare("CREATE TABLE", input->Pos(), SessionCtx->Query(), ctx)) { 
+                return SyncError(); 
+            } 
+ 
             auto requireStatus = RequireChild(*input, 0);
-            if (requireStatus.Level != TStatus::Ok) {
-                return SyncStatus(requireStatus);
-            }
-
-            auto cluster = TString(maybeCreate.Cast().DataSink().Cluster());
-            auto& table = SessionCtx->Tables().GetTable(cluster, TString(maybeCreate.Cast().Table()));
-
+            if (requireStatus.Level != TStatus::Ok) { 
+                return SyncStatus(requireStatus); 
+            } 
+ 
+            auto cluster = TString(maybeCreate.Cast().DataSink().Cluster()); 
+            auto& table = SessionCtx->Tables().GetTable(cluster, TString(maybeCreate.Cast().Table())); 
+ 
             if (!ApplyDdlOperation(cluster, input->Pos(), table.Metadata->Name, TYdbOperation::CreateTable, ctx)) {
-                return SyncError();
-            }
-
-            auto future = Gateway->CreateTable(table.Metadata, true);
-
-            return WrapFuture(future,
-                [](const IKikimrGateway::TGenericResult& res, const TExprNode::TPtr& input, TExprContext& ctx) {
-                    Y_UNUSED(res);
-                    auto resultNode = ctx.NewWorld(input->Pos());
-                    return resultNode;
-                }, "Executing CREATE TABLE");
-        }
-
+                return SyncError(); 
+            } 
+ 
+            auto future = Gateway->CreateTable(table.Metadata, true); 
+ 
+            return WrapFuture(future, 
+                [](const IKikimrGateway::TGenericResult& res, const TExprNode::TPtr& input, TExprContext& ctx) { 
+                    Y_UNUSED(res); 
+                    auto resultNode = ctx.NewWorld(input->Pos()); 
+                    return resultNode; 
+                }, "Executing CREATE TABLE"); 
+        } 
+ 
         if (auto maybeDrop = TMaybeNode<TKiDropTable>(input)) {
-            if (!EnsureNotPrepare("DROP TABLE", input->Pos(), SessionCtx->Query(), ctx)) {
-                return SyncError();
-            }
-
+            if (!EnsureNotPrepare("DROP TABLE", input->Pos(), SessionCtx->Query(), ctx)) { 
+                return SyncError(); 
+            } 
+ 
             auto requireStatus = RequireChild(*input, 0);
-            if (requireStatus.Level != TStatus::Ok) {
-                return SyncStatus(requireStatus);
-            }
-
-            auto cluster = TString(maybeDrop.Cast().DataSink().Cluster());
-            auto& table = SessionCtx->Tables().GetTable(cluster, TString(maybeDrop.Cast().Table()));
-
+            if (requireStatus.Level != TStatus::Ok) { 
+                return SyncStatus(requireStatus); 
+            } 
+ 
+            auto cluster = TString(maybeDrop.Cast().DataSink().Cluster()); 
+            auto& table = SessionCtx->Tables().GetTable(cluster, TString(maybeDrop.Cast().Table())); 
+ 
             if (!ApplyDdlOperation(cluster, input->Pos(), table.Metadata->Name, TYdbOperation::DropTable, ctx)) {
-                return SyncError();
-            }
-
-            auto future = Gateway->DropTable(table.Metadata->Cluster, table.Metadata->Name);
-
-            return WrapFuture(future,
-                [](const IKikimrGateway::TGenericResult& res, const TExprNode::TPtr& input, TExprContext& ctx) {
-                    Y_UNUSED(res);
-                    auto resultNode = ctx.NewWorld(input->Pos());
-                    return resultNode;
-                });
-
+                return SyncError(); 
+            } 
+ 
+            auto future = Gateway->DropTable(table.Metadata->Cluster, table.Metadata->Name); 
+ 
+            return WrapFuture(future, 
+                [](const IKikimrGateway::TGenericResult& res, const TExprNode::TPtr& input, TExprContext& ctx) { 
+                    Y_UNUSED(res); 
+                    auto resultNode = ctx.NewWorld(input->Pos()); 
+                    return resultNode; 
+                }); 
+ 
             input->SetState(TExprNode::EState::ExecutionComplete);
             input->SetResult(ctx.NewWorld(input->Pos()));
-            return SyncOk();
-        }
-
+            return SyncOk(); 
+        } 
+ 
         if (auto maybeAlter = TMaybeNode<TKiAlterTable>(input)) {
-            if (!EnsureNotPrepare("ALTER TABLE", input->Pos(), SessionCtx->Query(), ctx)) {
+            if (!EnsureNotPrepare("ALTER TABLE", input->Pos(), SessionCtx->Query(), ctx)) { 
                 return SyncError();
             }
 
@@ -518,13 +518,13 @@ public:
                 return SyncStatus(requireStatus);
             }
 
-            auto cluster = TString(maybeAlter.Cast().DataSink().Cluster());
-            auto& table = SessionCtx->Tables().GetTable(cluster, TString(maybeAlter.Cast().Table()));
+            auto cluster = TString(maybeAlter.Cast().DataSink().Cluster()); 
+            auto& table = SessionCtx->Tables().GetTable(cluster, TString(maybeAlter.Cast().Table())); 
 
             if (!ApplyDdlOperation(cluster, input->Pos(), table.Metadata->Name, TYdbOperation::AlterTable, ctx)) {
-                return SyncError();
-            }
-
+                return SyncError(); 
+            } 
+ 
             Ydb::Table::AlterTableRequest alterTableRequest;
             alterTableRequest.set_path(table.Metadata->Name);
 
@@ -968,222 +968,222 @@ public:
         }
 
         ctx.AddError(TIssue(ctx.GetPosition(input->Pos()), TStringBuilder()
-            << "(Kikimr DataSink) Failed to execute node: " << input->Content()));
-        return SyncError();
-    }
-
-private:
-    using TExecuteRunFunc = std::function<TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult>(
-        const IKikimrQueryExecutor::TExecuteSettings& settings)>;
-    using TExecuteFinalizeFunc = std::function<void(TExprBase node, const IKikimrQueryExecutor::TQueryResult& result,
-        TExprContext& ctx)>;
-
-    std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture> PerformExecution(TExprBase node,
-        TExprContext& ctx, const TString& cluster, TMaybe<TString> mode, TMaybe<bool> useNewEngine,
-        const TExecuteRunFunc& runFunc, const TExecuteFinalizeFunc& finalizeFunc)
-    {
+            << "(Kikimr DataSink) Failed to execute node: " << input->Content())); 
+        return SyncError(); 
+    } 
+ 
+private: 
+    using TExecuteRunFunc = std::function<TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult>( 
+        const IKikimrQueryExecutor::TExecuteSettings& settings)>; 
+    using TExecuteFinalizeFunc = std::function<void(TExprBase node, const IKikimrQueryExecutor::TQueryResult& result, 
+        TExprContext& ctx)>; 
+ 
+    std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture> PerformExecution(TExprBase node, 
+        TExprContext& ctx, const TString& cluster, TMaybe<TString> mode, TMaybe<bool> useNewEngine, 
+        const TExecuteRunFunc& runFunc, const TExecuteFinalizeFunc& finalizeFunc) 
+    { 
         if (node.Ref().GetState() == TExprNode::EState::ExecutionComplete) {
-            return SyncOk();
-        }
-
-        auto resultId = node.Ref().UniqueId();
-
-        TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult> asyncResult;
-        if (auto resultPtr = SessionCtx->Query().InProgress.FindPtr(resultId)) {
-            asyncResult = *resultPtr;
-        } else {
-            auto config = SessionCtx->Config().Snapshot();
-
-            auto isolationLevel = config->IsolationLevel.Get(cluster);
-
-            IKikimrQueryExecutor::TExecuteSettings settings;
-            settings.CommitTx = true;
-            if (mode) {
-                if (*mode == KikimrCommitModeFlush()) {
-                    settings.CommitTx = false;
-                }
-
-                if (*mode == KikimrCommitModeRollback()) {
-                    settings.CommitTx = false;
-                    settings.RollbackTx = true;
-                }
-            }
-
-            settings.IsolationLevel = isolationLevel;
-            settings.UseNewEngine = useNewEngine;
-            settings.StrictDml = config->StrictDml.Get(cluster).GetRef();
-
-            const auto& scanQuery = config->ScanQuery.Get(cluster);
-            if (scanQuery) {
-                settings.UseScanQuery = scanQuery.GetRef();
-            }
-
-            settings.StatsMode = SessionCtx->Query().StatsMode;
-            auto profile = config->Profile.Get(cluster);
+            return SyncOk(); 
+        } 
+ 
+        auto resultId = node.Ref().UniqueId(); 
+ 
+        TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult> asyncResult; 
+        if (auto resultPtr = SessionCtx->Query().InProgress.FindPtr(resultId)) { 
+            asyncResult = *resultPtr; 
+        } else { 
+            auto config = SessionCtx->Config().Snapshot(); 
+ 
+            auto isolationLevel = config->IsolationLevel.Get(cluster); 
+ 
+            IKikimrQueryExecutor::TExecuteSettings settings; 
+            settings.CommitTx = true; 
+            if (mode) { 
+                if (*mode == KikimrCommitModeFlush()) { 
+                    settings.CommitTx = false; 
+                } 
+ 
+                if (*mode == KikimrCommitModeRollback()) { 
+                    settings.CommitTx = false; 
+                    settings.RollbackTx = true; 
+                } 
+            } 
+ 
+            settings.IsolationLevel = isolationLevel; 
+            settings.UseNewEngine = useNewEngine; 
+            settings.StrictDml = config->StrictDml.Get(cluster).GetRef(); 
+ 
+            const auto& scanQuery = config->ScanQuery.Get(cluster); 
+            if (scanQuery) { 
+                settings.UseScanQuery = scanQuery.GetRef(); 
+            } 
+ 
+            settings.StatsMode = SessionCtx->Query().StatsMode; 
+            auto profile = config->Profile.Get(cluster); 
             if (profile && *profile) {
                 // Do not disable profiling if it was enabled at request level
-                settings.StatsMode = EKikimrStatsMode::Profile;
-            }
-
-            asyncResult = runFunc(settings);
-
-            auto insertResult = SessionCtx->Query().InProgress.insert(std::make_pair(resultId, asyncResult));
-            YQL_ENSURE(insertResult.second);
-        }
-
-        YQL_ENSURE(asyncResult);
-
-        if (asyncResult->HasResult()) {
-            SessionCtx->Query().InProgress.erase(resultId);
-
-            auto result = asyncResult->GetResult();
-            if (!result.Success()) {
+                settings.StatsMode = EKikimrStatsMode::Profile; 
+            } 
+ 
+            asyncResult = runFunc(settings); 
+ 
+            auto insertResult = SessionCtx->Query().InProgress.insert(std::make_pair(resultId, asyncResult)); 
+            YQL_ENSURE(insertResult.second); 
+        } 
+ 
+        YQL_ENSURE(asyncResult); 
+ 
+        if (asyncResult->HasResult()) { 
+            SessionCtx->Query().InProgress.erase(resultId); 
+ 
+            auto result = asyncResult->GetResult(); 
+            if (!result.Success()) { 
                 node.Ptr()->SetState(TExprNode::EState::Error);
-
-                return std::make_pair(IGraphTransformer::TStatus::Error, TAsyncTransformCallbackFuture());
-            }
-
+ 
+                return std::make_pair(IGraphTransformer::TStatus::Error, TAsyncTransformCallbackFuture()); 
+            } 
+ 
             auto insertResult = SessionCtx->Query().Results.emplace(resultId, std::move(result));
-            YQL_ENSURE(insertResult.second);
-
-            SessionCtx->Query().ExecutionOrder.push_back(resultId);
-
+            YQL_ENSURE(insertResult.second); 
+ 
+            SessionCtx->Query().ExecutionOrder.push_back(resultId); 
+ 
             node.Ptr()->SetState(TExprNode::EState::ExecutionComplete);
-            node.Ptr()->SetResult(ctx.NewAtom(node.Pos(), ToString(resultId)));
-
-            if (finalizeFunc) {
-                finalizeFunc(node, result, ctx);
-            }
-
-            return std::make_pair(IGraphTransformer::TStatus::Ok, TAsyncTransformCallbackFuture());
-        }
-
-        return std::make_pair(IGraphTransformer::TStatus::Async, asyncResult->Continue().Apply(
-            [](const TFuture<bool>& future) {
-                Y_UNUSED(future);
-
-                return TAsyncTransformCallback(
-                    [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
-                        Y_UNUSED(ctx);
-                        output = input;
-
+            node.Ptr()->SetResult(ctx.NewAtom(node.Pos(), ToString(resultId))); 
+ 
+            if (finalizeFunc) { 
+                finalizeFunc(node, result, ctx); 
+            } 
+ 
+            return std::make_pair(IGraphTransformer::TStatus::Ok, TAsyncTransformCallbackFuture()); 
+        } 
+ 
+        return std::make_pair(IGraphTransformer::TStatus::Async, asyncResult->Continue().Apply( 
+            [](const TFuture<bool>& future) { 
+                Y_UNUSED(future); 
+ 
+                return TAsyncTransformCallback( 
+                    [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) { 
+                        Y_UNUSED(ctx); 
+                        output = input; 
+ 
                         input->SetState(TExprNode::EState::ExecutionRequired);
-                        return IGraphTransformer::TStatus::Repeat;
-                    });
-            }));
-    }
-
-    std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture> RunKiExecDataQuery(TExprContext& ctx,
-        const TKiExecDataQuery& execQuery)
-    {
-        auto cluster = TString(execQuery.DataSink().Cluster());
-        auto settings = TKiExecDataQuerySettings::Parse(execQuery);
-
-        auto runFunc = [this, cluster, execQuery, &ctx](const IKikimrQueryExecutor::TExecuteSettings& settings)
-            -> TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult>
-        {
-            return QueryExecutor->ExecuteDataQuery(cluster, execQuery.Query().Ptr(), ctx, settings);
-        };
-
-        auto finalizeFunc = [] (TExprBase node, const IKikimrQueryExecutor::TQueryResult& result, TExprContext& ctx) {
-            FillExecDataQueryAst(node.Cast<TKiExecDataQuery>(), result.QueryAst, ctx);
-        };
-
-        return PerformExecution(execQuery, ctx, cluster, settings.Mode, settings.UseNewEngine, runFunc, finalizeFunc);
-    }
-
-    bool ApplyTableOperations(const TString& cluster, const TVector<NKqpProto::TKqpTableOp>& tableOps,
-        NKikimrKqp::EIsolationLevel isolationLevel, TExprContext& ctx)
-    {
-        bool strictDml = SessionCtx->Config().StrictDml.Get(cluster).GetRef();
-        auto queryType = SessionCtx->Query().Type;
-        TVector<NKqpProto::TKqpTableInfo> tableInfo;
-
+                        return IGraphTransformer::TStatus::Repeat; 
+                    }); 
+            })); 
+    } 
+ 
+    std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture> RunKiExecDataQuery(TExprContext& ctx, 
+        const TKiExecDataQuery& execQuery) 
+    { 
+        auto cluster = TString(execQuery.DataSink().Cluster()); 
+        auto settings = TKiExecDataQuerySettings::Parse(execQuery); 
+ 
+        auto runFunc = [this, cluster, execQuery, &ctx](const IKikimrQueryExecutor::TExecuteSettings& settings) 
+            -> TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult> 
+        { 
+            return QueryExecutor->ExecuteDataQuery(cluster, execQuery.Query().Ptr(), ctx, settings); 
+        }; 
+ 
+        auto finalizeFunc = [] (TExprBase node, const IKikimrQueryExecutor::TQueryResult& result, TExprContext& ctx) { 
+            FillExecDataQueryAst(node.Cast<TKiExecDataQuery>(), result.QueryAst, ctx); 
+        }; 
+ 
+        return PerformExecution(execQuery, ctx, cluster, settings.Mode, settings.UseNewEngine, runFunc, finalizeFunc); 
+    } 
+ 
+    bool ApplyTableOperations(const TString& cluster, const TVector<NKqpProto::TKqpTableOp>& tableOps, 
+        NKikimrKqp::EIsolationLevel isolationLevel, TExprContext& ctx) 
+    { 
+        bool strictDml = SessionCtx->Config().StrictDml.Get(cluster).GetRef(); 
+        auto queryType = SessionCtx->Query().Type; 
+        TVector<NKqpProto::TKqpTableInfo> tableInfo; 
+ 
         for (const auto& op : tableOps) {
             auto table = op.GetTable();
             const auto& desc = SessionCtx->Tables().GetTable(cluster, table);
             YQL_ENSURE(desc.Metadata);
-            tableInfo.push_back(NKqpProto::TKqpTableInfo());
+            tableInfo.push_back(NKqpProto::TKqpTableInfo()); 
             TableDescriptionToTableInfo(desc, &tableInfo.back());
         }
 
-        if (!SessionCtx->HasTx()) {
-            TKikimrTransactionContextBase emptyCtx;
+        if (!SessionCtx->HasTx()) { 
+            TKikimrTransactionContextBase emptyCtx; 
             return emptyCtx.ApplyTableOperations(tableOps, tableInfo, isolationLevel, strictDml, queryType, ctx);
-        }
-
+        } 
+ 
         return SessionCtx->Tx().ApplyTableOperations(tableOps, tableInfo, isolationLevel, strictDml, queryType, ctx);
-    }
-
+    } 
+ 
     bool ApplyDdlOperation(const TString& cluster, TPositionHandle pos, const TString& table,
         TYdbOperation op, TExprContext& ctx)
-    {
-        YQL_ENSURE(op & KikimrSchemeOps());
-
+    { 
+        YQL_ENSURE(op & KikimrSchemeOps()); 
+ 
         auto position = ctx.GetPosition(pos);
 
-        NKqpProto::TKqpTableOp protoOp;
+        NKqpProto::TKqpTableOp protoOp; 
         protoOp.MutablePosition()->SetRow(position.Row);
         protoOp.MutablePosition()->SetColumn(position.Column);
-        protoOp.SetTable(table);
-        protoOp.SetOperation((ui32)op);
-
-        return ApplyTableOperations(cluster, {protoOp}, NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE, ctx);
-    }
-
-private:
-    TIntrusivePtr<IKikimrGateway> Gateway;
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-    TIntrusivePtr<IKikimrQueryExecutor> QueryExecutor;
-};
-
-} // namespace
-
-NKikimrKqp::EIsolationLevel GetIsolationLevel(const TMaybe<TString>& isolationLevel) {
-    YQL_ENSURE(isolationLevel);
-    auto levelStr = *isolationLevel;
-
-    if (levelStr == "ReadStale") {
-        return NKikimrKqp::ISOLATION_LEVEL_READ_STALE;
-    } else if (levelStr == "ReadUncommitted") {
-        return NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED;
-    } else if (levelStr == "ReadCommitted") {
-        return NKikimrKqp::ISOLATION_LEVEL_READ_COMMITTED;
-    } else if (levelStr == "Serializable") {
-        return NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE;
-    }
-
-    YQL_ENSURE(false, "Unsupported isolation level: " << levelStr);
-}
-
-TMaybe<TString> GetIsolationLevel(const NKikimrKqp::EIsolationLevel& isolationLevel) {
-    switch (isolationLevel) {
-        case NKikimrKqp::ISOLATION_LEVEL_READ_STALE: return "ReadStale";
-        case NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED: return "ReadUncommitted";
-        case NKikimrKqp::ISOLATION_LEVEL_READ_COMMITTED: return "ReadCommitted";
-        case NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE: return "Serializable";
-        default:
-            return TMaybe<TString>();
-    }
-}
-
-TAutoPtr<IGraphTransformer> CreateKiSourceCallableExecutionTransformer(
-    TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx)
-{
-    return new TKiSourceCallableExecutionTransformer(gateway, sessionCtx);
-}
-
-TAutoPtr<IGraphTransformer> CreateKiSinkCallableExecutionTransformer(
-    TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-    TIntrusivePtr<IKikimrQueryExecutor> queryExecutor)
-{
+        protoOp.SetTable(table); 
+        protoOp.SetOperation((ui32)op); 
+ 
+        return ApplyTableOperations(cluster, {protoOp}, NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE, ctx); 
+    } 
+ 
+private: 
+    TIntrusivePtr<IKikimrGateway> Gateway; 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+    TIntrusivePtr<IKikimrQueryExecutor> QueryExecutor; 
+}; 
+ 
+} // namespace 
+ 
+NKikimrKqp::EIsolationLevel GetIsolationLevel(const TMaybe<TString>& isolationLevel) { 
+    YQL_ENSURE(isolationLevel); 
+    auto levelStr = *isolationLevel; 
+ 
+    if (levelStr == "ReadStale") { 
+        return NKikimrKqp::ISOLATION_LEVEL_READ_STALE; 
+    } else if (levelStr == "ReadUncommitted") { 
+        return NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED; 
+    } else if (levelStr == "ReadCommitted") { 
+        return NKikimrKqp::ISOLATION_LEVEL_READ_COMMITTED; 
+    } else if (levelStr == "Serializable") { 
+        return NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE; 
+    } 
+ 
+    YQL_ENSURE(false, "Unsupported isolation level: " << levelStr); 
+} 
+ 
+TMaybe<TString> GetIsolationLevel(const NKikimrKqp::EIsolationLevel& isolationLevel) { 
+    switch (isolationLevel) { 
+        case NKikimrKqp::ISOLATION_LEVEL_READ_STALE: return "ReadStale"; 
+        case NKikimrKqp::ISOLATION_LEVEL_READ_UNCOMMITTED: return "ReadUncommitted"; 
+        case NKikimrKqp::ISOLATION_LEVEL_READ_COMMITTED: return "ReadCommitted"; 
+        case NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE: return "Serializable"; 
+        default: 
+            return TMaybe<TString>(); 
+    } 
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKiSourceCallableExecutionTransformer( 
+    TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
+{ 
+    return new TKiSourceCallableExecutionTransformer(gateway, sessionCtx); 
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKiSinkCallableExecutionTransformer( 
+    TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+    TIntrusivePtr<IKikimrQueryExecutor> queryExecutor) 
+{ 
     return new TKiSinkCallableExecutionTransformer(gateway, sessionCtx, queryExecutor);
-}
-
-TAutoPtr<IGraphTransformer> CreateKiSinkPlanInfoTransformer(TIntrusivePtr<IKikimrQueryExecutor> queryExecutor) {
-    return new TKiSinkPlanInfoTransformer(queryExecutor);
-}
-
-} // namespace NYql
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKiSinkPlanInfoTransformer(TIntrusivePtr<IKikimrQueryExecutor> queryExecutor) { 
+    return new TKiSinkPlanInfoTransformer(queryExecutor); 
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_expr_nodes.cpp b/ydb/core/kqp/provider/yql_kikimr_expr_nodes.cpp
index cbe44c3a9d..2a40e4c4c6 100644
--- a/ydb/core/kqp/provider/yql_kikimr_expr_nodes.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_expr_nodes.cpp
@@ -1,34 +1,34 @@
-#include "yql_kikimr_expr_nodes.h"
-
-#include "yql_kikimr_provider_impl.h"
-
-namespace NYql {
-namespace NNodes {
-
+#include "yql_kikimr_expr_nodes.h" 
+ 
+#include "yql_kikimr_provider_impl.h" 
+ 
+namespace NYql { 
+namespace NNodes { 
+ 
 TString TKiReadTable::GetTable(TExprContext& ctx) const {
-    TKikimrKey key(ctx);
+    TKikimrKey key(ctx); 
     YQL_ENSURE(key.Extract(TableKey().Ref()));
     YQL_ENSURE(key.GetKeyType() == TKikimrKey::Type::Table);
-
-    return key.GetTablePath();
-}
-
-TCoAtomList TKiReadTable::GetSelectColumns(TExprContext& ctx, const TKikimrTableDescription& tableData,
-    bool withSystemColumns) const
-{
+ 
+    return key.GetTablePath(); 
+} 
+ 
+TCoAtomList TKiReadTable::GetSelectColumns(TExprContext& ctx, const TKikimrTableDescription& tableData, 
+    bool withSystemColumns) const 
+{ 
     if (Select().Maybe<TCoVoid>()) {
-        return BuildColumnsList(tableData, Pos(), ctx, withSystemColumns);
-    }
-
+        return BuildColumnsList(tableData, Pos(), ctx, withSystemColumns); 
+    } 
+ 
     return Select().Cast<TCoAtomList>();
-}
-
-TCoAtomList TKiReadTable::GetSelectColumns(TExprContext& ctx, const TKikimrTablesData& tablesData,
-    bool withSystemColumns) const
-{
-    auto& tableData = tablesData.ExistingTable(TString(DataSource().Cluster()), GetTable(ctx));
-    return GetSelectColumns(ctx, tableData, withSystemColumns);
-}
-
-} // namespace NNodes
-} // namespace NYql
+} 
+ 
+TCoAtomList TKiReadTable::GetSelectColumns(TExprContext& ctx, const TKikimrTablesData& tablesData, 
+    bool withSystemColumns) const 
+{ 
+    auto& tableData = tablesData.ExistingTable(TString(DataSource().Cluster()), GetTable(ctx)); 
+    return GetSelectColumns(ctx, tableData, withSystemColumns); 
+} 
+ 
+} // namespace NNodes 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_expr_nodes.h b/ydb/core/kqp/provider/yql_kikimr_expr_nodes.h
index e91fd7635a..5104afbd6a 100644
--- a/ydb/core/kqp/provider/yql_kikimr_expr_nodes.h
+++ b/ydb/core/kqp/provider/yql_kikimr_expr_nodes.h
@@ -1,89 +1,89 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.gen.h>
 #include <ydb/core/kqp/provider/yql_kikimr_provider.h>
-
+ 
 #include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
 #include <ydb/library/yql/core/expr_nodes/yql_expr_nodes.h>
-
-namespace NYql {
-namespace NNodes {
-
+ 
+namespace NYql { 
+namespace NNodes { 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.decl.inl.h>
-
+ 
 class TKiDataSource : public NGenerated::TKiDataSourceStub<TExprBase, TCallable, TCoAtom> {
-public:
+public: 
     explicit TKiDataSource(const TExprNode* node)
         : TKiDataSourceStub(node) {}
 
     explicit TKiDataSource(const TExprNode::TPtr& node)
-        : TKiDataSourceStub(node) {}
-
-    static bool Match(const TExprNode* node) {
-        if (!TKiDataSourceStub::Match(node)) {
-            return false;
-        }
-
+        : TKiDataSourceStub(node) {} 
+ 
+    static bool Match(const TExprNode* node) { 
+        if (!TKiDataSourceStub::Match(node)) { 
+            return false; 
+        } 
+ 
         if (node->Child(0)->Content() != KikimrProviderName) {
-            return false;
-        }
-
-        return true;
-    }
-};
-
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+}; 
+ 
 class TKiDataSink : public NGenerated::TKiDataSinkStub<TExprBase, TCallable, TCoAtom> {
-public:
+public: 
     explicit TKiDataSink(const TExprNode* node)
         : TKiDataSinkStub(node) {}
 
     explicit TKiDataSink(const TExprNode::TPtr& node)
-        : TKiDataSinkStub(node) {}
-
-    static bool Match(const TExprNode* node) {
-        if (!TKiDataSinkStub::Match(node)) {
-            return false;
-        }
-
+        : TKiDataSinkStub(node) {} 
+ 
+    static bool Match(const TExprNode* node) { 
+        if (!TKiDataSinkStub::Match(node)) { 
+            return false; 
+        } 
+ 
         if (node->Child(0)->Content() != KikimrProviderName) {
-            return false;
-        }
-
-        return true;
-    }
-};
-
-class TKiReadTable : public NGenerated::TKiReadTableStub<TExprBase, TKiReadBase, TCoNameValueTupleList> {
-public:
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+}; 
+ 
+class TKiReadTable : public NGenerated::TKiReadTableStub<TExprBase, TKiReadBase, TCoNameValueTupleList> { 
+public: 
     explicit TKiReadTable(const TExprNode* node)
         : TKiReadTableStub(node) {}
 
     explicit TKiReadTable(const TExprNode::TPtr& node)
-        : TKiReadTableStub(node) {}
-
+        : TKiReadTableStub(node) {} 
+ 
     TString GetTable(TExprContext& ctx) const;
-    TCoAtomList GetSelectColumns(TExprContext& ctx, const TKikimrTablesData& tablesData,
-        bool withVirtualColumns = false) const;
-    TCoAtomList GetSelectColumns(TExprContext& ctx, const TKikimrTableDescription& tableData,
-        bool withVirtualColumns = false) const;
-};
-
+    TCoAtomList GetSelectColumns(TExprContext& ctx, const TKikimrTablesData& tablesData, 
+        bool withVirtualColumns = false) const; 
+    TCoAtomList GetSelectColumns(TExprContext& ctx, const TKikimrTableDescription& tableData, 
+        bool withVirtualColumns = false) const; 
+}; 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.defs.inl.h>
-
-template<typename TParent>
-class TNodeBuilder<TParent, TKiColumnRangeTuple> : public NGenerated::TKiColumnRangeTupleBuilder<TParent>
-{
-public:
+ 
+template<typename TParent> 
+class TNodeBuilder<TParent, TKiColumnRangeTuple> : public NGenerated::TKiColumnRangeTupleBuilder<TParent> 
+{ 
+public: 
     TNodeBuilder(TExprContext& ctx, TPositionHandle pos,
-        typename NGenerated::TKiColumnRangeTupleBuilder<TParent>::BuildFuncType buildFunc,
-        typename NGenerated::TKiColumnRangeTupleBuilder<TParent>::GetArgFuncType getArgFunc)
-        : NGenerated::TKiColumnRangeTupleBuilder<TParent>(ctx, pos, buildFunc, getArgFunc) {}
-
-    TKiColumnRangeTuple DoBuild() {
+        typename NGenerated::TKiColumnRangeTupleBuilder<TParent>::BuildFuncType buildFunc, 
+        typename NGenerated::TKiColumnRangeTupleBuilder<TParent>::GetArgFuncType getArgFunc) 
+        : NGenerated::TKiColumnRangeTupleBuilder<TParent>(ctx, pos, buildFunc, getArgFunc) {} 
+ 
+    TKiColumnRangeTuple DoBuild() { 
         auto node = this->Ctx.NewList(this->Pos, { this->ColumnHolder.Cast().Ptr(), this->FromHolder.Cast().Ptr(), this->ToHolder.Cast().Ptr() });
-        return TKiColumnRangeTuple(node);
-    }
-};
-
-} // namespace NNodes
-} // namespace NYql
+        return TKiColumnRangeTuple(node); 
+    } 
+}; 
+ 
+} // namespace NNodes 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_expr_nodes.json b/ydb/core/kqp/provider/yql_kikimr_expr_nodes.json
index c54d82a2ca..0aff3c8ecf 100644
--- a/ydb/core/kqp/provider/yql_kikimr_expr_nodes.json
+++ b/ydb/core/kqp/provider/yql_kikimr_expr_nodes.json
@@ -1,31 +1,31 @@
-{
-    "NodeRootType": "TExprBase",
-    "NodeBuilderBase": "TNodeBuilderBase",
-    "ListBuilderBase": "TListBuilderBase",
-    "FreeArgCallableBase": "TFreeArgCallable",
-    "FreeArgBuilderBase": "TFreeArgCallableBuilderBase",
-    "Nodes": [
-        {
-            "Name": "TKiDataSource",
-            "Base": "TCallable",
-            "Definition": "Custom",
-            "Match": {"Type": "Callable", "Name": "DataSource"},
-            "Children": [
+{ 
+    "NodeRootType": "TExprBase", 
+    "NodeBuilderBase": "TNodeBuilderBase", 
+    "ListBuilderBase": "TListBuilderBase", 
+    "FreeArgCallableBase": "TFreeArgCallable", 
+    "FreeArgBuilderBase": "TFreeArgCallableBuilderBase", 
+    "Nodes": [ 
+        { 
+            "Name": "TKiDataSource", 
+            "Base": "TCallable", 
+            "Definition": "Custom", 
+            "Match": {"Type": "Callable", "Name": "DataSource"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Category", "Type": "TCoAtom"},
                 {"Index": 1, "Name": "Cluster", "Type": "TCoAtom"}
-            ]
-        },
-        {
-            "Name": "TKiDataSink",
-            "Base": "TCallable",
-            "Definition": "Custom",
-            "Match": {"Type": "Callable", "Name": "DataSink"},
-            "Children": [
+            ] 
+        }, 
+        { 
+            "Name": "TKiDataSink", 
+            "Base": "TCallable", 
+            "Definition": "Custom", 
+            "Match": {"Type": "Callable", "Name": "DataSink"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Category", "Type": "TCoAtom"},
                 {"Index": 1, "Name": "Cluster", "Type": "TCoAtom"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TKiVersionedTable",
             "Base": "TExprBase",
             "Match": {"Type": "Tuple"},
@@ -36,81 +36,81 @@
             ]
         },
         {
-            "Name": "TKiReadBase",
-            "Base": "TCallable",
-            "Match": {"Type": "CallableBase"},
-            "Builder": {"Generate": "None"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
-                {"Index": 1, "Name": "DataSource", "Type": "TKiDataSource"},
-                {"Index": 2, "Name": "TableKey", "Type": "TExprBase"}
-            ]
-        },
-        {
-            "Name": "TKiReadTable",
-            "Base": "TKiReadBase",
-            "Definition": "Custom",
-            "Match": {"Type": "Callable", "Name": "KiReadTable!"},
-            "Children": [
-                {"Index": 3, "Name": "Select", "Type": "TExprBase"},
+            "Name": "TKiReadBase", 
+            "Base": "TCallable", 
+            "Match": {"Type": "CallableBase"}, 
+            "Builder": {"Generate": "None"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "DataSource", "Type": "TKiDataSource"}, 
+                {"Index": 2, "Name": "TableKey", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKiReadTable", 
+            "Base": "TKiReadBase", 
+            "Definition": "Custom", 
+            "Match": {"Type": "Callable", "Name": "KiReadTable!"}, 
+            "Children": [ 
+                {"Index": 3, "Name": "Select", "Type": "TExprBase"}, 
                 {"Index": 4, "Name": "Settings", "Type": "TCoNameValueTupleList"}
-            ]
-        },
-        {
-            "Name": "TKiReadTableScheme",
-            "Base": "TKiReadBase",
-            "Match": {"Type": "Callable", "Name": "KiReadTableScheme!"}
-        },
-        {
-            "Name": "TKiReadTableList",
-            "Base": "TKiReadBase",
-            "Match": {"Type": "Callable", "Name": "KiReadTableList!"}
-        },
-        {
-            "Name": "TKiWriteTable",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiWriteTable!"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
-                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"},
+            ] 
+        }, 
+        { 
+            "Name": "TKiReadTableScheme", 
+            "Base": "TKiReadBase", 
+            "Match": {"Type": "Callable", "Name": "KiReadTableScheme!"} 
+        }, 
+        { 
+            "Name": "TKiReadTableList", 
+            "Base": "TKiReadBase", 
+            "Match": {"Type": "Callable", "Name": "KiReadTableList!"} 
+        }, 
+        { 
+            "Name": "TKiWriteTable", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiWriteTable!"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"}, 
                 {"Index": 2, "Name": "Table", "Type": "TCoAtom"},
-                {"Index": 3, "Name": "Input", "Type": "TExprBase"},
+                {"Index": 3, "Name": "Input", "Type": "TExprBase"}, 
                 {"Index": 4, "Name": "Mode", "Type": "TCoAtom"},
                 {"Index": 5, "Name": "Settings", "Type": "TCoNameValueTupleList"}
-            ]
-        },
-        {
-            "Name": "TKiUpdateTable",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiUpdateTable!"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
-                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"},
+            ] 
+        }, 
+        { 
+            "Name": "TKiUpdateTable", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiUpdateTable!"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"}, 
                 {"Index": 2, "Name": "Table", "Type": "TCoAtom"},
                 {"Index": 3, "Name": "Filter", "Type": "TCoLambda"},
                 {"Index": 4, "Name": "Update", "Type": "TCoLambda"}
-            ]
-        },
-        {
-            "Name": "TKiDeleteTable",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiDeleteTable!"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
-                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"},
+            ] 
+        }, 
+        { 
+            "Name": "TKiDeleteTable", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiDeleteTable!"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"}, 
                 {"Index": 2, "Name": "Table", "Type": "TCoAtom"},
                 {"Index": 3, "Name": "Filter", "Type": "TCoLambda"}
-            ]
-        },
-        {
-            "Name": "TKiCreateTable",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiCreateTable!"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
-                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"},
+            ] 
+        }, 
+        { 
+            "Name": "TKiCreateTable", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiCreateTable!"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"}, 
                 {"Index": 2, "Name": "Table", "Type": "TCoAtom"},
-                {"Index": 3, "Name": "Columns", "Type": "TExprList"},
+                {"Index": 3, "Name": "Columns", "Type": "TExprList"}, 
                 {"Index": 4, "Name": "PrimaryKey", "Type": "TCoAtomList"},
                 {"Index": 5, "Name": "Settings", "Type": "TCoNameValueTupleList"},
                 {"Index": 6, "Name": "Indexes", "Type": "TCoIndexList"},
@@ -118,9 +118,9 @@
                 {"Index": 8, "Name": "ColumnFamilies", "Type": "TExprList"},
                 {"Index": 9, "Name": "TableSettings", "Type": "TCoNameValueTupleList"},
                 {"Index": 10, "Name": "Changefeeds", "Type": "TCoChangefeedList"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TKiAlterTable",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "KiAlterTable!"},
@@ -132,17 +132,17 @@
             ]
         },
         {
-            "Name": "TKiDropTable",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiDropTable!"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
-                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"},
+            "Name": "TKiDropTable", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiDropTable!"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"}, 
                 {"Index": 2, "Name": "Table", "Type": "TCoAtom"},
                 {"Index": 3, "Name": "Settings", "Type": "TCoNameValueTupleList"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TKiCreateUser",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "KiCreateUser!"},
@@ -219,146 +219,146 @@
             ]
         },
         {
-            "Name": "TKiOperationList",
+            "Name": "TKiOperationList", 
             "ListBase": "TKiOperation"
         },
         {
-            "Name": "TKiResult",
-            "Base": "TExprBase",
-            "Match": {"Type": "Tuple"},
-            "Children": [
-                {"Index": 0, "Name": "Value", "Type": "TExprBase"},
-                {"Index": 1, "Name": "Columns", "Type": "TCoAtomList"},
-                {"Index": 2, "Name": "RowsLimit", "Type": "TCoAtom"}
-            ]
-        },
-        {
-            "Name": "TKiResultList",
-            "ListBase": "TKiResult"
-        },
-        {
-            "Name": "TKiEffects",
-            "VarArgBase": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiEffects"}
-        },
-        {
-            "Name": "TKiDataQuery",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiDataQuery"},
-            "Children": [
-                {"Index": 0, "Name": "Operations", "Type": "TKiOperationList"},
-                {"Index": 1, "Name": "Results", "Type": "TKiResultList"},
-                {"Index": 2, "Name": "Effects", "Type": "TKiEffects"}
-            ]
-        },
-        {
-            "Name": "TKiExecDataQuery",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiExecDataQuery!"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
-                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"},
-                {"Index": 2, "Name": "Query", "Type": "TKiDataQuery"},
-                {"Index": 3, "Name": "Settings", "Type": "TCoNameValueTupleList"},
-                {"Index": 4, "Name": "Ast", "Type": "TExprBase"}
-            ]
-        },
-        {
-            "Name": "TKiColumnRangeTuple",
-            "Base": "TExprBase",
-            "Match": {"Type": "NodeType", "TypeName": "List"},
-            "Builder": {"Generate": "Custom"},
-            "Children": [
+            "Name": "TKiResult", 
+            "Base": "TExprBase", 
+            "Match": {"Type": "Tuple"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Value", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "Columns", "Type": "TCoAtomList"}, 
+                {"Index": 2, "Name": "RowsLimit", "Type": "TCoAtom"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKiResultList", 
+            "ListBase": "TKiResult" 
+        }, 
+        { 
+            "Name": "TKiEffects", 
+            "VarArgBase": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiEffects"} 
+        }, 
+        { 
+            "Name": "TKiDataQuery", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiDataQuery"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Operations", "Type": "TKiOperationList"}, 
+                {"Index": 1, "Name": "Results", "Type": "TKiResultList"}, 
+                {"Index": 2, "Name": "Effects", "Type": "TKiEffects"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKiExecDataQuery", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiExecDataQuery!"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "DataSink", "Type": "TKiDataSink"}, 
+                {"Index": 2, "Name": "Query", "Type": "TKiDataQuery"}, 
+                {"Index": 3, "Name": "Settings", "Type": "TCoNameValueTupleList"}, 
+                {"Index": 4, "Name": "Ast", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKiColumnRangeTuple", 
+            "Base": "TExprBase", 
+            "Match": {"Type": "NodeType", "TypeName": "List"}, 
+            "Builder": {"Generate": "Custom"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Column", "Type": "TCoAtom"},
-                {"Index": 1, "Name": "From", "Type": "TExprBase"},
-                {"Index": 2, "Name": "To", "Type": "TExprBase"}
-            ]
-        },
-        {
-            "Name": "TKiSelectRow",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiSelectRow"},
-            "Children": [
+                {"Index": 1, "Name": "From", "Type": "TExprBase"}, 
+                {"Index": 2, "Name": "To", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKiSelectRow", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiSelectRow"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Cluster", "Type": "TCoAtom"},
                 {"Index": 1, "Name": "Table", "Type": "TKiVersionedTable"},
                 {"Index": 2, "Name": "Key", "Type": "TCoNameValueTupleList"},
                 {"Index": 3, "Name": "Select", "Type": "TCoAtomList"}
-            ]
-        },
-        {
-            "Name": "TKiUpdateRow",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiUpdateRow"},
-            "Children": [
+            ] 
+        }, 
+        { 
+            "Name": "TKiUpdateRow", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiUpdateRow"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Cluster", "Type": "TCoAtom"},
                 {"Index": 1, "Name": "Table", "Type": "TKiVersionedTable"},
                 {"Index": 2, "Name": "Key", "Type": "TCoNameValueTupleList"},
-                {"Index": 3, "Name": "Update", "Type": "TCoNameValueTupleList"}
-            ]
-        },
-        {
-            "Name": "TKiEraseRow",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiEraseRow"},
-            "Children": [
+                {"Index": 3, "Name": "Update", "Type": "TCoNameValueTupleList"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKiEraseRow", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiEraseRow"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Cluster", "Type": "TCoAtom"},
                 {"Index": 1, "Name": "Table", "Type": "TKiVersionedTable"},
                 {"Index": 2, "Name": "Key", "Type": "TCoNameValueTupleList"}
-            ]
-        },
-        {
-            "Name": "TKiSelectRangeBase",
-            "Base": "TCallable",
-            "Match": {"Type": "CallableBase"},
-            "Builder": {"Generate": "None"},
-            "Children": [
+            ] 
+        }, 
+        { 
+            "Name": "TKiSelectRangeBase", 
+            "Base": "TCallable", 
+            "Match": {"Type": "CallableBase"}, 
+            "Builder": {"Generate": "None"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Cluster", "Type": "TCoAtom"},
                 {"Index": 1, "Name": "Table", "Type": "TKiVersionedTable"},
-                {"Index": 2, "Name": "Range", "Type": "TExprList"},
+                {"Index": 2, "Name": "Range", "Type": "TExprList"}, 
                 {"Index": 3, "Name": "Select", "Type": "TCoAtomList"},
                 {"Index": 4, "Name": "Settings", "Type": "TCoNameValueTupleList"}
-            ]
-        },
-        {
-            "Name": "TKiSelectRange",
-            "Base": "TKiSelectRangeBase",
-            "Match": {"Type": "Callable", "Name": "KiSelectRange"}
-        },
-        {
+            ] 
+        }, 
+        { 
+            "Name": "TKiSelectRange", 
+            "Base": "TKiSelectRangeBase", 
+            "Match": {"Type": "Callable", "Name": "KiSelectRange"} 
+        }, 
+        { 
             "Name": "TKiSelectIndexRange",
-            "Base": "TKiSelectRangeBase",
+            "Base": "TKiSelectRangeBase", 
             "Match": {"Type": "Callable", "Name": "KiSelectIndexRange"},
             "Children": [
                 {"Index": 5, "Name": "IndexName", "Type": "TCoAtom"}
             ]
-        },
-        {
-            "Name": "TKiSetResult",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiSetResult"},
-            "Children": [
+        }, 
+        { 
+            "Name": "TKiSetResult", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiSetResult"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Name", "Type": "TCoAtom"},
-                {"Index": 1, "Name": "Data", "Type": "TExprBase"}
-            ]
-        },
-        {
-            "Name": "TKiAcquireLocks",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiAcquireLocks"},
-            "Children": [
-                {"Index": 0, "Name": "LockTxId", "Type": "TExprBase"}
-            ]
-        },
-        {
-            "Name": "TKiMapParameter",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiMapParameter"},
-            "Children": [
-                {"Index": 0, "Name": "Input", "Type": "TExprBase"},
+                {"Index": 1, "Name": "Data", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKiAcquireLocks", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiAcquireLocks"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "LockTxId", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKiMapParameter", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiMapParameter"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Input", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "Lambda", "Type": "TCoLambda"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TMkqlMapParameter",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "MapParameter"},
@@ -368,64 +368,64 @@
             ]
         },
         {
-            "Name": "TKiFlatMapParameter",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiFlatMapParameter"},
-            "Children": [
-                {"Index": 0, "Name": "Input", "Type": "TExprBase"},
+            "Name": "TKiFlatMapParameter", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiFlatMapParameter"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Input", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "Lambda", "Type": "TCoLambda"}
-            ]
-        },
-        {
-            "Name": "TKiConditionalEffect",
-            "Base": "TCallable",
-            "Match": {"Type": "CallableBase"},
-            "Builder": {"Generate": "None"},
-            "Children": [
-                {"Index": 0, "Name": "Predicate", "Type": "TExprBase"},
-                {"Index": 1, "Name": "Effect", "Type": "TExprBase"},
+            ] 
+        }, 
+        { 
+            "Name": "TKiConditionalEffect", 
+            "Base": "TCallable", 
+            "Match": {"Type": "CallableBase"}, 
+            "Builder": {"Generate": "None"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Predicate", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "Effect", "Type": "TExprBase"}, 
                 {"Index": 2, "Name": "Constraint", "Type": "TCoAtom"}
-            ]
-        },
-        {
-            "Name": "TKiAbortIf",
-            "Base": "TKiConditionalEffect",
-            "Match": {"Type": "Callable", "Name": "KiAbortIf"}
-        },
-        {
-            "Name": "TKiRevertIf",
-            "Base": "TKiConditionalEffect",
-            "Match": {"Type": "Callable", "Name": "KiRevertIf"}
-        },
-        {
-            "Name": "TKiProgram",
-            "Base": "TExprBase",
-            "Match": {"Type": "Tuple"},
-            "Children": [
-                {"Index": 0, "Name": "Results", "Type": "TExprList"},
-                {"Index": 1, "Name": "Effects", "Type": "TExprBase"}
-            ]
-        },
-        {
-            "Name": "TKiPartialSort",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiPartialSort"},
-            "Children": [
-                {"Index": 0, "Name": "Input",             "Type": "TExprBase"},
-                {"Index": 1, "Name": "SortDirections",    "Type": "TExprBase"},
+            ] 
+        }, 
+        { 
+            "Name": "TKiAbortIf", 
+            "Base": "TKiConditionalEffect", 
+            "Match": {"Type": "Callable", "Name": "KiAbortIf"} 
+        }, 
+        { 
+            "Name": "TKiRevertIf", 
+            "Base": "TKiConditionalEffect", 
+            "Match": {"Type": "Callable", "Name": "KiRevertIf"} 
+        }, 
+        { 
+            "Name": "TKiProgram", 
+            "Base": "TExprBase", 
+            "Match": {"Type": "Tuple"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Results", "Type": "TExprList"}, 
+                {"Index": 1, "Name": "Effects", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
+            "Name": "TKiPartialSort", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiPartialSort"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Input",             "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "SortDirections",    "Type": "TExprBase"}, 
                 {"Index": 2, "Name": "KeySelectorLambda", "Type": "TCoLambda"}
-            ]
-        },
-        {
-            "Name": "TKiPartialTake",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "KiPartialTake"},
-            "Children": [
-                {"Index": 0, "Name": "Input", "Type": "TExprBase"},
-                {"Index": 1, "Name": "Count", "Type": "TExprBase"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
+            "Name": "TKiPartialTake", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "KiPartialTake"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Input", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "Count", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TKiGrpcData",
             "Base": "TExprBase",
             "Match": {"Type": "Tuple"},
@@ -444,6 +444,6 @@
                 {"Index": 0, "Name": "GrpcData", "Type": "TKiGrpcData"},
                 {"Index": 1, "Name": "TvmId", "Type": "TCoAtom"}
             ]
-        }
-    ]
-}
+        } 
+    ] 
+} 
diff --git a/ydb/core/kqp/provider/yql_kikimr_gateway.cpp b/ydb/core/kqp/provider/yql_kikimr_gateway.cpp
index e49f84b5e1..b4ad49f920 100644
--- a/ydb/core/kqp/provider/yql_kikimr_gateway.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_gateway.cpp
@@ -1,204 +1,204 @@
-#include "yql_kikimr_gateway.h"
-
+#include "yql_kikimr_gateway.h" 
+ 
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
 #include <ydb/library/yql/providers/common/proto/gateways_config.pb.h>
 #include <ydb/library/yql/utils/yql_panic.h>
-
+ 
 #include <ydb/core/base/table_index.h>
 
-#include <util/string/split.h>
-
-namespace NYql {
-
-using namespace NThreading;
-
+#include <util/string/split.h> 
+ 
+namespace NYql { 
+ 
+using namespace NThreading; 
+ 
 static void CreateDirs(std::shared_ptr<TVector<TString>> partsHolder, size_t index,
-    TPromise<IKikimrGateway::TGenericResult>& promise, IKikimrGateway::TCreateDirFunc createDir)
-{
-    auto partPromise = NewPromise<IKikimrGateway::TGenericResult>();
-    auto& parts = *partsHolder;
-
-    partPromise.GetFuture().Apply(
-        [partsHolder, index, promise, createDir](const TFuture<IKikimrGateway::TGenericResult>& future) mutable {
-            auto& result = future.GetValue();
-            if (index == partsHolder->size() - 1) {
-                promise.SetValue(result);
-                return;
-            }
-
-            if (!result.Success() && result.Status() != TIssuesIds::KIKIMR_ACCESS_DENIED) {
-                promise.SetValue(result);
-                return;
-            }
-
-            CreateDirs(partsHolder, index + 1, promise, createDir);
-        });
-
+    TPromise<IKikimrGateway::TGenericResult>& promise, IKikimrGateway::TCreateDirFunc createDir) 
+{ 
+    auto partPromise = NewPromise<IKikimrGateway::TGenericResult>(); 
+    auto& parts = *partsHolder; 
+ 
+    partPromise.GetFuture().Apply( 
+        [partsHolder, index, promise, createDir](const TFuture<IKikimrGateway::TGenericResult>& future) mutable { 
+            auto& result = future.GetValue(); 
+            if (index == partsHolder->size() - 1) { 
+                promise.SetValue(result); 
+                return; 
+            } 
+ 
+            if (!result.Success() && result.Status() != TIssuesIds::KIKIMR_ACCESS_DENIED) { 
+                promise.SetValue(result); 
+                return; 
+            } 
+ 
+            CreateDirs(partsHolder, index + 1, promise, createDir); 
+        }); 
+ 
     TString basePath = IKikimrGateway::CombinePath(parts.begin(), parts.begin() + index);
-
-    createDir(basePath, parts[index], partPromise);
-}
-
-TKikimrClusterMapping::TKikimrClusterMapping(const TKikimrGatewayConfig& config) {
+ 
+    createDir(basePath, parts[index], partPromise); 
+} 
+ 
+TKikimrClusterMapping::TKikimrClusterMapping(const TKikimrGatewayConfig& config) { 
     THashMap<TString, TString> defaultSettings;
-    for (auto& setting : config.GetDefaultSettings()) {
-        defaultSettings[setting.GetName()] = setting.GetValue();
-    }
-
-    for (size_t i = 0; i < config.ClusterMappingSize(); ++i) {
-        const TKikimrClusterConfig& cluster = config.GetClusterMapping(i);
-
+    for (auto& setting : config.GetDefaultSettings()) { 
+        defaultSettings[setting.GetName()] = setting.GetValue(); 
+    } 
+ 
+    for (size_t i = 0; i < config.ClusterMappingSize(); ++i) { 
+        const TKikimrClusterConfig& cluster = config.GetClusterMapping(i); 
+ 
         auto name = cluster.GetName();
-
+ 
         if (Clusters.contains(name)) {
-            ythrow yexception() << "TKikimrGatewayConfig: Duplicate cluster name: " << name;
-        }
-
-        Clusters[name] = cluster;
-
-        if (cluster.GetDefault()) {
-            if (DefaultClusterName) {
-                ythrow yexception() << "TKikimrGatewayConfig: More than one default cluster (current: "
-                    << name << ", previous: " << DefaultClusterName << ")";
-            }
-            DefaultClusterName = name;
-        }
-
-        ClusterSettings[name] = defaultSettings;
-        for (auto& setting : cluster.GetSettings()) {
-            ClusterSettings[name][setting.GetName()] = setting.GetValue();
-        }
-    }
-}
-
+            ythrow yexception() << "TKikimrGatewayConfig: Duplicate cluster name: " << name; 
+        } 
+ 
+        Clusters[name] = cluster; 
+ 
+        if (cluster.GetDefault()) { 
+            if (DefaultClusterName) { 
+                ythrow yexception() << "TKikimrGatewayConfig: More than one default cluster (current: " 
+                    << name << ", previous: " << DefaultClusterName << ")"; 
+            } 
+            DefaultClusterName = name; 
+        } 
+ 
+        ClusterSettings[name] = defaultSettings; 
+        for (auto& setting : cluster.GetSettings()) { 
+            ClusterSettings[name][setting.GetName()] = setting.GetValue(); 
+        } 
+    } 
+} 
+ 
 void TKikimrClusterMapping::GetAllClusterNames(TVector<TString>& names) const {
-    names.clear();
-    for (const auto& c: Clusters) {
-        names.push_back(c.first);
-    }
-}
-
+    names.clear(); 
+    for (const auto& c: Clusters) { 
+        names.push_back(c.first); 
+    } 
+} 
+ 
 const TKikimrClusterConfig& TKikimrClusterMapping::GetClusterConfig(const TString& name) const {
-    if (const TKikimrClusterConfig* config = Clusters.FindPtr(name)) {
-        return *config;
-    } else {
-        throw yexception() << "Unknown cluster name: " << name;
-    }
-}
-
+    if (const TKikimrClusterConfig* config = Clusters.FindPtr(name)) { 
+        return *config; 
+    } else { 
+        throw yexception() << "Unknown cluster name: " << name; 
+    } 
+} 
+ 
 TMaybe<TString> TKikimrClusterMapping::GetClusterSetting(const TString& cluster, const TString& name) const {
-    auto clusterSettings = ClusterSettings.FindPtr(cluster);
-    YQL_ENSURE(clusterSettings);
-
-    auto setting = clusterSettings->FindPtr(name);
+    auto clusterSettings = ClusterSettings.FindPtr(cluster); 
+    YQL_ENSURE(clusterSettings); 
+ 
+    auto setting = clusterSettings->FindPtr(name); 
     return setting ? *setting : TMaybe<TString>();
-}
-
+} 
+ 
 TString TKikimrClusterMapping::GetDefaultClusterName() const {
     if (!DefaultClusterName) {
         ythrow yexception() << "TKikimrGatewayConfig: No default cluster";
     }
 
-    return DefaultClusterName;
-}
-
-bool TKikimrClusterMapping::HasCluster(const TString& cluster) const {
+    return DefaultClusterName; 
+} 
+ 
+bool TKikimrClusterMapping::HasCluster(const TString& cluster) const { 
     return Clusters.contains(cluster);
-}
-
-TKikimrPathId TKikimrPathId::Parse(const TStringBuf& str) {
-    TStringBuf ownerStr;
-    TStringBuf idStr;
-    YQL_ENSURE(str.TrySplit(':', ownerStr, idStr));
-
-    return TKikimrPathId(FromString<ui64>(ownerStr), FromString<ui64>(idStr));
-}
-
+} 
+ 
+TKikimrPathId TKikimrPathId::Parse(const TStringBuf& str) { 
+    TStringBuf ownerStr; 
+    TStringBuf idStr; 
+    YQL_ENSURE(str.TrySplit(':', ownerStr, idStr)); 
+ 
+    return TKikimrPathId(FromString<ui64>(ownerStr), FromString<ui64>(idStr)); 
+} 
+ 
 TString IKikimrGateway::CanonizePath(const TString& path) {
-    if (path.empty()) {
-        return "/";
-    }
-
-    if (path[0] != '/') {
-        return "/" + path;
-    }
-
-    return path;
-}
-
+    if (path.empty()) { 
+        return "/"; 
+    } 
+ 
+    if (path[0] != '/') { 
+        return "/" + path; 
+    } 
+ 
+    return path; 
+} 
+ 
 TVector<TString> IKikimrGateway::SplitPath(const TString& path) {
     TVector<TString> parts;
-    Split(path, "/", parts);
-    return parts;
-}
-
-bool IKikimrGateway::TrySplitTablePath(const TString& path, std::pair<TString, TString>& result, TString& error) {
-    auto parts = SplitPath(path);
-
-    if (parts.size() < 2) {
-        error = TString("Missing scheme root in table path: ") + path;
-        return false;
-    }
-
-    result = std::make_pair(
-        CombinePath(parts.begin(), parts.end() - 1),
+    Split(path, "/", parts); 
+    return parts; 
+} 
+ 
+bool IKikimrGateway::TrySplitTablePath(const TString& path, std::pair<TString, TString>& result, TString& error) { 
+    auto parts = SplitPath(path); 
+ 
+    if (parts.size() < 2) { 
+        error = TString("Missing scheme root in table path: ") + path; 
+        return false; 
+    } 
+ 
+    result = std::make_pair( 
+        CombinePath(parts.begin(), parts.end() - 1), 
         parts.back());
-
-    return true;
-}
-
+ 
+    return true; 
+} 
+ 
 TFuture<IKikimrGateway::TGenericResult> IKikimrGateway::CreatePath(const TString& path, TCreateDirFunc createDir) {
     auto partsHolder = std::make_shared<TVector<TString>>(SplitPath(path));
-    auto &parts = *partsHolder;
-
-    if (parts.size() < 2) {
-        TGenericResult result;
-        result.SetSuccess();
-        return MakeFuture<TGenericResult>(result);
-    }
-
-    auto pathPromise = NewPromise<TGenericResult>();
-    CreateDirs(partsHolder, 1, pathPromise, createDir);
-
-    return pathPromise.GetFuture();
-}
-
+    auto &parts = *partsHolder; 
+ 
+    if (parts.size() < 2) { 
+        TGenericResult result; 
+        result.SetSuccess(); 
+        return MakeFuture<TGenericResult>(result); 
+    } 
+ 
+    auto pathPromise = NewPromise<TGenericResult>(); 
+    CreateDirs(partsHolder, 1, pathPromise, createDir); 
+ 
+    return pathPromise.GetFuture(); 
+} 
+ 
 TString IKikimrGateway::CreateIndexTablePath(const TString& tableName, const TString& indexName) {
     return tableName + "/" + indexName + "/indexImplTable";
 }
 
 
-void IKikimrGateway::BuildIndexMetadata(TTableMetadataResult& loadTableMetadataResult) {
-    auto tableMetadata = loadTableMetadataResult.Metadata;
-    YQL_ENSURE(tableMetadata);
-
-    if (tableMetadata->Indexes.empty()) {
-        return;
-    }
+void IKikimrGateway::BuildIndexMetadata(TTableMetadataResult& loadTableMetadataResult) { 
+    auto tableMetadata = loadTableMetadataResult.Metadata; 
+    YQL_ENSURE(tableMetadata); 
 
+    if (tableMetadata->Indexes.empty()) { 
+        return; 
+    } 
+ 
     const auto& cluster = tableMetadata->Cluster;
     const auto& tableName = tableMetadata->Name;
     const size_t indexesCount = tableMetadata->Indexes.size();
 
-    NKikimr::NTableIndex::TTableColumns tableColumns;
-    tableColumns.Columns.reserve(tableMetadata->Columns.size());
+    NKikimr::NTableIndex::TTableColumns tableColumns; 
+    tableColumns.Columns.reserve(tableMetadata->Columns.size()); 
     for (auto& column: tableMetadata->Columns) {
-        tableColumns.Columns.insert_noresize(column.first);
+        tableColumns.Columns.insert_noresize(column.first); 
     }
-    tableColumns.Keys = tableMetadata->KeyColumnNames;
+    tableColumns.Keys = tableMetadata->KeyColumnNames; 
 
     tableMetadata->SecondaryGlobalIndexMetadata.resize(indexesCount);
     for (size_t i = 0; i < indexesCount; i++) {
         const auto& index = tableMetadata->Indexes[i];
         auto indexTablePath = CreateIndexTablePath(tableName, index.Name);
-        NKikimr::NTableIndex::TTableColumns indexTableColumns = NKikimr::NTableIndex::CalcTableImplDescription(
+        NKikimr::NTableIndex::TTableColumns indexTableColumns = NKikimr::NTableIndex::CalcTableImplDescription( 
                     tableColumns,
                     NKikimr::NTableIndex::TIndexColumns{index.KeyColumns, {}});
 
         TKikimrTableMetadataPtr indexTableMetadata = new TKikimrTableMetadata(cluster, indexTablePath);
         indexTableMetadata->DoesExist = true;
-        indexTableMetadata->KeyColumnNames = indexTableColumns.Keys;
-        for (auto& column: indexTableColumns.Columns) {
+        indexTableMetadata->KeyColumnNames = indexTableColumns.Keys; 
+        for (auto& column: indexTableColumns.Columns) { 
             indexTableMetadata->Columns[column] = tableMetadata->Columns.at(column);
         }
 
@@ -351,14 +351,14 @@ void ConvertTtlSettingsToProto(const NYql::TTtlSettings& settings, Ydb::Table::T
     proto.mutable_date_type_column()->set_expire_after_seconds(settings.ExpireAfter.Seconds());
 }
 
-Ydb::FeatureFlag::Status GetFlagValue(const TMaybe<bool>& value) {
-    if (!value) {
-        return Ydb::FeatureFlag::STATUS_UNSPECIFIED;
-    }
-
-    return *value
-        ? Ydb::FeatureFlag::ENABLED
-        : Ydb::FeatureFlag::DISABLED;
-}
-
-} // namespace NYql
+Ydb::FeatureFlag::Status GetFlagValue(const TMaybe<bool>& value) { 
+    if (!value) { 
+        return Ydb::FeatureFlag::STATUS_UNSPECIFIED; 
+    } 
+ 
+    return *value 
+        ? Ydb::FeatureFlag::ENABLED 
+        : Ydb::FeatureFlag::DISABLED; 
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_gateway.h b/ydb/core/kqp/provider/yql_kikimr_gateway.h
index 7598494a2b..6bbef160d2 100644
--- a/ydb/core/kqp/provider/yql_kikimr_gateway.h
+++ b/ydb/core/kqp/provider/yql_kikimr_gateway.h
@@ -1,5 +1,5 @@
-#pragma once
-
+#pragma once 
+ 
 #include "yql_kikimr_query_traits.h"
 
 #include <ydb/library/yql/public/udf/udf_data_type.h>
@@ -7,45 +7,45 @@
 #include <ydb/library/yql/utils/yql_panic.h>
 #include <ydb/library/yql/providers/common/gateway/yql_provider_gateway.h>
 #include <ydb/library/yql/providers/result/expr_nodes/yql_res_expr_nodes.h>
-
-// TODO: Switch to public protobufs
+ 
+// TODO: Switch to public protobufs 
 #include <ydb/core/protos/kqp.pb.h>
 #include <ydb/library/yql/dq/actors/protos/dq_events.pb.h>
 #include <ydb/core/protos/flat_scheme_op.pb.h>
 #include <ydb/library/aclib/aclib.h>
-
+ 
 #include <library/cpp/threading/future/future.h>
-
+ 
 #include <util/datetime/base.h>
-#include <util/generic/flags.h>
-#include <util/generic/map.h>
+#include <util/generic/flags.h> 
+#include <util/generic/map.h> 
 #include <util/generic/maybe.h>
 #include <util/generic/hash.h>
-#include <util/generic/ptr.h>
-#include <util/string/join.h>
-
+#include <util/generic/ptr.h> 
+#include <util/string/join.h> 
+ 
 #include <memory>
 
-namespace NYql {
-
+namespace NYql { 
+ 
 using NUdf::EDataSlot;
 
 class TKikimrGatewayConfig;
-class TKikimrClusterConfig;
-
-using TKikimrParamsMap = TMap<TString, NKikimrMiniKQL::TParams>;
-
-struct TKikimrQueryPhaseLimits {
-    ui32 AffectedShardsLimit = 0;
-    ui32 ReadsetCountLimit = 0;
-    ui64 ComputeNodeMemoryLimitBytes = 0;
-    ui64 TotalReadSizeLimitBytes = 0;
-};
-
-struct TKikimrQueryLimits {
-    TKikimrQueryPhaseLimits PhaseLimits;
-};
-
+class TKikimrClusterConfig; 
+ 
+using TKikimrParamsMap = TMap<TString, NKikimrMiniKQL::TParams>; 
+ 
+struct TKikimrQueryPhaseLimits { 
+    ui32 AffectedShardsLimit = 0; 
+    ui32 ReadsetCountLimit = 0; 
+    ui64 ComputeNodeMemoryLimitBytes = 0; 
+    ui64 TotalReadSizeLimitBytes = 0; 
+}; 
+ 
+struct TKikimrQueryLimits { 
+    TKikimrQueryPhaseLimits PhaseLimits; 
+}; 
+ 
 struct TIndexDescription {
     enum class EType : ui32 {
         GlobalSync = 0,
@@ -177,14 +177,14 @@ struct TTableSettings {
     bool IsSet() const;
 };
 
-struct TKikimrColumnMetadata {
+struct TKikimrColumnMetadata { 
     TString Name;
-    ui32 Id = 0;
+    ui32 Id = 0; 
     TString Type;
     bool NotNull = false;
-    ui32 TypeId = 0;
+    ui32 TypeId = 0; 
     TVector<TString> Families;
-
+ 
     TKikimrColumnMetadata() = default;
 
     TKikimrColumnMetadata(const TString& name, ui32 id, const TString& type, bool notNull, ui32 typeId = 0)
@@ -215,98 +215,98 @@ struct TKikimrColumnMetadata {
         }
     }
 
-    bool IsSameScheme(const TKikimrColumnMetadata& other) const {
+    bool IsSameScheme(const TKikimrColumnMetadata& other) const { 
         return Name == other.Name && Type == other.Type && NotNull == other.NotNull;
-    }
+    } 
 
     void SetNotNull() {
         NotNull = true;
     }
-};
-
-struct TKikimrPathId {
-    explicit TKikimrPathId(const std::pair<ui64, ui64>& raw)
-        : Raw(raw) {}
-
-    TKikimrPathId(ui64 ownerId, ui64 tableId)
-        : TKikimrPathId(std::make_pair(ownerId, tableId)) {}
-
+}; 
+ 
+struct TKikimrPathId { 
+    explicit TKikimrPathId(const std::pair<ui64, ui64>& raw) 
+        : Raw(raw) {} 
+ 
+    TKikimrPathId(ui64 ownerId, ui64 tableId) 
+        : TKikimrPathId(std::make_pair(ownerId, tableId)) {} 
+ 
     TKikimrPathId(const NKikimrKqp::TKqpPathIdProto* message)
         : TKikimrPathId(std::make_pair(message->GetOwnerId(), message->GetTableId())) {}
 
-    ui64 OwnerId() const { return Raw.first; }
-    ui64 TableId() const { return Raw.second; }
-
-    TString ToString() const {
-        return ::ToString(OwnerId()) + ':' + ::ToString(TableId());
-    }
-
-    bool operator==(const TKikimrPathId& x) const {
-        return Raw == x.Raw;
-    }
-
-    bool operator!=(const TKikimrPathId& x) const {
-        return !operator==(x);
-    }
-
-    ui64 Hash() const noexcept {
-        return THash<decltype(Raw)>()(Raw);
-    }
-
-    static TKikimrPathId Parse(const TStringBuf& str);
-
-    std::pair<ui64, ui64> Raw;
+    ui64 OwnerId() const { return Raw.first; } 
+    ui64 TableId() const { return Raw.second; } 
+ 
+    TString ToString() const { 
+        return ::ToString(OwnerId()) + ':' + ::ToString(TableId()); 
+    } 
+ 
+    bool operator==(const TKikimrPathId& x) const { 
+        return Raw == x.Raw; 
+    } 
+ 
+    bool operator!=(const TKikimrPathId& x) const { 
+        return !operator==(x); 
+    } 
+ 
+    ui64 Hash() const noexcept { 
+        return THash<decltype(Raw)>()(Raw); 
+    } 
+ 
+    static TKikimrPathId Parse(const TStringBuf& str); 
+ 
+    std::pair<ui64, ui64> Raw; 
 
     void ToMessage(NKikimrKqp::TKqpPathIdProto* message) const {
         message->SetOwnerId(OwnerId());
         message->SetTableId(TableId());
     }
-};
-
+}; 
+ 
 enum class EKikimrTableKind : ui32 {
-    Unspecified = 0,
+    Unspecified = 0, 
     Datashard = 1,
     SysView = 2,
     Olap = 3
-};
-
-struct TKikimrTableMetadata : public TThrRefBase {
-    bool DoesExist = false;
+}; 
+ 
+struct TKikimrTableMetadata : public TThrRefBase { 
+    bool DoesExist = false; 
     TString Cluster;
     TString Name;
-    TKikimrPathId PathId;
-    TString SysView;
-    ui64 SchemaVersion = 0;
-    THashMap<TString, TString> Attributes;
-    EKikimrTableKind Kind = EKikimrTableKind::Unspecified;
-
-    ui64 RecordsCount = 0;
-    ui64 DataSize = 0;
-    ui64 MemorySize = 0;
-    ui32 ShardsCount = 0;
-
-    TInstant LastAccessTime;
-    TInstant LastUpdateTime;
-
+    TKikimrPathId PathId; 
+    TString SysView; 
+    ui64 SchemaVersion = 0; 
+    THashMap<TString, TString> Attributes; 
+    EKikimrTableKind Kind = EKikimrTableKind::Unspecified; 
+ 
+    ui64 RecordsCount = 0; 
+    ui64 DataSize = 0; 
+    ui64 MemorySize = 0; 
+    ui32 ShardsCount = 0; 
+ 
+    TInstant LastAccessTime; 
+    TInstant LastUpdateTime; 
+ 
     TMap<TString, TKikimrColumnMetadata> Columns;
     TVector<TString> KeyColumnNames;
     TVector<TString> ColumnOrder;
-
+ 
     // Indexes and SecondaryGlobalIndexMetadata must be in same order
     TVector<TIndexDescription> Indexes;
     TVector<TIntrusivePtr<TKikimrTableMetadata>> SecondaryGlobalIndexMetadata;
 
     TVector<TColumnFamily> ColumnFamilies;
     TTableSettings TableSettings;
-
+ 
     TKikimrTableMetadata(const TString& cluster, const TString& table)
-        : Cluster(cluster)
-        , Name(table)
-        , PathId(std::make_pair(0, 0)) {}
-
-    TKikimrTableMetadata()
-        : TKikimrTableMetadata("", "") {}
-
+        : Cluster(cluster) 
+        , Name(table) 
+        , PathId(std::make_pair(0, 0)) {} 
+ 
+    TKikimrTableMetadata() 
+        : TKikimrTableMetadata("", "") {} 
+ 
     TKikimrTableMetadata(const NKikimrKqp::TKqpTableMetadataProto* message)
         : DoesExist(message->GetDoesExist())
         , Cluster(message->GetCluster())
@@ -341,27 +341,27 @@ struct TKikimrTableMetadata : public TThrRefBase {
         }
     }
 
-    bool IsSameTable(const TKikimrTableMetadata& other) {
-        if (!DoesExist) {
-            return false;
-        }
-
-        if (Cluster != other.Cluster || Name != other.Name || Columns.size() != other.Columns.size() ||
+    bool IsSameTable(const TKikimrTableMetadata& other) { 
+        if (!DoesExist) { 
+            return false; 
+        } 
+ 
+        if (Cluster != other.Cluster || Name != other.Name || Columns.size() != other.Columns.size() || 
                 KeyColumnNames != other.KeyColumnNames || Indexes.size() != other.Indexes.size()) {
             return false;
         }
 
         for (auto& [name, column]: Columns) {
-            auto otherColumn = other.Columns.FindPtr(name);
-            if (!otherColumn) {
-                return false;
-            }
-
-            if (!column.IsSameScheme(*otherColumn)) {
-                return false;
-            }
-        }
-
+            auto otherColumn = other.Columns.FindPtr(name); 
+            if (!otherColumn) { 
+                return false; 
+            } 
+ 
+            if (!column.IsSameScheme(*otherColumn)) { 
+                return false; 
+            } 
+        } 
+ 
         for (size_t i = 0; i < Indexes.size(); i++) {
             if (!Indexes[i].IsSameIndex(other.Indexes[i])) {
                 return false;
@@ -369,7 +369,7 @@ struct TKikimrTableMetadata : public TThrRefBase {
         }
 
         return true;
-    }
+    } 
 
     void ToMessage(NKikimrKqp::TKqpTableMetadataProto* message) const {
         message->SetDoesExist(DoesExist);
@@ -419,8 +419,8 @@ struct TKikimrTableMetadata : public TThrRefBase {
         }
         return {nullptr, TIndexDescription::EIndexState::Invalid};
     }
-};
-
+}; 
+ 
 struct TCreateUserSettings {
     TString UserName;
     TString Password;
@@ -458,103 +458,103 @@ struct TDropGroupSettings {
     bool Force = false;
 };
 
-struct TKikimrListPathItem {
+struct TKikimrListPathItem { 
     TKikimrListPathItem(TString name, bool isDirectory) {
-        Name = name;
-        IsDirectory = isDirectory;
-    }
-
+        Name = name; 
+        IsDirectory = isDirectory; 
+    } 
+ 
     TString Name;
-    bool IsDirectory;
-};
-
-typedef TIntrusivePtr<TKikimrTableMetadata> TKikimrTableMetadataPtr;
-
-class TKikimrClusterMapping {
-public:
-    TKikimrClusterMapping(const TKikimrGatewayConfig& config);
-
+    bool IsDirectory; 
+}; 
+ 
+typedef TIntrusivePtr<TKikimrTableMetadata> TKikimrTableMetadataPtr; 
+ 
+class TKikimrClusterMapping { 
+public: 
+    TKikimrClusterMapping(const TKikimrGatewayConfig& config); 
+ 
     void GetAllClusterNames(TVector<TString>& names) const;
     const TKikimrClusterConfig& GetClusterConfig(const TString& name) const;
     TMaybe<TString> GetClusterSetting(const TString& cluster, const TString& name) const;
     TString GetDefaultClusterName() const;
-    bool HasCluster(const TString& cluster) const;
-
-private:
+    bool HasCluster(const TString& cluster) const; 
+ 
+private: 
     THashMap<TString, TKikimrClusterConfig> Clusters;
     THashMap<TString, THashMap<TString, TString>> ClusterSettings;
     TString DefaultClusterName;
-};
-
-template<typename TResult>
-class IKikimrAsyncResult : public TThrRefBase {
-public:
-    virtual bool HasResult() const = 0;
+}; 
+ 
+template<typename TResult> 
+class IKikimrAsyncResult : public TThrRefBase { 
+public: 
+    virtual bool HasResult() const = 0; 
     virtual TResult GetResult() = 0;
-    virtual NThreading::TFuture<bool> Continue() = 0;
-
-    virtual ~IKikimrAsyncResult() {}
-};
-
-template<typename TResult>
-class TKikimrResultHolder : public IKikimrAsyncResult<TResult> {
-public:
+    virtual NThreading::TFuture<bool> Continue() = 0; 
+ 
+    virtual ~IKikimrAsyncResult() {} 
+}; 
+ 
+template<typename TResult> 
+class TKikimrResultHolder : public IKikimrAsyncResult<TResult> { 
+public: 
     TKikimrResultHolder(TResult&& result)
         : Result(std::move(result)) {}
-
-    bool HasResult() const override {
+ 
+    bool HasResult() const override { 
         return Full;
-    }
-
+    } 
+ 
     TResult GetResult() override {
         Full = false;
         return std::move(Result);
-    }
-
-    NThreading::TFuture<bool> Continue() override {
-        return NThreading::MakeFuture<bool>(true);
-    }
-
-private:
-    TResult Result;
+    } 
+ 
+    NThreading::TFuture<bool> Continue() override { 
+        return NThreading::MakeFuture<bool>(true); 
+    } 
+ 
+private: 
+    TResult Result; 
     bool Full = true;
-};
-
-template<typename TResult>
+}; 
+ 
+template<typename TResult> 
 static TIntrusivePtr<TKikimrResultHolder<TResult>> MakeKikimrResultHolder(TResult&& result) {
     return MakeIntrusive<TKikimrResultHolder<TResult>>(std::move(result));
-}
-
-class IKikimrGateway : public TThrRefBase {
-public:
+} 
+ 
+class IKikimrGateway : public TThrRefBase { 
+public: 
     using TPtr = TIntrusivePtr<IKikimrGateway>;
 
-    struct TGenericResult : public NCommon::TOperationResult {
-    };
-
-    struct TListPathResult : public TGenericResult {
+    struct TGenericResult : public NCommon::TOperationResult { 
+    }; 
+ 
+    struct TListPathResult : public TGenericResult { 
         TString Path;
         TVector<TKikimrListPathItem> Items;
-    };
-
-    struct TTableMetadataResult : public TGenericResult {
-        TKikimrTableMetadataPtr Metadata;
-    };
-
-    struct TQueryResult : public TGenericResult {
+    }; 
+ 
+    struct TTableMetadataResult : public TGenericResult { 
+        TKikimrTableMetadataPtr Metadata; 
+    }; 
+ 
+    struct TQueryResult : public TGenericResult { 
         TString SessionId;
         TVector<NKikimrMiniKQL::TResult*> Results;
-        TMaybe<NKikimrKqp::TQueryProfile> Profile; // TODO: Deprecate.
-        NKqpProto::TKqpStatsQuery QueryStats;
+        TMaybe<NKikimrKqp::TQueryProfile> Profile; // TODO: Deprecate. 
+        NKqpProto::TKqpStatsQuery QueryStats; 
         std::unique_ptr<NKikimrKqp::TPreparedQuery> PreparingQuery;
         std::shared_ptr<const NKikimrKqp::TPreparedQuery> PreparedQuery;
         std::optional<NKikimr::NKqp::TQueryTraits> QueryTraits;
-        TString QueryAst;
-        TString QueryPlan;
+        TString QueryAst; 
+        TString QueryPlan; 
         std::shared_ptr<google::protobuf::Arena> ProtobufArenaPtr;
-        TMaybe<ui16> SqlVersion;
-    };
-
+        TMaybe<ui16> SqlVersion; 
+    }; 
+ 
     struct TLoadTableMetadataSettings {
         TLoadTableMetadataSettings& WithTableStats(bool enable) {
             RequestStats_ = enable;
@@ -581,28 +581,28 @@ public:
         virtual ~IKqpTableMetadataLoader() = default;
     };
 
-public:
-    virtual bool HasCluster(const TString& cluster) = 0;
+public: 
+    virtual bool HasCluster(const TString& cluster) = 0; 
     virtual TVector<TString> GetClusters() = 0;
-    virtual TString GetDefaultCluster() = 0;
+    virtual TString GetDefaultCluster() = 0; 
     virtual TMaybe<TKikimrClusterConfig> GetClusterConfig(const TString& cluster) = 0;
     virtual TMaybe<TString> GetSetting(const TString& cluster, const TString& name) = 0;
-
-    virtual void SetToken(const TString& cluster, const TString& token) = 0;
-
+ 
+    virtual void SetToken(const TString& cluster, const TString& token) = 0; 
+ 
     virtual NThreading::TFuture<TListPathResult> ListPath(const TString& cluster, const TString& path) = 0;
-
-    virtual NThreading::TFuture<TTableMetadataResult> LoadTableMetadata(
+ 
+    virtual NThreading::TFuture<TTableMetadataResult> LoadTableMetadata( 
         const TString& cluster, const TString& table, TLoadTableMetadataSettings settings) = 0;
-
-    virtual NThreading::TFuture<TGenericResult> CreateTable(TKikimrTableMetadataPtr metadata, bool createDir) = 0;
-
+ 
+    virtual NThreading::TFuture<TGenericResult> CreateTable(TKikimrTableMetadataPtr metadata, bool createDir) = 0; 
+ 
     virtual NThreading::TFuture<TGenericResult> AlterTable(Ydb::Table::AlterTableRequest&& req, const TString& cluster) = 0;
 
     virtual NThreading::TFuture<TGenericResult> RenameTable(const TString& src, const TString& dst, const TString& cluster) = 0;
 
     virtual NThreading::TFuture<TGenericResult> DropTable(const TString& cluster, const TString& table) = 0;
-
+ 
     virtual NThreading::TFuture<TGenericResult> CreateUser(const TString& cluster, const TCreateUserSettings& settings) = 0;
 
     virtual NThreading::TFuture<TGenericResult> AlterUser(const TString& cluster, const TAlterUserSettings& settings) = 0;
@@ -617,43 +617,43 @@ public:
 
     virtual TVector<TString> GetCollectedSchemeData() = 0;
 
-public:
+public: 
     using TCreateDirFunc = std::function<void(const TString&, const TString&, NThreading::TPromise<TGenericResult>)>;
-
+ 
     static TString CanonizePath(const TString& path);
-
-    template <typename TIter>
-    static TString CombinePath(TIter begin, TIter end, bool canonize = true) {
-        auto path = JoinRange("/", begin, end);
-        return canonize
-            ? CanonizePath(path)
-            : path;
-    }
-
+ 
+    template <typename TIter> 
+    static TString CombinePath(TIter begin, TIter end, bool canonize = true) { 
+        auto path = JoinRange("/", begin, end); 
+        return canonize 
+            ? CanonizePath(path) 
+            : path; 
+    } 
+ 
     static TVector<TString> SplitPath(const TString& path);
-
-    static bool TrySplitTablePath(const TString& path, std::pair<TString, TString>& result, TString& error);
-
+ 
+    static bool TrySplitTablePath(const TString& path, std::pair<TString, TString>& result, TString& error); 
+ 
     static NThreading::TFuture<TGenericResult> CreatePath(const TString& path, TCreateDirFunc createDir);
 
     static TString CreateIndexTablePath(const TString& tableName, const TString& indexName);
 
-    static void BuildIndexMetadata(TTableMetadataResult& loadTableMetadataResult);
-};
-
+    static void BuildIndexMetadata(TTableMetadataResult& loadTableMetadataResult); 
+}; 
+ 
 EYqlIssueCode YqlStatusFromYdbStatus(ui32 ydbStatus);
-Ydb::FeatureFlag::Status GetFlagValue(const TMaybe<bool>& value);
-
+Ydb::FeatureFlag::Status GetFlagValue(const TMaybe<bool>& value); 
+ 
 void SetColumnType(Ydb::Type& protoType, const TString& typeName, bool notNull);
 bool ConvertReadReplicasSettingsToProto(const TString settings, Ydb::Table::ReadReplicasSettings& proto,
     Ydb::StatusIds::StatusCode& code, TString& error);
 void ConvertTtlSettingsToProto(const NYql::TTtlSettings& settings, Ydb::Table::TtlSettings& proto);
 
-} // namespace NYql
-
-template<>
-struct THash<NYql::TKikimrPathId> {
-    inline ui64 operator()(const NYql::TKikimrPathId& x) const noexcept {
-        return x.Hash();
-    }
-};
+} // namespace NYql 
+ 
+template<> 
+struct THash<NYql::TKikimrPathId> { 
+    inline ui64 operator()(const NYql::TKikimrPathId& x) const noexcept { 
+        return x.Hash(); 
+    } 
+}; 
diff --git a/ydb/core/kqp/provider/yql_kikimr_gateway_ut.cpp b/ydb/core/kqp/provider/yql_kikimr_gateway_ut.cpp
index 791a617c08..9242d5ab7f 100644
--- a/ydb/core/kqp/provider/yql_kikimr_gateway_ut.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_gateway_ut.cpp
@@ -3,71 +3,71 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
 #include <ydb/core/kqp/kqp_impl.h>
 #include <ydb/core/kqp/kqp_metadata_loader.h>
-
+ 
 #include <util/generic/maybe.h>
 
-namespace NYql {
-
-using namespace NKikimr;
-using namespace NKikimr::NKqp;
-using namespace NMiniKQL;
+namespace NYql { 
+ 
+using namespace NKikimr; 
+using namespace NKikimr::NKqp; 
+using namespace NMiniKQL; 
 using namespace NResultLib;
-using namespace NYdb::NTable;
-
-namespace {
-
-constexpr const char* TestCluster = "kikimr";
-
-void CreateSampleTables(TKikimrRunner& runner) {
-    auto schemeClient = runner.GetSchemeClient();
-    AssertSuccessResult(schemeClient.MakeDirectory("/Root/Test").GetValueSync());
-    AssertSuccessResult(schemeClient.MakeDirectory("/Root/Test/UserDir").GetValueSync());
-
-    auto tableClient = runner.GetTableClient();
-    auto session = tableClient.CreateSession().GetValueSync().GetSession();
-
-    AssertSuccessResult(session.ExecuteSchemeQuery(R"(
-        CREATE TABLE [/Root/Test/UserTable] (
-            UserKey Utf8,
-            UserSubkey Uint32,
-            UserValue Utf8,
-            PRIMARY KEY (UserKey, UserSubkey)
-        );
-        CREATE TABLE [/Root/Test/TestTable2] (
-            Group Uint32,
-            Name String,
-            Amount Uint64,
-            Comment String,
-            PRIMARY KEY (Group, Name)
-        );
-        CREATE TABLE [/Root/Test/TestTableKsv] (
-            key String,
-            subkey String,
-            value String,
-            PRIMARY KEY (key, subkey)
-        );
-        CREATE TABLE [/Root/Test/TestTable3] (
-            Key Utf8,
-            SomeJson Json,
-            PRIMARY KEY (Key)
-        );
-    )").GetValueSync());
-
-    AssertSuccessResult(session.ExecuteDataQuery(R"(
-        REPLACE INTO [/Root/Test/TestTable2] (Group, Name, Amount, Comment) VALUES
-            (1u, "Anna", 3500ul, "None"),
-            (1u, "Paul", 300ul, "None"),
-            (2u, "Tony", 7200ul, "None");
-
-        REPLACE INTO [/Root/Test/TestTableKsv] (key, subkey, value) VALUES
-            ("Anna", "1", "Value1"),
-            ("Anna", "2", "Value2"),
-            ("Paul", "1", "Value3"),
-            ("Tony", "2", "Value4");
-    )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync());
-}
-
-TIntrusivePtr<IKqpGateway> GetIcGateway(Tests::TServer& server) {
+using namespace NYdb::NTable; 
+ 
+namespace { 
+ 
+constexpr const char* TestCluster = "kikimr"; 
+ 
+void CreateSampleTables(TKikimrRunner& runner) { 
+    auto schemeClient = runner.GetSchemeClient(); 
+    AssertSuccessResult(schemeClient.MakeDirectory("/Root/Test").GetValueSync()); 
+    AssertSuccessResult(schemeClient.MakeDirectory("/Root/Test/UserDir").GetValueSync()); 
+ 
+    auto tableClient = runner.GetTableClient(); 
+    auto session = tableClient.CreateSession().GetValueSync().GetSession(); 
+ 
+    AssertSuccessResult(session.ExecuteSchemeQuery(R"( 
+        CREATE TABLE [/Root/Test/UserTable] ( 
+            UserKey Utf8, 
+            UserSubkey Uint32, 
+            UserValue Utf8, 
+            PRIMARY KEY (UserKey, UserSubkey) 
+        ); 
+        CREATE TABLE [/Root/Test/TestTable2] ( 
+            Group Uint32, 
+            Name String, 
+            Amount Uint64, 
+            Comment String, 
+            PRIMARY KEY (Group, Name) 
+        ); 
+        CREATE TABLE [/Root/Test/TestTableKsv] ( 
+            key String, 
+            subkey String, 
+            value String, 
+            PRIMARY KEY (key, subkey) 
+        ); 
+        CREATE TABLE [/Root/Test/TestTable3] ( 
+            Key Utf8, 
+            SomeJson Json, 
+            PRIMARY KEY (Key) 
+        ); 
+    )").GetValueSync()); 
+ 
+    AssertSuccessResult(session.ExecuteDataQuery(R"( 
+        REPLACE INTO [/Root/Test/TestTable2] (Group, Name, Amount, Comment) VALUES 
+            (1u, "Anna", 3500ul, "None"), 
+            (1u, "Paul", 300ul, "None"), 
+            (2u, "Tony", 7200ul, "None"); 
+ 
+        REPLACE INTO [/Root/Test/TestTableKsv] (key, subkey, value) VALUES 
+            ("Anna", "1", "Value1"), 
+            ("Anna", "2", "Value2"), 
+            ("Paul", "1", "Value3"), 
+            ("Tony", "2", "Value4"); 
+    )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync()); 
+} 
+ 
+TIntrusivePtr<IKqpGateway> GetIcGateway(Tests::TServer& server) { 
     auto counters = MakeIntrusive<TKqpRequestCounters>();
     counters->Counters = new TKqpCounters(server.GetRuntime()->GetAppData(0).Counters);
     counters->TxProxyMon = new NTxProxy::TTxProxyMon(server.GetRuntime()->GetAppData(0).Counters);
@@ -75,92 +75,92 @@ TIntrusivePtr<IKqpGateway> GetIcGateway(Tests::TServer& server) {
     std::shared_ptr<NYql::IKikimrGateway::IKqpTableMetadataLoader> loader = std::make_shared<TKqpTableMetadataLoader>(server.GetRuntime()->GetAnyNodeActorSystem(), false);
     return CreateKikimrIcGateway(TestCluster, "/Root", std::move(loader), server.GetRuntime()->GetAnyNodeActorSystem(),
         server.GetRuntime()->GetNodeId(0), counters, MakeMiniKQLCompileServiceID());
-}
-
-void TestListPathCommon(TIntrusivePtr<IKikimrGateway> gateway) {
-    auto responseFuture = gateway->ListPath(TestCluster, "/Root/Test");
-    responseFuture.Wait();
-    auto response = responseFuture.GetValue();
-    response.Issues().PrintTo(Cerr);
-    UNIT_ASSERT(response.Success());
-
-    UNIT_ASSERT_VALUES_EQUAL(response.Path, "/Root/Test");
+} 
+ 
+void TestListPathCommon(TIntrusivePtr<IKikimrGateway> gateway) { 
+    auto responseFuture = gateway->ListPath(TestCluster, "/Root/Test"); 
+    responseFuture.Wait(); 
+    auto response = responseFuture.GetValue(); 
+    response.Issues().PrintTo(Cerr); 
+    UNIT_ASSERT(response.Success()); 
+ 
+    UNIT_ASSERT_VALUES_EQUAL(response.Path, "/Root/Test"); 
     UNIT_ASSERT_VALUES_EQUAL(response.Items.size(), 5);
-    UNIT_ASSERT_VALUES_EQUAL(response.Items[0].Name, "TestTable2");
-    UNIT_ASSERT_VALUES_EQUAL(response.Items[0].IsDirectory, false);
+    UNIT_ASSERT_VALUES_EQUAL(response.Items[0].Name, "TestTable2"); 
+    UNIT_ASSERT_VALUES_EQUAL(response.Items[0].IsDirectory, false); 
     UNIT_ASSERT_VALUES_EQUAL(response.Items[1].Name, "TestTable3");
-    UNIT_ASSERT_VALUES_EQUAL(response.Items[1].IsDirectory, false);
+    UNIT_ASSERT_VALUES_EQUAL(response.Items[1].IsDirectory, false); 
     UNIT_ASSERT_VALUES_EQUAL(response.Items[2].Name, "TestTableKsv");
     UNIT_ASSERT_VALUES_EQUAL(response.Items[2].IsDirectory, false);
     UNIT_ASSERT_VALUES_EQUAL(response.Items[3].Name, "UserDir");
     UNIT_ASSERT_VALUES_EQUAL(response.Items[3].IsDirectory, true);
     UNIT_ASSERT_VALUES_EQUAL(response.Items[4].Name, "UserTable");
     UNIT_ASSERT_VALUES_EQUAL(response.Items[4].IsDirectory, false);
-}
-
-void TestLoadTableMetadataCommon(TIntrusivePtr<IKikimrGateway> gateway) {
-    auto responseFuture = gateway->LoadTableMetadata(TestCluster, "/Root/Test/UserTable",
+} 
+ 
+void TestLoadTableMetadataCommon(TIntrusivePtr<IKikimrGateway> gateway) { 
+    auto responseFuture = gateway->LoadTableMetadata(TestCluster, "/Root/Test/UserTable", 
         IKikimrGateway::TLoadTableMetadataSettings());
-    responseFuture.Wait();
-    auto response = responseFuture.GetValue();
-    response.Issues().PrintTo(Cerr);
-    UNIT_ASSERT(response.Success());
-
-    auto& metadata = *response.Metadata;
-    UNIT_ASSERT_VALUES_EQUAL(metadata.Cluster, TestCluster);
-    UNIT_ASSERT_VALUES_EQUAL(metadata.Name, "/Root/Test/UserTable");
-    UNIT_ASSERT_VALUES_EQUAL(metadata.Columns.size(), 3);
+    responseFuture.Wait(); 
+    auto response = responseFuture.GetValue(); 
+    response.Issues().PrintTo(Cerr); 
+    UNIT_ASSERT(response.Success()); 
+ 
+    auto& metadata = *response.Metadata; 
+    UNIT_ASSERT_VALUES_EQUAL(metadata.Cluster, TestCluster); 
+    UNIT_ASSERT_VALUES_EQUAL(metadata.Name, "/Root/Test/UserTable"); 
+    UNIT_ASSERT_VALUES_EQUAL(metadata.Columns.size(), 3); 
     UNIT_ASSERT_VALUES_EQUAL(metadata.Columns["UserKey"].Type, "Utf8");
-    UNIT_ASSERT_VALUES_EQUAL(metadata.Columns["UserSubkey"].Type, "Uint32");
+    UNIT_ASSERT_VALUES_EQUAL(metadata.Columns["UserSubkey"].Type, "Uint32"); 
     UNIT_ASSERT_VALUES_EQUAL(metadata.Columns["UserValue"].Type, "Utf8");
-    UNIT_ASSERT_VALUES_EQUAL(metadata.KeyColumnNames.size(), 2);
-    UNIT_ASSERT_VALUES_EQUAL(metadata.KeyColumnNames[0], "UserKey");
-    UNIT_ASSERT_VALUES_EQUAL(metadata.KeyColumnNames[1], "UserSubkey");
-}
-
-void TestRunSimpleCommon(TIntrusivePtr<IKqpGateway> gateway) {
+    UNIT_ASSERT_VALUES_EQUAL(metadata.KeyColumnNames.size(), 2); 
+    UNIT_ASSERT_VALUES_EQUAL(metadata.KeyColumnNames[0], "UserKey"); 
+    UNIT_ASSERT_VALUES_EQUAL(metadata.KeyColumnNames[1], "UserSubkey"); 
+} 
+ 
+void TestRunSimpleCommon(TIntrusivePtr<IKqpGateway> gateway) { 
     const TString program(R"(
-        (
-            (let key '(
-                '('Group (Uint32 '1))
+        ( 
+            (let key '( 
+                '('Group (Uint32 '1)) 
                 '('Name (String 'Paul))
-            ))
-            (let row '(
-                'Group
-                'Name
-                'Amount
-            ))
+            )) 
+            (let row '( 
+                'Group 
+                'Name 
+                'Amount 
+            )) 
             (let table '(
-                '"/Root/Test/TestTable2"
+                '"/Root/Test/TestTable2" 
                 '"0"
                 '""
             ))
             (let data (SelectRow table key row))
-            (let r (SetResult 'Result data))
-            (let pgmReturn (AsList r))
-            (return pgmReturn)
-        )
-    )");
-
-    auto responseFuture = gateway->ExecuteMkql(TestCluster, program, TKqpParamsMap(),
+            (let r (SetResult 'Result data)) 
+            (let pgmReturn (AsList r)) 
+            (return pgmReturn) 
+        ) 
+    )"); 
+ 
+    auto responseFuture = gateway->ExecuteMkql(TestCluster, program, TKqpParamsMap(), 
         IKqpGateway::TMkqlSettings(), IKqpGateway::TKqpSnapshot::InvalidSnapshot);
-    responseFuture.Wait();
-    auto response = responseFuture.GetValue();
-    response.Issues().PrintTo(Cerr);
-    UNIT_ASSERT(response.Success());
-
-    auto result = ConvertResult(response.Result.GetValue(), response.Result.GetType());
-    const TOptional resOpt = result.GetMember<TOptional>("Result");
-    UNIT_ASSERT(resOpt.HasItem());
-    const TOptional rowOpt = resOpt.GetItem<TOptional>();
-    UNIT_ASSERT(rowOpt.HasItem());
-    TStruct row = rowOpt.GetItem<TStruct>();
-    UNIT_ASSERT_VALUES_EQUAL(row.GetMember<TOptional>("Group").GetItem<ui32>(), 1);
-    UNIT_ASSERT_VALUES_EQUAL(row.GetMember<TOptional>("Name").GetItem<TStringBuf>(), "Paul");
-    UNIT_ASSERT_VALUES_EQUAL(row.GetMember<TOptional>("Amount").GetItem<ui64>(), 300);
-}
-
-void CheckPolicies(Tests::TClient& client, const TString& tableName) {
+    responseFuture.Wait(); 
+    auto response = responseFuture.GetValue(); 
+    response.Issues().PrintTo(Cerr); 
+    UNIT_ASSERT(response.Success()); 
+ 
+    auto result = ConvertResult(response.Result.GetValue(), response.Result.GetType()); 
+    const TOptional resOpt = result.GetMember<TOptional>("Result"); 
+    UNIT_ASSERT(resOpt.HasItem()); 
+    const TOptional rowOpt = resOpt.GetItem<TOptional>(); 
+    UNIT_ASSERT(rowOpt.HasItem()); 
+    TStruct row = rowOpt.GetItem<TStruct>(); 
+    UNIT_ASSERT_VALUES_EQUAL(row.GetMember<TOptional>("Group").GetItem<ui32>(), 1); 
+    UNIT_ASSERT_VALUES_EQUAL(row.GetMember<TOptional>("Name").GetItem<TStringBuf>(), "Paul"); 
+    UNIT_ASSERT_VALUES_EQUAL(row.GetMember<TOptional>("Amount").GetItem<ui64>(), 300); 
+} 
+ 
+void CheckPolicies(Tests::TClient& client, const TString& tableName) { 
     auto describeResult = client.Ls(tableName);
     UNIT_ASSERT(describeResult->Record.GetPathDescription().HasTableStats());
     const auto& desc = describeResult->Record.GetPathDescription();
@@ -185,14 +185,14 @@ struct TTestIndexSettings {
     const bool WithDataColumns;
 };
 
-void TestCreateTableCommon(TIntrusivePtr<IKikimrGateway> gateway, Tests::TClient& client,
+void TestCreateTableCommon(TIntrusivePtr<IKikimrGateway> gateway, Tests::TClient& client, 
         bool createFolders = true, const TMaybe<TTestIndexSettings> withIndex = Nothing(), bool withExtendedDdl = false,
         const TMaybe<bool>& shouldCreate = Nothing()) {
-    auto metadata = MakeIntrusive<TKikimrTableMetadata>();
-
-    metadata->Cluster = TestCluster;
-    metadata->Name = "/Root/f1/f2/table";
-
+    auto metadata = MakeIntrusive<TKikimrTableMetadata>(); 
+ 
+    metadata->Cluster = TestCluster; 
+    metadata->Name = "/Root/f1/f2/table"; 
+ 
     UNIT_ASSERT(metadata->ColumnOrder.size() == metadata->Columns.size());
 
     metadata->Columns.insert(std::make_pair("Column1", TKikimrColumnMetadata{"Column1", 0, "Uint32", false}));
@@ -205,8 +205,8 @@ void TestCreateTableCommon(TIntrusivePtr<IKikimrGateway> gateway, Tests::TClient
         metadata->Columns["Column2"].Families.push_back("Family2");
     }
 
-    metadata->KeyColumnNames.push_back("Column1");
-
+    metadata->KeyColumnNames.push_back("Column1"); 
+ 
     if (withIndex) {
         TVector<TString> dataColumns;
         if (withIndex->WithDataColumns) {
@@ -240,21 +240,21 @@ void TestCreateTableCommon(TIntrusivePtr<IKikimrGateway> gateway, Tests::TClient
         };
     }
 
-    auto responseFuture = gateway->CreateTable(metadata, createFolders);
-    responseFuture.Wait();
-    auto response = responseFuture.GetValue();
-    response.Issues().PrintTo(Cerr);
+    auto responseFuture = gateway->CreateTable(metadata, createFolders); 
+    responseFuture.Wait(); 
+    auto response = responseFuture.GetValue(); 
+    response.Issues().PrintTo(Cerr); 
     if ((!shouldCreate && !createFolders) || (shouldCreate && !*shouldCreate)) {
-        UNIT_ASSERT(!response.Success());
-        UNIT_ASSERT(HasIssue(response.Issues(), TIssuesIds::KIKIMR_SCHEME_ERROR));
-    } else {
-        UNIT_ASSERT_C(response.Success(), response.Issues().ToString());
-
-        auto loadFuture = gateway->LoadTableMetadata(TestCluster, "/Root/f1/f2/table",
+        UNIT_ASSERT(!response.Success()); 
+        UNIT_ASSERT(HasIssue(response.Issues(), TIssuesIds::KIKIMR_SCHEME_ERROR)); 
+    } else { 
+        UNIT_ASSERT_C(response.Success(), response.Issues().ToString()); 
+ 
+        auto loadFuture = gateway->LoadTableMetadata(TestCluster, "/Root/f1/f2/table", 
             IKikimrGateway::TLoadTableMetadataSettings());
-        loadFuture.Wait();
-        auto loadResponse = loadFuture.GetValue();
-        UNIT_ASSERT(loadResponse.Success());
+        loadFuture.Wait(); 
+        auto loadResponse = loadFuture.GetValue(); 
+        UNIT_ASSERT(loadResponse.Success()); 
         UNIT_ASSERT_VALUES_EQUAL(metadata->Name, loadResponse.Metadata->Name);
         UNIT_ASSERT_VALUES_EQUAL(metadata->Indexes.size(), loadResponse.Metadata->Indexes.size());
 
@@ -284,99 +284,99 @@ void TestCreateTableCommon(TIntrusivePtr<IKikimrGateway> gateway, Tests::TClient
         }
 
         if (withExtendedDdl) {
-            CheckPolicies(client, metadata->Name);
+            CheckPolicies(client, metadata->Name); 
         }
-    }
-}
-
-void TestDropTableCommon(TIntrusivePtr<IKikimrGateway> gateway) {
-    auto responseFuture = gateway->DropTable(TestCluster, "/Root/Test/UserTable");
-    responseFuture.Wait();
-    auto response = responseFuture.GetValue();
-    response.Issues().PrintTo(Cerr);
-    UNIT_ASSERT(response.Success());
-
-    auto loadFuture = gateway->LoadTableMetadata(TestCluster, "/Root/Test/UserTable",
+    } 
+} 
+ 
+void TestDropTableCommon(TIntrusivePtr<IKikimrGateway> gateway) { 
+    auto responseFuture = gateway->DropTable(TestCluster, "/Root/Test/UserTable"); 
+    responseFuture.Wait(); 
+    auto response = responseFuture.GetValue(); 
+    response.Issues().PrintTo(Cerr); 
+    UNIT_ASSERT(response.Success()); 
+ 
+    auto loadFuture = gateway->LoadTableMetadata(TestCluster, "/Root/Test/UserTable", 
         IKikimrGateway::TLoadTableMetadataSettings());
-    loadFuture.Wait();
-    auto loadResponse = loadFuture.GetValue();
-    UNIT_ASSERT(loadResponse.Success());
-    UNIT_ASSERT(!loadResponse.Metadata->DoesExist);
-}
-
-} // namespace
-
-
+    loadFuture.Wait(); 
+    auto loadResponse = loadFuture.GetValue(); 
+    UNIT_ASSERT(loadResponse.Success()); 
+    UNIT_ASSERT(!loadResponse.Metadata->DoesExist); 
+} 
+ 
+} // namespace 
+ 
+ 
 Y_UNIT_TEST_SUITE(KikimrIcGateway) {
     Y_UNIT_TEST(TestListPath) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestListPathCommon(GetIcGateway(kikimr.GetTestServer()));
-    }
-
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestListPathCommon(GetIcGateway(kikimr.GetTestServer())); 
+    } 
+ 
     Y_UNIT_TEST(TestLoadTableMetadata) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestLoadTableMetadataCommon(GetIcGateway(kikimr.GetTestServer()));
-    }
-
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestLoadTableMetadataCommon(GetIcGateway(kikimr.GetTestServer())); 
+    } 
+ 
     Y_UNIT_TEST(TestRunSimple) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestRunSimpleCommon(GetIcGateway(kikimr.GetTestServer()));
-    }
-
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestRunSimpleCommon(GetIcGateway(kikimr.GetTestServer())); 
+    } 
+ 
     Y_UNIT_TEST(TestCreateTable) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient());
-    }
-
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient()); 
+    } 
+ 
     Y_UNIT_TEST(TestCreateTableWithIndex) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), true,
-            TTestIndexSettings{false});
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), true, 
+            TTestIndexSettings{false}); 
     }
 
     Y_UNIT_TEST(TestCreateTableWithCoverIndex) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), true,
-            TTestIndexSettings{true});
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), true, 
+            TTestIndexSettings{true}); 
     }
 
     Y_UNIT_TEST(TestCreateTableNoFolder) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), false, Nothing(),
-            false, true);
-    }
-
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), false, Nothing(), 
+            false, true); 
+    } 
+ 
     Y_UNIT_TEST(TestCreateSameTable) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient());
-    }
-
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient()); 
+    } 
+ 
     Y_UNIT_TEST(TestCreateSameTableWithIndex) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), true,
-            TTestIndexSettings{false});
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), true, 
+            TTestIndexSettings{false}); 
     }
 
     Y_UNIT_TEST(TestDropTable) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestDropTableCommon(GetIcGateway(kikimr.GetTestServer()));
-    }
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestDropTableCommon(GetIcGateway(kikimr.GetTestServer())); 
+    } 
 
     Y_UNIT_TEST(TestCreateTableWithExtendedDdl) {
-        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false));
-        CreateSampleTables(kikimr);
-        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), true, Nothing(), true);
+        TKikimrRunner kikimr(NKqp::TKikimrSettings().SetWithSampleTables(false)); 
+        CreateSampleTables(kikimr); 
+        TestCreateTableCommon(GetIcGateway(kikimr.GetTestServer()), kikimr.GetTestClient(), true, Nothing(), true); 
     }
-}
-
-} // namespace NYql
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_kql.cpp b/ydb/core/kqp/provider/yql_kikimr_kql.cpp
index 95f5915a57..8154c22d6a 100644
--- a/ydb/core/kqp/provider/yql_kikimr_kql.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_kql.cpp
@@ -1,14 +1,14 @@
-#include "yql_kikimr_provider_impl.h"
+#include "yql_kikimr_provider_impl.h" 
 #include "kqp_opt_helpers.h"
-
+ 
 #include <ydb/library/yql/core/yql_opt_utils.h>
-
-namespace NYql {
-namespace {
-
-using namespace NNodes;
+ 
+namespace NYql { 
+namespace { 
+ 
+using namespace NNodes; 
 using namespace NKikimr::NKqp;
-
+ 
 TCoNameValueTupleList CreateSecondaryIndexKeyTuples(TCoArgument itemArg, const TVector<TString>& keyColumnNames,
     const THashSet<TStringBuf>& inputColumns, const TKikimrTableDescription& table,
     const TExprBase& fetch, bool nullExtension, TExprContext& ctx)
@@ -234,57 +234,57 @@ TExprBase CreateUpdateRowWithSecondaryIndex(
         .Done();
 }
 
-TExprNode::TPtr KiUpsertTableToKql(const TKiWriteTable& node, TExprContext& ctx, const TKikimrTableDescription& table,
+TExprNode::TPtr KiUpsertTableToKql(const TKiWriteTable& node, TExprContext& ctx, const TKikimrTableDescription& table, 
     bool replace, bool skipErase, TExprNode::TPtr& effect)
-{
-    auto itemArg = Build<TCoArgument>(ctx, node.Pos())
-        .Name("item")
-        .Done();
-
-    auto inputColumnsSetting = GetSetting(node.Settings().Ref(), "input_columns");
-    YQL_ENSURE(inputColumnsSetting);
-
-    THashSet<TStringBuf> inputColumns;
-    for (const auto& atom : TCoNameValueTuple(inputColumnsSetting).Value().Cast<TCoAtomList>()) {
-        inputColumns.insert(atom.Value());
-    }
-
+{ 
+    auto itemArg = Build<TCoArgument>(ctx, node.Pos()) 
+        .Name("item") 
+        .Done(); 
+ 
+    auto inputColumnsSetting = GetSetting(node.Settings().Ref(), "input_columns"); 
+    YQL_ENSURE(inputColumnsSetting); 
+ 
+    THashSet<TStringBuf> inputColumns; 
+    for (const auto& atom : TCoNameValueTuple(inputColumnsSetting).Value().Cast<TCoAtomList>()) { 
+        inputColumns.insert(atom.Value()); 
+    } 
+ 
     const auto& secondaryIndexes = BuildSecondaryIndexVector(table, node.Pos(), ctx);
 
-    TVector<TCoNameValueTuple> valueTuples;
+    TVector<TCoNameValueTuple> valueTuples; 
 
     const auto versionedTable = BuildVersionedTable(*table.Metadata, node.Pos(), ctx);
     YQL_ENSURE(versionedTable.Path() == node.Table());
 
-    for (auto& pair : table.Metadata->Columns) {
-        const TString& name = pair.first;
-
-        if (table.GetKeyColumnIndex(name)) {
-            continue;
-        }
-
-        if (inputColumns.contains(name)) {
-            auto tuple = Build<TCoNameValueTuple>(ctx, node.Pos())
-                .Name().Build(name)
-                .Value<TCoMember>()
-                    .Struct(itemArg)
-                    .Name().Build(name)
-                    .Build()
-                .Done();
-            valueTuples.push_back(tuple);
-        } else if (replace) {
-            auto type = table.GetColumnType(name);
+    for (auto& pair : table.Metadata->Columns) { 
+        const TString& name = pair.first; 
+ 
+        if (table.GetKeyColumnIndex(name)) { 
+            continue; 
+        } 
+ 
+        if (inputColumns.contains(name)) { 
+            auto tuple = Build<TCoNameValueTuple>(ctx, node.Pos()) 
+                .Name().Build(name) 
+                .Value<TCoMember>() 
+                    .Struct(itemArg) 
+                    .Name().Build(name) 
+                    .Build() 
+                .Done(); 
+            valueTuples.push_back(tuple); 
+        } else if (replace) { 
+            auto type = table.GetColumnType(name); 
             YQL_ENSURE(type, "No such column: " << name);
-            auto tuple = Build<TCoNameValueTuple>(ctx, node.Pos())
-                .Name().Build(name)
-                .Value<TCoNothing>()
-                    .OptionalType(NCommon::BuildTypeExpr(node.Pos(), *type, ctx))
-                    .Build()
-                .Done();
-            valueTuples.push_back(tuple);
-        }
-    }
-
+            auto tuple = Build<TCoNameValueTuple>(ctx, node.Pos()) 
+                .Name().Build(name) 
+                .Value<TCoNothing>() 
+                    .OptionalType(NCommon::BuildTypeExpr(node.Pos(), *type, ctx)) 
+                    .Build() 
+                .Done(); 
+            valueTuples.push_back(tuple); 
+        } 
+    } 
+ 
     const auto& tablePk = ExtractNamedKeyTuples(itemArg, table, ctx);
 
     // Update for main table
@@ -294,9 +294,9 @@ TExprNode::TPtr KiUpsertTableToKql(const TKiWriteTable& node, TExprContext& ctx,
         .Key(tablePk)
         .Update<TCoNameValueTupleList>()
             .Add(valueTuples)
-            .Build()
-        .Done();
-
+            .Build() 
+        .Done(); 
+ 
     const auto& input = (skipErase || secondaryIndexes.empty()) ? node.Input() : RemoveDuplicateKeyFromInput(node.Input(), table, node.Pos(), ctx);
 
     effect = Build<TCoFlatMap>(ctx, node.Pos())
@@ -318,110 +318,110 @@ TExprNode::TPtr KiUpsertTableToKql(const TKiWriteTable& node, TExprContext& ctx,
                 .Build()
             .Done()
             .Ptr();
-
-    return Build<TCoWorld>(ctx, node.Pos())
-        .Done()
-        .Ptr();
-}
-
-TExprNode::TPtr KiInsertTableToKql(const TKiWriteTable& node, TExprContext& ctx, const TKikimrTableDescription& table,
+ 
+    return Build<TCoWorld>(ctx, node.Pos()) 
+        .Done() 
+        .Ptr(); 
+} 
+ 
+TExprNode::TPtr KiInsertTableToKql(const TKiWriteTable& node, TExprContext& ctx, const TKikimrTableDescription& table, 
     const TYdbOperation& op, TExprNode::TPtr& effect)
-{
-    auto fetchItemArg = Build<TCoArgument>(ctx, node.Pos())
-        .Name("fetchItem")
-        .Done();
-
+{ 
+    auto fetchItemArg = Build<TCoArgument>(ctx, node.Pos()) 
+        .Name("fetchItem") 
+        .Done(); 
+ 
     const auto versionedTable = BuildVersionedTable(*table.Metadata, node.Pos(), ctx);
     YQL_ENSURE(versionedTable.Path() == node.Table());
 
-    auto fetchLambda = Build<TCoLambda>(ctx, node.Pos())
-        .Args(fetchItemArg)
-        .Body<TKiSelectRow>()
-            .Cluster(node.DataSink().Cluster())
+    auto fetchLambda = Build<TCoLambda>(ctx, node.Pos()) 
+        .Args(fetchItemArg) 
+        .Body<TKiSelectRow>() 
+            .Cluster(node.DataSink().Cluster()) 
             .Table(versionedTable)
-            .Key(ExtractNamedKeyTuples(fetchItemArg, table, ctx))
-            .Select()
-                .Build()
-            .Build()
-        .Done();
-
-    auto getKeyListItemArg = Build<TCoArgument>(ctx, node.Pos())
-        .Name("getKeyListItem")
-        .Done();
-
-    auto keyList = Build<TCoMap>(ctx, node.Pos())
-        .Input(node.Input())
-        .Lambda()
-            .Args(getKeyListItemArg)
-            .Body(ExtractKeys(getKeyListItemArg, table, ctx))
-            .Build()
-        .Done();
-
-    auto duplicatesPredicate = Build<TCoCmpNotEqual>(ctx, node.Pos())
-        .Left<TCoLength>()
-            .List(keyList)
-            .Build()
-        .Right<TCoLength>()
-            .List<TCoToDict>()
-                .List(keyList)
-                .KeySelector()
-                    .Args({"item"})
-                    .Body("item")
-                    .Build()
-                .PayloadSelector()
-                    .Args({"item"})
-                    .Body<TCoVoid>().Build()
-                    .Build()
-                .Settings()
-                    .Add().Build("One")
-                    .Add().Build("Hashed")
-                    .Build()
-                .Build()
-            .Build()
-        .Done();
-
-    auto fetchPredicate = Build<TCoHasItems>(ctx, node.Pos())
-        .List<TCoFlatMap>()
-            .Input(node.Input())
-            .Lambda(fetchLambda)
-            .Build()
-        .Done();
-
-    auto predicate = Build<TCoOr>(ctx, node.Pos())
+            .Key(ExtractNamedKeyTuples(fetchItemArg, table, ctx)) 
+            .Select() 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    auto getKeyListItemArg = Build<TCoArgument>(ctx, node.Pos()) 
+        .Name("getKeyListItem") 
+        .Done(); 
+ 
+    auto keyList = Build<TCoMap>(ctx, node.Pos()) 
+        .Input(node.Input()) 
+        .Lambda() 
+            .Args(getKeyListItemArg) 
+            .Body(ExtractKeys(getKeyListItemArg, table, ctx)) 
+            .Build() 
+        .Done(); 
+ 
+    auto duplicatesPredicate = Build<TCoCmpNotEqual>(ctx, node.Pos()) 
+        .Left<TCoLength>() 
+            .List(keyList) 
+            .Build() 
+        .Right<TCoLength>() 
+            .List<TCoToDict>() 
+                .List(keyList) 
+                .KeySelector() 
+                    .Args({"item"}) 
+                    .Body("item") 
+                    .Build() 
+                .PayloadSelector() 
+                    .Args({"item"}) 
+                    .Body<TCoVoid>().Build() 
+                    .Build() 
+                .Settings() 
+                    .Add().Build("One") 
+                    .Add().Build("Hashed") 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    auto fetchPredicate = Build<TCoHasItems>(ctx, node.Pos()) 
+        .List<TCoFlatMap>() 
+            .Input(node.Input()) 
+            .Lambda(fetchLambda) 
+            .Build() 
+        .Done(); 
+ 
+    auto predicate = Build<TCoOr>(ctx, node.Pos()) 
         .Add({duplicatesPredicate, fetchPredicate})
-        .Done();
-
-    TExprNode::TPtr insertEffect;
+        .Done(); 
+ 
+    TExprNode::TPtr insertEffect; 
     auto insertKql = KiUpsertTableToKql(node, ctx, table, false, true, insertEffect);
-
+ 
     if (op == TYdbOperation::InsertAbort) {
-        effect = Build<TKiAbortIf>(ctx, node.Pos())
-            .Predicate(predicate)
-            .Effect(insertEffect)
-            .Constraint().Build("insert_pk")
-            .Done()
-            .Ptr();
+        effect = Build<TKiAbortIf>(ctx, node.Pos()) 
+            .Predicate(predicate) 
+            .Effect(insertEffect) 
+            .Constraint().Build("insert_pk") 
+            .Done() 
+            .Ptr(); 
     } else if (op == TYdbOperation::InsertRevert) {
-        effect = Build<TKiRevertIf>(ctx, node.Pos())
-            .Predicate(predicate)
-            .Effect(insertEffect)
-            .Constraint().Build("insert_pk")
-            .Done()
-            .Ptr();
-    } else {
-        YQL_ENSURE(false, "Unexpected table operation");
-    }
-
-    return insertKql;
-}
-
-TExprNode::TPtr KiDeleteOnTableToKql(const TKiWriteTable& node, TExprContext& ctx,
-    const TKikimrTableDescription& table, TExprNode::TPtr& effect)
-{
-    auto itemArg = Build<TCoArgument>(ctx, node.Pos())
-        .Name("item")
-        .Done();
-
+        effect = Build<TKiRevertIf>(ctx, node.Pos()) 
+            .Predicate(predicate) 
+            .Effect(insertEffect) 
+            .Constraint().Build("insert_pk") 
+            .Done() 
+            .Ptr(); 
+    } else { 
+        YQL_ENSURE(false, "Unexpected table operation"); 
+    } 
+ 
+    return insertKql; 
+} 
+ 
+TExprNode::TPtr KiDeleteOnTableToKql(const TKiWriteTable& node, TExprContext& ctx, 
+    const TKikimrTableDescription& table, TExprNode::TPtr& effect) 
+{ 
+    auto itemArg = Build<TCoArgument>(ctx, node.Pos()) 
+        .Name("item") 
+        .Done(); 
+ 
     TVector<TExprBase> updates;
 
     const auto& tablePk = ExtractNamedKeyTuples(itemArg, table, ctx);
@@ -444,14 +444,14 @@ TExprNode::TPtr KiDeleteOnTableToKql(const TKiWriteTable& node, TExprContext& ct
         const THashSet<TString> dummyDataColumns;
         const auto& columnsToSelect = NKikimr::NKqp::CreateColumnsToSelectToUpdateIndex(indexes, pk, dummyDataColumns, node.Pos(), ctx);
         const TExprBase& fetch = Build<TKiSelectRow>(ctx, node.Pos())
-            .Cluster(node.DataSink().Cluster())
+            .Cluster(node.DataSink().Cluster()) 
             .Table(versionedTable)
             .Key(tablePk)
             .template Select<TCoAtomList>()
                 .Add(columnsToSelect)
                 .Build()
             .Done();
-
+ 
         for (const auto& pair : indexes) {
 
             TVector<TExprBase> keyToErase;
@@ -500,38 +500,38 @@ TExprNode::TPtr KiDeleteOnTableToKql(const TKiWriteTable& node, TExprContext& ct
     }
 
     effect = Build<TCoFlatMap>(ctx, node.Pos())
-        .Input(node.Input())
+        .Input(node.Input()) 
             .Lambda<TCoLambda>()
                 .Args({itemArg})
                 .Body<TCoAsList>()
                     .Add(updates)
                 .Build()
             .Build()
-        .Done()
-        .Ptr();
-
-    return Build<TCoWorld>(ctx, node.Pos())
-        .Done()
-        .Ptr();
-}
-
+        .Done() 
+        .Ptr(); 
+ 
+    return Build<TCoWorld>(ctx, node.Pos()) 
+        .Done() 
+        .Ptr(); 
+} 
+ 
 TExprNode::TPtr KiReadTableToKql(TCoRight right, TExprContext& ctx, const TKikimrTablesData& tablesData, bool withSystemColumns) {
     const auto& read = right.Input().Cast<TKiReadTable>();
     bool unwrapValues = HasSetting(read.Settings().Ref(), "unwrap_values");
-
-    TKikimrKey key(ctx);
-    YQL_ENSURE(key.Extract(read.TableKey().Ref()));
-    YQL_ENSURE(key.GetKeyType() == TKikimrKey::Type::Table);
+ 
+    TKikimrKey key(ctx); 
+    YQL_ENSURE(key.Extract(read.TableKey().Ref())); 
+    YQL_ENSURE(key.GetKeyType() == TKikimrKey::Type::Table); 
     const auto& cluster = read.DataSource().Cluster();
     const auto& table = key.GetTablePath();
-
+ 
     const auto& tableDesc = tablesData.ExistingTable(TString(cluster), TString(table));
-
+ 
     const auto versionedTable = BuildVersionedTable(*tableDesc.Metadata, read.Pos(), ctx);
     YQL_ENSURE(versionedTable.Path().Value() == table);
 
     TMaybe<TString> secondaryIndex;
-
+ 
     if (const auto& view = key.GetView()) {
         YQL_ENSURE(tableDesc.Metadata);
         if (!ValidateTableHasIndex(tableDesc.Metadata, ctx, read.Pos())) {
@@ -550,7 +550,7 @@ TExprNode::TPtr KiReadTableToKql(TCoRight right, TExprContext& ctx, const TKikim
         }
         secondaryIndex = metadata->Name;
     }
-
+ 
     if (secondaryIndex) {
         const auto& indexTableName = secondaryIndex.GetRef();
         const auto& keyTableDesc = tablesData.ExistingTable(TString(cluster), TString(indexTableName));
@@ -590,42 +590,42 @@ TExprNode::TPtr KiReadTableToKql(TCoRight right, TExprContext& ctx, const TKikim
         } else {
             return TExprBase(selectRange).Ptr();
         }
-    }
-}
-
-TExprNode::TPtr KiUpdateOnTableToKql(const TKiWriteTable& node, TExprContext& ctx,
+    } 
+} 
+ 
+TExprNode::TPtr KiUpdateOnTableToKql(const TKiWriteTable& node, TExprContext& ctx, 
     const TKikimrTableDescription& tableDesc, TExprNode::TPtr& effect)
-{
-    // TODO: KIKIMR-3206
+{ 
+    // TODO: KIKIMR-3206 
     // This function should be rewriten
-
+ 
     const auto& cluster = node.DataSink().Cluster();
 
     const auto& itemArg = Build<TCoArgument>(ctx, node.Pos())
-        .Name("item")
-        .Done();
-
+        .Name("item") 
+        .Done(); 
+ 
     const auto& inputColumnsSetting = GetSetting(node.Settings().Ref(), "input_columns");
-    YQL_ENSURE(inputColumnsSetting);
-
-    TVector<TCoNameValueTuple> valueTuples;
+    YQL_ENSURE(inputColumnsSetting); 
+ 
+    TVector<TCoNameValueTuple> valueTuples; 
     THashSet<TStringBuf> updatedColumns;
-    for (const auto& atom : TCoNameValueTuple(inputColumnsSetting).Value().Cast<TCoAtomList>()) {
+    for (const auto& atom : TCoNameValueTuple(inputColumnsSetting).Value().Cast<TCoAtomList>()) { 
         if (tableDesc.GetKeyColumnIndex(TString(atom.Value()))) {
-            continue;
-        }
-
-        auto tuple = Build<TCoNameValueTuple>(ctx, node.Pos())
-            .Name(atom)
-            .Value<TCoMember>()
-                .Struct(itemArg)
-                .Name(atom)
-                .Build()
-            .Done();
-        valueTuples.push_back(tuple);
+            continue; 
+        } 
+ 
+        auto tuple = Build<TCoNameValueTuple>(ctx, node.Pos()) 
+            .Name(atom) 
+            .Value<TCoMember>() 
+                .Struct(itemArg) 
+                .Name(atom) 
+                .Build() 
+            .Done(); 
+        valueTuples.push_back(tuple); 
         updatedColumns.insert(atom.Value());
-    }
-
+    } 
+ 
     // Returns index only if at least one of indexed columns for coresponding index has been updated.
     const auto& indexes = BuildSecondaryIndexVector(tableDesc, node.Pos(), ctx, &updatedColumns);
     const TVector<TString>& pk = tableDesc.Metadata->KeyColumnNames;
@@ -650,9 +650,9 @@ TExprNode::TPtr KiUpdateOnTableToKql(const TKiWriteTable& node, TExprContext& ct
             .Cluster(cluster)
             .Table(versionedTable)
             .Key(ExtractNamedKeyTuples(itemArg, tableDesc, ctx))
-            .Update<TCoNameValueTupleList>()
-                .Add(valueTuples)
-                .Build()
+            .Update<TCoNameValueTupleList>() 
+                .Add(valueTuples) 
+                .Build() 
             .Done()
         );
 
@@ -766,55 +766,55 @@ TExprNode::TPtr KiUpdateOnTableToKql(const TKiWriteTable& node, TExprContext& ct
                         .Build()
                     .Build()
                 .Build()
-            .Build()
-        .Done();
-
+            .Build() 
+        .Done(); 
+ 
     effect = Build<TCoFlatMap>(ctx, node.Pos())
         .Input(node.Input())
         .Lambda(updateLambda)
-        .Done()
-        .Ptr();
-
-    return Build<TCoWorld>(ctx, node.Pos())
-        .Done()
-        .Ptr();
-}
-
-TExprNode::TPtr KiWriteTableToKql(TKiWriteTable write, TExprContext& ctx,
-    const TKikimrTablesData& tablesData, TExprNode::TPtr& effect)
-{
-    auto op = GetTableOp(write);
-
-    auto cluster = write.DataSink().Cluster().Value();
-    auto table = write.Table().Value();
-    auto& tableDesc = tablesData.ExistingTable(TString(cluster), TString(table));
-
-    switch (op) {
+        .Done() 
+        .Ptr(); 
+ 
+    return Build<TCoWorld>(ctx, node.Pos()) 
+        .Done() 
+        .Ptr(); 
+} 
+ 
+TExprNode::TPtr KiWriteTableToKql(TKiWriteTable write, TExprContext& ctx, 
+    const TKikimrTablesData& tablesData, TExprNode::TPtr& effect) 
+{ 
+    auto op = GetTableOp(write); 
+ 
+    auto cluster = write.DataSink().Cluster().Value(); 
+    auto table = write.Table().Value(); 
+    auto& tableDesc = tablesData.ExistingTable(TString(cluster), TString(table)); 
+ 
+    switch (op) { 
         case TYdbOperation::Upsert:
         case TYdbOperation::Replace:
             return KiUpsertTableToKql(write, ctx, tableDesc, op == TYdbOperation::Replace, false, effect);
         case TYdbOperation::InsertRevert:
         case TYdbOperation::InsertAbort:
-            return KiInsertTableToKql(write, ctx, tableDesc, op, effect);
+            return KiInsertTableToKql(write, ctx, tableDesc, op, effect); 
         case TYdbOperation::DeleteOn:
-            return KiDeleteOnTableToKql(write, ctx, tableDesc, effect);
+            return KiDeleteOnTableToKql(write, ctx, tableDesc, effect); 
         case TYdbOperation::UpdateOn:
-            return KiUpdateOnTableToKql(write, ctx, tableDesc, effect);
-        default:
-            return nullptr;
-    }
-}
-
-TExprNode::TPtr KiUpdateTableToKql(TKiUpdateTable update, TExprContext& ctx,
+            return KiUpdateOnTableToKql(write, ctx, tableDesc, effect); 
+        default: 
+            return nullptr; 
+    } 
+} 
+ 
+TExprNode::TPtr KiUpdateTableToKql(TKiUpdateTable update, TExprContext& ctx, 
     const TKikimrTablesData& tablesData, TExprNode::TPtr& effect, bool withSystemColumns)
-{
-    YQL_ENSURE(update.Update().Ref().GetTypeAnn());
-
+{ 
+    YQL_ENSURE(update.Update().Ref().GetTypeAnn()); 
+ 
     const auto& cluster = update.DataSink().Cluster();
     const auto& table = update.Table();
     const auto& tableDesc = tablesData.ExistingTable(TString(cluster.Value()), TString(table.Value()));
     const TVector<TString>& pk = tableDesc.Metadata->KeyColumnNames;
-
+ 
     const auto versionedTable = BuildVersionedTable(*tableDesc.Metadata, update.Pos(), ctx);
     YQL_ENSURE(versionedTable.Path() == update.Table());
 
@@ -824,54 +824,54 @@ TExprNode::TPtr KiUpdateTableToKql(TKiUpdateTable update, TExprContext& ctx,
     const auto& selectRange = Build<TKiSelectRange>(ctx, update.Pos())
         .Cluster(cluster)
         .Table(versionedTable)
-        .Range(range.ToRangeExpr(update, ctx))
+        .Range(range.ToRangeExpr(update, ctx)) 
         .Select(BuildColumnsList(tableDesc, update.Pos(), ctx, withSystemColumns))
-        .Settings().Build()
-        .Done();
-
+        .Settings().Build() 
+        .Done(); 
+ 
     const auto& filter = Build<TCoFilter>(ctx, update.Pos())
-        .Input(selectRange)
-        .Lambda(update.Filter())
-        .Done();
-
+        .Input(selectRange) 
+        .Lambda(update.Filter()) 
+        .Done(); 
+ 
     const auto& itemArg = Build<TCoArgument>(ctx, update.Pos())
-        .Name("item")
-        .Done();
-
-    TVector<TCoNameValueTuple> valueTuples;
+        .Name("item") 
+        .Done(); 
+ 
+    TVector<TCoNameValueTuple> valueTuples; 
     const auto& updateResultType = update.Update().Ref().GetTypeAnn()->Cast<TStructExprType>();
     THashSet<TStringBuf> updatedColumns;
 
     for (const auto& item : updateResultType->GetItems()) {
-        const auto& name = item->GetName();
+        const auto& name = item->GetName(); 
         updatedColumns.insert(name);
-
+ 
         const auto& tuple = Build<TCoNameValueTuple>(ctx, update.Pos())
-            .Name().Build(name)
-            .Value<TCoMember>()
-                .Struct<TExprApplier>()
-                    .Apply(update.Update())
-                    .With(0, itemArg)
-                    .Build()
-                .Name().Build(name)
-                .Build()
-            .Done();
-        valueTuples.push_back(tuple);
-    }
-
+            .Name().Build(name) 
+            .Value<TCoMember>() 
+                .Struct<TExprApplier>() 
+                    .Apply(update.Update()) 
+                    .With(0, itemArg) 
+                    .Build() 
+                .Name().Build(name) 
+                .Build() 
+            .Done(); 
+        valueTuples.push_back(tuple); 
+    } 
+ 
     const auto& indexes = BuildSecondaryIndexVector(tableDesc, update.Pos(), ctx, &updatedColumns);
 
     TVector<TExprBase> updates;
     updates.emplace_back(Build<TKiUpdateRow>(ctx, update.Pos())
             .Cluster(cluster)
             .Table(versionedTable)
-            .Key(ExtractNamedKeyTuples(itemArg, tableDesc, ctx))
-            .Update<TCoNameValueTupleList>()
-                .Add(valueTuples)
-                .Build()
+            .Key(ExtractNamedKeyTuples(itemArg, tableDesc, ctx)) 
+            .Update<TCoNameValueTupleList>() 
+                .Add(valueTuples) 
+                .Build() 
             .Done()
         );
-
+ 
     if (indexes) {
         for (const auto& pair : indexes) {
             TVector<TString> indexTablePk;
@@ -971,28 +971,28 @@ TExprNode::TPtr KiUpdateTableToKql(TKiUpdateTable update, TExprContext& ctx,
     }
 
     effect = Build<TCoFlatMap>(ctx, update.Pos())
-        .Input(filter)
+        .Input(filter) 
         .Lambda<TCoLambda>()
             .Args({itemArg})
             .Body<TCoAsList>()
                 .Add(updates)
                 .Build()
             .Build()
-        .Done()
-        .Ptr();
-
-    return Build<TCoWorld>(ctx, update.Pos())
-        .Done()
-        .Ptr();
-}
-
-TExprNode::TPtr KiDeleteTableToKql(TKiDeleteTable del, TExprContext& ctx,
+        .Done() 
+        .Ptr(); 
+ 
+    return Build<TCoWorld>(ctx, update.Pos()) 
+        .Done() 
+        .Ptr(); 
+} 
+ 
+TExprNode::TPtr KiDeleteTableToKql(TKiDeleteTable del, TExprContext& ctx, 
     const TKikimrTablesData& tablesData, TExprNode::TPtr& effect, bool withSystemColumns)
-{
+{ 
     const auto& cluster = del.DataSink().Cluster();
     const auto& table = del.Table();
     const auto& tableDesc = tablesData.ExistingTable(TString(cluster.Value()), TString(table.Value()));
-
+ 
     const auto versionedTable = BuildVersionedTable(*tableDesc.Metadata, del.Pos(), ctx);
     YQL_ENSURE(versionedTable.Path() == table);
 
@@ -1000,25 +1000,25 @@ TExprNode::TPtr KiDeleteTableToKql(TKiDeleteTable del, TExprContext& ctx,
     const auto& selectRange = Build<TKiSelectRange>(ctx, del.Pos())
         .Cluster(cluster)
         .Table(versionedTable)
-        .Range(range.ToRangeExpr(del, ctx))
+        .Range(range.ToRangeExpr(del, ctx)) 
         .Select(BuildColumnsList(tableDesc, del.Pos(), ctx, withSystemColumns))
-        .Settings().Build()
-        .Done();
-
+        .Settings().Build() 
+        .Done(); 
+ 
     const auto& filter = Build<TCoFilter>(ctx, del.Pos())
-        .Input(selectRange)
-        .Lambda(del.Filter())
-        .Done();
-
+        .Input(selectRange) 
+        .Lambda(del.Filter()) 
+        .Done(); 
+ 
     const auto& itemArg = Build<TCoArgument>(ctx, del.Pos())
-        .Name("item")
-        .Done();
-
+        .Name("item") 
+        .Done(); 
+ 
     const auto& indexes = BuildSecondaryIndexVector(tableDesc, del.Pos(), ctx);
-
+ 
     TVector<TExprBase> updates;
     updates.reserve(indexes.size() + 1);
-
+ 
     const auto& tablePk = ExtractNamedKeyTuples(itemArg, tableDesc, ctx);
     updates.emplace_back(Build<TKiEraseRow>(ctx, del.Pos())
             .Cluster(cluster)
@@ -1086,124 +1086,124 @@ TExprNode::TPtr KiDeleteTableToKql(TKiDeleteTable del, TExprContext& ctx,
             .Done()
             .Ptr();
 
-    return Build<TCoWorld>(ctx, del.Pos())
-        .Done()
-        .Ptr();
-}
-
-} // namespace
-
-TKiProgram BuildKiProgram(TKiDataQuery query, const TKikimrTablesData& tablesData,
+    return Build<TCoWorld>(ctx, del.Pos()) 
+        .Done() 
+        .Ptr(); 
+} 
+ 
+} // namespace 
+ 
+TKiProgram BuildKiProgram(TKiDataQuery query, const TKikimrTablesData& tablesData, 
     TExprContext& ctx, bool withSystemColumns)
-{
-    TExprNode::TPtr optResult;
-    TOptimizeExprSettings optSettings(nullptr);
-    optSettings.VisitChanges = true;
-    IGraphTransformer::TStatus status(IGraphTransformer::TStatus::Ok);
-    status = OptimizeExpr(query.Effects().Ptr(), optResult,
+{ 
+    TExprNode::TPtr optResult; 
+    TOptimizeExprSettings optSettings(nullptr); 
+    optSettings.VisitChanges = true; 
+    IGraphTransformer::TStatus status(IGraphTransformer::TStatus::Ok); 
+    status = OptimizeExpr(query.Effects().Ptr(), optResult, 
         [&tablesData, withSystemColumns](const TExprNode::TPtr& input, TExprContext& ctx) {
-            auto node = TExprBase(input);
-            auto ret = input;
-
-            if (auto maybeWrite = node.Maybe<TKiWriteTable>()) {
-                KiWriteTableToKql(maybeWrite.Cast(), ctx, tablesData, ret);
-            } else if (auto maybeUpdate = node.Maybe<TKiUpdateTable>()) {
+            auto node = TExprBase(input); 
+            auto ret = input; 
+ 
+            if (auto maybeWrite = node.Maybe<TKiWriteTable>()) { 
+                KiWriteTableToKql(maybeWrite.Cast(), ctx, tablesData, ret); 
+            } else if (auto maybeUpdate = node.Maybe<TKiUpdateTable>()) { 
                 KiUpdateTableToKql(maybeUpdate.Cast(), ctx, tablesData, ret, withSystemColumns);
-            } else if (auto maybeDelete = node.Maybe<TKiDeleteTable>()) {
+            } else if (auto maybeDelete = node.Maybe<TKiDeleteTable>()) { 
                 KiDeleteTableToKql(maybeDelete.Cast(), ctx, tablesData, ret, withSystemColumns);
-            }
-
-            return ret;
-        }, ctx, optSettings);
-
-    YQL_ENSURE(status == IGraphTransformer::TStatus::Ok);
-
-    YQL_ENSURE(TMaybeNode<TKiEffects>(optResult));
-    TVector<TExprBase> effectsList(TKiEffects(optResult).begin(), TKiEffects(optResult).end());
-
-    TMaybeNode<TExprBase> effects;
-    if (effectsList.empty()) {
-        effects = Build<TCoList>(ctx, query.Pos())
-            .ListType<TCoListType>()
-                .ItemType<TCoVoidType>()
-                    .Build()
-                .Build()
-            .Done();
-    } else {
-        effects = Build<TCoExtend>(ctx, query.Pos())
-            .Add(effectsList)
-            .Done();
-    }
-
-    TVector<TExprBase> results;
-    for (const auto& kiResult : query.Results()) {
-        results.push_back(kiResult.Value());
-    }
-
-    auto program = Build<TKiProgram>(ctx, query.Pos())
-        .Results()
-            .Add(results)
-            .Build()
-        .Effects(effects.Cast())
-        .Done();
-
-    TExprNode::TPtr newProgram;
-    status = OptimizeExpr(program.Ptr(), newProgram,
+            } 
+ 
+            return ret; 
+        }, ctx, optSettings); 
+ 
+    YQL_ENSURE(status == IGraphTransformer::TStatus::Ok); 
+ 
+    YQL_ENSURE(TMaybeNode<TKiEffects>(optResult)); 
+    TVector<TExprBase> effectsList(TKiEffects(optResult).begin(), TKiEffects(optResult).end()); 
+ 
+    TMaybeNode<TExprBase> effects; 
+    if (effectsList.empty()) { 
+        effects = Build<TCoList>(ctx, query.Pos()) 
+            .ListType<TCoListType>() 
+                .ItemType<TCoVoidType>() 
+                    .Build() 
+                .Build() 
+            .Done(); 
+    } else { 
+        effects = Build<TCoExtend>(ctx, query.Pos()) 
+            .Add(effectsList) 
+            .Done(); 
+    } 
+ 
+    TVector<TExprBase> results; 
+    for (const auto& kiResult : query.Results()) { 
+        results.push_back(kiResult.Value()); 
+    } 
+ 
+    auto program = Build<TKiProgram>(ctx, query.Pos()) 
+        .Results() 
+            .Add(results) 
+            .Build() 
+        .Effects(effects.Cast()) 
+        .Done(); 
+ 
+    TExprNode::TPtr newProgram; 
+    status = OptimizeExpr(program.Ptr(), newProgram, 
         [&tablesData, withSystemColumns](const TExprNode::TPtr& input, TExprContext& ctx) {
-            auto node = TExprBase(input);
-
-            if (node.Maybe<TCoRight>().Input().Maybe<TKiReadTable>()) {
+            auto node = TExprBase(input); 
+ 
+            if (node.Maybe<TCoRight>().Input().Maybe<TKiReadTable>()) { 
                 return KiReadTableToKql(node.Cast<TCoRight>(), ctx, tablesData, withSystemColumns);
-            }
-
-            return input;
-        }, ctx, optSettings);
-
-    YQL_ENSURE(status == IGraphTransformer::TStatus::Ok);
-    YQL_ENSURE(TMaybeNode<TKiProgram>(newProgram));
-
-    return TKiProgram(newProgram);
-}
-
-TExprBase UnwrapKiReadTableValues(TExprBase input, const TKikimrTableDescription& tableDesc,
+            } 
+ 
+            return input; 
+        }, ctx, optSettings); 
+ 
+    YQL_ENSURE(status == IGraphTransformer::TStatus::Ok); 
+    YQL_ENSURE(TMaybeNode<TKiProgram>(newProgram)); 
+ 
+    return TKiProgram(newProgram); 
+} 
+ 
+TExprBase UnwrapKiReadTableValues(TExprBase input, const TKikimrTableDescription& tableDesc, 
     const TCoAtomList columns, TExprContext& ctx)
-{
-    TCoArgument itemArg = Build<TCoArgument>(ctx, input.Pos())
-        .Name("item")
-        .Done();
-
-    TVector<TExprBase> structItems;
-    for (auto atom : columns) {
-        auto columnType = tableDesc.GetColumnType(TString(atom.Value()));
+{ 
+    TCoArgument itemArg = Build<TCoArgument>(ctx, input.Pos()) 
+        .Name("item") 
+        .Done(); 
+ 
+    TVector<TExprBase> structItems; 
+    for (auto atom : columns) { 
+        auto columnType = tableDesc.GetColumnType(TString(atom.Value())); 
         YQL_ENSURE(columnType);
-
-        auto item = Build<TCoNameValueTuple>(ctx, input.Pos())
-            .Name(atom)
-            .Value<TCoCoalesce>()
-                .Predicate<TCoMember>()
-                    .Struct(itemArg)
-                    .Name(atom)
-                    .Build()
-                .Value<TCoDefault>()
-                    .Type(ExpandType(atom.Pos(), *columnType->Cast<TOptionalExprType>()->GetItemType(), ctx))
-                    .Build()
-                .Build()
-            .Done();
-
-        structItems.push_back(item);
-    }
-
-    return Build<TCoMap>(ctx, input.Pos())
-        .Input(input)
-        .Lambda()
-            .Args({itemArg})
-            .Body<TCoAsStruct>()
-                .Add(structItems)
-                .Build()
-            .Build()
-        .Done();
-}
-
+ 
+        auto item = Build<TCoNameValueTuple>(ctx, input.Pos()) 
+            .Name(atom) 
+            .Value<TCoCoalesce>() 
+                .Predicate<TCoMember>() 
+                    .Struct(itemArg) 
+                    .Name(atom) 
+                    .Build() 
+                .Value<TCoDefault>() 
+                    .Type(ExpandType(atom.Pos(), *columnType->Cast<TOptionalExprType>()->GetItemType(), ctx)) 
+                    .Build() 
+                .Build() 
+            .Done(); 
+ 
+        structItems.push_back(item); 
+    } 
+ 
+    return Build<TCoMap>(ctx, input.Pos()) 
+        .Input(input) 
+        .Lambda() 
+            .Args({itemArg}) 
+            .Body<TCoAsStruct>() 
+                .Add(structItems) 
+                .Build() 
+            .Build() 
+        .Done(); 
+} 
+ 
 bool IsKeySelectorPkPrefix(NNodes::TCoLambda keySelector, const TKikimrTableDescription& tableDesc, TVector<TString>* columns) {
     auto checkKey = [keySelector, &tableDesc, columns] (const TExprBase& key, ui32 index) {
         if (!key.Maybe<TCoMember>()) {
@@ -1245,4 +1245,4 @@ bool IsKeySelectorPkPrefix(NNodes::TCoLambda keySelector, const TKikimrTableDesc
     return true;
 }
 
-} // namespace NYql
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_mkql.cpp b/ydb/core/kqp/provider/yql_kikimr_mkql.cpp
index 4cd98892e4..a4f2f7f015 100644
--- a/ydb/core/kqp/provider/yql_kikimr_mkql.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_mkql.cpp
@@ -1,16 +1,16 @@
-#include "yql_kikimr_provider_impl.h"
+#include "yql_kikimr_provider_impl.h" 
 #include <ydb/core/kqp/provider/mkql/yql_kikimr_mkql_expr_nodes.h>
-
+ 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 #include <ydb/library/yql/core/yql_expr_type_annotation.h>
 #include <ydb/library/yql/core/yql_join.h>
+ 
 
-
-namespace NYql {
-namespace {
-
-using namespace NNodes;
-
+namespace NYql { 
+namespace { 
+ 
+using namespace NNodes; 
+ 
 TExprNode::TPtr BuildMkqlVersionedTable(const TCoAtom& tableName, const TCoAtom& schemaVersion,
     const TCoAtom& pathId, TExprContext& ctx, TPositionHandle pos)
 {
@@ -22,18 +22,18 @@ TExprNode::TPtr BuildMkqlVersionedTable(const TCoAtom& tableName, const TCoAtom&
         .Ptr();
 }
 
-TExprNode::TPtr MkqlRewriteCallables(TCallable callable, TExprContext& ctx, const TMaybe<TString>& rtParamName) {
-    TMaybeNode<TCoParameter> readTarget;
-
-    if (rtParamName) {
-        readTarget = Build<TCoParameter>(ctx, callable.Pos())
-            .Name().Build(*rtParamName)
-            .Type<TCoDataType>()
-                .Type().Build("Uint32")
-                .Build()
-            .Done();
-    }
-
+TExprNode::TPtr MkqlRewriteCallables(TCallable callable, TExprContext& ctx, const TMaybe<TString>& rtParamName) { 
+    TMaybeNode<TCoParameter> readTarget; 
+
+    if (rtParamName) { 
+        readTarget = Build<TCoParameter>(ctx, callable.Pos()) 
+            .Name().Build(*rtParamName) 
+            .Type<TCoDataType>() 
+                .Type().Build("Uint32") 
+                .Build() 
+            .Done(); 
+    } 
+ 
     if (auto maybeSelectRow = callable.Maybe<TKiSelectRow>()) {
         auto selectRow  = maybeSelectRow.Cast();
         auto vt = selectRow.Table();
@@ -41,46 +41,46 @@ TExprNode::TPtr MkqlRewriteCallables(TCallable callable, TExprContext& ctx, cons
             BuildMkqlVersionedTable(vt.Path(), vt.SchemaVersion(), vt.PathId(), ctx, selectRow.Pos()),
             selectRow.Key().Ptr(),
             selectRow.Select().Ptr()
-        };
-
-        if (readTarget) {
-            children.push_back(readTarget.Cast().Ptr());
-        }
-
+        }; 
+ 
+        if (readTarget) { 
+            children.push_back(readTarget.Cast().Ptr()); 
+        } 
+ 
         return ctx.NewCallable(selectRow.Pos(), "SelectRow", std::move(children));
-    }
-
+    } 
+ 
     if (auto maybeSelectRange = callable.Maybe<TKiSelectRangeBase>()) {
         auto selectRange = maybeSelectRange.Cast();
         auto vt = selectRange.Table();
-
+ 
         TExprNode::TListType children = {
             BuildMkqlVersionedTable(vt.Path(), vt.SchemaVersion(), vt.PathId(), ctx, selectRange.Pos()),
-            selectRange.Range().Ptr(),
-            selectRange.Select().Ptr(),
-            selectRange.Settings().Ptr()
-        };
-
-        if (readTarget) {
-            children.push_back(readTarget.Cast().Ptr());
-        }
-
-        auto selectRangeMkql = ctx.NewCallable(selectRange.Pos(), "SelectRange", std::move(children));
-
-        if (selectRange.Maybe<TKiSelectRange>()) {
-            return ctx.Builder(selectRange.Pos())
-                .Callable("Member")
-                    .Add(0, selectRangeMkql)
-                    .Atom(1, "List")
-                    .Seal()
-                .Build();
-        } else {
+            selectRange.Range().Ptr(), 
+            selectRange.Select().Ptr(), 
+            selectRange.Settings().Ptr() 
+        }; 
+ 
+        if (readTarget) { 
+            children.push_back(readTarget.Cast().Ptr()); 
+        } 
+ 
+        auto selectRangeMkql = ctx.NewCallable(selectRange.Pos(), "SelectRange", std::move(children)); 
+ 
+        if (selectRange.Maybe<TKiSelectRange>()) { 
+            return ctx.Builder(selectRange.Pos()) 
+                .Callable("Member") 
+                    .Add(0, selectRangeMkql) 
+                    .Atom(1, "List") 
+                    .Seal() 
+                .Build(); 
+        } else { 
             ctx.AddError(TIssue(ctx.GetPosition(selectRange.Pos()), TStringBuilder() << "Got unsupported callable: "
                 << selectRange.CallableName()));
             return nullptr;
-        }
-    }
-
+        } 
+    } 
+ 
     if (auto maybeUpdateRow = callable.Maybe<TKiUpdateRow>()) {
         auto updateRow = maybeUpdateRow.Cast();
         auto vt = updateRow.Table();
@@ -90,8 +90,8 @@ TExprNode::TPtr MkqlRewriteCallables(TCallable callable, TExprContext& ctx, cons
             .Update(updateRow.Update())
             .Done()
             .Ptr();
-    }
-
+    } 
+ 
     if (auto maybeEraseRow = callable.Maybe<TKiEraseRow>()) {
         auto eraseRow = maybeEraseRow.Cast();
         auto vt = eraseRow.Table();
@@ -100,107 +100,107 @@ TExprNode::TPtr MkqlRewriteCallables(TCallable callable, TExprContext& ctx, cons
                 .Key(eraseRow.Key())
                 .Done()
                 .Ptr();
-    }
-
-    if (auto setResult = callable.Maybe<TKiSetResult>()) {
-        return ctx.Builder(setResult.Cast().Pos())
-            .Callable("SetResult")
+    } 
+ 
+    if (auto setResult = callable.Maybe<TKiSetResult>()) { 
+        return ctx.Builder(setResult.Cast().Pos()) 
+            .Callable("SetResult") 
                 .Add(0, setResult.Cast().Name().Ptr())
                 .Add(1, setResult.Cast().Data().Ptr())
-                .Seal()
-            .Build();
-    }
-
-    if (auto acquireLocks = callable.Maybe<TKiAcquireLocks>()) {
-        return ctx.Builder(acquireLocks.Cast().Pos())
-            .Callable("AcquireLocks")
+                .Seal() 
+            .Build(); 
+    } 
+ 
+    if (auto acquireLocks = callable.Maybe<TKiAcquireLocks>()) { 
+        return ctx.Builder(acquireLocks.Cast().Pos()) 
+            .Callable("AcquireLocks") 
                 .Add(0, acquireLocks.Cast().LockTxId().Ptr())
-                .Seal()
-            .Build();
-    }
-
-    if (auto map = callable.Maybe<TKiMapParameter>()) {
+                .Seal() 
+            .Build(); 
+    } 
+ 
+    if (auto map = callable.Maybe<TKiMapParameter>()) { 
         return Build<TMkqlMapParameter>(ctx, map.Cast().Pos())
                 .Input(map.Cast().Input())
                 .Lambda(map.Cast().Lambda())
             .Done()
             .Ptr();
-    }
-
-    if (auto map = callable.Maybe<TKiFlatMapParameter>()) {
-        return ctx.Builder(map.Cast().Pos())
-            .Callable("FlatMapParameter")
+    } 
+ 
+    if (auto map = callable.Maybe<TKiFlatMapParameter>()) { 
+        return ctx.Builder(map.Cast().Pos()) 
+            .Callable("FlatMapParameter") 
                 .Add(0, map.Cast().Input().Ptr())
                 .Add(1, map.Cast().Lambda().Ptr())
-                .Seal()
-            .Build();
-    }
-    if (auto maybePartialSort = callable.Maybe<TKiPartialSort>()) {
-        return ctx.Builder(maybePartialSort.Cast().Pos())
-            .Callable("PartialSort")
-                .Add(0, maybePartialSort.Cast().Input().Ptr())
-                .Add(1, maybePartialSort.Cast().SortDirections().Ptr())
-                .Add(2, maybePartialSort.Cast().KeySelectorLambda().Ptr())
-                .Seal()
-            .Build();
-    }
-    if (auto maybePartialTake = callable.Maybe<TKiPartialTake>()) {
-        return ctx.Builder(maybePartialTake.Cast().Pos())
-            .Callable("PartialTake")
-                .Add(0, maybePartialTake.Cast().Input().Ptr())
-                .Add(1, maybePartialTake.Cast().Count().Ptr())
-                .Seal()
-            .Build();
-    }
-
+                .Seal() 
+            .Build(); 
+    } 
+    if (auto maybePartialSort = callable.Maybe<TKiPartialSort>()) { 
+        return ctx.Builder(maybePartialSort.Cast().Pos()) 
+            .Callable("PartialSort") 
+                .Add(0, maybePartialSort.Cast().Input().Ptr()) 
+                .Add(1, maybePartialSort.Cast().SortDirections().Ptr()) 
+                .Add(2, maybePartialSort.Cast().KeySelectorLambda().Ptr()) 
+                .Seal() 
+            .Build(); 
+    } 
+    if (auto maybePartialTake = callable.Maybe<TKiPartialTake>()) { 
+        return ctx.Builder(maybePartialTake.Cast().Pos()) 
+            .Callable("PartialTake") 
+                .Add(0, maybePartialTake.Cast().Input().Ptr()) 
+                .Add(1, maybePartialTake.Cast().Count().Ptr()) 
+                .Seal() 
+            .Build(); 
+    } 
+ 
     return callable.Ptr();
-}
-
-} // namespace
-
-TMaybeNode<TExprBase> TranslateToMkql(TExprBase node, TExprContext& ctx, const TMaybe<TString>& rtParamName) {
-    auto maybeProgram = node.Maybe<TKiProgram>();
-    YQL_ENSURE(maybeProgram);
-
-    auto program = maybeProgram.Cast();
-    bool hasResult = !program.Results().Empty();
-
-    if (hasResult) {
+} 
+ 
+} // namespace 
+ 
+TMaybeNode<TExprBase> TranslateToMkql(TExprBase node, TExprContext& ctx, const TMaybe<TString>& rtParamName) { 
+    auto maybeProgram = node.Maybe<TKiProgram>(); 
+    YQL_ENSURE(maybeProgram); 
+ 
+    auto program = maybeProgram.Cast(); 
+    bool hasResult = !program.Results().Empty(); 
+ 
+    if (hasResult) { 
         node = Build<TCoAppend>(ctx, node.Pos())
-            .List(program.Effects())
-            .Item<TKiSetResult>()
-                .Name().Build("Result")
-                .Data(program.Results())
-                .Build()
-            .Done();
-    } else {
-        node = program.Effects();
-    }
-
+            .List(program.Effects()) 
+            .Item<TKiSetResult>() 
+                .Name().Build("Result") 
+                .Data(program.Results()) 
+                .Build() 
+            .Done(); 
+    } else { 
+        node = program.Effects(); 
+    } 
+ 
     auto current = node.Ptr();
-    TExprNode::TPtr output;
+    TExprNode::TPtr output; 
     TOptimizeExprSettings optSettings(nullptr);
-    optSettings.VisitChanges = true;
-    auto status = OptimizeExpr(current, output,
-        [rtParamName](const TExprNode::TPtr& input, TExprContext& ctx) {
-            auto ret = input;
-            auto node = TExprBase(input);
-
-            if (auto call = node.Maybe<TCallable>()) {
-                ret = MkqlRewriteCallables(call.Cast(), ctx, rtParamName);
-                if (ret != input) {
-                    return ret;
-                }
-            }
-
-            return ret;
-        }, ctx, optSettings);
-
-    if (status != IGraphTransformer::TStatus::Ok) {
+    optSettings.VisitChanges = true; 
+    auto status = OptimizeExpr(current, output, 
+        [rtParamName](const TExprNode::TPtr& input, TExprContext& ctx) { 
+            auto ret = input; 
+            auto node = TExprBase(input); 
+ 
+            if (auto call = node.Maybe<TCallable>()) { 
+                ret = MkqlRewriteCallables(call.Cast(), ctx, rtParamName); 
+                if (ret != input) { 
+                    return ret; 
+                } 
+            } 
+ 
+            return ret; 
+        }, ctx, optSettings); 
+ 
+    if (status != IGraphTransformer::TStatus::Ok) { 
         return TExprNode::TPtr();
-    }
-
-    return TExprBase(output);
-}
-
-} // namespace NYql
+    } 
+ 
+    return TExprBase(output); 
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_opt.cpp b/ydb/core/kqp/provider/yql_kikimr_opt.cpp
index cdbb6e600d..81dc87e736 100644
--- a/ydb/core/kqp/provider/yql_kikimr_opt.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_opt.cpp
@@ -1,74 +1,74 @@
-#include "yql_kikimr_provider_impl.h"
-
+#include "yql_kikimr_provider_impl.h" 
+ 
 #include <ydb/library/yql/utils/log/log.h>
 #include <ydb/library/yql/core/common_opt/yql_co.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/core/yql_opt_aggregate.h>
-
-namespace NYql {
-namespace {
-
-using namespace NNodes;
-using namespace NCommon;
-
+ 
+namespace NYql { 
+namespace { 
+ 
+using namespace NNodes; 
+using namespace NCommon; 
+ 
 bool CanPushPartialSort(const TKiPartialSort& node, const TKikimrTableDescription& tableDesc, TVector<TString>* columns) {
     return IsKeySelectorPkPrefix(node.KeySelectorLambda(), tableDesc, columns);
 }
 
-TExprNode::TPtr KiTrimReadTableWorld(TExprBase node) {
+TExprNode::TPtr KiTrimReadTableWorld(TExprBase node) { 
     if (auto maybeRead = node.Maybe<TCoLeft>().Input().Maybe<TKiReadTable>()) {
-        YQL_CLOG(INFO, ProviderKikimr) << "KiTrimReadTableWorld";
-        return maybeRead.Cast().World().Ptr();
-    }
-
-    return node.Ptr();
-}
-
-TExprNode::TPtr KiEmptyCommit(TExprBase node) {
+        YQL_CLOG(INFO, ProviderKikimr) << "KiTrimReadTableWorld"; 
+        return maybeRead.Cast().World().Ptr(); 
+    } 
+ 
+    return node.Ptr(); 
+} 
+ 
+TExprNode::TPtr KiEmptyCommit(TExprBase node) { 
     if (!node.Maybe<TCoCommit>().World().Maybe<TCoCommit>()) {
-        return node.Ptr();
-    }
-
+        return node.Ptr(); 
+    } 
+ 
     auto commit = node.Cast<TCoCommit>();
-    if (!commit.DataSink().Maybe<TKiDataSink>()) {
-        return node.Ptr();
-    }
-
+    if (!commit.DataSink().Maybe<TKiDataSink>()) { 
+        return node.Ptr(); 
+    } 
+ 
     auto innerCommit = commit.World().Cast<TCoCommit>();
-    if (!innerCommit.DataSink().Maybe<TKiDataSink>()) {
-        return node.Ptr();
-    }
-
-    return innerCommit.Ptr();
-}
-
+    if (!innerCommit.DataSink().Maybe<TKiDataSink>()) { 
+        return node.Ptr(); 
+    } 
+ 
+    return innerCommit.Ptr(); 
+} 
+ 
 TExprNode::TPtr KiEraseOverSelectRow(TExprBase node, TExprContext& ctx) {
     if (!node.Maybe<TCoFlatMap>().Input().Maybe<TKiSelectRow>()) {
         return node.Ptr();
-    }
-
+    } 
+ 
     auto map = node.Cast<TCoFlatMap>();
 
     if (auto maybeErase = map.Lambda().Body().Maybe<TCoJust>().Input().Maybe<TKiEraseRow>()) {
-        auto selectRow = map.Input().Cast<TKiSelectRow>();
-        auto eraseRow = maybeErase.Cast();
-
-        YQL_ENSURE(selectRow.Cluster().Raw() == eraseRow.Cluster().Raw());
-
-        if (selectRow.Table().Raw() == eraseRow.Table().Raw()) {
-            auto ret = Build<TCoJust>(ctx, node.Pos())
-                .Input<TKiEraseRow>()
-                    .Cluster(selectRow.Cluster())
-                    .Table(selectRow.Table())
-                    .Key(selectRow.Key())
-                    .Build()
-                .Done();
-
-            YQL_CLOG(INFO, ProviderKikimr) << "KiEraseOverSelectRow";
-            return ret.Ptr();
-        }
-    }
-
+        auto selectRow = map.Input().Cast<TKiSelectRow>(); 
+        auto eraseRow = maybeErase.Cast(); 
+ 
+        YQL_ENSURE(selectRow.Cluster().Raw() == eraseRow.Cluster().Raw()); 
+ 
+        if (selectRow.Table().Raw() == eraseRow.Table().Raw()) { 
+            auto ret = Build<TCoJust>(ctx, node.Pos()) 
+                .Input<TKiEraseRow>() 
+                    .Cluster(selectRow.Cluster()) 
+                    .Table(selectRow.Table()) 
+                    .Key(selectRow.Key()) 
+                    .Build() 
+                .Done(); 
+ 
+            YQL_CLOG(INFO, ProviderKikimr) << "KiEraseOverSelectRow"; 
+            return ret.Ptr(); 
+        } 
+    } 
+ 
     if (auto maybeAsList = map.Lambda().Body().Maybe<TCoAsList>()) {
         auto asList = maybeAsList.Cast();
         if (asList.ArgCount() != 1) {
@@ -98,63 +98,63 @@ TExprNode::TPtr KiEraseOverSelectRow(TExprBase node, TExprContext& ctx) {
     }
 
     return node.Ptr();
-}
-
-TExprNode::TPtr KiRewriteAggregate(TExprBase node, TExprContext& ctx) {
+} 
+ 
+TExprNode::TPtr KiRewriteAggregate(TExprBase node, TExprContext& ctx) { 
     if (!node.Maybe<TCoAggregate>()) {
-        return node.Ptr();
-    }
-
+        return node.Ptr(); 
+    } 
+ 
     auto agg = node.Cast<TCoAggregate>();
     if (!agg.Input().Maybe<TKiSelectRange>() && !agg.Input().Maybe<TCoFlatMap>().Input().Maybe<TKiSelectRange>()) {
-        return node.Ptr();
-    }
-
-    for (size_t i = 0; i < agg.Handlers().Size(); ++i) {
-        auto aggHandler = agg.Handlers().Item(i);
-
+        return node.Ptr(); 
+    } 
+ 
+    for (size_t i = 0; i < agg.Handlers().Size(); ++i) { 
+        auto aggHandler = agg.Handlers().Item(i); 
+ 
         // Need to get rid of Unwraps in AggregateToPartitionByKeyWithCombine for DISTINCT case
-        if (aggHandler.DistinctName().IsValid()) {
-            return node.Ptr();
-        }
-    }
-
-    YQL_CLOG(INFO, ProviderKikimr) << "KiRewriteAggregate";
+        if (aggHandler.DistinctName().IsValid()) { 
+            return node.Ptr(); 
+        } 
+    } 
+ 
+    YQL_CLOG(INFO, ProviderKikimr) << "KiRewriteAggregate"; 
     return ExpandAggregate(node.Ptr(), ctx);
-}
-
+} 
+ 
 TExprNode::TPtr KiRedundantSortByPk(TExprBase node, TExprContext& ctx,
     const TKikimrTablesData& tablesData, const TKikimrConfiguration& config)
 {
     auto maybeSort = node.Maybe<TCoSort>();
-    auto maybePartialSort = node.Maybe<TKiPartialSort>();
-
-    if (!maybeSort && !maybePartialSort) {
-        return node.Ptr();
-    }
-
-    auto input = maybeSort ? maybeSort.Cast().Input() : maybePartialSort.Cast().Input();
-    auto sortDirections = maybeSort ? maybeSort.Cast().SortDirections() : maybePartialSort.Cast().SortDirections();
-    auto keySelector = maybeSort ? maybeSort.Cast().KeySelectorLambda() : maybePartialSort.Cast().KeySelectorLambda();
-
-    auto read = input;
+    auto maybePartialSort = node.Maybe<TKiPartialSort>(); 
+ 
+    if (!maybeSort && !maybePartialSort) { 
+        return node.Ptr(); 
+    } 
+ 
+    auto input = maybeSort ? maybeSort.Cast().Input() : maybePartialSort.Cast().Input(); 
+    auto sortDirections = maybeSort ? maybeSort.Cast().SortDirections() : maybePartialSort.Cast().SortDirections(); 
+    auto keySelector = maybeSort ? maybeSort.Cast().KeySelectorLambda() : maybePartialSort.Cast().KeySelectorLambda(); 
+ 
+    auto read = input; 
     TMaybe<THashSet<TStringBuf>> passthroughFields;
     if (maybePartialSort && input.Maybe<TCoFlatMap>()) {
         auto flatmap = input.Cast<TCoFlatMap>();
-
-        if (!IsPassthroughFlatMap(flatmap, &passthroughFields)) {
-            return node.Ptr();
-        }
-
-        read = flatmap.Input();
-    }
-
+ 
+        if (!IsPassthroughFlatMap(flatmap, &passthroughFields)) { 
+            return node.Ptr(); 
+        } 
+ 
+        read = flatmap.Input(); 
+    } 
+ 
     if (!read.Maybe<TKiSelectRange>()) {
-        return node.Ptr();
-    }
-
+        return node.Ptr(); 
+    } 
+ 
     auto selectRange = read.Cast<TKiSelectRange>();
-
+ 
     if (HasSetting(selectRange.Settings().Ref(), "Reverse")) {
         // N.B. when SelectRange has a Reverse option we cannot optimize
         // sort without complex analysis of how it interacts with sorting
@@ -171,70 +171,70 @@ TExprNode::TPtr KiRedundantSortByPk(TExprBase node, TExprContext& ctx,
     auto getDirection = [] (TExprBase expr) -> ui32 {
         if (!expr.Maybe<TCoBool>()) {
             return SortDirectionUnknown;
-        }
-
+        } 
+ 
         if (!FromString<bool>(expr.Cast<TCoBool>().Literal().Value())) {
             return SortDirectionReverse;
-        }
-
+        } 
+ 
         return SortDirectionForward;
-    };
-
+    }; 
+ 
     ui32 direction = SortDirectionNone;
 
-    if (auto maybeList = sortDirections.Maybe<TExprList>()) {
-        for (const auto& expr : maybeList.Cast()) {
+    if (auto maybeList = sortDirections.Maybe<TExprList>()) { 
+        for (const auto& expr : maybeList.Cast()) { 
             direction |= getDirection(expr);
             if (direction != SortDirectionForward && direction != SortDirectionReverse) {
-                return node.Ptr();
-            }
-        }
+                return node.Ptr(); 
+            } 
+        } 
     } else {
         direction |= getDirection(sortDirections);
         if (direction != SortDirectionForward && direction != SortDirectionReverse) {
             return node.Ptr();
         }
-    }
-
+    } 
+ 
     auto& tableData = tablesData.ExistingTable(selectRange.Cluster().StringValue(), selectRange.Table().Path().StringValue());
 
-    auto checkKey = [keySelector, &tableData, &passthroughFields] (TExprBase key, ui32 index) {
+    auto checkKey = [keySelector, &tableData, &passthroughFields] (TExprBase key, ui32 index) { 
         if (!key.Maybe<TCoMember>()) {
-            return false;
-        }
-
+            return false; 
+        } 
+ 
         auto member = key.Cast<TCoMember>();
-        if (member.Struct().Raw() != keySelector.Args().Arg(0).Raw()) {
-            return false;
-        }
-
-        auto column = TString(member.Name().Value());
-        auto columnIndex = tableData.GetKeyColumnIndex(column);
-        if (!columnIndex || *columnIndex != index) {
-            return false;
-        }
-
+        if (member.Struct().Raw() != keySelector.Args().Arg(0).Raw()) { 
+            return false; 
+        } 
+ 
+        auto column = TString(member.Name().Value()); 
+        auto columnIndex = tableData.GetKeyColumnIndex(column); 
+        if (!columnIndex || *columnIndex != index) { 
+            return false; 
+        } 
+ 
         if (passthroughFields && !passthroughFields->contains(column)) {
-            return false;
-        }
-
-        return true;
-    };
-
-    auto lambdaBody = keySelector.Body();
-    if (auto maybeTuple = lambdaBody.Maybe<TExprList>()) {
-        auto tuple = maybeTuple.Cast();
-        for (size_t i = 0; i < tuple.Size(); ++i) {
-            if (!checkKey(tuple.Item(i), i)) {
-                return node.Ptr();
-            }
-        }
-    } else {
-        if (!checkKey(lambdaBody, 0)) {
-            return node.Ptr();
-        }
-    }
-
+            return false; 
+        } 
+ 
+        return true; 
+    }; 
+ 
+    auto lambdaBody = keySelector.Body(); 
+    if (auto maybeTuple = lambdaBody.Maybe<TExprList>()) { 
+        auto tuple = maybeTuple.Cast(); 
+        for (size_t i = 0; i < tuple.Size(); ++i) { 
+            if (!checkKey(tuple.Item(i), i)) { 
+                return node.Ptr(); 
+            } 
+        } 
+    } else { 
+        if (!checkKey(lambdaBody, 0)) { 
+            return node.Ptr(); 
+        } 
+    } 
+ 
     if (direction == SortDirectionReverse) {
         if (!config.AllowReverseRange()) {
             return node.Ptr();
@@ -275,218 +275,218 @@ TExprNode::TPtr KiRedundantSortByPk(TExprBase node, TExprContext& ctx,
         }
     }
 
-    YQL_CLOG(INFO, ProviderKikimr) << "KiRedundantSortByPk";
-    return input.Ptr();
-}
-
-TExprNode::TPtr KiTopSort(TExprBase node, TExprContext& ctx, const TOptimizeContext& optCtx,
-    const TKikimrConfiguration& config)
-{
-    if (config.HasOptDisableTopSort()) {
-        return node.Ptr();
-    }
-
-    if (!node.Maybe<TCoTake>()) {
-        return node.Ptr();
-    }
-
+    YQL_CLOG(INFO, ProviderKikimr) << "KiRedundantSortByPk"; 
+    return input.Ptr(); 
+} 
+ 
+TExprNode::TPtr KiTopSort(TExprBase node, TExprContext& ctx, const TOptimizeContext& optCtx, 
+    const TKikimrConfiguration& config) 
+{ 
+    if (config.HasOptDisableTopSort()) { 
+        return node.Ptr(); 
+    } 
+ 
+    if (!node.Maybe<TCoTake>()) { 
+        return node.Ptr(); 
+    } 
+ 
     auto take = node.Cast<TCoTake>();
-    TCoInputBase top = take;
+    TCoInputBase top = take; 
     if (!optCtx.IsSingleUsage(take.Input().Ref())) {
-        return node.Ptr();
-    }
-
-    if (!IsKqlPureExpr(take.Count())) {
-        return node.Ptr();
-    }
-
-    auto skip = take.Input().Maybe<TCoSkip>();
-    if (skip) {
+        return node.Ptr(); 
+    } 
+ 
+    if (!IsKqlPureExpr(take.Count())) { 
+        return node.Ptr(); 
+    } 
+ 
+    auto skip = take.Input().Maybe<TCoSkip>(); 
+    if (skip) { 
         if (!optCtx.IsSingleUsage(skip.Cast().Input().Ref())) {
-            return node.Ptr();
-        }
-
-        if (!IsKqlPureExpr(skip.Cast().Count())) {
-            return node.Ptr();
-        }
-
-        top = skip.Cast();
-    }
-
-    auto sort = top.Input().Maybe<TCoSort>();
-    if (sort) {
+            return node.Ptr(); 
+        } 
+ 
+        if (!IsKqlPureExpr(skip.Cast().Count())) { 
+            return node.Ptr(); 
+        } 
+ 
+        top = skip.Cast(); 
+    } 
+ 
+    auto sort = top.Input().Maybe<TCoSort>(); 
+    if (sort) { 
         if (!optCtx.IsSingleUsage(sort.Cast().Input().Ref())) {
-            return node.Ptr();
-        }
-
-        top = sort.Cast();
-    }
-
-    bool hasExtend = false;
-    TVector<TExprBase> inputs;
-    if (auto maybeExtend = top.Input().Maybe<TCoExtend>()) {
-        for (const auto& input : maybeExtend.Cast()) {
-            inputs.push_back(input);
-        }
-        hasExtend = true;
-    } else {
-        inputs.push_back(top.Input());
-    }
-
-    TExprBase takeCount = take.Count();
-    if (skip) {
-        takeCount = Build<TCoPlus>(ctx, node.Pos())
-            .Left(take.Count())
-            .Right(skip.Cast().Count())
-            .Done();
-    }
-
-    bool hasFlatMaps = false;
-    TVector<TExprBase> partialOutputs;
-    for (auto& input : inputs) {
-        auto read = input;
-        if (auto maybeFlatmap = input.Maybe<TCoFlatMap>()) {
-            auto flatmap = maybeFlatmap.Cast();
+            return node.Ptr(); 
+        } 
+ 
+        top = sort.Cast(); 
+    } 
+ 
+    bool hasExtend = false; 
+    TVector<TExprBase> inputs; 
+    if (auto maybeExtend = top.Input().Maybe<TCoExtend>()) { 
+        for (const auto& input : maybeExtend.Cast()) { 
+            inputs.push_back(input); 
+        } 
+        hasExtend = true; 
+    } else { 
+        inputs.push_back(top.Input()); 
+    } 
+ 
+    TExprBase takeCount = take.Count(); 
+    if (skip) { 
+        takeCount = Build<TCoPlus>(ctx, node.Pos()) 
+            .Left(take.Count()) 
+            .Right(skip.Cast().Count()) 
+            .Done(); 
+    } 
+ 
+    bool hasFlatMaps = false; 
+    TVector<TExprBase> partialOutputs; 
+    for (auto& input : inputs) { 
+        auto read = input; 
+        if (auto maybeFlatmap = input.Maybe<TCoFlatMap>()) { 
+            auto flatmap = maybeFlatmap.Cast(); 
             if (!optCtx.IsSingleUsage(flatmap.Input().Ref())) {
-                return node.Ptr();
-            }
-
-            if (!IsKqlPureLambda(flatmap.Lambda())) {
-                return node.Ptr();
-            }
-
-            hasFlatMaps = true;
-            read = flatmap.Input();
-        }
-
+                return node.Ptr(); 
+            } 
+ 
+            if (!IsKqlPureLambda(flatmap.Lambda())) { 
+                return node.Ptr(); 
+            } 
+ 
+            hasFlatMaps = true; 
+            read = flatmap.Input(); 
+        } 
+ 
         if (!read.Maybe<TKiSelectRangeBase>()) {
-            return node.Ptr();
-        }
-
-        auto takeInput = input;
-        if (sort) {
-            takeInput = Build<TKiPartialSort>(ctx, node.Pos())
-                .Input(input)
-                .SortDirections(sort.Cast().SortDirections())
-                .KeySelectorLambda(sort.Cast().KeySelectorLambda())
-                .Done();
-        }
-
-        auto output = Build<TKiPartialTake>(ctx, node.Pos())
-            .Input(takeInput)
-            .Count(takeCount)
-            .Done();
-
-        partialOutputs.push_back(output);
-    }
-
-    TExprBase merged = Build<TCoExtend>(ctx, node.Pos())
-        .Add(partialOutputs)
-        .Done();
-
-    if (sort) {
-        merged = Build<TCoSort>(ctx, node.Pos())
-            .Input(merged)
-            .SortDirections(sort.Cast().SortDirections())
-            .KeySelectorLambda(sort.Cast().KeySelectorLambda())
-            .Done();
-    } else {
-        auto canRewrite = hasExtend || hasFlatMaps;
-        if (!canRewrite || take.Count().Maybe<TCoUint64>()) {
-            return node.Ptr();
-        }
-    }
-
-    YQL_CLOG(INFO, ProviderKikimr) << "KiTopSort";
-
-    if (skip) {
-        return Build<TCoTake>(ctx, node.Pos())
-            .Input<TCoSkip>()
-                .Input(merged)
-                .Count(skip.Count().Cast())
-                .Build()
-            .Count(take.Count())
-            .Done()
-            .Ptr();
-    } else {
-        return Build<TCoTake>(ctx, node.Pos())
-            .Input(merged)
-            .Count(take.Count())
-            .Done()
-            .Ptr();
-    }
-}
-
-TMaybeNode<TCoNameValueTupleList> SimplifyKeyTuples(TCoNameValueTupleList keyTupleList, TExprContext& ctx) {
-    TVector<TCoNameValueTuple> newTuples(keyTupleList.begin(), keyTupleList.end());
-
-    bool hasChanges = false;
-    for (ui32 i = 0; i < keyTupleList.Size(); ++i) {
-        const auto& tuple = keyTupleList.Item(i);
-        YQL_ENSURE(tuple.Value().IsValid());
-        if (auto maybeJust = tuple.Value().Maybe<TCoJust>()) {
-            hasChanges = true;
-            newTuples[i] = Build<TCoNameValueTuple>(ctx, maybeJust.Cast().Pos())
-                .Name(tuple.Name())
-                .Value(maybeJust.Cast().Input())
-                .Done();
-        }
-    }
-
-    if (hasChanges) {
-        return Build<TCoNameValueTupleList>(ctx, keyTupleList.Pos())
-            .Add(newTuples)
-            .Done();
-    }
-
-    return TMaybeNode<TCoNameValueTupleList>();
-}
-
-TExprNode::TPtr KiSimplifyRowKey(TExprBase node, TExprContext& ctx) {
-    if (auto maybeSelectRow = node.Maybe<TKiSelectRow>()) {
-        auto selectRow = maybeSelectRow.Cast();
-
-        if (auto newKey = SimplifyKeyTuples(selectRow.Key(), ctx)) {
-            return Build<TKiSelectRow>(ctx, node.Pos())
-                .Cluster(selectRow.Cluster())
-                .Table(selectRow.Table())
-                .Key(newKey.Cast())
-                .Select(selectRow.Select())
-                .Done()
-                .Ptr();
-        }
-    }
-
-    if (auto maybeEraseRow = node.Maybe<TKiEraseRow>()) {
-        auto eraseRow = maybeEraseRow.Cast();
-
-        if (auto newKey = SimplifyKeyTuples(eraseRow.Key(), ctx)) {
-            return Build<TKiEraseRow>(ctx, node.Pos())
-                .Cluster(eraseRow.Cluster())
-                .Table(eraseRow.Table())
-                .Key(newKey.Cast())
-                .Done()
-                .Ptr();
-        }
-    }
-
-    if (auto maybeUpdateRow = node.Maybe<TKiUpdateRow>()) {
-        auto updateRow = maybeUpdateRow.Cast();
-
-        if (auto newKey = SimplifyKeyTuples(updateRow.Key(), ctx)) {
-            return Build<TKiUpdateRow>(ctx, node.Pos())
-                .Cluster(updateRow.Cluster())
-                .Table(updateRow.Table())
-                .Key(newKey.Cast())
-                .Update(updateRow.Update())
-                .Done()
-                .Ptr();
-        }
-    }
-
-    return node.Ptr();
-}
-
+            return node.Ptr(); 
+        } 
+ 
+        auto takeInput = input; 
+        if (sort) { 
+            takeInput = Build<TKiPartialSort>(ctx, node.Pos()) 
+                .Input(input) 
+                .SortDirections(sort.Cast().SortDirections()) 
+                .KeySelectorLambda(sort.Cast().KeySelectorLambda()) 
+                .Done(); 
+        } 
+ 
+        auto output = Build<TKiPartialTake>(ctx, node.Pos()) 
+            .Input(takeInput) 
+            .Count(takeCount) 
+            .Done(); 
+ 
+        partialOutputs.push_back(output); 
+    } 
+ 
+    TExprBase merged = Build<TCoExtend>(ctx, node.Pos()) 
+        .Add(partialOutputs) 
+        .Done(); 
+ 
+    if (sort) { 
+        merged = Build<TCoSort>(ctx, node.Pos()) 
+            .Input(merged) 
+            .SortDirections(sort.Cast().SortDirections()) 
+            .KeySelectorLambda(sort.Cast().KeySelectorLambda()) 
+            .Done(); 
+    } else { 
+        auto canRewrite = hasExtend || hasFlatMaps; 
+        if (!canRewrite || take.Count().Maybe<TCoUint64>()) { 
+            return node.Ptr(); 
+        } 
+    } 
+ 
+    YQL_CLOG(INFO, ProviderKikimr) << "KiTopSort"; 
+ 
+    if (skip) { 
+        return Build<TCoTake>(ctx, node.Pos()) 
+            .Input<TCoSkip>() 
+                .Input(merged) 
+                .Count(skip.Count().Cast()) 
+                .Build() 
+            .Count(take.Count()) 
+            .Done() 
+            .Ptr(); 
+    } else { 
+        return Build<TCoTake>(ctx, node.Pos()) 
+            .Input(merged) 
+            .Count(take.Count()) 
+            .Done() 
+            .Ptr(); 
+    } 
+} 
+ 
+TMaybeNode<TCoNameValueTupleList> SimplifyKeyTuples(TCoNameValueTupleList keyTupleList, TExprContext& ctx) { 
+    TVector<TCoNameValueTuple> newTuples(keyTupleList.begin(), keyTupleList.end()); 
+ 
+    bool hasChanges = false; 
+    for (ui32 i = 0; i < keyTupleList.Size(); ++i) { 
+        const auto& tuple = keyTupleList.Item(i); 
+        YQL_ENSURE(tuple.Value().IsValid()); 
+        if (auto maybeJust = tuple.Value().Maybe<TCoJust>()) { 
+            hasChanges = true; 
+            newTuples[i] = Build<TCoNameValueTuple>(ctx, maybeJust.Cast().Pos()) 
+                .Name(tuple.Name()) 
+                .Value(maybeJust.Cast().Input()) 
+                .Done(); 
+        } 
+    } 
+ 
+    if (hasChanges) { 
+        return Build<TCoNameValueTupleList>(ctx, keyTupleList.Pos()) 
+            .Add(newTuples) 
+            .Done(); 
+    } 
+ 
+    return TMaybeNode<TCoNameValueTupleList>(); 
+} 
+ 
+TExprNode::TPtr KiSimplifyRowKey(TExprBase node, TExprContext& ctx) { 
+    if (auto maybeSelectRow = node.Maybe<TKiSelectRow>()) { 
+        auto selectRow = maybeSelectRow.Cast(); 
+ 
+        if (auto newKey = SimplifyKeyTuples(selectRow.Key(), ctx)) { 
+            return Build<TKiSelectRow>(ctx, node.Pos()) 
+                .Cluster(selectRow.Cluster()) 
+                .Table(selectRow.Table()) 
+                .Key(newKey.Cast()) 
+                .Select(selectRow.Select()) 
+                .Done() 
+                .Ptr(); 
+        } 
+    } 
+ 
+    if (auto maybeEraseRow = node.Maybe<TKiEraseRow>()) { 
+        auto eraseRow = maybeEraseRow.Cast(); 
+ 
+        if (auto newKey = SimplifyKeyTuples(eraseRow.Key(), ctx)) { 
+            return Build<TKiEraseRow>(ctx, node.Pos()) 
+                .Cluster(eraseRow.Cluster()) 
+                .Table(eraseRow.Table()) 
+                .Key(newKey.Cast()) 
+                .Done() 
+                .Ptr(); 
+        } 
+    } 
+ 
+    if (auto maybeUpdateRow = node.Maybe<TKiUpdateRow>()) { 
+        auto updateRow = maybeUpdateRow.Cast(); 
+ 
+        if (auto newKey = SimplifyKeyTuples(updateRow.Key(), ctx)) { 
+            return Build<TKiUpdateRow>(ctx, node.Pos()) 
+                .Cluster(updateRow.Cluster()) 
+                .Table(updateRow.Table()) 
+                .Key(newKey.Cast()) 
+                .Update(updateRow.Update()) 
+                .Done() 
+                .Ptr(); 
+        } 
+    } 
+ 
+    return node.Ptr(); 
+} 
+ 
 TExprNode::TPtr DoRewriteSelectIndexRange(const TKiSelectIndexRange& selectIndexRange,
     const TKikimrTablesData& tablesData, TExprContext& ctx,
     const TVector<TString>& extraColumns, const std::function<TExprBase(const TExprBase&)>& middleFilter = {})
@@ -653,175 +653,175 @@ TExprNode::TPtr KiApplyExtractMembersToSelectRange(TExprBase node, TExprContext&
     }
 }
 
-} // namespace
-
-TAutoPtr<IGraphTransformer> CreateKiLogicalOptProposalTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx) {
-    return CreateFunctorTransformer([sessionCtx](const TExprNode::TPtr& input, TExprNode::TPtr& output,
-        TExprContext& ctx)
-    {
-        typedef IGraphTransformer::TStatus TStatus;
-
-        TParentsMap parentsMap;
-        TOptimizeContext optCtx;
-        GatherParents(*input, parentsMap);
-        optCtx.ParentsMap = &parentsMap;
-
-        TStatus status = OptimizeExpr(input, output, [sessionCtx, &optCtx](const TExprNode::TPtr& inputNode, TExprContext& ctx) {
+} // namespace 
+ 
+TAutoPtr<IGraphTransformer> CreateKiLogicalOptProposalTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx) { 
+    return CreateFunctorTransformer([sessionCtx](const TExprNode::TPtr& input, TExprNode::TPtr& output, 
+        TExprContext& ctx) 
+    { 
+        typedef IGraphTransformer::TStatus TStatus; 
+ 
+        TParentsMap parentsMap; 
+        TOptimizeContext optCtx; 
+        GatherParents(*input, parentsMap); 
+        optCtx.ParentsMap = &parentsMap; 
+ 
+        TStatus status = OptimizeExpr(input, output, [sessionCtx, &optCtx](const TExprNode::TPtr& inputNode, TExprContext& ctx) { 
             auto ret = inputNode;
             TExprBase node(inputNode);
-
+ 
             ret = KiSqlInToEquiJoin(node, sessionCtx->Tables(), sessionCtx->Config(), ctx);
             if (ret != inputNode) {
                 return ret;
             }
 
-            ret = KiApplyExtractMembersToSelectRange(node, ctx);
-            if (ret != inputNode) {
-                return ret;
-            }
-
-            ret = KiApplyExtractMembersToSelectRow(node, ctx);
-            if (ret != inputNode) {
-                return ret;
-            }
-
+            ret = KiApplyExtractMembersToSelectRange(node, ctx); 
+            if (ret != inputNode) { 
+                return ret; 
+            } 
+ 
+            ret = KiApplyExtractMembersToSelectRow(node, ctx); 
+            if (ret != inputNode) { 
+                return ret; 
+            } 
+ 
             ret = KiRedundantSortByPk(node, ctx, sessionCtx->Tables(), sessionCtx->Config());
+            if (ret != inputNode) { 
+                return ret; 
+            } 
+ 
+            ret = KiApplyLimitToSelectRange(node, ctx); 
             if (ret != inputNode) {
-                return ret;
-            }
-
-            ret = KiApplyLimitToSelectRange(node, ctx);
+                return ret; 
+            } 
+ 
+            ret = KiPushPredicateToSelectRange(node, ctx, sessionCtx->Tables(), sessionCtx->Config()); 
             if (ret != inputNode) {
-                return ret;
-            }
-
-            ret = KiPushPredicateToSelectRange(node, ctx, sessionCtx->Tables(), sessionCtx->Config());
+                return ret; 
+            } 
+ 
+            ret = KiEraseOverSelectRow(node, ctx); 
             if (ret != inputNode) {
-                return ret;
-            }
-
-            ret = KiEraseOverSelectRow(node, ctx);
-            if (ret != inputNode) {
-                return ret;
-            }
-
-            ret = KiRewriteEquiJoin(node, sessionCtx->Tables(), sessionCtx->Config(), ctx);
-            if (ret != inputNode) {
-                return ret;
-            }
-
-            ret = KiRewriteAggregate(node, ctx);
-            if (ret != inputNode) {
-                return ret;
-            }
-
-            ret = KiTopSort(node, ctx, optCtx, sessionCtx->Config());
-            if (ret != inputNode) {
-                return ret;
-            }
-
-            ret = KiSimplifyRowKey(node, ctx);
-            if (ret != inputNode) {
-                return ret;
-            }
-
+                return ret; 
+            } 
+ 
+            ret = KiRewriteEquiJoin(node, sessionCtx->Tables(), sessionCtx->Config(), ctx); 
+            if (ret != inputNode) { 
+                return ret; 
+            } 
+ 
+            ret = KiRewriteAggregate(node, ctx); 
+            if (ret != inputNode) { 
+                return ret; 
+            } 
+ 
+            ret = KiTopSort(node, ctx, optCtx, sessionCtx->Config()); 
+            if (ret != inputNode) { 
+                return ret; 
+            } 
+ 
+            ret = KiSimplifyRowKey(node, ctx); 
+            if (ret != inputNode) { 
+                return ret; 
+            } 
+ 
             ret = KiRewritePartialTakeSortOverSelectIndexRange(node, sessionCtx->Tables(), ctx);
             if (ret != inputNode) {
                 return ret;
             }
 
-            return ret;
+            return ret; 
         }, ctx, TOptimizeExprSettings(nullptr));
-
-        return status;
-    });
-}
-
-TAutoPtr<IGraphTransformer> CreateKiPhysicalOptProposalTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx) {
-    return CreateFunctorTransformer([sessionCtx](const TExprNode::TPtr& input, TExprNode::TPtr& output,
-        TExprContext& ctx)
-    {
-        typedef IGraphTransformer::TStatus TStatus;
-
-        TStatus status = OptimizeExpr(input, output, [sessionCtx](const TExprNode::TPtr& inputNode, TExprContext& ctx) {
-            auto ret = inputNode;
-            TExprBase node(inputNode);
-
-            ret = KiEmptyCommit(node);
-            if (ret != inputNode) {
-                return ret;
-            }
-
-            if (auto maybeDatasink = node.Maybe<TCoCommit>().DataSink().Maybe<TKiDataSink>()) {
-                auto cluster = TString(maybeDatasink.Cast().Cluster());
-                auto useNewEngine = sessionCtx->Config().UseNewEngine.Get();
+ 
+        return status; 
+    }); 
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKiPhysicalOptProposalTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx) { 
+    return CreateFunctorTransformer([sessionCtx](const TExprNode::TPtr& input, TExprNode::TPtr& output, 
+        TExprContext& ctx) 
+    { 
+        typedef IGraphTransformer::TStatus TStatus; 
+ 
+        TStatus status = OptimizeExpr(input, output, [sessionCtx](const TExprNode::TPtr& inputNode, TExprContext& ctx) { 
+            auto ret = inputNode; 
+            TExprBase node(inputNode); 
+ 
+            ret = KiEmptyCommit(node); 
+            if (ret != inputNode) { 
+                return ret; 
+            } 
+ 
+            if (auto maybeDatasink = node.Maybe<TCoCommit>().DataSink().Maybe<TKiDataSink>()) { 
+                auto cluster = TString(maybeDatasink.Cast().Cluster()); 
+                auto useNewEngine = sessionCtx->Config().UseNewEngine.Get(); 
                 if (!useNewEngine.Defined() && sessionCtx->Config().HasKqpForceNewEngine()) {
                     useNewEngine = true;
                 }
-
+ 
                 ret = KiBuildQuery(node, useNewEngine, ctx);
-
-                if (ret != inputNode) {
-                    return ret;
-                }
-            }
-
-            if (sessionCtx->Config().HasDefaultCluster()) {
-                auto defaultCluster = sessionCtx->Config()._DefaultCluster.Get().GetRef();
+ 
+                if (ret != inputNode) { 
+                    return ret; 
+                } 
+            } 
+ 
+            if (sessionCtx->Config().HasDefaultCluster()) { 
+                auto defaultCluster = sessionCtx->Config()._DefaultCluster.Get().GetRef(); 
                 ret = KiBuildResult(node, defaultCluster, ctx);
-                if (ret != inputNode) {
-                    return ret;
-                }
-            }
-
-            return ret;
+                if (ret != inputNode) { 
+                    return ret; 
+                } 
+            } 
+ 
+            return ret; 
         }, ctx, TOptimizeExprSettings(nullptr));
-
-        if (status.Level != IGraphTransformer::TStatus::Ok) {
-            return status;
-        }
-
+ 
+        if (status.Level != IGraphTransformer::TStatus::Ok) { 
+            return status; 
+        } 
+ 
         status = OptimizeExpr(input, output, [sessionCtx](const TExprNode::TPtr& inputNode, TExprContext& ctx) {
-            Y_UNUSED(ctx);
-
-            auto ret = inputNode;
-            TExprBase node(inputNode);
-
-            ret = KiTrimReadTableWorld(node);
-            if (ret != inputNode) {
-                return ret;
-            }
-
+            Y_UNUSED(ctx); 
+ 
+            auto ret = inputNode; 
+            TExprBase node(inputNode); 
+ 
+            ret = KiTrimReadTableWorld(node); 
+            if (ret != inputNode) { 
+                return ret; 
+            } 
+ 
             ret = KiRewriteSelectIndexRange(node, sessionCtx->Tables(), ctx);
             if (ret != inputNode) {
                 return ret;
             }
 
-            return ret;
+            return ret; 
         }, ctx, TOptimizeExprSettings(nullptr));
-
-        return status;
-    });
-}
-
-bool IsKqlPureExpr(NNodes::TExprBase expr) {
-    auto node = FindNode(expr.Ptr(), [] (const TExprNode::TPtr& node) {
-        if (!node->IsCallable()) {
-            return false;
-        }
-
+ 
+        return status; 
+    }); 
+} 
+ 
+bool IsKqlPureExpr(NNodes::TExprBase expr) { 
+    auto node = FindNode(expr.Ptr(), [] (const TExprNode::TPtr& node) { 
+        if (!node->IsCallable()) { 
+            return false; 
+        } 
+ 
         if (!KikimrKqlFunctions().contains(node->Content())) {
-            return false;
-        }
-
-        return true;
-    });
-
-    return !node;
-}
-
-bool IsKqlPureLambda(TCoLambda lambda) {
-    return IsKqlPureExpr(lambda.Body());
-}
-
-} // namespace NYql
+            return false; 
+        } 
+ 
+        return true; 
+    }); 
+ 
+    return !node; 
+} 
+ 
+bool IsKqlPureLambda(TCoLambda lambda) { 
+    return IsKqlPureExpr(lambda.Body()); 
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_opt_build.cpp b/ydb/core/kqp/provider/yql_kikimr_opt_build.cpp
index 0ba0b34952..46809112c2 100644
--- a/ydb/core/kqp/provider/yql_kikimr_opt_build.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_opt_build.cpp
@@ -1,25 +1,25 @@
-#include "yql_kikimr_provider_impl.h"
-
+#include "yql_kikimr_provider_impl.h" 
+ 
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/utils/log/log.h>
 #include <ydb/library/yql/providers/result/expr_nodes/yql_res_expr_nodes.h>
-
-namespace NYql {
-namespace {
-
-using namespace NNodes;
-using namespace NCommon;
-
+ 
+namespace NYql { 
+namespace { 
+ 
+using namespace NNodes; 
+using namespace NCommon; 
+ 
 TKiOperation BuildTableOpNode(const TCoAtom& cluster, const TStringBuf& table, TYdbOperation op, TPositionHandle pos,
-    TExprContext& ctx)
-{
+    TExprContext& ctx) 
+{ 
     return Build<TKiOperation>(ctx, pos)
         .Cluster().Build(cluster)
         .Table().Build(table)
         .Operation<TCoAtom>().Build(ToString(op))
-        .Done();
-}
-
+        .Done(); 
+} 
+ 
 TKiOperation BuildYdbOpNode(const TCoAtom& cluster, TYdbOperation op, TPositionHandle pos, TExprContext& ctx) {
     return Build<TKiOperation>(ctx, pos)
         .Cluster().Build(cluster)
@@ -28,194 +28,194 @@ TKiOperation BuildYdbOpNode(const TCoAtom& cluster, TYdbOperation op, TPositionH
         .Done();
 }
 
-TCoAtomList GetResultColumns(const TResWriteBase& resWrite, TExprContext& ctx) {
-    TExprNode::TListType columns;
-    auto columnsSetting = GetSetting(resWrite.Settings().Ref(), "columns");
-    if (columnsSetting) {
-        YQL_ENSURE(TMaybeNode<TCoNameValueTuple>(columnsSetting));
-        TCoNameValueTuple tuple(columnsSetting);
-        YQL_ENSURE(tuple.Value().Maybe<TCoAtomList>());
-        auto list = tuple.Value().Cast<TCoAtomList>();
-        for (const auto& column : list) {
-            columns.push_back(column.Ptr());
-        }
-    }
-
-    return Build<TCoAtomList>(ctx, resWrite.Pos())
-        .Add(columns)
-        .Done();
-}
-
-ui64 GetResultRowsLimit(const TResWriteBase& resWrite) {
-    auto takeSetting = GetSetting(resWrite.Settings().Ref(), "take");
-    if (takeSetting) {
-        YQL_ENSURE(TMaybeNode<TCoNameValueTuple>(takeSetting));
-        TCoNameValueTuple tuple(takeSetting);
-        YQL_ENSURE(tuple.Value().Maybe<TCoAtom>());
-
-        ui64 rowsLimit;
-        if (TryFromString<ui64>(tuple.Value().Cast<TCoAtom>().Value(), rowsLimit)) {
-            return rowsLimit;
-        }
-    }
-
-    return 0;
-}
-
-struct TKiExploreTxResults {
-    THashSet<const TExprNode*> Ops;
-    TVector<TExprBase> Sync;
-    TVector<TExprBase> Results;
-    TVector<TExprBase> Effects;
+TCoAtomList GetResultColumns(const TResWriteBase& resWrite, TExprContext& ctx) { 
+    TExprNode::TListType columns; 
+    auto columnsSetting = GetSetting(resWrite.Settings().Ref(), "columns"); 
+    if (columnsSetting) { 
+        YQL_ENSURE(TMaybeNode<TCoNameValueTuple>(columnsSetting)); 
+        TCoNameValueTuple tuple(columnsSetting); 
+        YQL_ENSURE(tuple.Value().Maybe<TCoAtomList>()); 
+        auto list = tuple.Value().Cast<TCoAtomList>(); 
+        for (const auto& column : list) { 
+            columns.push_back(column.Ptr()); 
+        } 
+    } 
+ 
+    return Build<TCoAtomList>(ctx, resWrite.Pos()) 
+        .Add(columns) 
+        .Done(); 
+} 
+ 
+ui64 GetResultRowsLimit(const TResWriteBase& resWrite) { 
+    auto takeSetting = GetSetting(resWrite.Settings().Ref(), "take"); 
+    if (takeSetting) { 
+        YQL_ENSURE(TMaybeNode<TCoNameValueTuple>(takeSetting)); 
+        TCoNameValueTuple tuple(takeSetting); 
+        YQL_ENSURE(tuple.Value().Maybe<TCoAtom>()); 
+ 
+        ui64 rowsLimit; 
+        if (TryFromString<ui64>(tuple.Value().Cast<TCoAtom>().Value(), rowsLimit)) { 
+            return rowsLimit; 
+        } 
+    } 
+ 
+    return 0; 
+} 
+ 
+struct TKiExploreTxResults { 
+    THashSet<const TExprNode*> Ops; 
+    TVector<TExprBase> Sync; 
+    TVector<TExprBase> Results; 
+    TVector<TExprBase> Effects; 
     TVector<TKiOperation> TableOperations;
-    bool HasExecute;
-
-    THashSet<const TExprNode*> GetSyncSet() const {
-        THashSet<const TExprNode*> syncSet;
-        for (auto node : Sync) {
-            syncSet.insert(node.Raw());
-        }
-
-        return syncSet;
-    }
-
-    void GetTableOperations(bool& hasScheme, bool& hasData) {
-        hasScheme = false;
-        hasData = false;
-        for (auto& node : TableOperations) {
+    bool HasExecute; 
+ 
+    THashSet<const TExprNode*> GetSyncSet() const { 
+        THashSet<const TExprNode*> syncSet; 
+        for (auto node : Sync) { 
+            syncSet.insert(node.Raw()); 
+        } 
+ 
+        return syncSet; 
+    } 
+ 
+    void GetTableOperations(bool& hasScheme, bool& hasData) { 
+        hasScheme = false; 
+        hasData = false; 
+        for (auto& node : TableOperations) { 
             auto op = FromString<TYdbOperation>(TString(node.Operation()));
-            hasScheme = hasScheme || (op & KikimrSchemeOps());
-            hasData = hasData || (op & KikimrDataOps());
-        }
-    }
-
-    TKiExploreTxResults()
-        : HasExecute(false) {}
-};
-
-bool ExploreTx(TExprBase node, TExprContext& ctx, const TKiDataSink& dataSink, TKiExploreTxResults& txRes) {
-    if (txRes.Ops.cend() != txRes.Ops.find(node.Raw())) {
-        return true;
-    }
-
-    if (node.Maybe<TCoWorld>()) {
-        txRes.Ops.insert(node.Raw());
-        return true;
-    }
-
-    if (auto maybeLeft = node.Maybe<TCoLeft>()) {
-        txRes.Ops.insert(node.Raw());
-        return ExploreTx(maybeLeft.Cast().Input(), ctx, dataSink, txRes);
-    }
-
-    auto checkDataSource = [dataSink] (const TKiDataSource& ds) {
-        return dataSink.Cluster().Raw() == ds.Cluster().Raw();
-    };
-
-    auto checkDataSink = [dataSink] (const TKiDataSink& ds) {
-        return dataSink.Raw() == ds.Raw();
-    };
-
+            hasScheme = hasScheme || (op & KikimrSchemeOps()); 
+            hasData = hasData || (op & KikimrDataOps()); 
+        } 
+    } 
+ 
+    TKiExploreTxResults() 
+        : HasExecute(false) {} 
+}; 
+ 
+bool ExploreTx(TExprBase node, TExprContext& ctx, const TKiDataSink& dataSink, TKiExploreTxResults& txRes) { 
+    if (txRes.Ops.cend() != txRes.Ops.find(node.Raw())) { 
+        return true; 
+    } 
+ 
+    if (node.Maybe<TCoWorld>()) { 
+        txRes.Ops.insert(node.Raw()); 
+        return true; 
+    } 
+ 
+    if (auto maybeLeft = node.Maybe<TCoLeft>()) { 
+        txRes.Ops.insert(node.Raw()); 
+        return ExploreTx(maybeLeft.Cast().Input(), ctx, dataSink, txRes); 
+    } 
+ 
+    auto checkDataSource = [dataSink] (const TKiDataSource& ds) { 
+        return dataSink.Cluster().Raw() == ds.Cluster().Raw(); 
+    }; 
+ 
+    auto checkDataSink = [dataSink] (const TKiDataSink& ds) { 
+        return dataSink.Raw() == ds.Raw(); 
+    }; 
+ 
     auto cluster = dataSink.Cluster();
 
-    if (auto maybeRead = node.Maybe<TKiReadTable>()) {
-        auto read = maybeRead.Cast();
-        if (!checkDataSource(read.DataSource())) {
-            return false;
-        }
-
-        TKikimrKey key(ctx);
-        YQL_ENSURE(key.Extract(read.TableKey().Ref()));
-        YQL_ENSURE(key.GetKeyType() == TKikimrKey::Type::Table);
-        auto table = key.GetTablePath();
-        txRes.Ops.insert(node.Raw());
-        auto result = ExploreTx(maybeRead.Cast().World(), ctx, dataSink, txRes);
+    if (auto maybeRead = node.Maybe<TKiReadTable>()) { 
+        auto read = maybeRead.Cast(); 
+        if (!checkDataSource(read.DataSource())) { 
+            return false; 
+        } 
+ 
+        TKikimrKey key(ctx); 
+        YQL_ENSURE(key.Extract(read.TableKey().Ref())); 
+        YQL_ENSURE(key.GetKeyType() == TKikimrKey::Type::Table); 
+        auto table = key.GetTablePath(); 
+        txRes.Ops.insert(node.Raw()); 
+        auto result = ExploreTx(maybeRead.Cast().World(), ctx, dataSink, txRes); 
         txRes.TableOperations.push_back(BuildTableOpNode(cluster, table, TYdbOperation::Select, read.Pos(), ctx));
-        return result;
-    }
-
-    if (auto maybeWrite = node.Maybe<TKiWriteTable>()) {
-        auto write = maybeWrite.Cast();
-        if (!checkDataSink(write.DataSink())) {
-            return false;
-        }
-
-        auto table = write.Table().Value();
-        txRes.Ops.insert(node.Raw());
-        auto result = ExploreTx(write.World(), ctx, dataSink, txRes);
-        auto tableOp = GetTableOp(write);
+        return result; 
+    } 
+ 
+    if (auto maybeWrite = node.Maybe<TKiWriteTable>()) { 
+        auto write = maybeWrite.Cast(); 
+        if (!checkDataSink(write.DataSink())) { 
+            return false; 
+        } 
+ 
+        auto table = write.Table().Value(); 
+        txRes.Ops.insert(node.Raw()); 
+        auto result = ExploreTx(write.World(), ctx, dataSink, txRes); 
+        auto tableOp = GetTableOp(write); 
         txRes.TableOperations.push_back(BuildTableOpNode(cluster, table, tableOp, write.Pos(), ctx));
-        txRes.Effects.push_back(node);
-        return result;
-    }
-
-    if (auto maybeUpdate = node.Maybe<TKiUpdateTable>()) {
-        auto update = maybeUpdate.Cast();
-        if (!checkDataSink(update.DataSink())) {
-            return false;
-        }
-
-        auto table = update.Table().Value();
-        txRes.Ops.insert(node.Raw());
-        auto result = ExploreTx(update.World(), ctx, dataSink, txRes);
+        txRes.Effects.push_back(node); 
+        return result; 
+    } 
+ 
+    if (auto maybeUpdate = node.Maybe<TKiUpdateTable>()) { 
+        auto update = maybeUpdate.Cast(); 
+        if (!checkDataSink(update.DataSink())) { 
+            return false; 
+        } 
+ 
+        auto table = update.Table().Value(); 
+        txRes.Ops.insert(node.Raw()); 
+        auto result = ExploreTx(update.World(), ctx, dataSink, txRes); 
         txRes.TableOperations.push_back(BuildTableOpNode(cluster, table, TYdbOperation::Update, update.Pos(), ctx));
-        txRes.Effects.push_back(node);
-        return result;
-    }
-
-    if (auto maybeDelete = node.Maybe<TKiDeleteTable>()) {
-        auto del = maybeDelete.Cast();
-        if (!checkDataSink(del.DataSink())) {
-            return false;
-        }
-
-        auto table = del.Table().Value();
-        txRes.Ops.insert(node.Raw());
-        auto result = ExploreTx(del.World(), ctx, dataSink, txRes);
+        txRes.Effects.push_back(node); 
+        return result; 
+    } 
+ 
+    if (auto maybeDelete = node.Maybe<TKiDeleteTable>()) { 
+        auto del = maybeDelete.Cast(); 
+        if (!checkDataSink(del.DataSink())) { 
+            return false; 
+        } 
+ 
+        auto table = del.Table().Value(); 
+        txRes.Ops.insert(node.Raw()); 
+        auto result = ExploreTx(del.World(), ctx, dataSink, txRes); 
         txRes.TableOperations.push_back(BuildTableOpNode(cluster, table, TYdbOperation::Delete, del.Pos(), ctx));
-        txRes.Effects.push_back(node);
-        return result;
-    }
-
-    if (auto maybeCreate = node.Maybe<TKiCreateTable>()) {
-        auto create = maybeCreate.Cast();
-        if (!checkDataSink(create.DataSink())) {
-            return false;
-        }
-
-        auto table = create.Table().Value();
-        txRes.Ops.insert(node.Raw());
-        auto result = ExploreTx(create.World(), ctx, dataSink, txRes);
+        txRes.Effects.push_back(node); 
+        return result; 
+    } 
+ 
+    if (auto maybeCreate = node.Maybe<TKiCreateTable>()) { 
+        auto create = maybeCreate.Cast(); 
+        if (!checkDataSink(create.DataSink())) { 
+            return false; 
+        } 
+ 
+        auto table = create.Table().Value(); 
+        txRes.Ops.insert(node.Raw()); 
+        auto result = ExploreTx(create.World(), ctx, dataSink, txRes); 
         txRes.TableOperations.push_back(BuildTableOpNode(cluster, table, TYdbOperation::CreateTable, create.Pos(), ctx));
-        return result;
-    }
-
-    if (auto maybeDrop = node.Maybe<TKiDropTable>()) {
-        auto drop = maybeDrop.Cast();
-        if (!checkDataSink(drop.DataSink())) {
-            return false;
-        }
-
-        auto table = drop.Table().Value();
-        txRes.Ops.insert(node.Raw());
-        auto result = ExploreTx(drop.World(), ctx, dataSink, txRes);
+        return result; 
+    } 
+ 
+    if (auto maybeDrop = node.Maybe<TKiDropTable>()) { 
+        auto drop = maybeDrop.Cast(); 
+        if (!checkDataSink(drop.DataSink())) { 
+            return false; 
+        } 
+ 
+        auto table = drop.Table().Value(); 
+        txRes.Ops.insert(node.Raw()); 
+        auto result = ExploreTx(drop.World(), ctx, dataSink, txRes); 
         txRes.TableOperations.push_back(BuildTableOpNode(cluster, table, TYdbOperation::DropTable, drop.Pos(), ctx));
-        return result;
-    }
-
-    if (auto maybeAlter = node.Maybe<TKiAlterTable>()) {
-        auto alter = maybeAlter.Cast();
-        if (!checkDataSink(alter.DataSink())) {
-            return false;
-        }
-
-        auto table = alter.Table().Value();
-        txRes.Ops.insert(node.Raw());
-        auto result = ExploreTx(alter.World(), ctx, dataSink, txRes);
+        return result; 
+    } 
+ 
+    if (auto maybeAlter = node.Maybe<TKiAlterTable>()) { 
+        auto alter = maybeAlter.Cast(); 
+        if (!checkDataSink(alter.DataSink())) { 
+            return false; 
+        } 
+ 
+        auto table = alter.Table().Value(); 
+        txRes.Ops.insert(node.Raw()); 
+        auto result = ExploreTx(alter.World(), ctx, dataSink, txRes); 
         txRes.TableOperations.push_back(BuildTableOpNode(cluster, table, TYdbOperation::AlterTable, alter.Pos(), ctx));
-        return result;
-    }
-
+        return result; 
+    } 
+ 
     if (auto maybeCreateUser = node.Maybe<TKiCreateUser>()) {
         auto createUser = maybeCreateUser.Cast();
         if (!checkDataSink(createUser.DataSink())) {
@@ -288,303 +288,303 @@ bool ExploreTx(TExprBase node, TExprContext& ctx, const TKiDataSink& dataSink, T
         return result;
     }
 
-    if (auto maybeExecQuery = node.Maybe<TKiExecDataQuery>()) {
-        auto execQuery = maybeExecQuery.Cast();
-        if (!checkDataSink(execQuery.DataSink())) {
-            return false;
-        }
-
-        txRes.HasExecute = true;
-        return true;
-    }
-
-    if (auto maybeCommit = node.Maybe<TCoCommit>()) {
-        auto commit = maybeCommit.Cast();
-
-        if (commit.DataSink().Maybe<TKiDataSink>() && checkDataSink(commit.DataSink().Cast<TKiDataSink>())) {
-            txRes.Sync.push_back(commit);
-            return true;
-        }
-
-        return ExploreTx(commit.World(), ctx, dataSink, txRes);
-    }
-
-    if (auto maybeSync = node.Maybe<TCoSync>()) {
-        txRes.Ops.insert(node.Raw());
-        for (auto child : maybeSync.Cast()) {
-            if (!ExploreTx(child, ctx, dataSink, txRes)) {
-                return false;
-            }
-
-            return true;
-        }
-    }
-
-    if (node.Maybe<TResWrite>() ||
-        node.Maybe<TResPull>())
-    {
-        txRes.Ops.insert(node.Raw());
-        bool result = ExploreTx(TExprBase(node.Ref().ChildPtr(0)), ctx, dataSink, txRes);
-        txRes.Results.push_back(node);
-        return result;
-    }
-
-    if (node.Ref().IsCallable(ConfigureName)) {
-        txRes.Sync.push_back(node);
-        return true;
-    }
-
-    return false;
-}
-
-bool IsKikimrPureNode(const TExprNode::TPtr& node) {
-    if (node->IsCallable("TypeOf")) {
-        return true;
-    }
-
-    if (TMaybeNode<TCoDataSource>(node) ||
-        TMaybeNode<TCoDataSink>(node))
-    {
-        return true;
-    }
-
+    if (auto maybeExecQuery = node.Maybe<TKiExecDataQuery>()) { 
+        auto execQuery = maybeExecQuery.Cast(); 
+        if (!checkDataSink(execQuery.DataSink())) { 
+            return false; 
+        } 
+ 
+        txRes.HasExecute = true; 
+        return true; 
+    } 
+ 
+    if (auto maybeCommit = node.Maybe<TCoCommit>()) { 
+        auto commit = maybeCommit.Cast(); 
+ 
+        if (commit.DataSink().Maybe<TKiDataSink>() && checkDataSink(commit.DataSink().Cast<TKiDataSink>())) { 
+            txRes.Sync.push_back(commit); 
+            return true; 
+        } 
+ 
+        return ExploreTx(commit.World(), ctx, dataSink, txRes); 
+    } 
+ 
+    if (auto maybeSync = node.Maybe<TCoSync>()) { 
+        txRes.Ops.insert(node.Raw()); 
+        for (auto child : maybeSync.Cast()) { 
+            if (!ExploreTx(child, ctx, dataSink, txRes)) { 
+                return false; 
+            } 
+ 
+            return true; 
+        } 
+    } 
+ 
+    if (node.Maybe<TResWrite>() || 
+        node.Maybe<TResPull>()) 
+    { 
+        txRes.Ops.insert(node.Raw()); 
+        bool result = ExploreTx(TExprBase(node.Ref().ChildPtr(0)), ctx, dataSink, txRes); 
+        txRes.Results.push_back(node); 
+        return result; 
+    } 
+ 
+    if (node.Ref().IsCallable(ConfigureName)) { 
+        txRes.Sync.push_back(node); 
+        return true; 
+    } 
+ 
+    return false; 
+} 
+ 
+bool IsKikimrPureNode(const TExprNode::TPtr& node) { 
+    if (node->IsCallable("TypeOf")) { 
+        return true; 
+    } 
+ 
+    if (TMaybeNode<TCoDataSource>(node) || 
+        TMaybeNode<TCoDataSink>(node)) 
+    { 
+        return true; 
+    } 
+ 
     if (!node->GetTypeAnn()->IsComposable()) {
-        return false;
-    }
-
-    return true;
-}
-
-bool CheckTx(TExprBase txStart, const TKiDataSink& dataSink, const THashSet<const TExprNode*>& txOps,
-    const THashSet<const TExprNode*>& txSync)
-{
-    bool hasErrors = false;
-    VisitExpr(txStart.Ptr(), [&txOps, &txSync, &hasErrors, dataSink] (const TExprNode::TPtr& node) {
-        if (hasErrors) {
-            return false;
-        }
-
-        if (txSync.find(node.Get()) != txSync.cend()) {
-            return false;
-        }
-
-        if (auto maybeCommit = TMaybeNode<TCoCommit>(node)) {
-            if (maybeCommit.Cast().DataSink().Raw() != dataSink.Raw()) {
-                return true;
-            }
-        }
-
-        if (!IsKikimrPureNode(node) && txOps.find(node.Get()) == txOps.cend()) {
-            hasErrors = true;
-            return false;
-        }
-
-        return true;
-    });
-
-    return !hasErrors;
-}
-
-TExprNode::TPtr MakeSchemeTx(TCoCommit commit, TExprContext& ctx) {
-    auto settings = NCommon::ParseCommitSettings(commit, ctx);
-
-    if (settings.Mode) {
-        return commit.Ptr();
-    }
-
-    return Build<TCoCommit>(ctx, commit.Pos())
-        .World(commit.World())
-        .DataSink(commit.DataSink())
-        .Settings()
-            .Add()
-                .Name().Build("mode")
-                .Value<TCoAtom>().Build(KikimrCommitModeScheme())
-                .Build()
-            .Build()
-        .Done()
-        .Ptr();
-}
-
-TKiDataQuery MakeKiDataQuery(TExprBase node, const TKiExploreTxResults& txExplore, TExprContext& ctx) {
-    TExprNode::TListType queryResults;
-    for (auto& result : txExplore.Results) {
-        auto resWrite = result.Cast<TResWriteBase>();
-
-        auto kiResult = Build<TKiResult>(ctx, node.Pos())
-            .Value(resWrite.Data())
-            .Columns(GetResultColumns(resWrite, ctx))
-            .RowsLimit().Build(GetResultRowsLimit(resWrite))
-            .Done();
-
-        queryResults.push_back(kiResult.Ptr());
-    }
-
-    auto query = Build<TKiDataQuery>(ctx, node.Pos())
-        .Operations()
-            .Add(txExplore.TableOperations)
-            .Build()
-        .Results()
-            .Add(queryResults)
-            .Build()
-        .Effects()
-            .Add(txExplore.Effects)
-            .Build()
-        .Done();
-
-
-    auto txSyncSet = txExplore.GetSyncSet();
-    auto world = Build<TCoWorld>(ctx, node.Pos()).Done();
-
-    TExprNode::TPtr optResult;
-    TOptimizeExprSettings optSettings(nullptr);
-    optSettings.VisitChanges = true;
-    auto status = OptimizeExpr(query.Ptr(), optResult,
-        [world, &txSyncSet](const TExprNode::TPtr& input, TExprContext& ctx) {
-            auto node = TExprBase(input);
-
-            if (txSyncSet.contains(node.Raw())) {
-                return world.Ptr();
-            }
-
-            if (node.Maybe<TKiReadTable>() ||
-                node.Maybe<TKiWriteTable>() ||
-                node.Maybe<TKiUpdateTable>() ||
-                node.Maybe<TKiDeleteTable>())
-            {
-                return ctx.ChangeChild(node.Ref(), 0, world.Ptr());
-            }
-
-            return node.Ptr();
-        }, ctx, optSettings);
-
-    YQL_ENSURE(status == IGraphTransformer::TStatus::Ok);
-    YQL_ENSURE(TMaybeNode<TKiDataQuery>(optResult));
-    return TKiDataQuery(optResult);
-}
-
-} // namespace
-
-TExprNode::TPtr KiBuildQuery(TExprBase node, const TMaybe<bool>& useNewEngine, TExprContext& ctx) {
-    if (!node.Maybe<TCoCommit>().DataSink().Maybe<TKiDataSink>()) {
-        return node.Ptr();
-    }
-
-    auto commit = node.Cast<TCoCommit>();
-    auto settings = NCommon::ParseCommitSettings(commit, ctx);
-    auto kiDataSink = commit.DataSink().Cast<TKiDataSink>();
-
-    TKiExploreTxResults txExplore;
-    if (!ExploreTx(commit.World(), ctx, kiDataSink, txExplore)) {
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
+bool CheckTx(TExprBase txStart, const TKiDataSink& dataSink, const THashSet<const TExprNode*>& txOps, 
+    const THashSet<const TExprNode*>& txSync) 
+{ 
+    bool hasErrors = false; 
+    VisitExpr(txStart.Ptr(), [&txOps, &txSync, &hasErrors, dataSink] (const TExprNode::TPtr& node) { 
+        if (hasErrors) { 
+            return false; 
+        } 
+ 
+        if (txSync.find(node.Get()) != txSync.cend()) { 
+            return false; 
+        } 
+ 
+        if (auto maybeCommit = TMaybeNode<TCoCommit>(node)) { 
+            if (maybeCommit.Cast().DataSink().Raw() != dataSink.Raw()) { 
+                return true; 
+            } 
+        } 
+ 
+        if (!IsKikimrPureNode(node) && txOps.find(node.Get()) == txOps.cend()) { 
+            hasErrors = true; 
+            return false; 
+        } 
+ 
+        return true; 
+    }); 
+ 
+    return !hasErrors; 
+} 
+ 
+TExprNode::TPtr MakeSchemeTx(TCoCommit commit, TExprContext& ctx) { 
+    auto settings = NCommon::ParseCommitSettings(commit, ctx); 
+ 
+    if (settings.Mode) { 
+        return commit.Ptr(); 
+    } 
+ 
+    return Build<TCoCommit>(ctx, commit.Pos()) 
+        .World(commit.World()) 
+        .DataSink(commit.DataSink()) 
+        .Settings() 
+            .Add() 
+                .Name().Build("mode") 
+                .Value<TCoAtom>().Build(KikimrCommitModeScheme()) 
+                .Build() 
+            .Build() 
+        .Done() 
+        .Ptr(); 
+} 
+ 
+TKiDataQuery MakeKiDataQuery(TExprBase node, const TKiExploreTxResults& txExplore, TExprContext& ctx) { 
+    TExprNode::TListType queryResults; 
+    for (auto& result : txExplore.Results) { 
+        auto resWrite = result.Cast<TResWriteBase>(); 
+ 
+        auto kiResult = Build<TKiResult>(ctx, node.Pos()) 
+            .Value(resWrite.Data()) 
+            .Columns(GetResultColumns(resWrite, ctx)) 
+            .RowsLimit().Build(GetResultRowsLimit(resWrite)) 
+            .Done(); 
+ 
+        queryResults.push_back(kiResult.Ptr()); 
+    } 
+ 
+    auto query = Build<TKiDataQuery>(ctx, node.Pos()) 
+        .Operations() 
+            .Add(txExplore.TableOperations) 
+            .Build() 
+        .Results() 
+            .Add(queryResults) 
+            .Build() 
+        .Effects() 
+            .Add(txExplore.Effects) 
+            .Build() 
+        .Done(); 
+ 
+ 
+    auto txSyncSet = txExplore.GetSyncSet(); 
+    auto world = Build<TCoWorld>(ctx, node.Pos()).Done(); 
+ 
+    TExprNode::TPtr optResult; 
+    TOptimizeExprSettings optSettings(nullptr); 
+    optSettings.VisitChanges = true; 
+    auto status = OptimizeExpr(query.Ptr(), optResult, 
+        [world, &txSyncSet](const TExprNode::TPtr& input, TExprContext& ctx) { 
+            auto node = TExprBase(input); 
+ 
+            if (txSyncSet.contains(node.Raw())) { 
+                return world.Ptr(); 
+            } 
+ 
+            if (node.Maybe<TKiReadTable>() || 
+                node.Maybe<TKiWriteTable>() || 
+                node.Maybe<TKiUpdateTable>() || 
+                node.Maybe<TKiDeleteTable>()) 
+            { 
+                return ctx.ChangeChild(node.Ref(), 0, world.Ptr()); 
+            } 
+ 
+            return node.Ptr(); 
+        }, ctx, optSettings); 
+ 
+    YQL_ENSURE(status == IGraphTransformer::TStatus::Ok); 
+    YQL_ENSURE(TMaybeNode<TKiDataQuery>(optResult)); 
+    return TKiDataQuery(optResult); 
+} 
+ 
+} // namespace 
+ 
+TExprNode::TPtr KiBuildQuery(TExprBase node, const TMaybe<bool>& useNewEngine, TExprContext& ctx) { 
+    if (!node.Maybe<TCoCommit>().DataSink().Maybe<TKiDataSink>()) { 
+        return node.Ptr(); 
+    } 
+ 
+    auto commit = node.Cast<TCoCommit>(); 
+    auto settings = NCommon::ParseCommitSettings(commit, ctx); 
+    auto kiDataSink = commit.DataSink().Cast<TKiDataSink>(); 
+ 
+    TKiExploreTxResults txExplore; 
+    if (!ExploreTx(commit.World(), ctx, kiDataSink, txExplore)) { 
         return node.Ptr();
-    }
-
-    if (txExplore.HasExecute) {
+    } 
+ 
+    if (txExplore.HasExecute) { 
+        return node.Ptr(); 
+    } 
+ 
+    auto txSyncSet = txExplore.GetSyncSet(); 
+    if (!CheckTx(commit.World(), kiDataSink, txExplore.Ops, txSyncSet)) { 
         return node.Ptr();
-    }
-
-    auto txSyncSet = txExplore.GetSyncSet();
-    if (!CheckTx(commit.World(), kiDataSink, txExplore.Ops, txSyncSet)) {
-        return node.Ptr();
-    }
-
-    bool hasScheme;
-    bool hasData;
-    txExplore.GetTableOperations(hasScheme, hasData);
-
-    if (hasData && hasScheme) {
+    } 
+ 
+    bool hasScheme; 
+    bool hasData; 
+    txExplore.GetTableOperations(hasScheme, hasData); 
+ 
+    if (hasData && hasScheme) { 
         ctx.AddError(YqlIssue(ctx.GetPosition(commit.Pos()), TIssuesIds::KIKIMR_MIXED_SCHEME_DATA_TX));
-        return nullptr;
-    }
-
-    if (hasScheme) {
-        return MakeSchemeTx(commit, ctx);
-    }
-
-    auto dataQuery = MakeKiDataQuery(commit.World(), txExplore, ctx);
-
-    TKiExecDataQuerySettings execSettings;
-    if (settings.Mode) {
-        auto value = settings.Mode.Cast().Value();
-        if (!value.empty()) {
-            execSettings.Mode = value;
-        }
-    }
-    execSettings.UseNewEngine = useNewEngine;
-
-    auto execQuery = Build<TKiExecDataQuery>(ctx, node.Pos())
-        .World<TCoSync>()
-            .Add<TCoWorld>().Build()
-            .Add(txExplore.Sync)
-            .Build()
-        .DataSink(commit.DataSink().Cast<TKiDataSink>())
-        .Query(dataQuery)
-        .Settings(execSettings.BuildNode(ctx, node.Pos()))
-        .Ast<TCoVoid>().Build()
-        .Done();
-
-    TExprBase execWorld = Build<TCoLeft>(ctx, node.Pos())
-        .Input(execQuery)
-        .Done();
-
-    if (!txExplore.Results.empty()) {
-        auto execRight = Build<TCoRight>(ctx, node.Pos())
-            .Input(execQuery)
-            .Done()
-            .Ptr();
-
-        for (size_t i = 0; i < txExplore.Results.size(); ++i) {
-            auto result = txExplore.Results[i].Cast<TResWriteBase>();
-
-            auto extractValue = Build<TCoNth>(ctx, node.Pos())
-                .Tuple(execRight)
-                .Index().Build(i)
-                .Done()
-                .Ptr();
-
-            auto newResult = ctx.ChangeChild(
+        return nullptr; 
+    } 
+ 
+    if (hasScheme) { 
+        return MakeSchemeTx(commit, ctx); 
+    } 
+ 
+    auto dataQuery = MakeKiDataQuery(commit.World(), txExplore, ctx); 
+ 
+    TKiExecDataQuerySettings execSettings; 
+    if (settings.Mode) { 
+        auto value = settings.Mode.Cast().Value(); 
+        if (!value.empty()) { 
+            execSettings.Mode = value; 
+        } 
+    } 
+    execSettings.UseNewEngine = useNewEngine; 
+ 
+    auto execQuery = Build<TKiExecDataQuery>(ctx, node.Pos()) 
+        .World<TCoSync>() 
+            .Add<TCoWorld>().Build() 
+            .Add(txExplore.Sync) 
+            .Build() 
+        .DataSink(commit.DataSink().Cast<TKiDataSink>()) 
+        .Query(dataQuery) 
+        .Settings(execSettings.BuildNode(ctx, node.Pos())) 
+        .Ast<TCoVoid>().Build() 
+        .Done(); 
+ 
+    TExprBase execWorld = Build<TCoLeft>(ctx, node.Pos()) 
+        .Input(execQuery) 
+        .Done(); 
+ 
+    if (!txExplore.Results.empty()) { 
+        auto execRight = Build<TCoRight>(ctx, node.Pos()) 
+            .Input(execQuery) 
+            .Done() 
+            .Ptr(); 
+ 
+        for (size_t i = 0; i < txExplore.Results.size(); ++i) { 
+            auto result = txExplore.Results[i].Cast<TResWriteBase>(); 
+ 
+            auto extractValue = Build<TCoNth>(ctx, node.Pos()) 
+                .Tuple(execRight) 
+                .Index().Build(i) 
+                .Done() 
+                .Ptr(); 
+ 
+            auto newResult = ctx.ChangeChild( 
                 *ctx.ChangeChild(
                     result.Ref(),
-                    TResWriteBase::idx_World,
-                    execWorld.Ptr()
-                ),
-                TResWriteBase::idx_Data,
-                std::move(extractValue)
-            );
-
-            execWorld = Build<TCoCommit>(ctx, node.Pos())
-                .World(newResult)
-                .DataSink<TResultDataSink>()
-                    .Build()
-                .Done();
-        }
-    }
-
-    auto ret = Build<TCoCommit>(ctx, node.Pos())
-        .World(execWorld)
-        .DataSink(commit.DataSink())
-        .Settings(settings.BuildNode(ctx))
-        .Done()
-        .Ptr();
-
-    YQL_CLOG(INFO, ProviderKikimr) << "KiBuildQuery";
-    return ret;
-}
-
+                    TResWriteBase::idx_World, 
+                    execWorld.Ptr() 
+                ), 
+                TResWriteBase::idx_Data, 
+                std::move(extractValue) 
+            ); 
+ 
+            execWorld = Build<TCoCommit>(ctx, node.Pos()) 
+                .World(newResult) 
+                .DataSink<TResultDataSink>() 
+                    .Build() 
+                .Done(); 
+        } 
+    } 
+ 
+    auto ret = Build<TCoCommit>(ctx, node.Pos()) 
+        .World(execWorld) 
+        .DataSink(commit.DataSink()) 
+        .Settings(settings.BuildNode(ctx)) 
+        .Done() 
+        .Ptr(); 
+ 
+    YQL_CLOG(INFO, ProviderKikimr) << "KiBuildQuery"; 
+    return ret; 
+} 
+ 
 TExprNode::TPtr KiBuildResult(TExprBase node,  const TString& cluster, TExprContext& ctx) {
     if (!node.Maybe<TResFill>()) {
-        return node.Ptr();
-    }
-
+        return node.Ptr(); 
+    } 
+ 
     auto resFill = node.Cast<TResFill>();
-
+ 
     if (resFill.DelegatedSource().Value() != KikimrProviderName) {
         return node.Ptr();
-    }
-
+    } 
+ 
     if (resFill.Data().Maybe<TCoNth>().Tuple().Maybe<TCoRight>().Input().Maybe<TKiExecDataQuery>()) {
-        return node.Ptr();
-    }
-
+        return node.Ptr(); 
+    } 
+ 
     auto dataQuery = Build<TKiDataQuery>(ctx, node.Pos())
         .Operations()
             .Build()
@@ -593,10 +593,10 @@ TExprNode::TPtr KiBuildResult(TExprBase node,  const TString& cluster, TExprCont
                 .Value(resFill.Data())
                 .Columns(GetResultColumns(resFill, ctx))
                 .RowsLimit().Build(GetResultRowsLimit(resFill))
-                .Build()
-            .Build()
+                .Build() 
+            .Build() 
         .Effects()
-            .Build()
+            .Build() 
         .Done();
 
     auto exec = Build<TKiExecDataQuery>(ctx, node.Pos())
@@ -604,44 +604,44 @@ TExprNode::TPtr KiBuildResult(TExprBase node,  const TString& cluster, TExprCont
         .DataSink<TKiDataSink>()
             .Category().Build(KikimrProviderName)
             .Cluster().Build(cluster)
-            .Build()
+            .Build() 
         .Query(dataQuery)
-        .Settings()
-            .Build()
+        .Settings() 
+            .Build() 
         .Ast<TCoVoid>().Build()
-        .Done();
-
-    auto data = Build<TCoNth>(ctx, node.Pos())
-        .Tuple<TCoRight>()
+        .Done(); 
+ 
+    auto data = Build<TCoNth>(ctx, node.Pos()) 
+        .Tuple<TCoRight>() 
             .Input(exec)
-            .Build()
-        .Index().Build(0)
-        .Done();
-
-    auto world = Build<TCoLeft>(ctx, node.Pos())
+            .Build() 
+        .Index().Build(0) 
+        .Done(); 
+ 
+    auto world = Build<TCoLeft>(ctx, node.Pos()) 
         .Input(exec)
-        .Done();
-
+        .Done(); 
+ 
     return ctx.ChangeChild(*ctx.ChangeChild(resFill.Ref(), 0, world.Ptr()), 3, data.Ptr());
-}
-
+} 
+ 
 TYdbOperation GetTableOp(const TKiWriteTable& write) {
-    auto mode = write.Mode().Value();
-    if (mode == "upsert") {
+    auto mode = write.Mode().Value(); 
+    if (mode == "upsert") { 
         return TYdbOperation::Upsert;
-    } else if (mode == "replace") {
+    } else if (mode == "replace") { 
         return TYdbOperation::Replace;
-    } else if (mode == "insert_revert") {
+    } else if (mode == "insert_revert") { 
         return TYdbOperation::InsertRevert;
-    } else if (mode == "insert_abort") {
+    } else if (mode == "insert_abort") { 
         return TYdbOperation::InsertAbort;
-    } else if (mode == "delete_on") {
+    } else if (mode == "delete_on") { 
         return TYdbOperation::DeleteOn;
-    } else if (mode == "update_on") {
+    } else if (mode == "update_on") { 
         return TYdbOperation::UpdateOn;
-    }
-
-    YQL_ENSURE(false, "Unexpected TKiWriteTable mode: " << mode);
-}
-
-} // namespace NYql
+    } 
+ 
+    YQL_ENSURE(false, "Unexpected TKiWriteTable mode: " << mode); 
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_opt_join.cpp b/ydb/core/kqp/provider/yql_kikimr_opt_join.cpp
index 662082c543..db4ca7924e 100644
--- a/ydb/core/kqp/provider/yql_kikimr_opt_join.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_opt_join.cpp
@@ -1,45 +1,45 @@
-#include "yql_kikimr_provider_impl.h"
+#include "yql_kikimr_provider_impl.h" 
 #include "yql_kikimr_opt_utils.h"
-
+ 
 #include <ydb/library/yql/core/yql_join.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/utils/log/log.h>
 #include <util/string/cast.h>
-
-namespace NYql {
-namespace {
-
-using namespace NNodes;
-using namespace NCommon;
-
-using TGetExprFunc = std::function<TExprBase()>;
-
-TExprBase GetEquiJoinInputList(TCoAtom scope, const TJoinLabels& joinLabels,
-    const TVector<TCoEquiJoinInput>& joinInputs)
-{
-    auto inputIndex = joinLabels.FindInputIndex(scope.Value());
-    YQL_ENSURE(inputIndex);
-
-    return joinInputs[*inputIndex].List();
-}
-
-void GatherEquiJoinLables(TExprBase joinScope, TVector<TString>& labels) {
-    if (joinScope.Maybe<TCoAtom>()) {
+ 
+namespace NYql { 
+namespace { 
+ 
+using namespace NNodes; 
+using namespace NCommon; 
+ 
+using TGetExprFunc = std::function<TExprBase()>; 
+ 
+TExprBase GetEquiJoinInputList(TCoAtom scope, const TJoinLabels& joinLabels, 
+    const TVector<TCoEquiJoinInput>& joinInputs) 
+{ 
+    auto inputIndex = joinLabels.FindInputIndex(scope.Value()); 
+    YQL_ENSURE(inputIndex); 
+ 
+    return joinInputs[*inputIndex].List(); 
+} 
+ 
+void GatherEquiJoinLables(TExprBase joinScope, TVector<TString>& labels) { 
+    if (joinScope.Maybe<TCoAtom>()) { 
         labels.emplace_back(TString(joinScope.Cast<TCoAtom>()));
-        return;
-    }
-
-    auto joinTuple = joinScope.Cast<TCoEquiJoinTuple>();
-    GatherEquiJoinLables(joinTuple.LeftScope(), labels);
-    GatherEquiJoinLables(joinTuple.RightScope(), labels);
-}
-
-TSet<TString> GetEquiJoinLabelReps(TExprBase joinScope) {
-    TVector<TString> labels;
-    GatherEquiJoinLables(joinScope, labels);
-    return TSet<TString>(labels.begin(), labels.end());
-}
-
+        return; 
+    } 
+ 
+    auto joinTuple = joinScope.Cast<TCoEquiJoinTuple>(); 
+    GatherEquiJoinLables(joinTuple.LeftScope(), labels); 
+    GatherEquiJoinLables(joinTuple.RightScope(), labels); 
+} 
+ 
+TSet<TString> GetEquiJoinLabelReps(TExprBase joinScope) { 
+    TVector<TString> labels; 
+    GatherEquiJoinLables(joinScope, labels); 
+    return TSet<TString>(labels.begin(), labels.end()); 
+} 
+ 
 TExprBase ConvertToTuples(const TSet<TString>& columns, const TCoArgument& structArg, TExprContext& ctx,
     TPositionHandle pos)
 {
@@ -70,49 +70,49 @@ TVector<TExprBase> ConvertToAtoms(const TSet<TString>& columns, TExprContext& ct
 };
 
 
-TMaybeNode<TExprBase> EquiJoinGetIdxLookupValue(const TStringBuf& leftDataName, const TStringBuf& rightDataName,
+TMaybeNode<TExprBase> EquiJoinGetIdxLookupValue(const TStringBuf& leftDataName, const TStringBuf& rightDataName, 
     TExprBase leftRow, const TString& leftMemberName, TPositionHandle pos, TExprContext& ctx)
-{
-    auto leftMember = Build<TCoMember>(ctx, pos)
-        .Struct(leftRow)
-        .Name().Build(leftMemberName)
-        .Done();
-
-    TExprBase value = leftMember;
-    if (leftDataName != rightDataName) {
-        bool canConvert = false;
-
+{ 
+    auto leftMember = Build<TCoMember>(ctx, pos) 
+        .Struct(leftRow) 
+        .Name().Build(leftMemberName) 
+        .Done(); 
+ 
+    TExprBase value = leftMember; 
+    if (leftDataName != rightDataName) { 
+        bool canConvert = false; 
+ 
         if (IsDataTypeNumeric(NKikimr::NUdf::GetDataSlot(leftDataName)) && IsDataTypeNumeric(NKikimr::NUdf::GetDataSlot(rightDataName))) {
             canConvert = GetNumericDataTypeLevel(NKikimr::NUdf::GetDataSlot(rightDataName))
             >= GetNumericDataTypeLevel(NKikimr::NUdf::GetDataSlot(leftDataName));
-        }
-
-        if (leftDataName == "Utf8" && rightDataName == "String") {
-            canConvert = true;
-        }
-
-        if (!canConvert) {
-            return TMaybeNode<TExprBase>();
-        }
-
-        value = Build<TCoConvert>(ctx, pos)
-            .Input(value)
-            .Type().Build(rightDataName)
-            .Done();
-    }
-
-    return value;
-}
-
-bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, const TJoinLabels& joinLabels,
-    const TVector<TCoEquiJoinInput>& joinInputs, const TKikimrTablesData& tablesData, TExprContext& ctx,
-    TMaybeNode<TExprBase>& idxLookupExpr)
-{
-    if (!joinTuple.RightScope().Maybe<TCoAtom>()) {
-        // Can't lookup in join result
-        return false;
-    }
-
+        } 
+ 
+        if (leftDataName == "Utf8" && rightDataName == "String") { 
+            canConvert = true; 
+        } 
+ 
+        if (!canConvert) { 
+            return TMaybeNode<TExprBase>(); 
+        } 
+ 
+        value = Build<TCoConvert>(ctx, pos) 
+            .Input(value) 
+            .Type().Build(rightDataName) 
+            .Done(); 
+    } 
+ 
+    return value; 
+} 
+ 
+bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, const TJoinLabels& joinLabels, 
+    const TVector<TCoEquiJoinInput>& joinInputs, const TKikimrTablesData& tablesData, TExprContext& ctx, 
+    TMaybeNode<TExprBase>& idxLookupExpr) 
+{ 
+    if (!joinTuple.RightScope().Maybe<TCoAtom>()) { 
+        // Can't lookup in join result 
+        return false; 
+    } 
+ 
     static const struct {
         const TStringBuf Left = "Left";
         const TStringBuf Inner = "Inner";
@@ -120,7 +120,7 @@ bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, c
         const TStringBuf LeftOnly = "LeftOnly";
         const TStringBuf RightSemi = "RightSemi";
     } joinNames;
-
+ 
     static const TVector<TStringBuf> allowedJoins {
         joinNames.Left,
         joinNames.Inner,
@@ -131,173 +131,173 @@ bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, c
 
     const TStringBuf joinType = joinTuple.Type().Value();
     if (Find(allowedJoins, joinType) == allowedJoins.cend()) {
-        return false;
-    }
-
+        return false; 
+    } 
+ 
     auto linkSettings = GetEquiJoinLinkSettings(joinTuple.Options().Ref());
     if (linkSettings.LeftHints.contains("any") || linkSettings.RightHints.contains("any")) {
-        return false;
-    }
-
-    auto rightExpr = GetEquiJoinInputList(joinTuple.RightScope().Cast<TCoAtom>(), joinLabels, joinInputs);
-
+        return false; 
+    } 
+ 
+    auto rightExpr = GetEquiJoinInputList(joinTuple.RightScope().Cast<TCoAtom>(), joinLabels, joinInputs); 
+ 
     TMaybeNode<TKiSelectRangeBase> rightSelect;
-    TMaybeNode<TCoFlatMap> rightFlatmap;
-    TMaybeNode<TCoFilterNullMembers> rightFilterNull;
-    TMaybeNode<TCoSkipNullMembers> rightSkipNull;
+    TMaybeNode<TCoFlatMap> rightFlatmap; 
+    TMaybeNode<TCoFilterNullMembers> rightFilterNull; 
+    TMaybeNode<TCoSkipNullMembers> rightSkipNull; 
     TMaybeNode<TCoAtom> indexTable;
-
+ 
     if (auto select = rightExpr.Maybe<TKiSelectRangeBase>()) {
-        rightSelect = select;
-    }
-
+        rightSelect = select; 
+    } 
+ 
     if (auto select = rightExpr.Maybe<TCoFlatMap>().Input().Maybe<TKiSelectRangeBase>()) {
-        rightSelect = select;
-        rightFlatmap = rightExpr.Cast<TCoFlatMap>();
-    }
-
-    if (auto select = rightExpr.Maybe<TCoFlatMap>().Input().Maybe<TCoFilterNullMembers>()
+        rightSelect = select; 
+        rightFlatmap = rightExpr.Cast<TCoFlatMap>(); 
+    } 
+ 
+    if (auto select = rightExpr.Maybe<TCoFlatMap>().Input().Maybe<TCoFilterNullMembers>() 
         .Input().Maybe<TKiSelectRangeBase>())
-    {
-        rightSelect = select;
-        rightFlatmap = rightExpr.Cast<TCoFlatMap>();
-        rightFilterNull = rightFlatmap.Input().Cast<TCoFilterNullMembers>();
-    }
-
-    if (auto select = rightExpr.Maybe<TCoFlatMap>().Input().Maybe<TCoSkipNullMembers>()
+    { 
+        rightSelect = select; 
+        rightFlatmap = rightExpr.Cast<TCoFlatMap>(); 
+        rightFilterNull = rightFlatmap.Input().Cast<TCoFilterNullMembers>(); 
+    } 
+ 
+    if (auto select = rightExpr.Maybe<TCoFlatMap>().Input().Maybe<TCoSkipNullMembers>() 
         .Input().Maybe<TKiSelectRangeBase>())
-    {
-        rightSelect = select;
-        rightFlatmap = rightExpr.Cast<TCoFlatMap>();
-        rightSkipNull = rightFlatmap.Input().Cast<TCoSkipNullMembers>();
-    }
-
+    { 
+        rightSelect = select; 
+        rightFlatmap = rightExpr.Cast<TCoFlatMap>(); 
+        rightSkipNull = rightFlatmap.Input().Cast<TCoSkipNullMembers>(); 
+    } 
+ 
     if (auto indexSelect = rightSelect.Maybe<TKiSelectIndexRange>()) {
         indexTable = indexSelect.Cast().IndexName();
     }
 
-    if (!rightSelect) {
-        return false;
-    }
-
-    if (rightFlatmap && !IsPassthroughFlatMap(rightFlatmap.Cast(), nullptr)) {
-        // Can't lookup in modified table
-        return false;
-    }
-
+    if (!rightSelect) { 
+        return false; 
+    } 
+ 
+    if (rightFlatmap && !IsPassthroughFlatMap(rightFlatmap.Cast(), nullptr)) { 
+        // Can't lookup in modified table 
+        return false; 
+    } 
+ 
     const auto selectRange = rightSelect.Cast();
     const TStringBuf cluster = selectRange.Cluster().Value();
     const TStringBuf lookupTable = indexTable ? indexTable.Cast().Value() : selectRange.Table().Path().Value();
     const TKikimrTableDescription& lookupTableDesc = tablesData.ExistingTable(cluster, lookupTable);
-
+ 
     auto rightKeyRange = TKikimrKeyRange::GetPointKeyRange(ctx, lookupTableDesc, selectRange.Range());
-    if (!rightKeyRange) {
-        // Don't rewrite join with arbitrary range
-        return false;
-    }
-
-    for (size_t i = 0; i < rightKeyRange->GetColumnRangesCount(); ++i) {
-        auto columnRange = rightKeyRange->GetColumnRange(i);
-        if (columnRange.IsDefined()) {
-            YQL_ENSURE(columnRange.IsPoint());
-            auto argument = FindNode(columnRange.GetFrom().GetValue().Ptr(), [] (const TExprNode::TPtr& node) {
-                return node->IsArgument();
-            });
-
-            if (argument) {
-                // Can't lookup in dependent range
-                return false;
-            }
-        }
-    }
-
-    auto leftLabelReps = GetEquiJoinLabelReps(joinTuple.LeftScope());
-    YQL_ENSURE(!leftLabelReps.empty());
-    auto rightLabelReps = GetEquiJoinLabelReps(joinTuple.RightScope());
-    YQL_ENSURE(rightLabelReps.size() == 1);
+    if (!rightKeyRange) { 
+        // Don't rewrite join with arbitrary range 
+        return false; 
+    } 
+ 
+    for (size_t i = 0; i < rightKeyRange->GetColumnRangesCount(); ++i) { 
+        auto columnRange = rightKeyRange->GetColumnRange(i); 
+        if (columnRange.IsDefined()) { 
+            YQL_ENSURE(columnRange.IsPoint()); 
+            auto argument = FindNode(columnRange.GetFrom().GetValue().Ptr(), [] (const TExprNode::TPtr& node) { 
+                return node->IsArgument(); 
+            }); 
+ 
+            if (argument) { 
+                // Can't lookup in dependent range 
+                return false; 
+            } 
+        } 
+    } 
+ 
+    auto leftLabelReps = GetEquiJoinLabelReps(joinTuple.LeftScope()); 
+    YQL_ENSURE(!leftLabelReps.empty()); 
+    auto rightLabelReps = GetEquiJoinLabelReps(joinTuple.RightScope()); 
+    YQL_ENSURE(rightLabelReps.size() == 1); 
     YQL_ENSURE(rightLabelReps.contains(joinTuple.RightScope().Cast<TCoAtom>().Value()));
-
-    auto joinKeyCount = joinTuple.RightKeys().Size() / 2;
-
-    bool prefixLeftMembers = !joinTuple.LeftScope().Maybe<TCoAtom>();
-
-    TCoArgument leftRowArg = Build<TCoArgument>(ctx, joinTuple.Pos())
-        .Name("leftRow")
-        .Done();
-
-    TSet<TString> leftKeyColumnsSet;
-    TSet<TString> rightKeyColumnsSet;
+ 
+    auto joinKeyCount = joinTuple.RightKeys().Size() / 2; 
+ 
+    bool prefixLeftMembers = !joinTuple.LeftScope().Maybe<TCoAtom>(); 
+ 
+    TCoArgument leftRowArg = Build<TCoArgument>(ctx, joinTuple.Pos()) 
+        .Name("leftRow") 
+        .Done(); 
+ 
+    TSet<TString> leftKeyColumnsSet; 
+    TSet<TString> rightKeyColumnsSet; 
     TVector<TColumnRange> keyColumnRanges(lookupTableDesc.Metadata->KeyColumnNames.size());
-
-    for (size_t i = 0; i < joinKeyCount; ++i) {
-        auto joinLeftLabel = joinTuple.LeftKeys().Item(i * 2);
-        auto joinLeftColumn = joinTuple.LeftKeys().Item(i * 2 + 1);
-        auto joinRightLabel = joinTuple.RightKeys().Item(i * 2);
-        auto joinRightColumn = joinTuple.RightKeys().Item(i * 2 + 1);
-
+ 
+    for (size_t i = 0; i < joinKeyCount; ++i) { 
+        auto joinLeftLabel = joinTuple.LeftKeys().Item(i * 2); 
+        auto joinLeftColumn = joinTuple.LeftKeys().Item(i * 2 + 1); 
+        auto joinRightLabel = joinTuple.RightKeys().Item(i * 2); 
+        auto joinRightColumn = joinTuple.RightKeys().Item(i * 2 + 1); 
+ 
         if (!rightLabelReps.contains(joinRightLabel) || !leftLabelReps.contains(joinLeftLabel)) {
-            // Join already rewritten, skip opt
-            return false;
-        }
-
+            // Join already rewritten, skip opt 
+            return false; 
+        } 
+ 
         TString leftColumnName = ToString(joinLeftColumn.Value());
-        TString leftMemberName = prefixLeftMembers
-            ? FullColumnName(joinLeftLabel.Value(), joinLeftColumn.Value())
-            : leftColumnName;
-
+        TString leftMemberName = prefixLeftMembers 
+            ? FullColumnName(joinLeftLabel.Value(), joinLeftColumn.Value()) 
+            : leftColumnName; 
+ 
         TString rightColumnName = ToString(joinRightColumn.Value());
-
+ 
         auto keyColumnIdx = lookupTableDesc.GetKeyColumnIndex(rightColumnName);
-        if (!keyColumnIdx) {
-            // Non-key columns in join key currently not supported
-            return false;
-        }
-
+        if (!keyColumnIdx) { 
+            // Non-key columns in join key currently not supported 
+            return false; 
+        } 
+ 
         if (rightKeyColumnsSet.contains(rightColumnName)) {
-            // Can't lookup same column twice
-            return false;
-        }
-
-        leftKeyColumnsSet.insert(leftMemberName);
-        rightKeyColumnsSet.insert(rightColumnName);
-
-        auto leftInput = GetEquiJoinInputList(joinLeftLabel, joinLabels, joinInputs);
-        const TDataExprType* leftData;
-        const TDataExprType* rightData;
+            // Can't lookup same column twice 
+            return false; 
+        } 
+ 
+        leftKeyColumnsSet.insert(leftMemberName); 
+        rightKeyColumnsSet.insert(rightColumnName); 
+ 
+        auto leftInput = GetEquiJoinInputList(joinLeftLabel, joinLabels, joinInputs); 
+        const TDataExprType* leftData; 
+        const TDataExprType* rightData; 
         if (!GetEquiJoinKeyTypes(leftInput, leftColumnName, lookupTableDesc, rightColumnName, leftData, rightData)) {
-            return false;
-        }
-
+            return false; 
+        } 
+ 
         auto value = EquiJoinGetIdxLookupValue(leftData->GetName(), rightData->GetName(), leftRowArg,
-            leftMemberName, joinTuple.Pos(), ctx);
-        if (!value) {
-            return false;
-        }
-
-        keyColumnRanges[*keyColumnIdx] = TColumnRange::MakePoint(value.Cast());
-    }
-
-    for (size_t i = 0; i < keyColumnRanges.size(); ++i) {
+            leftMemberName, joinTuple.Pos(), ctx); 
+        if (!value) { 
+            return false; 
+        } 
+ 
+        keyColumnRanges[*keyColumnIdx] = TColumnRange::MakePoint(value.Cast()); 
+    } 
+ 
+    for (size_t i = 0; i < keyColumnRanges.size(); ++i) { 
         bool leftColumnDefined = keyColumnRanges[i].IsDefined();
         if (leftColumnDefined && rightKeyRange->GetColumnRange(i).IsDefined()) {
-            return false;
+            return false; 
         }
         if (!leftColumnDefined) {
-            keyColumnRanges[i] = rightKeyRange->GetColumnRange(i);
-        }
-
-        YQL_ENSURE(keyColumnRanges[i].IsPoint() || !keyColumnRanges[i].IsDefined());
-    }
-
-    for (size_t i = 0; i < keyColumnRanges.size() - 1; ++i) {
-        if (!keyColumnRanges[i].IsDefined() && keyColumnRanges[i + 1].IsDefined()) {
-            // Invalid lookup key
-            // TODO: Move part of lookup key to residual predicate
-            return false;
-        }
-    }
-
-    TCoAtomList lookupColumns = selectRange.Select();
+            keyColumnRanges[i] = rightKeyRange->GetColumnRange(i); 
+        } 
+ 
+        YQL_ENSURE(keyColumnRanges[i].IsPoint() || !keyColumnRanges[i].IsDefined()); 
+    } 
+ 
+    for (size_t i = 0; i < keyColumnRanges.size() - 1; ++i) { 
+        if (!keyColumnRanges[i].IsDefined() && keyColumnRanges[i + 1].IsDefined()) { 
+            // Invalid lookup key 
+            // TODO: Move part of lookup key to residual predicate 
+            return false; 
+        } 
+    } 
+ 
+    TCoAtomList lookupColumns = selectRange.Select(); 
     bool requireIndexValues = false; // 'true' means that some requested columns are not presented in the index-table,
                                      // so read from data-table is required
     if (indexTable) {
@@ -310,7 +310,7 @@ bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, c
             }
         }
     }
-
+ 
     auto selectedColumns = (indexTable && requireIndexValues)
         ? BuildKeyColumnsList(lookupTableDesc, selectRange.Pos(), ctx)
         : lookupColumns;
@@ -318,83 +318,83 @@ bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, c
     auto lookup = TKikimrKeyRange::BuildReadRangeExpr(lookupTableDesc, TKeyRange(ctx, keyColumnRanges, {}),
                                                       selectedColumns, false /* allowNulls */, ctx);
 
-    // Skip null keys in lookup part as for equijoin semantics null != null,
-    // so we can't have nulls in lookup part
-    lookup = Build<TCoSkipNullMembers>(ctx, joinTuple.Pos())
-        .Input(lookup)
-        .Members()
+    // Skip null keys in lookup part as for equijoin semantics null != null, 
+    // so we can't have nulls in lookup part 
+    lookup = Build<TCoSkipNullMembers>(ctx, joinTuple.Pos()) 
+        .Input(lookup) 
+        .Members() 
             .Add(ConvertToAtoms(rightKeyColumnsSet, ctx, joinTuple.Pos()))
-            .Build()
-        .Done();
-
-    if (rightFilterNull) {
-        lookup = Build<TCoFilterNullMembers>(ctx, joinTuple.Pos())
-            .Input(lookup)
-            .Members(rightFilterNull.Cast().Members())
-            .Done();
-    }
-
-    if (rightSkipNull) {
-        lookup = Build<TCoSkipNullMembers>(ctx, joinTuple.Pos())
-            .Input(lookup)
-            .Members(rightSkipNull.Cast().Members())
-            .Done();
-    }
-
+            .Build() 
+        .Done(); 
+ 
+    if (rightFilterNull) { 
+        lookup = Build<TCoFilterNullMembers>(ctx, joinTuple.Pos()) 
+            .Input(lookup) 
+            .Members(rightFilterNull.Cast().Members()) 
+            .Done(); 
+    } 
+ 
+    if (rightSkipNull) { 
+        lookup = Build<TCoSkipNullMembers>(ctx, joinTuple.Pos()) 
+            .Input(lookup) 
+            .Members(rightSkipNull.Cast().Members()) 
+            .Done(); 
+    } 
+ 
     // If we have index table AND need data from main we cand add this flat map here
     // because lookup is index table and does not have all columns
     if (rightFlatmap && !requireIndexValues) {
-        lookup = Build<TCoFlatMap>(ctx, joinTuple.Pos())
-            .Input(lookup)
-            .Lambda(rightFlatmap.Cast().Lambda())
-            .Done();
-    }
-
-    auto addJoinResults = [&joinLabels, &ctx]
-        (const TExprBase& joinTuple, const TExprBase& rowArg, TVector<TExprBase>& resultTuples,
-            TVector<TString>* resultColumns)
+        lookup = Build<TCoFlatMap>(ctx, joinTuple.Pos()) 
+            .Input(lookup) 
+            .Lambda(rightFlatmap.Cast().Lambda()) 
+            .Done(); 
+    } 
+ 
+    auto addJoinResults = [&joinLabels, &ctx] 
+        (const TExprBase& joinTuple, const TExprBase& rowArg, TVector<TExprBase>& resultTuples, 
+            TVector<TString>* resultColumns) 
     {
-        TVector<std::pair<TString, TString>> joinColumns;
-        if (auto maybeAtom = joinTuple.Maybe<TCoAtom>()) {
-            auto maybeInput = joinLabels.FindInput(maybeAtom.Cast().Value());
-            YQL_ENSURE(maybeInput);
-
-            auto input = *maybeInput;
-
-            for (auto item: input->InputType->GetItems()) {
-                joinColumns.emplace_back(item->GetName(), input->FullName(item->GetName()));
-            }
-        } else {
-            auto columns = GetJoinColumnTypes(joinTuple.Ref(), joinLabels, ctx);
-            for (auto it: joinLabels.Inputs) {
-                for (auto item: it.InputType->GetItems()) {
-                    auto member = item->GetName();
-                    auto column = it.FullName(member);
-
-                    if (columns.FindPtr(column)) {
-                        joinColumns.emplace_back(member, column);
-                    }
-                }
+        TVector<std::pair<TString, TString>> joinColumns; 
+        if (auto maybeAtom = joinTuple.Maybe<TCoAtom>()) { 
+            auto maybeInput = joinLabels.FindInput(maybeAtom.Cast().Value()); 
+            YQL_ENSURE(maybeInput); 
+ 
+            auto input = *maybeInput; 
+
+            for (auto item: input->InputType->GetItems()) { 
+                joinColumns.emplace_back(item->GetName(), input->FullName(item->GetName())); 
+            } 
+        } else { 
+            auto columns = GetJoinColumnTypes(joinTuple.Ref(), joinLabels, ctx); 
+            for (auto it: joinLabels.Inputs) { 
+                for (auto item: it.InputType->GetItems()) { 
+                    auto member = item->GetName(); 
+                    auto column = it.FullName(member); 
+ 
+                    if (columns.FindPtr(column)) { 
+                        joinColumns.emplace_back(member, column); 
+                    } 
+                } 
+            } 
+        } 
+ 
+        for (auto& pair : joinColumns) { 
+            auto& member = pair.first; 
+            auto& column = pair.second; 
+
+            if (resultColumns) { 
+                resultColumns->push_back(column); 
             }
-        }
-
-        for (auto& pair : joinColumns) {
-            auto& member = pair.first;
-            auto& column = pair.second;
-
-            if (resultColumns) {
-                resultColumns->push_back(column);
-            }
-
-            auto tuple = Build<TCoNameValueTuple>(ctx, joinTuple.Pos())
-                .Name().Build(column)
-                .Value<TCoMember>()
-                    .Struct(rowArg)
-                    .Name().Build(joinTuple.Maybe<TCoAtom>() ? member : column)
-                    .Build()
-                .Done();
-
-            resultTuples.emplace_back(std::move(tuple));
+ 
+            auto tuple = Build<TCoNameValueTuple>(ctx, joinTuple.Pos()) 
+                .Name().Build(column) 
+                .Value<TCoMember>() 
+                    .Struct(rowArg) 
+                    .Name().Build(joinTuple.Maybe<TCoAtom>() ? member : column) 
+                    .Build() 
+                .Done(); 
+ 
+            resultTuples.emplace_back(std::move(tuple)); 
         }
     };
 
@@ -416,39 +416,39 @@ bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, c
         }
     };
 
-    auto getJoinResultExpr = [requireIndexValues, &indexTable, &addJoinResults,
-        &injectRightDataKey, &ctx, &joinTuple]
+    auto getJoinResultExpr = [requireIndexValues, &indexTable, &addJoinResults, 
+        &injectRightDataKey, &ctx, &joinTuple] 
         (TMaybeNode<TExprBase> leftRowArg, TMaybeNode<TExprBase> rightRowArg)
     {
         TVector<TString> resultColumns;
         TVector<TExprBase> joinResultTuples;
 
         if (leftRowArg.IsValid()) {
-            addJoinResults(joinTuple.LeftScope(), leftRowArg.Cast(), joinResultTuples, &resultColumns);
+            addJoinResults(joinTuple.LeftScope(), leftRowArg.Cast(), joinResultTuples, &resultColumns); 
         }
 
         if (rightRowArg.IsValid()) {
             if (!requireIndexValues) {
-                addJoinResults(joinTuple.RightScope(), rightRowArg.Cast(), joinResultTuples, &resultColumns);
+                addJoinResults(joinTuple.RightScope(), rightRowArg.Cast(), joinResultTuples, &resultColumns); 
             } else {
                 // we need data from the right table that not contains in the lookup-table (not indexed columns),
                 // so we add reads from the right table
                 YQL_ENSURE(indexTable.IsValid());
                 //TODO: May be it'a a good idea to get some collumns data from the index-read?
                 injectRightDataKey(rightRowArg, joinResultTuples);
-            }
+            } 
         } else {
             YQL_ENSURE(!requireIndexValues);
         }
-
+ 
         auto expr = Build<TCoAsStruct>(ctx, joinTuple.Pos())
-                .Add(joinResultTuples)
-                .Done();
-
+                .Add(joinResultTuples) 
+                .Done(); 
+ 
         return std::make_pair(expr, resultColumns);
     };
 
-    auto finalizeJoinResultExpr = [&joinTuple, &tablesData, &ctx,
+    auto finalizeJoinResultExpr = [&joinTuple, &tablesData, &ctx, 
                                    &selectRange, &addJoinResults, &rightFlatmap, &joinType]
             (const TExprBase& input, const TVector<TString>& finishedColumns, bool needExtraRead)
                 -> NNodes::TExprBase
@@ -490,7 +490,7 @@ bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, c
                 .Done();
         }
 
-        addJoinResults(joinTuple.RightScope(), select, joinResultTuples, nullptr);
+        addJoinResults(joinTuple.RightScope(), select, joinResultTuples, nullptr); 
 
         if (joinType == joinNames.Inner || joinType == joinNames.RightSemi) {
             return Build<TCoFlatMap>(ctx, joinTuple.Pos())
@@ -524,43 +524,43 @@ bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, c
         }
     };
 
-    auto leftExpr = getLeftExpr();
-    TCoArgument rightRowArg = Build<TCoArgument>(ctx, joinTuple.Pos())
-        .Name("rightRow")
-        .Done();
-
+    auto leftExpr = getLeftExpr(); 
+    TCoArgument rightRowArg = Build<TCoArgument>(ctx, joinTuple.Pos()) 
+        .Name("rightRow") 
+        .Done(); 
+ 
     if (joinType == joinNames.Left) {
-        TExprBase rightNothing = Build<TCoNothing>(ctx, joinTuple.Pos())
-            .OptionalType<TCoTypeOf>()
-                .Value<TCoToOptional>()
-                    .List(lookup)
-                    .Build()
-                .Build()
-            .Done();
-
+        TExprBase rightNothing = Build<TCoNothing>(ctx, joinTuple.Pos()) 
+            .OptionalType<TCoTypeOf>() 
+                .Value<TCoToOptional>() 
+                    .List(lookup) 
+                    .Build() 
+                .Build() 
+            .Done(); 
+ 
         auto joinResultExpr = getJoinResultExpr(leftRowArg, rightRowArg);
 
         auto joinMap = Build<TCoFlatMap>(ctx, joinTuple.Pos())
-            .Input(leftExpr)
-            .Lambda()
-                .Args({leftRowArg})
-                .Body<TCoIf>()
-                    .Predicate<TCoHasItems>()
-                        .List(lookup)
-                        .Build()
-                    .ThenValue<TCoMap>()
-                        .Input(lookup)
-                        .Lambda()
-                            .Args({rightRowArg})
+            .Input(leftExpr) 
+            .Lambda() 
+                .Args({leftRowArg}) 
+                .Body<TCoIf>() 
+                    .Predicate<TCoHasItems>() 
+                        .List(lookup) 
+                        .Build() 
+                    .ThenValue<TCoMap>() 
+                        .Input(lookup) 
+                        .Lambda() 
+                            .Args({rightRowArg}) 
                             .Body(joinResultExpr.first)
-                            .Build()
-                        .Build()
-                    .ElseValue<TCoAsList>()
+                            .Build() 
+                        .Build() 
+                    .ElseValue<TCoAsList>() 
                         .Add(getJoinResultExpr(leftRowArg, rightNothing).first)
-                        .Build()
-                    .Build()
-                .Build()
-            .Done();
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Done(); 
         idxLookupExpr = finalizeJoinResultExpr(joinMap, joinResultExpr.second, requireIndexValues);
         return true;
     }
@@ -569,66 +569,66 @@ bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, c
         const auto joinResultExpr = getJoinResultExpr(leftRowArg, rightRowArg);
 
         auto joinMap = Build<TCoFlatMap>(ctx, joinTuple.Pos())
-            .Input<TCoSkipNullMembers>()
-                .Input(leftExpr)
-                .Members()
+            .Input<TCoSkipNullMembers>() 
+                .Input(leftExpr) 
+                .Members() 
                     .Add(ConvertToAtoms(leftKeyColumnsSet, ctx, joinTuple.Pos()))
-                    .Build()
-                .Build()
-            .Lambda()
-                .Args({leftRowArg})
-                .Body<TCoMap>()
-                    .Input(lookup)
-                    .Lambda()
-                        .Args({rightRowArg})
+                    .Build() 
+                .Build() 
+            .Lambda() 
+                .Args({leftRowArg}) 
+                .Body<TCoMap>() 
+                    .Input(lookup) 
+                    .Lambda() 
+                        .Args({rightRowArg}) 
                         .Body(joinResultExpr.first)
-                        .Build()
-                    .Build()
-                .Build()
-            .Done();
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Done(); 
         idxLookupExpr = finalizeJoinResultExpr(joinMap, joinResultExpr.second, requireIndexValues);
         return true;
     }
 
     if (joinType == joinNames.LeftSemi) {
-        idxLookupExpr = Build<TCoFlatMap>(ctx, joinTuple.Pos())
-            .Input<TCoSkipNullMembers>()
-                .Input(leftExpr)
-                .Members()
+        idxLookupExpr = Build<TCoFlatMap>(ctx, joinTuple.Pos()) 
+            .Input<TCoSkipNullMembers>() 
+                .Input(leftExpr) 
+                .Members() 
                     .Add(ConvertToAtoms(leftKeyColumnsSet, ctx, joinTuple.Pos()))
-                    .Build()
-                .Build()
-            .Lambda()
-                .Args({leftRowArg})
-                .Body<TCoOptionalIf>()
-                    .Predicate<TCoHasItems>()
-                        .List(lookup)
-                        .Build()
+                    .Build() 
+                .Build() 
+            .Lambda() 
+                .Args({leftRowArg}) 
+                .Body<TCoOptionalIf>() 
+                    .Predicate<TCoHasItems>() 
+                        .List(lookup) 
+                        .Build() 
                     .Value(getJoinResultExpr(leftRowArg, {}).first)
-                    .Build()
-                .Build()
-            .Done();
+                    .Build() 
+                .Build() 
+            .Done(); 
         return true;
     }
 
     if (joinType == joinNames.LeftOnly) {
-        idxLookupExpr = Build<TCoFlatMap>(ctx, joinTuple.Pos())
-            .Input(leftExpr)
-            .Lambda()
-                .Args({leftRowArg})
-                .Body<TCoOptionalIf>()
-                    .Predicate<TCoNot>()
-                        .Value<TCoHasItems>()
-                            .List(lookup)
-                            .Build()
-                        .Build()
+        idxLookupExpr = Build<TCoFlatMap>(ctx, joinTuple.Pos()) 
+            .Input(leftExpr) 
+            .Lambda() 
+                .Args({leftRowArg}) 
+                .Body<TCoOptionalIf>() 
+                    .Predicate<TCoNot>() 
+                        .Value<TCoHasItems>() 
+                            .List(lookup) 
+                            .Build() 
+                        .Build() 
                     .Value(getJoinResultExpr(leftRowArg, {}).first)
-                    .Build()
-                .Build()
-            .Done();
+                    .Build() 
+                .Build() 
+            .Done(); 
         return true;
-    }
-
+    } 
+ 
     if (joinType == joinNames.RightSemi) {
         // In this case we iterate over left table (with deduplication)
         // and do index-lookup in the right one.
@@ -667,94 +667,94 @@ bool EquiJoinToIdxLookup(TGetExprFunc getLeftExpr, TCoEquiJoinTuple joinTuple, c
 
     YQL_ENSURE(false, "Unexpected join type " << joinType);
     return false;
-}
-
+} 
+ 
 TExprBase GetEquiJoinLabelsNode(const TVector<TString>& labels, TPositionHandle pos, TExprContext& ctx) {
-    TVector<TExprBase> labelAtoms;
-    for (auto& label : labels) {
-        auto atom = Build<TCoAtom>(ctx, pos)
-            .Value(label)
-            .Done();
-        labelAtoms.push_back(atom);
-    }
-
-    if (labelAtoms.size() == 1) {
-        return labelAtoms.front();
-    }
-
-    return Build<TCoAtomList>(ctx, pos)
-        .Add(labelAtoms)
-        .Done();
-}
-
-TCoEquiJoin BuildPairEquiJoin(TCoEquiJoinTuple joinTuple, TExprBase leftList, TExprBase rightList,
-    TExprContext& ctx)
-{
-    TVector<TString> leftLabels;
-    GatherEquiJoinLables(joinTuple.LeftScope(), leftLabels);
-    YQL_ENSURE(!leftLabels.empty());
-
-    TVector<TString> rightLabels;
-    GatherEquiJoinLables(joinTuple.RightScope(), rightLabels);
-    YQL_ENSURE(!rightLabels.empty());
-
-    auto join = Build<TCoEquiJoin>(ctx, joinTuple.Pos())
-        .Add<TCoEquiJoinInput>()
-            .List(leftList)
-            .Scope(GetEquiJoinLabelsNode(leftLabels, joinTuple.Pos(), ctx))
-            .Build()
-        .Add<TCoEquiJoinInput>()
-            .List(rightList)
-            .Scope(GetEquiJoinLabelsNode(rightLabels, joinTuple.Pos(), ctx))
-            .Build()
-        .Add<TCoEquiJoinTuple>()
-            .Type(joinTuple.Type())
-            .LeftScope<TCoAtom>().Build(leftLabels.front())
-            .RightScope<TCoAtom>().Build(rightLabels.front())
-            .LeftKeys(joinTuple.LeftKeys())
-            .RightKeys(joinTuple.RightKeys())
-            .Options(joinTuple.Options())
-            .Build()
-        .Add<TExprList>().Build()
-        .Done();
-
-    return join;
-}
-
+    TVector<TExprBase> labelAtoms; 
+    for (auto& label : labels) { 
+        auto atom = Build<TCoAtom>(ctx, pos) 
+            .Value(label) 
+            .Done(); 
+        labelAtoms.push_back(atom); 
+    } 
+ 
+    if (labelAtoms.size() == 1) { 
+        return labelAtoms.front(); 
+    } 
+ 
+    return Build<TCoAtomList>(ctx, pos) 
+        .Add(labelAtoms) 
+        .Done(); 
+} 
+ 
+TCoEquiJoin BuildPairEquiJoin(TCoEquiJoinTuple joinTuple, TExprBase leftList, TExprBase rightList, 
+    TExprContext& ctx) 
+{ 
+    TVector<TString> leftLabels; 
+    GatherEquiJoinLables(joinTuple.LeftScope(), leftLabels); 
+    YQL_ENSURE(!leftLabels.empty()); 
+ 
+    TVector<TString> rightLabels; 
+    GatherEquiJoinLables(joinTuple.RightScope(), rightLabels); 
+    YQL_ENSURE(!rightLabels.empty()); 
+ 
+    auto join = Build<TCoEquiJoin>(ctx, joinTuple.Pos()) 
+        .Add<TCoEquiJoinInput>() 
+            .List(leftList) 
+            .Scope(GetEquiJoinLabelsNode(leftLabels, joinTuple.Pos(), ctx)) 
+            .Build() 
+        .Add<TCoEquiJoinInput>() 
+            .List(rightList) 
+            .Scope(GetEquiJoinLabelsNode(rightLabels, joinTuple.Pos(), ctx)) 
+            .Build() 
+        .Add<TCoEquiJoinTuple>() 
+            .Type(joinTuple.Type()) 
+            .LeftScope<TCoAtom>().Build(leftLabels.front()) 
+            .RightScope<TCoAtom>().Build(rightLabels.front()) 
+            .LeftKeys(joinTuple.LeftKeys()) 
+            .RightKeys(joinTuple.RightKeys()) 
+            .Options(joinTuple.Options()) 
+            .Build() 
+        .Add<TExprList>().Build() 
+        .Done(); 
+ 
+    return join; 
+} 
+ 
 TExprBase GetEquiJoinTreeExpr(const TExprBase& joinScope, const TVector<TCoEquiJoinInput>& joinInputs,
-    const TJoinLabels& joinLabels, TExprContext& ctx)
-{
-    if (joinScope.Maybe<TCoAtom>()) {
-        return GetEquiJoinInputList(joinScope.Cast<TCoAtom>(), joinLabels, joinInputs);
-    }
-
-    auto joinTree = joinScope.Cast<TCoEquiJoinTuple>();
-
-    TVector<TString> labels;
-    GatherEquiJoinLables(joinTree, labels);
-
-    TVector<TExprBase> newJoinInputs;
-
-    THashSet<ui32> usedIndices;
-    for (auto& label : labels) {
-        auto index = joinLabels.FindInputIndex(label);
-        YQL_ENSURE(index);
-
+    const TJoinLabels& joinLabels, TExprContext& ctx) 
+{ 
+    if (joinScope.Maybe<TCoAtom>()) { 
+        return GetEquiJoinInputList(joinScope.Cast<TCoAtom>(), joinLabels, joinInputs); 
+    } 
+ 
+    auto joinTree = joinScope.Cast<TCoEquiJoinTuple>(); 
+ 
+    TVector<TString> labels; 
+    GatherEquiJoinLables(joinTree, labels); 
+ 
+    TVector<TExprBase> newJoinInputs; 
+ 
+    THashSet<ui32> usedIndices; 
+    for (auto& label : labels) { 
+        auto index = joinLabels.FindInputIndex(label); 
+        YQL_ENSURE(index); 
+ 
         if (!usedIndices.contains(*index)) {
-            newJoinInputs.push_back(joinInputs[*index]);
-            usedIndices.insert(*index);
-        }
-    }
-
-    auto join = Build<TCoEquiJoin>(ctx, joinScope.Pos())
-        .Add(newJoinInputs)
-        .Add(joinTree)
-        .Add<TExprList>().Build()
-        .Done();
-
-    return join;
-}
-
+            newJoinInputs.push_back(joinInputs[*index]); 
+            usedIndices.insert(*index); 
+        } 
+    } 
+ 
+    auto join = Build<TCoEquiJoin>(ctx, joinScope.Pos()) 
+        .Add(newJoinInputs) 
+        .Add(joinTree) 
+        .Add<TExprList>().Build() 
+        .Done(); 
+ 
+    return join; 
+} 
+ 
 TMaybe<TStringBuf> TryFlipJoinType(TStringBuf joinType) {
     if (joinType == TStringBuf("Inner")) {
         return TStringBuf("Inner");
@@ -775,45 +775,45 @@ TMaybe<TStringBuf> TryFlipJoinType(TStringBuf joinType) {
 }
 
 bool RewriteEquiJoinInternal(const TCoEquiJoinTuple& joinTree, const TVector<TCoEquiJoinInput>& joinInputs,
-    const TJoinLabels& joinLabels, const TKikimrTablesData& tablesData, TExprContext& ctx,
+    const TJoinLabels& joinLabels, const TKikimrTablesData& tablesData, TExprContext& ctx, 
     const TKikimrConfiguration& config, TMaybeNode<TExprBase>& rewrittenExpr)
-{
-    bool leftRewritten = false;
-    TMaybeNode<TExprBase> leftExpr;
-    if (!joinTree.LeftScope().Maybe<TCoAtom>()) {
-        leftRewritten = RewriteEquiJoinInternal(joinTree.LeftScope().Cast<TCoEquiJoinTuple>(), joinInputs,
+{ 
+    bool leftRewritten = false; 
+    TMaybeNode<TExprBase> leftExpr; 
+    if (!joinTree.LeftScope().Maybe<TCoAtom>()) { 
+        leftRewritten = RewriteEquiJoinInternal(joinTree.LeftScope().Cast<TCoEquiJoinTuple>(), joinInputs, 
             joinLabels, tablesData, ctx, config, leftExpr);
-    }
-
-    bool rightRewritten = false;
-    TMaybeNode<TExprBase> rightExpr;
-    if (!joinTree.RightScope().Maybe<TCoAtom>()) {
-        rightRewritten = RewriteEquiJoinInternal(joinTree.RightScope().Cast<TCoEquiJoinTuple>(), joinInputs,
+    } 
+ 
+    bool rightRewritten = false; 
+    TMaybeNode<TExprBase> rightExpr; 
+    if (!joinTree.RightScope().Maybe<TCoAtom>()) { 
+        rightRewritten = RewriteEquiJoinInternal(joinTree.RightScope().Cast<TCoEquiJoinTuple>(), joinInputs, 
             joinLabels, tablesData, ctx, config, rightExpr);
-    }
-
-    auto getLeftExpr = [leftRewritten, leftExpr, joinTree, &joinInputs, &joinLabels, &ctx] () {
-        return leftRewritten
-            ? leftExpr.Cast()
-            : GetEquiJoinTreeExpr(joinTree.LeftScope(), joinInputs, joinLabels, ctx);
-    };
-
-    auto getRightExpr = [rightRewritten, rightExpr, joinTree, &joinInputs, &joinLabels, &ctx] () {
-        return rightRewritten
-            ? rightExpr.Cast()
-            : GetEquiJoinTreeExpr(joinTree.RightScope(), joinInputs, joinLabels, ctx);
-    };
-
-    if (!config.HasOptDisableJoinTableLookup()) {
+    } 
+ 
+    auto getLeftExpr = [leftRewritten, leftExpr, joinTree, &joinInputs, &joinLabels, &ctx] () { 
+        return leftRewritten 
+            ? leftExpr.Cast() 
+            : GetEquiJoinTreeExpr(joinTree.LeftScope(), joinInputs, joinLabels, ctx); 
+    }; 
+ 
+    auto getRightExpr = [rightRewritten, rightExpr, joinTree, &joinInputs, &joinLabels, &ctx] () { 
+        return rightRewritten 
+            ? rightExpr.Cast() 
+            : GetEquiJoinTreeExpr(joinTree.RightScope(), joinInputs, joinLabels, ctx); 
+    }; 
+ 
+    if (!config.HasOptDisableJoinTableLookup()) { 
         if (EquiJoinToIdxLookup(getLeftExpr, joinTree, joinLabels, joinInputs, tablesData, ctx, rewrittenExpr)) {
             return true;
         }
 
         bool tryFlip = joinTree.Type().Value() == TStringBuf("LeftSemi")
-            ? !config.HasOptDisableJoinReverseTableLookupLeftSemi()
-            : !config.HasOptDisableJoinReverseTableLookup();
-
-        if (tryFlip) {
+            ? !config.HasOptDisableJoinReverseTableLookupLeftSemi() 
+            : !config.HasOptDisableJoinReverseTableLookup(); 
+ 
+        if (tryFlip) { 
             // try to switch left and right subtrees and do rewrite one more time
             if (auto flipJoinType = TryFlipJoinType(joinTree.Type().Value())) {
                 auto flipJoinTree = Build<TCoEquiJoinTuple>(ctx, joinTree.Pos())
@@ -832,110 +832,110 @@ bool RewriteEquiJoinInternal(const TCoEquiJoinTuple& joinTree, const TVector<TCo
                 }
             }
         }
-    }
-
-    if (leftRewritten || rightRewritten) {
-        rewrittenExpr = BuildPairEquiJoin(joinTree, getLeftExpr(), getRightExpr(), ctx);
-        return true;
-    }
-
-    return false;
-}
-
-} // namespace
-
-TExprBase DeduplicateByMembers(const TExprBase& expr, const TSet<TString>& members, TExprContext& ctx,
-        TPositionHandle pos)
-{
-    auto structArg = Build<TCoArgument>(ctx, pos)
-            .Name("struct")
-            .Done();
-
-    return Build<TCoPartitionByKey>(ctx, pos)
-            .Input(expr)
-            .KeySelectorLambda()
-                .Args(structArg)
-                .Body(ConvertToTuples(members, structArg, ctx, pos))
-                .Build()
-            .SortDirections<TCoVoid>()
-                .Build()
-            .SortKeySelectorLambda<TCoVoid>()
-                .Build()
-            .ListHandlerLambda()
-                .Args({"stream"})
-                .Body<TCoFlatMap>()
-                    .Input("stream")
-                    .Lambda()
-                        .Args({"tuple"})
-                        .Body<TCoTake>()
-                            .Input<TCoNth>()
-                                .Tuple("tuple")
-                                .Index().Value("1").Build()
-                                .Build()
-                            .Count<TCoUint64>()
-                                .Literal().Value("1").Build()
-                                .Build()
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Done();
-}
-
-TExprNode::TPtr KiRewriteEquiJoin(TExprBase node, const TKikimrTablesData& tablesData,
-    const TKikimrConfiguration& config, TExprContext& ctx)
-{
-    if (!node.Maybe<TCoEquiJoin>()) {
-        return node.Ptr();
-    }
-
-    if (config.HasOptDisableJoinRewrite()) {
-        return node.Ptr();
-    }
-
-    auto join = node.Cast<TCoEquiJoin>();
-    auto joinTree = join.Arg(join.ArgCount() - 2).Cast<TCoEquiJoinTuple>();
-
-    TVector<TCoEquiJoinInput> joinInputs;
-    TJoinLabels joinLabels;
-    for (size_t i = 0; i < join.ArgCount() - 2; ++i) {
-        auto input = join.Arg(i).Cast<TCoEquiJoinInput>();
-        joinInputs.push_back(input);
-
+    } 
+ 
+    if (leftRewritten || rightRewritten) { 
+        rewrittenExpr = BuildPairEquiJoin(joinTree, getLeftExpr(), getRightExpr(), ctx); 
+        return true; 
+    } 
+ 
+    return false; 
+} 
+ 
+} // namespace 
+ 
+TExprBase DeduplicateByMembers(const TExprBase& expr, const TSet<TString>& members, TExprContext& ctx, 
+        TPositionHandle pos) 
+{ 
+    auto structArg = Build<TCoArgument>(ctx, pos) 
+            .Name("struct") 
+            .Done(); 
+ 
+    return Build<TCoPartitionByKey>(ctx, pos) 
+            .Input(expr) 
+            .KeySelectorLambda() 
+                .Args(structArg) 
+                .Body(ConvertToTuples(members, structArg, ctx, pos)) 
+                .Build() 
+            .SortDirections<TCoVoid>() 
+                .Build() 
+            .SortKeySelectorLambda<TCoVoid>() 
+                .Build() 
+            .ListHandlerLambda() 
+                .Args({"stream"}) 
+                .Body<TCoFlatMap>() 
+                    .Input("stream") 
+                    .Lambda() 
+                        .Args({"tuple"}) 
+                        .Body<TCoTake>() 
+                            .Input<TCoNth>() 
+                                .Tuple("tuple") 
+                                .Index().Value("1").Build() 
+                                .Build() 
+                            .Count<TCoUint64>() 
+                                .Literal().Value("1").Build() 
+                                .Build() 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Done(); 
+} 
+ 
+TExprNode::TPtr KiRewriteEquiJoin(TExprBase node, const TKikimrTablesData& tablesData, 
+    const TKikimrConfiguration& config, TExprContext& ctx) 
+{ 
+    if (!node.Maybe<TCoEquiJoin>()) { 
+        return node.Ptr(); 
+    } 
+ 
+    if (config.HasOptDisableJoinRewrite()) { 
+        return node.Ptr(); 
+    } 
+ 
+    auto join = node.Cast<TCoEquiJoin>(); 
+    auto joinTree = join.Arg(join.ArgCount() - 2).Cast<TCoEquiJoinTuple>(); 
+ 
+    TVector<TCoEquiJoinInput> joinInputs; 
+    TJoinLabels joinLabels; 
+    for (size_t i = 0; i < join.ArgCount() - 2; ++i) { 
+        auto input = join.Arg(i).Cast<TCoEquiJoinInput>(); 
+        joinInputs.push_back(input); 
+ 
         auto itemType = input.List().Ptr()->GetTypeAnn()->Cast<TListExprType>()->GetItemType();
         joinLabels.Add(ctx, *input.Scope().Ptr(), itemType->Cast<TStructExprType>());
-    }
-
-    TMaybeNode<TExprBase> rewrittenJoin;
+    } 
+ 
+    TMaybeNode<TExprBase> rewrittenJoin; 
     if (!RewriteEquiJoinInternal(joinTree, joinInputs, joinLabels, tablesData, ctx, config, rewrittenJoin)) {
         return node.Ptr();
     }
-
+ 
     YQL_ENSURE(rewrittenJoin.IsValid());
     YQL_CLOG(INFO, ProviderKikimr) << "KiRewriteEquiJoin";
-
+ 
     auto joinOptions = join.Arg(join.ArgCount() - 1).Cast<TExprList>();
-
+ 
     if (rewrittenJoin.Maybe<TCoEquiJoin>()) {
         auto equiJoin = rewrittenJoin.Cast<TCoEquiJoin>();
         return ctx.ChangeChild(*equiJoin.Ptr(), equiJoin.ArgCount() - 1, joinOptions.Ptr());
     }
-
+ 
     TExprBase joinExpr = rewrittenJoin.Cast();
     auto resultType = node.Ptr()->GetTypeAnn()->Cast<TListExprType>()->GetItemType()->Cast<TStructExprType>();
     auto renameMap = LoadJoinRenameMap(*joinOptions.Ptr());
-
+ 
     THashMap<TStringBuf, TStringBuf> reverseRenameMap;
     for (auto& pair : renameMap) {
         for (TStringBuf newName : pair.second) {
             reverseRenameMap[newName] = pair.first;
         }
     }
-
+ 
     TCoArgument rowArg = Build<TCoArgument>(ctx, joinExpr.Pos())
         .Name("row")
         .Done();
-
+ 
     TVector<TExprBase> renameTuples;
     for (auto& item : resultType->GetItems()) {
         TStringBuf newName = item->GetName();
@@ -951,8 +951,8 @@ TExprNode::TPtr KiRewriteEquiJoin(TExprBase node, const TKikimrTablesData& table
             .Done();
 
         renameTuples.push_back(tuple);
-    }
-
+    } 
+ 
     return Build<TCoMap>(ctx, joinExpr.Pos())
         .Input(joinExpr)
         .Lambda()
@@ -963,6 +963,6 @@ TExprNode::TPtr KiRewriteEquiJoin(TExprBase node, const TKikimrTablesData& table
             .Build()
         .Done()
         .Ptr();
-}
-
-} // namespace NYql
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_opt_range.cpp b/ydb/core/kqp/provider/yql_kikimr_opt_range.cpp
index cce81efc42..7333630c21 100644
--- a/ydb/core/kqp/provider/yql_kikimr_opt_range.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_opt_range.cpp
@@ -1,23 +1,23 @@
-#include "yql_kikimr_provider_impl.h"
+#include "yql_kikimr_provider_impl.h" 
 #include "yql_kikimr_opt_utils.h"
-
+ 
 #include <ydb/library/yql/core/common_opt/yql_co_sqlin.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/utils/log/log.h>
 #include <ydb/library/yql/utils/utf8.h>
-
-namespace NYql {
-namespace {
-
-using namespace NNodes;
-using namespace NCommon;
-
+ 
+namespace NYql { 
+namespace { 
+ 
+using namespace NNodes; 
+using namespace NCommon; 
+ 
 struct TTakeNode {
     const TExprBase Input;
     const TExprBase Count;
     const bool IsPartial;
 };
-
+ 
 TTakeNode GetTakeChildren(TExprBase node) {
     if (auto maybeCoTake = node.Maybe<TCoTake>()) {
         auto coTake = maybeCoTake.Cast();
@@ -27,269 +27,269 @@ TTakeNode GetTakeChildren(TExprBase node) {
         return TTakeNode {kiPartialTake.Input(), kiPartialTake.Count(), true};
     }
 }
-
-template<typename T>
-TTableLookup::TCompareResult::TResult CompareValues(const T& left, const T& right) {
-    if (left == right) {
-        return TTableLookup::TCompareResult::Equal;
-    } else {
-        return left > right
-            ? TTableLookup::TCompareResult::Greater
-            : TTableLookup::TCompareResult::Less;
-    }
-}
-
-template<typename T>
-TTableLookup::TCompareResult CompareIntegralNodes(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) {
-    T leftValue = FromString<T>(left.Ref(), slot);
-    T rightValue = FromString<T>(right.Ref(), slot);
-    auto compareResult = CompareValues(leftValue, rightValue);
-
-    TMaybe<bool> adjacent;
-    switch (compareResult) {
-        case TTableLookup::TCompareResult::Equal:
+ 
+template<typename T> 
+TTableLookup::TCompareResult::TResult CompareValues(const T& left, const T& right) { 
+    if (left == right) { 
+        return TTableLookup::TCompareResult::Equal; 
+    } else { 
+        return left > right 
+            ? TTableLookup::TCompareResult::Greater 
+            : TTableLookup::TCompareResult::Less; 
+    } 
+} 
+ 
+template<typename T> 
+TTableLookup::TCompareResult CompareIntegralNodes(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) { 
+    T leftValue = FromString<T>(left.Ref(), slot); 
+    T rightValue = FromString<T>(right.Ref(), slot); 
+    auto compareResult = CompareValues(leftValue, rightValue); 
+ 
+    TMaybe<bool> adjacent; 
+    switch (compareResult) { 
+        case TTableLookup::TCompareResult::Equal: 
+            break; 
+ 
+        case TTableLookup::TCompareResult::Greater: 
+            adjacent = leftValue == rightValue + 1; 
             break;
-
-        case TTableLookup::TCompareResult::Greater:
-            adjacent = leftValue == rightValue + 1;
+ 
+        case TTableLookup::TCompareResult::Less: 
+            adjacent = rightValue == leftValue + 1; 
             break;
-
-        case TTableLookup::TCompareResult::Less:
-            adjacent = rightValue == leftValue + 1;
-            break;
-    }
-
-    return TTableLookup::TCompareResult(compareResult, adjacent);
-}
-
-template<typename T>
-TTableLookup::TCompareResult CompareNodes(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) {
-    T leftValue = FromString<T>(left.Ref(), slot);
-    T rightValue = FromString<T>(right.Ref(), slot);
-    return TTableLookup::TCompareResult(CompareValues(leftValue, rightValue));
-}
-
-template<>
-TTableLookup::TCompareResult CompareNodes<bool>(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) {
-    bool leftValue = FromString<bool>(left.Ref(), slot);
-    bool rightValue = FromString<bool>(right.Ref(), slot);
-    auto compareResult = CompareValues(leftValue, rightValue);
-
-    return TTableLookup::TCompareResult(compareResult);
-}
-
-template<>
-TTableLookup::TCompareResult CompareNodes<ui64>(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) {
-    return CompareIntegralNodes<ui64>(left, right, slot);
-}
-
-template<>
-TTableLookup::TCompareResult CompareNodes<i64>(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) {
-    return CompareIntegralNodes<i64>(left, right, slot);
-}
-
-template<>
-TTableLookup::TCompareResult CompareNodes<TString>(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) {
-    Y_UNUSED(slot);
-
-    const auto& leftValue = left.Value();
-    const auto& rightValue = right.Value();
-    return TTableLookup::TCompareResult(CompareValues(leftValue, rightValue));
-}
-
-} // namespace
-
-bool KiTableLookupCanCompare(TExprBase node) {
-    if (node.Maybe<TCoBool>()) {
-        return true;
-    }
-
-    if (node.Maybe<TCoIntegralCtor>()) {
-        return true;
-    }
-
-    if (node.Maybe<TCoString>()) {
-        return true;
-    }
-
-    if (node.Maybe<TCoUtf8>()) {
-        return true;
-    }
-
-    return false;
-}
-
-TMaybeNode<TExprBase> KiTableLookupGetValue(TExprBase node, const TTypeAnnotationNode* type,
-    TExprContext& ctx)
-{
-    const TTypeAnnotationNode* targetType = type;
-    bool isTargetOptional = false;
-    if (type->GetKind() == ETypeAnnotationKind::Optional) {
-        targetType = type->Cast<TOptionalExprType>()->GetItemType();
-        isTargetOptional = true;
-    }
-
-    if (targetType->GetKind() != ETypeAnnotationKind::Data) {
-        return TMaybeNode<TExprBase>();
-    }
-
-    THashSet<const TExprNode*> knownArgs;
-    bool canPush = true;
-    VisitExpr(node.Ptr(), [&knownArgs, &canPush] (const TExprNode::TPtr& exprNode) {
-        auto node = TExprBase(exprNode);
-
-        if (!canPush) {
-            return false;
-        }
-
-        if (auto maybeLambda = node.Maybe<TCoLambda>()) {
-            for (const auto& arg : maybeLambda.Cast().Args()) {
-                knownArgs.emplace(arg.Raw());
-            }
-        }
-
-        if (auto maybeArg = node.Maybe<TCoArgument>()) {
+    } 
+ 
+    return TTableLookup::TCompareResult(compareResult, adjacent); 
+} 
+ 
+template<typename T> 
+TTableLookup::TCompareResult CompareNodes(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) { 
+    T leftValue = FromString<T>(left.Ref(), slot); 
+    T rightValue = FromString<T>(right.Ref(), slot); 
+    return TTableLookup::TCompareResult(CompareValues(leftValue, rightValue)); 
+} 
+ 
+template<> 
+TTableLookup::TCompareResult CompareNodes<bool>(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) { 
+    bool leftValue = FromString<bool>(left.Ref(), slot); 
+    bool rightValue = FromString<bool>(right.Ref(), slot); 
+    auto compareResult = CompareValues(leftValue, rightValue); 
+ 
+    return TTableLookup::TCompareResult(compareResult); 
+} 
+ 
+template<> 
+TTableLookup::TCompareResult CompareNodes<ui64>(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) { 
+    return CompareIntegralNodes<ui64>(left, right, slot); 
+} 
+ 
+template<> 
+TTableLookup::TCompareResult CompareNodes<i64>(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) { 
+    return CompareIntegralNodes<i64>(left, right, slot); 
+} 
+ 
+template<> 
+TTableLookup::TCompareResult CompareNodes<TString>(TCoAtom left, TCoAtom right, NKikimr::NUdf::EDataSlot slot) { 
+    Y_UNUSED(slot); 
+ 
+    const auto& leftValue = left.Value(); 
+    const auto& rightValue = right.Value(); 
+    return TTableLookup::TCompareResult(CompareValues(leftValue, rightValue)); 
+} 
+ 
+} // namespace 
+ 
+bool KiTableLookupCanCompare(TExprBase node) { 
+    if (node.Maybe<TCoBool>()) { 
+        return true; 
+    } 
+ 
+    if (node.Maybe<TCoIntegralCtor>()) { 
+        return true; 
+    } 
+ 
+    if (node.Maybe<TCoString>()) { 
+        return true; 
+    } 
+ 
+    if (node.Maybe<TCoUtf8>()) { 
+        return true; 
+    } 
+ 
+    return false; 
+} 
+ 
+TMaybeNode<TExprBase> KiTableLookupGetValue(TExprBase node, const TTypeAnnotationNode* type, 
+    TExprContext& ctx) 
+{ 
+    const TTypeAnnotationNode* targetType = type; 
+    bool isTargetOptional = false; 
+    if (type->GetKind() == ETypeAnnotationKind::Optional) { 
+        targetType = type->Cast<TOptionalExprType>()->GetItemType(); 
+        isTargetOptional = true; 
+    } 
+ 
+    if (targetType->GetKind() != ETypeAnnotationKind::Data) { 
+        return TMaybeNode<TExprBase>(); 
+    } 
+ 
+    THashSet<const TExprNode*> knownArgs; 
+    bool canPush = true; 
+    VisitExpr(node.Ptr(), [&knownArgs, &canPush] (const TExprNode::TPtr& exprNode) { 
+        auto node = TExprBase(exprNode); 
+ 
+        if (!canPush) { 
+            return false; 
+        } 
+ 
+        if (auto maybeLambda = node.Maybe<TCoLambda>()) { 
+            for (const auto& arg : maybeLambda.Cast().Args()) { 
+                knownArgs.emplace(arg.Raw()); 
+            } 
+        } 
+ 
+        if (auto maybeArg = node.Maybe<TCoArgument>()) { 
             if (!knownArgs.contains(maybeArg.Cast().Raw())) {
-                canPush = false;
-                return false;
-            }
-        }
-
-        if (auto maybeCallable = node.Maybe<TCallable>()) {
-            auto callable = maybeCallable.Cast();
-
+                canPush = false; 
+                return false; 
+            } 
+        } 
+ 
+        if (auto maybeCallable = node.Maybe<TCallable>()) { 
+            auto callable = maybeCallable.Cast(); 
+ 
             if (KikimrKqlFunctions().contains(callable.CallableName())) {
-                if (callable.Maybe<TKiSelectRow>()) {
-                    return true;
-                }
-
-                if (callable.Maybe<TKiSelectRange>()) {
-                    return true;
-                }
-
-                canPush = false;
-                return false;
-            }
-        }
-
-        return true;
-    });
-
-    if (!canPush) {
-        return TMaybeNode<TExprBase>();
-    }
-
+                if (callable.Maybe<TKiSelectRow>()) { 
+                    return true; 
+                } 
+ 
+                if (callable.Maybe<TKiSelectRange>()) { 
+                    return true; 
+                } 
+ 
+                canPush = false; 
+                return false; 
+            } 
+        } 
+ 
+        return true; 
+    }); 
+ 
+    if (!canPush) { 
+        return TMaybeNode<TExprBase>(); 
+    } 
+ 
     const auto& dataTypeName = targetType->Cast<TDataExprType>()->GetName();
-
-    TExprBase valueNode = node;
-    if (isTargetOptional) {
-        if (auto maybeJust = node.Maybe<TCoJust>()) {
-            valueNode = maybeJust.Cast().Input();
-        }
-
-        if (node.Maybe<TCoNothing>()) {
-            return Build<TCoNothing>(ctx, node.Pos())
-                .OptionalType(ExpandType(node.Pos(), *type, ctx))
-                .Done()
-                .Ptr();
-        }
-    }
-
-    TExprNode::TPtr literal;
-    if (auto maybeInt = valueNode.Maybe<TCoIntegralCtor>()) {
-        if (maybeInt.Cast().CallableName() == dataTypeName) {
-            return valueNode;
-        }
-
+ 
+    TExprBase valueNode = node; 
+    if (isTargetOptional) { 
+        if (auto maybeJust = node.Maybe<TCoJust>()) { 
+            valueNode = maybeJust.Cast().Input(); 
+        } 
+ 
+        if (node.Maybe<TCoNothing>()) { 
+            return Build<TCoNothing>(ctx, node.Pos()) 
+                .OptionalType(ExpandType(node.Pos(), *type, ctx)) 
+                .Done() 
+                .Ptr(); 
+        } 
+    } 
+ 
+    TExprNode::TPtr literal; 
+    if (auto maybeInt = valueNode.Maybe<TCoIntegralCtor>()) { 
+        if (maybeInt.Cast().CallableName() == dataTypeName) { 
+            return valueNode; 
+        } 
+ 
         if (AllowIntegralConversion(maybeInt.Cast(), false, NKikimr::NUdf::GetDataSlot(dataTypeName))) {
-            literal = maybeInt.Cast().Literal().Ptr();
-        }
-    }
-
-    if (auto maybeString = valueNode.Maybe<TCoString>()) {
-        if (dataTypeName == "String") {
-            return valueNode;
-        }
-
-        if (dataTypeName == "Utf8") {
-            auto atom = maybeString.Cast().Literal();
-            auto value = atom.Value();
+            literal = maybeInt.Cast().Literal().Ptr(); 
+        } 
+    } 
+ 
+    if (auto maybeString = valueNode.Maybe<TCoString>()) { 
+        if (dataTypeName == "String") { 
+            return valueNode; 
+        } 
+ 
+        if (dataTypeName == "Utf8") { 
+            auto atom = maybeString.Cast().Literal(); 
+            auto value = atom.Value(); 
             if (!IsUtf8(value)) {
-                return {};
-            }
-
-            literal = atom.Ptr();
-        }
-    }
-
-    if (auto maybeUtf8 = valueNode.Maybe<TCoUtf8>()) {
-        if (dataTypeName == "String" || dataTypeName == "Utf8") {
-            literal = maybeUtf8.Cast().Literal().Ptr();
-        }
-    }
-
-    if (auto maybeBool = valueNode.Maybe<TCoBool>()) {
-        if (dataTypeName == "Bool") {
-            literal = maybeBool.Cast().Literal().Ptr();
-        }
-    }
-
-    if (literal) {
-        auto ret = ctx.Builder(valueNode.Pos())
-            .Callable(dataTypeName)
-                .Add(0, literal)
-                .Seal()
-            .Build();
-
-        return ret;
-    }
-
+                return {}; 
+            } 
+ 
+            literal = atom.Ptr(); 
+        } 
+    } 
+ 
+    if (auto maybeUtf8 = valueNode.Maybe<TCoUtf8>()) { 
+        if (dataTypeName == "String" || dataTypeName == "Utf8") { 
+            literal = maybeUtf8.Cast().Literal().Ptr(); 
+        } 
+    } 
+ 
+    if (auto maybeBool = valueNode.Maybe<TCoBool>()) { 
+        if (dataTypeName == "Bool") { 
+            literal = maybeBool.Cast().Literal().Ptr(); 
+        } 
+    } 
+ 
+    if (literal) { 
+        auto ret = ctx.Builder(valueNode.Pos()) 
+            .Callable(dataTypeName) 
+                .Add(0, literal) 
+                .Seal() 
+            .Build(); 
+ 
+        return ret; 
+    } 
+ 
     auto valueType = valueNode.Ref().GetTypeAnn();
-    if (isTargetOptional && valueType->GetKind() == ETypeAnnotationKind::Optional) {
-        valueType = valueType->Cast<TOptionalExprType>()->GetItemType();
-    }
-
-    if (valueType->GetKind() == ETypeAnnotationKind::Data &&
+    if (isTargetOptional && valueType->GetKind() == ETypeAnnotationKind::Optional) { 
+        valueType = valueType->Cast<TOptionalExprType>()->GetItemType(); 
+    } 
+ 
+    if (valueType->GetKind() == ETypeAnnotationKind::Data && 
         valueType->Cast<TDataExprType>()->GetName() == dataTypeName)
-    {
-        return node;
-    }
-
-    return Build<TCoConvert>(ctx, node.Pos())
-        .Input(node)
-        .Type().Build(dataTypeName)
-        .Done();
-}
-
-TTableLookup::TCompareResult KiTableLookupCompare(TExprBase left, TExprBase right) {
-    if (left.Maybe<TCoBool>() && right.Maybe<TCoBool>()) {
-        return CompareNodes<bool>(left.Cast<TCoBool>().Literal(),
-            right.Cast<TCoBool>().Literal(), NKikimr::NUdf::EDataSlot::Bool);
-    }
-
-    if (left.Maybe<TCoUint64>() && right.Maybe<TCoUint64>()) {
-        return CompareNodes<ui64>(left.Cast<TCoUint64>().Literal(),
-            right.Cast<TCoUint64>().Literal(), NKikimr::NUdf::EDataSlot::Uint64);
-    }
-
-    if (left.Maybe<TCoIntegralCtor>() && right.Maybe<TCoIntegralCtor>()) {
-        return CompareNodes<i64>(left.Cast<TCoIntegralCtor>().Literal(),
-            right.Cast<TCoIntegralCtor>().Literal(), NKikimr::NUdf::EDataSlot::Int64);
-    }
-
-    if (left.Maybe<TCoString>() && right.Maybe<TCoString>() ||
-        left.Maybe<TCoUtf8>() && right.Maybe<TCoUtf8>())
-    {
-        return CompareNodes<TString>(left.Cast<TCoDataCtor>().Literal(),
-            right.Cast<TCoDataCtor>().Literal(), NKikimr::NUdf::EDataSlot::String);
-    }
-
-    YQL_ENSURE(false, "Unexpected nodes in Kikimr TableLookupCompare: (" << left.Ref().Content()
-        << ", " << right.Ref().Content() << ")");
-}
-
-
-TExprNode::TPtr KiApplyLimitToSelectRange(TExprBase node, TExprContext& ctx) {
+    { 
+        return node; 
+    } 
+ 
+    return Build<TCoConvert>(ctx, node.Pos()) 
+        .Input(node) 
+        .Type().Build(dataTypeName) 
+        .Done(); 
+} 
+ 
+TTableLookup::TCompareResult KiTableLookupCompare(TExprBase left, TExprBase right) { 
+    if (left.Maybe<TCoBool>() && right.Maybe<TCoBool>()) { 
+        return CompareNodes<bool>(left.Cast<TCoBool>().Literal(), 
+            right.Cast<TCoBool>().Literal(), NKikimr::NUdf::EDataSlot::Bool); 
+    } 
+ 
+    if (left.Maybe<TCoUint64>() && right.Maybe<TCoUint64>()) { 
+        return CompareNodes<ui64>(left.Cast<TCoUint64>().Literal(), 
+            right.Cast<TCoUint64>().Literal(), NKikimr::NUdf::EDataSlot::Uint64); 
+    } 
+ 
+    if (left.Maybe<TCoIntegralCtor>() && right.Maybe<TCoIntegralCtor>()) { 
+        return CompareNodes<i64>(left.Cast<TCoIntegralCtor>().Literal(), 
+            right.Cast<TCoIntegralCtor>().Literal(), NKikimr::NUdf::EDataSlot::Int64); 
+    } 
+ 
+    if (left.Maybe<TCoString>() && right.Maybe<TCoString>() || 
+        left.Maybe<TCoUtf8>() && right.Maybe<TCoUtf8>()) 
+    { 
+        return CompareNodes<TString>(left.Cast<TCoDataCtor>().Literal(), 
+            right.Cast<TCoDataCtor>().Literal(), NKikimr::NUdf::EDataSlot::String); 
+    } 
+ 
+    YQL_ENSURE(false, "Unexpected nodes in Kikimr TableLookupCompare: (" << left.Ref().Content() 
+        << ", " << right.Ref().Content() << ")"); 
+} 
+ 
+
+TExprNode::TPtr KiApplyLimitToSelectRange(TExprBase node, TExprContext& ctx) { 
     if (!node.Maybe<TCoTake>() && !node.Maybe<TKiPartialTake>()) {
         return node.Ptr();
     }
@@ -298,65 +298,65 @@ TExprNode::TPtr KiApplyLimitToSelectRange(TExprBase node, TExprContext& ctx) {
 
     if (!takeNode.Input.Maybe<TCoSkip>().Input().Maybe<TKiSelectRangeBase>() &&
         !takeNode.Input.Maybe<TKiSelectRangeBase>())
-    {
-        return node.Ptr();
-    }
-
+    { 
+        return node.Ptr(); 
+    } 
+ 
     auto maybeSkip = takeNode.Input.Maybe<TCoSkip>();
-    TMaybeNode<TExprBase> limitValue;
-
+    TMaybeNode<TExprBase> limitValue; 
+ 
     if (auto maybeTakeCount = takeNode.Count.Maybe<TCoUint64>()) {
-        ui64 totalLimit;
-        auto takeValue = FromString<ui64>(maybeTakeCount.Cast().Literal().Value());
-
-        if (maybeSkip) {
-            if (auto maybeSkipCount = maybeSkip.Count().Maybe<TCoUint64>()) {
-                auto skipValue = FromString<ui64>(maybeSkipCount.Cast().Literal().Value());
-                totalLimit = takeValue + skipValue;
-            } else {
-                return node.Ptr();
-            }
-        } else {
-            totalLimit = takeValue;
-        }
-
-        limitValue = Build<TCoUint64>(ctx, node.Pos())
-            .Literal<TCoAtom>()
-                .Value(ToString(totalLimit))
-                .Build()
-            .Done();
-    } else {
+        ui64 totalLimit; 
+        auto takeValue = FromString<ui64>(maybeTakeCount.Cast().Literal().Value()); 
+ 
+        if (maybeSkip) { 
+            if (auto maybeSkipCount = maybeSkip.Count().Maybe<TCoUint64>()) { 
+                auto skipValue = FromString<ui64>(maybeSkipCount.Cast().Literal().Value()); 
+                totalLimit = takeValue + skipValue; 
+            } else { 
+                return node.Ptr(); 
+            } 
+        } else { 
+            totalLimit = takeValue; 
+        } 
+ 
+        limitValue = Build<TCoUint64>(ctx, node.Pos()) 
+            .Literal<TCoAtom>() 
+                .Value(ToString(totalLimit)) 
+                .Build() 
+            .Done(); 
+    } else { 
         limitValue = takeNode.Count;
-        if (maybeSkip) {
-            limitValue = Build<TCoPlus>(ctx, node.Pos())
-                .Left(limitValue.Cast())
-                .Right(maybeSkip.Cast().Count())
-                .Done();
-        }
-    }
-
-    YQL_ENSURE(limitValue);
-
+        if (maybeSkip) { 
+            limitValue = Build<TCoPlus>(ctx, node.Pos()) 
+                .Left(limitValue.Cast()) 
+                .Right(maybeSkip.Cast().Count()) 
+                .Done(); 
+        } 
+    } 
+ 
+    YQL_ENSURE(limitValue); 
+ 
     auto input = maybeSkip
         ? takeNode.Input.Cast<TCoSkip>().Input()
         : takeNode.Input;
-
+ 
     bool isIndexRange = input.Maybe<TKiSelectIndexRange>().IsValid();
 
     auto select = input.Cast<TKiSelectRangeBase>();
 
     if (HasSetting(select.Settings().Ref(), "ItemsLimit")) {
-        return node.Ptr();
-    }
-
-    auto newSettings = Build<TCoNameValueTupleList>(ctx, select.Settings().Pos())
-        .Add(TVector<TExprBase>(select.Settings().begin(), select.Settings().end()))
-        .Add<TCoNameValueTuple>()
-            .Name().Build("ItemsLimit")
-            .Value(limitValue)
-            .Build()
-        .Done();
-
+        return node.Ptr(); 
+    } 
+ 
+    auto newSettings = Build<TCoNameValueTupleList>(ctx, select.Settings().Pos()) 
+        .Add(TVector<TExprBase>(select.Settings().begin(), select.Settings().end())) 
+        .Add<TCoNameValueTuple>() 
+            .Name().Build("ItemsLimit") 
+            .Value(limitValue) 
+            .Build() 
+        .Done(); 
+ 
     TExprNode::TPtr newSelect;
     if (isIndexRange) {
         newSelect = Build<TKiSelectIndexRange>(ctx, select.Pos())
@@ -378,10 +378,10 @@ TExprNode::TPtr KiApplyLimitToSelectRange(TExprBase node, TExprContext& ctx) {
             .Done()
             .Ptr();
     }
-
-    YQL_CLOG(INFO, ProviderKikimr) << "KiApplyLimitToSelectRange";
-
-    if (maybeSkip) {
+ 
+    YQL_CLOG(INFO, ProviderKikimr) << "KiApplyLimitToSelectRange"; 
+ 
+    if (maybeSkip) { 
         if (takeNode.IsPartial) {
             return Build<TKiPartialTake>(ctx, node.Pos())
                 .Input<TCoSkip>()
@@ -402,7 +402,7 @@ TExprNode::TPtr KiApplyLimitToSelectRange(TExprBase node, TExprContext& ctx) {
     } else {
         if (takeNode.IsPartial) {
             return Build<TKiPartialTake>(ctx, node.Pos())
-                .Input(newSelect)
+                .Input(newSelect) 
                 .Count(takeNode.Count)
                 .Done().Ptr();
 
@@ -412,9 +412,9 @@ TExprNode::TPtr KiApplyLimitToSelectRange(TExprBase node, TExprContext& ctx) {
                 .Count(takeNode.Count)
                 .Done().Ptr();
         }
-    }
-}
-
+    } 
+} 
+ 
 TExprNode::TPtr BuildFallbackSelectRange(TCoFlatMap oldFlatMap,
     TKiSelectRangeBase select, TMaybeNode<TCoFilterNullMembers> filterNull,
     TMaybeNode<TCoSkipNullMembers> skipNull, const TKikimrTableDescription& tableDesc,
@@ -455,55 +455,55 @@ TExprNode::TPtr BuildFallbackSelectRange(TCoFlatMap oldFlatMap,
         .Ptr();
 }
 
-TExprNode::TPtr KiPushPredicateToSelectRange(TExprBase node, TExprContext& ctx,
-    const TKikimrTablesData& tablesData, const TKikimrConfiguration& config)
-{
-    if (!node.Maybe<TCoFlatMap>()) {
-        return node.Ptr();
-    }
-    auto flatmap = node.Cast<TCoFlatMap>();
-
-    if (!IsPredicateFlatMap(flatmap.Lambda().Body().Ref())) {
-        return node.Ptr();
-    }
-
+TExprNode::TPtr KiPushPredicateToSelectRange(TExprBase node, TExprContext& ctx, 
+    const TKikimrTablesData& tablesData, const TKikimrConfiguration& config) 
+{ 
+    if (!node.Maybe<TCoFlatMap>()) { 
+        return node.Ptr(); 
+    } 
+    auto flatmap = node.Cast<TCoFlatMap>(); 
+ 
+    if (!IsPredicateFlatMap(flatmap.Lambda().Body().Ref())) { 
+        return node.Ptr(); 
+    } 
+ 
     TMaybeNode<TKiSelectRangeBase> select;
-    TMaybeNode<TCoFilterNullMembers> filterNull;
-    TMaybeNode<TCoSkipNullMembers> skipNull;
+    TMaybeNode<TCoFilterNullMembers> filterNull; 
+    TMaybeNode<TCoSkipNullMembers> skipNull; 
     TMaybeNode<TCoAtom> indexTable;
-
+ 
     if (auto maybeRange = flatmap.Input().Maybe<TKiSelectRangeBase>()) {
-        select = maybeRange.Cast();
-    }
-
+        select = maybeRange.Cast(); 
+    } 
+ 
     if (auto maybeRange = flatmap.Input().Maybe<TCoFilterNullMembers>().Input().Maybe<TKiSelectRangeBase>()) {
-        select = maybeRange.Cast();
-        filterNull = flatmap.Input().Cast<TCoFilterNullMembers>();
-    }
-
+        select = maybeRange.Cast(); 
+        filterNull = flatmap.Input().Cast<TCoFilterNullMembers>(); 
+    } 
+ 
     if (auto maybeRange = flatmap.Input().Maybe<TCoSkipNullMembers>().Input().Maybe<TKiSelectRangeBase>()) {
-        select = maybeRange.Cast();
-        skipNull = flatmap.Input().Cast<TCoSkipNullMembers>();
-    }
-
-    if (!select) {
-        return node.Ptr();
-    }
-
+        select = maybeRange.Cast(); 
+        skipNull = flatmap.Input().Cast<TCoSkipNullMembers>(); 
+    } 
+ 
+    if (!select) { 
+        return node.Ptr(); 
+    } 
+ 
     if (auto indexSelect = select.Maybe<TKiSelectIndexRange>()) {
         indexTable = indexSelect.Cast().IndexName();
     }
 
-    auto selectRange = select.Cast();
+    auto selectRange = select.Cast(); 
     const auto& cluster = TString(selectRange.Cluster());
 
     const auto& lookupTableName = indexTable ? TString(indexTable.Cast()) : TString(selectRange.Table().Path());
     auto& lookupTableDesc = tablesData.ExistingTable(cluster, lookupTableName);
-
-    if (!TKikimrKeyRange::IsFull(selectRange.Range())) {
-        return node.Ptr();
-    }
-
+ 
+    if (!TKikimrKeyRange::IsFull(selectRange.Range())) { 
+        return node.Ptr(); 
+    } 
+ 
     if (indexTable) {
         bool needDataRead = false;
         for (const auto& col : selectRange.Select()) {
@@ -520,15 +520,15 @@ TExprNode::TPtr KiPushPredicateToSelectRange(TExprBase node, TExprContext& ctx,
         }
     }
 
-    auto row = flatmap.Lambda().Args().Arg(0);
-    auto predicate = TExprBase(flatmap.Lambda().Body().Ref().ChildPtr(0));
+    auto row = flatmap.Lambda().Args().Arg(0); 
+    auto predicate = TExprBase(flatmap.Lambda().Body().Ref().ChildPtr(0)); 
     TTableLookup lookup = ExtractTableLookup(row, predicate, lookupTableDesc.Metadata->KeyColumnNames,
-        &KiTableLookupGetValue, &KiTableLookupCanCompare, &KiTableLookupCompare, ctx,
-        config.HasAllowNullCompareInIndex());
-
+        &KiTableLookupGetValue, &KiTableLookupCanCompare, &KiTableLookupCompare, ctx, 
+        config.HasAllowNullCompareInIndex()); 
+ 
     auto& dataTableDesc = tablesData.ExistingTable(cluster, TString(selectRange.Table().Path()));
 
-    if (lookup.IsFullScan()) {
+    if (lookup.IsFullScan()) { 
         // WARNING: Sometimes we want to check index table usage here.
         // Ok, but we must be aware about other optimizations.
         // Example SqlIn using secondary index rewriten to EquiJoin on
@@ -539,20 +539,20 @@ TExprNode::TPtr KiPushPredicateToSelectRange(TExprBase node, TExprContext& ctx,
         // EquiJoin optimization has bot been made yet.
         // See KIKIMR-11041 for more examples and consider KiRewriteSelectIndexRange method
 
-        return node.Ptr();
-    }
-
-    TVector<TExprBase> fetches;
-
-    for (auto& keyRange : lookup.GetKeyRanges()) {
-        TExprBase predicate = keyRange.GetResidualPredicate()
-            ? keyRange.GetResidualPredicate().Cast()
-            : Build<TCoBool>(ctx, node.Pos())
-                .Literal().Build("true")
-                .Done();
-
-        auto newBody = ctx.ChangeChild(flatmap.Lambda().Body().Ref(), 0, predicate.Ptr());
-
+        return node.Ptr(); 
+    } 
+ 
+    TVector<TExprBase> fetches; 
+
+    for (auto& keyRange : lookup.GetKeyRanges()) { 
+        TExprBase predicate = keyRange.GetResidualPredicate() 
+            ? keyRange.GetResidualPredicate().Cast() 
+            : Build<TCoBool>(ctx, node.Pos()) 
+                .Literal().Build("true") 
+                .Done(); 
+ 
+        auto newBody = ctx.ChangeChild(flatmap.Lambda().Body().Ref(), 0, predicate.Ptr()); 
+ 
         TExprNode::TPtr input;
 
         if (indexTable) {
@@ -603,203 +603,203 @@ TExprNode::TPtr KiPushPredicateToSelectRange(TExprBase node, TExprContext& ctx,
                 .Ptr();
         }
 
-        auto fetch = Build<TCoFlatMap>(ctx, node.Pos())
-            .Input(input)
-            .Lambda()
-                .Args({"item"})
-                .Body<TExprApplier>()
-                    .Apply(TExprBase(newBody))
-                    .With(flatmap.Lambda().Args().Arg(0), "item")
-                    .Build()
-                .Build()
-            .Done();
-
-        fetches.push_back(fetch);
-    }
-
-    YQL_CLOG(INFO, ProviderKikimr) << "KiPushPredicateToSelectRange";
-    return Build<TCoExtend>(ctx, node.Pos())
-        .Add(fetches)
-        .Done()
-        .Ptr();
-}
-
-TExprNode::TPtr KiApplyExtractMembersToSelectRow(TExprBase node, TExprContext& ctx) {
-    if (!node.Maybe<TCoExtractMembers>().Input().Maybe<TKiSelectRow>()) {
-        return node.Ptr();
-    }
-
-    auto extract = node.Cast<TCoExtractMembers>();
-    auto selectRow = extract.Input().Cast<TKiSelectRow>();
-    auto input = extract.Input();
-
-    YQL_CLOG(INFO, ProviderKikimr) << "KiApplyExtractMembersToSelectRow";
-    return Build<TKiSelectRow>(ctx, node.Pos())
-        .Cluster(selectRow.Cluster())
-        .Table(selectRow.Table())
-        .Key(selectRow.Key())
-        .Select(extract.Members())
-        .Done().Ptr();
-}
-
+        auto fetch = Build<TCoFlatMap>(ctx, node.Pos()) 
+            .Input(input) 
+            .Lambda() 
+                .Args({"item"}) 
+                .Body<TExprApplier>() 
+                    .Apply(TExprBase(newBody)) 
+                    .With(flatmap.Lambda().Args().Arg(0), "item") 
+                    .Build() 
+                .Build() 
+            .Done(); 
+ 
+        fetches.push_back(fetch); 
+    } 
+ 
+    YQL_CLOG(INFO, ProviderKikimr) << "KiPushPredicateToSelectRange"; 
+    return Build<TCoExtend>(ctx, node.Pos()) 
+        .Add(fetches) 
+        .Done() 
+        .Ptr(); 
+} 
+ 
+TExprNode::TPtr KiApplyExtractMembersToSelectRow(TExprBase node, TExprContext& ctx) { 
+    if (!node.Maybe<TCoExtractMembers>().Input().Maybe<TKiSelectRow>()) { 
+        return node.Ptr(); 
+    } 
+ 
+    auto extract = node.Cast<TCoExtractMembers>(); 
+    auto selectRow = extract.Input().Cast<TKiSelectRow>(); 
+    auto input = extract.Input(); 
+ 
+    YQL_CLOG(INFO, ProviderKikimr) << "KiApplyExtractMembersToSelectRow"; 
+    return Build<TKiSelectRow>(ctx, node.Pos()) 
+        .Cluster(selectRow.Cluster()) 
+        .Table(selectRow.Table()) 
+        .Key(selectRow.Key()) 
+        .Select(extract.Members()) 
+        .Done().Ptr(); 
+} 
+ 
 TKikimrKeyRange::TKikimrKeyRange(TExprContext& ctx, const TKikimrTableDescription& table)
-    : Table(table)
+    : Table(table) 
     , KeyRange(ctx, Table.Metadata->KeyColumnNames.size(), TMaybeNode<TExprBase>())
 {}
-
-TKikimrKeyRange::TKikimrKeyRange(const TKikimrTableDescription& table, const TKeyRange& keyRange)
-    : Table(table)
-    , KeyRange(keyRange)
-{
-    YQL_ENSURE(Table.Metadata->KeyColumnNames.size() == KeyRange.GetColumnRangesCount());
-}
-
-bool TKikimrKeyRange::IsFull(TExprList list) {
-    for (auto node : list) {
-        if (auto maybeColumnRange = node.Maybe<TKiColumnRangeTuple>()) {
-            auto columnRange = maybeColumnRange.Cast();
-
-            if (!columnRange.From().Maybe<TCoNothing>()) {
-                return false;
-            }
-
-            if (!columnRange.To().Maybe<TCoVoid>()) {
-                return false;
-            }
-        }
-
-        if (auto maybeAtom = node.Maybe<TCoAtom>()) {
-            auto atom = maybeAtom.Cast();
-
-            if (atom.Value() != "IncFrom" && atom.Value() != "IncTo") {
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
+ 
+TKikimrKeyRange::TKikimrKeyRange(const TKikimrTableDescription& table, const TKeyRange& keyRange) 
+    : Table(table) 
+    , KeyRange(keyRange) 
+{ 
+    YQL_ENSURE(Table.Metadata->KeyColumnNames.size() == KeyRange.GetColumnRangesCount()); 
+} 
+ 
+bool TKikimrKeyRange::IsFull(TExprList list) { 
+    for (auto node : list) { 
+        if (auto maybeColumnRange = node.Maybe<TKiColumnRangeTuple>()) { 
+            auto columnRange = maybeColumnRange.Cast(); 
+ 
+            if (!columnRange.From().Maybe<TCoNothing>()) { 
+                return false; 
+            } 
+ 
+            if (!columnRange.To().Maybe<TCoVoid>()) { 
+                return false; 
+            } 
+        } 
+ 
+        if (auto maybeAtom = node.Maybe<TCoAtom>()) { 
+            auto atom = maybeAtom.Cast(); 
+ 
+            if (atom.Value() != "IncFrom" && atom.Value() != "IncTo") { 
+                return false; 
+            } 
+        } 
+    } 
+ 
+    return true; 
+} 
+ 
 TMaybe<TKeyRange> TKikimrKeyRange::GetPointKeyRange(TExprContext& ctx, const TKikimrTableDescription& table, TExprList range) {
-    size_t keyColumnsCount = table.Metadata->KeyColumnNames.size();
-    TVector<TMaybeNode<TExprBase>> fromValues(keyColumnsCount);
-    TVector<TMaybeNode<TExprBase>> toValues(keyColumnsCount);
-    bool incFrom = false;
-    bool incTo = false;
-
-    for (auto node : range) {
-        if (auto maybeColumnRange = node.Maybe<TKiColumnRangeTuple>()) {
-            auto columnRange = maybeColumnRange.Cast();
-
-            auto idx = table.GetKeyColumnIndex(TString(columnRange.Column()));
-            YQL_ENSURE(idx);
-
-            fromValues[*idx] = columnRange.From();
-            toValues[*idx] = columnRange.To();
-        }
-
-        if (auto maybeAtom = node.Maybe<TCoAtom>()) {
-            auto value = maybeAtom.Cast().Value();
-
-            if (value == "IncFrom") {
-                incFrom = true;
-            }
-
-            if (value == "IncTo") {
-                incTo = true;
-            }
-        }
-    }
-
-    if (!incFrom || !incTo) {
-        return {};
-    }
-
-    TVector<TColumnRange> columnRanges(keyColumnsCount);
-    for (size_t i = 0; i < keyColumnsCount; ++i) {
-        YQL_ENSURE(fromValues[i]);
-        YQL_ENSURE(toValues[i]);
-
-        if (!fromValues[i].Maybe<TCoVoid>() && !toValues[i].Maybe<TCoVoid>()) {
-            if (fromValues[i].Cast().Raw() != toValues[i].Cast().Raw()) {
-                return {};
-            }
-
-            columnRanges[i] = TColumnRange::MakePoint(fromValues[i].Cast());
-            YQL_ENSURE(i == 0 || columnRanges[i - 1].IsPoint());
-        } else {
-            if (!fromValues[i].Maybe<TCoNothing>() || !toValues[i].Maybe<TCoVoid>()) {
-                return {};
-            }
-        }
-    }
-
+    size_t keyColumnsCount = table.Metadata->KeyColumnNames.size(); 
+    TVector<TMaybeNode<TExprBase>> fromValues(keyColumnsCount); 
+    TVector<TMaybeNode<TExprBase>> toValues(keyColumnsCount); 
+    bool incFrom = false; 
+    bool incTo = false; 
+ 
+    for (auto node : range) { 
+        if (auto maybeColumnRange = node.Maybe<TKiColumnRangeTuple>()) { 
+            auto columnRange = maybeColumnRange.Cast(); 
+ 
+            auto idx = table.GetKeyColumnIndex(TString(columnRange.Column())); 
+            YQL_ENSURE(idx); 
+ 
+            fromValues[*idx] = columnRange.From(); 
+            toValues[*idx] = columnRange.To(); 
+        } 
+ 
+        if (auto maybeAtom = node.Maybe<TCoAtom>()) { 
+            auto value = maybeAtom.Cast().Value(); 
+ 
+            if (value == "IncFrom") { 
+                incFrom = true; 
+            } 
+ 
+            if (value == "IncTo") { 
+                incTo = true; 
+            } 
+        } 
+    } 
+ 
+    if (!incFrom || !incTo) { 
+        return {}; 
+    } 
+ 
+    TVector<TColumnRange> columnRanges(keyColumnsCount); 
+    for (size_t i = 0; i < keyColumnsCount; ++i) { 
+        YQL_ENSURE(fromValues[i]); 
+        YQL_ENSURE(toValues[i]); 
+ 
+        if (!fromValues[i].Maybe<TCoVoid>() && !toValues[i].Maybe<TCoVoid>()) { 
+            if (fromValues[i].Cast().Raw() != toValues[i].Cast().Raw()) { 
+                return {}; 
+            } 
+ 
+            columnRanges[i] = TColumnRange::MakePoint(fromValues[i].Cast()); 
+            YQL_ENSURE(i == 0 || columnRanges[i - 1].IsPoint()); 
+        } else { 
+            if (!fromValues[i].Maybe<TCoNothing>() || !toValues[i].Maybe<TCoVoid>()) { 
+                return {}; 
+            } 
+        } 
+    } 
+ 
     return TKeyRange(ctx, columnRanges, {});
-}
-
-TExprList TKikimrKeyRange::ToRangeExpr(TExprBase owner, TExprContext& ctx) {
-    auto pInf = [owner, &ctx] () -> TExprBase {
-        return Build<TCoVoid>(ctx, owner.Pos()).Done();
-    };
-
-    auto nInf = [owner, &ctx] (const TTypeAnnotationNode* type) -> TExprBase {
+} 
+ 
+TExprList TKikimrKeyRange::ToRangeExpr(TExprBase owner, TExprContext& ctx) { 
+    auto pInf = [owner, &ctx] () -> TExprBase { 
+        return Build<TCoVoid>(ctx, owner.Pos()).Done(); 
+    }; 
+ 
+    auto nInf = [owner, &ctx] (const TTypeAnnotationNode* type) -> TExprBase { 
         /* required optional type for TCoNothing */
         if (type->GetKind() != ETypeAnnotationKind::Optional) {
             type = ctx.MakeType<TOptionalExprType>(type);
         }
-        return Build<TCoNothing>(ctx, owner.Pos())
-            .OptionalType(BuildTypeExpr(owner.Pos(), *type, ctx))
-            .Done();
-    };
-
-    bool fromInclusive = true;
-    bool toInclusive = true;
-    TVector<TExprBase> columnRanges;
-
-    for (size_t i = 0; i < KeyRange.GetColumnRangesCount(); ++i) {
+        return Build<TCoNothing>(ctx, owner.Pos()) 
+            .OptionalType(BuildTypeExpr(owner.Pos(), *type, ctx)) 
+            .Done(); 
+    }; 
+ 
+    bool fromInclusive = true; 
+    bool toInclusive = true; 
+    TVector<TExprBase> columnRanges; 
+ 
+    for (size_t i = 0; i < KeyRange.GetColumnRangesCount(); ++i) { 
         const auto& column = Table.Metadata->KeyColumnNames[i];
         const auto& range = KeyRange.GetColumnRange(i);
-
-        auto type = Table.GetColumnType(column);
-        YQL_ENSURE(type);
-
-        TMaybeNode<TExprBase> from;
-        TMaybeNode<TExprBase> to;
-
-        if (range.GetFrom().IsDefined()) {
-            fromInclusive = range.GetFrom().IsInclusive();
-            from = range.GetFrom().GetValue();
-        } else {
-            from = fromInclusive ? nInf(type) : pInf();
-        }
-
-        if (range.GetTo().IsDefined()) {
-            toInclusive = range.GetTo().IsInclusive();
-            to = range.GetTo().GetValue();
-        } else {
-            to = toInclusive ? pInf() : nInf(type);
-        }
-
-        auto rangeExpr = Build<TKiColumnRangeTuple>(ctx, owner.Pos())
-            .Column().Build(column)
-            .From(from.Cast())
-            .To(to.Cast())
-            .Done();
-
-        columnRanges.push_back(rangeExpr);
-    }
-
-    return Build<TExprList>(ctx, owner.Pos())
-        .Add<TCoAtom>()
-            .Value(fromInclusive ? "IncFrom" : "ExcFrom")
-            .Build()
-        .Add<TCoAtom>()
-            .Value(toInclusive ? "IncTo" : "ExcTo")
-            .Build()
-        .Add(columnRanges)
-        .Done();
-}
-
+ 
+        auto type = Table.GetColumnType(column); 
+        YQL_ENSURE(type); 
+ 
+        TMaybeNode<TExprBase> from; 
+        TMaybeNode<TExprBase> to; 
+ 
+        if (range.GetFrom().IsDefined()) { 
+            fromInclusive = range.GetFrom().IsInclusive(); 
+            from = range.GetFrom().GetValue(); 
+        } else { 
+            from = fromInclusive ? nInf(type) : pInf(); 
+        } 
+ 
+        if (range.GetTo().IsDefined()) { 
+            toInclusive = range.GetTo().IsInclusive(); 
+            to = range.GetTo().GetValue(); 
+        } else { 
+            to = toInclusive ? pInf() : nInf(type); 
+        } 
+ 
+        auto rangeExpr = Build<TKiColumnRangeTuple>(ctx, owner.Pos()) 
+            .Column().Build(column) 
+            .From(from.Cast()) 
+            .To(to.Cast()) 
+            .Done(); 
+ 
+        columnRanges.push_back(rangeExpr); 
+    } 
+ 
+    return Build<TExprList>(ctx, owner.Pos()) 
+        .Add<TCoAtom>() 
+            .Value(fromInclusive ? "IncFrom" : "ExcFrom") 
+            .Build() 
+        .Add<TCoAtom>() 
+            .Value(toInclusive ? "IncTo" : "ExcTo") 
+            .Build() 
+        .Add(columnRanges) 
+        .Done(); 
+} 
+ 
 static TVector<TExprNodePtr> GetSkipNullKeys(const NCommon::TKeyRange& keyRange,
     const TKikimrTableDescription& tableDesc, const NYql::TPositionHandle& pos, TExprContext& ctx)
 {
@@ -814,71 +814,71 @@ static TVector<TExprNodePtr> GetSkipNullKeys(const NCommon::TKeyRange& keyRange,
     return skipNullKeys;
 }
 
-NNodes::TExprBase TKikimrKeyRange::BuildReadRangeExpr(const TKikimrTableDescription& tableDesc,
+NNodes::TExprBase TKikimrKeyRange::BuildReadRangeExpr(const TKikimrTableDescription& tableDesc, 
     const NCommon::TKeyRange& keyRange, NNodes::TCoAtomList select, bool allowNulls,
     TExprContext& ctx)
-{
-    YQL_ENSURE(tableDesc.Metadata);
-    TString cluster = tableDesc.Metadata->Cluster;
-
+{ 
+    YQL_ENSURE(tableDesc.Metadata); 
+    TString cluster = tableDesc.Metadata->Cluster; 
+ 
     const auto versionedTable = BuildVersionedTable(*tableDesc.Metadata, select.Pos(), ctx);
 
-    if (keyRange.IsEquiRange()) {
-        TVector<TExprBase> columnTuples;
-        for (size_t i = 0; i < keyRange.GetColumnRangesCount(); ++i) {
+    if (keyRange.IsEquiRange()) { 
+        TVector<TExprBase> columnTuples; 
+        for (size_t i = 0; i < keyRange.GetColumnRangesCount(); ++i) { 
             const auto& column = tableDesc.Metadata->KeyColumnNames[i];
-            auto& range = keyRange.GetColumnRange(i);
-
-            auto tuple = Build<TCoNameValueTuple>(ctx, select.Pos())
-                .Name().Build(column)
-                .Value(range.GetFrom().GetValue())
-                .Done();
-
-            columnTuples.push_back(tuple);
-        }
-
-        return Build<TCoToList>(ctx, select.Pos())
-            .Optional<TKiSelectRow>()
-                .Cluster().Build(cluster)
+            auto& range = keyRange.GetColumnRange(i); 
+ 
+            auto tuple = Build<TCoNameValueTuple>(ctx, select.Pos()) 
+                .Name().Build(column) 
+                .Value(range.GetFrom().GetValue()) 
+                .Done(); 
+ 
+            columnTuples.push_back(tuple); 
+        } 
+ 
+        return Build<TCoToList>(ctx, select.Pos()) 
+            .Optional<TKiSelectRow>() 
+                .Cluster().Build(cluster) 
                 .Table(versionedTable)
-                .Key<TCoNameValueTupleList>()
-                    .Add(columnTuples)
-                    .Build()
-                .Select(select)
-                .Build()
-            .Done();
-    } else {
-        TVector<TExprNodePtr> skipNullKeys;
-        if (!allowNulls) {
+                .Key<TCoNameValueTupleList>() 
+                    .Add(columnTuples) 
+                    .Build() 
+                .Select(select) 
+                .Build() 
+            .Done(); 
+    } else { 
+        TVector<TExprNodePtr> skipNullKeys; 
+        if (!allowNulls) { 
             skipNullKeys = GetSkipNullKeys(keyRange, tableDesc, select.Pos(), ctx);
-        }
-
-        TVector<TCoNameValueTuple> settings;
-        if (!skipNullKeys.empty()) {
-            auto setting = Build<TCoNameValueTuple>(ctx, select.Pos())
-                .Name().Build("SkipNullKeys")
-                .Value<TCoAtomList>()
-                    .Add(skipNullKeys)
-                    .Build()
-                .Done();
-
-            settings.push_back(setting);
-        }
-
-        TKikimrKeyRange tableKeyRange(tableDesc, keyRange);
-
-        return Build<TKiSelectRange>(ctx, select.Pos())
-            .Cluster().Build(cluster)
+        } 
+ 
+        TVector<TCoNameValueTuple> settings; 
+        if (!skipNullKeys.empty()) { 
+            auto setting = Build<TCoNameValueTuple>(ctx, select.Pos()) 
+                .Name().Build("SkipNullKeys") 
+                .Value<TCoAtomList>() 
+                    .Add(skipNullKeys) 
+                    .Build() 
+                .Done(); 
+ 
+            settings.push_back(setting); 
+        } 
+ 
+        TKikimrKeyRange tableKeyRange(tableDesc, keyRange); 
+ 
+        return Build<TKiSelectRange>(ctx, select.Pos()) 
+            .Cluster().Build(cluster) 
             .Table(versionedTable)
-            .Range(tableKeyRange.ToRangeExpr(select, ctx))
-            .Select(select)
-            .Settings()
-                .Add(settings)
-                .Build()
-            .Done();
-    }
-}
-
+            .Range(tableKeyRange.ToRangeExpr(select, ctx)) 
+            .Select(select) 
+            .Settings() 
+                .Add(settings) 
+                .Build() 
+            .Done(); 
+    } 
+} 
+ 
 NNodes::TExprBase TKikimrKeyRange::BuildIndexReadRangeExpr(const TKikimrTableDescription& lookupTableDesc,
     const NCommon::TKeyRange& keyRange, NNodes::TCoAtomList select, bool allowNulls,
     const TKikimrTableDescription& dataTableDesc, TExprContext& ctx)
@@ -1043,4 +1043,4 @@ TExprNode::TPtr KiSqlInToEquiJoin(NNodes::TExprBase node, const TKikimrTablesDat
     return node.Ptr();
 }
 
-} // namespace NYql
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_provider.cpp b/ydb/core/kqp/provider/yql_kikimr_provider.cpp
index 635d164827..9437604bbf 100644
--- a/ydb/core/kqp/provider/yql_kikimr_provider.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_provider.cpp
@@ -1,82 +1,82 @@
-#include "yql_kikimr_provider_impl.h"
-
+#include "yql_kikimr_provider_impl.h" 
+ 
 #include <ydb/library/yql/providers/common/proto/gateways_config.pb.h>
 #include <ydb/core/base/path.h>
 #include <ydb/library/yql/providers/result/provider/yql_result_provider.h>
 #include <ydb/library/yql/providers/common/schema/expr/yql_expr_schema.h>
-
+ 
 #include <ydb/public/lib/scheme_types/scheme_type_id.h>
-
-namespace NYql {
-
-using namespace NNodes;
-
-namespace {
-
+ 
+namespace NYql { 
+ 
+using namespace NNodes; 
+ 
+namespace { 
+ 
 const TStringBuf CommitModeFlush = "flush";
 const TStringBuf CommitModeRollback = "rollback";
 const TStringBuf CommitModeScheme = "scheme";
-
-struct TKikimrData {
+ 
+struct TKikimrData { 
     THashSet<TStringBuf> DataSourceNames;
     THashSet<TStringBuf> DataSinkNames;
     THashSet<TStringBuf> KqlNames;
-
+ 
     THashSet<TStringBuf> CommitModes;
-    THashSet<TStringBuf> SupportedEffects;
-
+    THashSet<TStringBuf> SupportedEffects; 
+ 
     TYdbOperations SchemeOps;
     TYdbOperations DataOps;
     TYdbOperations ModifyOps;
     TYdbOperations ReadOps;
     TYdbOperations RequireUnmodifiedOps;
-
+ 
     TMap<TString, NKikimr::NUdf::EDataSlot> SystemColumns;
 
-    TKikimrData() {
-        DataSourceNames.insert(TKiReadTable::CallableName());
-        DataSourceNames.insert(TKiReadTableScheme::CallableName());
-        DataSourceNames.insert(TKiReadTableList::CallableName());
-
+    TKikimrData() { 
+        DataSourceNames.insert(TKiReadTable::CallableName()); 
+        DataSourceNames.insert(TKiReadTableScheme::CallableName()); 
+        DataSourceNames.insert(TKiReadTableList::CallableName()); 
+ 
         DataSinkNames.insert(TKiClusterConfig::CallableName());
-        DataSinkNames.insert(TKiWriteTable::CallableName());
-        DataSinkNames.insert(TKiUpdateTable::CallableName());
-        DataSinkNames.insert(TKiDeleteTable::CallableName());
-        DataSinkNames.insert(TKiCreateTable::CallableName());
+        DataSinkNames.insert(TKiWriteTable::CallableName()); 
+        DataSinkNames.insert(TKiUpdateTable::CallableName()); 
+        DataSinkNames.insert(TKiDeleteTable::CallableName()); 
+        DataSinkNames.insert(TKiCreateTable::CallableName()); 
         DataSinkNames.insert(TKiAlterTable::CallableName());
-        DataSinkNames.insert(TKiDropTable::CallableName());
+        DataSinkNames.insert(TKiDropTable::CallableName()); 
         DataSinkNames.insert(TKiCreateUser::CallableName());
         DataSinkNames.insert(TKiAlterUser::CallableName());
         DataSinkNames.insert(TKiDropUser::CallableName());
         DataSinkNames.insert(TKiCreateGroup::CallableName());
         DataSinkNames.insert(TKiAlterGroup::CallableName());
         DataSinkNames.insert(TKiDropGroup::CallableName());
-        DataSinkNames.insert(TKiDataQuery::CallableName());
-        DataSinkNames.insert(TKiExecDataQuery::CallableName());
-        DataSinkNames.insert(TKiEffects::CallableName());
-
-        KqlNames.insert(TKiSelectRow::CallableName());
-        KqlNames.insert(TKiSelectRange::CallableName());
+        DataSinkNames.insert(TKiDataQuery::CallableName()); 
+        DataSinkNames.insert(TKiExecDataQuery::CallableName()); 
+        DataSinkNames.insert(TKiEffects::CallableName()); 
+ 
+        KqlNames.insert(TKiSelectRow::CallableName()); 
+        KqlNames.insert(TKiSelectRange::CallableName()); 
         KqlNames.insert(TKiSelectIndexRange::CallableName());
-        KqlNames.insert(TKiUpdateRow::CallableName());
-        KqlNames.insert(TKiEraseRow::CallableName());
-        KqlNames.insert(TKiSetResult::CallableName());
-        KqlNames.insert(TKiMapParameter::CallableName());
-        KqlNames.insert(TKiFlatMapParameter::CallableName());
-        KqlNames.insert(TKiPartialSort::CallableName());
-        KqlNames.insert(TKiPartialTake::CallableName());
-        KqlNames.insert(TKiRevertIf::CallableName());
-        KqlNames.insert(TKiAbortIf::CallableName());
-
-        CommitModes.insert(CommitModeFlush);
-        CommitModes.insert(CommitModeRollback);
-        CommitModes.insert(CommitModeScheme);
-
-        SupportedEffects.insert(TKiWriteTable::CallableName());
-        SupportedEffects.insert(TKiUpdateTable::CallableName());
-        SupportedEffects.insert(TKiDeleteTable::CallableName());
-
-        ModifyOps =
+        KqlNames.insert(TKiUpdateRow::CallableName()); 
+        KqlNames.insert(TKiEraseRow::CallableName()); 
+        KqlNames.insert(TKiSetResult::CallableName()); 
+        KqlNames.insert(TKiMapParameter::CallableName()); 
+        KqlNames.insert(TKiFlatMapParameter::CallableName()); 
+        KqlNames.insert(TKiPartialSort::CallableName()); 
+        KqlNames.insert(TKiPartialTake::CallableName()); 
+        KqlNames.insert(TKiRevertIf::CallableName()); 
+        KqlNames.insert(TKiAbortIf::CallableName()); 
+ 
+        CommitModes.insert(CommitModeFlush); 
+        CommitModes.insert(CommitModeRollback); 
+        CommitModes.insert(CommitModeScheme); 
+ 
+        SupportedEffects.insert(TKiWriteTable::CallableName()); 
+        SupportedEffects.insert(TKiUpdateTable::CallableName()); 
+        SupportedEffects.insert(TKiDeleteTable::CallableName()); 
+ 
+        ModifyOps = 
             TYdbOperation::Upsert |
             TYdbOperation::Replace |
             TYdbOperation::Update |
@@ -85,15 +85,15 @@ struct TKikimrData {
             TYdbOperation::DeleteOn |
             TYdbOperation::InsertRevert |
             TYdbOperation::InsertAbort;
-
-        ReadOps =
+ 
+        ReadOps = 
             TYdbOperation::Select |
             TYdbOperation::Update |
             TYdbOperation::Delete;
-
-        DataOps = ModifyOps | ReadOps;
-
-        SchemeOps =
+ 
+        DataOps = ModifyOps | ReadOps; 
+ 
+        SchemeOps = 
             TYdbOperation::CreateTable |
             TYdbOperation::DropTable |
             TYdbOperation::AlterTable |
@@ -103,8 +103,8 @@ struct TKikimrData {
             TYdbOperation::CreateGroup |
             TYdbOperation::AlterGroup |
             TYdbOperation::DropGroup;
-
-        RequireUnmodifiedOps =
+ 
+        RequireUnmodifiedOps = 
             TYdbOperation::InsertRevert |
             TYdbOperation::InsertAbort |
             TYdbOperation::UpdateOn; // TODO: KIKIMR-3206
@@ -112,26 +112,26 @@ struct TKikimrData {
         SystemColumns = {
             {"_yql_partition_id", NKikimr::NUdf::EDataSlot::Uint64}
         };
-    }
-};
-
-} // namespace
-
-const TKikimrTableDescription* TKikimrTablesData::EnsureTableExists(const TString& cluster,
+    } 
+}; 
+ 
+} // namespace 
+ 
+const TKikimrTableDescription* TKikimrTablesData::EnsureTableExists(const TString& cluster, 
     const TString& table, TPositionHandle pos, TExprContext& ctx) const
-{
-    auto desc = Tables.FindPtr(std::make_pair(cluster, table));
-    if (desc && desc->DoesExist()) {
-        return desc;
-    }
-
+{ 
+    auto desc = Tables.FindPtr(std::make_pair(cluster, table)); 
+    if (desc && desc->DoesExist()) { 
+        return desc; 
+    } 
+ 
     ctx.AddError(YqlIssue(ctx.GetPosition(pos), TIssuesIds::KIKIMR_SCHEME_ERROR, TStringBuilder()
-        << "Cannot find table '" << NCommon::FullTableName(cluster, table)
+        << "Cannot find table '" << NCommon::FullTableName(cluster, table) 
         << "' because it does not exist or you do not have access permissions."
-        << " Please check correctness of table path and user permissions."));
-    return nullptr;
-}
-
+        << " Please check correctness of table path and user permissions.")); 
+    return nullptr; 
+} 
+ 
 TKikimrTableDescription& TKikimrTablesData::GetOrAddTable(const TString& cluster, const TString& database, const TString& table) {
     if (!Tables.FindPtr(std::make_pair(cluster, table))) {
         auto& desc = Tables[std::make_pair(cluster, table)];
@@ -146,32 +146,32 @@ TKikimrTableDescription& TKikimrTablesData::GetOrAddTable(const TString& cluster
     }
 
     return Tables[std::make_pair(cluster, table)];
-}
-
+} 
+ 
 TKikimrTableDescription& TKikimrTablesData::GetTable(const TString& cluster, const TString& table) {
-    auto desc = Tables.FindPtr(std::make_pair(cluster, table));
+    auto desc = Tables.FindPtr(std::make_pair(cluster, table)); 
     YQL_ENSURE(desc, "Unexpected empty metadata, cluster '" << cluster << "', table '" << table << "'");
-
-    return *desc;
-}
-
-const TKikimrTableDescription& TKikimrTablesData::ExistingTable(const TStringBuf& cluster,
-    const TStringBuf& table) const
-{
-    auto desc = Tables.FindPtr(std::make_pair(TString(cluster), TString(table)));
-    YQL_ENSURE(desc);
-    YQL_ENSURE(desc->DoesExist());
-
-    return *desc;
-}
-
+ 
+    return *desc; 
+} 
+ 
+const TKikimrTableDescription& TKikimrTablesData::ExistingTable(const TStringBuf& cluster, 
+    const TStringBuf& table) const 
+{ 
+    auto desc = Tables.FindPtr(std::make_pair(TString(cluster), TString(table))); 
+    YQL_ENSURE(desc); 
+    YQL_ENSURE(desc->DoesExist()); 
+ 
+    return *desc; 
+} 
+ 
 bool TKikimrTableDescription::Load(TExprContext& ctx, bool withSystemColumns) {
-    ColumnTypes.clear();
-
+    ColumnTypes.clear(); 
+ 
     TVector<const TItemExprType*> items;
-    for (auto pair : Metadata->Columns) {
-        auto& column = pair.second;
-
+    for (auto pair : Metadata->Columns) { 
+        auto& column = pair.second; 
+ 
         // Currently Kikimr doesn't have parametrized types and Decimal type
         // is passed with no params. It's known to always be Decimal(22,9),
         // so we transform Decimal type here.
@@ -183,17 +183,17 @@ bool TKikimrTableDescription::Load(TExprContext& ctx, bool withSystemColumns) {
                 ToString(NKikimr::NScheme::DECIMAL_SCALE));
         else
             type = ctx.MakeType<TDataExprType>(NKikimr::NUdf::GetDataSlot(column.Type));
-
+ 
         if (!column.NotNull) {
             type = ctx.MakeType<TOptionalExprType>(type);
         }
-
+ 
         items.push_back(ctx.MakeType<TItemExprType>(column.Name, type));
 
         auto insertResult = ColumnTypes.insert(std::make_pair(column.Name, type));
         YQL_ENSURE(insertResult.second);
-    }
-
+    } 
+ 
     if (withSystemColumns) {
         for (const auto& [name, type] : KikimrSystemColumns()) {
             const TOptionalExprType* optType = ctx.MakeType<TOptionalExprType>(ctx.MakeType<TDataExprType>(type));
@@ -205,156 +205,156 @@ bool TKikimrTableDescription::Load(TExprContext& ctx, bool withSystemColumns) {
     }
 
     SchemeNode = ctx.MakeType<TStructExprType>(items);
-    return true;
-}
-
+    return true; 
+} 
+ 
 TMaybe<ui32> TKikimrTableDescription::GetKeyColumnIndex(const TString& name) const {
-    auto it = std::find(Metadata->KeyColumnNames.begin(), Metadata->KeyColumnNames.end(), name);
-    return it == Metadata->KeyColumnNames.end()
-        ? TMaybe<ui32>()
-        : it - Metadata->KeyColumnNames.begin();
-}
-
+    auto it = std::find(Metadata->KeyColumnNames.begin(), Metadata->KeyColumnNames.end(), name); 
+    return it == Metadata->KeyColumnNames.end() 
+        ? TMaybe<ui32>() 
+        : it - Metadata->KeyColumnNames.begin(); 
+} 
+ 
 const TTypeAnnotationNode* TKikimrTableDescription::GetColumnType(const TString& name) const {
-    auto* type = ColumnTypes.FindPtr(name);
-    if (!type) {
-        return nullptr;
-    }
-
-    return *type;
-}
-
-bool TKikimrTableDescription::DoesExist() const {
-    return Metadata->DoesExist;
-}
-
+    auto* type = ColumnTypes.FindPtr(name); 
+    if (!type) { 
+        return nullptr; 
+    } 
+ 
+    return *type; 
+} 
+ 
+bool TKikimrTableDescription::DoesExist() const { 
+    return Metadata->DoesExist; 
+} 
+ 
 void TKikimrTableDescription::ToYson(NYson::TYsonWriter& writer) const {
-    YQL_ENSURE(Metadata);
-
-    auto& meta = *Metadata;
-
-    writer.OnBeginMap();
+    YQL_ENSURE(Metadata); 
+ 
+    auto& meta = *Metadata; 
+ 
+    writer.OnBeginMap(); 
     writer.OnKeyedItem(TStringBuf("Cluster"));
-    writer.OnStringScalar(meta.Cluster);
+    writer.OnStringScalar(meta.Cluster); 
     writer.OnKeyedItem(TStringBuf("Name"));
-    writer.OnStringScalar(meta.Name);
+    writer.OnStringScalar(meta.Name); 
     writer.OnKeyedItem(TStringBuf("Id"));
-    writer.OnStringScalar(meta.PathId.ToString());
-
+    writer.OnStringScalar(meta.PathId.ToString()); 
+ 
     writer.OnKeyedItem(TStringBuf("DoesExist"));
-    writer.OnBooleanScalar(DoesExist());
+    writer.OnBooleanScalar(DoesExist()); 
     writer.OnKeyedItem(TStringBuf("IsSorted"));
-    writer.OnBooleanScalar(true);
+    writer.OnBooleanScalar(true); 
     writer.OnKeyedItem(TStringBuf("IsDynamic"));
     writer.OnBooleanScalar(true);
     writer.OnKeyedItem(TStringBuf("UniqueKeys"));
     writer.OnBooleanScalar(true);
     writer.OnKeyedItem(TStringBuf("CanWrite"));
-    writer.OnBooleanScalar(true);
+    writer.OnBooleanScalar(true); 
     writer.OnKeyedItem(TStringBuf("IsRealData"));
-    writer.OnBooleanScalar(true);
+    writer.OnBooleanScalar(true); 
     writer.OnKeyedItem(TStringBuf("YqlCompatibleSchema"));
     writer.OnBooleanScalar(true);
-
+ 
     writer.OnKeyedItem(TStringBuf("RecordsCount"));
-    writer.OnInt64Scalar(meta.RecordsCount);
+    writer.OnInt64Scalar(meta.RecordsCount); 
     writer.OnKeyedItem(TStringBuf("DataSize"));
-    writer.OnInt64Scalar(meta.DataSize);
+    writer.OnInt64Scalar(meta.DataSize); 
     writer.OnKeyedItem(TStringBuf("MemorySize"));
-    writer.OnInt64Scalar(meta.MemorySize);
+    writer.OnInt64Scalar(meta.MemorySize); 
     writer.OnKeyedItem(TStringBuf("ChunkCount"));
-    writer.OnInt64Scalar(meta.ShardsCount);
-
+    writer.OnInt64Scalar(meta.ShardsCount); 
+ 
     writer.OnKeyedItem(TStringBuf("AccessTime"));
-    writer.OnInt64Scalar(meta.LastAccessTime.Seconds());
+    writer.OnInt64Scalar(meta.LastAccessTime.Seconds()); 
     writer.OnKeyedItem(TStringBuf("ModifyTime"));
-    writer.OnInt64Scalar(meta.LastUpdateTime.Seconds());
-
-    writer.OnKeyedItem("Fields");
-    writer.OnBeginList();
-    {
+    writer.OnInt64Scalar(meta.LastUpdateTime.Seconds()); 
+ 
+    writer.OnKeyedItem("Fields"); 
+    writer.OnBeginList(); 
+    { 
         for (auto& item: SchemeNode->GetItems()) {
-            writer.OnListItem();
-
+            writer.OnListItem(); 
+ 
             auto name = item->GetName();
-            writer.OnBeginMap();
-
-            writer.OnKeyedItem("Name");
-            writer.OnStringScalar(name);
-
-            writer.OnKeyedItem("Type");
+            writer.OnBeginMap(); 
+ 
+            writer.OnKeyedItem("Name"); 
+            writer.OnStringScalar(name); 
+ 
+            writer.OnKeyedItem("Type"); 
             NCommon::WriteTypeToYson(writer, item->GetItemType());
-
+ 
             TMaybe<ui32> keyIndex = GetKeyColumnIndex(TString(name));
-
-            writer.OnKeyedItem("ClusterSortOrder");
-            writer.OnBeginList();
-            if (keyIndex.Defined()) {
-                writer.OnListItem();
-                writer.OnInt64Scalar(*keyIndex);
-            }
-            writer.OnEndList();
-
-            writer.OnKeyedItem("Ascending");
-            writer.OnBeginList();
-            if (keyIndex.Defined()) {
-                writer.OnListItem();
-                writer.OnBooleanScalar(true);
-            }
-            writer.OnEndList();
-
-            writer.OnEndMap();
-        }
-    }
-    writer.OnEndList();
-
-    writer.OnKeyedItem("RowType");
+ 
+            writer.OnKeyedItem("ClusterSortOrder"); 
+            writer.OnBeginList(); 
+            if (keyIndex.Defined()) { 
+                writer.OnListItem(); 
+                writer.OnInt64Scalar(*keyIndex); 
+            } 
+            writer.OnEndList(); 
+ 
+            writer.OnKeyedItem("Ascending"); 
+            writer.OnBeginList(); 
+            if (keyIndex.Defined()) { 
+                writer.OnListItem(); 
+                writer.OnBooleanScalar(true); 
+            } 
+            writer.OnEndList(); 
+ 
+            writer.OnEndMap(); 
+        } 
+    } 
+    writer.OnEndList(); 
+ 
+    writer.OnKeyedItem("RowType"); 
     NCommon::WriteTypeToYson(writer, SchemeNode);
-
-    writer.OnEndMap();
-}
-
+ 
+    writer.OnEndMap(); 
+} 
+ 
 bool TKikimrKey::Extract(const TExprNode& key) {
-    if (key.IsCallable("MrTableConcat")) {
+    if (key.IsCallable("MrTableConcat")) { 
         Ctx.AddError(TIssue(Ctx.GetPosition(key.Pos()), "CONCAT is not supported on Kikimr clusters."));
-        return false;
-    }
-
-    if (!key.IsCallable("Key")) {
+        return false; 
+    } 
+ 
+    if (!key.IsCallable("Key")) { 
         Ctx.AddError(TIssue(Ctx.GetPosition(key.Pos()), "Expected key"));
-        return false;
-    }
-
+        return false; 
+    } 
+ 
     const auto& tagName = key.Child(0)->Child(0)->Content();
-    if (tagName == "table") {
-        KeyType = Type::Table;
-        const TExprNode* nameNode = key.Child(0)->Child(1);
-
-        if (nameNode->IsCallable("MrTableRange") || nameNode->IsCallable("MrTableRangeStrict")) {
+    if (tagName == "table") { 
+        KeyType = Type::Table; 
+        const TExprNode* nameNode = key.Child(0)->Child(1); 
+ 
+        if (nameNode->IsCallable("MrTableRange") || nameNode->IsCallable("MrTableRangeStrict")) { 
             Ctx.AddError(TIssue(Ctx.GetPosition(key.Pos()), "RANGE is not supported on Kikimr clusters."));
-            return false;
-        }
-
-        if (!nameNode->IsCallable("String")) {
+            return false; 
+        } 
+ 
+        if (!nameNode->IsCallable("String")) { 
             Ctx.AddError(TIssue(Ctx.GetPosition(key.Pos()), "Expected String as table key."));
-            return false;
-        }
-
+            return false; 
+        } 
+ 
         Target = nameNode->Child(0)->Content();
-    } else if (tagName == "tablescheme") {
-        KeyType = Type::TableScheme;
+    } else if (tagName == "tablescheme") { 
+        KeyType = Type::TableScheme; 
         Target = key.Child(0)->Child(1)->Child(0)->Content();
-    } else if (tagName == "tablelist") {
-        KeyType = Type::TableList;
+    } else if (tagName == "tablelist") { 
+        KeyType = Type::TableList; 
         Target = key.Child(0)->Child(1)->Child(0)->Content();
     } else if (tagName == "role") {
         KeyType = Type::Role;
         Target = key.Child(0)->Child(1)->Child(0)->Content();
-    } else {
+    } else { 
         Ctx.AddError(TIssue(Ctx.GetPosition(key.Child(0)->Pos()), TString("Unexpected tag for kikimr key: ") + tagName));
-        return false;
-    }
-
+        return false; 
+    } 
+ 
     if (key.ChildrenSize() > 1) {
         for (ui32 i = 1; i < key.ChildrenSize(); ++i) {
             auto tag = key.Child(i)->Child(0);
@@ -381,13 +381,13 @@ bool TKikimrKey::Extract(const TExprNode& key) {
             }
         }
     }
-    return true;
-}
-
+    return true; 
+} 
+ 
 NNodes::TKiVersionedTable BuildVersionedTable(const TKikimrTableMetadata& metadata, TPositionHandle pos, TExprContext& ctx) {
     return Build<TKiVersionedTable>(ctx, pos)
-        .Path().Build(metadata.Name)
-        .SchemaVersion().Build(ToString(metadata.SchemaVersion))
+        .Path().Build(metadata.Name) 
+        .SchemaVersion().Build(ToString(metadata.SchemaVersion)) 
         .PathId().Build(metadata.PathId.ToString())
         .Done();
 }
@@ -401,12 +401,12 @@ NNodes::TCoAtomList BuildColumnsList(
     TVector<TExprBase> columnsToSelect;
     for (const auto& pair : table.Metadata->Columns) {
         auto atom = Build<TCoAtom>(ctx, pos)
-            .Value(pair.second.Name)
-            .Done();
-
+            .Value(pair.second.Name) 
+            .Done(); 
+ 
         columnsToSelect.emplace_back(std::move(atom));
-    }
-
+    } 
+ 
     if (withSystemColumns) {
         for (const auto& pair : KikimrSystemColumns()) {
             auto atom = Build<TCoAtom>(ctx, pos)
@@ -418,10 +418,10 @@ NNodes::TCoAtomList BuildColumnsList(
     }
 
     return Build<TCoAtomList>(ctx, pos)
-        .Add(columnsToSelect)
-        .Done();
+        .Add(columnsToSelect) 
+        .Done(); 
 }
-
+ 
 NNodes::TCoAtomList BuildKeyColumnsList(const TKikimrTableDescription& table, TPositionHandle pos, TExprContext& ctx) {
     TVector<TExprBase> columnsToSelect;
     columnsToSelect.reserve(table.Metadata->KeyColumnNames.size());
@@ -437,8 +437,8 @@ NNodes::TCoAtomList BuildKeyColumnsList(const TKikimrTableDescription& table, TP
     return Build<TCoAtomList>(ctx, pos)
         .Add(columnsToSelect)
         .Done();
-}
-
+} 
+ 
 NNodes::TCoAtomList MergeColumns(const NNodes::TCoAtomList& col1, const TVector<TString>& col2, TExprContext& ctx) {
     TVector<TCoAtom> columns;
     THashSet<TString> uniqColumns;
@@ -484,33 +484,33 @@ TCoNameValueTupleList ExtractNamedKeyTuples(TCoArgument itemArg, const TKikimrTa
         .Done();
 }
 
-TVector<NKqpProto::TKqpTableOp> TableOperationsToProto(const TCoNameValueTupleList& operations, TExprContext& ctx) {
-    TVector<NKqpProto::TKqpTableOp> protoOps;
-    for (const auto& op : operations) {
-        auto table = TString(op.Name());
+TVector<NKqpProto::TKqpTableOp> TableOperationsToProto(const TCoNameValueTupleList& operations, TExprContext& ctx) { 
+    TVector<NKqpProto::TKqpTableOp> protoOps; 
+    for (const auto& op : operations) { 
+        auto table = TString(op.Name()); 
         auto tableOp = FromString<TYdbOperation>(TString(op.Value().Cast<TCoAtom>()));
         auto pos = ctx.GetPosition(op.Pos());
-
-        NKqpProto::TKqpTableOp protoOp;
+ 
+        NKqpProto::TKqpTableOp protoOp; 
         protoOp.MutablePosition()->SetRow(pos.Row);
         protoOp.MutablePosition()->SetColumn(pos.Column);
-        protoOp.SetTable(table);
-        protoOp.SetOperation((ui32)tableOp);
-
-        protoOps.push_back(protoOp);
-    }
-
-    return protoOps;
-}
-
-TVector<NKqpProto::TKqpTableOp> TableOperationsToProto(const TKiOperationList& operations, TExprContext& ctx) {
-    TVector<NKqpProto::TKqpTableOp> protoOps;
+        protoOp.SetTable(table); 
+        protoOp.SetOperation((ui32)tableOp); 
+ 
+        protoOps.push_back(protoOp); 
+    } 
+ 
+    return protoOps; 
+} 
+ 
+TVector<NKqpProto::TKqpTableOp> TableOperationsToProto(const TKiOperationList& operations, TExprContext& ctx) { 
+    TVector<NKqpProto::TKqpTableOp> protoOps; 
     for (const auto& op : operations) {
         auto table = TString(op.Table());
         auto tableOp = FromString<TYdbOperation>(TString(op.Operation()));
         auto pos = ctx.GetPosition(op.Pos());
 
-        NKqpProto::TKqpTableOp protoOp;
+        NKqpProto::TKqpTableOp protoOp; 
         protoOp.MutablePosition()->SetRow(pos.Row);
         protoOp.MutablePosition()->SetColumn(pos.Column);
         protoOp.SetTable(table);
@@ -522,52 +522,52 @@ TVector<NKqpProto::TKqpTableOp> TableOperationsToProto(const TKiOperationList& o
     return protoOps;
 }
 
-void TableDescriptionToTableInfo(const TKikimrTableDescription& desc, NKqpProto::TKqpTableInfo* info) {
+void TableDescriptionToTableInfo(const TKikimrTableDescription& desc, NKqpProto::TKqpTableInfo* info) { 
     YQL_ENSURE(desc.Metadata);
     info->SetTableName(desc.Metadata->Name);
-    info->MutableTableId()->SetOwnerId(desc.Metadata->PathId.OwnerId());
-    info->MutableTableId()->SetTableId(desc.Metadata->PathId.TableId());
+    info->MutableTableId()->SetOwnerId(desc.Metadata->PathId.OwnerId()); 
+    info->MutableTableId()->SetTableId(desc.Metadata->PathId.TableId()); 
     info->SetSchemaVersion(desc.Metadata->SchemaVersion);
     if (desc.Metadata->Indexes) {
         info->SetHasIndexTables(true);
     }
 }
 
-bool TKikimrTransactionContextBase::ApplyTableOperations(const TVector<NKqpProto::TKqpTableOp>& operations,
-    const TVector<NKqpProto::TKqpTableInfo>& tableInfos, NKikimrKqp::EIsolationLevel isolationLevel, bool strictDml,
+bool TKikimrTransactionContextBase::ApplyTableOperations(const TVector<NKqpProto::TKqpTableOp>& operations, 
+    const TVector<NKqpProto::TKqpTableInfo>& tableInfos, NKikimrKqp::EIsolationLevel isolationLevel, bool strictDml, 
     EKikimrQueryType queryType, TExprContext& ctx)
-{
-    if (IsClosed()) {
-        TString message = TStringBuilder() << "Cannot perform operations on closed transaction.";
+{ 
+    if (IsClosed()) { 
+        TString message = TStringBuilder() << "Cannot perform operations on closed transaction."; 
         ctx.AddError(YqlIssue({}, TIssuesIds::KIKIMR_BAD_OPERATION, message));
-        return false;
-    }
-
-    isolationLevel = EffectiveIsolationLevel
-        ? *EffectiveIsolationLevel
-        : isolationLevel;
-
-    bool hasScheme = false;
-    bool hasData = false;
-    for (auto& pair : TableOperations) {
-        hasScheme = hasScheme || (pair.second & KikimrSchemeOps());
-        hasData = hasData || (pair.second & KikimrDataOps());
-    }
-
-    THashMap<TString, NKqpProto::TKqpTableInfo> tableInfoMap;
+        return false; 
+    } 
+ 
+    isolationLevel = EffectiveIsolationLevel 
+        ? *EffectiveIsolationLevel 
+        : isolationLevel; 
+ 
+    bool hasScheme = false; 
+    bool hasData = false; 
+    for (auto& pair : TableOperations) { 
+        hasScheme = hasScheme || (pair.second & KikimrSchemeOps()); 
+        hasData = hasData || (pair.second & KikimrDataOps()); 
+    } 
+ 
+    THashMap<TString, NKqpProto::TKqpTableInfo> tableInfoMap; 
     for (const auto& info : tableInfos) {
         tableInfoMap.insert(std::make_pair(info.GetTableName(), info));
-
-        TKikimrPathId pathId(info.GetTableId().GetOwnerId(), info.GetTableId().GetTableId());
-        TableByIdMap.insert(std::make_pair(pathId, info.GetTableName()));
+ 
+        TKikimrPathId pathId(info.GetTableId().GetOwnerId(), info.GetTableId().GetTableId()); 
+        TableByIdMap.insert(std::make_pair(pathId, info.GetTableName())); 
     }
 
-    for (const auto& op : operations) {
+    for (const auto& op : operations) { 
         const auto& table = op.GetTable();
 
         auto newOp = TYdbOperation(op.GetOperation());
-        TPosition pos(op.GetPosition().GetColumn(), op.GetPosition().GetRow());
-
+        TPosition pos(op.GetPosition().GetColumn(), op.GetPosition().GetRow()); 
+ 
         const auto info = tableInfoMap.FindPtr(table);
         if (!info) {
             TString message = TStringBuilder()
@@ -576,142 +576,142 @@ bool TKikimrTransactionContextBase::ApplyTableOperations(const TVector<NKqpProto
             return false;
         }
 
-        if (queryType == EKikimrQueryType::Dml && (newOp & KikimrSchemeOps())) {
-            TString message = TStringBuilder() << "Operation '" << newOp
-                << "' can't be performed in data query";
-            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message));
-            return false;
-        }
-
-        if (queryType == EKikimrQueryType::Ddl && (newOp & KikimrDataOps())) {
-            TString message = TStringBuilder() << "Operation '" << newOp
-                << "' can't be performed in scheme query";
-            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message));
-            return false;
-        }
-
-        if (queryType == EKikimrQueryType::Scan && (newOp & KikimrModifyOps())) {
-            TString message = TStringBuilder() << "Operation '" << newOp
-                << "' can't be performed in scan query";
-            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message));
-            return false;
-        }
-
-        if (hasData && (newOp & KikimrSchemeOps()) ||
-            hasScheme && (newOp & KikimrDataOps()))
-        {
-            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_MIXED_SCHEME_DATA_TX));
-            return false;
-        }
-
-        if (Readonly && (newOp & KikimrModifyOps())) {
-            TString message = TStringBuilder() << "Operation '" << newOp
-                << "' can't be performed in read only transaction";
-            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message));
-            return false;
-        }
-
-        auto& currentOps = TableOperations[table];
-
-        if (currentOps & KikimrModifyOps()) {
-            if (KikimrRequireUnmodifiedOps() & newOp) {
-                TString message = TStringBuilder() << "Operation '" << newOp
-                    << "' can't be performed on previously modified table: " << table;
-                ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message));
-                return false;
-            }
-
-            if (KikimrReadOps() & newOp) {
-                TString message = TStringBuilder() << "Data modifications previously made to table '" << table
-                    << "' in current transaction won't be seen by operation: '" << newOp << "'";
-                if (!AddDmlIssue(YqlIssue(pos, TIssuesIds::KIKIMR_READ_MODIFIED_TABLE, message), strictDml, ctx)) {
-                    return false;
-                }
-            }
+        if (queryType == EKikimrQueryType::Dml && (newOp & KikimrSchemeOps())) { 
+            TString message = TStringBuilder() << "Operation '" << newOp 
+                << "' can't be performed in data query"; 
+            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message)); 
+            return false; 
+        } 
+ 
+        if (queryType == EKikimrQueryType::Ddl && (newOp & KikimrDataOps())) { 
+            TString message = TStringBuilder() << "Operation '" << newOp 
+                << "' can't be performed in scheme query"; 
+            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message)); 
+            return false; 
+        } 
+ 
+        if (queryType == EKikimrQueryType::Scan && (newOp & KikimrModifyOps())) { 
+            TString message = TStringBuilder() << "Operation '" << newOp 
+                << "' can't be performed in scan query"; 
+            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message)); 
+            return false; 
+        } 
+ 
+        if (hasData && (newOp & KikimrSchemeOps()) || 
+            hasScheme && (newOp & KikimrDataOps())) 
+        { 
+            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_MIXED_SCHEME_DATA_TX)); 
+            return false; 
+        } 
+ 
+        if (Readonly && (newOp & KikimrModifyOps())) { 
+            TString message = TStringBuilder() << "Operation '" << newOp 
+                << "' can't be performed in read only transaction"; 
+            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message)); 
+            return false; 
+        } 
+ 
+        auto& currentOps = TableOperations[table]; 
+
+        if (currentOps & KikimrModifyOps()) { 
+            if (KikimrRequireUnmodifiedOps() & newOp) { 
+                TString message = TStringBuilder() << "Operation '" << newOp 
+                    << "' can't be performed on previously modified table: " << table; 
+                ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message)); 
+                return false; 
+            } 
+ 
+            if (KikimrReadOps() & newOp) { 
+                TString message = TStringBuilder() << "Data modifications previously made to table '" << table 
+                    << "' in current transaction won't be seen by operation: '" << newOp << "'"; 
+                if (!AddDmlIssue(YqlIssue(pos, TIssuesIds::KIKIMR_READ_MODIFIED_TABLE, message), strictDml, ctx)) { 
+                    return false; 
+                } 
+            } 
 
             if (info->GetHasIndexTables()) {
                 TString message = TStringBuilder() << "Multiple modification of table with secondary indexes is not supported yet";
                 ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message));
                 return false;
             }
-        }
-
-        if ((KikimrRequireUnmodifiedOps() & newOp) && isolationLevel != NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE) {
-            TString message = TStringBuilder()
+        } 
+ 
+        if ((KikimrRequireUnmodifiedOps() & newOp) && isolationLevel != NKikimrKqp::ISOLATION_LEVEL_SERIALIZABLE) { 
+            TString message = TStringBuilder() 
                 << "Operation '" << newOp << "' is only supported with SERIALIZABLE isolation level";
-            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message));
-            return false;
-        }
-
-        // TODO: KIKIMR-3206
+            ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_BAD_OPERATION, message)); 
+            return false; 
+        } 
+ 
+        // TODO: KIKIMR-3206 
         bool currentDelete = currentOps & (TYdbOperation::Delete | TYdbOperation::DeleteOn);
         bool newUpdate = newOp == TYdbOperation::Update;
-        if (currentDelete && newUpdate) {
-            TString message = TStringBuilder() << "Operation '" << newOp
-                << "' may lead to unexpected results when applied to table with deleted rows: " << table;
-            if (!AddDmlIssue(YqlIssue(pos, TIssuesIds::KIKIMR_UPDATE_TABLE_WITH_DELETES, message), strictDml, ctx)) {
-                return false;
-            }
-        }
-
-        currentOps |= newOp;
-    }
-
-    return true;
-}
-
+        if (currentDelete && newUpdate) { 
+            TString message = TStringBuilder() << "Operation '" << newOp 
+                << "' may lead to unexpected results when applied to table with deleted rows: " << table; 
+            if (!AddDmlIssue(YqlIssue(pos, TIssuesIds::KIKIMR_UPDATE_TABLE_WITH_DELETES, message), strictDml, ctx)) { 
+                return false; 
+            } 
+        } 
+ 
+        currentOps |= newOp; 
+    } 
+ 
+    return true; 
+} 
+ 
 const THashSet<TStringBuf>& KikimrDataSourceFunctions() {
-    return Singleton<TKikimrData>()->DataSourceNames;
-}
-
+    return Singleton<TKikimrData>()->DataSourceNames; 
+} 
+ 
 const THashSet<TStringBuf>& KikimrDataSinkFunctions() {
-    return Singleton<TKikimrData>()->DataSinkNames;
-}
-
+    return Singleton<TKikimrData>()->DataSinkNames; 
+} 
+ 
 const THashSet<TStringBuf>& KikimrKqlFunctions() {
-    return Singleton<TKikimrData>()->KqlNames;
-}
-
-const THashSet<TStringBuf>& KikimrSupportedEffects() {
-    return Singleton<TKikimrData>()->SupportedEffects;
-}
-
+    return Singleton<TKikimrData>()->KqlNames; 
+} 
+ 
+const THashSet<TStringBuf>& KikimrSupportedEffects() { 
+    return Singleton<TKikimrData>()->SupportedEffects; 
+} 
+ 
 const THashSet<TStringBuf>& KikimrCommitModes() {
-    return Singleton<TKikimrData>()->CommitModes;
-}
-
-const TStringBuf& KikimrCommitModeFlush() {
-    return CommitModeFlush;
-}
-
-const TStringBuf& KikimrCommitModeRollback() {
-    return CommitModeRollback;
-}
-
-const TStringBuf& KikimrCommitModeScheme() {
-    return CommitModeScheme;
-}
-
+    return Singleton<TKikimrData>()->CommitModes; 
+} 
+ 
+const TStringBuf& KikimrCommitModeFlush() { 
+    return CommitModeFlush; 
+} 
+ 
+const TStringBuf& KikimrCommitModeRollback() { 
+    return CommitModeRollback; 
+} 
+ 
+const TStringBuf& KikimrCommitModeScheme() { 
+    return CommitModeScheme; 
+} 
+ 
 const TYdbOperations& KikimrSchemeOps() {
-    return Singleton<TKikimrData>()->SchemeOps;
-}
-
+    return Singleton<TKikimrData>()->SchemeOps; 
+} 
+ 
 const TYdbOperations& KikimrDataOps() {
-    return Singleton<TKikimrData>()->DataOps;
-}
-
+    return Singleton<TKikimrData>()->DataOps; 
+} 
+ 
 const TYdbOperations& KikimrModifyOps() {
-    return Singleton<TKikimrData>()->ModifyOps;
-}
-
+    return Singleton<TKikimrData>()->ModifyOps; 
+} 
+ 
 const TYdbOperations& KikimrReadOps() {
-    return Singleton<TKikimrData>()->ReadOps;
-}
-
+    return Singleton<TKikimrData>()->ReadOps; 
+} 
+ 
 const TYdbOperations& KikimrRequireUnmodifiedOps() {
-    return Singleton<TKikimrData>()->RequireUnmodifiedOps;
-}
-
+    return Singleton<TKikimrData>()->RequireUnmodifiedOps; 
+} 
+ 
 const TMap<TString, NKikimr::NUdf::EDataSlot>& KikimrSystemColumns() {
     return Singleton<TKikimrData>()->SystemColumns;
 }
@@ -729,65 +729,65 @@ bool ValidateTableHasIndex(TKikimrTableMetadataPtr metadata, TExprContext& ctx,
     return true;
 }
 
-bool AddDmlIssue(const TIssue& issue, bool strictDml, TExprContext& ctx) {
-    if (strictDml) {
-        TIssue newIssue;
-        newIssue.SetCode(issue.GetCode(), ESeverity::TSeverityIds_ESeverityId_S_ERROR);
-        newIssue.Message = "Detected violation of logical DML constraints. YDB transactions don't see their own"
-            " changes, make sure you perform all table reads before any modifications.";
-
-        newIssue.AddSubIssue(new TIssue(issue));
-
-        ctx.AddError(newIssue);
-        return false;
-    } else {
+bool AddDmlIssue(const TIssue& issue, bool strictDml, TExprContext& ctx) { 
+    if (strictDml) { 
+        TIssue newIssue; 
+        newIssue.SetCode(issue.GetCode(), ESeverity::TSeverityIds_ESeverityId_S_ERROR); 
+        newIssue.Message = "Detected violation of logical DML constraints. YDB transactions don't see their own" 
+            " changes, make sure you perform all table reads before any modifications."; 
+ 
+        newIssue.AddSubIssue(new TIssue(issue)); 
+ 
+        ctx.AddError(newIssue); 
+        return false; 
+    } else { 
         if (!ctx.AddWarning(issue)) {
             return false;
         }
-        return true;
-    }
-}
-
-TKiExecDataQuerySettings TKiExecDataQuerySettings::Parse(TKiExecDataQuery exec) {
-    TKiExecDataQuerySettings settings;
-
-    for (const auto& setting : exec.Settings()) {
-        if (setting.Name() == "mode") {
-            YQL_ENSURE(setting.Value().Maybe<TCoAtom>());
-            settings.Mode = setting.Value().Cast<TCoAtom>();
-        } else if (setting.Name()  == "use_new_engine") {
-            YQL_ENSURE(setting.Value().Maybe<TCoAtom>());
-            settings.UseNewEngine = FromString<bool>(setting.Value().Cast<TCoAtom>().Value());
-        } else {
-            settings.Other.push_back(setting);
-        }
-    }
-
-    return settings;
-}
-
+        return true; 
+    } 
+} 
+ 
+TKiExecDataQuerySettings TKiExecDataQuerySettings::Parse(TKiExecDataQuery exec) { 
+    TKiExecDataQuerySettings settings; 
+ 
+    for (const auto& setting : exec.Settings()) { 
+        if (setting.Name() == "mode") { 
+            YQL_ENSURE(setting.Value().Maybe<TCoAtom>()); 
+            settings.Mode = setting.Value().Cast<TCoAtom>(); 
+        } else if (setting.Name()  == "use_new_engine") { 
+            YQL_ENSURE(setting.Value().Maybe<TCoAtom>()); 
+            settings.UseNewEngine = FromString<bool>(setting.Value().Cast<TCoAtom>().Value()); 
+        } else { 
+            settings.Other.push_back(setting); 
+        } 
+    } 
+ 
+    return settings; 
+} 
+ 
 TCoNameValueTupleList TKiExecDataQuerySettings::BuildNode(TExprContext& ctx, TPositionHandle pos) const {
-    TVector<TCoNameValueTuple> settings(Other);
-
-    if (Mode) {
-        settings.push_back(Build<TCoNameValueTuple>(ctx, pos)
-            .Name().Build("mode")
-            .Value<TCoAtom>().Build(*Mode)
-            .Done());
-    }
-
-    if (UseNewEngine) {
-        settings.push_back(Build<TCoNameValueTuple>(ctx, pos)
-            .Name().Build("use_new_engine")
-            .Value<TCoAtom>().Build(ToString(*UseNewEngine))
-            .Done());
-    }
-
-    return Build<TCoNameValueTupleList>(ctx, pos)
-        .Add(settings)
-        .Done();
-}
-
+    TVector<TCoNameValueTuple> settings(Other); 
+ 
+    if (Mode) { 
+        settings.push_back(Build<TCoNameValueTuple>(ctx, pos) 
+            .Name().Build("mode") 
+            .Value<TCoAtom>().Build(*Mode) 
+            .Done()); 
+    } 
+ 
+    if (UseNewEngine) { 
+        settings.push_back(Build<TCoNameValueTuple>(ctx, pos) 
+            .Name().Build("use_new_engine") 
+            .Value<TCoAtom>().Build(ToString(*UseNewEngine)) 
+            .Done()); 
+    } 
+ 
+    return Build<TCoNameValueTupleList>(ctx, pos) 
+        .Add(settings) 
+        .Done(); 
+} 
+ 
 template <>
 double TKikimrQueryContext::GetRandom<double>() const {
     return RandomProvider->GenRandReal2();
@@ -803,4 +803,4 @@ TGUID TKikimrQueryContext::GetRandom<TGUID>() const {
     return RandomProvider->GenUuid4();
 }
 
-} // namespace NYql
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_provider.h b/ydb/core/kqp/provider/yql_kikimr_provider.h
index 6903e6f193..e3ded5888d 100644
--- a/ydb/core/kqp/provider/yql_kikimr_provider.h
+++ b/ydb/core/kqp/provider/yql_kikimr_provider.h
@@ -1,5 +1,5 @@
-#pragma once
-
+#pragma once 
+ 
 #include "yql_kikimr_gateway.h"
 #include "yql_kikimr_settings.h"
 #include "yql_kikimr_query_traits.h"
@@ -7,107 +7,107 @@
 #include <ydb/library/yql/ast/yql_gc_nodes.h>
 #include <ydb/library/yql/core/yql_type_annotation.h>
 #include <ydb/library/yql/minikql/mkql_function_registry.h>
-
+ 
 #include <library/cpp/actors/core/actor.h>
 #include <library/cpp/cache/cache.h>
-
-#include <util/generic/strbuf.h>
-#include <util/generic/flags.h>
-
-namespace NYql {
-
+ 
+#include <util/generic/strbuf.h> 
+#include <util/generic/flags.h> 
+ 
+namespace NYql { 
+ 
 const TStringBuf KikimrMkqlProtoFormat = "mkql_proto";
-
-class IKikimrRemoteGateway;
-
-struct TKikimrQueryDeadlines {
-    TInstant CancelAt;
-    TInstant TimeoutAt;
-};
-
-enum class EKikimrStatsMode {
-    None = 0,
-    Basic = 1,
-    Profile = 2
-};
-
-class IKikimrQueryExecutor : public TThrRefBase {
-public:
-    using TQueryResult = IKikimrGateway::TQueryResult;
-    using TAsyncQueryResult = IKikimrAsyncResult<TQueryResult>;
-
-    struct TExecuteSettings {
-        bool CommitTx = false;
-        bool RollbackTx = false;
-        TKikimrQueryDeadlines Deadlines;
-        TKikimrQueryLimits Limits;
-        bool RawResults = false; // TODO: deprecate
-        TMaybe<TString> IsolationLevel; // TODO: deprecate
-        TMaybe<bool> StrictDml; // TODO: deprecate
-        TMaybe<bool> UseNewEngine;
-        TMaybe<bool> UseScanQuery;
-        EKikimrStatsMode StatsMode = EKikimrStatsMode::None;
-        TMaybe<bool> DocumentApiRestricted;
+ 
+class IKikimrRemoteGateway; 
+ 
+struct TKikimrQueryDeadlines { 
+    TInstant CancelAt; 
+    TInstant TimeoutAt; 
+}; 
+ 
+enum class EKikimrStatsMode { 
+    None = 0, 
+    Basic = 1, 
+    Profile = 2 
+}; 
+ 
+class IKikimrQueryExecutor : public TThrRefBase { 
+public: 
+    using TQueryResult = IKikimrGateway::TQueryResult; 
+    using TAsyncQueryResult = IKikimrAsyncResult<TQueryResult>; 
+ 
+    struct TExecuteSettings { 
+        bool CommitTx = false; 
+        bool RollbackTx = false; 
+        TKikimrQueryDeadlines Deadlines; 
+        TKikimrQueryLimits Limits; 
+        bool RawResults = false; // TODO: deprecate 
+        TMaybe<TString> IsolationLevel; // TODO: deprecate 
+        TMaybe<bool> StrictDml; // TODO: deprecate 
+        TMaybe<bool> UseNewEngine; 
+        TMaybe<bool> UseScanQuery; 
+        EKikimrStatsMode StatsMode = EKikimrStatsMode::None; 
+        TMaybe<bool> DocumentApiRestricted; 
         TMaybe<NKikimrKqp::TRlPath> RlPath;
-
-        bool ForceNewEngine() const { return UseNewEngine && *UseNewEngine; }
-    };
-
-    virtual ~IKikimrQueryExecutor() {}
-
-    virtual TIntrusivePtr<TAsyncQueryResult> ExecuteKql(const TString& cluster,
-        const TExprNode::TPtr& query, TExprContext& ctx, const TExecuteSettings& settings) = 0;
-
-    virtual TIntrusivePtr<TAsyncQueryResult> ExecuteDataQuery(const TString& cluster,
-        const TExprNode::TPtr& query, TExprContext& ctx, const TExecuteSettings& settings) = 0;
-
-    virtual TIntrusivePtr<TAsyncQueryResult> ExplainDataQuery(const TString& cluster,
-        const TExprNode::TPtr& query, TExprContext& ctx) = 0;
-};
-
-enum class EKikimrQueryType {
-    Unspecified = 0,
-    Dml,
-    Ddl,
+ 
+        bool ForceNewEngine() const { return UseNewEngine && *UseNewEngine; } 
+    }; 
+ 
+    virtual ~IKikimrQueryExecutor() {} 
+ 
+    virtual TIntrusivePtr<TAsyncQueryResult> ExecuteKql(const TString& cluster, 
+        const TExprNode::TPtr& query, TExprContext& ctx, const TExecuteSettings& settings) = 0; 
+ 
+    virtual TIntrusivePtr<TAsyncQueryResult> ExecuteDataQuery(const TString& cluster, 
+        const TExprNode::TPtr& query, TExprContext& ctx, const TExecuteSettings& settings) = 0; 
+ 
+    virtual TIntrusivePtr<TAsyncQueryResult> ExplainDataQuery(const TString& cluster, 
+        const TExprNode::TPtr& query, TExprContext& ctx) = 0; 
+}; 
+ 
+enum class EKikimrQueryType { 
+    Unspecified = 0, 
+    Dml, 
+    Ddl, 
     YqlScript,
-    YqlInternal,
+    YqlInternal, 
     Scan,
     YqlScriptStreaming,
-};
-
-struct TKikimrQueryContext : TThrRefBase {
-    TKikimrQueryContext() {}
-    TKikimrQueryContext(const TKikimrQueryContext&) = delete;
-    TKikimrQueryContext& operator=(const TKikimrQueryContext&) = delete;
-
-    bool PrepareOnly = false;
+}; 
+ 
+struct TKikimrQueryContext : TThrRefBase { 
+    TKikimrQueryContext() {} 
+    TKikimrQueryContext(const TKikimrQueryContext&) = delete; 
+    TKikimrQueryContext& operator=(const TKikimrQueryContext&) = delete; 
+ 
+    bool PrepareOnly = false; 
 
     /*
      * Defuse DDL-prohibiting checks when PrepareOnly = true. Used in scripting query explain.
      */
     bool SuppressDdlChecks = false;
 
-    EKikimrStatsMode StatsMode = EKikimrStatsMode::None;
-    EKikimrQueryType Type = EKikimrQueryType::Unspecified;
-    TKikimrQueryDeadlines Deadlines;
-    TKikimrQueryLimits Limits;
-
-    // Operations on document API tables are performed in restricted mode by default,
-    // full mode can be enabled explicitly.
-    bool DocumentApiRestricted = true;
-
+    EKikimrStatsMode StatsMode = EKikimrStatsMode::None; 
+    EKikimrQueryType Type = EKikimrQueryType::Unspecified; 
+    TKikimrQueryDeadlines Deadlines; 
+    TKikimrQueryLimits Limits; 
+ 
+    // Operations on document API tables are performed in restricted mode by default, 
+    // full mode can be enabled explicitly. 
+    bool DocumentApiRestricted = true; 
+ 
     // Force NewEngine stuff
     // remove it after enabling NewEngine
     std::optional<NKikimr::NKqp::TQueryTraits> QueryTraits;
 
     std::unique_ptr<NKikimrKqp::TPreparedQuery> PreparingQuery;
     std::shared_ptr<const NKikimrKqp::TPreparedQuery> PreparedQuery;
-    TKikimrParamsMap Parameters;
-
+    TKikimrParamsMap Parameters; 
+ 
     THashMap<ui64, IKikimrQueryExecutor::TQueryResult> Results;
     THashMap<ui64, TIntrusivePtr<IKikimrQueryExecutor::TAsyncQueryResult>> InProgress;
     TVector<ui64> ExecutionOrder;
-
+ 
     NActors::TActorId ReplyTarget;
     TMaybe<NKikimrKqp::TRlPath> RlPath;
 
@@ -150,22 +150,22 @@ struct TKikimrQueryContext : TThrRefBase {
         return *cached;
     }
 
-    void Reset() {
-        PrepareOnly = false;
+    void Reset() { 
+        PrepareOnly = false; 
         SuppressDdlChecks = false;
-        StatsMode = EKikimrStatsMode::None;
-        Type = EKikimrQueryType::Unspecified;
-        Deadlines = {};
-        Limits = {};
-
+        StatsMode = EKikimrStatsMode::None; 
+        Type = EKikimrQueryType::Unspecified; 
+        Deadlines = {}; 
+        Limits = {}; 
+ 
         QueryTraits.reset();
         PreparingQuery.reset();
         PreparedQuery.reset();
-        Parameters.clear();
-
-        Results.clear();
-        InProgress.clear();
-        ExecutionOrder.clear();
+        Parameters.clear(); 
+ 
+        Results.clear(); 
+        InProgress.clear(); 
+        ExecutionOrder.clear(); 
 
         RlPath.Clear();
 
@@ -173,181 +173,181 @@ struct TKikimrQueryContext : TThrRefBase {
         std::get<0>(CachedRandom).reset();
         std::get<1>(CachedRandom).reset();
         std::get<2>(CachedRandom).reset();
-    }
-};
-
-class TKikimrTableDescription {
-public:
-    TKikimrTableDescription() {}
-
-    TKikimrTableDescription(const TKikimrTableDescription&) = delete;
-    TKikimrTableDescription& operator=(const TKikimrTableDescription&) = delete;
-
-    TKikimrTableMetadataPtr Metadata = nullptr;
-    const TStructExprType* SchemeNode = nullptr;
+    } 
+}; 
+ 
+class TKikimrTableDescription { 
+public: 
+    TKikimrTableDescription() {} 
+ 
+    TKikimrTableDescription(const TKikimrTableDescription&) = delete; 
+    TKikimrTableDescription& operator=(const TKikimrTableDescription&) = delete; 
+ 
+    TKikimrTableMetadataPtr Metadata = nullptr; 
+    const TStructExprType* SchemeNode = nullptr; 
     TMaybe<TString> RelativePath;
-
+ 
     bool Load(TExprContext& ctx, bool withVirtualColumns = false);
     void ToYson(NYson::TYsonWriter& writer) const;
-
+ 
     TMaybe<ui32> GetKeyColumnIndex(const TString& name) const;
     const TTypeAnnotationNode* GetColumnType(const TString& name) const;
-
+ 
     const THashMap<TString, const TTypeAnnotationNode*> GetColumnTypesMap() const { return ColumnTypes; }
-
-    bool DoesExist() const;
-
-    void RequireStats() { NeedsStats = true; }
-    bool GetNeedsStats() const { return NeedsStats; }
-
-private:
+ 
+    bool DoesExist() const; 
+ 
+    void RequireStats() { NeedsStats = true; } 
+    bool GetNeedsStats() const { return NeedsStats; } 
+ 
+private: 
     THashMap<TString, const TTypeAnnotationNode*> ColumnTypes;
-    bool NeedsStats = false;
-};
-
-class TKikimrTablesData : public TThrRefBase {
-public:
-    TKikimrTablesData() {}
-    TKikimrTablesData(const TKikimrTablesData&) = delete;
-    TKikimrTablesData& operator=(const TKikimrTablesData&) = delete;
-
+    bool NeedsStats = false; 
+}; 
+ 
+class TKikimrTablesData : public TThrRefBase { 
+public: 
+    TKikimrTablesData() {} 
+    TKikimrTablesData(const TKikimrTablesData&) = delete; 
+    TKikimrTablesData& operator=(const TKikimrTablesData&) = delete; 
+ 
     TKikimrTableDescription& GetOrAddTable(const TString& cluster, const TString& database, const TString& table);
     TKikimrTableDescription& GetTable(const TString& cluster, const TString& table);
-
-    const TKikimrTableDescription* EnsureTableExists(const TString& cluster, const TString& table,
+ 
+    const TKikimrTableDescription* EnsureTableExists(const TString& cluster, const TString& table, 
         TPositionHandle pos, TExprContext& ctx) const;
-
-    const TKikimrTableDescription& ExistingTable(const TStringBuf& cluster, const TStringBuf& table) const;
-
-    const THashMap<std::pair<TString, TString>, TKikimrTableDescription>& GetTables() const {
-        return Tables;
-    }
-
-    void Reset() {
-        Tables.clear();
-    }
-
-private:
+ 
+    const TKikimrTableDescription& ExistingTable(const TStringBuf& cluster, const TStringBuf& table) const; 
+ 
+    const THashMap<std::pair<TString, TString>, TKikimrTableDescription>& GetTables() const { 
+        return Tables; 
+    } 
+ 
+    void Reset() { 
+        Tables.clear(); 
+    } 
+ 
+private: 
     THashMap<std::pair<TString, TString>, TKikimrTableDescription> Tables;
-};
-
+}; 
+ 
 enum class TYdbOperation : ui32 {
     CreateTable          = 1 << 0,
     DropTable            = 1 << 1,
     AlterTable           = 1 << 2,
-    Select               = 1 << 3,
-    Upsert               = 1 << 4,
-    Replace              = 1 << 5,
-    Update               = 1 << 6,
-    Delete               = 1 << 7,
-    InsertRevert         = 1 << 8,
-    InsertAbort          = 1 << 9,
-    ReservedInsertIgnore = 1 << 10,
-    UpdateOn             = 1 << 11,
-    DeleteOn             = 1 << 12,
+    Select               = 1 << 3, 
+    Upsert               = 1 << 4, 
+    Replace              = 1 << 5, 
+    Update               = 1 << 6, 
+    Delete               = 1 << 7, 
+    InsertRevert         = 1 << 8, 
+    InsertAbort          = 1 << 9, 
+    ReservedInsertIgnore = 1 << 10, 
+    UpdateOn             = 1 << 11, 
+    DeleteOn             = 1 << 12, 
     CreateUser           = 1 << 13,
     AlterUser            = 1 << 14,
     DropUser             = 1 << 15,
     CreateGroup           = 1 << 16,
     AlterGroup            = 1 << 17,
     DropGroup             = 1 << 18
-};
-
+}; 
+ 
 Y_DECLARE_FLAGS(TYdbOperations, TYdbOperation)
 Y_DECLARE_OPERATORS_FOR_FLAGS(TYdbOperations)
-
-class IKikimrTransactionContext : public TThrRefBase {
-public:
-    virtual void Invalidate() = 0;
-    virtual void Finish() = 0;
-
-    virtual bool IsInvalidated() const = 0;
-    virtual bool IsClosed() const = 0;
-
-    virtual bool ApplyTableOperations(const TVector<NKqpProto::TKqpTableOp>& operations,
-        const TVector<NKqpProto::TKqpTableInfo>& tableInfo, NKikimrKqp::EIsolationLevel isolationLevel,
+ 
+class IKikimrTransactionContext : public TThrRefBase { 
+public: 
+    virtual void Invalidate() = 0; 
+    virtual void Finish() = 0; 
+ 
+    virtual bool IsInvalidated() const = 0; 
+    virtual bool IsClosed() const = 0; 
+ 
+    virtual bool ApplyTableOperations(const TVector<NKqpProto::TKqpTableOp>& operations, 
+        const TVector<NKqpProto::TKqpTableInfo>& tableInfo, NKikimrKqp::EIsolationLevel isolationLevel, 
         bool strictDml, EKikimrQueryType queryType, TExprContext& ctx) = 0;
-
-    virtual ~IKikimrTransactionContext() = default;
-};
-
-class TKikimrTransactionContextBase : public IKikimrTransactionContext {
-public:
+ 
+    virtual ~IKikimrTransactionContext() = default; 
+}; 
+ 
+class TKikimrTransactionContextBase : public IKikimrTransactionContext { 
+public: 
     THashMap<TString, TYdbOperations> TableOperations;
-    THashMap<TKikimrPathId, TString> TableByIdMap;
-    TMaybe<NKikimrKqp::EIsolationLevel> EffectiveIsolationLevel;
-    bool Readonly = false;
-    bool Invalidated = false;
-    bool Closed = false;
-
-    bool HasStarted() const {
-        return EffectiveIsolationLevel.Defined();
-    }
-
-    bool IsInvalidated() const override {
-        return Invalidated;
-    }
-
-    bool IsClosed() const override {
-        return Closed;
-    }
-
-    void Finish() override {
-        Closed = true;
-    }
-
-    void Invalidate() override {
-        if (HasStarted()) {
-            Invalidated = true;
-        }
-    }
-
-    void Reset() {
-        TableOperations.clear();
-        TableByIdMap.clear();
-        EffectiveIsolationLevel.Clear();
-        Invalidated = false;
-        Readonly = false;
-        Closed = false;
-    }
-
-    bool ApplyTableOperations(const TVector<NKqpProto::TKqpTableOp>& operations, const TVector<NKqpProto::TKqpTableInfo>& tableInfo,
+    THashMap<TKikimrPathId, TString> TableByIdMap; 
+    TMaybe<NKikimrKqp::EIsolationLevel> EffectiveIsolationLevel; 
+    bool Readonly = false; 
+    bool Invalidated = false; 
+    bool Closed = false; 
+ 
+    bool HasStarted() const { 
+        return EffectiveIsolationLevel.Defined(); 
+    } 
+ 
+    bool IsInvalidated() const override { 
+        return Invalidated; 
+    } 
+ 
+    bool IsClosed() const override { 
+        return Closed; 
+    } 
+ 
+    void Finish() override { 
+        Closed = true; 
+    } 
+ 
+    void Invalidate() override { 
+        if (HasStarted()) { 
+            Invalidated = true; 
+        } 
+    } 
+ 
+    void Reset() { 
+        TableOperations.clear(); 
+        TableByIdMap.clear(); 
+        EffectiveIsolationLevel.Clear(); 
+        Invalidated = false; 
+        Readonly = false; 
+        Closed = false; 
+    } 
+ 
+    bool ApplyTableOperations(const TVector<NKqpProto::TKqpTableOp>& operations, const TVector<NKqpProto::TKqpTableInfo>& tableInfo, 
         NKikimrKqp::EIsolationLevel isolationLevel, bool strictDml, EKikimrQueryType queryType, TExprContext& ctx) override;
-};
-
-class TKikimrSessionContext : public TThrRefBase {
-public:
-    TKikimrSessionContext(TKikimrConfiguration::TPtr config, TIntrusivePtr<IKikimrTransactionContext> txCtx = nullptr)
-        : Configuration(config)
-        , TablesData(MakeIntrusive<TKikimrTablesData>())
-        , QueryCtx(MakeIntrusive<TKikimrQueryContext>())
-        , TxCtx(txCtx) {}
-
-    TKikimrSessionContext(const TKikimrSessionContext&) = delete;
-    TKikimrSessionContext& operator=(const TKikimrSessionContext&) = delete;
-
-    TKikimrConfiguration& Config() { return *Configuration; }
-    TKikimrTablesData& Tables() { return *TablesData; }
-    TKikimrQueryContext& Query() { return *QueryCtx; }
-    IKikimrTransactionContext& Tx() { Y_VERIFY(HasTx()); return *TxCtx; }
-
-    TKikimrConfiguration::TPtr ConfigPtr() { return Configuration; }
-    TIntrusivePtr<TKikimrTablesData> TablesPtr() { return TablesData; }
-    TIntrusivePtr<TKikimrQueryContext> QueryPtr() { return QueryCtx; }
-    TIntrusivePtr<IKikimrTransactionContext> TxPtr() { return TxCtx; }
-
-    bool HasTx() const { return !!TxCtx; }
-    void ClearTx() { TxCtx.Reset(); }
-    void SetTx(TIntrusivePtr<IKikimrTransactionContext>& txCtx) { TxCtx.Reset(txCtx); }
-
+}; 
+ 
+class TKikimrSessionContext : public TThrRefBase { 
+public: 
+    TKikimrSessionContext(TKikimrConfiguration::TPtr config, TIntrusivePtr<IKikimrTransactionContext> txCtx = nullptr) 
+        : Configuration(config) 
+        , TablesData(MakeIntrusive<TKikimrTablesData>()) 
+        , QueryCtx(MakeIntrusive<TKikimrQueryContext>()) 
+        , TxCtx(txCtx) {} 
+ 
+    TKikimrSessionContext(const TKikimrSessionContext&) = delete; 
+    TKikimrSessionContext& operator=(const TKikimrSessionContext&) = delete; 
+ 
+    TKikimrConfiguration& Config() { return *Configuration; } 
+    TKikimrTablesData& Tables() { return *TablesData; } 
+    TKikimrQueryContext& Query() { return *QueryCtx; } 
+    IKikimrTransactionContext& Tx() { Y_VERIFY(HasTx()); return *TxCtx; } 
+ 
+    TKikimrConfiguration::TPtr ConfigPtr() { return Configuration; } 
+    TIntrusivePtr<TKikimrTablesData> TablesPtr() { return TablesData; } 
+    TIntrusivePtr<TKikimrQueryContext> QueryPtr() { return QueryCtx; } 
+    TIntrusivePtr<IKikimrTransactionContext> TxPtr() { return TxCtx; } 
+ 
+    bool HasTx() const { return !!TxCtx; } 
+    void ClearTx() { TxCtx.Reset(); } 
+    void SetTx(TIntrusivePtr<IKikimrTransactionContext>& txCtx) { TxCtx.Reset(txCtx); } 
+ 
     TString GetUserName() const {
-        return UserName;
-    }
-
+        return UserName; 
+    } 
+ 
     void SetUserName(const TString& userName) {
-        UserName = userName;
-    }
-
+        UserName = userName; 
+    } 
+ 
     TString GetDatabase() const {
         return Database;
     }
@@ -356,38 +356,38 @@ public:
         Database = database;
     }
 
-    void Reset(bool keepConfigChanges) {
-        TablesData->Reset();
-        QueryCtx->Reset();
-        ClearTx();
-
-        if (!keepConfigChanges) {
-            Configuration->Restore();
-        }
-    }
-
-private:
-    TString UserName;
+    void Reset(bool keepConfigChanges) { 
+        TablesData->Reset(); 
+        QueryCtx->Reset(); 
+        ClearTx(); 
+ 
+        if (!keepConfigChanges) { 
+            Configuration->Restore(); 
+        } 
+    } 
+ 
+private: 
+    TString UserName; 
     TString Database;
-    TKikimrConfiguration::TPtr Configuration;
-    TIntrusivePtr<TKikimrTablesData> TablesData;
-    TIntrusivePtr<TKikimrQueryContext> QueryCtx;
-    TIntrusivePtr<IKikimrTransactionContext> TxCtx;
-};
-
-bool AddDmlIssue(const TIssue& issue, bool strictDml, TExprContext& ctx);
-
-TIntrusivePtr<IDataProvider> CreateKikimrDataSource(
-    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
+    TKikimrConfiguration::TPtr Configuration; 
+    TIntrusivePtr<TKikimrTablesData> TablesData; 
+    TIntrusivePtr<TKikimrQueryContext> QueryCtx; 
+    TIntrusivePtr<IKikimrTransactionContext> TxCtx; 
+}; 
+ 
+bool AddDmlIssue(const TIssue& issue, bool strictDml, TExprContext& ctx); 
+ 
+TIntrusivePtr<IDataProvider> CreateKikimrDataSource( 
+    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry, 
+    TTypeAnnotationContext& types, 
+    TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx); 
+ 
+TIntrusivePtr<IDataProvider> CreateKikimrDataSink( 
+    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry, 
     TTypeAnnotationContext& types,
-    TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx);
-
-TIntrusivePtr<IDataProvider> CreateKikimrDataSink(
-    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
-    TTypeAnnotationContext& types,
-    TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-    TIntrusivePtr<IKikimrQueryExecutor> queryExecutor);
-
-} // namespace NYql
+    TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+    TIntrusivePtr<IKikimrQueryExecutor> queryExecutor); 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_provider_impl.h b/ydb/core/kqp/provider/yql_kikimr_provider_impl.h
index e1aa3cda2b..903e719c07 100644
--- a/ydb/core/kqp/provider/yql_kikimr_provider_impl.h
+++ b/ydb/core/kqp/provider/yql_kikimr_provider_impl.h
@@ -1,83 +1,83 @@
-#pragma once
-
-#include "yql_kikimr_provider.h"
-
+#pragma once 
+ 
+#include "yql_kikimr_provider.h" 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.h>
 #include <ydb/core/kqp/provider/yql_kikimr_results.h>
-
+ 
 #include <ydb/library/yql/providers/common/provider/yql_provider.h>
 #include <ydb/library/yql/providers/common/provider/yql_table_lookup.h>
-
-
-namespace NYql {
-
-class TKiSourceVisitorTransformer: public TSyncTransformerBase {
-public:
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final;
-
-private:
-    virtual TStatus HandleKiRead(NNodes::TKiReadBase node, TExprContext& ctx) = 0;
-    virtual TStatus HandleRead(NNodes::TExprBase node, TExprContext& ctx) = 0;
-    virtual TStatus HandleLength(NNodes::TExprBase node, TExprContext& ctx) = 0;
-    virtual TStatus HandleConfigure(NNodes::TExprBase node, TExprContext& ctx) = 0;
-};
-
-class TKiSinkVisitorTransformer : public TSyncTransformerBase {
-public:
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final;
-
-private:
+ 
+ 
+namespace NYql { 
+ 
+class TKiSourceVisitorTransformer: public TSyncTransformerBase { 
+public: 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final; 
+ 
+private: 
+    virtual TStatus HandleKiRead(NNodes::TKiReadBase node, TExprContext& ctx) = 0; 
+    virtual TStatus HandleRead(NNodes::TExprBase node, TExprContext& ctx) = 0; 
+    virtual TStatus HandleLength(NNodes::TExprBase node, TExprContext& ctx) = 0; 
+    virtual TStatus HandleConfigure(NNodes::TExprBase node, TExprContext& ctx) = 0; 
+}; 
+ 
+class TKiSinkVisitorTransformer : public TSyncTransformerBase { 
+public: 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final; 
+ 
+private: 
     virtual TStatus HandleClusterConfig(NNodes::TKiClusterConfig, TExprContext& ctx) = 0;
-    virtual TStatus HandleWriteTable(NNodes::TKiWriteTable node, TExprContext& ctx) = 0;
-    virtual TStatus HandleUpdateTable(NNodes::TKiUpdateTable node, TExprContext& ctx) = 0;
-    virtual TStatus HandleDeleteTable(NNodes::TKiDeleteTable node, TExprContext& ctx) = 0;
-    virtual TStatus HandleCreateTable(NNodes::TKiCreateTable node, TExprContext& ctx) = 0;
+    virtual TStatus HandleWriteTable(NNodes::TKiWriteTable node, TExprContext& ctx) = 0; 
+    virtual TStatus HandleUpdateTable(NNodes::TKiUpdateTable node, TExprContext& ctx) = 0; 
+    virtual TStatus HandleDeleteTable(NNodes::TKiDeleteTable node, TExprContext& ctx) = 0; 
+    virtual TStatus HandleCreateTable(NNodes::TKiCreateTable node, TExprContext& ctx) = 0; 
     virtual TStatus HandleAlterTable(NNodes::TKiAlterTable node, TExprContext& ctx) = 0;
-    virtual TStatus HandleDropTable(NNodes::TKiDropTable node, TExprContext& ctx) = 0;
+    virtual TStatus HandleDropTable(NNodes::TKiDropTable node, TExprContext& ctx) = 0; 
     virtual TStatus HandleCreateUser(NNodes::TKiCreateUser node, TExprContext& ctx) = 0;
     virtual TStatus HandleAlterUser(NNodes::TKiAlterUser node, TExprContext& ctx) = 0;
     virtual TStatus HandleDropUser(NNodes::TKiDropUser node, TExprContext& ctx) = 0;
     virtual TStatus HandleCreateGroup(NNodes::TKiCreateGroup node, TExprContext& ctx) = 0;
     virtual TStatus HandleAlterGroup(NNodes::TKiAlterGroup node, TExprContext& ctx) = 0;
     virtual TStatus HandleDropGroup(NNodes::TKiDropGroup node, TExprContext& ctx) = 0;
-    virtual TStatus HandleWrite(NNodes::TExprBase node, TExprContext& ctx) = 0;
+    virtual TStatus HandleWrite(NNodes::TExprBase node, TExprContext& ctx) = 0; 
     virtual TStatus HandleCommit(NNodes::TCoCommit node, TExprContext& ctx) = 0;
-    virtual TStatus HandleKql(NNodes::TCallable node, TExprContext& ctx) = 0;
-    virtual TStatus HandleExecDataQuery(NNodes::TKiExecDataQuery node, TExprContext& ctx) = 0;
-    virtual TStatus HandleDataQuery(NNodes::TKiDataQuery node, TExprContext& ctx) = 0;
-    virtual TStatus HandleEffects(NNodes::TKiEffects node, TExprContext& ctx) = 0;
-};
-
-class TKikimrKey {
-public:
-    enum class Type {
-        Table,
-        TableList,
+    virtual TStatus HandleKql(NNodes::TCallable node, TExprContext& ctx) = 0; 
+    virtual TStatus HandleExecDataQuery(NNodes::TKiExecDataQuery node, TExprContext& ctx) = 0; 
+    virtual TStatus HandleDataQuery(NNodes::TKiDataQuery node, TExprContext& ctx) = 0; 
+    virtual TStatus HandleEffects(NNodes::TKiEffects node, TExprContext& ctx) = 0; 
+}; 
+ 
+class TKikimrKey { 
+public: 
+    enum class Type { 
+        Table, 
+        TableList, 
         TableScheme,
         Role
-    };
-
-public:
-    TKikimrKey(TExprContext& ctx)
-        : Ctx(ctx) {}
-
-    Type GetKeyType() const {
+    }; 
+ 
+public: 
+    TKikimrKey(TExprContext& ctx) 
+        : Ctx(ctx) {} 
+ 
+    Type GetKeyType() const { 
         Y_VERIFY_DEBUG(KeyType.Defined());
-        return *KeyType;
-    }
-
+        return *KeyType; 
+    } 
+ 
     TString GetTablePath() const {
         Y_VERIFY_DEBUG(KeyType.Defined());
         Y_VERIFY_DEBUG(KeyType == Type::Table || KeyType == Type::TableScheme);
         return Target;
-    }
-
+    } 
+ 
     TString GetFolderPath() const {
         Y_VERIFY_DEBUG(KeyType.Defined());
         Y_VERIFY_DEBUG(KeyType == Type::TableList);
         return Target;
-    }
-
+    } 
+ 
     TString GetRoleName() const {
         Y_VERIFY_DEBUG(KeyType.Defined());
         Y_VERIFY_DEBUG(KeyType == Type::Role);
@@ -89,121 +89,121 @@ public:
     }
 
     bool Extract(const TExprNode& key);
-
-private:
-    TExprContext& Ctx;
-    TMaybe<Type> KeyType;
+ 
+private: 
+    TExprContext& Ctx; 
+    TMaybe<Type> KeyType; 
     TString Target;
     TMaybe<TString> View;
-};
-
-struct TKiExecDataQuerySettings {
-    TMaybe<TString> Mode;
-    TMaybe<bool> UseNewEngine;
-    TVector<NNodes::TCoNameValueTuple> Other;
-
+}; 
+ 
+struct TKiExecDataQuerySettings { 
+    TMaybe<TString> Mode; 
+    TMaybe<bool> UseNewEngine; 
+    TVector<NNodes::TCoNameValueTuple> Other; 
+ 
     NNodes::TCoNameValueTupleList BuildNode(TExprContext& ctx, TPositionHandle pos) const;
-
-    static TKiExecDataQuerySettings Parse(NNodes::TKiExecDataQuery exec);
-};
-
-class TKikimrKeyRange {
-public:
+ 
+    static TKiExecDataQuerySettings Parse(NNodes::TKiExecDataQuery exec); 
+}; 
+ 
+class TKikimrKeyRange { 
+public: 
     TKikimrKeyRange(TExprContext& ctx, const TKikimrTableDescription& table);
-    TKikimrKeyRange(const TKikimrTableDescription& table, const NCommon::TKeyRange& keyRange);
-
-    static bool IsFull(NNodes::TExprList list);
+    TKikimrKeyRange(const TKikimrTableDescription& table, const NCommon::TKeyRange& keyRange); 
+ 
+    static bool IsFull(NNodes::TExprList list); 
     static TMaybe<NCommon::TKeyRange> GetPointKeyRange(TExprContext& ctx, const TKikimrTableDescription& table, NNodes::TExprList range);
-    static NNodes::TExprBase BuildReadRangeExpr(const TKikimrTableDescription& tableDesc,
+    static NNodes::TExprBase BuildReadRangeExpr(const TKikimrTableDescription& tableDesc, 
         const NCommon::TKeyRange& keyRange, NNodes::TCoAtomList select,  bool allowNulls,
         TExprContext& ctx);
     static NNodes::TExprBase BuildIndexReadRangeExpr(const TKikimrTableDescription& lookupTableDesc,
         const NCommon::TKeyRange& keyRange, NNodes::TCoAtomList select, bool allowNulls,
         const TKikimrTableDescription& dataTableDesc, TExprContext& ctx);
-
-    NNodes::TExprList ToRangeExpr(NNodes::TExprBase owner, TExprContext& ctx);
-
-private:
-    const TKikimrTableDescription& Table;
-    NCommon::TKeyRange KeyRange;
-};
-
-template<typename TResult>
-class TKikimrFutureResult : public IKikimrAsyncResult<TResult> {
-public:
-    TKikimrFutureResult(const NThreading::TFuture<TResult>& future, TExprContext& ctx)
-        : Future(future)
-        , ExprCtx(ctx)
-        , Completed(false) {}
-
-    bool HasResult() const override {
+ 
+    NNodes::TExprList ToRangeExpr(NNodes::TExprBase owner, TExprContext& ctx); 
+ 
+private: 
+    const TKikimrTableDescription& Table; 
+    NCommon::TKeyRange KeyRange; 
+}; 
+ 
+template<typename TResult> 
+class TKikimrFutureResult : public IKikimrAsyncResult<TResult> { 
+public: 
+    TKikimrFutureResult(const NThreading::TFuture<TResult>& future, TExprContext& ctx) 
+        : Future(future) 
+        , ExprCtx(ctx) 
+        , Completed(false) {} 
+ 
+    bool HasResult() const override { 
         if (Completed) {
             YQL_ENSURE(ExtractedResult.has_value());
         }
-        return Completed;
-    }
-
+        return Completed; 
+    } 
+ 
     TResult GetResult() override {
-        YQL_ENSURE(Completed);
+        YQL_ENSURE(Completed); 
         if (ExtractedResult) {
             return std::move(*ExtractedResult);
         }
         return std::move(Future.ExtractValue());
-    }
-
-    NThreading::TFuture<bool> Continue() override {
-        if (Completed) {
-            return NThreading::MakeFuture(true);
-        }
-
-        if (Future.HasValue()) {
+    } 
+ 
+    NThreading::TFuture<bool> Continue() override { 
+        if (Completed) { 
+            return NThreading::MakeFuture(true); 
+        } 
+ 
+        if (Future.HasValue()) { 
             ExtractedResult.emplace(std::move(Future.ExtractValue()));
             ExtractedResult->ReportIssues(ExprCtx.IssueManager);
-
-            Completed = true;
-            return NThreading::MakeFuture(true);
-        }
-
-        return Future.Apply([](const NThreading::TFuture<TResult>& future) {
-            YQL_ENSURE(future.HasValue());
-            return false;
-        });
-    }
-
-private:
-    NThreading::TFuture<TResult> Future;
+ 
+            Completed = true; 
+            return NThreading::MakeFuture(true); 
+        } 
+ 
+        return Future.Apply([](const NThreading::TFuture<TResult>& future) { 
+            YQL_ENSURE(future.HasValue()); 
+            return false; 
+        }); 
+    } 
+ 
+private: 
+    NThreading::TFuture<TResult> Future; 
     std::optional<TResult> ExtractedResult;
-    TExprContext& ExprCtx;
-    bool Completed;
-};
-
+    TExprContext& ExprCtx; 
+    bool Completed; 
+}; 
+ 
 TAutoPtr<IGraphTransformer> CreateKiSourceTypeAnnotationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx,
     TTypeAnnotationContext& types);
-TAutoPtr<IGraphTransformer> CreateKiSinkTypeAnnotationTransformer(TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx);
-TAutoPtr<IGraphTransformer> CreateKiLogicalOptProposalTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx);
-TAutoPtr<IGraphTransformer> CreateKiPhysicalOptProposalTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx);
-TAutoPtr<IGraphTransformer> CreateKiSourceLoadTableMetadataTransformer(TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx);
-TAutoPtr<IGraphTransformer> CreateKiSinkIntentDeterminationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx);
-
-TAutoPtr<IGraphTransformer> CreateKiSourceCallableExecutionTransformer(
-    TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx);
-
-TAutoPtr<IGraphTransformer> CreateKiSinkCallableExecutionTransformer(
-    TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx,
-    TIntrusivePtr<IKikimrQueryExecutor> queryExecutor);
-
-TAutoPtr<IGraphTransformer> CreateKiSinkPlanInfoTransformer(TIntrusivePtr<IKikimrQueryExecutor> queryExecutor);
-
-NNodes::TMaybeNode<NNodes::TExprBase> TranslateToMkql(NNodes::TExprBase node, TExprContext& ctx,
-    const TMaybe<TString>& rtParamName);
-
-NNodes::TExprBase UnwrapKiReadTableValues(NNodes::TExprBase input, const TKikimrTableDescription& tableDesc,
-    NNodes::TCoAtomList columns, TExprContext& ctx);
-
+TAutoPtr<IGraphTransformer> CreateKiSinkTypeAnnotationTransformer(TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx); 
+TAutoPtr<IGraphTransformer> CreateKiLogicalOptProposalTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx); 
+TAutoPtr<IGraphTransformer> CreateKiPhysicalOptProposalTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx); 
+TAutoPtr<IGraphTransformer> CreateKiSourceLoadTableMetadataTransformer(TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx); 
+TAutoPtr<IGraphTransformer> CreateKiSinkIntentDeterminationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx); 
+ 
+TAutoPtr<IGraphTransformer> CreateKiSourceCallableExecutionTransformer( 
+    TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx); 
+ 
+TAutoPtr<IGraphTransformer> CreateKiSinkCallableExecutionTransformer( 
+    TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx, 
+    TIntrusivePtr<IKikimrQueryExecutor> queryExecutor); 
+ 
+TAutoPtr<IGraphTransformer> CreateKiSinkPlanInfoTransformer(TIntrusivePtr<IKikimrQueryExecutor> queryExecutor); 
+ 
+NNodes::TMaybeNode<NNodes::TExprBase> TranslateToMkql(NNodes::TExprBase node, TExprContext& ctx, 
+    const TMaybe<TString>& rtParamName); 
+ 
+NNodes::TExprBase UnwrapKiReadTableValues(NNodes::TExprBase input, const TKikimrTableDescription& tableDesc, 
+    NNodes::TCoAtomList columns, TExprContext& ctx); 
+ 
 NNodes::TKiVersionedTable BuildVersionedTable(const TKikimrTableMetadata& metadata, TPositionHandle pos, TExprContext& ctx);
 NNodes::TCoAtomList BuildColumnsList(
     const TKikimrTableDescription& table,
@@ -219,66 +219,66 @@ NNodes::TCoAtomList BuildKeyColumnsList(
 
 NNodes::TCoAtomList MergeColumns(const NNodes::TCoAtomList& col1, const TVector<TString>& col2, TExprContext& ctx);
 
-bool IsKqlPureExpr(NNodes::TExprBase expr);
+bool IsKqlPureExpr(NNodes::TExprBase expr); 
 bool IsKqlPureLambda(NNodes::TCoLambda lambda);
 bool IsKeySelectorPkPrefix(NNodes::TCoLambda lambda, const TKikimrTableDescription& desc, TVector<TString>* columns);
-
+ 
 NNodes::TCoNameValueTupleList ExtractNamedKeyTuples(NNodes::TCoArgument arg,
     const TKikimrTableDescription& desc, TExprContext& ctx, const TString& tablePrefix = TString());
 
-const TTypeAnnotationNode* GetReadTableRowType(TExprContext& ctx, const TKikimrTablesData& tablesData,
+const TTypeAnnotationNode* GetReadTableRowType(TExprContext& ctx, const TKikimrTablesData& tablesData, 
     const TString& cluster, const TString& table, NNodes::TCoAtomList select, bool withSystemColumns = false);
-
-NKikimrKqp::EIsolationLevel GetIsolationLevel(const TMaybe<TString>& isolationLevel);
-TMaybe<TString> GetIsolationLevel(const NKikimrKqp::EIsolationLevel& isolationLevel);
-
+ 
+NKikimrKqp::EIsolationLevel GetIsolationLevel(const TMaybe<TString>& isolationLevel); 
+TMaybe<TString> GetIsolationLevel(const NKikimrKqp::EIsolationLevel& isolationLevel); 
+ 
 TYdbOperation GetTableOp(const NNodes::TKiWriteTable& write);
-TVector<NKqpProto::TKqpTableOp> TableOperationsToProto(const NNodes::TCoNameValueTupleList& operations, TExprContext& ctx);
-TVector<NKqpProto::TKqpTableOp> TableOperationsToProto(const NNodes::TKiOperationList& operations, TExprContext& ctx);
-void TableDescriptionToTableInfo(const TKikimrTableDescription& desc, NKqpProto::TKqpTableInfo* info);
-
-NNodes::TExprBase DeduplicateByMembers(const NNodes::TExprBase& expr, const TSet<TString>& members, TExprContext& ctx,
-    TPositionHandle pos);
-
-// Optimizer rules
-TExprNode::TPtr KiBuildQuery(NNodes::TExprBase node, const TMaybe<bool>& useNewEngine, TExprContext& ctx);
+TVector<NKqpProto::TKqpTableOp> TableOperationsToProto(const NNodes::TCoNameValueTupleList& operations, TExprContext& ctx); 
+TVector<NKqpProto::TKqpTableOp> TableOperationsToProto(const NNodes::TKiOperationList& operations, TExprContext& ctx); 
+void TableDescriptionToTableInfo(const TKikimrTableDescription& desc, NKqpProto::TKqpTableInfo* info); 
+ 
+NNodes::TExprBase DeduplicateByMembers(const NNodes::TExprBase& expr, const TSet<TString>& members, TExprContext& ctx, 
+    TPositionHandle pos); 
+ 
+// Optimizer rules 
+TExprNode::TPtr KiBuildQuery(NNodes::TExprBase node, const TMaybe<bool>& useNewEngine, TExprContext& ctx); 
 TExprNode::TPtr KiBuildResult(NNodes::TExprBase node,  const TString& cluster, TExprContext& ctx);
-TExprNode::TPtr KiApplyLimitToSelectRange(NNodes::TExprBase node, TExprContext& ctx);
-TExprNode::TPtr KiPushPredicateToSelectRange(NNodes::TExprBase node, TExprContext& ctx,
-    const TKikimrTablesData& tablesData, const TKikimrConfiguration& config);
-TExprNode::TPtr KiApplyExtractMembersToSelectRow(NNodes::TExprBase node, TExprContext& ctx);
-TExprNode::TPtr KiRewriteEquiJoin(NNodes::TExprBase node, const TKikimrTablesData& tablesData,
-    const TKikimrConfiguration& config, TExprContext& ctx);
+TExprNode::TPtr KiApplyLimitToSelectRange(NNodes::TExprBase node, TExprContext& ctx); 
+TExprNode::TPtr KiPushPredicateToSelectRange(NNodes::TExprBase node, TExprContext& ctx, 
+    const TKikimrTablesData& tablesData, const TKikimrConfiguration& config); 
+TExprNode::TPtr KiApplyExtractMembersToSelectRow(NNodes::TExprBase node, TExprContext& ctx); 
+TExprNode::TPtr KiRewriteEquiJoin(NNodes::TExprBase node, const TKikimrTablesData& tablesData, 
+    const TKikimrConfiguration& config, TExprContext& ctx); 
 TExprNode::TPtr KiSqlInToEquiJoin(NNodes::TExprBase node, const TKikimrTablesData& tablesData,
     const TKikimrConfiguration& config, TExprContext& ctx);
-
-bool KiTableLookupCanCompare(NNodes::TExprBase node);
-NNodes::TMaybeNode<NNodes::TExprBase> KiTableLookupGetValue(NNodes::TExprBase node, const TTypeAnnotationNode* type,
-    TExprContext& ctx);
-NCommon::TTableLookup::TCompareResult KiTableLookupCompare(NNodes::TExprBase left, NNodes::TExprBase right);
-
+ 
+bool KiTableLookupCanCompare(NNodes::TExprBase node); 
+NNodes::TMaybeNode<NNodes::TExprBase> KiTableLookupGetValue(NNodes::TExprBase node, const TTypeAnnotationNode* type, 
+    TExprContext& ctx); 
+NCommon::TTableLookup::TCompareResult KiTableLookupCompare(NNodes::TExprBase left, NNodes::TExprBase right); 
+ 
 NNodes::TKiProgram BuildKiProgram(NNodes::TKiDataQuery query, const TKikimrTablesData& tablesData, TExprContext& ctx,
     bool withSystemColumns);
-
+ 
 const THashSet<TStringBuf>& KikimrDataSourceFunctions();
 const THashSet<TStringBuf>& KikimrDataSinkFunctions();
 const THashSet<TStringBuf>& KikimrKqlFunctions();
-const THashSet<TStringBuf>& KikimrSupportedEffects();
-
+const THashSet<TStringBuf>& KikimrSupportedEffects(); 
+ 
 const THashSet<TStringBuf>& KikimrCommitModes();
-const TStringBuf& KikimrCommitModeFlush();
-const TStringBuf& KikimrCommitModeRollback();
-const TStringBuf& KikimrCommitModeScheme();
-
+const TStringBuf& KikimrCommitModeFlush(); 
+const TStringBuf& KikimrCommitModeRollback(); 
+const TStringBuf& KikimrCommitModeScheme(); 
+ 
 const TYdbOperations& KikimrSchemeOps();
 const TYdbOperations& KikimrDataOps();
 const TYdbOperations& KikimrModifyOps();
 const TYdbOperations& KikimrReadOps();
 const TYdbOperations& KikimrRequireUnmodifiedOps();
-
+ 
 const TMap<TString, NKikimr::NUdf::EDataSlot>& KikimrSystemColumns();
 bool IsKikimrSystemColumn(const TStringBuf columnName);
 
 bool ValidateTableHasIndex(TKikimrTableMetadataPtr metadata, TExprContext& ctx, const TPositionHandle& pos);
 
-} // namespace NYql
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_results.cpp b/ydb/core/kqp/provider/yql_kikimr_results.cpp
index 8ec93f416d..417107072d 100644
--- a/ydb/core/kqp/provider/yql_kikimr_results.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_results.cpp
@@ -1,240 +1,240 @@
-#include "yql_kikimr_results.h"
-
+#include "yql_kikimr_results.h" 
+ 
 #include <ydb/library/binary_json/read.h>
 #include <ydb/library/dynumber/dynumber.h>
-
+ 
 #include <ydb/library/yql/providers/common/codec/yql_codec_results.h>
 #include <ydb/library/yql/providers/common/provider/yql_provider.h>
 #include <ydb/library/yql/providers/common/schema/expr/yql_expr_schema.h>
 #include <ydb/library/yql/public/decimal/yql_decimal.h>
-
-namespace NYql {
-
-using namespace NNodes;
-
-namespace {
-
-bool ResultsOverflow(ui64 rows, ui64 bytes, const IDataProvider::TFillSettings& fillSettings) {
-    if (fillSettings.RowsLimitPerWrite && rows >= *fillSettings.RowsLimitPerWrite) {
-        return true;
-    }
-
-    if (fillSettings.AllResultsBytesLimit && bytes >= *fillSettings.AllResultsBytesLimit) {
-        return true;
-    }
-
-    return false;
-}
-
+ 
+namespace NYql { 
+ 
+using namespace NNodes; 
+ 
+namespace { 
+ 
+bool ResultsOverflow(ui64 rows, ui64 bytes, const IDataProvider::TFillSettings& fillSettings) { 
+    if (fillSettings.RowsLimitPerWrite && rows >= *fillSettings.RowsLimitPerWrite) { 
+        return true; 
+    } 
+ 
+    if (fillSettings.AllResultsBytesLimit && bytes >= *fillSettings.AllResultsBytesLimit) { 
+        return true; 
+    } 
+ 
+    return false; 
+} 
+ 
 void WriteValueToYson(const TStringStream& stream, NCommon::TYsonResultWriter& writer, const NKikimrMiniKQL::TType& type,
     const NKikimrMiniKQL::TValue& value, const TVector<TString>* fieldsOrder,
-    const IDataProvider::TFillSettings& fillSettings, bool& truncated, bool firstLevel = false)
-{
-    switch (type.GetKind()) {
-        case NKikimrMiniKQL::ETypeKind::Void:
+    const IDataProvider::TFillSettings& fillSettings, bool& truncated, bool firstLevel = false) 
+{ 
+    switch (type.GetKind()) { 
+        case NKikimrMiniKQL::ETypeKind::Void: 
             writer.OnVoid();
-            return;
-
-        case NKikimrMiniKQL::ETypeKind::Data:
-        {
-            if (type.GetData().GetScheme() == NYql::NProto::TypeIds::Decimal) {
-                using NYql::NDecimal::ToString;
-                using NYql::NDecimal::FromProto;
-
-                auto decimalParams = type.GetData().GetDecimalParams();
-                const auto& str = ToString(FromProto(value), decimalParams.GetPrecision(), decimalParams.GetScale());
-                writer.OnUtf8StringScalar(str);
-
-                return;
-            }
-
-            if (type.GetData().GetScheme() == NYql::NProto::TypeIds::Uuid) {
-                using NKikimr::NMiniKQL::UuidHalfsToByteString;
-
-                TStringStream stream;
-                UuidHalfsToByteString(value.GetLow128(), value.GetHi128(), stream);
-                writer.OnStringScalar(stream.Str());
-
-                return;
-            }
-
-            if (type.GetData().GetScheme() == NYql::NProto::TypeIds::DyNumber) {
-                using NKikimr::NDyNumber::DyNumberToString;
-
-                const auto number = DyNumberToString(value.GetBytes());
-                YQL_ENSURE(number.Defined(), "Invalid DyNumber binary representation");
-                writer.OnStringScalar(*number);
-
-                return;
-            }
-
-            if (type.GetData().GetScheme() == NYql::NProto::TypeIds::JsonDocument) {
-                using NKikimr::NBinaryJson::SerializeToJson;
-
-                const auto json = SerializeToJson(value.GetBytes());
-                writer.OnStringScalar(json);
-
-                return;
-            }
-
-            if (value.HasBool()) {
-                writer.OnBooleanScalar(value.GetBool());
-            }
-
-            if (value.HasInt32()) {
-                writer.OnInt64Scalar(value.GetInt32());
-            }
-
-            if (value.HasUint32()) {
-                writer.OnUint64Scalar(value.GetUint32());
-            }
-
-            if (value.HasInt64()) {
-                writer.OnInt64Scalar(value.GetInt64());
-            }
-
-            if (value.HasUint64()) {
-                writer.OnUint64Scalar(value.GetUint64());
-            }
-
-            if (value.HasFloat()) {
+            return; 
+ 
+        case NKikimrMiniKQL::ETypeKind::Data: 
+        { 
+            if (type.GetData().GetScheme() == NYql::NProto::TypeIds::Decimal) { 
+                using NYql::NDecimal::ToString; 
+                using NYql::NDecimal::FromProto; 
+ 
+                auto decimalParams = type.GetData().GetDecimalParams(); 
+                const auto& str = ToString(FromProto(value), decimalParams.GetPrecision(), decimalParams.GetScale()); 
+                writer.OnUtf8StringScalar(str); 
+ 
+                return; 
+            } 
+ 
+            if (type.GetData().GetScheme() == NYql::NProto::TypeIds::Uuid) { 
+                using NKikimr::NMiniKQL::UuidHalfsToByteString; 
+ 
+                TStringStream stream; 
+                UuidHalfsToByteString(value.GetLow128(), value.GetHi128(), stream); 
+                writer.OnStringScalar(stream.Str()); 
+ 
+                return; 
+            } 
+ 
+            if (type.GetData().GetScheme() == NYql::NProto::TypeIds::DyNumber) { 
+                using NKikimr::NDyNumber::DyNumberToString; 
+ 
+                const auto number = DyNumberToString(value.GetBytes()); 
+                YQL_ENSURE(number.Defined(), "Invalid DyNumber binary representation"); 
+                writer.OnStringScalar(*number); 
+ 
+                return; 
+            } 
+ 
+            if (type.GetData().GetScheme() == NYql::NProto::TypeIds::JsonDocument) { 
+                using NKikimr::NBinaryJson::SerializeToJson; 
+ 
+                const auto json = SerializeToJson(value.GetBytes()); 
+                writer.OnStringScalar(json); 
+ 
+                return; 
+            } 
+ 
+            if (value.HasBool()) { 
+                writer.OnBooleanScalar(value.GetBool()); 
+            } 
+ 
+            if (value.HasInt32()) { 
+                writer.OnInt64Scalar(value.GetInt32()); 
+            } 
+ 
+            if (value.HasUint32()) { 
+                writer.OnUint64Scalar(value.GetUint32()); 
+            } 
+ 
+            if (value.HasInt64()) { 
+                writer.OnInt64Scalar(value.GetInt64()); 
+            } 
+ 
+            if (value.HasUint64()) { 
+                writer.OnUint64Scalar(value.GetUint64()); 
+            } 
+ 
+            if (value.HasFloat()) { 
                 writer.OnFloatScalar(value.GetFloat());
-            }
-
-            if (value.HasDouble()) {
-                writer.OnDoubleScalar(value.GetDouble());
-            }
-
-            if (value.HasBytes()) {
-                writer.OnStringScalar(value.GetBytes());
-            }
-
-            if (value.HasText()) {
-                writer.OnStringScalar(value.GetText());
-            }
-
-            return;
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Optional:
-            if (!value.HasOptional()) {
-                writer.OnEntity();
-                return;
-            }
-
-            writer.OnBeginList();
-            writer.OnListItem();
-            WriteValueToYson(stream, writer, type.GetOptional().GetItem(), value.GetOptional(),
-                nullptr, fillSettings, truncated);
-            writer.OnEndList();
-            return;
-
-        case NKikimrMiniKQL::ETypeKind::Tuple: {
-            writer.OnBeginList();
-            auto tupleType = type.GetTuple();
-
-            for (size_t i = 0; i < tupleType.ElementSize(); ++i) {
-                auto element = value.GetTuple(i);
-                auto elementType = tupleType.GetElement(i);
-
-                writer.OnListItem();
-                WriteValueToYson(stream, writer, elementType, element, nullptr, fillSettings, truncated);
-            }
-
-            writer.OnEndList();
-            return;
-        }
-
-        case NKikimrMiniKQL::ETypeKind::List: {
-            writer.OnBeginList();
-            ui64 rowsWritten = 0;
-            for (auto& item : value.GetList()) {
-                writer.OnListItem();
-
-                if (firstLevel) {
-                    if (ResultsOverflow(rowsWritten, stream.Size(), fillSettings)) {
-                        truncated = true;
-                        break;
-                    }
-                }
-
-                WriteValueToYson(stream, writer, type.GetList().GetItem(), item,
-                    firstLevel ? fieldsOrder : nullptr, fillSettings, truncated);
-                ++rowsWritten;
-            }
-            writer.OnEndList();
-            return;
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Struct:
-        {
-            writer.OnBeginList();
-            auto structType = type.GetStruct();
-
-            auto writeMember = [&stream, &structType, &value, &writer, &fillSettings, &truncated] (size_t index) {
-                auto member = structType.GetMember(index);
-                auto memberValue = value.GetStruct(index);
-                writer.OnListItem();
-                WriteValueToYson(stream, writer, member.GetType(), memberValue, nullptr,
-                    fillSettings, truncated);
-            };
-
-            if (fieldsOrder) {
-                YQL_ENSURE(fieldsOrder->size() == structType.MemberSize());
+            } 
+ 
+            if (value.HasDouble()) { 
+                writer.OnDoubleScalar(value.GetDouble()); 
+            } 
+ 
+            if (value.HasBytes()) { 
+                writer.OnStringScalar(value.GetBytes()); 
+            } 
+ 
+            if (value.HasText()) { 
+                writer.OnStringScalar(value.GetText()); 
+            } 
+ 
+            return; 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Optional: 
+            if (!value.HasOptional()) { 
+                writer.OnEntity(); 
+                return; 
+            } 
+ 
+            writer.OnBeginList(); 
+            writer.OnListItem(); 
+            WriteValueToYson(stream, writer, type.GetOptional().GetItem(), value.GetOptional(), 
+                nullptr, fillSettings, truncated); 
+            writer.OnEndList(); 
+            return; 
+ 
+        case NKikimrMiniKQL::ETypeKind::Tuple: { 
+            writer.OnBeginList(); 
+            auto tupleType = type.GetTuple(); 
+ 
+            for (size_t i = 0; i < tupleType.ElementSize(); ++i) { 
+                auto element = value.GetTuple(i); 
+                auto elementType = tupleType.GetElement(i); 
+ 
+                writer.OnListItem(); 
+                WriteValueToYson(stream, writer, elementType, element, nullptr, fillSettings, truncated); 
+            } 
+ 
+            writer.OnEndList(); 
+            return; 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::List: { 
+            writer.OnBeginList(); 
+            ui64 rowsWritten = 0; 
+            for (auto& item : value.GetList()) { 
+                writer.OnListItem(); 
+ 
+                if (firstLevel) { 
+                    if (ResultsOverflow(rowsWritten, stream.Size(), fillSettings)) { 
+                        truncated = true; 
+                        break; 
+                    } 
+                } 
+ 
+                WriteValueToYson(stream, writer, type.GetList().GetItem(), item, 
+                    firstLevel ? fieldsOrder : nullptr, fillSettings, truncated); 
+                ++rowsWritten; 
+            } 
+            writer.OnEndList(); 
+            return; 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Struct: 
+        { 
+            writer.OnBeginList(); 
+            auto structType = type.GetStruct(); 
+ 
+            auto writeMember = [&stream, &structType, &value, &writer, &fillSettings, &truncated] (size_t index) { 
+                auto member = structType.GetMember(index); 
+                auto memberValue = value.GetStruct(index); 
+                writer.OnListItem(); 
+                WriteValueToYson(stream, writer, member.GetType(), memberValue, nullptr, 
+                    fillSettings, truncated); 
+            }; 
+ 
+            if (fieldsOrder) { 
+                YQL_ENSURE(fieldsOrder->size() == structType.MemberSize()); 
                 TMap<TString, size_t> memberIndices;
-                for (size_t i = 0; i < structType.MemberSize(); ++i) {
-                    memberIndices[structType.GetMember(i).GetName()] = i;
-                }
-                for (auto& field : *fieldsOrder) {
-                    auto* memberIndex = memberIndices.FindPtr(field);
-                    YQL_ENSURE(memberIndex);
-
-                    writeMember(*memberIndex);
-                }
-            } else {
-                for (size_t i = 0; i < structType.MemberSize(); ++i) {
-                    writeMember(i);
-                }
-            }
-
-            writer.OnEndList();
-            return;
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Dict:
-        {
-            writer.OnBeginList();
-            auto dictType = type.GetDict();
-            auto keyType = dictType.GetKey();
-            auto payloadType = dictType.GetPayload();
-
-            for (auto& pair : value.GetDict()) {
-                writer.OnListItem();
-
-                writer.OnBeginList();
-                writer.OnListItem();
-                WriteValueToYson(stream, writer, keyType, pair.GetKey(), nullptr, fillSettings, truncated);
-                writer.OnListItem();
-                WriteValueToYson(stream, writer, payloadType, pair.GetPayload(), nullptr, fillSettings, truncated);
-                writer.OnEndList();
-            }
-
-            writer.OnEndList();
-            return;
-        }
-
-        default:
-            YQL_ENSURE(false, "Unsupported type: " + ToString((ui32)type.GetKind()));
-    }
-}
-
+                for (size_t i = 0; i < structType.MemberSize(); ++i) { 
+                    memberIndices[structType.GetMember(i).GetName()] = i; 
+                } 
+                for (auto& field : *fieldsOrder) { 
+                    auto* memberIndex = memberIndices.FindPtr(field); 
+                    YQL_ENSURE(memberIndex); 
+ 
+                    writeMember(*memberIndex); 
+                } 
+            } else { 
+                for (size_t i = 0; i < structType.MemberSize(); ++i) { 
+                    writeMember(i); 
+                } 
+            } 
+ 
+            writer.OnEndList(); 
+            return; 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Dict: 
+        { 
+            writer.OnBeginList(); 
+            auto dictType = type.GetDict(); 
+            auto keyType = dictType.GetKey(); 
+            auto payloadType = dictType.GetPayload(); 
+ 
+            for (auto& pair : value.GetDict()) { 
+                writer.OnListItem(); 
+ 
+                writer.OnBeginList(); 
+                writer.OnListItem(); 
+                WriteValueToYson(stream, writer, keyType, pair.GetKey(), nullptr, fillSettings, truncated); 
+                writer.OnListItem(); 
+                WriteValueToYson(stream, writer, payloadType, pair.GetPayload(), nullptr, fillSettings, truncated); 
+                writer.OnEndList(); 
+            } 
+ 
+            writer.OnEndList(); 
+            return; 
+        } 
+ 
+        default: 
+            YQL_ENSURE(false, "Unsupported type: " + ToString((ui32)type.GetKind())); 
+    } 
+} 
+ 
 TExprNode::TPtr MakeAtomForDataType(EDataSlot slot, const NKikimrMiniKQL::TValue& value,
     TPositionHandle pos, TExprContext& ctx)
-{
+{ 
     if (slot == EDataSlot::Bool) {
-        return ctx.NewAtom(pos, ToString(value.GetBool()));
+        return ctx.NewAtom(pos, ToString(value.GetBool())); 
     } else if (slot == EDataSlot::Uint8) {
-        return ctx.NewAtom(pos, ToString(ui8(value.GetUint32())));
+        return ctx.NewAtom(pos, ToString(ui8(value.GetUint32()))); 
     } else if (slot == EDataSlot::Int8) {
         return ctx.NewAtom(pos, ToString(i8(value.GetInt32())));
     } else if (slot == EDataSlot::Int16) {
@@ -242,312 +242,312 @@ TExprNode::TPtr MakeAtomForDataType(EDataSlot slot, const NKikimrMiniKQL::TValue
     } else if (slot == EDataSlot::Uint16) {
         return ctx.NewAtom(pos, ToString(ui16(value.GetUint32())));
     } else if (slot == EDataSlot::Int32) {
-        return ctx.NewAtom(pos, ToString(value.GetInt32()));
+        return ctx.NewAtom(pos, ToString(value.GetInt32())); 
     } else if (slot == EDataSlot::Uint32) {
-        return ctx.NewAtom(pos, ToString(value.GetUint32()));
+        return ctx.NewAtom(pos, ToString(value.GetUint32())); 
     } else if (slot == EDataSlot::Int64) {
-        return ctx.NewAtom(pos, ToString(value.GetInt64()));
+        return ctx.NewAtom(pos, ToString(value.GetInt64())); 
     } else if (slot == EDataSlot::Uint64) {
-        return ctx.NewAtom(pos, ToString(value.GetUint64()));
+        return ctx.NewAtom(pos, ToString(value.GetUint64())); 
     } else if (slot == EDataSlot::Float) {
-        return ctx.NewAtom(pos, ToString(value.GetFloat()));
+        return ctx.NewAtom(pos, ToString(value.GetFloat())); 
     } else if (slot == EDataSlot::Double) {
-        return ctx.NewAtom(pos, ToString(value.GetDouble()));
+        return ctx.NewAtom(pos, ToString(value.GetDouble())); 
     } else if (slot == EDataSlot::String) {
-        return ctx.NewAtom(pos, value.GetBytes());
+        return ctx.NewAtom(pos, value.GetBytes()); 
     } else if (slot == EDataSlot::Utf8) {
-        return ctx.NewAtom(pos, value.GetText());
+        return ctx.NewAtom(pos, value.GetText()); 
     } else if (slot == EDataSlot::Yson) {
-        return ctx.NewAtom(pos, value.GetBytes());
+        return ctx.NewAtom(pos, value.GetBytes()); 
     } else if (slot == EDataSlot::Json) {
-        return ctx.NewAtom(pos, value.GetText());
+        return ctx.NewAtom(pos, value.GetText()); 
     } else if (slot == EDataSlot::Date) {
-        return ctx.NewAtom(pos, ToString(ui16(value.GetUint32())));
+        return ctx.NewAtom(pos, ToString(ui16(value.GetUint32()))); 
     } else if (slot == EDataSlot::Datetime) {
-        return ctx.NewAtom(pos, ToString(value.GetUint32()));
+        return ctx.NewAtom(pos, ToString(value.GetUint32())); 
     } else if (slot == EDataSlot::Timestamp) {
-        return ctx.NewAtom(pos, ToString(value.GetUint64()));
+        return ctx.NewAtom(pos, ToString(value.GetUint64())); 
     } else if (slot == EDataSlot::Interval) {
         return ctx.NewAtom(pos, ToString(value.GetInt64()));
-    } else {
-       return nullptr;
-    }
-}
-
-} // namespace
-
-bool GetRunResultIndex(const NKikimrMiniKQL::TStructType& resultType, const TString& resultName, ui32& index) {
-    for (ui32 i = 0; i < resultType.MemberSize(); ++i) {
-        if (resultType.GetMember(i).GetName() == resultName) {
-            index = i;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-void UnpackKikimrRunResult(const NKikimrMiniKQL::TResult& runResult, const NKikimrMiniKQL::TTupleType*& tupleType,
-    const NKikimrMiniKQL::TValue*& tupleValue)
-{
-    const auto& structType = runResult.GetType().GetStruct();
-    ui32 resultIndex;
-    YQL_ENSURE(GetRunResultIndex(structType, "Result", resultIndex));
-
-    const auto& member = structType.GetMember(resultIndex);
-    const auto& memberType = member.GetType();
-    YQL_ENSURE(memberType.GetKind() == NKikimrMiniKQL::ETypeKind::Optional);
-    const auto& optionalType = memberType.GetOptional().GetItem();
-    YQL_ENSURE(optionalType.GetKind() == NKikimrMiniKQL::ETypeKind::Tuple);
-    tupleType = &optionalType.GetTuple();
-
-    const auto& structValue = runResult.GetValue().GetStruct(resultIndex);
-    YQL_ENSURE(structValue.HasOptional());
-    tupleValue = &structValue.GetOptional();
-}
-
-void GetKikimrUnpackedRunResult(const NKikimrMiniKQL::TResult& runResult, ui32 index,
-    const NKikimrMiniKQL::TType*& type, const NKikimrMiniKQL::TValue*& value)
-{
-    const NKikimrMiniKQL::TTupleType* tupleType;
-    const NKikimrMiniKQL::TValue* tupleValue;
-    UnpackKikimrRunResult(runResult, tupleType, tupleValue);
-
-    type = &tupleType->GetElement(index);
-    value = &tupleValue->GetTuple(index);
-}
-
-NKikimrMiniKQL::TResult GetKikimrUnpackedRunResult(const NKikimrMiniKQL::TResult& runResult, ui32 index) {
-    const NKikimrMiniKQL::TType* type;
-    const NKikimrMiniKQL::TValue* value;
-    GetKikimrUnpackedRunResult(runResult, index, type, value);
-    YQL_ENSURE(type);
-    YQL_ENSURE(value);
-
-    NKikimrMiniKQL::TResult result;
-    result.MutableType()->CopyFrom(*type);
-    result.MutableValue()->CopyFrom(*value);
-    return result;
-}
-
+    } else { 
+       return nullptr; 
+    } 
+} 
+ 
+} // namespace 
+ 
+bool GetRunResultIndex(const NKikimrMiniKQL::TStructType& resultType, const TString& resultName, ui32& index) { 
+    for (ui32 i = 0; i < resultType.MemberSize(); ++i) { 
+        if (resultType.GetMember(i).GetName() == resultName) { 
+            index = i; 
+            return true; 
+        } 
+    } 
+ 
+    return false; 
+} 
+ 
+void UnpackKikimrRunResult(const NKikimrMiniKQL::TResult& runResult, const NKikimrMiniKQL::TTupleType*& tupleType, 
+    const NKikimrMiniKQL::TValue*& tupleValue) 
+{ 
+    const auto& structType = runResult.GetType().GetStruct(); 
+    ui32 resultIndex; 
+    YQL_ENSURE(GetRunResultIndex(structType, "Result", resultIndex)); 
+ 
+    const auto& member = structType.GetMember(resultIndex); 
+    const auto& memberType = member.GetType(); 
+    YQL_ENSURE(memberType.GetKind() == NKikimrMiniKQL::ETypeKind::Optional); 
+    const auto& optionalType = memberType.GetOptional().GetItem(); 
+    YQL_ENSURE(optionalType.GetKind() == NKikimrMiniKQL::ETypeKind::Tuple); 
+    tupleType = &optionalType.GetTuple(); 
+ 
+    const auto& structValue = runResult.GetValue().GetStruct(resultIndex); 
+    YQL_ENSURE(structValue.HasOptional()); 
+    tupleValue = &structValue.GetOptional(); 
+} 
+ 
+void GetKikimrUnpackedRunResult(const NKikimrMiniKQL::TResult& runResult, ui32 index, 
+    const NKikimrMiniKQL::TType*& type, const NKikimrMiniKQL::TValue*& value) 
+{ 
+    const NKikimrMiniKQL::TTupleType* tupleType; 
+    const NKikimrMiniKQL::TValue* tupleValue; 
+    UnpackKikimrRunResult(runResult, tupleType, tupleValue); 
+ 
+    type = &tupleType->GetElement(index); 
+    value = &tupleValue->GetTuple(index); 
+} 
+ 
+NKikimrMiniKQL::TResult GetKikimrUnpackedRunResult(const NKikimrMiniKQL::TResult& runResult, ui32 index) { 
+    const NKikimrMiniKQL::TType* type; 
+    const NKikimrMiniKQL::TValue* value; 
+    GetKikimrUnpackedRunResult(runResult, index, type, value); 
+    YQL_ENSURE(type); 
+    YQL_ENSURE(value); 
+ 
+    NKikimrMiniKQL::TResult result; 
+    result.MutableType()->CopyFrom(*type); 
+    result.MutableValue()->CopyFrom(*value); 
+    return result; 
+} 
+ 
 TVector<NKikimrMiniKQL::TResult*> UnpackKikimrRunResult(const NKikimrMiniKQL::TResult& runResult, google::protobuf::Arena* arena) {
-    const NKikimrMiniKQL::TTupleType* tupleType;
-    const NKikimrMiniKQL::TValue* tupleValue;
-    UnpackKikimrRunResult(runResult, tupleType, tupleValue);
-
+    const NKikimrMiniKQL::TTupleType* tupleType; 
+    const NKikimrMiniKQL::TValue* tupleValue; 
+    UnpackKikimrRunResult(runResult, tupleType, tupleValue); 
+ 
     TVector<NKikimrMiniKQL::TResult*> results;
-    ui32 resultsSize = tupleType->ElementSize();
-    for (ui32 i = 0; i < resultsSize; ++i) {
+    ui32 resultsSize = tupleType->ElementSize(); 
+    for (ui32 i = 0; i < resultsSize; ++i) { 
         results.push_back(google::protobuf::Arena::CreateMessage<NKikimrMiniKQL::TResult>(arena));
         NKikimrMiniKQL::TResult* result = results.back();
         *result->MutableType() = tupleType->GetElement(i);
         *result->MutableValue() = tupleValue->GetTuple(i);
-    }
-
-    return results;
-}
-
+    } 
+ 
+    return results; 
+} 
+ 
 void KikimrResultToYson(const TStringStream& stream, NYson::TYsonWriter& writer, const NKikimrMiniKQL::TResult& result,
     const TVector<TString>& columnHints, const IDataProvider::TFillSettings& fillSettings, bool& truncated)
-{
-    truncated = false;
+{ 
+    truncated = false; 
     NCommon::TYsonResultWriter resultWriter(writer);
     WriteValueToYson(stream, resultWriter, result.GetType(), result.GetValue(), columnHints.empty() ? nullptr : &columnHints,
-        fillSettings, truncated, true);
-}
-
-bool IsRawKikimrResult(const NKikimrMiniKQL::TResult& result) {
-    auto& type = result.GetType();
-    if (type.GetKind() != NKikimrMiniKQL::ETypeKind::Struct) {
-        return true;
-    }
-
-    auto& structType = type.GetStruct();
-    if (structType.MemberSize() != 2) {
-        return true;
-    }
-
-    return structType.GetMember(0).GetName() != "Data" || structType.GetMember(1).GetName() != "Truncated";
-}
-
+        fillSettings, truncated, true); 
+} 
+ 
+bool IsRawKikimrResult(const NKikimrMiniKQL::TResult& result) { 
+    auto& type = result.GetType(); 
+    if (type.GetKind() != NKikimrMiniKQL::ETypeKind::Struct) { 
+        return true; 
+    } 
+ 
+    auto& structType = type.GetStruct(); 
+    if (structType.MemberSize() != 2) { 
+        return true; 
+    } 
+ 
+    return structType.GetMember(0).GetName() != "Data" || structType.GetMember(1).GetName() != "Truncated"; 
+} 
+ 
 NKikimrMiniKQL::TResult* KikimrResultToProto(const NKikimrMiniKQL::TResult& result, const TVector<TString>& columnHints,
     const IDataProvider::TFillSettings& fillSettings, google::protobuf::Arena* arena)
-{
+{ 
     NKikimrMiniKQL::TResult* packedResult = google::protobuf::Arena::CreateMessage<NKikimrMiniKQL::TResult>(arena);
     auto* packedType = packedResult->MutableType();
-    packedType->SetKind(NKikimrMiniKQL::ETypeKind::Struct);
-    auto* dataMember = packedType->MutableStruct()->AddMember();
-    dataMember->SetName("Data");
-    auto* truncatedMember = packedType->MutableStruct()->AddMember();
-    truncatedMember->SetName("Truncated");
-    truncatedMember->MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data);
+    packedType->SetKind(NKikimrMiniKQL::ETypeKind::Struct); 
+    auto* dataMember = packedType->MutableStruct()->AddMember(); 
+    dataMember->SetName("Data"); 
+    auto* truncatedMember = packedType->MutableStruct()->AddMember(); 
+    truncatedMember->SetName("Truncated"); 
+    truncatedMember->MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data); 
     truncatedMember->MutableType()->MutableData()->SetScheme(NKikimr::NUdf::TDataType<bool>::Id);
-
+ 
     auto* packedValue = packedResult->MutableValue();
-    auto* dataValue = packedValue->AddStruct();
-    auto* dataType = dataMember->MutableType();
-    auto* truncatedValue = packedValue->AddStruct();
-
-    bool truncated = false;
-    if (result.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::List) {
-        const auto& itemType = result.GetType().GetList().GetItem();
-
+    auto* dataValue = packedValue->AddStruct(); 
+    auto* dataType = dataMember->MutableType(); 
+    auto* truncatedValue = packedValue->AddStruct(); 
+ 
+    bool truncated = false; 
+    if (result.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::List) { 
+        const auto& itemType = result.GetType().GetList().GetItem(); 
+ 
         TMap<TString, size_t> memberIndices;
-        if (itemType.GetKind() == NKikimrMiniKQL::ETypeKind::Struct && !columnHints.empty()) {
-            const auto& structType = itemType.GetStruct();
-
-            for (size_t i = 0; i < structType.MemberSize(); ++i) {
-                memberIndices[structType.GetMember(i).GetName()] = i;
-            }
-
-            dataType->SetKind(NKikimrMiniKQL::ETypeKind::List);
-            auto* newItem = dataType->MutableList()->MutableItem();
-            newItem->SetKind(NKikimrMiniKQL::ETypeKind::Struct);
-            auto* newStructType = newItem->MutableStruct();
-            for (auto& column : columnHints) {
-                auto* memberIndex = memberIndices.FindPtr(column);
-                YQL_ENSURE(memberIndex);
-
-                *newStructType->AddMember() = structType.GetMember(*memberIndex);
-            }
-        } else {
-            *dataType = result.GetType();
-        }
-
-        ui64 rowsWritten = 0;
-        ui64 bytesWritten = 0;
-        for (auto& item : result.GetValue().GetList()) {
-            if (ResultsOverflow(rowsWritten, bytesWritten, fillSettings)) {
-                truncated = true;
-                break;
-            }
-
-            if (!memberIndices.empty()) {
-                auto* newStruct = dataValue->AddList();
-                for (auto& column : columnHints) {
-                    auto* memberIndex = memberIndices.FindPtr(column);
-                    YQL_ENSURE(memberIndex);
-
-                    *newStruct->AddStruct() = item.GetStruct(*memberIndex);
-                }
-            } else {
-                *dataValue->AddList() = item;
-            }
-
-            bytesWritten += item.ByteSize();
-            ++rowsWritten;
-        }
-    } else {
-        dataType->CopyFrom(result.GetType());
-        dataValue->CopyFrom(result.GetValue());
-    }
-
-    truncatedValue->SetBool(truncated);
-    return packedResult;
-}
-
-const TTypeAnnotationNode* ParseTypeFromKikimrProto(const NKikimrMiniKQL::TType& type, TExprContext& ctx) {
-    switch (type.GetKind()) {
-        case NKikimrMiniKQL::ETypeKind::Void: {
-            return ctx.MakeType<TVoidExprType>();
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Data: {
-            const NKikimrMiniKQL::TDataType& protoData = type.GetData();
-            auto schemeType = protoData.GetScheme();
-            auto slot = NKikimr::NUdf::FindDataSlot(schemeType);
-            if (!slot) {
-                ctx.AddError(TIssue(TPosition(), TStringBuilder() << "Unsupported data type: "
-                    << protoData.GetScheme()));
-                return nullptr;
-            }
-
-            if (schemeType == NYql::NProto::TypeIds::Decimal) {
-                return ctx.MakeType<TDataExprParamsType>(*slot, ToString(protoData.GetDecimalParams().GetPrecision()),
-                    ToString(protoData.GetDecimalParams().GetScale()));
-            } else {
-                return ctx.MakeType<TDataExprType>(*slot);
-            }
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Optional: {
-            auto itemType = ParseTypeFromKikimrProto(type.GetOptional().GetItem(), ctx);
-            if (!itemType) {
-                return nullptr;
-            }
-
-            return ctx.MakeType<TOptionalExprType>(itemType);
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Tuple: {
+        if (itemType.GetKind() == NKikimrMiniKQL::ETypeKind::Struct && !columnHints.empty()) { 
+            const auto& structType = itemType.GetStruct(); 
+ 
+            for (size_t i = 0; i < structType.MemberSize(); ++i) { 
+                memberIndices[structType.GetMember(i).GetName()] = i; 
+            } 
+ 
+            dataType->SetKind(NKikimrMiniKQL::ETypeKind::List); 
+            auto* newItem = dataType->MutableList()->MutableItem(); 
+            newItem->SetKind(NKikimrMiniKQL::ETypeKind::Struct); 
+            auto* newStructType = newItem->MutableStruct(); 
+            for (auto& column : columnHints) { 
+                auto* memberIndex = memberIndices.FindPtr(column); 
+                YQL_ENSURE(memberIndex); 
+ 
+                *newStructType->AddMember() = structType.GetMember(*memberIndex); 
+            } 
+        } else { 
+            *dataType = result.GetType(); 
+        } 
+ 
+        ui64 rowsWritten = 0; 
+        ui64 bytesWritten = 0; 
+        for (auto& item : result.GetValue().GetList()) { 
+            if (ResultsOverflow(rowsWritten, bytesWritten, fillSettings)) { 
+                truncated = true; 
+                break; 
+            } 
+ 
+            if (!memberIndices.empty()) { 
+                auto* newStruct = dataValue->AddList(); 
+                for (auto& column : columnHints) { 
+                    auto* memberIndex = memberIndices.FindPtr(column); 
+                    YQL_ENSURE(memberIndex); 
+ 
+                    *newStruct->AddStruct() = item.GetStruct(*memberIndex); 
+                } 
+            } else { 
+                *dataValue->AddList() = item; 
+            } 
+ 
+            bytesWritten += item.ByteSize(); 
+            ++rowsWritten; 
+        } 
+    } else { 
+        dataType->CopyFrom(result.GetType()); 
+        dataValue->CopyFrom(result.GetValue()); 
+    } 
+ 
+    truncatedValue->SetBool(truncated); 
+    return packedResult; 
+} 
+ 
+const TTypeAnnotationNode* ParseTypeFromKikimrProto(const NKikimrMiniKQL::TType& type, TExprContext& ctx) { 
+    switch (type.GetKind()) { 
+        case NKikimrMiniKQL::ETypeKind::Void: { 
+            return ctx.MakeType<TVoidExprType>(); 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Data: { 
+            const NKikimrMiniKQL::TDataType& protoData = type.GetData(); 
+            auto schemeType = protoData.GetScheme(); 
+            auto slot = NKikimr::NUdf::FindDataSlot(schemeType); 
+            if (!slot) { 
+                ctx.AddError(TIssue(TPosition(), TStringBuilder() << "Unsupported data type: " 
+                    << protoData.GetScheme())); 
+                return nullptr; 
+            } 
+ 
+            if (schemeType == NYql::NProto::TypeIds::Decimal) { 
+                return ctx.MakeType<TDataExprParamsType>(*slot, ToString(protoData.GetDecimalParams().GetPrecision()), 
+                    ToString(protoData.GetDecimalParams().GetScale())); 
+            } else { 
+                return ctx.MakeType<TDataExprType>(*slot); 
+            } 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Optional: { 
+            auto itemType = ParseTypeFromKikimrProto(type.GetOptional().GetItem(), ctx); 
+            if (!itemType) { 
+                return nullptr; 
+            } 
+ 
+            return ctx.MakeType<TOptionalExprType>(itemType); 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Tuple: { 
             TTypeAnnotationNode::TListType tupleItems;
-
-            for (auto& element : type.GetTuple().GetElement()) {
-                auto elementType = ParseTypeFromKikimrProto(element, ctx);
-                if (!elementType) {
-                    return nullptr;
-                }
-
-                tupleItems.push_back(elementType);
-            }
-
-            return ctx.MakeType<TTupleExprType>(tupleItems);
-        }
-
-        case NKikimrMiniKQL::ETypeKind::List: {
-            auto itemType = ParseTypeFromKikimrProto(type.GetList().GetItem(), ctx);
-            if (!itemType) {
-                return nullptr;
-            }
-
-            return ctx.MakeType<TListExprType>(itemType);
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Struct: {
+ 
+            for (auto& element : type.GetTuple().GetElement()) { 
+                auto elementType = ParseTypeFromKikimrProto(element, ctx); 
+                if (!elementType) { 
+                    return nullptr; 
+                } 
+ 
+                tupleItems.push_back(elementType); 
+            } 
+ 
+            return ctx.MakeType<TTupleExprType>(tupleItems); 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::List: { 
+            auto itemType = ParseTypeFromKikimrProto(type.GetList().GetItem(), ctx); 
+            if (!itemType) { 
+                return nullptr; 
+            } 
+ 
+            return ctx.MakeType<TListExprType>(itemType); 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Struct: { 
             TVector<const TItemExprType*> structMembers;
-            for (auto& member : type.GetStruct().GetMember()) {
-                auto memberType = ParseTypeFromKikimrProto(member.GetType(), ctx);
-                if (!memberType) {
-                    return nullptr;
-                }
-
-                structMembers.push_back(ctx.MakeType<TItemExprType>(member.GetName(), memberType));
-            }
-
-            return ctx.MakeType<TStructExprType>(structMembers);
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Dict: {
-            auto keyType = ParseTypeFromKikimrProto(type.GetDict().GetKey(), ctx);
-            if (!keyType) {
-                return nullptr;
-            }
-
-            auto payloadType = ParseTypeFromKikimrProto(type.GetDict().GetPayload(), ctx);
-            if (!payloadType) {
-                return nullptr;
-            }
-
-            return ctx.MakeType<TDictExprType>(keyType, payloadType);
-        }
-
-        default: {
-            ctx.AddError(TIssue(TPosition(), TStringBuilder() << "Unsupported protobuf type: "
-                << type.ShortDebugString()));
-            return nullptr;
-        }
-    }
-}
-
-bool ExportTypeToKikimrProto(const TTypeAnnotationNode& type, NKikimrMiniKQL::TType& protoType, TExprContext& ctx) {
-    switch (type.GetKind()) {
-        case ETypeAnnotationKind::Void: {
-            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Void);
-            return true;
-        }
-
-        case ETypeAnnotationKind::Data: {
-            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Data);
+            for (auto& member : type.GetStruct().GetMember()) { 
+                auto memberType = ParseTypeFromKikimrProto(member.GetType(), ctx); 
+                if (!memberType) { 
+                    return nullptr; 
+                } 
+ 
+                structMembers.push_back(ctx.MakeType<TItemExprType>(member.GetName(), memberType)); 
+            } 
+ 
+            return ctx.MakeType<TStructExprType>(structMembers); 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Dict: { 
+            auto keyType = ParseTypeFromKikimrProto(type.GetDict().GetKey(), ctx); 
+            if (!keyType) { 
+                return nullptr; 
+            } 
+ 
+            auto payloadType = ParseTypeFromKikimrProto(type.GetDict().GetPayload(), ctx); 
+            if (!payloadType) { 
+                return nullptr; 
+            } 
+ 
+            return ctx.MakeType<TDictExprType>(keyType, payloadType); 
+        } 
+ 
+        default: { 
+            ctx.AddError(TIssue(TPosition(), TStringBuilder() << "Unsupported protobuf type: " 
+                << type.ShortDebugString())); 
+            return nullptr; 
+        } 
+    } 
+} 
+ 
+bool ExportTypeToKikimrProto(const TTypeAnnotationNode& type, NKikimrMiniKQL::TType& protoType, TExprContext& ctx) { 
+    switch (type.GetKind()) { 
+        case ETypeAnnotationKind::Void: { 
+            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Void); 
+            return true; 
+        } 
+ 
+        case ETypeAnnotationKind::Data: { 
+            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
             auto slot = type.Cast<TDataExprType>()->GetSlot();
             auto typeId = NKikimr::NUdf::GetDataTypeInfo(slot).TypeId;
             if (typeId == NYql::NProto::TypeIds::Decimal) {
@@ -561,439 +561,439 @@ bool ExportTypeToKikimrProto(const TTypeAnnotationNode& type, NKikimrMiniKQL::TT
             } else {
                 protoType.MutableData()->SetScheme(typeId);
             }
-            return true;
-        }
-
-        case ETypeAnnotationKind::Optional: {
-            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Optional);
-            auto itemType = type.Cast<TOptionalExprType>()->GetItemType();
-            return ExportTypeToKikimrProto(*itemType, *protoType.MutableOptional()->MutableItem(), ctx);
-        }
-
-        case ETypeAnnotationKind::Tuple: {
-            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Tuple);
-            auto& protoTuple = *protoType.MutableTuple();
-            for (auto& itemType : type.Cast<TTupleExprType>()->GetItems()) {
-                if (!ExportTypeToKikimrProto(*itemType, *protoTuple.AddElement(), ctx)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        case ETypeAnnotationKind::List: {
-            protoType.SetKind(NKikimrMiniKQL::ETypeKind::List);
-            auto itemType = type.Cast<TListExprType>()->GetItemType();
-            return ExportTypeToKikimrProto(*itemType, *protoType.MutableList()->MutableItem(), ctx);
-        }
-
-        case ETypeAnnotationKind::Struct: {
-            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Struct);
-            auto& protoStruct = *protoType.MutableStruct();
-            for (auto& member : type.Cast<TStructExprType>()->GetItems()) {
-                auto& protoMember = *protoStruct.AddMember();
-                protoMember.SetName(TString(member->GetName()));
-                if (!ExportTypeToKikimrProto(*member->GetItemType(), *protoMember.MutableType(), ctx)) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        case ETypeAnnotationKind::Dict: {
-            auto& dictType = *type.Cast<TDictExprType>();
-
-            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Dict);
-            auto& protoDict = *protoType.MutableDict();
-
-            if (!ExportTypeToKikimrProto(*dictType.GetKeyType(), *protoDict.MutableKey(), ctx)) {
-                return false;
-            }
-            if (!ExportTypeToKikimrProto(*dictType.GetPayloadType(), *protoDict.MutablePayload(), ctx)) {
-                return false;
-            }
-
-            return true;
-        }
-
-        default: {
-            ctx.AddError(TIssue(TPosition(), TStringBuilder() << "Unsupported protobuf type: " << type));
-            return false;
-        }
-    }
-}
-
-TExprNode::TPtr ParseKikimrProtoValue(const NKikimrMiniKQL::TType& type, const NKikimrMiniKQL::TValue& value,
+            return true; 
+        } 
+ 
+        case ETypeAnnotationKind::Optional: { 
+            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Optional); 
+            auto itemType = type.Cast<TOptionalExprType>()->GetItemType(); 
+            return ExportTypeToKikimrProto(*itemType, *protoType.MutableOptional()->MutableItem(), ctx); 
+        } 
+ 
+        case ETypeAnnotationKind::Tuple: { 
+            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Tuple); 
+            auto& protoTuple = *protoType.MutableTuple(); 
+            for (auto& itemType : type.Cast<TTupleExprType>()->GetItems()) { 
+                if (!ExportTypeToKikimrProto(*itemType, *protoTuple.AddElement(), ctx)) { 
+                    return false; 
+                } 
+            } 
+            return true; 
+        } 
+ 
+        case ETypeAnnotationKind::List: { 
+            protoType.SetKind(NKikimrMiniKQL::ETypeKind::List); 
+            auto itemType = type.Cast<TListExprType>()->GetItemType(); 
+            return ExportTypeToKikimrProto(*itemType, *protoType.MutableList()->MutableItem(), ctx); 
+        } 
+ 
+        case ETypeAnnotationKind::Struct: { 
+            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Struct); 
+            auto& protoStruct = *protoType.MutableStruct(); 
+            for (auto& member : type.Cast<TStructExprType>()->GetItems()) { 
+                auto& protoMember = *protoStruct.AddMember(); 
+                protoMember.SetName(TString(member->GetName())); 
+                if (!ExportTypeToKikimrProto(*member->GetItemType(), *protoMember.MutableType(), ctx)) { 
+                    return false; 
+                } 
+            } 
+ 
+            return true; 
+        } 
+ 
+        case ETypeAnnotationKind::Dict: { 
+            auto& dictType = *type.Cast<TDictExprType>(); 
+ 
+            protoType.SetKind(NKikimrMiniKQL::ETypeKind::Dict); 
+            auto& protoDict = *protoType.MutableDict(); 
+ 
+            if (!ExportTypeToKikimrProto(*dictType.GetKeyType(), *protoDict.MutableKey(), ctx)) { 
+                return false; 
+            } 
+            if (!ExportTypeToKikimrProto(*dictType.GetPayloadType(), *protoDict.MutablePayload(), ctx)) { 
+                return false; 
+            } 
+ 
+            return true; 
+        } 
+ 
+        default: { 
+            ctx.AddError(TIssue(TPosition(), TStringBuilder() << "Unsupported protobuf type: " << type)); 
+            return false; 
+        } 
+    } 
+} 
+ 
+TExprNode::TPtr ParseKikimrProtoValue(const NKikimrMiniKQL::TType& type, const NKikimrMiniKQL::TValue& value, 
     TPositionHandle pos, TExprContext& ctx)
-{
+{ 
     auto position = ctx.GetPosition(pos);
-    switch (type.GetKind()) {
-        case NKikimrMiniKQL::ETypeKind::Void: {
-            return ctx.NewCallable(pos, "Void", {});
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Data: {
-            auto typeNode = ParseTypeFromKikimrProto(type, ctx);
-            if (!typeNode) {
-                return nullptr;
-            }
-
-            auto dataTypeNode = typeNode->Cast<TDataExprType>();
-            YQL_ENSURE(dataTypeNode);
-
+    switch (type.GetKind()) { 
+        case NKikimrMiniKQL::ETypeKind::Void: { 
+            return ctx.NewCallable(pos, "Void", {}); 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Data: { 
+            auto typeNode = ParseTypeFromKikimrProto(type, ctx); 
+            if (!typeNode) { 
+                return nullptr; 
+            } 
+ 
+            auto dataTypeNode = typeNode->Cast<TDataExprType>(); 
+            YQL_ENSURE(dataTypeNode); 
+ 
             auto valueAtom = MakeAtomForDataType(dataTypeNode->GetSlot(), value, pos, ctx);
-            if (!valueAtom) {
+            if (!valueAtom) { 
                 ctx.AddError(TIssue(position, TStringBuilder() << "Unsupported data type: "
                     << dataTypeNode->GetName()));
-                return nullptr;
-            }
+                return nullptr; 
+            } 
             return ctx.NewCallable(pos, dataTypeNode->GetName(), {valueAtom});
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Optional: {
-            const auto& itemType = type.GetOptional().GetItem();
-
-            if (value.HasOptional()) {
-                auto itemNode = ParseKikimrProtoValue(itemType, value.GetOptional(), pos, ctx);
-                if (!itemNode) {
-                    return nullptr;
-                }
-                return ctx.NewCallable(pos, "Just", {itemNode});
-            } else {
-                auto typeNode = ParseTypeFromKikimrProto(type, ctx);
-                if (!typeNode) {
-                    return nullptr;
-                }
-
-                return ctx.NewCallable(pos, "Nothing", {ExpandType(pos, *typeNode, ctx)});
-            }
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Tuple: {
-            const auto& tupleType = type.GetTuple();
-            if (tupleType.ElementSize() != value.TupleSize()) {
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Optional: { 
+            const auto& itemType = type.GetOptional().GetItem(); 
+ 
+            if (value.HasOptional()) { 
+                auto itemNode = ParseKikimrProtoValue(itemType, value.GetOptional(), pos, ctx); 
+                if (!itemNode) { 
+                    return nullptr; 
+                } 
+                return ctx.NewCallable(pos, "Just", {itemNode}); 
+            } else { 
+                auto typeNode = ParseTypeFromKikimrProto(type, ctx); 
+                if (!typeNode) { 
+                    return nullptr; 
+                } 
+ 
+                return ctx.NewCallable(pos, "Nothing", {ExpandType(pos, *typeNode, ctx)}); 
+            } 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Tuple: { 
+            const auto& tupleType = type.GetTuple(); 
+            if (tupleType.ElementSize() != value.TupleSize()) { 
                 ctx.AddError(TIssue(position, TStringBuilder() << "Bad tuple value, size mismatch"));
-                return nullptr;
-            }
-
+                return nullptr; 
+            } 
+ 
             TExprNode::TListType itemNodes;
-            for (ui32 i = 0; i < tupleType.ElementSize(); ++i) {
-                const auto& itemType = tupleType.GetElement(i);
-                auto itemNode = ParseKikimrProtoValue(itemType, value.GetTuple(i), pos, ctx);
-                if (!itemNode) {
-                    return nullptr;
-                }
-
-                itemNodes.push_back(itemNode);
-            }
-
-            return ctx.NewList(pos, std::move(itemNodes));
-        }
-
-        case NKikimrMiniKQL::ETypeKind::List: {
-            const auto& itemType = type.GetList().GetItem();
-            auto itemTypeNode = ParseTypeFromKikimrProto(itemType, ctx);
-            if (!itemTypeNode) {
-                return nullptr;
-            }
-
+            for (ui32 i = 0; i < tupleType.ElementSize(); ++i) { 
+                const auto& itemType = tupleType.GetElement(i); 
+                auto itemNode = ParseKikimrProtoValue(itemType, value.GetTuple(i), pos, ctx); 
+                if (!itemNode) { 
+                    return nullptr; 
+                } 
+ 
+                itemNodes.push_back(itemNode); 
+            } 
+ 
+            return ctx.NewList(pos, std::move(itemNodes)); 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::List: { 
+            const auto& itemType = type.GetList().GetItem(); 
+            auto itemTypeNode = ParseTypeFromKikimrProto(itemType, ctx); 
+            if (!itemTypeNode) { 
+                return nullptr; 
+            } 
+ 
             TExprNode::TListType itemNodes;
-            for (ui32 i = 0; i < value.ListSize(); ++i) {
-                auto itemNode = ParseKikimrProtoValue(itemType, value.GetList(i), pos, ctx);
-                if (!itemNode) {
-                    return nullptr;
-                }
-
-                itemNodes.push_back(itemNode);
-            }
-
-            return itemNodes.empty()
-                ? ctx.NewCallable(pos, "List", {
-                    ctx.NewCallable(pos, "ListType", {ExpandType(pos, *itemTypeNode, ctx)})})
-                : ctx.NewCallable(pos, "AsList", std::move(itemNodes));
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Struct: {
-            const auto& structType = type.GetStruct();
-            if (structType.MemberSize() != value.StructSize()) {
+            for (ui32 i = 0; i < value.ListSize(); ++i) { 
+                auto itemNode = ParseKikimrProtoValue(itemType, value.GetList(i), pos, ctx); 
+                if (!itemNode) { 
+                    return nullptr; 
+                } 
+ 
+                itemNodes.push_back(itemNode); 
+            } 
+ 
+            return itemNodes.empty() 
+                ? ctx.NewCallable(pos, "List", { 
+                    ctx.NewCallable(pos, "ListType", {ExpandType(pos, *itemTypeNode, ctx)})}) 
+                : ctx.NewCallable(pos, "AsList", std::move(itemNodes)); 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Struct: { 
+            const auto& structType = type.GetStruct(); 
+            if (structType.MemberSize() != value.StructSize()) { 
                 ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder() << "Bad struct value, size mismatch"));
-                return nullptr;
-            }
-
+                return nullptr; 
+            } 
+ 
             TExprNode::TListType structMembers;
-            for (ui32 i = 0; i < structType.MemberSize(); ++i) {
-                const auto& member = structType.GetMember(i);
-
-                auto memberValueNode = ParseKikimrProtoValue(member.GetType(), value.GetStruct(i), pos, ctx);
-                if (!memberValueNode) {
-                    return nullptr;
-                }
-
-                auto memberNode = ctx.NewList(pos, {
-                    ctx.NewAtom(pos, member.GetName()),
-                    memberValueNode
-                });
-
-                structMembers.push_back(memberNode);
-            }
-
-            return ctx.NewCallable(pos, "AsStruct", std::move(structMembers));
-        }
-
-        case NKikimrMiniKQL::ETypeKind::Dict: {
-            const auto& dictType = type.GetDict();
+            for (ui32 i = 0; i < structType.MemberSize(); ++i) { 
+                const auto& member = structType.GetMember(i); 
+ 
+                auto memberValueNode = ParseKikimrProtoValue(member.GetType(), value.GetStruct(i), pos, ctx); 
+                if (!memberValueNode) { 
+                    return nullptr; 
+                } 
+ 
+                auto memberNode = ctx.NewList(pos, { 
+                    ctx.NewAtom(pos, member.GetName()), 
+                    memberValueNode 
+                }); 
+ 
+                structMembers.push_back(memberNode); 
+            } 
+ 
+            return ctx.NewCallable(pos, "AsStruct", std::move(structMembers)); 
+        } 
+ 
+        case NKikimrMiniKQL::ETypeKind::Dict: { 
+            const auto& dictType = type.GetDict(); 
             TExprNode::TListType dictPairs;
-            for (ui32 i = 0; i < value.DictSize(); ++i) {
-                auto keyNode = ParseKikimrProtoValue(dictType.GetKey(), value.GetDict(i).GetKey(), pos, ctx);
-                if (!keyNode) {
-                    return nullptr;
-                }
-
-                auto payloadNode = ParseKikimrProtoValue(dictType.GetPayload(), value.GetDict(i).GetPayload(),
-                    pos, ctx);
-                if (!payloadNode) {
-                    return nullptr;
-                }
-
-                auto pairNode = ctx.NewList(pos, {
-                    keyNode,
-                    payloadNode
-                });
-
-                dictPairs.push_back(pairNode);
-            }
-
-            return ctx.NewCallable(pos, "AsDict", std::move(dictPairs));
-        }
-
-        default: {
+            for (ui32 i = 0; i < value.DictSize(); ++i) { 
+                auto keyNode = ParseKikimrProtoValue(dictType.GetKey(), value.GetDict(i).GetKey(), pos, ctx); 
+                if (!keyNode) { 
+                    return nullptr; 
+                } 
+ 
+                auto payloadNode = ParseKikimrProtoValue(dictType.GetPayload(), value.GetDict(i).GetPayload(), 
+                    pos, ctx); 
+                if (!payloadNode) { 
+                    return nullptr; 
+                } 
+ 
+                auto pairNode = ctx.NewList(pos, { 
+                    keyNode, 
+                    payloadNode 
+                }); 
+ 
+                dictPairs.push_back(pairNode); 
+            } 
+ 
+            return ctx.NewCallable(pos, "AsDict", std::move(dictPairs)); 
+        } 
+ 
+        default: { 
             ctx.AddError(TIssue(position, TStringBuilder() << "Unexpected type for protobuf value: " << type));
-            return nullptr;
-        }
-    }
-}
-
-bool CheckKqpResultType(const NKikimrMiniKQL::TResult& kqpResult, const TTypeAnnotationNode& expectedType,
-    TExprContext& ctx)
-{
-    YQL_ENSURE(kqpResult.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::Struct);
-    const auto& structType = kqpResult.GetType().GetStruct();
-    YQL_ENSURE(structType.GetMember(0).GetName() == "Data");
-    YQL_ENSURE(structType.GetMember(1).GetName() == "Truncated");
-
-    auto type = ParseTypeFromKikimrProto(structType.GetMember(0).GetType(), ctx);
-    if (!type) {
-        return false;
-    }
-
-    if (!expectedType.Equals(*type)) {
-        ctx.AddError(TIssue(TPosition(), TStringBuilder() << "Kikimr result type mismatch, expected: "
-            << expectedType << ", actual: " << *type));
-
-        return false;
-    }
-
-    return true;
-}
-
+            return nullptr; 
+        } 
+    } 
+} 
+ 
+bool CheckKqpResultType(const NKikimrMiniKQL::TResult& kqpResult, const TTypeAnnotationNode& expectedType, 
+    TExprContext& ctx) 
+{ 
+    YQL_ENSURE(kqpResult.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::Struct); 
+    const auto& structType = kqpResult.GetType().GetStruct(); 
+    YQL_ENSURE(structType.GetMember(0).GetName() == "Data"); 
+    YQL_ENSURE(structType.GetMember(1).GetName() == "Truncated"); 
+ 
+    auto type = ParseTypeFromKikimrProto(structType.GetMember(0).GetType(), ctx); 
+    if (!type) { 
+        return false; 
+    } 
+ 
+    if (!expectedType.Equals(*type)) { 
+        ctx.AddError(TIssue(TPosition(), TStringBuilder() << "Kikimr result type mismatch, expected: " 
+            << expectedType << ", actual: " << *type)); 
+ 
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
 TMaybe<TString> KqpResultToYson(const NKikimrMiniKQL::TResult& kqpResult, const NYson::EYsonFormat& ysonFormat,
-    TExprContext& ctx)
-{
-    YQL_ENSURE(kqpResult.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::Struct);
-    const auto& structType = kqpResult.GetType().GetStruct();
-    YQL_ENSURE(structType.GetMember(0).GetName() == "Data");
-    YQL_ENSURE(structType.GetMember(1).GetName() == "Truncated");
-
-    NKikimrMiniKQL::TResult dataResult;
-    dataResult.MutableType()->CopyFrom(structType.GetMember(0).GetType());
-    dataResult.MutableValue()->CopyFrom(kqpResult.GetValue().GetStruct(0));
-
-    TStringStream out;
+    TExprContext& ctx) 
+{ 
+    YQL_ENSURE(kqpResult.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::Struct); 
+    const auto& structType = kqpResult.GetType().GetStruct(); 
+    YQL_ENSURE(structType.GetMember(0).GetName() == "Data"); 
+    YQL_ENSURE(structType.GetMember(1).GetName() == "Truncated"); 
+ 
+    NKikimrMiniKQL::TResult dataResult; 
+    dataResult.MutableType()->CopyFrom(structType.GetMember(0).GetType()); 
+    dataResult.MutableValue()->CopyFrom(kqpResult.GetValue().GetStruct(0)); 
+ 
+    TStringStream out; 
     NYson::TYsonWriter writer(&out, ysonFormat, ::NYson::EYsonType::Node, true);
-    writer.OnBeginMap();
-    writer.OnKeyedItem("Type");
-
+    writer.OnBeginMap(); 
+    writer.OnKeyedItem("Type"); 
+ 
     TVector<TString> columns;
-    if (dataResult.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::List) {
-        const auto& itemType = dataResult.GetType().GetList().GetItem();
-        if (itemType.GetKind() == NKikimrMiniKQL::ETypeKind::Struct) {
-            for (auto& member : itemType.GetStruct().GetMember()) {
-                columns.push_back(member.GetName());
-            }
-        }
-    }
-
-    auto resultDataType = ParseTypeFromKikimrProto(dataResult.GetType(), ctx);
-    if (!resultDataType) {
-        return Nothing();
-    }
-    NCommon::WriteResOrPullType(writer, resultDataType, columns);
-
-    writer.OnKeyedItem("Data");
-
-    IDataProvider::TFillSettings fillSettings;
-    fillSettings.AllResultsBytesLimit = Nothing();
-    fillSettings.RowsLimitPerWrite = Nothing();
-    fillSettings.Format = IDataProvider::EResultFormat::Yson;
-    fillSettings.FormatDetails = ToString((ui32)ysonFormat);
-
-    bool truncated;
-    KikimrResultToYson(out, writer, dataResult, columns, fillSettings, truncated);
-    YQL_ENSURE(!truncated);
-
-    if (kqpResult.GetValue().GetStruct(1).GetBool()) {
-        writer.OnKeyedItem("Truncated");
-        writer.OnBooleanScalar(true);
-    }
-
-    writer.OnEndMap();
-    return out.Str();
-}
-
-TMaybe<TString> GetTableListResult(const IKikimrGateway::TListPathResult& res,
-    const IDataProvider::TFillSettings& fillSettings, TExprContext& ctx)
-{
-    NKikimrMiniKQL::TType stringType;
-    stringType.SetKind(NKikimrMiniKQL::ETypeKind::Data);
+    if (dataResult.GetType().GetKind() == NKikimrMiniKQL::ETypeKind::List) { 
+        const auto& itemType = dataResult.GetType().GetList().GetItem(); 
+        if (itemType.GetKind() == NKikimrMiniKQL::ETypeKind::Struct) { 
+            for (auto& member : itemType.GetStruct().GetMember()) { 
+                columns.push_back(member.GetName()); 
+            } 
+        } 
+    } 
+ 
+    auto resultDataType = ParseTypeFromKikimrProto(dataResult.GetType(), ctx); 
+    if (!resultDataType) { 
+        return Nothing(); 
+    } 
+    NCommon::WriteResOrPullType(writer, resultDataType, columns); 
+ 
+    writer.OnKeyedItem("Data"); 
+ 
+    IDataProvider::TFillSettings fillSettings; 
+    fillSettings.AllResultsBytesLimit = Nothing(); 
+    fillSettings.RowsLimitPerWrite = Nothing(); 
+    fillSettings.Format = IDataProvider::EResultFormat::Yson; 
+    fillSettings.FormatDetails = ToString((ui32)ysonFormat); 
+ 
+    bool truncated; 
+    KikimrResultToYson(out, writer, dataResult, columns, fillSettings, truncated); 
+    YQL_ENSURE(!truncated); 
+ 
+    if (kqpResult.GetValue().GetStruct(1).GetBool()) { 
+        writer.OnKeyedItem("Truncated"); 
+        writer.OnBooleanScalar(true); 
+    } 
+ 
+    writer.OnEndMap(); 
+    return out.Str(); 
+} 
+ 
+TMaybe<TString> GetTableListResult(const IKikimrGateway::TListPathResult& res, 
+    const IDataProvider::TFillSettings& fillSettings, TExprContext& ctx) 
+{ 
+    NKikimrMiniKQL::TType stringType; 
+    stringType.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
     stringType.MutableData()->SetScheme(NKikimr::NUdf::TDataType<char*>::Id);
-
-    NKikimrMiniKQL::TResult result;
-    auto& structType = *result.MutableType();
-    structType.SetKind(NKikimrMiniKQL::ETypeKind::Struct);
-    auto& prefixMember = *structType.MutableStruct()->AddMember();
-    prefixMember.SetName("Prefix");
-    prefixMember.MutableType()->CopyFrom(stringType);
-    auto& foldersMember = *structType.MutableStruct()->AddMember();
-    foldersMember.SetName("Folders");
-    foldersMember.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::List);
-    foldersMember.MutableType()->MutableList()->MutableItem()->CopyFrom(stringType);
-    auto& tablesMember = *structType.MutableStruct()->AddMember();
-    tablesMember.SetName("Tables");
-    tablesMember.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::List);
-    tablesMember.MutableType()->MutableList()->MutableItem()->CopyFrom(stringType);
-
-    auto& prefixValue = *result.MutableValue()->AddStruct();
-    auto& foldersValue = *result.MutableValue()->AddStruct();
-    auto& tablesValue = *result.MutableValue()->AddStruct();
-
-    prefixValue.SetBytes(res.Path);
-
-    for (const auto& item : res.Items) {
-        if (item.IsDirectory) {
-            foldersValue.AddList()->SetBytes(item.Name);
-        } else {
-            tablesValue.AddList()->SetBytes(item.Name);
-        }
-    }
-
+ 
+    NKikimrMiniKQL::TResult result; 
+    auto& structType = *result.MutableType(); 
+    structType.SetKind(NKikimrMiniKQL::ETypeKind::Struct); 
+    auto& prefixMember = *structType.MutableStruct()->AddMember(); 
+    prefixMember.SetName("Prefix"); 
+    prefixMember.MutableType()->CopyFrom(stringType); 
+    auto& foldersMember = *structType.MutableStruct()->AddMember(); 
+    foldersMember.SetName("Folders"); 
+    foldersMember.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::List); 
+    foldersMember.MutableType()->MutableList()->MutableItem()->CopyFrom(stringType); 
+    auto& tablesMember = *structType.MutableStruct()->AddMember(); 
+    tablesMember.SetName("Tables"); 
+    tablesMember.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::List); 
+    tablesMember.MutableType()->MutableList()->MutableItem()->CopyFrom(stringType); 
+ 
+    auto& prefixValue = *result.MutableValue()->AddStruct(); 
+    auto& foldersValue = *result.MutableValue()->AddStruct(); 
+    auto& tablesValue = *result.MutableValue()->AddStruct(); 
+ 
+    prefixValue.SetBytes(res.Path); 
+ 
+    for (const auto& item : res.Items) { 
+        if (item.IsDirectory) { 
+            foldersValue.AddList()->SetBytes(item.Name); 
+        } else { 
+            tablesValue.AddList()->SetBytes(item.Name); 
+        } 
+    } 
+ 
     std::unique_ptr<NKikimrMiniKQL::TResult> packedResult(KikimrResultToProto(result, {}, fillSettings, nullptr));
-
-    if (fillSettings.Format == IDataProvider::EResultFormat::Yson) {
+ 
+    if (fillSettings.Format == IDataProvider::EResultFormat::Yson) { 
         NYson::EYsonFormat ysonFormat = NCommon::GetYsonFormat(fillSettings);
         auto yson = KqpResultToYson(*packedResult, ysonFormat, ctx);
-        if (!yson) {
-            return Nothing();
-        }
-
-        return *yson;
-    } else {
-        YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Custom);
-        YQL_ENSURE(fillSettings.FormatDetails == KikimrMkqlProtoFormat);
-
+        if (!yson) { 
+            return Nothing(); 
+        } 
+ 
+        return *yson; 
+    } else { 
+        YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Custom); 
+        YQL_ENSURE(fillSettings.FormatDetails == KikimrMkqlProtoFormat); 
+ 
         TVector<char> buffer(packedResult->ByteSize());
         Y_PROTOBUF_SUPPRESS_NODISCARD packedResult->SerializeToArray(buffer.data(), buffer.size());
-        return TString(buffer.data(), buffer.size());
-    }
-}
-
-
-TMaybe<TString> GetTableMetadataResult(const TKikimrTableDescription& table,
-    const IDataProvider::TFillSettings& fillSettings, TExprContext& ctx)
-{
-    TStringStream out;
+        return TString(buffer.data(), buffer.size()); 
+    } 
+} 
+ 
+ 
+TMaybe<TString> GetTableMetadataResult(const TKikimrTableDescription& table, 
+    const IDataProvider::TFillSettings& fillSettings, TExprContext& ctx) 
+{ 
+    TStringStream out; 
     NYson::TYsonWriter writer(&out, NYson::EYsonFormat::Binary);
-    table.ToYson(writer);
-
-    auto metaYson = out.Str();
-
-    NKikimrMiniKQL::TResult result;
-    auto& resultType = *result.MutableType();
-    resultType.SetKind(NKikimrMiniKQL::ETypeKind::Data);
+    table.ToYson(writer); 
+ 
+    auto metaYson = out.Str(); 
+ 
+    NKikimrMiniKQL::TResult result; 
+    auto& resultType = *result.MutableType(); 
+    resultType.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
     resultType.MutableData()->SetScheme(NKikimr::NUdf::TDataType<NKikimr::NUdf::TYson>::Id);
-
-    result.MutableValue()->SetBytes(metaYson);
-
+ 
+    result.MutableValue()->SetBytes(metaYson); 
+ 
     std::unique_ptr<NKikimrMiniKQL::TResult> packedResult(KikimrResultToProto(result, {}, fillSettings, nullptr));
-
-    if (fillSettings.Format == IDataProvider::EResultFormat::Yson) {
+ 
+    if (fillSettings.Format == IDataProvider::EResultFormat::Yson) { 
         NYson::EYsonFormat ysonFormat = NCommon::GetYsonFormat(fillSettings);
         auto yson = KqpResultToYson(*packedResult, ysonFormat, ctx);
-        if (!yson) {
-            return Nothing();
-        }
-
-        return *yson;
-    } else {
-        YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Custom);
-        YQL_ENSURE(fillSettings.FormatDetails == KikimrMkqlProtoFormat);
-
+        if (!yson) { 
+            return Nothing(); 
+        } 
+ 
+        return *yson; 
+    } else { 
+        YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Custom); 
+        YQL_ENSURE(fillSettings.FormatDetails == KikimrMkqlProtoFormat); 
+ 
         TVector<char> buffer(packedResult->ByteSize());
         Y_PROTOBUF_SUPPRESS_NODISCARD packedResult->SerializeToArray(buffer.data(), buffer.size());
-        return TString(buffer.data(), buffer.size());
-    }
-}
-
-void TransformerStatsToProto(const TString& name, const IGraphTransformer::TStatistics& stats,
-    NKikimrKqp::TTransformProfile& profile)
-{
-    profile.SetName(name);
-    if (stats.TransformDuration.MicroSeconds() > 0) {
-        profile.SetTransformDurationUs(stats.TransformDuration.MicroSeconds());
-    }
-    if (stats.WaitDuration.MicroSeconds() > 0) {
-        profile.SetWaitDurationUs(stats.WaitDuration.MicroSeconds());
-    }
-    if (stats.NewExprNodes > 0) {
-        profile.SetNewExprNodes(stats.NewExprNodes);
-    }
-    if (stats.NewTypeNodes > 0) {
-        profile.SetNewTypeNodes(stats.NewTypeNodes);
-    }
+        return TString(buffer.data(), buffer.size()); 
+    } 
+} 
+ 
+void TransformerStatsToProto(const TString& name, const IGraphTransformer::TStatistics& stats, 
+    NKikimrKqp::TTransformProfile& profile) 
+{ 
+    profile.SetName(name); 
+    if (stats.TransformDuration.MicroSeconds() > 0) { 
+        profile.SetTransformDurationUs(stats.TransformDuration.MicroSeconds()); 
+    } 
+    if (stats.WaitDuration.MicroSeconds() > 0) { 
+        profile.SetWaitDurationUs(stats.WaitDuration.MicroSeconds()); 
+    } 
+    if (stats.NewExprNodes > 0) { 
+        profile.SetNewExprNodes(stats.NewExprNodes); 
+    } 
+    if (stats.NewTypeNodes > 0) { 
+        profile.SetNewTypeNodes(stats.NewTypeNodes); 
+    } 
     // TODO: stats.NewConstraintNodes
-    if (stats.Repeats > 0) {
-        profile.SetRepeats(stats.Repeats);
-    }
-    if (stats.Restarts > 0) {
-        profile.SetRestarts(stats.Restarts);
-    }
-
-    for (auto& stage : stats.Stages) {
-        TransformerStatsToProto(stage.first, stage.second, *profile.AddStages());
-    }
-}
-
-void TransformerStatsFromProto(const NKikimrKqp::TTransformProfile& proto, IGraphTransformer::TStatistics& stats,
-    TString& name)
-{
-    name = proto.GetName();
-
-    stats.TransformDuration = TDuration::MicroSeconds(proto.GetTransformDurationUs());
-    stats.WaitDuration = TDuration::MicroSeconds(proto.GetWaitDurationUs());
-    stats.NewExprNodes = proto.GetNewExprNodes();
-    stats.NewTypeNodes = proto.GetNewTypeNodes();
-    stats.Repeats = proto.GetRepeats();
-    stats.Restarts = proto.GetRestarts();
-
-    for (auto& protoStage : proto.GetStages()) {
-        TString stageName;
-        IGraphTransformer::TStatistics stageStats;
-
-        TransformerStatsFromProto(protoStage, stageStats, stageName);
-        stats.Stages.emplace_back(stageName, stageStats);
-    }
-}
-
+    if (stats.Repeats > 0) { 
+        profile.SetRepeats(stats.Repeats); 
+    } 
+    if (stats.Restarts > 0) { 
+        profile.SetRestarts(stats.Restarts); 
+    } 
+ 
+    for (auto& stage : stats.Stages) { 
+        TransformerStatsToProto(stage.first, stage.second, *profile.AddStages()); 
+    } 
+} 
+ 
+void TransformerStatsFromProto(const NKikimrKqp::TTransformProfile& proto, IGraphTransformer::TStatistics& stats, 
+    TString& name) 
+{ 
+    name = proto.GetName(); 
+ 
+    stats.TransformDuration = TDuration::MicroSeconds(proto.GetTransformDurationUs()); 
+    stats.WaitDuration = TDuration::MicroSeconds(proto.GetWaitDurationUs()); 
+    stats.NewExprNodes = proto.GetNewExprNodes(); 
+    stats.NewTypeNodes = proto.GetNewTypeNodes(); 
+    stats.Repeats = proto.GetRepeats(); 
+    stats.Restarts = proto.GetRestarts(); 
+ 
+    for (auto& protoStage : proto.GetStages()) { 
+        TString stageName; 
+        IGraphTransformer::TStatistics stageStats; 
+ 
+        TransformerStatsFromProto(protoStage, stageStats, stageName); 
+        stats.Stages.emplace_back(stageName, stageStats); 
+    } 
+} 
+ 
 void KikimrReadOpStatsToYson(const NKikimrQueryStats::TReadOpStats& opStats, NYson::TYsonWriter& writer) {
     writer.OnBeginMap();
     writer.OnKeyedItem("Count");
@@ -1070,19 +1070,19 @@ void KikimrTxStatsToYson(const NKikimrQueryStats::TTxStats& txStats, NYson::TYso
 }
 
 void KikimrProfileToYson(const NKikimrKqp::TKqlProfile& kqlProfile, NYson::TYsonWriter& writer) {
-    writer.OnBeginMap();
-    if (kqlProfile.HasQuery()) {
-        writer.OnKeyedItem("Query");
-        writer.OnStringScalar(kqlProfile.GetQuery());
-    }
-
-    writer.OnKeyedItem("MkqlProfiles");
-    writer.OnBeginList();
-    for (auto& mkql : kqlProfile.GetMkqlProfiles()) {
-        writer.OnListItem();
+    writer.OnBeginMap(); 
+    if (kqlProfile.HasQuery()) { 
+        writer.OnKeyedItem("Query"); 
+        writer.OnStringScalar(kqlProfile.GetQuery()); 
+    } 
+ 
+    writer.OnKeyedItem("MkqlProfiles"); 
+    writer.OnBeginList(); 
+    for (auto& mkql : kqlProfile.GetMkqlProfiles()) { 
+        writer.OnListItem(); 
         writer.OnBeginMap();
         writer.OnKeyedItem("Query");
-        writer.OnStringScalar(mkql.HasQuery() ? mkql.GetQuery() : "");
+        writer.OnStringScalar(mkql.HasQuery() ? mkql.GetQuery() : ""); 
 
         if (mkql.HasTxStats()) {
             writer.OnKeyedItem("TxStats");
@@ -1090,44 +1090,44 @@ void KikimrProfileToYson(const NKikimrKqp::TKqlProfile& kqlProfile, NYson::TYson
         }
 
         writer.OnEndMap();
-    }
-    writer.OnEndList();
-
-    if (kqlProfile.HasEffectiveIsolationLevel()) {
-        writer.OnKeyedItem("EffectiveIsolationLevel");
-        writer.OnStringScalar(NKikimrKqp::EIsolationLevel_Name(kqlProfile.GetEffectiveIsolationLevel()));
-    }
-
-    if (kqlProfile.HasTransformStats()) {
-        writer.OnKeyedItem("TransformStats");
-
-        TString transformName;
-        IGraphTransformer::TStatistics transformStats;
-        TransformerStatsFromProto(kqlProfile.GetTransformStats(), transformStats, transformName);
-        NCommon::TransformerStatsToYson(transformName, transformStats, writer);
-    }
-
-    writer.OnEndMap();
-}
-
+    } 
+    writer.OnEndList(); 
+ 
+    if (kqlProfile.HasEffectiveIsolationLevel()) { 
+        writer.OnKeyedItem("EffectiveIsolationLevel"); 
+        writer.OnStringScalar(NKikimrKqp::EIsolationLevel_Name(kqlProfile.GetEffectiveIsolationLevel())); 
+    } 
+ 
+    if (kqlProfile.HasTransformStats()) { 
+        writer.OnKeyedItem("TransformStats"); 
+ 
+        TString transformName; 
+        IGraphTransformer::TStatistics transformStats; 
+        TransformerStatsFromProto(kqlProfile.GetTransformStats(), transformStats, transformName); 
+        NCommon::TransformerStatsToYson(transformName, transformStats, writer); 
+    } 
+ 
+    writer.OnEndMap(); 
+} 
+ 
 void KikimrProfileToYson(const NKikimrKqp::TQueryProfile& queryProfile, NYson::TYsonWriter& writer) {
-    writer.OnBeginMap();
-    writer.OnKeyedItem("TransformStats");
-
-    TString transformName;
-    IGraphTransformer::TStatistics transformStats;
-    TransformerStatsFromProto(queryProfile.GetTransformStats(), transformStats, transformName);
-    NCommon::TransformerStatsToYson(transformName, transformStats, writer);
-
-    writer.OnKeyedItem("KqlProfiles");
-    writer.OnBeginList();
-    for (auto& kqlProfile : queryProfile.GetKqlProfiles()) {
-        writer.OnListItem();
-        KikimrProfileToYson(kqlProfile, writer);
-    }
-    writer.OnEndList();
-    writer.OnEndMap();
-}
-
-} // namespace NYql
-
+    writer.OnBeginMap(); 
+    writer.OnKeyedItem("TransformStats"); 
+ 
+    TString transformName; 
+    IGraphTransformer::TStatistics transformStats; 
+    TransformerStatsFromProto(queryProfile.GetTransformStats(), transformStats, transformName); 
+    NCommon::TransformerStatsToYson(transformName, transformStats, writer); 
+ 
+    writer.OnKeyedItem("KqlProfiles"); 
+    writer.OnBeginList(); 
+    for (auto& kqlProfile : queryProfile.GetKqlProfiles()) { 
+        writer.OnListItem(); 
+        KikimrProfileToYson(kqlProfile, writer); 
+    } 
+    writer.OnEndList(); 
+    writer.OnEndMap(); 
+} 
+ 
+} // namespace NYql 
+ 
diff --git a/ydb/core/kqp/provider/yql_kikimr_results.h b/ydb/core/kqp/provider/yql_kikimr_results.h
index c3460f8a07..76c1bed093 100644
--- a/ydb/core/kqp/provider/yql_kikimr_results.h
+++ b/ydb/core/kqp/provider/yql_kikimr_results.h
@@ -1,48 +1,48 @@
-#pragma once
-
-#include "yql_kikimr_provider.h"
-
-namespace NYql {
-
-bool GetRunResultIndex(const NKikimrMiniKQL::TStructType& resultType, const TString& resultName, ui32& index);
-
-NKikimrMiniKQL::TResult GetKikimrUnpackedRunResult(const NKikimrMiniKQL::TResult& runResult, ui32 index);
-void GetKikimrUnpackedRunResult(const NKikimrMiniKQL::TResult& runResult, ui32 index,
-    const NKikimrMiniKQL::TType*& type, const NKikimrMiniKQL::TValue*& value);
-
+#pragma once 
+ 
+#include "yql_kikimr_provider.h" 
+ 
+namespace NYql { 
+ 
+bool GetRunResultIndex(const NKikimrMiniKQL::TStructType& resultType, const TString& resultName, ui32& index); 
+ 
+NKikimrMiniKQL::TResult GetKikimrUnpackedRunResult(const NKikimrMiniKQL::TResult& runResult, ui32 index); 
+void GetKikimrUnpackedRunResult(const NKikimrMiniKQL::TResult& runResult, ui32 index, 
+    const NKikimrMiniKQL::TType*& type, const NKikimrMiniKQL::TValue*& value); 
+ 
 TVector<NKikimrMiniKQL::TResult*> UnpackKikimrRunResult(const NKikimrMiniKQL::TResult& runResult, google::protobuf::Arena* arena);
-
+ 
 void KikimrResultToYson(const TStringStream& stream, NYson::TYsonWriter& writer, const NKikimrMiniKQL::TResult& result,
     const TVector<TString>& columnHints, const IDataProvider::TFillSettings& fillSettings, bool& truncated);
-
+ 
 NKikimrMiniKQL::TResult* KikimrResultToProto(const NKikimrMiniKQL::TResult& result, const TVector<TString>& columnHints,
     const IDataProvider::TFillSettings& fillSettings, google::protobuf::Arena* arena);
-
-bool IsRawKikimrResult(const NKikimrMiniKQL::TResult& result);
-
-const TTypeAnnotationNode* ParseTypeFromKikimrProto(const NKikimrMiniKQL::TType& type, TExprContext& ctx);
-bool ExportTypeToKikimrProto(const TTypeAnnotationNode& type, NKikimrMiniKQL::TType& protoType, TExprContext& ctx);
-TExprNode::TPtr ParseKikimrProtoValue(const NKikimrMiniKQL::TType& type, const NKikimrMiniKQL::TValue& value,
+ 
+bool IsRawKikimrResult(const NKikimrMiniKQL::TResult& result); 
+ 
+const TTypeAnnotationNode* ParseTypeFromKikimrProto(const NKikimrMiniKQL::TType& type, TExprContext& ctx); 
+bool ExportTypeToKikimrProto(const TTypeAnnotationNode& type, NKikimrMiniKQL::TType& protoType, TExprContext& ctx); 
+TExprNode::TPtr ParseKikimrProtoValue(const NKikimrMiniKQL::TType& type, const NKikimrMiniKQL::TValue& value, 
     TPositionHandle pos, TExprContext& ctx);
-bool CheckKqpResultType(const NKikimrMiniKQL::TResult& kqpResult, const TTypeAnnotationNode& expectedType,
-    TExprContext& ctx);
-
+bool CheckKqpResultType(const NKikimrMiniKQL::TResult& kqpResult, const TTypeAnnotationNode& expectedType, 
+    TExprContext& ctx); 
+ 
 TMaybe<TString> KqpResultToYson(const NKikimrMiniKQL::TResult& kqpResult, const NYson::EYsonFormat& ysonFormat,
-    TExprContext& ctx);
-
-TMaybe<TString> GetTableListResult(const IKikimrGateway::TListPathResult& res,
-    const IDataProvider::TFillSettings& fillSettings, TExprContext& ctx);
-
-TMaybe<TString> GetTableMetadataResult(const TKikimrTableDescription& table,
-    const IDataProvider::TFillSettings& fillSettings, TExprContext& ctx);
-
-void TransformerStatsToProto(const TString& name, const IGraphTransformer::TStatistics& stats,
-    NKikimrKqp::TTransformProfile& profile);
-
-void TransformerStatsFromProto(const NKikimrKqp::TTransformProfile& proto, IGraphTransformer::TStatistics& stats,
-    TString& name);
-
+    TExprContext& ctx); 
+ 
+TMaybe<TString> GetTableListResult(const IKikimrGateway::TListPathResult& res, 
+    const IDataProvider::TFillSettings& fillSettings, TExprContext& ctx); 
+ 
+TMaybe<TString> GetTableMetadataResult(const TKikimrTableDescription& table, 
+    const IDataProvider::TFillSettings& fillSettings, TExprContext& ctx); 
+ 
+void TransformerStatsToProto(const TString& name, const IGraphTransformer::TStatistics& stats, 
+    NKikimrKqp::TTransformProfile& profile); 
+ 
+void TransformerStatsFromProto(const NKikimrKqp::TTransformProfile& proto, IGraphTransformer::TStatistics& stats, 
+    TString& name); 
+ 
 void KikimrProfileToYson(const NKikimrKqp::TKqlProfile& kqlProfile, NYson::TYsonWriter& writer);
 void KikimrProfileToYson(const NKikimrKqp::TQueryProfile& profile, NYson::TYsonWriter& writer);
-
-} // namespace NYql
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/provider/yql_kikimr_settings.cpp b/ydb/core/kqp/provider/yql_kikimr_settings.cpp
index ebd392e16c..b94c933df7 100644
--- a/ydb/core/kqp/provider/yql_kikimr_settings.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_settings.cpp
@@ -1,9 +1,9 @@
-#include "yql_kikimr_settings.h"
-
-namespace NYql {
-
-using namespace NCommon;
-
+#include "yql_kikimr_settings.h" 
+ 
+namespace NYql { 
+ 
+using namespace NCommon; 
+ 
 namespace {
 
 template <typename TType>
@@ -20,77 +20,77 @@ EOptionalFlag GetOptionalFlagValue(const TMaybe<TType>& flag) {
 }
 
 static inline bool GetFlagValue(const TMaybe<bool>& flag) {
-    return flag ? flag.GetRef() : false;
-}
-
+    return flag ? flag.GetRef() : false; 
+} 
+ 
 } // anonymous namespace end
 
-TKikimrConfiguration::TKikimrConfiguration() {
-    /* KQP */
-    REGISTER_SETTING(*this, _KqpQueryTimeoutSec);
-    REGISTER_SETTING(*this, _KqpSessionIdleTimeoutSec);
-    REGISTER_SETTING(*this, _KqpMaxActiveTxPerSession);
-    REGISTER_SETTING(*this, _KqpTxIdleTimeoutSec);
-    REGISTER_SETTING(*this, _KqpRollbackInvalidatedTx);
-    REGISTER_SETTING(*this, _KqpExprNodesAllocationLimit);
-    REGISTER_SETTING(*this, _KqpExprStringsAllocationLimit);
-    REGISTER_SETTING(*this, _KqpTablePathPrefix);
-    REGISTER_SETTING(*this, _KqpSlowLogWarningThresholdMs);
-    REGISTER_SETTING(*this, _KqpSlowLogNoticeThresholdMs);
-    REGISTER_SETTING(*this, _KqpSlowLogTraceThresholdMs);
-    REGISTER_SETTING(*this, _KqpYqlSyntaxVersion);
-    REGISTER_SETTING(*this, _KqpAllowNewEngine);
+TKikimrConfiguration::TKikimrConfiguration() { 
+    /* KQP */ 
+    REGISTER_SETTING(*this, _KqpQueryTimeoutSec); 
+    REGISTER_SETTING(*this, _KqpSessionIdleTimeoutSec); 
+    REGISTER_SETTING(*this, _KqpMaxActiveTxPerSession); 
+    REGISTER_SETTING(*this, _KqpTxIdleTimeoutSec); 
+    REGISTER_SETTING(*this, _KqpRollbackInvalidatedTx); 
+    REGISTER_SETTING(*this, _KqpExprNodesAllocationLimit); 
+    REGISTER_SETTING(*this, _KqpExprStringsAllocationLimit); 
+    REGISTER_SETTING(*this, _KqpTablePathPrefix); 
+    REGISTER_SETTING(*this, _KqpSlowLogWarningThresholdMs); 
+    REGISTER_SETTING(*this, _KqpSlowLogNoticeThresholdMs); 
+    REGISTER_SETTING(*this, _KqpSlowLogTraceThresholdMs); 
+    REGISTER_SETTING(*this, _KqpYqlSyntaxVersion); 
+    REGISTER_SETTING(*this, _KqpAllowNewEngine); 
     REGISTER_SETTING(*this, _KqpForceNewEngine);
-    REGISTER_SETTING(*this, _KqpAllowUnsafeCommit);
+    REGISTER_SETTING(*this, _KqpAllowUnsafeCommit); 
     REGISTER_SETTING(*this, _KqpMaxComputeActors);
     REGISTER_SETTING(*this, _KqpEnableSpilling);
     REGISTER_SETTING(*this, _KqpDisableLlvmForUdfStages);
-    REGISTER_SETTING(*this, _KqpPushOlapProcess);
+    REGISTER_SETTING(*this, _KqpPushOlapProcess); 
     REGISTER_SETTING(*this, KqpPushOlapProcess);
-
-    /* Compile time */
-    REGISTER_SETTING(*this, _CommitPerShardKeysSizeLimitBytes);
-    REGISTER_SETTING(*this, _CommitReadsLimit);
-    REGISTER_SETTING(*this, _DefaultCluster);
-    REGISTER_SETTING(*this, _ResultRowsLimit);
+ 
+    /* Compile time */ 
+    REGISTER_SETTING(*this, _CommitPerShardKeysSizeLimitBytes); 
+    REGISTER_SETTING(*this, _CommitReadsLimit); 
+    REGISTER_SETTING(*this, _DefaultCluster); 
+    REGISTER_SETTING(*this, _ResultRowsLimit); 
     REGISTER_SETTING(*this, _AllowReverseRange);
-    REGISTER_SETTING(*this, CommitSafety).Enum({"Full", "Safe", "Moderate"});
-    REGISTER_SETTING(*this, UseNewEngine);
-    REGISTER_SETTING(*this, UnwrapReadTableValues);
-    REGISTER_SETTING(*this, AllowNullCompareInIndex);
+    REGISTER_SETTING(*this, CommitSafety).Enum({"Full", "Safe", "Moderate"}); 
+    REGISTER_SETTING(*this, UseNewEngine); 
+    REGISTER_SETTING(*this, UnwrapReadTableValues); 
+    REGISTER_SETTING(*this, AllowNullCompareInIndex); 
     REGISTER_SETTING(*this, EnableSystemColumns);
     REGISTER_SETTING(*this, EnableLlvm);
-
-    REGISTER_SETTING(*this, OptDisableJoinRewrite);
-    REGISTER_SETTING(*this, OptDisableJoinTableLookup);
-    REGISTER_SETTING(*this, OptDisableJoinReverseTableLookup);
-    REGISTER_SETTING(*this, OptDisableJoinReverseTableLookupLeftSemi);
-    REGISTER_SETTING(*this, OptDisableTopSort);
+ 
+    REGISTER_SETTING(*this, OptDisableJoinRewrite); 
+    REGISTER_SETTING(*this, OptDisableJoinTableLookup); 
+    REGISTER_SETTING(*this, OptDisableJoinReverseTableLookup); 
+    REGISTER_SETTING(*this, OptDisableJoinReverseTableLookupLeftSemi); 
+    REGISTER_SETTING(*this, OptDisableTopSort); 
     REGISTER_SETTING(*this, OptDisableSqlInToJoin);
     REGISTER_SETTING(*this, OptEnableInplaceUpdate);
     REGISTER_SETTING(*this, OptEnablePredicateExtract);
-
-    /* Runtime */
-    REGISTER_SETTING(*this, _RestrictModifyPermissions);
-    REGISTER_SETTING(*this, _UseLocalProvider);
-    REGISTER_SETTING(*this, IsolationLevel).Enum({"ReadStale", "ReadUncommitted", "ReadCommitted", "Serializable"});
-    REGISTER_SETTING(*this, Profile);
-    REGISTER_SETTING(*this, StrictDml);
-    REGISTER_SETTING(*this, ScanQuery);
-}
-
-bool TKikimrSettings::HasAllowNullCompareInIndex() const {
-    return GetFlagValue(AllowNullCompareInIndex.Get());
-}
-
-bool TKikimrSettings::HasUnwrapReadTableValues() const {
-    return GetFlagValue(UnwrapReadTableValues.Get());
-}
-
-bool TKikimrSettings::HasAllowKqpNewEngine() const {
-    return GetFlagValue(_KqpAllowNewEngine.Get());
-}
-
+ 
+    /* Runtime */ 
+    REGISTER_SETTING(*this, _RestrictModifyPermissions); 
+    REGISTER_SETTING(*this, _UseLocalProvider); 
+    REGISTER_SETTING(*this, IsolationLevel).Enum({"ReadStale", "ReadUncommitted", "ReadCommitted", "Serializable"}); 
+    REGISTER_SETTING(*this, Profile); 
+    REGISTER_SETTING(*this, StrictDml); 
+    REGISTER_SETTING(*this, ScanQuery); 
+} 
+ 
+bool TKikimrSettings::HasAllowNullCompareInIndex() const { 
+    return GetFlagValue(AllowNullCompareInIndex.Get()); 
+} 
+ 
+bool TKikimrSettings::HasUnwrapReadTableValues() const { 
+    return GetFlagValue(UnwrapReadTableValues.Get()); 
+} 
+ 
+bool TKikimrSettings::HasAllowKqpNewEngine() const { 
+    return GetFlagValue(_KqpAllowNewEngine.Get()); 
+} 
+ 
 bool TKikimrSettings::HasKqpForceNewEngine() const {
     return GetFlagValue(_KqpForceNewEngine.Get());
 }
@@ -99,18 +99,18 @@ bool TKikimrSettings::HasUseNewEngine() const {
     return GetFlagValue(UseNewEngine.Get());
 }
 
-bool TKikimrSettings::HasAllowKqpUnsafeCommit() const {
-    return GetFlagValue(_KqpAllowUnsafeCommit.Get());
-}
-
+bool TKikimrSettings::HasAllowKqpUnsafeCommit() const { 
+    return GetFlagValue(_KqpAllowUnsafeCommit.Get()); 
+} 
+ 
 bool TKikimrSettings::AllowReverseRange() const {
     return GetFlagValue(_AllowReverseRange.Get());
 }
 
-bool TKikimrSettings::HasDefaultCluster() const {
-    return _DefaultCluster.Get() && !_DefaultCluster.Get().GetRef().empty();
-}
-
+bool TKikimrSettings::HasDefaultCluster() const { 
+    return _DefaultCluster.Get() && !_DefaultCluster.Get().GetRef().empty(); 
+} 
+ 
 bool TKikimrSettings::SystemColumnsEnabled() const {
     return GetFlagValue(EnableSystemColumns.Get());
 }
@@ -123,7 +123,7 @@ bool TKikimrSettings::DisableLlvmForUdfStages() const {
     return GetFlagValue(_KqpDisableLlvmForUdfStages.Get());
 }
 
-bool TKikimrSettings::PushOlapProcess() const {
+bool TKikimrSettings::PushOlapProcess() const { 
     auto settingsFlag = GetFlagValue(_KqpPushOlapProcess.Get());
     auto runtimeFlag = GetFlagValue(KqpPushOlapProcess.Get());
 
@@ -139,28 +139,28 @@ bool TKikimrSettings::PushOlapProcess() const {
 
     // Other cases handled by AND
     return settingsFlag && runtimeFlag;
-}
-
-bool TKikimrSettings::HasOptDisableJoinRewrite() const {
-    return GetFlagValue(OptDisableJoinRewrite.Get());
-}
-
-bool TKikimrSettings::HasOptDisableJoinTableLookup() const {
-    return GetFlagValue(OptDisableJoinTableLookup.Get());
-}
-
-bool TKikimrSettings::HasOptDisableJoinReverseTableLookup() const {
-    return GetFlagValue(OptDisableJoinReverseTableLookup.Get());
-}
-
-bool TKikimrSettings::HasOptDisableJoinReverseTableLookupLeftSemi() const {
-    return GetFlagValue(OptDisableJoinReverseTableLookupLeftSemi.Get());
-}
-
-bool TKikimrSettings::HasOptDisableTopSort() const {
-    return GetFlagValue(OptDisableTopSort.Get());
-}
-
+} 
+ 
+bool TKikimrSettings::HasOptDisableJoinRewrite() const { 
+    return GetFlagValue(OptDisableJoinRewrite.Get()); 
+} 
+ 
+bool TKikimrSettings::HasOptDisableJoinTableLookup() const { 
+    return GetFlagValue(OptDisableJoinTableLookup.Get()); 
+} 
+ 
+bool TKikimrSettings::HasOptDisableJoinReverseTableLookup() const { 
+    return GetFlagValue(OptDisableJoinReverseTableLookup.Get()); 
+} 
+ 
+bool TKikimrSettings::HasOptDisableJoinReverseTableLookupLeftSemi() const { 
+    return GetFlagValue(OptDisableJoinReverseTableLookupLeftSemi.Get()); 
+} 
+ 
+bool TKikimrSettings::HasOptDisableTopSort() const { 
+    return GetFlagValue(OptDisableTopSort.Get()); 
+} 
+ 
 bool TKikimrSettings::HasOptDisableSqlInToJoin() const {
     return GetFlagValue(OptDisableSqlInToJoin.Get());
 }
@@ -177,8 +177,8 @@ EOptionalFlag TKikimrSettings::GetEnableLlvm() const {
     return GetOptionalFlagValue(EnableLlvm.Get());
 }
 
-TKikimrSettings::TConstPtr TKikimrConfiguration::Snapshot() const {
+TKikimrSettings::TConstPtr TKikimrConfiguration::Snapshot() const { 
     return std::make_shared<const TKikimrSettings>(*this);
-}
-
-}
+} 
+ 
+} 
diff --git a/ydb/core/kqp/provider/yql_kikimr_settings.h b/ydb/core/kqp/provider/yql_kikimr_settings.h
index 530cfb2855..4081288227 100644
--- a/ydb/core/kqp/provider/yql_kikimr_settings.h
+++ b/ydb/core/kqp/provider/yql_kikimr_settings.h
@@ -1,153 +1,153 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/providers/common/config/yql_dispatch.h>
 #include <ydb/library/yql/providers/common/config/yql_setting.h>
 #include <ydb/core/protos/config.pb.h>
-
-namespace NYql {
-
+ 
+namespace NYql { 
+ 
 enum EOptionalFlag {
     Disabled = 0,
     Enabled = 1,
     Auto = 2
 };
 
-struct TKikimrSettings {
+struct TKikimrSettings { 
     using TConstPtr = std::shared_ptr<const TKikimrSettings>;
-
-    /* KQP */
-    NCommon::TConfSetting<ui32, false> _KqpQueryTimeoutSec;
-    NCommon::TConfSetting<ui32, false> _KqpSessionIdleTimeoutSec;
-    NCommon::TConfSetting<ui32, false> _KqpMaxActiveTxPerSession;
-    NCommon::TConfSetting<ui32, false> _KqpTxIdleTimeoutSec;
-    NCommon::TConfSetting<bool, false> _KqpRollbackInvalidatedTx;
-    NCommon::TConfSetting<ui64, false> _KqpExprNodesAllocationLimit;
-    NCommon::TConfSetting<ui64, false> _KqpExprStringsAllocationLimit;
-    NCommon::TConfSetting<TString, false> _KqpTablePathPrefix;
-    NCommon::TConfSetting<ui32, false> _KqpSlowLogWarningThresholdMs;
-    NCommon::TConfSetting<ui32, false> _KqpSlowLogNoticeThresholdMs;
-    NCommon::TConfSetting<ui32, false> _KqpSlowLogTraceThresholdMs;
-    NCommon::TConfSetting<ui32, false> _KqpYqlSyntaxVersion;
-    NCommon::TConfSetting<bool, false> _KqpAllowNewEngine;
+ 
+    /* KQP */ 
+    NCommon::TConfSetting<ui32, false> _KqpQueryTimeoutSec; 
+    NCommon::TConfSetting<ui32, false> _KqpSessionIdleTimeoutSec; 
+    NCommon::TConfSetting<ui32, false> _KqpMaxActiveTxPerSession; 
+    NCommon::TConfSetting<ui32, false> _KqpTxIdleTimeoutSec; 
+    NCommon::TConfSetting<bool, false> _KqpRollbackInvalidatedTx; 
+    NCommon::TConfSetting<ui64, false> _KqpExprNodesAllocationLimit; 
+    NCommon::TConfSetting<ui64, false> _KqpExprStringsAllocationLimit; 
+    NCommon::TConfSetting<TString, false> _KqpTablePathPrefix; 
+    NCommon::TConfSetting<ui32, false> _KqpSlowLogWarningThresholdMs; 
+    NCommon::TConfSetting<ui32, false> _KqpSlowLogNoticeThresholdMs; 
+    NCommon::TConfSetting<ui32, false> _KqpSlowLogTraceThresholdMs; 
+    NCommon::TConfSetting<ui32, false> _KqpYqlSyntaxVersion; 
+    NCommon::TConfSetting<bool, false> _KqpAllowNewEngine; 
     NCommon::TConfSetting<bool, false> _KqpForceNewEngine;
-    NCommon::TConfSetting<bool, false> _KqpAllowUnsafeCommit;
+    NCommon::TConfSetting<bool, false> _KqpAllowUnsafeCommit; 
     NCommon::TConfSetting<ui32, false> _KqpMaxComputeActors;
     NCommon::TConfSetting<bool, false> _KqpEnableSpilling;
     NCommon::TConfSetting<bool, false> _KqpDisableLlvmForUdfStages;
     /*
      * Both settings for predicates push are needed.
      */
-    NCommon::TConfSetting<bool, false> _KqpPushOlapProcess;
+    NCommon::TConfSetting<bool, false> _KqpPushOlapProcess; 
     NCommon::TConfSetting<bool, false> KqpPushOlapProcess;
-
-    /* Compile time */
+ 
+    /* Compile time */ 
     NCommon::TConfSetting<bool, false> _AllowReverseRange;
-    NCommon::TConfSetting<ui64, false> _CommitPerShardKeysSizeLimitBytes;
-    NCommon::TConfSetting<ui32, false> _CommitReadsLimit;
-    NCommon::TConfSetting<TString, false> _DefaultCluster;
-    NCommon::TConfSetting<ui32, false> _ResultRowsLimit;
-    NCommon::TConfSetting<TString, false> CommitSafety;
-    NCommon::TConfSetting<bool, false> UseNewEngine;
-    NCommon::TConfSetting<bool, false> UnwrapReadTableValues;
-    NCommon::TConfSetting<bool, false> AllowNullCompareInIndex;
+    NCommon::TConfSetting<ui64, false> _CommitPerShardKeysSizeLimitBytes; 
+    NCommon::TConfSetting<ui32, false> _CommitReadsLimit; 
+    NCommon::TConfSetting<TString, false> _DefaultCluster; 
+    NCommon::TConfSetting<ui32, false> _ResultRowsLimit; 
+    NCommon::TConfSetting<TString, false> CommitSafety; 
+    NCommon::TConfSetting<bool, false> UseNewEngine; 
+    NCommon::TConfSetting<bool, false> UnwrapReadTableValues; 
+    NCommon::TConfSetting<bool, false> AllowNullCompareInIndex; 
     NCommon::TConfSetting<bool, false> EnableSystemColumns;
     NCommon::TConfSetting<bool, false> EnableLlvm;
-
-    /* Disable optimizer rules */
-    NCommon::TConfSetting<bool, false> OptDisableJoinRewrite;
-    NCommon::TConfSetting<bool, false> OptDisableJoinTableLookup;
-    NCommon::TConfSetting<bool, false> OptDisableJoinReverseTableLookup;
-    NCommon::TConfSetting<bool, false> OptDisableJoinReverseTableLookupLeftSemi;
-    NCommon::TConfSetting<bool, false> OptDisableTopSort;
+ 
+    /* Disable optimizer rules */ 
+    NCommon::TConfSetting<bool, false> OptDisableJoinRewrite; 
+    NCommon::TConfSetting<bool, false> OptDisableJoinTableLookup; 
+    NCommon::TConfSetting<bool, false> OptDisableJoinReverseTableLookup; 
+    NCommon::TConfSetting<bool, false> OptDisableJoinReverseTableLookupLeftSemi; 
+    NCommon::TConfSetting<bool, false> OptDisableTopSort; 
     NCommon::TConfSetting<bool, false> OptDisableSqlInToJoin;
     NCommon::TConfSetting<bool, false> OptEnableInplaceUpdate;
     NCommon::TConfSetting<bool, false> OptEnablePredicateExtract;
-
-    /* Runtime */
-    NCommon::TConfSetting<bool, true> _UseLocalProvider;
-    NCommon::TConfSetting<bool, true> _RestrictModifyPermissions;
-    NCommon::TConfSetting<TString, true> IsolationLevel;
-    NCommon::TConfSetting<bool, true> Profile;
-    NCommon::TConfSetting<bool, true> StrictDml;
-    NCommon::TConfSetting<bool, true> ScanQuery;
-
-    /* Accessors */
-    bool HasAllowNullCompareInIndex() const;
-    bool HasUnwrapReadTableValues() const;
-    bool HasAllowKqpNewEngine() const;
+ 
+    /* Runtime */ 
+    NCommon::TConfSetting<bool, true> _UseLocalProvider; 
+    NCommon::TConfSetting<bool, true> _RestrictModifyPermissions; 
+    NCommon::TConfSetting<TString, true> IsolationLevel; 
+    NCommon::TConfSetting<bool, true> Profile; 
+    NCommon::TConfSetting<bool, true> StrictDml; 
+    NCommon::TConfSetting<bool, true> ScanQuery; 
+ 
+    /* Accessors */ 
+    bool HasAllowNullCompareInIndex() const; 
+    bool HasUnwrapReadTableValues() const; 
+    bool HasAllowKqpNewEngine() const; 
     bool HasKqpForceNewEngine() const;
     bool HasUseNewEngine() const;
     bool AllowReverseRange() const;
-    bool HasDefaultCluster() const;
-    bool HasAllowKqpUnsafeCommit() const;
+    bool HasDefaultCluster() const; 
+    bool HasAllowKqpUnsafeCommit() const; 
     bool SystemColumnsEnabled() const;
     bool SpillingEnabled() const;
     bool DisableLlvmForUdfStages() const;
-    bool PushOlapProcess() const;
-
-    bool HasOptDisableJoinRewrite() const;
-    bool HasOptDisableJoinTableLookup() const;
-    bool HasOptDisableJoinReverseTableLookup() const;
-    bool HasOptDisableJoinReverseTableLookupLeftSemi() const;
-    bool HasOptDisableTopSort() const;
+    bool PushOlapProcess() const; 
+ 
+    bool HasOptDisableJoinRewrite() const; 
+    bool HasOptDisableJoinTableLookup() const; 
+    bool HasOptDisableJoinReverseTableLookup() const; 
+    bool HasOptDisableJoinReverseTableLookupLeftSemi() const; 
+    bool HasOptDisableTopSort() const; 
     bool HasOptDisableSqlInToJoin() const;
     EOptionalFlag GetOptPredicateExtract() const;
     EOptionalFlag GetEnableLlvm() const;
 
-    // WARNING: For testing purposes only, inplace update is not ready for production usage.
+    // WARNING: For testing purposes only, inplace update is not ready for production usage. 
     bool HasOptEnableInplaceUpdate() const;
-};
-
-struct TKikimrConfiguration : public TKikimrSettings, public NCommon::TSettingDispatcher {
-    using TPtr = TIntrusivePtr<TKikimrConfiguration>;
-
-    TKikimrConfiguration();
-    TKikimrConfiguration(const TKikimrConfiguration&) = delete;
-
-    template <typename TProtoConfig>
-    void Init(const TProtoConfig& config)
-    {
-        TMaybe<TString> defaultCluster;
+}; 
+ 
+struct TKikimrConfiguration : public TKikimrSettings, public NCommon::TSettingDispatcher { 
+    using TPtr = TIntrusivePtr<TKikimrConfiguration>; 
+ 
+    TKikimrConfiguration(); 
+    TKikimrConfiguration(const TKikimrConfiguration&) = delete; 
+ 
+    template <typename TProtoConfig> 
+    void Init(const TProtoConfig& config) 
+    { 
+        TMaybe<TString> defaultCluster; 
         TVector<TString> clusters(Reserve(config.ClusterMappingSize()));
-        for (auto& cluster: config.GetClusterMapping()) {
-            clusters.push_back(cluster.GetName());
-            if (cluster.HasDefault() && cluster.GetDefault()) {
-                defaultCluster = cluster.GetName();
-            }
-        }
-
-        this->SetValidClusters(clusters);
-
-        if (defaultCluster) {
-            this->Dispatch(NCommon::ALL_CLUSTERS, "_DefaultCluster", *defaultCluster, EStage::CONFIG);
-        }
-
-        // Init settings from config
-        this->Dispatch(config.GetDefaultSettings());
-        for (auto& cluster: config.GetClusterMapping()) {
-            this->Dispatch(cluster.GetName(), cluster.GetSettings());
-        }
-        this->FreezeDefaults();
-    }
-
-    template <typename TDefultSettingsContainer, typename TSettingsContainer>
-    void Init(const TDefultSettingsContainer& defaultSettings, const TString& cluster,
-        const TSettingsContainer& settings, bool freezeDefaults)
-    {
+        for (auto& cluster: config.GetClusterMapping()) { 
+            clusters.push_back(cluster.GetName()); 
+            if (cluster.HasDefault() && cluster.GetDefault()) { 
+                defaultCluster = cluster.GetName(); 
+            } 
+        } 
+ 
+        this->SetValidClusters(clusters); 
+ 
+        if (defaultCluster) { 
+            this->Dispatch(NCommon::ALL_CLUSTERS, "_DefaultCluster", *defaultCluster, EStage::CONFIG); 
+        } 
+ 
+        // Init settings from config 
+        this->Dispatch(config.GetDefaultSettings()); 
+        for (auto& cluster: config.GetClusterMapping()) { 
+            this->Dispatch(cluster.GetName(), cluster.GetSettings()); 
+        } 
+        this->FreezeDefaults(); 
+    } 
+ 
+    template <typename TDefultSettingsContainer, typename TSettingsContainer> 
+    void Init(const TDefultSettingsContainer& defaultSettings, const TString& cluster, 
+        const TSettingsContainer& settings, bool freezeDefaults) 
+    { 
         this->SetValidClusters(TVector<TString>{cluster});
-
-        this->Dispatch(NCommon::ALL_CLUSTERS, "_DefaultCluster", cluster, EStage::CONFIG);
-        this->Dispatch(defaultSettings);
-        this->Dispatch(NCommon::ALL_CLUSTERS, settings);
-
-        if (freezeDefaults) {
-            this->FreezeDefaults();
-        }
-    }
-
-    TKikimrSettings::TConstPtr Snapshot() const;
+ 
+        this->Dispatch(NCommon::ALL_CLUSTERS, "_DefaultCluster", cluster, EStage::CONFIG); 
+        this->Dispatch(defaultSettings); 
+        this->Dispatch(NCommon::ALL_CLUSTERS, settings); 
+ 
+        if (freezeDefaults) { 
+            this->FreezeDefaults(); 
+        } 
+    } 
+ 
+    TKikimrSettings::TConstPtr Snapshot() const; 
 
     NKikimrConfig::TFeatureFlags FeatureFlags;
-};
-
-}
+}; 
+ 
+} 
diff --git a/ydb/core/kqp/provider/yql_kikimr_type_ann.cpp b/ydb/core/kqp/provider/yql_kikimr_type_ann.cpp
index 692165204a..88894d9ac5 100644
--- a/ydb/core/kqp/provider/yql_kikimr_type_ann.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_type_ann.cpp
@@ -1,127 +1,127 @@
-#include "yql_kikimr_provider_impl.h"
-
+#include "yql_kikimr_provider_impl.h" 
+ 
 #include <ydb/library/yql/core/type_ann/type_ann_impl.h>
 #include <ydb/library/yql/core/type_ann/type_ann_list.h>
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 #include <ydb/library/yql/core/yql_expr_type_annotation.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/providers/common/provider/yql_provider.h>
-
-namespace NYql {
-namespace {
-
-using namespace NCommon;
-using namespace NNodes;
-
+ 
+namespace NYql { 
+namespace { 
+ 
+using namespace NCommon; 
+using namespace NNodes; 
+ 
 const TString DocApiTableVersionAttribute = "__document_api_version";
-
-const TTypeAnnotationNode* GetExpectedRowType(const TKikimrTableDescription& tableDesc,
+ 
+const TTypeAnnotationNode* GetExpectedRowType(const TKikimrTableDescription& tableDesc, 
     const TVector<TString>& columns, const TPosition& pos, TExprContext& ctx)
-{
+{ 
     TVector<const TItemExprType*> expectedRowTypeItems;
-    for (auto& column : columns) {
-        auto columnType = tableDesc.GetColumnType(column);
-
-        if (!columnType) {
+    for (auto& column : columns) { 
+        auto columnType = tableDesc.GetColumnType(column); 
+ 
+        if (!columnType) { 
             ctx.AddError(TIssue(pos, TStringBuilder()
-                << "No such column: " << column << ", table: "
-                << FullTableName(tableDesc.Metadata->Cluster, tableDesc.Metadata->Name)));
-            return nullptr;
-        }
-
-        expectedRowTypeItems.push_back(ctx.MakeType<TItemExprType>(column, columnType));
-    }
-
-    const TTypeAnnotationNode* expectedRowType = ctx.MakeType<TStructExprType>(expectedRowTypeItems);
-    return expectedRowType;
-}
-
-const TTypeAnnotationNode* GetExpectedRowType(const TKikimrTableDescription& tableDesc,
-    const TStructExprType& structType, const TPosition& pos, TExprContext& ctx)
-{
+                << "No such column: " << column << ", table: " 
+                << FullTableName(tableDesc.Metadata->Cluster, tableDesc.Metadata->Name))); 
+            return nullptr; 
+        } 
+ 
+        expectedRowTypeItems.push_back(ctx.MakeType<TItemExprType>(column, columnType)); 
+    } 
+ 
+    const TTypeAnnotationNode* expectedRowType = ctx.MakeType<TStructExprType>(expectedRowTypeItems); 
+    return expectedRowType; 
+} 
+ 
+const TTypeAnnotationNode* GetExpectedRowType(const TKikimrTableDescription& tableDesc, 
+    const TStructExprType& structType, const TPosition& pos, TExprContext& ctx) 
+{ 
     TVector<TString> columns;
-    for (auto& item : structType.GetItems()) {
-        columns.push_back(TString(item->GetName()));
-    }
-
-    return GetExpectedRowType(tableDesc, columns, pos, ctx);
-}
-
+    for (auto& item : structType.GetItems()) { 
+        columns.push_back(TString(item->GetName())); 
+    } 
+ 
+    return GetExpectedRowType(tableDesc, columns, pos, ctx); 
+} 
+ 
 IGraphTransformer::TStatus ConvertTableRowType(TExprNode::TPtr& input, const TKikimrTableDescription& tableDesc,
-    TExprContext& ctx)
-{
+    TExprContext& ctx) 
+{ 
     YQL_ENSURE(input->GetTypeAnn());
-
-    const TTypeAnnotationNode* actualType;
+ 
+    const TTypeAnnotationNode* actualType; 
     switch (input->GetTypeAnn()->GetKind()) {
-        case ETypeAnnotationKind::List:
+        case ETypeAnnotationKind::List: 
             actualType = input->GetTypeAnn()->Cast<TListExprType>()->GetItemType();
-            break;
-        case ETypeAnnotationKind::Stream:
+            break; 
+        case ETypeAnnotationKind::Stream: 
             actualType = input->GetTypeAnn()->Cast<TStreamExprType>()->GetItemType();
-            break;
-        default:
+            break; 
+        default: 
             actualType = input->GetTypeAnn();
-            break;
-    }
-
-    YQL_ENSURE(actualType->GetKind() == ETypeAnnotationKind::Struct);
-    auto rowType = actualType->Cast<TStructExprType>();
-
+            break; 
+    } 
+ 
+    YQL_ENSURE(actualType->GetKind() == ETypeAnnotationKind::Struct); 
+    auto rowType = actualType->Cast<TStructExprType>(); 
+ 
     auto pos = ctx.GetPosition(input->Pos());
     auto expectedType = GetExpectedRowType(tableDesc, *rowType, pos, ctx);
-    if (!expectedType) {
-        return IGraphTransformer::TStatus::Error;
-    }
-
+    if (!expectedType) { 
+        return IGraphTransformer::TStatus::Error; 
+    } 
+ 
     switch (input->GetTypeAnn()->GetKind()) {
-        case ETypeAnnotationKind::List:
-            expectedType = ctx.MakeType<TListExprType>(expectedType);
-            break;
-        case ETypeAnnotationKind::Stream:
-            expectedType = ctx.MakeType<TStreamExprType>(expectedType);
-            break;
-        default:
-            break;
-    }
-
-    auto convertStatus = TryConvertTo(input, *expectedType, ctx);
-
-    if (convertStatus.Level == IGraphTransformer::TStatus::Error) {
+        case ETypeAnnotationKind::List: 
+            expectedType = ctx.MakeType<TListExprType>(expectedType); 
+            break; 
+        case ETypeAnnotationKind::Stream: 
+            expectedType = ctx.MakeType<TStreamExprType>(expectedType); 
+            break; 
+        default: 
+            break; 
+    } 
+ 
+    auto convertStatus = TryConvertTo(input, *expectedType, ctx); 
+ 
+    if (convertStatus.Level == IGraphTransformer::TStatus::Error) { 
         ctx.AddError(TIssue(pos, TStringBuilder()
-            << "Row type mismatch for table: "
-            << FullTableName(tableDesc.Metadata->Cluster, tableDesc.Metadata->Name)));
-        return IGraphTransformer::TStatus::Error;
-    }
-
-    return convertStatus;
-}
-
-class TKiSourceTypeAnnotationTransformer : public TKiSourceVisitorTransformer {
-public:
+            << "Row type mismatch for table: " 
+            << FullTableName(tableDesc.Metadata->Cluster, tableDesc.Metadata->Name))); 
+        return IGraphTransformer::TStatus::Error; 
+    } 
+ 
+    return convertStatus; 
+} 
+ 
+class TKiSourceTypeAnnotationTransformer : public TKiSourceVisitorTransformer { 
+public: 
     TKiSourceTypeAnnotationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx, TTypeAnnotationContext& types)
         : SessionCtx(sessionCtx)
         , Types(types) {}
-
-private:
-    TStatus HandleKiRead(TKiReadBase node, TExprContext& ctx) override {
+ 
+private: 
+    TStatus HandleKiRead(TKiReadBase node, TExprContext& ctx) override { 
         auto cluster = TString(node.DataSource().Cluster());
-
-        TKikimrKey key(ctx);
+ 
+        TKikimrKey key(ctx); 
         if (!key.Extract(node.TableKey().Ref())) {
-            return TStatus::Error;
-        }
-
-        switch (key.GetKeyType()) {
-            case TKikimrKey::Type::Table:
+            return TStatus::Error; 
+        } 
+ 
+        switch (key.GetKeyType()) { 
+            case TKikimrKey::Type::Table: 
             {
-                auto readTable = node.Cast<TKiReadTable>();
+                auto readTable = node.Cast<TKiReadTable>(); 
 
                 const TKikimrTableDescription* tableDesc;
                 if ((tableDesc = SessionCtx->Tables().EnsureTableExists(cluster, key.GetTablePath(), node.Pos(), ctx)) == nullptr) {
-                    return TStatus::Error;
-                }
-
+                    return TStatus::Error; 
+                } 
+ 
                 if (const auto& view = key.GetView()) {
                     if (!ValidateTableHasIndex(tableDesc->Metadata, ctx, node.Pos())) {
                         return TStatus::Error;
@@ -138,93 +138,93 @@ private:
                     readTable.GetSelectColumns(ctx, SessionCtx->Tables(), sysColumnsEnabled), sysColumnsEnabled
                 );
 
-                if (!selectType) {
-                    return TStatus::Error;
-                }
-
-                if (HasSetting(readTable.Settings().Ref(), "unwrap_values")) {
+                if (!selectType) { 
+                    return TStatus::Error; 
+                } 
+ 
+                if (HasSetting(readTable.Settings().Ref(), "unwrap_values")) { 
                     TVector<const TItemExprType*> unwrappedItems;
-                    for (auto* item : selectType->Cast<TStructExprType>()->GetItems()) {
-                        auto unwrappedType = item->GetItemType()->Cast<TOptionalExprType>()->GetItemType();
-                        auto newItemType = ctx.MakeType<TItemExprType>(item->GetName(), unwrappedType);
-                        YQL_ENSURE(newItemType->Validate(node.Pos(), ctx));
-                        unwrappedItems.push_back(newItemType);
-                    }
-                    auto newStructType = ctx.MakeType<TStructExprType>(unwrappedItems);
-                    YQL_ENSURE(newStructType->Validate(node.Pos(), ctx));
-                    selectType = newStructType;
-                }
-
+                    for (auto* item : selectType->Cast<TStructExprType>()->GetItems()) { 
+                        auto unwrappedType = item->GetItemType()->Cast<TOptionalExprType>()->GetItemType(); 
+                        auto newItemType = ctx.MakeType<TItemExprType>(item->GetName(), unwrappedType); 
+                        YQL_ENSURE(newItemType->Validate(node.Pos(), ctx)); 
+                        unwrappedItems.push_back(newItemType); 
+                    } 
+                    auto newStructType = ctx.MakeType<TStructExprType>(unwrappedItems); 
+                    YQL_ENSURE(newStructType->Validate(node.Pos(), ctx)); 
+                    selectType = newStructType; 
+                } 
+ 
                 auto listSelectType = ctx.MakeType<TListExprType>(selectType);
-
+ 
                 TTypeAnnotationNode::TListType children;
                 children.push_back(node.World().Ref().GetTypeAnn());
-                children.push_back(listSelectType);
+                children.push_back(listSelectType); 
                 auto tupleAnn = ctx.MakeType<TTupleExprType>(children);
                 node.Ptr()->SetTypeAnn(tupleAnn);
 
                 YQL_ENSURE(tableDesc->Metadata->ColumnOrder.size() == tableDesc->Metadata->Columns.size());
                 return Types.SetColumnOrder(node.Ref(), tableDesc->Metadata->ColumnOrder, ctx);
-            }
-
-            case TKikimrKey::Type::TableList:
-            {
-                auto tableListAnnotation = BuildCommonTableListType(ctx);
+            } 
+ 
+            case TKikimrKey::Type::TableList: 
+            { 
+                auto tableListAnnotation = BuildCommonTableListType(ctx); 
                 TTypeAnnotationNode::TListType children;
                 children.push_back(node.World().Ref().GetTypeAnn());
-                children.push_back(tableListAnnotation);
+                children.push_back(tableListAnnotation); 
                 node.Ptr()->SetTypeAnn(ctx.MakeType<TTupleExprType>(children));
-                return TStatus::Ok;
-            }
-
-            case TKikimrKey::Type::TableScheme:
-            {
-                auto tableDesc = SessionCtx->Tables().EnsureTableExists(cluster, key.GetTablePath(), node.Pos(), ctx);
-                if (!tableDesc) {
-                    return TStatus::Error;
-                }
-
+                return TStatus::Ok; 
+            } 
+ 
+            case TKikimrKey::Type::TableScheme: 
+            { 
+                auto tableDesc = SessionCtx->Tables().EnsureTableExists(cluster, key.GetTablePath(), node.Pos(), ctx); 
+                if (!tableDesc) { 
+                    return TStatus::Error; 
+                } 
+ 
                 TTypeAnnotationNode::TListType children;
                 children.push_back(node.World().Ref().GetTypeAnn());
                 children.push_back(ctx.MakeType<TDataExprType>(EDataSlot::Yson));
                 node.Ptr()->SetTypeAnn(ctx.MakeType<TTupleExprType>(children));
-                return TStatus::Ok;
-            }
+                return TStatus::Ok; 
+            } 
 
             case TKikimrKey::Type::Role:
             {
                 return TStatus::Ok;
             }
-        }
-
+        } 
+ 
         return TStatus::Error;
-    }
-
-    TStatus HandleRead(TExprBase node, TExprContext& ctx) override {
+    } 
+ 
+    TStatus HandleRead(TExprBase node, TExprContext& ctx) override { 
         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), "Failed to annotate Read!, IO rewrite should handle this"));
-        return TStatus::Error;
-    }
-
-    TStatus HandleLength(TExprBase node, TExprContext& ctx) override {
+        return TStatus::Error; 
+    } 
+ 
+    TStatus HandleLength(TExprBase node, TExprContext& ctx) override { 
         Y_UNUSED(node);
         Y_UNUSED(ctx);
-        return TStatus::Error;
-    }
-
-    TStatus HandleConfigure(TExprBase node, TExprContext& ctx) override {
+        return TStatus::Error; 
+    } 
+ 
+    TStatus HandleConfigure(TExprBase node, TExprContext& ctx) override { 
         if (!EnsureWorldType(*node.Ref().Child(0), ctx)) {
-            return TStatus::Error;
-        }
-
+            return TStatus::Error; 
+        } 
+ 
         node.Ptr()->SetTypeAnn(node.Ref().Child(0)->GetTypeAnn());
-        return TStatus::Ok;
-    }
-
-private:
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
+        return TStatus::Ok; 
+    } 
+ 
+private: 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
     TTypeAnnotationContext& Types;
-};
-
+}; 
+ 
 namespace {
     std::function<void(TPositionHandle pos, const TString& column, const TString& message)> GetColumnTypeErrorFn(TExprContext& ctx) {
         auto columnTypeError = [&ctx](TPositionHandle pos, const TString& column, const TString& message) {
@@ -260,15 +260,15 @@ namespace {
     }
 }
 
-class TKiSinkTypeAnnotationTransformer : public TKiSinkVisitorTransformer
-{
-public:
-    TKiSinkTypeAnnotationTransformer(TIntrusivePtr<IKikimrGateway> gateway,
-        TIntrusivePtr<TKikimrSessionContext> sessionCtx)
-        : Gateway(gateway)
-        , SessionCtx(sessionCtx) {}
-
-private:
+class TKiSinkTypeAnnotationTransformer : public TKiSinkVisitorTransformer 
+{ 
+public: 
+    TKiSinkTypeAnnotationTransformer(TIntrusivePtr<IKikimrGateway> gateway, 
+        TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
+        : Gateway(gateway) 
+        , SessionCtx(sessionCtx) {} 
+ 
+private: 
     virtual TStatus HandleClusterConfig(TKiClusterConfig node, TExprContext& ctx) override {
         if (!EnsureTuple(node.GrpcData().Ref(), ctx)) {
             return TStatus::Error;
@@ -282,94 +282,94 @@ private:
         return TStatus::Ok;
     }
 
-    virtual TStatus HandleWriteTable(TKiWriteTable node, TExprContext& ctx) override {
+    virtual TStatus HandleWriteTable(TKiWriteTable node, TExprContext& ctx) override { 
         if (!EnsureWorldType(node.World().Ref(), ctx)) {
-            return TStatus::Error;
-        }
-
+            return TStatus::Error; 
+        } 
+ 
         if (!EnsureSpecificDataSink(node.DataSink().Ref(), KikimrProviderName, ctx)) {
-            return TStatus::Error;
-        }
-
-        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()),
-            TString(node.Table().Value()), node.Pos(), ctx);
-
-        if (!table) {
-            return TStatus::Error;
-        }
-
-        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
+            return TStatus::Error; 
+        } 
+ 
+        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()), 
+            TString(node.Table().Value()), node.Pos(), ctx); 
+ 
+        if (!table) { 
+            return TStatus::Error; 
+        } 
+ 
+        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
         auto pos = ctx.GetPosition(node.Pos());
-        if (auto maybeTuple = node.Input().Maybe<TExprList>()) {
-            auto tuple = maybeTuple.Cast();
-
+        if (auto maybeTuple = node.Input().Maybe<TExprList>()) { 
+            auto tuple = maybeTuple.Cast(); 
+ 
             TVector<TExprBase> convertedValues;
-            for (const auto& value : tuple) {
+            for (const auto& value : tuple) { 
                 auto valueType = value.Ref().GetTypeAnn();
-                if (valueType->GetKind() != ETypeAnnotationKind::Struct) {
+                if (valueType->GetKind() != ETypeAnnotationKind::Struct) { 
                     ctx.AddError(TIssue(pos, TStringBuilder()
-                        << "Expected structs as input, but got: " << *valueType));
-                    return TStatus::Error;
-                }
-
+                        << "Expected structs as input, but got: " << *valueType)); 
+                    return TStatus::Error; 
+                } 
+ 
                 auto expectedType = GetExpectedRowType(*table, *valueType->Cast<TStructExprType>(), pos, ctx);
-                if (!expectedType) {
-                    return TStatus::Error;
-                }
-
-                TExprNode::TPtr node = value.Ptr();
-                if (TryConvertTo(node, *expectedType, ctx) == TStatus::Error) {
+                if (!expectedType) { 
+                    return TStatus::Error; 
+                } 
+ 
+                TExprNode::TPtr node = value.Ptr(); 
+                if (TryConvertTo(node, *expectedType, ctx) == TStatus::Error) { 
                     ctx.AddError(YqlIssue(ctx.GetPosition(node->Pos()), TIssuesIds::KIKIMR_BAD_COLUMN_TYPE, TStringBuilder()
                         << "Failed to convert input columns types to scheme types"));
-                    return TStatus::Error;
-                }
-
-                convertedValues.push_back(TExprBase(node));
-            }
-
+                    return TStatus::Error; 
+                } 
+ 
+                convertedValues.push_back(TExprBase(node)); 
+            } 
+ 
             auto list = Build<TCoAsList>(ctx, node.Pos())
-                .Add(convertedValues)
-                .Done();
-
-            node.Ptr()->ChildRef(TKiWriteTable::idx_Input) = list.Ptr();
-            return TStatus::Repeat;
-        }
-
-        const TStructExprType* rowType = nullptr;
-
+                .Add(convertedValues) 
+                .Done(); 
+ 
+            node.Ptr()->ChildRef(TKiWriteTable::idx_Input) = list.Ptr(); 
+            return TStatus::Repeat; 
+        } 
+ 
+        const TStructExprType* rowType = nullptr; 
+ 
         auto inputType = node.Input().Ref().GetTypeAnn();
-        if (inputType->GetKind() == ETypeAnnotationKind::List) {
-            auto listType = inputType->Cast<TListExprType>();
-            auto itemType = listType->GetItemType();
-            if (itemType->GetKind() == ETypeAnnotationKind::Struct) {
-                rowType = itemType->Cast<TStructExprType>();
-            }
-        } else if (inputType->GetKind() == ETypeAnnotationKind::Stream) {
-            auto streamType = inputType->Cast<TStreamExprType>();
-            auto itemType = streamType->GetItemType();
-            if (itemType->GetKind() == ETypeAnnotationKind::Struct) {
-                rowType = itemType->Cast<TStructExprType>();
-            }
-        }
-
-        if (!rowType) {
+        if (inputType->GetKind() == ETypeAnnotationKind::List) { 
+            auto listType = inputType->Cast<TListExprType>(); 
+            auto itemType = listType->GetItemType(); 
+            if (itemType->GetKind() == ETypeAnnotationKind::Struct) { 
+                rowType = itemType->Cast<TStructExprType>(); 
+            } 
+        } else if (inputType->GetKind() == ETypeAnnotationKind::Stream) { 
+            auto streamType = inputType->Cast<TStreamExprType>(); 
+            auto itemType = streamType->GetItemType(); 
+            if (itemType->GetKind() == ETypeAnnotationKind::Struct) { 
+                rowType = itemType->Cast<TStructExprType>(); 
+            } 
+        } 
+ 
+        if (!rowType) { 
             ctx.AddError(TIssue(pos, TStringBuilder()
-                << "Expected list or stream of structs as input, but got: " << *inputType));
-            return TStatus::Error;
-        }
-
-        for (auto& keyColumnName : table->Metadata->KeyColumnNames) {
-            if (!rowType->FindItem(keyColumnName)) {
+                << "Expected list or stream of structs as input, but got: " << *inputType)); 
+            return TStatus::Error; 
+        } 
+ 
+        for (auto& keyColumnName : table->Metadata->KeyColumnNames) { 
+            if (!rowType->FindItem(keyColumnName)) { 
                 ctx.AddError(YqlIssue(pos, TIssuesIds::KIKIMR_PRECONDITION_FAILED, TStringBuilder()
                     << "Missing key column in input: " << keyColumnName
                     << " for table: " << table->Metadata->Name));
-                return TStatus::Error;
-            }
-        }
-
+                return TStatus::Error; 
+            } 
+        } 
+ 
         auto op = GetTableOp(node);
         if (op == TYdbOperation::InsertAbort || op == TYdbOperation::InsertRevert ||
             op == TYdbOperation::Upsert || op == TYdbOperation::Replace) {
@@ -400,92 +400,92 @@ private:
             }
         }
 
-        auto inputColumns = GetSetting(node.Settings().Ref(), "input_columns");
-        if (!inputColumns) {
+        auto inputColumns = GetSetting(node.Settings().Ref(), "input_columns"); 
+        if (!inputColumns) { 
             TExprNode::TListType columns;
-            for (auto& item : rowType->GetItems()) {
-                columns.push_back(ctx.NewAtom(node.Pos(), item->GetName()));
-            }
-
+            for (auto& item : rowType->GetItems()) { 
+                columns.push_back(ctx.NewAtom(node.Pos(), item->GetName())); 
+            } 
+ 
             node.Ptr()->ChildRef(TKiWriteTable::idx_Settings) = Build<TCoNameValueTupleList>(ctx, node.Pos())
-                .Add(node.Settings())
-                .Add()
-                    .Name().Build("input_columns")
+                .Add(node.Settings()) 
+                .Add() 
+                    .Name().Build("input_columns") 
                     .Value<TCoAtomList>()
-                        .Add(columns)
-                        .Build()
-                    .Build()
-                .Done()
-                .Ptr();
-
-            return TStatus::Repeat;
-        } else {
+                        .Add(columns) 
+                        .Build() 
+                    .Build() 
+                .Done() 
+                .Ptr(); 
+ 
+            return TStatus::Repeat; 
+        } else { 
             for (const auto& atom : TCoNameValueTuple(inputColumns).Value().Cast<TCoAtomList>()) {
-                YQL_ENSURE(rowType->FindItem(atom.Value()));
-            }
-        }
-
+                YQL_ENSURE(rowType->FindItem(atom.Value())); 
+            } 
+        } 
+ 
         auto status = ConvertTableRowType(node.Ptr()->ChildRef(TKiWriteTable::idx_Input), *table, ctx);
-        if (status != IGraphTransformer::TStatus::Ok) {
-            return status;
-        }
-
-        if (!EnsureModifyPermissions(table->Metadata->Cluster, table->Metadata->Name, node.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
+        if (status != IGraphTransformer::TStatus::Ok) { 
+            return status; 
+        } 
+ 
+        if (!EnsureModifyPermissions(table->Metadata->Cluster, table->Metadata->Name, node.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
         node.Ptr()->SetTypeAnn(node.World().Ref().GetTypeAnn());
-        return TStatus::Ok;
-    }
-
-    virtual TStatus HandleUpdateTable(TKiUpdateTable node, TExprContext& ctx) override {
-        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()), TString(node.Table().Value()), node.Pos(), ctx);
-        if (!table) {
-            return TStatus::Error;
-        }
-
-        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
-        auto rowType = table->SchemeNode;
+        return TStatus::Ok; 
+    } 
+ 
+    virtual TStatus HandleUpdateTable(TKiUpdateTable node, TExprContext& ctx) override { 
+        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()), TString(node.Table().Value()), node.Pos(), ctx); 
+        if (!table) { 
+            return TStatus::Error; 
+        } 
+ 
+        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
+        auto rowType = table->SchemeNode; 
         auto& filterLambda = node.Ptr()->ChildRef(TKiUpdateTable::idx_Filter);
         if (!UpdateLambdaAllArgumentsTypes(filterLambda, {rowType}, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         if (!filterLambda->GetTypeAnn()) {
-            return IGraphTransformer::TStatus::Repeat;
-        }
-
+            return IGraphTransformer::TStatus::Repeat; 
+        } 
+ 
         if (!EnsureSpecificDataType(*filterLambda, EDataSlot::Bool, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         auto& updateLambda = node.Ptr()->ChildRef(TKiUpdateTable::idx_Update);
         if (!UpdateLambdaAllArgumentsTypes(updateLambda, {rowType}, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         if (!updateLambda->GetTypeAnn()) {
-            return IGraphTransformer::TStatus::Repeat;
-        }
-
-        if (!EnsureStructType(*updateLambda, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Repeat; 
+        } 
+ 
+        if (!EnsureStructType(*updateLambda, ctx)) { 
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         auto updateResultType = updateLambda->GetTypeAnn()->Cast<TStructExprType>();
-        for (auto& item : updateResultType->GetItems()) {
+        for (auto& item : updateResultType->GetItems()) { 
             const auto& name = item->GetName();
-
+ 
             if (table->GetKeyColumnIndex(TString(name))) {
                 ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-                    << "Cannot update primary key column: " << name));
-                return IGraphTransformer::TStatus::Error;
-            }
-        }
-
+                    << "Cannot update primary key column: " << name)); 
+                return IGraphTransformer::TStatus::Error; 
+            } 
+        } 
+ 
         for (const auto& item : updateResultType->GetItems()) {
             auto column = table->Metadata->Columns.FindPtr(TString(item->GetName()));
             YQL_ENSURE(column);
@@ -497,105 +497,105 @@ private:
         }
 
         auto updateBody = node.Update().Body().Ptr();
-        auto status = ConvertTableRowType(updateBody, *table, ctx);
-        if (status != IGraphTransformer::TStatus::Ok) {
-            if (status == IGraphTransformer::TStatus::Repeat) {
+        auto status = ConvertTableRowType(updateBody, *table, ctx); 
+        if (status != IGraphTransformer::TStatus::Ok) { 
+            if (status == IGraphTransformer::TStatus::Repeat) { 
                 updateLambda = Build<TCoLambda>(ctx, node.Update().Pos())
-                    .Args(node.Update().Args())
-                    .Body(updateBody)
-                    .Done()
+                    .Args(node.Update().Args()) 
+                    .Body(updateBody) 
+                    .Done() 
                     .Ptr();
-            }
-
-            return status;
-        }
-
-        if (!EnsureModifyPermissions(table->Metadata->Cluster, table->Metadata->Name, node.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
+            } 
+ 
+            return status; 
+        } 
+ 
+        if (!EnsureModifyPermissions(table->Metadata->Cluster, table->Metadata->Name, node.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
         node.Ptr()->SetTypeAnn(node.World().Ref().GetTypeAnn());
-        return TStatus::Ok;
-    }
-
-    virtual TStatus HandleDeleteTable(TKiDeleteTable node, TExprContext& ctx) override {
-        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()), TString(node.Table().Value()), node.Pos(), ctx);
-        if (!table) {
-            return TStatus::Error;
-        }
-
-        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
-        auto rowType = table->SchemeNode;
+        return TStatus::Ok; 
+    } 
+ 
+    virtual TStatus HandleDeleteTable(TKiDeleteTable node, TExprContext& ctx) override { 
+        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()), TString(node.Table().Value()), node.Pos(), ctx); 
+        if (!table) { 
+            return TStatus::Error; 
+        } 
+ 
+        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
+        auto rowType = table->SchemeNode; 
         auto& filterLambda = node.Ptr()->ChildRef(TKiUpdateTable::idx_Filter);
         if (!UpdateLambdaAllArgumentsTypes(filterLambda, {rowType}, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         if (!filterLambda->GetTypeAnn()) {
-            return IGraphTransformer::TStatus::Repeat;
-        }
-
+            return IGraphTransformer::TStatus::Repeat; 
+        } 
+ 
         if (!EnsureSpecificDataType(*filterLambda, EDataSlot::Bool, ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
-        if (!EnsureModifyPermissions(table->Metadata->Cluster, table->Metadata->Name, node.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
+        if (!EnsureModifyPermissions(table->Metadata->Cluster, table->Metadata->Name, node.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
         node.Ptr()->SetTypeAnn(node.World().Ref().GetTypeAnn());
-        return TStatus::Ok;
-    }
-
-    virtual TStatus HandleCreateTable(TKiCreateTable create, TExprContext& ctx) override {
+        return TStatus::Ok; 
+    } 
+ 
+    virtual TStatus HandleCreateTable(TKiCreateTable create, TExprContext& ctx) override { 
         TString cluster = TString(create.DataSink().Cluster());
         TString table = TString(create.Table());
-
+ 
         auto columnTypeError = GetColumnTypeErrorFn(ctx);
-
-        TKikimrTableMetadataPtr meta = new TKikimrTableMetadata(cluster, table);
-        meta->DoesExist = true;
+ 
+        TKikimrTableMetadataPtr meta = new TKikimrTableMetadata(cluster, table); 
+        meta->DoesExist = true; 
         meta->ColumnOrder.reserve(create.Columns().Size());
-
-        for (auto atom : create.PrimaryKey()) {
+ 
+        for (auto atom : create.PrimaryKey()) { 
             meta->KeyColumnNames.emplace_back(atom.Value());
-        }
-
+        } 
+ 
         for (const auto& column : create.PartitionBy()) {
             meta->TableSettings.PartitionBy.emplace_back(column.Value());
         }
 
-        for (auto item : create.Columns()) {
-            auto columnTuple = item.Cast<TExprList>();
+        for (auto item : create.Columns()) { 
+            auto columnTuple = item.Cast<TExprList>(); 
             auto nameNode = columnTuple.Item(0).Cast<TCoAtom>();
-            auto typeNode = columnTuple.Item(1);
-
+            auto typeNode = columnTuple.Item(1); 
+ 
             auto columnName = TString(nameNode.Value());
             auto columnType = typeNode.Ref().GetTypeAnn();
-            YQL_ENSURE(columnType && columnType->GetKind() == ETypeAnnotationKind::Type);
-
-            auto type = columnType->Cast<TTypeExprType>()->GetType();
+            YQL_ENSURE(columnType && columnType->GetKind() == ETypeAnnotationKind::Type); 
+ 
+            auto type = columnType->Cast<TTypeExprType>()->GetType(); 
             auto notNull = type->GetKind() != ETypeAnnotationKind::Optional;
             auto actualType = notNull ? type : type->Cast<TOptionalExprType>()->GetItemType();
-            if (actualType->GetKind() != ETypeAnnotationKind::Data) {
-                columnTypeError(typeNode.Pos(), columnName, "Only core YQL data types are currently supported");
-                return TStatus::Error;
-            }
-
-            auto dataType = actualType->Cast<TDataExprType>();
-
+            if (actualType->GetKind() != ETypeAnnotationKind::Data) { 
+                columnTypeError(typeNode.Pos(), columnName, "Only core YQL data types are currently supported"); 
+                return TStatus::Error; 
+            } 
+ 
+            auto dataType = actualType->Cast<TDataExprType>(); 
+ 
             if (!ValidateColumnDataType(dataType, typeNode, columnName, ctx)) {
                 return IGraphTransformer::TStatus::Error;
             }
 
-            TKikimrColumnMetadata columnMeta;
-            columnMeta.Name = columnName;
+            TKikimrColumnMetadata columnMeta; 
+            columnMeta.Name = columnName; 
             columnMeta.Type = dataType->GetName();
             columnMeta.NotNull = notNull;
-
+ 
             if (columnTuple.Size() > 2) {
                 auto families = columnTuple.Item(2).Cast<TCoAtomList>();
                 for (auto family : families) {
@@ -604,14 +604,14 @@ private:
             }
 
             meta->ColumnOrder.push_back(columnName);
-            auto insertRes = meta->Columns.insert(std::make_pair(columnName, columnMeta));
+            auto insertRes = meta->Columns.insert(std::make_pair(columnName, columnMeta)); 
             if (!insertRes.second) {
                 ctx.AddError(TIssue(ctx.GetPosition(create.Pos()), TStringBuilder()
                     << "Duplicate column: " << columnName << "."));
                 return TStatus::Error;
             }
-        }
-
+        } 
+ 
         for (const auto& index : create.Indexes()) {
             const auto type = index.Type().Value();
             TIndexDescription::EType indexType;
@@ -816,46 +816,46 @@ private:
             }
         }
 
-        if (!EnsureModifyPermissions(cluster, table, create.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
-        auto& tableDesc = SessionCtx->Tables().GetTable(cluster, table);
-        if (tableDesc.DoesExist() && !tableDesc.Metadata->IsSameTable(*meta)) {
+        if (!EnsureModifyPermissions(cluster, table, create.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
+        auto& tableDesc = SessionCtx->Tables().GetTable(cluster, table); 
+        if (tableDesc.DoesExist() && !tableDesc.Metadata->IsSameTable(*meta)) { 
             ctx.AddError(TIssue(ctx.GetPosition(create.Pos()), TStringBuilder()
-                << "Table name conflict: " << NCommon::FullTableName(cluster, table)
-                << " is used to reference multiple tables."));
-            return TStatus::Error;
-        }
-
-        tableDesc.Metadata = meta;
+                << "Table name conflict: " << NCommon::FullTableName(cluster, table) 
+                << " is used to reference multiple tables.")); 
+            return TStatus::Error; 
+        } 
+ 
+        tableDesc.Metadata = meta; 
         bool sysColumnsEnabled = SessionCtx->Config().SystemColumnsEnabled();
         YQL_ENSURE(tableDesc.Load(ctx, sysColumnsEnabled));
-
+ 
         create.Ptr()->SetTypeAnn(create.World().Ref().GetTypeAnn());
-        return TStatus::Ok;
-    }
-
-    virtual TStatus HandleDropTable(TKiDropTable node, TExprContext& ctx) override {
-        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()), TString(node.Table().Value()), node.Pos(), ctx);
-        if (!table) {
-            return TStatus::Error;
-        }
-
-        if (!EnsureModifyPermissions(table->Metadata->Cluster, table->Metadata->Name, node.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
-        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
+        return TStatus::Ok; 
+    } 
+ 
+    virtual TStatus HandleDropTable(TKiDropTable node, TExprContext& ctx) override { 
+        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()), TString(node.Table().Value()), node.Pos(), ctx); 
+        if (!table) { 
+            return TStatus::Error; 
+        } 
+ 
+        if (!EnsureModifyPermissions(table->Metadata->Cluster, table->Metadata->Name, node.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
+        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
         node.Ptr()->SetTypeAnn(node.World().Ref().GetTypeAnn());
-        return TStatus::Ok;
-    }
-
+        return TStatus::Ok; 
+    } 
+ 
     virtual TStatus HandleAlterTable(TKiAlterTable node, TExprContext& ctx) override {
-        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()), TString(node.Table().Value()), node.Pos(), ctx);
+        auto table = SessionCtx->Tables().EnsureTableExists(TString(node.DataSink().Cluster()), TString(node.Table().Value()), node.Pos(), ctx); 
         if (!table) {
             return TStatus::Error;
         }
@@ -868,10 +868,10 @@ private:
             return TStatus::Error;
         }
 
-        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) {
-            return TStatus::Error;
-        }
-
+        if (!CheckDocApiModifiation(*table->Metadata, node.Pos(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
         YQL_ENSURE(!node.Actions().Empty());
 
         for (const auto& action : node.Actions()) {
@@ -1128,336 +1128,336 @@ private:
         return TStatus::Ok;
     }
 
-    virtual TStatus HandleWrite(TExprBase node, TExprContext& ctx) override {
+    virtual TStatus HandleWrite(TExprBase node, TExprContext& ctx) override { 
         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), "Failed to annotate Write!, IO rewrite should handle this"));
-        return TStatus::Error;
-    }
-
+        return TStatus::Error; 
+    } 
+ 
     virtual TStatus HandleCommit(NNodes::TCoCommit node, TExprContext& ctx) override {
-        auto settings = NCommon::ParseCommitSettings(node, ctx);
-
-        bool isFlushCommit = false;
-        if (settings.Mode) {
-            auto mode = settings.Mode.Cast().Value();
-
+        auto settings = NCommon::ParseCommitSettings(node, ctx); 
+ 
+        bool isFlushCommit = false; 
+        if (settings.Mode) { 
+            auto mode = settings.Mode.Cast().Value(); 
+ 
             if (!KikimrCommitModes().contains(mode)) {
                 ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-                    << "Unsupported Kikimr commit mode: " << mode));
-                return TStatus::Error;
-            }
-
-            isFlushCommit = (mode == KikimrCommitModeFlush());
-        }
-
-        if (!settings.EnsureEpochEmpty(ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-        if (!settings.EnsureOtherEmpty(ctx)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
-        switch (SessionCtx->Query().Type) {
-            case EKikimrQueryType::YqlScript:
+                    << "Unsupported Kikimr commit mode: " << mode)); 
+                return TStatus::Error; 
+            } 
+ 
+            isFlushCommit = (mode == KikimrCommitModeFlush()); 
+        } 
+ 
+        if (!settings.EnsureEpochEmpty(ctx)) { 
+            return IGraphTransformer::TStatus::Error; 
+        } 
+        if (!settings.EnsureOtherEmpty(ctx)) { 
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
+        switch (SessionCtx->Query().Type) { 
+            case EKikimrQueryType::YqlScript: 
             case EKikimrQueryType::YqlScriptStreaming:
             case EKikimrQueryType::YqlInternal:
-                break;
-
-            default:
-                if (!isFlushCommit) {
+                break; 
+ 
+            default: 
+                if (!isFlushCommit) { 
                     ctx.AddError(YqlIssue(ctx.GetPosition(node.Pos()), TIssuesIds::KIKIMR_BAD_OPERATION, TStringBuilder()
-                        << "COMMIT not supported inside Kikimr query"));
-
-                    return TStatus::Error;
-                }
-                break;
-        }
-
+                        << "COMMIT not supported inside Kikimr query")); 
+ 
+                    return TStatus::Error; 
+                } 
+                break; 
+        } 
+ 
         node.Ptr()->SetTypeAnn(node.World().Ref().GetTypeAnn());
-        return TStatus::Ok;
-    }
-
-    virtual TStatus HandleEffects(NNodes::TKiEffects node, TExprContext& ctx) override {
-        for (const auto& effect : node) {
-            if (!EnsureWorldType(effect.Ref(), ctx)) {
-                return TStatus::Error;
-            }
-
-            if (!KikimrSupportedEffects().contains(effect.CallableName())) {
+        return TStatus::Ok; 
+    } 
+ 
+    virtual TStatus HandleEffects(NNodes::TKiEffects node, TExprContext& ctx) override { 
+        for (const auto& effect : node) { 
+            if (!EnsureWorldType(effect.Ref(), ctx)) { 
+                return TStatus::Error; 
+            } 
+ 
+            if (!KikimrSupportedEffects().contains(effect.CallableName())) { 
                 ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-                    << "Unsupported Kikimr data query effect: " << effect.CallableName()));
-                return TStatus::Error;
-            }
-        }
-
-        node.Ptr()->SetTypeAnn(ctx.MakeType<TWorldExprType>());
-        return TStatus::Ok;
-    }
-
-    virtual TStatus HandleDataQuery(NNodes::TKiDataQuery node, TExprContext& ctx) override {
-        if (!EnsureWorldType(node.Effects().Ref(), ctx)) {
-            return TStatus::Error;
-        }
-
-        TTypeAnnotationNode::TListType resultTypes;
-        for (const auto& result : node.Results()) {
-            auto resultType = result.Value().Ref().GetTypeAnn();
-            if (!EnsureListType(node.Pos(), *resultType, ctx)) {
-                return TStatus::Error;
-            }
-            auto itemType = resultType->Cast<TListExprType>()->GetItemType();
-            if (!EnsureStructType(node.Pos(), *itemType, ctx)) {
-                return TStatus::Error;
-            }
-            auto structType = itemType->Cast<TStructExprType>();
-
-            for (const auto& column : result.Columns()) {
-                if (!structType->FindItem(column)) {
+                    << "Unsupported Kikimr data query effect: " << effect.CallableName())); 
+                return TStatus::Error; 
+            } 
+        } 
+ 
+        node.Ptr()->SetTypeAnn(ctx.MakeType<TWorldExprType>()); 
+        return TStatus::Ok; 
+    } 
+ 
+    virtual TStatus HandleDataQuery(NNodes::TKiDataQuery node, TExprContext& ctx) override { 
+        if (!EnsureWorldType(node.Effects().Ref(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
+        TTypeAnnotationNode::TListType resultTypes; 
+        for (const auto& result : node.Results()) { 
+            auto resultType = result.Value().Ref().GetTypeAnn(); 
+            if (!EnsureListType(node.Pos(), *resultType, ctx)) { 
+                return TStatus::Error; 
+            } 
+            auto itemType = resultType->Cast<TListExprType>()->GetItemType(); 
+            if (!EnsureStructType(node.Pos(), *itemType, ctx)) { 
+                return TStatus::Error; 
+            } 
+            auto structType = itemType->Cast<TStructExprType>(); 
+ 
+            for (const auto& column : result.Columns()) { 
+                if (!structType->FindItem(column)) { 
                     ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-                        << "Invalid column in result: " << column.Value()));
-                    return TStatus::Error;
-                }
-            }
-
-            resultTypes.push_back(resultType);
-        }
-
-        node.Ptr()->SetTypeAnn(ctx.MakeType<TTupleExprType>(resultTypes));
-        return TStatus::Ok;
-    }
-
-    virtual TStatus HandleExecDataQuery(NNodes::TKiExecDataQuery node, TExprContext& ctx) override {
-        if (!EnsureWorldType(node.World().Ref(), ctx)) {
-            return TStatus::Error;
-        }
-
-        if (!EnsureDataSink(node.DataSink().Ref(), ctx)) {
-            return TStatus::Error;
-        }
-
-        TTypeAnnotationNode::TListType children;
+                        << "Invalid column in result: " << column.Value())); 
+                    return TStatus::Error; 
+                } 
+            } 
+ 
+            resultTypes.push_back(resultType); 
+        } 
+ 
+        node.Ptr()->SetTypeAnn(ctx.MakeType<TTupleExprType>(resultTypes)); 
+        return TStatus::Ok; 
+    } 
+ 
+    virtual TStatus HandleExecDataQuery(NNodes::TKiExecDataQuery node, TExprContext& ctx) override { 
+        if (!EnsureWorldType(node.World().Ref(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
+        if (!EnsureDataSink(node.DataSink().Ref(), ctx)) { 
+            return TStatus::Error; 
+        } 
+ 
+        TTypeAnnotationNode::TListType children; 
         children.push_back(node.World().Ref().GetTypeAnn());
-        children.push_back(node.Query().Ref().GetTypeAnn());
-        auto tupleAnn = ctx.MakeType<TTupleExprType>(children);
+        children.push_back(node.Query().Ref().GetTypeAnn()); 
+        auto tupleAnn = ctx.MakeType<TTupleExprType>(children); 
         node.Ptr()->SetTypeAnn(tupleAnn);
-
-        return TStatus::Ok;
-    }
-
-    virtual TStatus HandleKql(TCallable node, TExprContext& ctx) override {
+ 
+        return TStatus::Ok; 
+    } 
+ 
+    virtual TStatus HandleKql(TCallable node, TExprContext& ctx) override { 
         bool sysColumnsEnabled = SessionCtx->Config().SystemColumnsEnabled();
-        if (auto call = node.Maybe<TKiSelectRow>()) {
-            auto selectRow = call.Cast();
-
-            auto selectType = GetReadTableRowType(ctx, SessionCtx->Tables(), TString(selectRow.Cluster()),
+        if (auto call = node.Maybe<TKiSelectRow>()) { 
+            auto selectRow = call.Cast(); 
+ 
+            auto selectType = GetReadTableRowType(ctx, SessionCtx->Tables(), TString(selectRow.Cluster()), 
                 TString(selectRow.Table().Path()), selectRow.Select(), sysColumnsEnabled);
-            if (!selectType) {
-                return TStatus::Error;
-            }
-
+            if (!selectType) { 
+                return TStatus::Error; 
+            } 
+ 
             auto optSelectType = ctx.MakeType<TOptionalExprType>(selectType);
-
+ 
             node.Ptr()->SetTypeAnn(optSelectType);
-
-            return TStatus::Ok;
-        }
-
-        if (auto call = node.Maybe<TKiSelectRangeBase>()) {
-            auto selectRange = call.Cast();
-
-            auto selectType = GetReadTableRowType(ctx, SessionCtx->Tables(), TString(selectRange.Cluster()),
+ 
+            return TStatus::Ok; 
+        } 
+ 
+        if (auto call = node.Maybe<TKiSelectRangeBase>()) { 
+            auto selectRange = call.Cast(); 
+ 
+            auto selectType = GetReadTableRowType(ctx, SessionCtx->Tables(), TString(selectRange.Cluster()), 
                 TString(selectRange.Table().Path()), selectRange.Select(), sysColumnsEnabled);
-            if (!selectType) {
-                return TStatus::Error;
-            }
-
+            if (!selectType) { 
+                return TStatus::Error; 
+            } 
+ 
             auto listSelectType = ctx.MakeType<TListExprType>(selectType);
-
+ 
             node.Ptr()->SetTypeAnn(listSelectType);
-
-            return TStatus::Ok;
-        }
-
-        if (node.Maybe<TKiUpdateRow>()) {
+ 
+            return TStatus::Ok; 
+        } 
+ 
+        if (node.Maybe<TKiUpdateRow>()) { 
             node.Ptr()->SetTypeAnn(ctx.MakeType<TVoidExprType>());
-
-            return TStatus::Ok;
-        }
-
-        if (node.Maybe<TKiEraseRow>()) {
+ 
+            return TStatus::Ok; 
+        } 
+ 
+        if (node.Maybe<TKiEraseRow>()) { 
             node.Ptr()->SetTypeAnn(ctx.MakeType<TVoidExprType>());
-
-            return TStatus::Ok;
-        }
-
-        if (node.Maybe<TKiSetResult>()) {
+ 
+            return TStatus::Ok; 
+        } 
+ 
+        if (node.Maybe<TKiSetResult>()) { 
             node.Ptr()->SetTypeAnn(ctx.MakeType<TVoidExprType>());
-
-            return TStatus::Ok;
-        }
-
-        if (auto maybeMap = node.Maybe<TKiMapParameter>()) {
-            auto map = maybeMap.Cast();
-
+ 
+            return TStatus::Ok; 
+        } 
+ 
+        if (auto maybeMap = node.Maybe<TKiMapParameter>()) { 
+            auto map = maybeMap.Cast(); 
+ 
             if (!EnsureArgsCount(map.Ref(), 2, ctx)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
             if (!EnsureListType(map.Input().Ref(), ctx)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
             auto& lambda = map.Ptr()->ChildRef(TKiMapParameter::idx_Lambda);
             auto itemType = map.Input().Ref().GetTypeAnn()->Cast<TListExprType>()->GetItemType();
             if (!UpdateLambdaAllArgumentsTypes(lambda, {itemType}, ctx)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
             if (!lambda->GetTypeAnn()) {
-                return IGraphTransformer::TStatus::Repeat;
-            }
-
+                return IGraphTransformer::TStatus::Repeat; 
+            } 
+ 
             map.Ptr()->SetTypeAnn(ctx.MakeType<TListExprType>(lambda->GetTypeAnn()));
-
-            return TStatus::Ok;
-        }
-
-        if (auto maybeMap = node.Maybe<TKiFlatMapParameter>()) {
-            auto map = maybeMap.Cast();
-
+ 
+            return TStatus::Ok; 
+        } 
+ 
+        if (auto maybeMap = node.Maybe<TKiFlatMapParameter>()) { 
+            auto map = maybeMap.Cast(); 
+ 
             if (!EnsureArgsCount(map.Ref(), 2, ctx)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
             if (!EnsureListType(map.Input().Ref(), ctx)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
             auto& lambda = map.Ptr()->ChildRef(TKiFlatMapParameter::idx_Lambda);
             auto itemType = map.Input().Ref().GetTypeAnn()->Cast<TListExprType>()->GetItemType();
             if (!UpdateLambdaAllArgumentsTypes(lambda, {itemType}, ctx)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
             if (!lambda->GetTypeAnn()) {
-                return IGraphTransformer::TStatus::Repeat;
-            }
-
+                return IGraphTransformer::TStatus::Repeat; 
+            } 
+ 
             auto retKind = lambda->GetTypeAnn()->GetKind();
-            if (retKind != ETypeAnnotationKind::List) {
+            if (retKind != ETypeAnnotationKind::List) { 
                 ctx.AddError(TIssue(ctx.GetPosition(lambda->Pos()), TStringBuilder() << "Expected list as labmda return type, but got: " << *lambda->GetTypeAnn()));
-                return IGraphTransformer::TStatus::Error;
-            }
-
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
             map.Ptr()->SetTypeAnn(lambda->GetTypeAnn());
-
-            return TStatus::Ok;
-        }
-
-        if (node.Maybe<TKiPartialSort>()) {
-            NTypeAnnImpl::TContext typeAnnCtx(ctx);
-            TExprNode::TPtr output;
-            return NTypeAnnImpl::SortWrapper(node.Ptr(), output, typeAnnCtx);
-        }
-
-        if (node.Maybe<TKiPartialTake>()) {
-            NTypeAnnImpl::TContext typeAnnCtx(ctx);
-            TExprNode::TPtr output;
-            return NTypeAnnImpl::TakeWrapper(node.Ptr(), output, typeAnnCtx);
-        }
-
-        if (auto maybeCondEffect = node.Maybe<TKiConditionalEffect>()) {
-            auto condEffect = maybeCondEffect.Cast();
-
-            if (!EnsureDataType(condEffect.Predicate().Ref(), ctx)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-
+ 
+            return TStatus::Ok; 
+        } 
+ 
+        if (node.Maybe<TKiPartialSort>()) { 
+            NTypeAnnImpl::TContext typeAnnCtx(ctx); 
+            TExprNode::TPtr output; 
+            return NTypeAnnImpl::SortWrapper(node.Ptr(), output, typeAnnCtx); 
+        } 
+ 
+        if (node.Maybe<TKiPartialTake>()) { 
+            NTypeAnnImpl::TContext typeAnnCtx(ctx); 
+            TExprNode::TPtr output; 
+            return NTypeAnnImpl::TakeWrapper(node.Ptr(), output, typeAnnCtx); 
+        } 
+ 
+        if (auto maybeCondEffect = node.Maybe<TKiConditionalEffect>()) { 
+            auto condEffect = maybeCondEffect.Cast(); 
+ 
+            if (!EnsureDataType(condEffect.Predicate().Ref(), ctx)) { 
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
             auto predicateType = condEffect.Predicate().Ref().GetTypeAnn()->Cast<TDataExprType>();
-            YQL_ENSURE(predicateType);
-
+            YQL_ENSURE(predicateType); 
+ 
             if (predicateType->GetSlot() != EDataSlot::Bool) {
                 ctx.AddError(TIssue(ctx.GetPosition(condEffect.Pos()), "Expected bool as predicate type"));
-                return IGraphTransformer::TStatus::Error;
-            }
-
-            if (!EnsureListOfVoidType(condEffect.Effect().Ref(), ctx)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
+            if (!EnsureListOfVoidType(condEffect.Effect().Ref(), ctx)) { 
+                return IGraphTransformer::TStatus::Error; 
+            } 
+ 
             condEffect.Ptr()->SetTypeAnn(condEffect.Effect().Ref().GetTypeAnn());
-
-            return TStatus::Ok;
-        }
-
+ 
+            return TStatus::Ok; 
+        } 
+ 
         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder()
-            << "Unknown Kql callable in type annotation: " << node.CallableName()));
-
-        return TStatus::Error;
-    }
-
+            << "Unknown Kql callable in type annotation: " << node.CallableName())); 
+ 
+        return TStatus::Error; 
+    } 
+ 
     bool EnsureModifyPermissions(const TString& cluster, const TString& table, TPositionHandle pos, TExprContext& ctx) {
-        bool restrictPermissions = SessionCtx->Config()._RestrictModifyPermissions.Get(cluster).GetRef();
-        if (!restrictPermissions) {
-            return true;
-        }
-
+        bool restrictPermissions = SessionCtx->Config()._RestrictModifyPermissions.Get(cluster).GetRef(); 
+        if (!restrictPermissions) { 
+            return true; 
+        } 
+ 
         TString tmpDir = "/Root/Tmp/";
-        TString homeDir = "/Root/Home/" + SessionCtx->GetUserName() + "/";
-
-        auto tablePath = Gateway->CanonizePath(table);
-        if (!tablePath.StartsWith(tmpDir) && !tablePath.StartsWith(homeDir)) {
+        TString homeDir = "/Root/Home/" + SessionCtx->GetUserName() + "/"; 
+ 
+        auto tablePath = Gateway->CanonizePath(table); 
+        if (!tablePath.StartsWith(tmpDir) && !tablePath.StartsWith(homeDir)) { 
             ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder()
-                << "User " << SessionCtx->GetUserName() << " doesn't have permissions to modify table: " << table));
-            return false;
-        }
-
-        return true;
-    }
-
-    bool CheckDocApiModifiation(const TKikimrTableMetadata& meta, TPositionHandle pos, TExprContext& ctx) {
-        if (!SessionCtx->Query().DocumentApiRestricted) {
-            return true;
-        }
-
-        if (!meta.Attributes.FindPtr(DocApiTableVersionAttribute)) {
-            return true;
-        }
-
-        ctx.AddError(YqlIssue(ctx.GetPosition(pos), TIssuesIds::KIKIMR_BAD_OPERATION, TStringBuilder()
-            << "Document API table cannot be modified from YQL query: " << meta.Name));
-        return false;
-    }
-
-private:
-    TIntrusivePtr<IKikimrGateway> Gateway;
-    TIntrusivePtr<TKikimrSessionContext> SessionCtx;
-};
-
-} // namespace
-
+                << "User " << SessionCtx->GetUserName() << " doesn't have permissions to modify table: " << table)); 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+    bool CheckDocApiModifiation(const TKikimrTableMetadata& meta, TPositionHandle pos, TExprContext& ctx) { 
+        if (!SessionCtx->Query().DocumentApiRestricted) { 
+            return true; 
+        } 
+ 
+        if (!meta.Attributes.FindPtr(DocApiTableVersionAttribute)) { 
+            return true; 
+        } 
+ 
+        ctx.AddError(YqlIssue(ctx.GetPosition(pos), TIssuesIds::KIKIMR_BAD_OPERATION, TStringBuilder() 
+            << "Document API table cannot be modified from YQL query: " << meta.Name)); 
+        return false; 
+    } 
+ 
+private: 
+    TIntrusivePtr<IKikimrGateway> Gateway; 
+    TIntrusivePtr<TKikimrSessionContext> SessionCtx; 
+}; 
+ 
+} // namespace 
+ 
 TAutoPtr<IGraphTransformer> CreateKiSourceTypeAnnotationTransformer(TIntrusivePtr<TKikimrSessionContext> sessionCtx,
     TTypeAnnotationContext& types)
 {
     return new TKiSourceTypeAnnotationTransformer(sessionCtx, types);
-}
-
-TAutoPtr<IGraphTransformer> CreateKiSinkTypeAnnotationTransformer(TIntrusivePtr<IKikimrGateway> gateway,
-    TIntrusivePtr<TKikimrSessionContext> sessionCtx)
-{
-    return new TKiSinkTypeAnnotationTransformer(gateway, sessionCtx);
-}
-
-const TTypeAnnotationNode* GetReadTableRowType(TExprContext& ctx, const TKikimrTablesData& tablesData,
+} 
+ 
+TAutoPtr<IGraphTransformer> CreateKiSinkTypeAnnotationTransformer(TIntrusivePtr<IKikimrGateway> gateway, 
+    TIntrusivePtr<TKikimrSessionContext> sessionCtx) 
+{ 
+    return new TKiSinkTypeAnnotationTransformer(gateway, sessionCtx); 
+} 
+ 
+const TTypeAnnotationNode* GetReadTableRowType(TExprContext& ctx, const TKikimrTablesData& tablesData, 
     const TString& cluster, const TString& table, TCoAtomList select, bool withSystemColumns)
-{
-    auto tableDesc = tablesData.EnsureTableExists(cluster, table, select.Pos(), ctx);
-    if (!tableDesc) {
-        return nullptr;
-    }
-
-    TVector<const TItemExprType*> resultItems;
-    for (auto item : select) {
-        auto column = tableDesc->Metadata->Columns.FindPtr(item.Value());
+{ 
+    auto tableDesc = tablesData.EnsureTableExists(cluster, table, select.Pos(), ctx); 
+    if (!tableDesc) { 
+        return nullptr; 
+    } 
+ 
+    TVector<const TItemExprType*> resultItems; 
+    for (auto item : select) { 
+        auto column = tableDesc->Metadata->Columns.FindPtr(item.Value()); 
         TString columnName;
         if (column) {
             columnName = column->Name;
@@ -1469,24 +1469,24 @@ const TTypeAnnotationNode* GetReadTableRowType(TExprContext& ctx, const TKikimrT
                     << "Column not found: " << item.Value()));
                 return nullptr;
             }
-        }
-
+        } 
+ 
         auto type = tableDesc->GetColumnType(columnName);
         YQL_ENSURE(type, "No such column: " << columnName);
-
+ 
         auto itemType = ctx.MakeType<TItemExprType>(columnName, type);
-        if (!itemType->Validate(select.Pos(), ctx)) {
-            return nullptr;
-        }
-        resultItems.push_back(itemType);
-    }
-
-    auto resultType = ctx.MakeType<TStructExprType>(resultItems);
-    if (!resultType->Validate(select.Pos(), ctx)) {
-        return nullptr;
-    }
-
-    return resultType;
-}
-
-} // namespace NYql
+        if (!itemType->Validate(select.Pos(), ctx)) { 
+            return nullptr; 
+        } 
+        resultItems.push_back(itemType); 
+    } 
+ 
+    auto resultType = ctx.MakeType<TStructExprType>(resultItems); 
+    if (!resultType->Validate(select.Pos(), ctx)) { 
+        return nullptr; 
+    } 
+ 
+    return resultType; 
+} 
+ 
+} // namespace NYql 
diff --git a/ydb/core/kqp/proxy/kqp_proxy_service.cpp b/ydb/core/kqp/proxy/kqp_proxy_service.cpp
index decd2cb301..2ab90693da 100644
--- a/ydb/core/kqp/proxy/kqp_proxy_service.cpp
+++ b/ydb/core/kqp/proxy/kqp_proxy_service.cpp
@@ -1,5 +1,5 @@
 #include "kqp_proxy_service.h"
-
+ 
 #include <ydb/core/kqp/kqp_impl.h>
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/base/path.h>
@@ -17,10 +17,10 @@
 #include <ydb/core/actorlib_impl/long_timer.h>
 #include <ydb/public/lib/operation_id/operation_id.h>
 #include <ydb/core/node_whiteboard/node_whiteboard.h>
-
+ 
 #include <ydb/library/yql/utils/actor_log/log.h>
 #include <ydb/library/yql/core/services/mounts/yql_mounts.h>
-
+ 
 #include <library/cpp/actors/core/actor_bootstrapped.h>
 #include <library/cpp/actors/core/interconnect.h>
 #include <library/cpp/actors/core/hfunc.h>
@@ -28,12 +28,12 @@
 #include <library/cpp/actors/interconnect/interconnect.h>
 #include <library/cpp/resource/resource.h>
 #include <library/cpp/monlib/service/pages/templates.h>
-
-
+ 
+ 
 namespace NKikimr::NKqp {
 
-namespace {
-
+namespace { 
+ 
 #define KQP_PROXY_LOG_T(stream) LOG_TRACE_S(*TlsActivationContext, NKikimrServices::KQP_PROXY, stream)
 #define KQP_PROXY_LOG_D(stream) LOG_DEBUG_S(*TlsActivationContext, NKikimrServices::KQP_PROXY, stream)
 #define KQP_PROXY_LOG_I(stream) LOG_INFO_S(*TlsActivationContext, NKikimrServices::KQP_PROXY, stream)
@@ -45,72 +45,72 @@ namespace {
 TString MakeKqpProxyBoardPath(const TString& database) {
     return "kqpprx+" + database;
 }
-
+ 
 
 static constexpr TDuration DEFAULT_KEEP_ALIVE_TIMEOUT = TDuration::MilliSeconds(5000);
 static constexpr TDuration DEFAULT_EXTRA_TIMEOUT_WAIT = TDuration::MilliSeconds(10);
 static constexpr TDuration DEFAULT_PUBLISH_BATCHING_INTERVAL = TDuration::MilliSeconds(1000);
 static constexpr TDuration DEFAUL_BOARD_LOOKUP_INTERVAL = TDuration::MilliSeconds(5000);
-
-
+ 
+ 
 std::optional<ui32> GetDefaultStateStorageGroupId(const TString& database) {
     if (auto* domainInfo = AppData()->DomainsInfo->GetDomainByName(ExtractDomain(database))) {
         return domainInfo->DefaultStateStorageGroup;
     }
-
+ 
     return std::nullopt;
 }
-
+ 
 
 std::optional<ui32> TryDecodeYdbSessionId(const TString& sessionId) {
-    if (sessionId.empty()) {
+    if (sessionId.empty()) { 
         return std::nullopt;
-    }
-
-    try {
+    } 
+ 
+    try { 
         NOperationId::TOperationId opId(sessionId);
         ui32 nodeId;
         const auto& nodeIds = opId.GetValue("node_id");
         if (nodeIds.size() != 1) {
             return std::nullopt;
-        }
-
+        } 
+ 
         if (!TryFromString(*nodeIds[0], nodeId)) {
             return std::nullopt;
-        }
+        } 
 
         return nodeId;
     } catch (...) {
         return std::nullopt;
-    }
-
+    } 
+ 
     return std::nullopt;
-}
-
-bool IsSqlQuery(const NKikimrKqp::EQueryType& queryType) {
-    switch (queryType) {
-        case NKikimrKqp::QUERY_TYPE_SQL_DML:
-        case NKikimrKqp::QUERY_TYPE_SQL_DDL:
-        case NKikimrKqp::QUERY_TYPE_SQL_SCRIPT:
+} 
+ 
+bool IsSqlQuery(const NKikimrKqp::EQueryType& queryType) { 
+    switch (queryType) { 
+        case NKikimrKqp::QUERY_TYPE_SQL_DML: 
+        case NKikimrKqp::QUERY_TYPE_SQL_DDL: 
+        case NKikimrKqp::QUERY_TYPE_SQL_SCRIPT: 
         case NKikimrKqp::QUERY_TYPE_SQL_SCRIPT_STREAMING:
-        case NKikimrKqp::QUERY_TYPE_SQL_SCAN:
-            return true;
-
-        default:
-            break;
-    }
-
-    return false;
-}
-
-TString EncodeSessionId(ui32 nodeId, const TString& id) {
-    Ydb::TOperationId opId;
+        case NKikimrKqp::QUERY_TYPE_SQL_SCAN: 
+            return true; 
+ 
+        default: 
+            break; 
+    } 
+ 
+    return false; 
+} 
+ 
+TString EncodeSessionId(ui32 nodeId, const TString& id) { 
+    Ydb::TOperationId opId; 
     opId.SetKind(NOperationId::TOperationId::SESSION_YQL);
     NOperationId::AddOptionalValue(opId, "node_id", ToString(nodeId));
     NOperationId::AddOptionalValue(opId, "id", Base64Encode(id));
     return NOperationId::ProtoToString(opId);
-}
-
+} 
+ 
 
 class TLocalSessionsRegistry {
     THashMap<TString, TKqpSessionInfo> LocalSessions;
@@ -217,7 +217,7 @@ public:
 };
 
 
-class TKqpProxyService : public TActorBootstrapped<TKqpProxyService> {
+class TKqpProxyService : public TActorBootstrapped<TKqpProxyService> { 
     struct TEvPrivate {
         enum EEv {
             EvReadyToPublishResources = EventSpaceBegin(TEvents::ES_PRIVATE),
@@ -237,66 +237,66 @@ class TKqpProxyService : public TActorBootstrapped<TKqpProxyService> {
         };
     };
 
-public:
+public: 
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
         return NKikimrServices::TActivity::KQP_PROXY_ACTOR;
-    }
-
-    TKqpProxyService(const NKikimrConfig::TLogConfig& logConfig,
-        const NKikimrConfig::TTableServiceConfig& tableServiceConfig,
+    } 
+ 
+    TKqpProxyService(const NKikimrConfig::TLogConfig& logConfig, 
+        const NKikimrConfig::TTableServiceConfig& tableServiceConfig, 
         TVector<NKikimrKqp::TKqpSetting>&& settings,
         std::shared_ptr<IQueryReplayBackendFactory> queryReplayFactory)
-        : YqlLoggerScope(new NYql::NLog::TTlsLogBackend(new TNullLogBackend()))
-        , LogConfig(logConfig)
-        , TableServiceConfig(tableServiceConfig)
+        : YqlLoggerScope(new NYql::NLog::TTlsLogBackend(new TNullLogBackend())) 
+        , LogConfig(logConfig) 
+        , TableServiceConfig(tableServiceConfig) 
         , KqpSettings(std::make_shared<const TKqpSettings>(std::move(settings)))
         , QueryReplayFactory(std::move(queryReplayFactory))
-        , PendingRequests()
-        , TenantsReady(false)
-        , Tenants()
-        , ModuleResolverState() {}
-
+        , PendingRequests() 
+        , TenantsReady(false) 
+        , Tenants() 
+        , ModuleResolverState() {} 
+ 
     void Bootstrap() {
         Counters = MakeIntrusive<TKqpCounters>(AppData()->Counters, &TlsActivationContext->AsActorContext());
-        ModuleResolverState = MakeIntrusive<TModuleResolverState>();
-
-        if (!GetYqlDefaultModuleResolver(ModuleResolverState->ExprCtx, ModuleResolverState->ModuleResolver)) {
-            TStringStream errorStream;
+        ModuleResolverState = MakeIntrusive<TModuleResolverState>(); 
+ 
+        if (!GetYqlDefaultModuleResolver(ModuleResolverState->ExprCtx, ModuleResolverState->ModuleResolver)) { 
+            TStringStream errorStream; 
             ModuleResolverState->ExprCtx.IssueManager.GetIssues().PrintTo(errorStream);
-
+ 
             KQP_PROXY_LOG_E("Failed to load default YQL libraries: " << errorStream.Str());
             PassAway();
-        }
-
-        ModuleResolverState->FreezeGuardHolder =
-            MakeHolder<NYql::TExprContext::TFreezeGuard>(ModuleResolverState->ExprCtx);
-
+        } 
+ 
+        ModuleResolverState->FreezeGuardHolder = 
+            MakeHolder<NYql::TExprContext::TFreezeGuard>(ModuleResolverState->ExprCtx); 
+ 
         UpdateYqlLogLevels();
-
-        // Subscribe for TableService & Logger config changes
-        ui32 tableServiceConfigKind = (ui32)NKikimrConsole::TConfigItem::TableServiceConfigItem;
-        ui32 logConfigKind = (ui32)NKikimrConsole::TConfigItem::LogConfigItem;
+ 
+        // Subscribe for TableService & Logger config changes 
+        ui32 tableServiceConfigKind = (ui32)NKikimrConsole::TConfigItem::TableServiceConfigItem; 
+        ui32 logConfigKind = (ui32)NKikimrConsole::TConfigItem::LogConfigItem; 
         Send(NConsole::MakeConfigsDispatcherID(SelfId().NodeId()),
-            new NConsole::TEvConfigsDispatcher::TEvSetConfigSubscriptionRequest(
-                {tableServiceConfigKind, logConfigKind}),
-            IEventHandle::FlagTrackDelivery);
-
+            new NConsole::TEvConfigsDispatcher::TEvSetConfigSubscriptionRequest( 
+                {tableServiceConfigKind, logConfigKind}), 
+            IEventHandle::FlagTrackDelivery); 
+ 
         WhiteBoardService = NNodeWhiteboard::MakeNodeWhiteboardServiceId(SelfId().NodeId());
-        // Subscribe for tenant changes
+        // Subscribe for tenant changes 
         Send(MakeTenantPoolRootID(), new TEvents::TEvSubscribe());
-
+ 
         if (auto& cfg = TableServiceConfig.GetSpillingServiceConfig().GetLocalFileConfig(); cfg.GetEnable()) {
             SpillingService = TlsActivationContext->ExecutorThread.RegisterActor(CreateKqpLocalFileSpillingService(cfg, Counters));
             TlsActivationContext->ExecutorThread.ActorSystem->RegisterLocalService(
                 MakeKqpLocalFileSpillingServiceID(SelfId().NodeId()), SpillingService);
         }
 
-        // Create compile service
+        // Create compile service 
         CompileService = TlsActivationContext->ExecutorThread.RegisterActor(CreateKqpCompileService(TableServiceConfig,
             KqpSettings, ModuleResolverState, Counters, std::move(QueryReplayFactory)));
         TlsActivationContext->ExecutorThread.ActorSystem->RegisterLocalService(
             MakeKqpCompileServiceID(SelfId().NodeId()), CompileService);
-
+ 
         KqpNodeService = TlsActivationContext->ExecutorThread.RegisterActor(CreateKqpNodeService(TableServiceConfig, Counters));
         TlsActivationContext->ExecutorThread.ActorSystem->RegisterLocalService(
             MakeKqpNodeServiceID(SelfId().NodeId()), KqpNodeService);
@@ -307,13 +307,13 @@ public:
              mon->RegisterActorPage(actorsMonPage, "kqp_proxy", "KQP Proxy", false, TlsActivationContext->ExecutorThread.ActorSystem, SelfId());
         }
 
-        Become(&TKqpProxyService::MainState);
+        Become(&TKqpProxyService::MainState); 
         StartCollectPeerProxyData();
         PublishResourceUsage();
         AskSelfNodeInfo();
         SendWhiteboardRequest();
-    }
-
+    } 
+ 
     void AskSelfNodeInfo() {
         Send(GetNameserviceActorId(), new TEvInterconnect::TEvGetNode(SelfId().NodeId()));
     }
@@ -421,78 +421,78 @@ public:
             Send(BoardPublishActor, new TEvents::TEvPoison);
         }
         return TActor::PassAway();
-    }
-
+    } 
+ 
     void Handle(TEvTenantPool::TEvTenantPoolStatus::TPtr& ev) {
-        const auto &event = ev->Get()->Record;
-
-        TenantsReady = true;
-        Tenants.clear();
-        for (auto &slot : event.GetSlots()) {
-            Tenants.insert(slot.GetAssignedTenant());
-        }
-
+        const auto &event = ev->Get()->Record; 
+ 
+        TenantsReady = true; 
+        Tenants.clear(); 
+        for (auto &slot : event.GetSlots()) { 
+            Tenants.insert(slot.GetAssignedTenant()); 
+        } 
+ 
         KQP_PROXY_LOG_I("Received tenant pool status, serving tenants: " << JoinRange(", ", Tenants.begin(), Tenants.end()));
         for (auto& [_, sessionInfo] : LocalSessions) {
             if (!sessionInfo.Database.empty() && !Tenants.contains(sessionInfo.Database)) {
-                auto closeSessionEv = MakeHolder<TEvKqp::TEvCloseSessionRequest>();
-                closeSessionEv->Record.MutableRequest()->SetSessionId(sessionInfo.SessionId);
+                auto closeSessionEv = MakeHolder<TEvKqp::TEvCloseSessionRequest>(); 
+                closeSessionEv->Record.MutableRequest()->SetSessionId(sessionInfo.SessionId); 
                 Send(sessionInfo.WorkerId, closeSessionEv.Release());
-            }
-        }
+            } 
+        } 
 
         PublishResourceUsage();
-    }
-
+    } 
+ 
     void Handle(NConsole::TEvConfigsDispatcher::TEvSetConfigSubscriptionResponse::TPtr& ev) {
-        Y_UNUSED(ev);
+        Y_UNUSED(ev); 
         KQP_PROXY_LOG_D("Subscribed for config changes.");
-    }
-
+    } 
+ 
     void Handle(NConsole::TEvConsole::TEvConfigNotificationRequest::TPtr& ev) {
-        auto &event = ev->Get()->Record;
-
-        TableServiceConfig.Swap(event.MutableConfig()->MutableTableServiceConfig());
+        auto &event = ev->Get()->Record; 
+ 
+        TableServiceConfig.Swap(event.MutableConfig()->MutableTableServiceConfig()); 
         KQP_PROXY_LOG_D("Updated table service config.");
-
-        LogConfig.Swap(event.MutableConfig()->MutableLogConfig());
+ 
+        LogConfig.Swap(event.MutableConfig()->MutableLogConfig()); 
         UpdateYqlLogLevels();
-
+ 
         auto responseEv = MakeHolder<NConsole::TEvConsole::TEvConfigNotificationResponse>(event);
         Send(ev->Sender, responseEv.Release(), IEventHandle::FlagTrackDelivery, ev->Cookie);
         StartCollectPeerProxyData();
         PublishResourceUsage();
-    }
-
+    } 
+ 
     void Handle(TEvents::TEvUndelivered::TPtr& ev) {
-        switch (ev->Get()->SourceType) {
-            case NConsole::TEvConfigsDispatcher::EvSetConfigSubscriptionRequest:
+        switch (ev->Get()->SourceType) { 
+            case NConsole::TEvConfigsDispatcher::EvSetConfigSubscriptionRequest: 
                 KQP_PROXY_LOG_C("Failed to deliver subscription request to config dispatcher.");
-                break;
-
-            case NConsole::TEvConsole::EvConfigNotificationResponse:
+                break; 
+ 
+            case NConsole::TEvConsole::EvConfigNotificationResponse: 
                 KQP_PROXY_LOG_E("Failed to deliver config notification response.");
-                break;
-
+                break; 
+ 
             case NNodeWhiteboard::TEvWhiteboard::EvSystemStateRequest:
                 KQP_PROXY_LOG_D("Failed to get system details");
                 break;
 
-            case TKqpEvents::EvQueryRequest:
-            case TKqpEvents::EvPingSessionRequest: {
+            case TKqpEvents::EvQueryRequest: 
+            case TKqpEvents::EvPingSessionRequest: { 
                 KQP_PROXY_LOG_D("Session not found, targetId: " << ev->Sender << " requestId: " << ev->Cookie);
-
-                ReplyProcessError(Ydb::StatusIds::BAD_SESSION, "Session not found.", ev->Cookie);
+ 
+                ReplyProcessError(Ydb::StatusIds::BAD_SESSION, "Session not found.", ev->Cookie); 
                 RemoveSession("", ev->Sender);
-                break;
-            }
-
-            default:
+                break; 
+            } 
+ 
+            default: 
                 KQP_PROXY_LOG_E("Undelivered event with unexpected source type: " << ev->Get()->SourceType);
-                break;
-        }
-    }
-
+                break; 
+        } 
+    } 
+ 
     void Handle(TEvKqp::TEvInitiateShutdownRequest::TPtr& ev) {
         KQP_PROXY_LOG_N("KQP proxy shutdown requested.");
         ShutdownRequested = true;
@@ -507,12 +507,12 @@ public:
     }
 
     void Handle(TEvKqp::TEvCreateSessionRequest::TPtr& ev) {
-        auto& event = ev->Get()->Record;
-        auto& request = event.GetRequest();
-        TKqpRequestInfo requestInfo(event.GetTraceId());
-
-        auto responseEv = MakeHolder<TEvKqp::TEvCreateSessionResponse>();
-
+        auto& event = ev->Get()->Record; 
+        auto& request = event.GetRequest(); 
+        TKqpRequestInfo requestInfo(event.GetTraceId()); 
+ 
+        auto responseEv = MakeHolder<TEvKqp::TEvCreateSessionResponse>(); 
+ 
         TProcessResult<TKqpSessionInfo*> result;
         TKqpDbCountersPtr dbCounters;
 
@@ -520,100 +520,100 @@ public:
 
         if (CheckRequestDeadline(requestInfo, deadline, result) &&
             CreateNewSessionWorker(requestInfo, TString(DefaultKikimrPublicClusterName), true, request.GetDatabase(), result))
-        {
-            auto& response = *responseEv->Record.MutableResponse();
+        { 
+            auto& response = *responseEv->Record.MutableResponse(); 
             response.SetSessionId(result.Value->SessionId);
             dbCounters = result.Value->DbCounters;
         } else {
             dbCounters = Counters->GetDbCounters(request.GetDatabase());
-        }
-
+        } 
+ 
         LogRequest(request, requestInfo, ev->Sender, dbCounters);
 
         responseEv->Record.SetResourceExhausted(result.ResourceExhausted);
-        responseEv->Record.SetYdbStatus(result.YdbStatus);
-        responseEv->Record.SetError(result.Error);
-
+        responseEv->Record.SetYdbStatus(result.YdbStatus); 
+        responseEv->Record.SetError(result.Error); 
+ 
         LogResponse(event.GetTraceId(), responseEv->Record, dbCounters);
         Send(ev->Sender, responseEv.Release(), 0, ev->Cookie);
-    }
-
+    } 
+ 
     void Handle(TEvKqp::TEvQueryRequest::TPtr& ev) {
-        auto& event = ev->Get()->Record;
-        auto& request = *event.MutableRequest();
-        TString traceId = event.GetTraceId();
-        TKqpRequestInfo requestInfo(traceId);
+        auto& event = ev->Get()->Record; 
+        auto& request = *event.MutableRequest(); 
+        TString traceId = event.GetTraceId(); 
+        TKqpRequestInfo requestInfo(traceId); 
         ui64 requestId = PendingRequests.RegisterRequest(ev->Sender, ev->Cookie, traceId, TKqpEvents::EvQueryRequest);
-
+ 
         auto dbCounters = GetDbCountersForSession(request.GetSessionId());
 
-        auto queryLimitBytes = TableServiceConfig.GetQueryLimitBytes();
-        if (queryLimitBytes && IsSqlQuery(request.GetType())) {
-            auto querySizeBytes = request.GetQuery().size();
-            if (querySizeBytes > queryLimitBytes) {
+        auto queryLimitBytes = TableServiceConfig.GetQueryLimitBytes(); 
+        if (queryLimitBytes && IsSqlQuery(request.GetType())) { 
+            auto querySizeBytes = request.GetQuery().size(); 
+            if (querySizeBytes > queryLimitBytes) { 
                 TString error = TStringBuilder() << "Query text size exceeds limit (" << querySizeBytes << "b > " << queryLimitBytes << "b)";
-                ReplyProcessError(Ydb::StatusIds::BAD_REQUEST, error, requestId);
+                ReplyProcessError(Ydb::StatusIds::BAD_REQUEST, error, requestId); 
                 if (!dbCounters) {
                     dbCounters = Counters->GetDbCounters(request.GetDatabase());
                 }
                 LogRequest(request, requestInfo, ev->Sender, requestId, dbCounters);
-                return;
-            }
-        }
-
-        auto paramsLimitBytes = TableServiceConfig.GetParametersLimitBytes();
-        if (paramsLimitBytes) {
-            auto paramsBytes = request.GetParameters().ByteSizeLong();
-            if (paramsBytes > paramsLimitBytes) {
+                return; 
+            } 
+        } 
+ 
+        auto paramsLimitBytes = TableServiceConfig.GetParametersLimitBytes(); 
+        if (paramsLimitBytes) { 
+            auto paramsBytes = request.GetParameters().ByteSizeLong(); 
+            if (paramsBytes > paramsLimitBytes) { 
                 if (!dbCounters) {
                     dbCounters = Counters->GetDbCounters(request.GetDatabase());
                 }
                 LogRequest(request, requestInfo, ev->Sender, requestId, dbCounters);
 
                 TString error = TStringBuilder() << "Parameters size exceeds limit (" << paramsBytes << "b > " << paramsLimitBytes << "b)";
-                ReplyProcessError(Ydb::StatusIds::BAD_REQUEST, error, requestId);
-                return;
-            }
-        }
-
+                ReplyProcessError(Ydb::StatusIds::BAD_REQUEST, error, requestId); 
+                return; 
+            } 
+        } 
+ 
         TActorId targetId;
-        if (!request.GetSessionId().empty()) {
+        if (!request.GetSessionId().empty()) { 
             TProcessResult<TActorId> result;
             if (!TryGetSessionTargetActor(request.GetSessionId(), requestInfo, result)) {
                 if (!dbCounters) {
                     dbCounters = Counters->GetDbCounters(request.GetDatabase());
                 }
                 LogRequest(request, requestInfo, ev->Sender, requestId, dbCounters);
-                ReplyProcessError(result.YdbStatus, result.Error, requestId);
-                return;
-            }
-
-            targetId = result.Value;
+                ReplyProcessError(result.YdbStatus, result.Error, requestId); 
+                return; 
+            } 
+ 
+            targetId = result.Value; 
 
             LogRequest(request, requestInfo, ev->Sender, requestId, dbCounters);
-        } else {
-            TString cluster = request.GetCluster();
-            if (cluster.empty()) {
-                cluster = TString(DefaultKikimrClusterName);
-            }
-
+        } else { 
+            TString cluster = request.GetCluster(); 
+            if (cluster.empty()) { 
+                cluster = TString(DefaultKikimrClusterName); 
+            } 
+ 
             TProcessResult<TKqpSessionInfo*> result;
             if (!CreateNewSessionWorker(requestInfo, cluster, false, request.GetDatabase(), result)) {
                 if (!dbCounters) {
                     dbCounters = Counters->GetDbCounters(request.GetDatabase());
                 }
                 LogRequest(request, requestInfo, ev->Sender, requestId, dbCounters);
-                ReplyProcessError(result.YdbStatus, result.Error, requestId);
-                return;
-            }
-
+                ReplyProcessError(result.YdbStatus, result.Error, requestId); 
+                return; 
+            } 
+ 
             targetId = result.Value->WorkerId;
             request.SetSessionId(result.Value->SessionId);
             dbCounters = result.Value->DbCounters;
 
             LogRequest(request, requestInfo, ev->Sender, requestId, dbCounters);
-        }
-
+        } 
+ 
         TString sessionId = request.GetSessionId();
         PendingRequests.SetSessionId(requestId, sessionId, dbCounters);
         // We add extra milliseconds to the user-specified timeout, so it means we give additional priority for worker replies,
@@ -624,46 +624,46 @@ public:
         StartQueryTimeout(requestId, timeoutMs);
         Send(targetId, ev->Release().Release(), IEventHandle::FlagTrackDelivery, requestId);
         KQP_PROXY_LOG_D(TKqpRequestInfo(traceId, sessionId) << "Sent request to target, requestId: " << requestId << ", targetId: " << targetId);
-    }
-
+    } 
+ 
     void Handle(TEvKqp::TEvCloseSessionRequest::TPtr& ev) {
-        auto& event = ev->Get()->Record;
-        auto& request = event.GetRequest();
-
-        TKqpRequestInfo requestInfo(event.GetTraceId());
-
-        TString sessionId = request.GetSessionId();
+        auto& event = ev->Get()->Record; 
+        auto& request = event.GetRequest(); 
+ 
+        TKqpRequestInfo requestInfo(event.GetTraceId()); 
+ 
+        TString sessionId = request.GetSessionId(); 
         auto dbCounters = GetDbCountersForSession(sessionId);
 
         LogRequest(request, requestInfo, ev->Sender, dbCounters);
 
-        if (!sessionId.empty()) {
+        if (!sessionId.empty()) { 
             TProcessResult<TActorId> result;
             if (TryGetSessionTargetActor(sessionId, requestInfo, result)) {
                 Send(result.Value, ev->Release().Release());
-            }
-        }
-    }
-
+            } 
+        } 
+    } 
+ 
     void Handle(TEvKqp::TEvPingSessionRequest::TPtr& ev) {
-        auto& event = ev->Get()->Record;
-        auto& request = event.GetRequest();
-
-        auto traceId = event.GetTraceId();
-        TKqpRequestInfo requestInfo(traceId);
+        auto& event = ev->Get()->Record; 
+        auto& request = event.GetRequest(); 
+ 
+        auto traceId = event.GetTraceId(); 
+        TKqpRequestInfo requestInfo(traceId); 
         auto sessionId = request.GetSessionId();
         ui64 requestId = PendingRequests.RegisterRequest(ev->Sender, ev->Cookie, traceId, TKqpEvents::EvPingSessionRequest);
-
+ 
         auto dbCounters = GetDbCountersForSession(sessionId);
 
         LogRequest(request, requestInfo, ev->Sender, requestId, dbCounters);
 
         TProcessResult<TActorId> result;
         if (!TryGetSessionTargetActor(sessionId, requestInfo, result)) {
-            ReplyProcessError(result.YdbStatus, result.Error, requestId);
-            return;
-        }
-
+            ReplyProcessError(result.YdbStatus, result.Error, requestId); 
+            return; 
+        } 
+ 
         TDuration timeout = DEFAULT_KEEP_ALIVE_TIMEOUT;
         if (request.GetTimeoutMs() > 0) {
             timeout = TDuration::MilliSeconds(Min(timeout.MilliSeconds(), (ui64)request.GetTimeoutMs()));
@@ -672,29 +672,29 @@ public:
         PendingRequests.SetSessionId(requestId, sessionId, dbCounters);
         StartQueryTimeout(requestId, timeout);
         Send(result.Value, ev->Release().Release(), IEventHandle::FlagTrackDelivery, requestId);
-    }
-
-    template<typename TEvent>
+    } 
+ 
+    template<typename TEvent> 
     void ForwardEvent(TEvent ev) {
-        ui64 requestId = ev->Cookie;
-
+        ui64 requestId = ev->Cookie; 
+ 
         StopQueryTimeout(requestId);
-        auto proxyRequest = PendingRequests.FindPtr(requestId);
-        if (!proxyRequest) {
+        auto proxyRequest = PendingRequests.FindPtr(requestId); 
+        if (!proxyRequest) { 
             KQP_PROXY_LOG_E("Unknown sender for proxy response, requestId: " << requestId);
-            return;
-        }
-
+            return; 
+        } 
+ 
         LogResponse(proxyRequest->TraceId, ev->Get()->Record, proxyRequest->DbCounters);
         Send(proxyRequest->Sender, ev->Release().Release(), 0, proxyRequest->SenderCookie);
 
-        TKqpRequestInfo requestInfo(proxyRequest->TraceId);
+        TKqpRequestInfo requestInfo(proxyRequest->TraceId); 
         KQP_PROXY_LOG_D(requestInfo << "Forwarded response to sender actor, requestId: " << requestId
             << ", sender: " << proxyRequest->Sender << ", selfId: " << SelfId());
-
+ 
         PendingRequests.Erase(requestId);
-    }
-
+    } 
+ 
     void LookupPeerProxyData() {
         if (!SelfDataCenterId || BoardLookupActor || Tenants.empty()) {
             return;
@@ -947,24 +947,24 @@ public:
 
         TString message = TStringBuilder() << "Query did not complete within specified timeout, session id " << reqInfo->SessionId;
         KQP_PROXY_LOG_D("Reply timeout: requestId " <<  requestId << " sessionId" << reqInfo->SessionId);
-        ReplyProcessError(Ydb::StatusIds::TIMEOUT, message, requestId);
+        ReplyProcessError(Ydb::StatusIds::TIMEOUT, message, requestId); 
     }
 
     void Handle(TEvKqp::TEvCloseSessionResponse::TPtr& ev) {
-        const auto &event = ev->Get()->Record;
-        if (event.GetStatus() == Ydb::StatusIds::SUCCESS && event.GetResponse().GetClosed()) {
-            auto sessionId = event.GetResponse().GetSessionId();
+        const auto &event = ev->Get()->Record; 
+        if (event.GetStatus() == Ydb::StatusIds::SUCCESS && event.GetResponse().GetClosed()) { 
+            auto sessionId = event.GetResponse().GetSessionId(); 
             TActorId workerId = ev->Sender;
-
+ 
             RemoveSession(sessionId, workerId);
-
+ 
             KQP_PROXY_LOG_D("Session closed, sessionId: " << event.GetResponse().GetSessionId()
                 << ", workerId: " << workerId << ", local sessions count: " << LocalSessions.size());
-        }
-    }
-
+        } 
+    } 
+ 
     STATEFN(MainState) {
-        switch (ev->GetTypeRewrite()) {
+        switch (ev->GetTypeRewrite()) { 
             hFunc(TEvInterconnect::TEvNodeInfo, Handle);
             hFunc(NMon::TEvHttpInfo, Handle);
             hFunc(TEvStateStorage::TEvBoardInfo, Handle);
@@ -985,101 +985,101 @@ public:
             hFunc(TEvKqp::TEvInitiateShutdownRequest, Handle);
             hFunc(TEvPrivate::TEvOnRequestTimeout, Handle);
             hFunc(NNodeWhiteboard::TEvWhiteboard::TEvSystemStateResponse, Handle);
-        default:
+        default: 
             Y_FAIL("TKqpProxyService: unexpected event type: %" PRIx32 " event: %s",
                 ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
-        }
-    }
-
-private:
+        } 
+    } 
+ 
+private: 
     void LogResponse(const TKqpRequestInfo& requestInfo,
         const NKikimrKqp::TEvProcessResponse& event, TKqpDbCountersPtr dbCounters)
-    {
-        auto status = event.GetYdbStatus();
-        if (status != Ydb::StatusIds::SUCCESS) {
-            KQP_PROXY_LOG_W(requestInfo << event.GetError());
-        }
-
-        Counters->ReportResponseStatus(dbCounters, event.ByteSize(), status);
-    }
-
+    { 
+        auto status = event.GetYdbStatus(); 
+        if (status != Ydb::StatusIds::SUCCESS) { 
+            KQP_PROXY_LOG_W(requestInfo << event.GetError()); 
+        } 
+ 
+        Counters->ReportResponseStatus(dbCounters, event.ByteSize(), status); 
+    } 
+ 
     void LogResponse(const TKqpRequestInfo& requestInfo,
         const TEvKqp::TProtoArenaHolder<NKikimrKqp::TEvQueryResponse>& holder,
         TKqpDbCountersPtr dbCounters)
-    {
-        Y_UNUSED(requestInfo);
+    { 
+        Y_UNUSED(requestInfo); 
         const auto& event = holder.GetRef();
-
+ 
         Counters->ReportResponseStatus(dbCounters, event.ByteSize(),
-            event.GetYdbStatus());
+            event.GetYdbStatus()); 
 
-        for (auto& issue : event.GetResponse().GetQueryIssues()) {
+        for (auto& issue : event.GetResponse().GetQueryIssues()) { 
             Counters->ReportIssues(dbCounters, issue);
-        }
-
+        } 
+ 
         ui64 resultsBytes = 0;
-        for (auto& result : event.GetResponse().GetResults()) {
+        for (auto& result : event.GetResponse().GetResults()) { 
             resultsBytes += result.ByteSize();
-        }
+        } 
         Counters->ReportResultsBytes(dbCounters, resultsBytes);
-    }
-
+    } 
+ 
     void LogResponse(const TKqpRequestInfo& requestInfo,
         const NKikimrKqp::TEvCreateSessionResponse& event, TKqpDbCountersPtr dbCounters)
-    {
-        Y_UNUSED(requestInfo);
+    { 
+        Y_UNUSED(requestInfo); 
 
         Counters->ReportResponseStatus(dbCounters, event.ByteSize(),
-            event.GetYdbStatus());
-    }
-
+            event.GetYdbStatus()); 
+    } 
+ 
     void LogResponse(const TKqpRequestInfo& requestInfo,
         const NKikimrKqp::TEvPingSessionResponse& event, TKqpDbCountersPtr dbCounters)
-    {
-        Y_UNUSED(requestInfo);
+    { 
+        Y_UNUSED(requestInfo); 
 
         Counters->ReportResponseStatus(dbCounters, event.ByteSize(), event.GetStatus());
-    }
-
+    } 
+ 
     void LogRequest(const NKikimrKqp::TCloseSessionRequest& request,
         const TKqpRequestInfo& requestInfo, const TActorId& sender,
         TKqpDbCountersPtr dbCounters)
-    {
+    { 
         KQP_PROXY_LOG_D(requestInfo << "Received close session request, sender: " << sender << ", SessionId: " << request.GetSessionId());
         Counters->ReportCloseSession(dbCounters, request.ByteSize());
-    }
-
+    } 
+ 
     void LogRequest(const NKikimrKqp::TQueryRequest& request,
         const TKqpRequestInfo& requestInfo, const TActorId& sender, ui64 requestId,
         TKqpDbCountersPtr dbCounters)
-    {
+    { 
         KQP_PROXY_LOG_D(requestInfo << "Received new query request, sender: " << sender << ", RequestId: " << requestId
-            << ", Query: \"" << request.GetQuery().substr(0, 10000) << "\"");
+            << ", Query: \"" << request.GetQuery().substr(0, 10000) << "\""); 
         Counters->ReportQueryRequest(dbCounters, request);
-    }
-
+    } 
+ 
     void LogRequest(const NKikimrKqp::TCreateSessionRequest& request,
         const TKqpRequestInfo& requestInfo, const TActorId& sender,
         TKqpDbCountersPtr dbCounters)
-    {
+    { 
         KQP_PROXY_LOG_D(requestInfo << "Received create session request, sender: " << sender);
         Counters->ReportCreateSession(dbCounters, request.ByteSize());
-    }
-
+    } 
+ 
     void LogRequest(const NKikimrKqp::TPingSessionRequest& request,
         const TKqpRequestInfo& requestInfo, const TActorId& sender, ui64 requestId,
         TKqpDbCountersPtr dbCounters)
-    {
+    { 
         KQP_PROXY_LOG_D(requestInfo << "Received ping session request, sender: " << sender << " selfID: " << SelfId() << ", RequestId: " << requestId);
         Counters->ReportPingSession(dbCounters, request.ByteSize());
-    }
-
-    bool ReplyProcessError(Ydb::StatusIds::StatusCode ydbStatus, const TString& message, ui64 requestId)
-    {
-        auto response = TEvKqp::TEvProcessResponse::Error(ydbStatus, message);
+    } 
+ 
+    bool ReplyProcessError(Ydb::StatusIds::StatusCode ydbStatus, const TString& message, ui64 requestId) 
+    { 
+        auto response = TEvKqp::TEvProcessResponse::Error(ydbStatus, message); 
         return Send(SelfId(), response.Release(), 0, requestId);
-    }
-
+    } 
+ 
     bool CheckRequestDeadline(const TKqpRequestInfo& requestInfo, const TInstant deadline, TProcessResult<TKqpSessionInfo*>& result)
     {
         if (!deadline) {
@@ -1102,33 +1102,33 @@ private:
 
     bool CreateNewSessionWorker(const TKqpRequestInfo& requestInfo,
         const TString& cluster, bool longSession, const TString& database, TProcessResult<TKqpSessionInfo*>& result)
-    {
-        if (!database.empty()) {
-            if (!TenantsReady) {
-                TString error = TStringBuilder() << "Node isn't ready to serve database requests.";
-
+    { 
+        if (!database.empty()) { 
+            if (!TenantsReady) { 
+                TString error = TStringBuilder() << "Node isn't ready to serve database requests."; 
+ 
                 KQP_PROXY_LOG_E(requestInfo << error);
-
-                result.YdbStatus = Ydb::StatusIds::UNAVAILABLE;
-                result.Error = error;
-                return false;
-            }
-
+ 
+                result.YdbStatus = Ydb::StatusIds::UNAVAILABLE; 
+                result.Error = error; 
+                return false; 
+            } 
+ 
             /*
              * TODO: disabled due to SLYDB-42. Remove (or rework) it after KIKIMR-9650 & KIKIMR-9652
             if (!Tenants.contains(database)) {
-                TString error = TStringBuilder() << "Unexpected node for database: " << database;
-
-                LOG_ERROR_S(ctx, NKikimrServices::KQP_PROXY, requestInfo << error
-                    << ", known databases: " << JoinRange(", ", Tenants.begin(), Tenants.end()));
-
-                result.YdbStatus = Ydb::StatusIds::INTERNAL_ERROR;
-                result.Error = error;
-                return false;
-            }
+                TString error = TStringBuilder() << "Unexpected node for database: " << database; 
+ 
+                LOG_ERROR_S(ctx, NKikimrServices::KQP_PROXY, requestInfo << error 
+                    << ", known databases: " << JoinRange(", ", Tenants.begin(), Tenants.end())); 
+ 
+                result.YdbStatus = Ydb::StatusIds::INTERNAL_ERROR; 
+                result.Error = error; 
+                return false; 
+            } 
             */
-        }
-
+        } 
+ 
         if (ShutdownRequested) {
             TString error = TStringBuilder() << "Cannot create session: system shutdown requested.";
 
@@ -1142,144 +1142,144 @@ private:
             return false;
         }
 
-        auto sessionsLimitPerNode = TableServiceConfig.GetSessionsLimitPerNode();
-        if (sessionsLimitPerNode && LocalSessions.size() >= sessionsLimitPerNode) {
-            TString error = TStringBuilder() << "Active sessions limit exceeded, maximum allowed: "
-                << sessionsLimitPerNode;
+        auto sessionsLimitPerNode = TableServiceConfig.GetSessionsLimitPerNode(); 
+        if (sessionsLimitPerNode && LocalSessions.size() >= sessionsLimitPerNode) { 
+            TString error = TStringBuilder() << "Active sessions limit exceeded, maximum allowed: " 
+                << sessionsLimitPerNode; 
             KQP_PROXY_LOG_W(requestInfo << error);
-
-            result.YdbStatus = Ydb::StatusIds::OVERLOADED;
-            result.Error = error;
-            return false;
-        }
-
+ 
+            result.YdbStatus = Ydb::StatusIds::OVERLOADED; 
+            result.Error = error; 
+            return false; 
+        } 
+ 
         auto sessionId = EncodeSessionId(SelfId().NodeId(), CreateGuidAsString());
-
+ 
         auto dbCounters = Counters->GetDbCounters(database);
 
         TKqpWorkerSettings workerSettings(cluster, database, TableServiceConfig, dbCounters);
-        workerSettings.LongSession = longSession;
-
+        workerSettings.LongSession = longSession; 
+ 
         IActor* workerActor = AppData()->FeatureFlags.GetEnableKqpSessionActor()
                 ? CreateKqpSessionActor(SelfId(), sessionId, KqpSettings, workerSettings, ModuleResolverState, Counters)
                 : CreateKqpWorkerActor(SelfId(), sessionId, KqpSettings, workerSettings, ModuleResolverState, Counters);
         auto workerId = TlsActivationContext->ExecutorThread.RegisterActor(workerActor, TMailboxType::HTSwap, AppData()->UserPoolId);
         TKqpSessionInfo* sessionInfo = LocalSessions.Create(sessionId, workerId, database, dbCounters);
-
+ 
         KQP_PROXY_LOG_D(requestInfo << "Created new session"
             << ", sessionId: " << sessionInfo->SessionId
             << ", workerId: " << sessionInfo->WorkerId
             << ", database: " << sessionInfo->Database
-            << ", longSession: " << longSession
-            << ", local sessions count: " << LocalSessions.size());
-
-        result.YdbStatus = Ydb::StatusIds::SUCCESS;
-        result.Error.clear();
-        result.Value = sessionInfo;
+            << ", longSession: " << longSession 
+            << ", local sessions count: " << LocalSessions.size()); 
+ 
+        result.YdbStatus = Ydb::StatusIds::SUCCESS; 
+        result.Error.clear(); 
+        result.Value = sessionInfo; 
         PublishResourceUsage();
-        return true;
-    }
-
+        return true; 
+    } 
+ 
     bool TryGetSessionTargetActor(const TString& sessionId, const TKqpRequestInfo& requestInfo, TProcessResult<TActorId>& result)
-    {
-        result.YdbStatus = Ydb::StatusIds::SUCCESS;
-        result.Error.clear();
-
+    { 
+        result.YdbStatus = Ydb::StatusIds::SUCCESS; 
+        result.Error.clear(); 
+ 
         auto nodeId = TryDecodeYdbSessionId(sessionId);
         if (!nodeId) {
-            TString error = TStringBuilder() << "Failed to parse session id: " << sessionId;
+            TString error = TStringBuilder() << "Failed to parse session id: " << sessionId; 
             KQP_PROXY_LOG_W(requestInfo << error);
-
-            result.YdbStatus = Ydb::StatusIds::BAD_REQUEST;
-            result.Error = error;
-            return false;
-        }
-
+ 
+            result.YdbStatus = Ydb::StatusIds::BAD_REQUEST; 
+            result.Error = error; 
+            return false; 
+        } 
+ 
         if (*nodeId == SelfId().NodeId()) {
             auto localSession = LocalSessions.FindAndPromote(sessionId);
-            if (!localSession) {
-                TString error = TStringBuilder() << "Session not found: " << sessionId;
+            if (!localSession) { 
+                TString error = TStringBuilder() << "Session not found: " << sessionId; 
                 KQP_PROXY_LOG_N(requestInfo << error);
-
-                result.YdbStatus = Ydb::StatusIds::BAD_SESSION;
-                result.Error = error;
-                return false;
-            }
-
-            result.Value = localSession->WorkerId;
-            return true;
-        }
-
+ 
+                result.YdbStatus = Ydb::StatusIds::BAD_SESSION; 
+                result.Error = error; 
+                return false; 
+            } 
+ 
+            result.Value = localSession->WorkerId; 
+            return true; 
+        } 
+ 
         if (!Tenants.empty()) {
             auto counters = Counters->GetDbCounters(*Tenants.begin());
             Counters->ReportProxyForwardedRequest(counters);
         }
 
         result.Value = MakeKqpProxyID(*nodeId);
-        return true;
-    }
-
+        return true; 
+    } 
+ 
     void RemoveSession(const TString& sessionId, const TActorId& workerId) {
-        if (!sessionId.empty()) {
+        if (!sessionId.empty()) { 
             LocalSessions.Erase(sessionId);
             PublishResourceUsage();
             if (ShutdownRequested) {
                 ShutdownState->Update(LocalSessions.size());
-            }
+            } 
 
             return;
-        }
-
+        } 
+ 
         LocalSessions.Erase(workerId);
         PublishResourceUsage();
         if (ShutdownRequested) {
             ShutdownState->Update(LocalSessions.size());
         }
-    }
-
+    } 
+ 
     void UpdateYqlLogLevels() {
-        const auto& kqpYqlName = NKikimrServices::EServiceKikimr_Name(NKikimrServices::KQP_YQL);
-        for (auto &entry : LogConfig.GetEntry()) {
-            if (entry.GetComponent() == kqpYqlName && entry.HasLevel()) {
-                auto yqlPriority = static_cast<NActors::NLog::EPriority>(entry.GetLevel());
+        const auto& kqpYqlName = NKikimrServices::EServiceKikimr_Name(NKikimrServices::KQP_YQL); 
+        for (auto &entry : LogConfig.GetEntry()) { 
+            if (entry.GetComponent() == kqpYqlName && entry.HasLevel()) { 
+                auto yqlPriority = static_cast<NActors::NLog::EPriority>(entry.GetLevel()); 
                 NYql::NDq::SetYqlLogLevels(yqlPriority);
                 KQP_PROXY_LOG_D("Updated YQL logs priority: " << (ui32)yqlPriority);
-                return;
-            }
-        }
-
-        // Set log level based on current logger settings
+                return; 
+            } 
+        } 
+ 
+        // Set log level based on current logger settings 
         ui8 currentLevel = TlsActivationContext->LoggerSettings()->GetComponentSettings(NKikimrServices::KQP_YQL).Raw.X.Level;
-        auto yqlPriority = static_cast<NActors::NLog::EPriority>(currentLevel);
-
+        auto yqlPriority = static_cast<NActors::NLog::EPriority>(currentLevel); 
+ 
         KQP_PROXY_LOG_D("Updated YQL logs priority to current level: " << (ui32)yqlPriority);
         NYql::NDq::SetYqlLogLevels(yqlPriority);
-    }
-
+    } 
+ 
     TKqpDbCountersPtr GetDbCountersForSession(const TString& sessionId) const {
         auto localSession = LocalSessions.FindPtr(sessionId);
         return localSession ? localSession->DbCounters : nullptr;
     }
 
-private:
-    NYql::NLog::YqlLoggerScope YqlLoggerScope;
-    NKikimrConfig::TLogConfig LogConfig;
-    NKikimrConfig::TTableServiceConfig TableServiceConfig;
-    TKqpSettings::TConstPtr KqpSettings;
+private: 
+    NYql::NLog::YqlLoggerScope YqlLoggerScope; 
+    NKikimrConfig::TLogConfig LogConfig; 
+    NKikimrConfig::TTableServiceConfig TableServiceConfig; 
+    TKqpSettings::TConstPtr KqpSettings; 
     std::shared_ptr<IQueryReplayBackendFactory> QueryReplayFactory;
-
+ 
     std::optional<TPeerStats> PeerStats;
     TKqpProxyRequestTracker PendingRequests;
-    bool TenantsReady;
+    bool TenantsReady; 
     bool ShutdownRequested = false;
-    THashMap<ui64, NKikimrConsole::TConfigItem::EKind> ConfigSubscriptions;
+    THashMap<ui64, NKikimrConsole::TConfigItem::EKind> ConfigSubscriptions; 
     THashMap<ui64, TActorId> TimeoutTimers;
-    THashSet<TString> Tenants;
-
+    THashSet<TString> Tenants; 
+ 
     TIntrusivePtr<TKqpShutdownState> ShutdownState;
-    TIntrusivePtr<TModuleResolverState> ModuleResolverState;
-
-    TIntrusivePtr<TKqpCounters> Counters;
+    TIntrusivePtr<TModuleResolverState> ModuleResolverState; 
+ 
+    TIntrusivePtr<TKqpCounters> Counters; 
     TLocalSessionsRegistry LocalSessions;
 
     bool ServerWorkerBalancerComplete = false;
@@ -1295,16 +1295,16 @@ private:
     TActorId SpillingService;
     TActorId WhiteBoardService;
     NKikimrKqp::TKqpProxyNodeResources NodeResources;
-};
-
-} // namespace
-
-IActor* CreateKqpProxyService(const NKikimrConfig::TLogConfig& logConfig,
-    const NKikimrConfig::TTableServiceConfig& tableServiceConfig,
+}; 
+ 
+} // namespace 
+ 
+IActor* CreateKqpProxyService(const NKikimrConfig::TLogConfig& logConfig, 
+    const NKikimrConfig::TTableServiceConfig& tableServiceConfig, 
     TVector<NKikimrKqp::TKqpSetting>&& settings,
     std::shared_ptr<IQueryReplayBackendFactory> queryReplayFactory)
-{
+{ 
     return new TKqpProxyService(logConfig, tableServiceConfig, std::move(settings), std::move(queryReplayFactory));
-}
-
+} 
+ 
 } // namespace NKikimr::NKqp
diff --git a/ydb/core/kqp/rm/kqp_rm.cpp b/ydb/core/kqp/rm/kqp_rm.cpp
index 30fc08ff5f..dd8965d8cc 100644
--- a/ydb/core/kqp/rm/kqp_rm.cpp
+++ b/ydb/core/kqp/rm/kqp_rm.cpp
@@ -25,7 +25,7 @@ using namespace NResourceBroker;
 #define LOG_I(stream) LOG_INFO_S(*TlsActivationContext, NKikimrServices::KQP_RESOURCE_MANAGER, stream)
 #define LOG_E(stream) LOG_ERROR_S(*TlsActivationContext, NKikimrServices::KQP_RESOURCE_MANAGER, stream)
 #define LOG_W(stream) LOG_WARN_S(*TlsActivationContext, NKikimrServices::KQP_RESOURCE_MANAGER, stream)
-#define LOG_N(stream) LOG_NOTICE_S(*TlsActivationContext, NKikimrServices::KQP_RESOURCE_MANAGER, stream)
+#define LOG_N(stream) LOG_NOTICE_S(*TlsActivationContext, NKikimrServices::KQP_RESOURCE_MANAGER, stream) 
 
 namespace {
 
@@ -299,7 +299,7 @@ public:
 
         if (!hasScanQueryMemory) {
             Counters->RmNotEnoughMemory->Inc();
-            LOG_N("TxId: " << txId << ", taskId: " << taskId << ". Not enough ScanQueryMemory, requested: " << resources.Memory);
+            LOG_N("TxId: " << txId << ", taskId: " << taskId << ". Not enough ScanQueryMemory, requested: " << resources.Memory); 
             if (details) {
                 details->SetScanQueryMemory();
             }
@@ -308,7 +308,7 @@ public:
 
         if (!hasExecutionUnits) {
             Counters->RmNotEnoughComputeActors->Inc();
-            LOG_N("TxId: " << txId << ", taskId: " << taskId << ". Not enough ExecutionUnits, requested: " << resources.ExecutionUnits);
+            LOG_N("TxId: " << txId << ", taskId: " << taskId << ". Not enough ExecutionUnits, requested: " << resources.ExecutionUnits); 
             if (details) {
                 details->SetExecutionUnits();
             }
@@ -331,7 +331,7 @@ public:
                     } // with_lock (Lock)
 
                     Counters->RmNotEnoughMemory->Inc();
-                    LOG_N("TxId: " << txId << ", taskId: " << taskId << ". Query memory limit exceeded: "
+                    LOG_N("TxId: " << txId << ", taskId: " << taskId << ". Query memory limit exceeded: " 
                         << "requested " << (it->second.TxScanQueryMemory + resources.Memory));
                     if (details) {
                         details->SetQueryMemoryLimit();
@@ -353,7 +353,7 @@ public:
                 } // with_lock (Lock)
 
                 Counters->RmNotEnoughMemory->Inc();
-                LOG_N("TxId: " << txId << ", taskId: " << taskId << ". Not enough ScanQueryMemory: "
+                LOG_N("TxId: " << txId << ", taskId: " << taskId << ". Not enough ScanQueryMemory: " 
                     << "requested " << resources.Memory);
                 if (details) {
                     details->SetScanQueryMemory();
diff --git a/ydb/core/kqp/runtime/kqp_compute.cpp b/ydb/core/kqp/runtime/kqp_compute.cpp
index b4d788fc9c..b2de88a9a2 100644
--- a/ydb/core/kqp/runtime/kqp_compute.cpp
+++ b/ydb/core/kqp/runtime/kqp_compute.cpp
@@ -1,21 +1,21 @@
-#include "kqp_compute.h"
-
+#include "kqp_compute.h" 
+ 
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_codegen.h>
 #include <ydb/library/yql/minikql/comp_nodes/mkql_factories.h>
 #include <ydb/library/yql/minikql/mkql_node.h>
 #include <ydb/library/yql/minikql/mkql_program_builder.h>
 #include <ydb/library/yql/public/udf/udf_terminator.h>
 #include <ydb/library/yql/public/udf/udf_type_builder.h>
-
-namespace NKikimr {
-namespace NMiniKQL {
-
-TComputationNodeFactory GetKqpBaseComputeFactory(const TKqpComputeContextBase* computeCtx) {
+ 
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
+TComputationNodeFactory GetKqpBaseComputeFactory(const TKqpComputeContextBase* computeCtx) { 
     return NYql::NDq::GetDqBaseComputeFactory(computeCtx);
 }
-
+ 
 namespace {
-
+ 
 class TKqpEnsureWrapper : public TMutableCodegeneratorNode<TKqpEnsureWrapper> {
     using TBaseComputation = TMutableCodegeneratorNode<TKqpEnsureWrapper>;
 public:
@@ -96,7 +96,7 @@ IComputationNode* WrapKqpEnsure(TCallable& callable, const TComputationNodeFacto
     auto message = LocateNode(ctx.NodeLocator, callable, 3);
 
     return new TKqpEnsureWrapper(ctx.Mutables, value, predicate, issueCode, message);
-}
-
+} 
+ 
 } // namespace NMiniKQL
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/runtime/kqp_compute.h b/ydb/core/kqp/runtime/kqp_compute.h
index c55a4e2a21..5ac3922759 100644
--- a/ydb/core/kqp/runtime/kqp_compute.h
+++ b/ydb/core/kqp/runtime/kqp_compute.h
@@ -1,15 +1,15 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/dq/runtime/dq_compute.h>
-
+ 
 #include <ydb/core/scheme/scheme_tabledefs.h>
 #include <ydb/core/tablet_flat/flat_row_eggs.h>
 
 // TODO rename file to runtime_compute_context.h
 
-namespace NKikimr {
-namespace NMiniKQL {
-
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
 class TKqpComputeContextBase : public NYql::NDq::TDqComputeContextBase {
 public:
     struct TColumn {
@@ -24,9 +24,9 @@ public:
 private:
     ui64 CurrentTaskId = 0;
 };
-
-TComputationNodeFactory GetKqpBaseComputeFactory(const TKqpComputeContextBase* computeCtx);
-
+ 
+TComputationNodeFactory GetKqpBaseComputeFactory(const TKqpComputeContextBase* computeCtx); 
+ 
 class TKqpEnsureFail : public yexception {
 public:
     TKqpEnsureFail(ui32 code, TString&& message)
@@ -49,4 +49,4 @@ private:
 IComputationNode* WrapKqpEnsure(TCallable& callable, const TComputationNodeFactoryContext& ctx);
 
 } // namespace NMiniKQL
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/runtime/kqp_effects.cpp b/ydb/core/kqp/runtime/kqp_effects.cpp
index b178192f27..e16bae1d29 100644
--- a/ydb/core/kqp/runtime/kqp_effects.cpp
+++ b/ydb/core/kqp/runtime/kqp_effects.cpp
@@ -1,39 +1,39 @@
-#include "kqp_runtime_impl.h"
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NMiniKQL;
-
-namespace {
-
-using namespace NYql;
-using namespace NDq;
-
-class TKqpApplyEffectsConsumer : public IDqOutputConsumer {
-public:
-    TKqpApplyEffectsConsumer(NUdf::IApplyContext* applyCtx)
-        : ApplyCtx(applyCtx) {}
-
-    bool IsFull() const override {
-        return false;
-    }
-
-    void Consume(NUdf::TUnboxedValue&& value) final {
-        value.Apply(*ApplyCtx);
-    }
-
-    void Finish() final {}
-
-private:
-    NUdf::IApplyContext* ApplyCtx;
-};
-
-} // namespace
-
-IDqOutputConsumer::TPtr CreateKqpApplyEffectsConsumer(NUdf::IApplyContext* applyCtx) {
-    return MakeIntrusive<TKqpApplyEffectsConsumer>(applyCtx);
-}
-
+#include "kqp_runtime_impl.h" 
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NMiniKQL; 
+ 
+namespace { 
+ 
+using namespace NYql; 
+using namespace NDq; 
+ 
+class TKqpApplyEffectsConsumer : public IDqOutputConsumer { 
+public: 
+    TKqpApplyEffectsConsumer(NUdf::IApplyContext* applyCtx) 
+        : ApplyCtx(applyCtx) {} 
+ 
+    bool IsFull() const override { 
+        return false; 
+    } 
+ 
+    void Consume(NUdf::TUnboxedValue&& value) final { 
+        value.Apply(*ApplyCtx); 
+    } 
+ 
+    void Finish() final {} 
+ 
+private: 
+    NUdf::IApplyContext* ApplyCtx; 
+}; 
+ 
+} // namespace 
+ 
+IDqOutputConsumer::TPtr CreateKqpApplyEffectsConsumer(NUdf::IApplyContext* applyCtx) { 
+    return MakeIntrusive<TKqpApplyEffectsConsumer>(applyCtx); 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/runtime/kqp_output_stream.cpp b/ydb/core/kqp/runtime/kqp_output_stream.cpp
index 640706d9b4..0cf82f01db 100644
--- a/ydb/core/kqp/runtime/kqp_output_stream.cpp
+++ b/ydb/core/kqp/runtime/kqp_output_stream.cpp
@@ -1,66 +1,66 @@
-#include "kqp_runtime_impl.h"
-
+#include "kqp_runtime_impl.h" 
+ 
 #include <ydb/core/kqp/common/kqp_resolve.h>
 #include <ydb/core/scheme_types/scheme_type_registry.h>
-
+ 
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_holders.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NMiniKQL;
-
-namespace {
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NMiniKQL; 
+ 
+namespace { 
+ 
 using namespace NYql;
 using namespace NDq;
 using namespace NUdf;
 
 
 class TKqpOutputRangePartitionConsumer : public IDqOutputConsumer {
-public:
+public: 
     TKqpOutputRangePartitionConsumer(const TTypeEnvironment& typeEnv,
         TVector<NYql::NDq::IDqOutput::TPtr>&& outputs, TVector<TKqpRangePartition>&& partitions,
         TVector<TDataTypeId>&& keyColumnTypes, TVector<ui32>&& keyColumnIndices)
         : TypeEnv(typeEnv)
         , Outputs(std::move(outputs))
-        , Partitions(std::move(partitions))
-        , KeyColumnTypes(std::move(keyColumnTypes))
-        , KeyColumnIndices(std::move(keyColumnIndices))
+        , Partitions(std::move(partitions)) 
+        , KeyColumnTypes(std::move(keyColumnTypes)) 
+        , KeyColumnIndices(std::move(keyColumnIndices)) 
     {
-        MKQL_ENSURE_S(!Partitions.empty());
-        MKQL_ENSURE_S(KeyColumnTypes.size() == KeyColumnIndices.size());
-
+        MKQL_ENSURE_S(!Partitions.empty()); 
+        MKQL_ENSURE_S(KeyColumnTypes.size() == KeyColumnIndices.size()); 
+ 
         SortPartitions(Partitions, KeyColumnTypes, [](const auto& partition) { return partition.Range; });
-    }
-
+    } 
+ 
     bool IsFull() const override {
         return AnyOf(Outputs, [](const auto& output) { return output->IsFull(); });
     }
-
+ 
     void Consume(TUnboxedValue&& value) final {
         ui32 partitionIndex = FindKeyPartitionIndex(TypeEnv, value, Partitions, KeyColumnTypes, KeyColumnIndices,
                 [](const auto& partition) { return partition.Range; });
-
+ 
         Outputs[partitionIndex]->Push(std::move(value));
     }
-
+ 
     void Finish() final {
         for (auto& output : Outputs) {
             output->Finish();
-        }
-    }
-
-private:
+        } 
+    } 
+ 
+private: 
     const TTypeEnvironment& TypeEnv;
     TVector<NYql::NDq::IDqOutput::TPtr> Outputs;
-    TVector<TKqpRangePartition> Partitions;
+    TVector<TKqpRangePartition> Partitions; 
     TVector<TDataTypeId> KeyColumnTypes;
-    TVector<ui32> KeyColumnIndices;
-};
-
-} // namespace
-
+    TVector<ui32> KeyColumnIndices; 
+}; 
+ 
+} // namespace 
+ 
 NYql::NDq::IDqOutputConsumer::TPtr CreateOutputRangePartitionConsumer(
     TVector<NYql::NDq::IDqOutput::TPtr>&& outputs, TVector<TKqpRangePartition>&& partitions,
     TVector<NUdf::TDataTypeId>&& keyColumnTypes, TVector<ui32>&& keyColumnIndices,
@@ -68,7 +68,7 @@ NYql::NDq::IDqOutputConsumer::TPtr CreateOutputRangePartitionConsumer(
 {
     return MakeIntrusive<TKqpOutputRangePartitionConsumer>(typeEnv, std::move(outputs), std::move(partitions),
             std::move(keyColumnTypes), std::move(keyColumnIndices));
-}
-
+} 
+ 
 } // namespace NKqp
 } // namespace NKikimr
diff --git a/ydb/core/kqp/runtime/kqp_program_builder.cpp b/ydb/core/kqp/runtime/kqp_program_builder.cpp
index b5169c19d8..08e42cd102 100644
--- a/ydb/core/kqp/runtime/kqp_program_builder.cpp
+++ b/ydb/core/kqp/runtime/kqp_program_builder.cpp
@@ -1,19 +1,19 @@
-#include "kqp_program_builder.h"
-
+#include "kqp_program_builder.h" 
+ 
 #include <ydb/core/kqp/common/kqp_yql.h>
 #include <ydb/core/scheme/scheme_tabledefs.h>
-
+ 
 #include <ydb/library/yql/minikql/mkql_node_cast.h>
 #include <ydb/library/yql/minikql/mkql_runtime_version.h>
-
-namespace NKikimr {
-namespace NMiniKQL {
-
-namespace {
-
-TType* GetRowType(const TProgramBuilder& builder, const TArrayRef<TKqpTableColumn>& columns) {
-    TStructTypeBuilder rowTypeBuilder(builder.GetTypeEnvironment());
-    for (auto& column : columns) {
+ 
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
+namespace { 
+ 
+TType* GetRowType(const TProgramBuilder& builder, const TArrayRef<TKqpTableColumn>& columns) { 
+    TStructTypeBuilder rowTypeBuilder(builder.GetTypeEnvironment()); 
+    for (auto& column : columns) { 
         TType* type = nullptr;
         if (column.Type == NUdf::TDataType<NUdf::TDecimal>::Id) {
             type = TDataDecimalType::Create(NScheme::DECIMAL_PRECISION, NScheme::DECIMAL_SCALE, builder.GetTypeEnvironment());
@@ -26,121 +26,121 @@ TType* GetRowType(const TProgramBuilder& builder, const TArrayRef<TKqpTableColum
         }
 
         rowTypeBuilder.Add(column.Name, type);
-    }
-
-    return rowTypeBuilder.Build();
-}
-
-TRuntimeNode BuildColumnTags(const TProgramBuilder& builder, const TArrayRef<TKqpTableColumn>& columns) {
-    TStructLiteralBuilder tagsBuilder(builder.GetTypeEnvironment());
-    for (auto& column : columns) {
-        tagsBuilder.Add(column.Name, builder.NewDataLiteral<ui32>(column.Id));
-    }
-
-    return TRuntimeNode(tagsBuilder.Build(), true);
-}
-
-TRuntimeNode BuildColumnIndicesMap(const TProgramBuilder& builder, const TStructType& rowType,
-    const TArrayRef<TKqpTableColumn>& columns)
-{
-    TDictLiteralBuilder indicesMap(builder.GetTypeEnvironment(),
-        TDataType::Create(NUdf::TDataType<ui32>::Id, builder.GetTypeEnvironment()),
-        TDataType::Create(NUdf::TDataType<ui32>::Id, builder.GetTypeEnvironment()));
-
-    for (auto& column : columns) {
-        ui32 index = rowType.GetMemberIndex(column.Name);
-        indicesMap.Add(builder.NewDataLiteral<ui32>(column.Id), builder.NewDataLiteral<ui32>(index));
-    }
-
-    return TRuntimeNode(indicesMap.Build(), true);
-}
-
-TRuntimeNode BuildKeyPrefixIndicesList(const TProgramBuilder& builder, const TStructType& rowType,
-    const TArrayRef<TKqpTableColumn>& keyColumns)
-{
-    TListLiteralBuilder indicesList(builder.GetTypeEnvironment(),
-        TDataType::Create(NUdf::TDataType<ui32>::Id, builder.GetTypeEnvironment()));
-
-    MKQL_ENSURE_S(rowType.GetMembersCount() <= keyColumns.size());
-    for (ui32 i = 0; i < rowType.GetMembersCount(); ++i) {
-        auto& keyColumn = keyColumns[i];
-        ui32 index = rowType.GetMemberIndex(keyColumn.Name);
-        indicesList.Add(builder.NewDataLiteral<ui32>(index));
-    }
-
-    return TRuntimeNode(indicesList.Build(), true);
-}
-
-TRuntimeNode BuildTableIdLiteral(const TTableId& tableId, TProgramBuilder& builder) {
-    TVector<TRuntimeNode> tupleItems {
+    } 
+ 
+    return rowTypeBuilder.Build(); 
+} 
+ 
+TRuntimeNode BuildColumnTags(const TProgramBuilder& builder, const TArrayRef<TKqpTableColumn>& columns) { 
+    TStructLiteralBuilder tagsBuilder(builder.GetTypeEnvironment()); 
+    for (auto& column : columns) { 
+        tagsBuilder.Add(column.Name, builder.NewDataLiteral<ui32>(column.Id)); 
+    } 
+ 
+    return TRuntimeNode(tagsBuilder.Build(), true); 
+} 
+ 
+TRuntimeNode BuildColumnIndicesMap(const TProgramBuilder& builder, const TStructType& rowType, 
+    const TArrayRef<TKqpTableColumn>& columns) 
+{ 
+    TDictLiteralBuilder indicesMap(builder.GetTypeEnvironment(), 
+        TDataType::Create(NUdf::TDataType<ui32>::Id, builder.GetTypeEnvironment()), 
+        TDataType::Create(NUdf::TDataType<ui32>::Id, builder.GetTypeEnvironment())); 
+ 
+    for (auto& column : columns) { 
+        ui32 index = rowType.GetMemberIndex(column.Name); 
+        indicesMap.Add(builder.NewDataLiteral<ui32>(column.Id), builder.NewDataLiteral<ui32>(index)); 
+    } 
+ 
+    return TRuntimeNode(indicesMap.Build(), true); 
+} 
+ 
+TRuntimeNode BuildKeyPrefixIndicesList(const TProgramBuilder& builder, const TStructType& rowType, 
+    const TArrayRef<TKqpTableColumn>& keyColumns) 
+{ 
+    TListLiteralBuilder indicesList(builder.GetTypeEnvironment(), 
+        TDataType::Create(NUdf::TDataType<ui32>::Id, builder.GetTypeEnvironment())); 
+ 
+    MKQL_ENSURE_S(rowType.GetMembersCount() <= keyColumns.size()); 
+    for (ui32 i = 0; i < rowType.GetMembersCount(); ++i) { 
+        auto& keyColumn = keyColumns[i]; 
+        ui32 index = rowType.GetMemberIndex(keyColumn.Name); 
+        indicesList.Add(builder.NewDataLiteral<ui32>(index)); 
+    } 
+ 
+    return TRuntimeNode(indicesList.Build(), true); 
+} 
+ 
+TRuntimeNode BuildTableIdLiteral(const TTableId& tableId, TProgramBuilder& builder) { 
+    TVector<TRuntimeNode> tupleItems { 
         builder.NewDataLiteral<ui64>(tableId.PathId.OwnerId),
         builder.NewDataLiteral<ui64>(tableId.PathId.LocalPathId),
-        builder.NewDataLiteral<NUdf::EDataSlot::String>(tableId.SysViewInfo),
-        builder.NewDataLiteral<ui64>(tableId.SchemaVersion),
-    };
-
-    return builder.NewTuple(tupleItems);
-}
-
-TRuntimeNode BuildKeyRangeNode(TProgramBuilder& builder, const TKqpKeyRange& range) {
-    TVector<TRuntimeNode> rangeItems;
-    rangeItems.reserve(4);
-    rangeItems.push_back(builder.NewTuple(range.FromTuple));
-    rangeItems.push_back(builder.NewDataLiteral(range.FromInclusive));
-    rangeItems.push_back(builder.NewTuple(range.ToTuple));
-    rangeItems.push_back(builder.NewDataLiteral(range.ToInclusive));
-
-    return builder.NewTuple(rangeItems);
-}
-
+        builder.NewDataLiteral<NUdf::EDataSlot::String>(tableId.SysViewInfo), 
+        builder.NewDataLiteral<ui64>(tableId.SchemaVersion), 
+    }; 
+ 
+    return builder.NewTuple(tupleItems); 
+} 
+ 
+TRuntimeNode BuildKeyRangeNode(TProgramBuilder& builder, const TKqpKeyRange& range) { 
+    TVector<TRuntimeNode> rangeItems; 
+    rangeItems.reserve(4); 
+    rangeItems.push_back(builder.NewTuple(range.FromTuple)); 
+    rangeItems.push_back(builder.NewDataLiteral(range.FromInclusive)); 
+    rangeItems.push_back(builder.NewTuple(range.ToTuple)); 
+    rangeItems.push_back(builder.NewDataLiteral(range.ToInclusive)); 
+ 
+    return builder.NewTuple(rangeItems); 
+} 
+ 
 TRuntimeNode BuildKeyRangesNode(TProgramBuilder& builder, const TKqpKeyRanges& range) {
     TVector<TRuntimeNode> rangeItems{range.Ranges};
     return builder.NewTuple(rangeItems);
 }
 
-TRuntimeNode BuildSkipNullKeysNode(TProgramBuilder& builder, const TKqpKeyRange& range) {
-    TListLiteralBuilder skipNullKeysBuilder(
-        builder.GetTypeEnvironment(),
-        builder.NewDataType(NUdf::TDataType<bool>::Id));
-
-    for (bool skipNull : range.SkipNullKeys) {
-        skipNullKeysBuilder.Add(builder.NewDataLiteral(skipNull));
-    }
-    return TRuntimeNode(skipNullKeysBuilder.Build(), true);
-}
-
-TType* MakeWideFlowType(TProgramBuilder& builder, TStructType* rowType) {
-    std::vector<TType*> tupleItems;
-    tupleItems.reserve(rowType->GetMembersCount());
-    for (ui32 i = 0; i < rowType->GetMembersCount(); ++i) {
-        tupleItems.push_back(rowType->GetMemberType(i));
-    }
-
-    return builder.NewFlowType(builder.NewTupleType(tupleItems));
-}
-
-} // namespace
-
-TKqpProgramBuilder::TKqpProgramBuilder(const TTypeEnvironment& env, const IFunctionRegistry& functionRegistry)
-    : TProgramBuilder(env, functionRegistry) {}
-
+TRuntimeNode BuildSkipNullKeysNode(TProgramBuilder& builder, const TKqpKeyRange& range) { 
+    TListLiteralBuilder skipNullKeysBuilder( 
+        builder.GetTypeEnvironment(), 
+        builder.NewDataType(NUdf::TDataType<bool>::Id)); 
+ 
+    for (bool skipNull : range.SkipNullKeys) { 
+        skipNullKeysBuilder.Add(builder.NewDataLiteral(skipNull)); 
+    } 
+    return TRuntimeNode(skipNullKeysBuilder.Build(), true); 
+} 
+ 
+TType* MakeWideFlowType(TProgramBuilder& builder, TStructType* rowType) { 
+    std::vector<TType*> tupleItems; 
+    tupleItems.reserve(rowType->GetMembersCount()); 
+    for (ui32 i = 0; i < rowType->GetMembersCount(); ++i) { 
+        tupleItems.push_back(rowType->GetMemberType(i)); 
+    } 
+ 
+    return builder.NewFlowType(builder.NewTupleType(tupleItems)); 
+} 
+ 
+} // namespace 
+ 
+TKqpProgramBuilder::TKqpProgramBuilder(const TTypeEnvironment& env, const IFunctionRegistry& functionRegistry) 
+    : TProgramBuilder(env, functionRegistry) {} 
+ 
 TRuntimeNode TKqpProgramBuilder::KqpReadTable(const TTableId& tableId, const TKqpKeyRange& range,
-    const TArrayRef<TKqpTableColumn>& columns)
-{
-    auto rowType = GetRowType(*this, columns);
+    const TArrayRef<TKqpTableColumn>& columns) 
+{ 
+    auto rowType = GetRowType(*this, columns); 
     auto returnType = NewFlowType(rowType);
-
-    TCallableBuilder builder(Env, __func__, returnType);
-    builder.Add(BuildTableIdLiteral(tableId, *this));
-    builder.Add(BuildKeyRangeNode(*this, range));
-    builder.Add(BuildColumnTags(*this, columns));
-    builder.Add(BuildSkipNullKeysNode(*this, range));
+ 
+    TCallableBuilder builder(Env, __func__, returnType); 
+    builder.Add(BuildTableIdLiteral(tableId, *this)); 
+    builder.Add(BuildKeyRangeNode(*this, range)); 
+    builder.Add(BuildColumnTags(*this, columns)); 
+    builder.Add(BuildSkipNullKeysNode(*this, range)); 
     builder.Add(range.ItemsLimit ? range.ItemsLimit : NewNull());
     builder.Add(NewDataLiteral(range.Reverse));
-
-    return TRuntimeNode(builder.Build(), false);
-}
-
+ 
+    return TRuntimeNode(builder.Build(), false); 
+} 
+ 
 TRuntimeNode TKqpProgramBuilder::KqpWideReadTable(const TTableId& tableId, const TKqpKeyRange& range,
     const TArrayRef<TKqpTableColumn>& columns)
 {
@@ -148,16 +148,16 @@ TRuntimeNode TKqpProgramBuilder::KqpWideReadTable(const TTableId& tableId, const
     auto structType = AS_TYPE(TStructType, rowType);
     auto returnType = MakeWideFlowType(*this, structType);
 
-    MKQL_ENSURE_S(returnType);
-    MKQL_ENSURE_S(returnType->IsFlow());
-    const auto itemType = AS_TYPE(TFlowType, returnType)->GetItemType();
-    MKQL_ENSURE_S(itemType->IsTuple());
+    MKQL_ENSURE_S(returnType); 
+    MKQL_ENSURE_S(returnType->IsFlow()); 
+    const auto itemType = AS_TYPE(TFlowType, returnType)->GetItemType(); 
+    MKQL_ENSURE_S(itemType->IsTuple()); 
 
     TCallableBuilder builder(Env, __func__, returnType);
     builder.Add(BuildTableIdLiteral(tableId, *this));
-    builder.Add(BuildKeyRangeNode(*this, range));
+    builder.Add(BuildKeyRangeNode(*this, range)); 
     builder.Add(BuildColumnTags(*this, columns));
-    builder.Add(BuildSkipNullKeysNode(*this, range));
+    builder.Add(BuildSkipNullKeysNode(*this, range)); 
     builder.Add(range.ItemsLimit ? range.ItemsLimit : NewNull());
     builder.Add(NewDataLiteral(range.Reverse));
 
@@ -188,40 +188,40 @@ TRuntimeNode TKqpProgramBuilder::KqpWideReadTableRanges(const TTableId& tableId,
     return TRuntimeNode(builder.Build(), false);
 }
 
-TRuntimeNode TKqpProgramBuilder::KqpLookupTable(const TTableId& tableId, const TRuntimeNode& lookupKeys,
-    const TArrayRef<TKqpTableColumn>& keyColumns, const TArrayRef<TKqpTableColumn>& columns)
-{
-    auto keysType = AS_TYPE(TStreamType, lookupKeys.GetStaticType());
-    auto keyType = AS_TYPE(TStructType, keysType->GetItemType());
-
-    auto rowType = GetRowType(*this, columns);
-    auto returnType = NewFlowType(rowType);
-
-    TCallableBuilder builder(Env, __func__, returnType);
-    builder.Add(BuildTableIdLiteral(tableId, *this));
-    builder.Add(lookupKeys);
-    builder.Add(BuildKeyPrefixIndicesList(*this, *keyType, keyColumns));
-    builder.Add(BuildColumnTags(*this, columns));
-
-    return TRuntimeNode(builder.Build(), false);
-}
-
-TRuntimeNode TKqpProgramBuilder::KqpUpsertRows(const TTableId& tableId, const TRuntimeNode& rows,
+TRuntimeNode TKqpProgramBuilder::KqpLookupTable(const TTableId& tableId, const TRuntimeNode& lookupKeys, 
+    const TArrayRef<TKqpTableColumn>& keyColumns, const TArrayRef<TKqpTableColumn>& columns) 
+{ 
+    auto keysType = AS_TYPE(TStreamType, lookupKeys.GetStaticType()); 
+    auto keyType = AS_TYPE(TStructType, keysType->GetItemType()); 
+ 
+    auto rowType = GetRowType(*this, columns); 
+    auto returnType = NewFlowType(rowType); 
+ 
+    TCallableBuilder builder(Env, __func__, returnType); 
+    builder.Add(BuildTableIdLiteral(tableId, *this)); 
+    builder.Add(lookupKeys); 
+    builder.Add(BuildKeyPrefixIndicesList(*this, *keyType, keyColumns)); 
+    builder.Add(BuildColumnTags(*this, columns)); 
+ 
+    return TRuntimeNode(builder.Build(), false); 
+} 
+ 
+TRuntimeNode TKqpProgramBuilder::KqpUpsertRows(const TTableId& tableId, const TRuntimeNode& rows, 
     const TArrayRef<TKqpTableColumn>& upsertColumns)
-{
-    auto streamType = AS_TYPE(TStreamType, rows.GetStaticType());
-    auto rowType = AS_TYPE(TStructType, streamType->GetItemType());
-
-    auto returnType = NewStreamType(NewResourceType(NYql::KqpEffectTag));
-
-    TCallableBuilder builder(Env, __func__, returnType);
-    builder.Add(BuildTableIdLiteral(tableId, *this));
-    builder.Add(rows);
-    builder.Add(BuildColumnIndicesMap(*this, *rowType, upsertColumns));
-
-    return TRuntimeNode(builder.Build(), false);
-}
-
+{ 
+    auto streamType = AS_TYPE(TStreamType, rows.GetStaticType()); 
+    auto rowType = AS_TYPE(TStructType, streamType->GetItemType()); 
+ 
+    auto returnType = NewStreamType(NewResourceType(NYql::KqpEffectTag)); 
+ 
+    TCallableBuilder builder(Env, __func__, returnType); 
+    builder.Add(BuildTableIdLiteral(tableId, *this)); 
+    builder.Add(rows); 
+    builder.Add(BuildColumnIndicesMap(*this, *rowType, upsertColumns)); 
+ 
+    return TRuntimeNode(builder.Build(), false); 
+} 
+ 
 TRuntimeNode TKqpProgramBuilder::KqpDeleteRows(const TTableId& tableId, const TRuntimeNode& rows) {
     auto returnType = NewStreamType(NewResourceType(NYql::KqpEffectTag));
 
@@ -232,16 +232,16 @@ TRuntimeNode TKqpProgramBuilder::KqpDeleteRows(const TTableId& tableId, const TR
     return TRuntimeNode(builder.Build(), false);
 }
 
-TRuntimeNode TKqpProgramBuilder::KqpEffects(const TArrayRef<const TRuntimeNode>& effects) {
-    auto returnType = NewStreamType(NewResourceType(NYql::KqpEffectTag));
-    TCallableBuilder builder(Env, __func__, returnType);
-    for (auto& effect : effects) {
-        builder.Add(effect);
-    }
-
-    return TRuntimeNode(builder.Build(), false);
-}
-
+TRuntimeNode TKqpProgramBuilder::KqpEffects(const TArrayRef<const TRuntimeNode>& effects) { 
+    auto returnType = NewStreamType(NewResourceType(NYql::KqpEffectTag)); 
+    TCallableBuilder builder(Env, __func__, returnType); 
+    for (auto& effect : effects) { 
+        builder.Add(effect); 
+    } 
+ 
+    return TRuntimeNode(builder.Build(), false); 
+} 
+ 
 TRuntimeNode TKqpProgramBuilder::KqpEnsure(TRuntimeNode value, TRuntimeNode predicate, TRuntimeNode issueCode,
     TRuntimeNode message)
 {
@@ -270,4 +270,4 @@ TRuntimeNode TKqpProgramBuilder::KqpEnsure(TRuntimeNode value, TRuntimeNode pred
 }
 
 } // namespace NMiniKQL
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/runtime/kqp_program_builder.h b/ydb/core/kqp/runtime/kqp_program_builder.h
index 348d25eeea..67de99bffe 100644
--- a/ydb/core/kqp/runtime/kqp_program_builder.h
+++ b/ydb/core/kqp/runtime/kqp_program_builder.h
@@ -1,38 +1,38 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/minikql/mkql_program_builder.h>
-
-namespace NKikimr {
-
-struct TTableId;
-
-namespace NMiniKQL {
-
-struct TKqpTableColumn {
-    ui32 Id;
-    TString Name;
-    NUdf::TDataTypeId Type;
+ 
+namespace NKikimr { 
+ 
+struct TTableId; 
+ 
+namespace NMiniKQL { 
+ 
+struct TKqpTableColumn { 
+    ui32 Id; 
+    TString Name; 
+    NUdf::TDataTypeId Type; 
     bool NotNull;
-
+ 
     TKqpTableColumn(ui32 id, const TStringBuf& name, NUdf::TDataTypeId type, bool notNull)
-        : Id(id)
-        , Name(name)
+        : Id(id) 
+        , Name(name) 
         , Type(type)
         , NotNull(notNull) {}
-};
-
-using TKqpKeyTuple = TVector<TRuntimeNode>;
-
-struct TKqpKeyRange {
-    TKqpKeyTuple FromTuple;
-    TKqpKeyTuple ToTuple;
-    bool FromInclusive = false;
-    bool ToInclusive = false;
+}; 
+ 
+using TKqpKeyTuple = TVector<TRuntimeNode>; 
+ 
+struct TKqpKeyRange { 
+    TKqpKeyTuple FromTuple; 
+    TKqpKeyTuple ToTuple; 
+    bool FromInclusive = false; 
+    bool ToInclusive = false; 
     TSmallVec<bool> SkipNullKeys;
     TRuntimeNode ItemsLimit;
     bool Reverse = false;
-};
-
+}; 
+ 
 struct TKqpKeyRanges {
     TRuntimeNode Ranges;
     TSmallVec<bool> SkipNullKeys;
@@ -40,31 +40,31 @@ struct TKqpKeyRanges {
     bool Reverse = false;
 };
 
-class TKqpProgramBuilder: public TProgramBuilder {
-public:
-    TKqpProgramBuilder(const TTypeEnvironment& env, const IFunctionRegistry& functionRegistry);
-
+class TKqpProgramBuilder: public TProgramBuilder { 
+public: 
+    TKqpProgramBuilder(const TTypeEnvironment& env, const IFunctionRegistry& functionRegistry); 
+ 
     TRuntimeNode KqpReadTable(const TTableId& tableId, const TKqpKeyRange& range,
-        const TArrayRef<TKqpTableColumn>& columns);
-
+        const TArrayRef<TKqpTableColumn>& columns); 
+ 
     TRuntimeNode KqpWideReadTable(const TTableId& tableId, const TKqpKeyRange& range,
         const TArrayRef<TKqpTableColumn>& columns);
 
     TRuntimeNode KqpWideReadTableRanges(const TTableId& tableId, const TKqpKeyRanges& range,
         const TArrayRef<TKqpTableColumn>& columns, TType* returnType);
 
-    TRuntimeNode KqpLookupTable(const TTableId& tableId, const TRuntimeNode& lookupKeys,
-        const TArrayRef<TKqpTableColumn>& keyColumns, const TArrayRef<TKqpTableColumn>& columns);
-
-    TRuntimeNode KqpUpsertRows(const TTableId& tableId, const TRuntimeNode& rows,
+    TRuntimeNode KqpLookupTable(const TTableId& tableId, const TRuntimeNode& lookupKeys, 
+        const TArrayRef<TKqpTableColumn>& keyColumns, const TArrayRef<TKqpTableColumn>& columns); 
+ 
+    TRuntimeNode KqpUpsertRows(const TTableId& tableId, const TRuntimeNode& rows, 
         const TArrayRef<TKqpTableColumn>& upsertColumns);
-
-    TRuntimeNode KqpDeleteRows(const TTableId& tableId, const TRuntimeNode& rows);
-
-    TRuntimeNode KqpEffects(const TArrayRef<const TRuntimeNode>& effects);
+ 
+    TRuntimeNode KqpDeleteRows(const TTableId& tableId, const TRuntimeNode& rows); 
+ 
+    TRuntimeNode KqpEffects(const TArrayRef<const TRuntimeNode>& effects); 
 
     TRuntimeNode KqpEnsure(TRuntimeNode value, TRuntimeNode predicate, TRuntimeNode issueCode, TRuntimeNode message);
-};
-
+}; 
+ 
 } // namespace NMiniKQL
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/runtime/kqp_read_table.cpp b/ydb/core/kqp/runtime/kqp_read_table.cpp
index 358ebd0a3e..b6d4601b39 100644
--- a/ydb/core/kqp/runtime/kqp_read_table.cpp
+++ b/ydb/core/kqp/runtime/kqp_read_table.cpp
@@ -6,32 +6,32 @@
 #include <ydb/library/yql/minikql/mkql_node_cast.h>
 
 namespace NKikimr {
-
-namespace NKqp {
-
-using namespace NMiniKQL;
-
-TTableId ParseTableId(const TRuntimeNode& node) {
-    auto tuple = AS_VALUE(TTupleLiteral, node);
-    MKQL_ENSURE_S(tuple->GetValuesCount() >= 4);
-    ui64 ownerId = AS_VALUE(TDataLiteral, tuple->GetValue(0))->AsValue().Get<ui64>();
-    ui64 tableId = AS_VALUE(TDataLiteral, tuple->GetValue(1))->AsValue().Get<ui64>();
-    TString sysViewInfo(AS_VALUE(TDataLiteral, tuple->GetValue(2))->AsValue().AsStringRef());
-    ui64 schemeVersion = AS_VALUE(TDataLiteral, tuple->GetValue(3))->AsValue().Get<ui64>();
-    return TTableId(ownerId, tableId, sysViewInfo, schemeVersion);
-}
-
-NUdf::TDataTypeId UnwrapDataTypeFromStruct(const TStructType& structType, ui32 index) {
-    if (structType.GetMemberType(index)->GetKind() == TType::EKind::Optional) {
-        auto type = AS_TYPE(TDataType, AS_TYPE(TOptionalType, structType.GetMemberType(index))->GetItemType());
-        return type->GetSchemeType();
-    } else {
-        return AS_TYPE(TDataType, structType.GetMemberType(index))->GetSchemeType();
-    }
-}
-
-} // namespace NKqp
-
+ 
+namespace NKqp { 
+ 
+using namespace NMiniKQL; 
+ 
+TTableId ParseTableId(const TRuntimeNode& node) { 
+    auto tuple = AS_VALUE(TTupleLiteral, node); 
+    MKQL_ENSURE_S(tuple->GetValuesCount() >= 4); 
+    ui64 ownerId = AS_VALUE(TDataLiteral, tuple->GetValue(0))->AsValue().Get<ui64>(); 
+    ui64 tableId = AS_VALUE(TDataLiteral, tuple->GetValue(1))->AsValue().Get<ui64>(); 
+    TString sysViewInfo(AS_VALUE(TDataLiteral, tuple->GetValue(2))->AsValue().AsStringRef()); 
+    ui64 schemeVersion = AS_VALUE(TDataLiteral, tuple->GetValue(3))->AsValue().Get<ui64>(); 
+    return TTableId(ownerId, tableId, sysViewInfo, schemeVersion); 
+} 
+ 
+NUdf::TDataTypeId UnwrapDataTypeFromStruct(const TStructType& structType, ui32 index) { 
+    if (structType.GetMemberType(index)->GetKind() == TType::EKind::Optional) { 
+        auto type = AS_TYPE(TDataType, AS_TYPE(TOptionalType, structType.GetMemberType(index))->GetItemType()); 
+        return type->GetSchemeType(); 
+    } else { 
+        return AS_TYPE(TDataType, structType.GetMemberType(index))->GetSchemeType(); 
+    } 
+} 
+ 
+} // namespace NKqp 
+ 
 namespace NMiniKQL {
 
 using namespace NTable;
@@ -70,37 +70,37 @@ void BuildKeyTupleCells(const TTupleType* tupleType, const TUnboxedValue& tupleV
 }
 
 void ParseReadColumns(const TType* readType, const TRuntimeNode& tagsNode,
-    TSmallVec<TKqpComputeContextBase::TColumn>& columns, TSmallVec<TKqpComputeContextBase::TColumn>& systemColumns)
-{
-    MKQL_ENSURE_S(readType);
-    MKQL_ENSURE_S(readType->GetKind() == TType::EKind::Flow);
+    TSmallVec<TKqpComputeContextBase::TColumn>& columns, TSmallVec<TKqpComputeContextBase::TColumn>& systemColumns) 
+{ 
+    MKQL_ENSURE_S(readType); 
+    MKQL_ENSURE_S(readType->GetKind() == TType::EKind::Flow); 
 
     auto tags = AS_VALUE(TStructLiteral, tagsNode);
     MKQL_ENSURE_S(tags);
 
-    auto itemType = AS_TYPE(TFlowType, readType)->GetItemType();
-    MKQL_ENSURE_S(itemType->GetKind() == TType::EKind::Struct);
+    auto itemType = AS_TYPE(TFlowType, readType)->GetItemType(); 
+    MKQL_ENSURE_S(itemType->GetKind() == TType::EKind::Struct); 
 
-    auto structType = AS_TYPE(TStructType, itemType);
+    auto structType = AS_TYPE(TStructType, itemType); 
     MKQL_ENSURE_S(tags->GetValuesCount() == structType->GetMembersCount());
 
-    columns.reserve(structType->GetMembersCount());
+    columns.reserve(structType->GetMembersCount()); 
 
-    for (ui32 i = 0; i < structType->GetMembersCount(); ++i) {
-        auto memberType = structType->GetMemberType(i);
-        if (memberType->GetKind() == TType::EKind::Optional) {
-            memberType = AS_TYPE(TOptionalType, memberType)->GetItemType();
-        }
-        MKQL_ENSURE_S(memberType->GetKind() == TType::EKind::Data);
+    for (ui32 i = 0; i < structType->GetMembersCount(); ++i) { 
+        auto memberType = structType->GetMemberType(i); 
+        if (memberType->GetKind() == TType::EKind::Optional) { 
+            memberType = AS_TYPE(TOptionalType, memberType)->GetItemType(); 
+        } 
+        MKQL_ENSURE_S(memberType->GetKind() == TType::EKind::Data); 
         NTable::TTag columnId = AS_VALUE(TDataLiteral, tags->GetValue(i))->AsValue().Get<ui32>();
-        if (IsSystemColumn(columnId)) {
-            systemColumns.push_back({columnId, AS_TYPE(TDataType, memberType)->GetSchemeType()});
-        } else {
-            columns.push_back({columnId, AS_TYPE(TDataType, memberType)->GetSchemeType()});
-        }
-    }
-}
-
+        if (IsSystemColumn(columnId)) { 
+            systemColumns.push_back({columnId, AS_TYPE(TDataType, memberType)->GetSchemeType()}); 
+        } else { 
+            columns.push_back({columnId, AS_TYPE(TDataType, memberType)->GetSchemeType()}); 
+        } 
+    } 
+} 
+ 
 void ParseWideReadColumns(const TCallable& callable, const TRuntimeNode& tagsNode,
     TSmallVec<TKqpComputeContextBase::TColumn>& columns, TSmallVec<TKqpComputeContextBase::TColumn>& systemColumns)
 {
diff --git a/ydb/core/kqp/runtime/kqp_read_table.h b/ydb/core/kqp/runtime/kqp_read_table.h
index 99c9cc3f05..c6b7ce3199 100644
--- a/ydb/core/kqp/runtime/kqp_read_table.h
+++ b/ydb/core/kqp/runtime/kqp_read_table.h
@@ -36,8 +36,8 @@ struct TParseReadTableRangesResult : TParseReadTableResultBase {
 };
 
 void ParseReadColumns(const TType* readType, const TRuntimeNode& tagsNode,
-    TSmallVec<TKqpComputeContextBase::TColumn>& columns, TSmallVec<TKqpComputeContextBase::TColumn>& systemColumns);
-
+    TSmallVec<TKqpComputeContextBase::TColumn>& columns, TSmallVec<TKqpComputeContextBase::TColumn>& systemColumns); 
+ 
 TParseReadTableResult ParseWideReadTable(TCallable& callable);
 TParseReadTableRangesResult ParseWideReadTableRanges(TCallable& callable);
 
diff --git a/ydb/core/kqp/runtime/kqp_runtime_impl.h b/ydb/core/kqp/runtime/kqp_runtime_impl.h
index 004af2a5d6..71ae621284 100644
--- a/ydb/core/kqp/runtime/kqp_runtime_impl.h
+++ b/ydb/core/kqp/runtime/kqp_runtime_impl.h
@@ -1,28 +1,28 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/scheme/scheme_tabledefs.h>
-
+ 
 #include <ydb/library/yql/dq/runtime/dq_output_consumer.h>
 #include <ydb/library/yql/minikql/mkql_node.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-struct TKqpRangePartition {
-    TKeyDesc::TPartitionRangeInfo Range;
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+struct TKqpRangePartition { 
+    TKeyDesc::TPartitionRangeInfo Range; 
     ui64 ChannelId = std::numeric_limits<ui64>::max();
-};
-
-TTableId ParseTableId(const NMiniKQL::TRuntimeNode& node);
-
-NUdf::TDataTypeId UnwrapDataTypeFromStruct(const NMiniKQL::TStructType& structType, ui32 index);
-
+}; 
+ 
+TTableId ParseTableId(const NMiniKQL::TRuntimeNode& node); 
+ 
+NUdf::TDataTypeId UnwrapDataTypeFromStruct(const NMiniKQL::TStructType& structType, ui32 index); 
+ 
 NYql::NDq::IDqOutputConsumer::TPtr CreateOutputRangePartitionConsumer(
     TVector<NYql::NDq::IDqOutput::TPtr>&& outputs, TVector<TKqpRangePartition>&& partitions,
     TVector<NUdf::TDataTypeId>&& keyColumnTypes, TVector<ui32>&& keyColumnIndices,
     const NMiniKQL::TTypeEnvironment& typeEnv);
-
-NYql::NDq::IDqOutputConsumer::TPtr CreateKqpApplyEffectsConsumer(NUdf::IApplyContext* applyCtx);
-
+ 
+NYql::NDq::IDqOutputConsumer::TPtr CreateKqpApplyEffectsConsumer(NUdf::IApplyContext* applyCtx); 
+ 
 } // namespace NKqp
 } // namespace NKikimr
diff --git a/ydb/core/kqp/runtime/kqp_tasks_runner.cpp b/ydb/core/kqp/runtime/kqp_tasks_runner.cpp
index 70b1038e6c..53d162e541 100644
--- a/ydb/core/kqp/runtime/kqp_tasks_runner.cpp
+++ b/ydb/core/kqp/runtime/kqp_tasks_runner.cpp
@@ -1,26 +1,26 @@
-#include "kqp_tasks_runner.h"
-
-#include "kqp_runtime_impl.h"
-
+#include "kqp_tasks_runner.h" 
+ 
+#include "kqp_runtime_impl.h" 
+ 
 #include <ydb/core/kqp/common/kqp_resolve.h>
-
+ 
 #include <ydb/library/yql/dq/runtime/dq_columns_resolve.h>
 #include <ydb/library/yql/dq/runtime/dq_tasks_runner.h>
-
-#include <util/generic/vector.h>
-
-namespace NKikimr {
+ 
+#include <util/generic/vector.h> 
+ 
+namespace NKikimr { 
 
 namespace NMiniKQL {
 class TKqpScanComputeContext;
 } // namespace NMiniKQL
 
-namespace NKqp {
-
-using namespace NMiniKQL;
-using namespace NYql;
+namespace NKqp { 
+ 
+using namespace NMiniKQL; 
+using namespace NYql; 
 using namespace NDq;
-
+ 
 IDqOutputConsumer::TPtr KqpBuildOutputConsumer(const NDqProto::TTaskOutput& outputDesc, const TType* type,
     NUdf::IApplyContext* applyCtx, const TTypeEnvironment& typeEnv, TVector<IDqOutput::TPtr>&& outputs)
 {
@@ -30,40 +30,40 @@ IDqOutputConsumer::TPtr KqpBuildOutputConsumer(const NDqProto::TTaskOutput& outp
             TVector<ui32> keyColumnIndices;
             GetColumnsInfo(type, outputDesc.GetRangePartition().GetKeyColumns(), keyColumnTypes, keyColumnIndices);
             YQL_ENSURE(!keyColumnTypes.empty());
-
+ 
             TVector<TKqpRangePartition> partitions;
             partitions.reserve(outputDesc.GetRangePartition().PartitionsSize());
-
+ 
             for (auto& partitionDesc : outputDesc.GetRangePartition().GetPartitions()) {
                 TKqpRangePartition partition;
                 partition.ChannelId = partitionDesc.GetChannelId();
                 partition.Range.EndKeyPrefix = TSerializedCellVec(partitionDesc.GetEndKeyPrefix());
                 partition.Range.IsInclusive = partitionDesc.GetIsInclusive();
                 partition.Range.IsPoint = partitionDesc.GetIsPoint();
-
+ 
                 partitions.emplace_back(std::move(partition));
-            }
-
+            } 
+ 
             return CreateOutputRangePartitionConsumer(std::move(outputs), std::move(partitions),
                 std::move(keyColumnTypes), std::move(keyColumnIndices), typeEnv);
         }
-
+ 
         case NDqProto::TTaskOutput::kEffects: {
             return CreateKqpApplyEffectsConsumer(applyCtx);
-        }
+        } 
 
         default: {
             return DqBuildOutputConsumer(outputDesc, type, typeEnv, std::move(outputs));
         }
-    }
+    } 
 }
-
+ 
 TIntrusivePtr<IDqTaskRunner> CreateKqpTaskRunner(const TDqTaskRunnerContext& execCtx,
     const TDqTaskRunnerSettings& settings, const TLogFunc& logFunc)
 {
     return MakeDqTaskRunner(execCtx, settings, logFunc);
-}
-
+} 
+ 
 
 TKqpTasksRunner::TKqpTasksRunner(const google::protobuf::RepeatedPtrField<NDqProto::TDqTask>& tasks,
     const TDqTaskRunnerContext& execCtx, const TDqTaskRunnerSettings& settings, const TLogFunc& logFunc)
@@ -225,4 +225,4 @@ TIntrusivePtr<TKqpTasksRunner> CreateKqpTasksRunner(const google::protobuf::Repe
 }
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/runtime/kqp_tasks_runner.h b/ydb/core/kqp/runtime/kqp_tasks_runner.h
index 6ae8bf1db7..888777e99f 100644
--- a/ydb/core/kqp/runtime/kqp_tasks_runner.h
+++ b/ydb/core/kqp/runtime/kqp_tasks_runner.h
@@ -1,9 +1,9 @@
-#pragma once
-
+#pragma once 
+ 
 #include "kqp_compute.h"
 #include <ydb/library/yql/dq/runtime/dq_tasks_runner.h>
-
-namespace NKikimr {
+ 
+namespace NKikimr { 
 namespace NKqp {
 
 NYql::NDq::IDqOutputConsumer::TPtr KqpBuildOutputConsumer(const NYql::NDqProto::TTaskOutput& outputDesc,
@@ -12,7 +12,7 @@ NYql::NDq::IDqOutputConsumer::TPtr KqpBuildOutputConsumer(const NYql::NDqProto::
 
 TIntrusivePtr<NYql::NDq::IDqTaskRunner> CreateKqpTaskRunner(const NYql::NDq::TDqTaskRunnerContext& execCtx,
     const NYql::NDq::TDqTaskRunnerSettings& settings, const NYql::NDq::TLogFunc& logFunc);
-
+ 
 
 class TKqpTasksRunner : public TSimpleRefCount<TKqpTasksRunner>, private TNonCopyable {
 public:
@@ -71,4 +71,4 @@ TIntrusivePtr<TKqpTasksRunner> CreateKqpTasksRunner(const google::protobuf::Repe
     const NYql::NDq::TLogFunc& logFunc);
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/runtime/kqp_transport.cpp b/ydb/core/kqp/runtime/kqp_transport.cpp
index 8c1b3262d0..2a3697e883 100644
--- a/ydb/core/kqp/runtime/kqp_transport.cpp
+++ b/ydb/core/kqp/runtime/kqp_transport.cpp
@@ -1,28 +1,28 @@
-#include "kqp_transport.h"
+#include "kqp_transport.h" 
 #include <ydb/library/yql/dq/proto/dq_transport.pb.h>
-
+ 
 #include <ydb/core/engine/mkql_proto.h>
 #include <ydb/core/ydb_convert/ydb_convert.h>
-
+ 
 #include <ydb/library/yql/dq/runtime/dq_transport.h>
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_pack.h>
 #include <ydb/library/yql/minikql/mkql_node_cast.h>
 #include <ydb/library/yql/utils/yql_panic.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NMiniKQL;
-using namespace NYql;
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NMiniKQL; 
+using namespace NYql; 
+ 
 TKqpProtoBuilder::TSelfHosted::TSelfHosted(const IFunctionRegistry& funcRegistry)
     : Alloc(TAlignedPagePoolCounters(), funcRegistry.SupportsSizedAllocators())
-    , TypeEnv(Alloc)
+    , TypeEnv(Alloc) 
     , MemInfo("KqpProtoBuilder")
     , HolderFactory(Alloc.Ref(), MemInfo)
-{
-}
-
+{ 
+} 
+ 
 TKqpProtoBuilder::TKqpProtoBuilder(const IFunctionRegistry& funcRegistry)
     : SelfHosted(MakeHolder<TSelfHosted>(funcRegistry))
 {
@@ -40,12 +40,12 @@ TKqpProtoBuilder::TKqpProtoBuilder(TScopedAlloc* alloc, TTypeEnvironment* typeEn
 {
 }
 
-TKqpProtoBuilder::~TKqpProtoBuilder() {
+TKqpProtoBuilder::~TKqpProtoBuilder() { 
     if (SelfHosted) {
         SelfHosted->Alloc.Acquire();
     }
-}
-
+} 
+ 
 NKikimrMiniKQL::TType TKqpProtoBuilder::ApplyColumnHints(const NKikimrMiniKQL::TType& srcRowType,
     const TVector<TString>& columnHints)
 {
@@ -75,17 +75,17 @@ NKikimrMiniKQL::TType TKqpProtoBuilder::ApplyColumnHints(const NKikimrMiniKQL::T
 
 void TKqpProtoBuilder::BuildValue(const TVector<NDqProto::TData>& data, const NKikimrMiniKQL::TType& valueType,
     NKikimrMiniKQL::TResult* result)
-{
+{ 
     THolder<TGuard<TScopedAlloc>> guard;
     if (SelfHosted) {
         guard = MakeHolder<TGuard<TScopedAlloc>>(*Alloc);
     }
-
+ 
     result->MutableType()->CopyFrom(valueType);
-
+ 
     auto mkqlType = ImportTypeFromProto(result->GetType(), *TypeEnv);
-
-    TUnboxedValueVector buffer;
+ 
+    TUnboxedValueVector buffer; 
     auto transportVersion = NDqProto::EDataTransportVersion::DATA_TRANSPORT_VERSION_UNSPECIFIED;
     if (!data.empty()) {
         switch (data.front().GetTransportVersion()) {
@@ -106,14 +106,14 @@ void TKqpProtoBuilder::BuildValue(const TVector<NDqProto::TData>& data, const NK
         }
     }
     NDq::TDqDataSerializer dataSerializer(*TypeEnv, *HolderFactory, transportVersion);
-    for (auto& part : data) {
-        dataSerializer.Deserialize(part, mkqlType, buffer);
-    }
-    YQL_ENSURE(buffer.size() == 1, "Actual buffer size: " << data.size());
-
+    for (auto& part : data) { 
+        dataSerializer.Deserialize(part, mkqlType, buffer); 
+    } 
+    YQL_ENSURE(buffer.size() == 1, "Actual buffer size: " << data.size()); 
+ 
     ExportValueToProto(mkqlType, buffer[0], *result->MutableValue());
 }
-
+ 
 void TKqpProtoBuilder::BuildValue(TUnboxedValueVector& rows, const NKikimrMiniKQL::TType& valueType,
     NKikimrMiniKQL::TResult* result)
 {
@@ -122,19 +122,19 @@ void TKqpProtoBuilder::BuildValue(TUnboxedValueVector& rows, const NKikimrMiniKQ
     result->MutableType()->CopyFrom(valueType);
     auto mkqlType = ImportTypeFromProto(result->GetType(), *TypeEnv);
     ExportValueToProto(mkqlType, rows[0], *result->MutableValue());
-}
-
+} 
+ 
 void TKqpProtoBuilder::BuildStream(const TVector<NDqProto::TData>& data, const NKikimrMiniKQL::TType& srcRowType,
     const NKikimrMiniKQL::TType* dstRowType, NKikimrMiniKQL::TResult* result)
-{
+{ 
     YQL_ENSURE(srcRowType.GetKind() == NKikimrMiniKQL::Struct);
-
+ 
     auto* mkqlSrcRowType = NMiniKQL::ImportTypeFromProto(srcRowType, *TypeEnv);
     auto* mkqlSrcRowStructType = static_cast<TStructType*>(mkqlSrcRowType);
 
     result->MutableType()->SetKind(NKikimrMiniKQL::List);
     auto* newRowType = result->MutableType()->MutableList()->MutableItem();
-
+ 
     TListType* mkqlSrcRowsType = nullptr;
     TMap<TStringBuf, ui32> memberIndices;
 
@@ -176,14 +176,14 @@ void TKqpProtoBuilder::BuildStream(const TVector<NDqProto::TData>& data, const N
         mkqlSrcRowsType = TListType::Create(mkqlSrcRowType, *TypeEnv);
     }
 
-    for (auto& part : data) {
+    for (auto& part : data) { 
         if (part.GetRows() == 0) {
             continue;
         }
 
         TUnboxedValueVector rows;
         dataSerializer.Deserialize(part, mkqlSrcRowType, rows);
-
+ 
         if (dstRowType) {
             for (auto& srcRow : rows) {
                 auto* dstRow = result->MutableValue()->MutableList()->Add()->MutableStruct();
@@ -198,9 +198,9 @@ void TKqpProtoBuilder::BuildStream(const TVector<NDqProto::TData>& data, const N
         } else {
             ExportValueToProto(mkqlSrcRowsType, HolderFactory->VectorAsArray(rows), *result->MutableValue());
         }
-    }
+    } 
 }
-
+ 
 void TKqpProtoBuilder::BuildStream(TUnboxedValueVector& rows, const NKikimrMiniKQL::TType& srcRowType,
     const NKikimrMiniKQL::TType* dstRowType, NKikimrMiniKQL::TResult* result)
 {
@@ -242,20 +242,20 @@ void TKqpProtoBuilder::BuildStream(TUnboxedValueVector& rows, const NKikimrMiniK
 
         ExportValueToProto(mkqlSrcRowsType, HolderFactory->VectorAsArray(rows), *result->MutableValue());
     }
-}
-
+} 
+ 
 Ydb::ResultSet TKqpProtoBuilder::BuildYdbResultSet(const TVector<NDqProto::TData>& data,
     const NKikimrMiniKQL::TType& srcRowType, const NKikimrMiniKQL::TType* dstRowType)
-{
+{ 
     YQL_ENSURE(srcRowType.GetKind() == NKikimrMiniKQL::Struct);
-
+ 
     auto* mkqlSrcRowType = NMiniKQL::ImportTypeFromProto(srcRowType, *TypeEnv);
     auto* mkqlSrcRowStructType = static_cast<TStructType*>(mkqlSrcRowType);
 
-    Ydb::ResultSet resultSet;
-
+    Ydb::ResultSet resultSet; 
+ 
     TMap<TStringBuf, ui32> memberIndices;
-
+ 
     if (dstRowType) {
         YQL_ENSURE(dstRowType->GetKind() == NKikimrMiniKQL::Struct);
 
@@ -274,8 +274,8 @@ Ydb::ResultSet TKqpProtoBuilder::BuildYdbResultSet(const TVector<NDqProto::TData
             column->set_name(member.GetName());
             ConvertMiniKQLTypeToYdbType(member.GetType(), *column->mutable_type());
         }
-    }
-
+    } 
+ 
     THolder<TGuard<TScopedAlloc>> guard;
     if (SelfHosted) {
         guard = MakeHolder<TGuard<TScopedAlloc>>(*Alloc);
@@ -302,7 +302,7 @@ Ydb::ResultSet TKqpProtoBuilder::BuildYdbResultSet(const TVector<NDqProto::TData
     }
     NDq::TDqDataSerializer dataSerializer(*TypeEnv, *HolderFactory, transportVersion);
 
-    for (auto& part : data) {
+    for (auto& part : data) { 
         if (part.GetRows()) {
             TUnboxedValueVector rows;
             dataSerializer.Deserialize(part, mkqlSrcRowType, rows);
@@ -325,11 +325,11 @@ Ydb::ResultSet TKqpProtoBuilder::BuildYdbResultSet(const TVector<NDqProto::TData
                     ExportValueToProto(mkqlSrcRowType, row, *resultSet.add_rows());
                 }
             }
-        }
-    }
-
-    return resultSet;
-}
-
+        } 
+    } 
+ 
+    return resultSet; 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/runtime/kqp_transport.h b/ydb/core/kqp/runtime/kqp_transport.h
index 9fa6adec13..8964992361 100644
--- a/ydb/core/kqp/runtime/kqp_transport.h
+++ b/ydb/core/kqp/runtime/kqp_transport.h
@@ -1,33 +1,33 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/common/kqp_gateway.h>
 #include <ydb/core/protos/kqp.pb.h>
-
+ 
 #include <ydb/library/yql/ast/yql_expr.h>
 #include <ydb/library/yql/minikql/computation/mkql_computation_node.h>
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_holders.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-class TKqpProtoBuilder : private TNonCopyable {
-public:
-    TKqpProtoBuilder(const NMiniKQL::IFunctionRegistry& funcRegistry);
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+class TKqpProtoBuilder : private TNonCopyable { 
+public: 
+    TKqpProtoBuilder(const NMiniKQL::IFunctionRegistry& funcRegistry); 
 
     TKqpProtoBuilder(NMiniKQL::TScopedAlloc* alloc, NMiniKQL::TTypeEnvironment* typeEnv,
         NMiniKQL::THolderFactory* holderFactory);
 
-    ~TKqpProtoBuilder();
-
+    ~TKqpProtoBuilder(); 
+ 
     static NKikimrMiniKQL::TType ApplyColumnHints(const NKikimrMiniKQL::TType& srcRowType,
         const TVector<TString>& columnHints);
 
     void BuildValue(const TVector<NYql::NDqProto::TData>& data, const NKikimrMiniKQL::TType& type,
         NKikimrMiniKQL::TResult* result);
-
+ 
     void BuildValue(NMiniKQL::TUnboxedValueVector& rows, const NKikimrMiniKQL::TType& type,
         NKikimrMiniKQL::TResult* result);
-
+ 
     void BuildStream(const TVector<NYql::NDqProto::TData>& data, const NKikimrMiniKQL::TType& srcRowType,
         const NKikimrMiniKQL::TType* dstRowType, NKikimrMiniKQL::TResult* result);
 
@@ -36,8 +36,8 @@ public:
 
     Ydb::ResultSet BuildYdbResultSet(const TVector<NYql::NDqProto::TData>& data,
         const NKikimrMiniKQL::TType& srcRowType, const NKikimrMiniKQL::TType* dstRowType = nullptr);
-
-private:
+ 
+private: 
     NMiniKQL::TScopedAlloc* Alloc = nullptr;
     NMiniKQL::TTypeEnvironment* TypeEnv = nullptr;
     NMiniKQL::THolderFactory* HolderFactory = nullptr;
@@ -51,7 +51,7 @@ private:
         explicit TSelfHosted(const NMiniKQL::IFunctionRegistry& funcRegistry);
     };
     THolder<TSelfHosted> SelfHosted;
-};
-
+}; 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/runtime/ya.make b/ydb/core/kqp/runtime/ya.make
index 1143b6bc89..a3a3782e29 100644
--- a/ydb/core/kqp/runtime/ya.make
+++ b/ydb/core/kqp/runtime/ya.make
@@ -1,31 +1,31 @@
-LIBRARY()
-
-OWNER(
-    spuchin
-    g:kikimr
-)
-
-SRCS(
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
+    g:kikimr 
+) 
+ 
+SRCS( 
     kqp_channel_storage.cpp
-    kqp_compute.cpp
-    kqp_compute.h
-    kqp_effects.cpp
-    kqp_output_stream.cpp
-    kqp_program_builder.cpp
-    kqp_program_builder.h
+    kqp_compute.cpp 
+    kqp_compute.h 
+    kqp_effects.cpp 
+    kqp_output_stream.cpp 
+    kqp_program_builder.cpp 
+    kqp_program_builder.h 
     kqp_read_table.cpp
     kqp_read_table.h
-    kqp_runtime_impl.h
+    kqp_runtime_impl.h 
     kqp_scan_data.cpp
     kqp_scan_data.h
     kqp_spilling_file.cpp
-    kqp_tasks_runner.cpp
-    kqp_tasks_runner.h
-    kqp_transport.h
-    kqp_transport.cpp
-)
-
-PEERDIR(
+    kqp_tasks_runner.cpp 
+    kqp_tasks_runner.h 
+    kqp_transport.h 
+    kqp_transport.cpp 
+) 
+ 
+PEERDIR( 
     contrib/libs/apache/arrow
     ydb/core/actorlib_impl
     ydb/core/base
@@ -42,13 +42,13 @@ PEERDIR(
     ydb/library/yql/utils
     ydb/library/yql/dq/actors/protos
     ydb/library/yql/dq/runtime
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
 GENERATE_ENUM_SERIALIZATION(kqp_spilling.h)
 
-END()
+END() 
 
 RECURSE_FOR_TESTS(
     ut
diff --git a/ydb/core/kqp/ut/common/kqp_ut_common.cpp b/ydb/core/kqp/ut/common/kqp_ut_common.cpp
index 9bc7889f92..747224d2cb 100644
--- a/ydb/core/kqp/ut/common/kqp_ut_common.cpp
+++ b/ydb/core/kqp/ut/common/kqp_ut_common.cpp
@@ -1,5 +1,5 @@
-#include "kqp_ut_common.h"
-
+#include "kqp_ut_common.h" 
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_results.h>
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
 
@@ -9,12 +9,12 @@
 #include <ydb/library/yql/public/udf/udf_value_builder.h>
 #include <ydb/library/yql/minikql/invoke_builtins/mkql_builtins.h>
 #include <ydb/library/yql/utils/yql_panic.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb::NTable;
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb::NTable; 
+ 
 SIMPLE_UDF(TTestFilter, bool(i64)) {
     Y_UNUSED(valueBuilder);
     const i64 arg = args[0].Get<i64>();
@@ -34,22 +34,22 @@ SIMPLE_UDF(TTestFilterTerminate, bool(i64, i64)) {
     return NUdf::TUnboxedValuePod(true);
 }
 
-SIMPLE_UDF(TRandString, char*(ui32)) {
-    Y_UNUSED(valueBuilder);
-    const ui32 size = args[0].Get<ui32>();
-
-    auto str = valueBuilder->NewStringNotFilled(size);
-    auto strRef = str.AsStringRef();
-
-    for (ui32 i = 0; i < size; ++i) {
-        *(strRef.Data() + i) = '0' + RandomNumber<ui32>() % 10;
-    }
-
-    return str;
-}
-
-SIMPLE_MODULE(TTestUdfsModule, TTestFilter, TTestFilterTerminate, TRandString);
-
+SIMPLE_UDF(TRandString, char*(ui32)) { 
+    Y_UNUSED(valueBuilder); 
+    const ui32 size = args[0].Get<ui32>(); 
+
+    auto str = valueBuilder->NewStringNotFilled(size); 
+    auto strRef = str.AsStringRef(); 
+
+    for (ui32 i = 0; i < size; ++i) { 
+        *(strRef.Data() + i) = '0' + RandomNumber<ui32>() % 10; 
+    } 
+ 
+    return str; 
+} 
+ 
+SIMPLE_MODULE(TTestUdfsModule, TTestFilter, TTestFilterTerminate, TRandString); 
+ 
 NMiniKQL::IFunctionRegistry* UdfFrFactory(const NScheme::TTypeRegistry& typeRegistry) {
     Y_UNUSED(typeRegistry);
     auto funcRegistry = NMiniKQL::CreateFunctionRegistry(NMiniKQL::CreateBuiltinRegistry())->Clone();
@@ -64,15 +64,15 @@ TVector<NKikimrKqp::TKqpSetting> SyntaxV1Settings() {
     return {setting};
 }
 
-TKikimrRunner::TKikimrRunner(const TKikimrSettings& settings) {
-    // EnableKikimrBacktraceFormat(); // Very slow, enable only when required locally
+TKikimrRunner::TKikimrRunner(const TKikimrSettings& settings) { 
+    // EnableKikimrBacktraceFormat(); // Very slow, enable only when required locally 
 
     auto mbusPort = PortManager.GetPort();
     auto grpcPort = PortManager.GetPort();
-
+ 
     Cerr << "Trying to start KiKiMR, gRPC: " << grpcPort << ", MsgBus: " << mbusPort << Endl;
 
-    TVector<NKikimrKqp::TKqpSetting> effectiveKqpSettings;
+    TVector<NKikimrKqp::TKqpSetting> effectiveKqpSettings; 
     {
         // Allow NewEngine in tests
         NKikimrKqp::TKqpSetting setting;
@@ -81,13 +81,13 @@ TKikimrRunner::TKikimrRunner(const TKikimrSettings& settings) {
         effectiveKqpSettings.push_back(setting);
 
         // Force NewEngine in tests
-        // setting.SetName("_KqpForceNewEngine");
-        // setting.SetValue("true");
-        // effectiveKqpSettings.push_back(setting);
+        // setting.SetName("_KqpForceNewEngine"); 
+        // setting.SetValue("true"); 
+        // effectiveKqpSettings.push_back(setting); 
     }
-
+ 
     bool enableSpilling = false;
-    if (settings.AppConfig.GetTableServiceConfig().GetSpillingServiceConfig().GetLocalFileConfig().GetEnable()) {
+    if (settings.AppConfig.GetTableServiceConfig().GetSpillingServiceConfig().GetLocalFileConfig().GetEnable()) { 
         NKikimrKqp::TKqpSetting setting;
         setting.SetName("_KqpEnableSpilling");
         setting.SetValue("true");
@@ -95,106 +95,106 @@ TKikimrRunner::TKikimrRunner(const TKikimrSettings& settings) {
         enableSpilling = true;
     }
 
-    effectiveKqpSettings.insert(effectiveKqpSettings.end(), settings.KqpSettings.begin(), settings.KqpSettings.end());
-
-    ServerSettings.Reset(MakeHolder<Tests::TServerSettings>(mbusPort));
-    ServerSettings->SetDomainName(settings.DomainRoot);
-    ServerSettings->SetKqpSettings(effectiveKqpSettings);
-    ServerSettings->SetAppConfig(settings.AppConfig);
+    effectiveKqpSettings.insert(effectiveKqpSettings.end(), settings.KqpSettings.begin(), settings.KqpSettings.end()); 
+ 
+    ServerSettings.Reset(MakeHolder<Tests::TServerSettings>(mbusPort)); 
+    ServerSettings->SetDomainName(settings.DomainRoot); 
+    ServerSettings->SetKqpSettings(effectiveKqpSettings); 
+    ServerSettings->SetAppConfig(settings.AppConfig); 
     ServerSettings->SetFeatureFlags(settings.FeatureFlags);
-    ServerSettings->SetNodeCount(settings.NodeCount);
-    ServerSettings->SetEnableKqpSpilling(enableSpilling);
+    ServerSettings->SetNodeCount(settings.NodeCount); 
+    ServerSettings->SetEnableKqpSpilling(enableSpilling); 
     ServerSettings->SetEnableDataColumnForIndexTable(true);
     ServerSettings->SetKeepSnapshotTimeout(settings.KeepSnapshotTimeout);
-    ServerSettings->SetFrFactory(&UdfFrFactory);
+    ServerSettings->SetFrFactory(&UdfFrFactory); 
     ServerSettings->SetEnableSchemeTransactionsAtSchemeShard(true);
     ServerSettings->SetEnableNotNullColumns(true);
     if (settings.LogStream)
         ServerSettings->SetLogBackend(new TStreamLogBackend(settings.LogStream));
-
-    Server.Reset(MakeHolder<Tests::TServer>(*ServerSettings));
-    Server->EnableGRpc(grpcPort);
+ 
+    Server.Reset(MakeHolder<Tests::TServer>(*ServerSettings)); 
+    Server->EnableGRpc(grpcPort); 
     Server->SetupDefaultProfiles();
-
-    Client.Reset(MakeHolder<Tests::TClient>(*ServerSettings));
-
-    Endpoint = "localhost:" + ToString(grpcPort);
-
-    DriverConfig = NYdb::TDriverConfig()
-        .SetEndpoint(Endpoint)
+ 
+    Client.Reset(MakeHolder<Tests::TClient>(*ServerSettings)); 
+ 
+    Endpoint = "localhost:" + ToString(grpcPort); 
+ 
+    DriverConfig = NYdb::TDriverConfig() 
+        .SetEndpoint(Endpoint) 
         .SetDatabase("/" + settings.DomainRoot)
         .SetDiscoveryMode(NYdb::EDiscoveryMode::Async)
-        .SetAuthToken(settings.AuthToken);
-    Driver.Reset(MakeHolder<NYdb::TDriver>(DriverConfig));
-
-    Initialize(settings);
-}
-
-TKikimrRunner::TKikimrRunner(const TVector<NKikimrKqp::TKqpSetting>& kqpSettings, const TString& authToken,
+        .SetAuthToken(settings.AuthToken); 
+    Driver.Reset(MakeHolder<NYdb::TDriver>(DriverConfig)); 
+ 
+    Initialize(settings); 
+} 
+ 
+TKikimrRunner::TKikimrRunner(const TVector<NKikimrKqp::TKqpSetting>& kqpSettings, const TString& authToken, 
     const TString& domainRoot, ui32 nodeCount)
-    : TKikimrRunner(TKikimrSettings()
-        .SetKqpSettings(kqpSettings)
-        .SetAuthToken(authToken)
-        .SetDomainRoot(domainRoot)
-        .SetNodeCount(nodeCount)) {}
-
+    : TKikimrRunner(TKikimrSettings() 
+        .SetKqpSettings(kqpSettings) 
+        .SetAuthToken(authToken) 
+        .SetDomainRoot(domainRoot) 
+        .SetNodeCount(nodeCount)) {} 
+ 
 TKikimrRunner::TKikimrRunner(const NKikimrConfig::TAppConfig& appConfig, const TString& authToken,
     const TString& domainRoot, ui32 nodeCount)
-    : TKikimrRunner(TKikimrSettings()
-        .SetAppConfig(appConfig)
-        .SetAuthToken(authToken)
-        .SetDomainRoot(domainRoot)
-        .SetNodeCount(nodeCount)) {}
-
-TKikimrRunner::TKikimrRunner(const NKikimrConfig::TAppConfig& appConfig,
-    const TVector<NKikimrKqp::TKqpSetting>& kqpSettings, const TString& authToken, const TString& domainRoot,
-    ui32 nodeCount)
-    : TKikimrRunner(TKikimrSettings()
-        .SetAppConfig(appConfig)
-        .SetKqpSettings(kqpSettings)
-        .SetAuthToken(authToken)
-        .SetDomainRoot(domainRoot)
-        .SetNodeCount(nodeCount)) {}
-
-TKikimrRunner::TKikimrRunner(const NKikimrConfig::TFeatureFlags& featureFlags, const TString& authToken,
-    const TString& domainRoot, ui32 nodeCount)
-    : TKikimrRunner(TKikimrSettings()
-        .SetFeatureFlags(featureFlags)
+    : TKikimrRunner(TKikimrSettings() 
+        .SetAppConfig(appConfig) 
+        .SetAuthToken(authToken) 
+        .SetDomainRoot(domainRoot) 
+        .SetNodeCount(nodeCount)) {} 
+ 
+TKikimrRunner::TKikimrRunner(const NKikimrConfig::TAppConfig& appConfig, 
+    const TVector<NKikimrKqp::TKqpSetting>& kqpSettings, const TString& authToken, const TString& domainRoot, 
+    ui32 nodeCount) 
+    : TKikimrRunner(TKikimrSettings() 
+        .SetAppConfig(appConfig) 
+        .SetKqpSettings(kqpSettings) 
+        .SetAuthToken(authToken) 
+        .SetDomainRoot(domainRoot) 
+        .SetNodeCount(nodeCount)) {} 
+ 
+TKikimrRunner::TKikimrRunner(const NKikimrConfig::TFeatureFlags& featureFlags, const TString& authToken, 
+    const TString& domainRoot, ui32 nodeCount) 
+    : TKikimrRunner(TKikimrSettings() 
+        .SetFeatureFlags(featureFlags) 
+        .SetAuthToken(authToken) 
+        .SetDomainRoot(domainRoot) 
+        .SetNodeCount(nodeCount)) {} 
+ 
+TKikimrRunner::TKikimrRunner(const TString& authToken, const TString& domainRoot, ui32 nodeCount) 
+    : TKikimrRunner(TKikimrSettings() 
         .SetAuthToken(authToken)
         .SetDomainRoot(domainRoot)
         .SetNodeCount(nodeCount)) {}
-
-TKikimrRunner::TKikimrRunner(const TString& authToken, const TString& domainRoot, ui32 nodeCount)
-    : TKikimrRunner(TKikimrSettings()
-        .SetAuthToken(authToken)
-        .SetDomainRoot(domainRoot)
-        .SetNodeCount(nodeCount)) {}
-
+ 
 void TKikimrRunner::CreateSampleTables() {
     Client->CreateTable("/Root", R"(
-        Name: "TwoShard"
-        Columns { Name: "Key", Type: "Uint32" }
-        Columns { Name: "Value1", Type: "String" }
-        Columns { Name: "Value2", Type: "Int32" }
-        KeyColumnNames: ["Key"]
-        UniformPartitionsCount: 2
+        Name: "TwoShard" 
+        Columns { Name: "Key", Type: "Uint32" } 
+        Columns { Name: "Value1", Type: "String" } 
+        Columns { Name: "Value2", Type: "Int32" } 
+        KeyColumnNames: ["Key"] 
+        UniformPartitionsCount: 2 
     )");
-
+ 
     Client->CreateTable("/Root", R"(
-        Name: "EightShard"
-        Columns { Name: "Key", Type: "Uint64" }
-        Columns { Name: "Text", Type: "String" }
-        Columns { Name: "Data", Type: "Int32" }
-        KeyColumnNames: ["Key"],
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 200 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 300 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 400 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 500 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 600 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 700 } } } }
+        Name: "EightShard" 
+        Columns { Name: "Key", Type: "Uint64" } 
+        Columns { Name: "Text", Type: "String" } 
+        Columns { Name: "Data", Type: "Int32" } 
+        KeyColumnNames: ["Key"], 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 100 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 200 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 300 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 400 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 500 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 600 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 700 } } } } 
     )");
-
+ 
     Client->CreateTable("/Root", R"(
         Name: "Logs"
         Columns { Name: "App", Type: "Utf8" }
@@ -207,49 +207,49 @@ void TKikimrRunner::CreateSampleTables() {
     )");
 
     Client->CreateTable("/Root", R"(
-        Name: "BatchUpload"
-        Columns {
-            Name: "Key1"
-            Type: "Uint32"
-        }
-        Columns {
-            Name: "Key2"
-            Type: "String"
-        }
-        Columns {
-            Name: "Value1"
-            Type: "Int64"
-        }
-        Columns {
-            Name: "Value2"
-            Type: "Double"
-        }
-        Columns {
-            Name: "Blob1"
-            Type: "String"
-        }
-        Columns {
-            Name: "Blob2"
-            Type: "String"
-        }
-        KeyColumnNames: ["Key1", "Key2"]
-        UniformPartitionsCount: 10
+        Name: "BatchUpload" 
+        Columns { 
+            Name: "Key1" 
+            Type: "Uint32" 
+        } 
+        Columns { 
+            Name: "Key2" 
+            Type: "String" 
+        } 
+        Columns { 
+            Name: "Value1" 
+            Type: "Int64" 
+        } 
+        Columns { 
+            Name: "Value2" 
+            Type: "Double" 
+        } 
+        Columns { 
+            Name: "Blob1" 
+            Type: "String" 
+        } 
+        Columns { 
+            Name: "Blob2" 
+            Type: "String" 
+        } 
+        KeyColumnNames: ["Key1", "Key2"] 
+        UniformPartitionsCount: 10 
     )");
-
-    // TODO: Reuse driver (YDB-626)
+ 
+    // TODO: Reuse driver (YDB-626) 
     NYdb::TDriver driver(NYdb::TDriverConfig().SetEndpoint(Endpoint).SetDatabase("/Root"));
-    NYdb::NTable::TTableClient client(driver);
-    auto session = client.CreateSession().GetValueSync().GetSession();
-
-    AssertSuccessResult(session.ExecuteSchemeQuery(R"(
-        --!syntax_v1
-
+    NYdb::NTable::TTableClient client(driver); 
+    auto session = client.CreateSession().GetValueSync().GetSession(); 
+ 
+    AssertSuccessResult(session.ExecuteSchemeQuery(R"( 
+        --!syntax_v1 
+ 
         CREATE TABLE `KeyValue` (
-            Key Uint64,
-            Value String,
-            PRIMARY KEY (Key)
-        );
-
+            Key Uint64, 
+            Value String, 
+            PRIMARY KEY (Key) 
+        ); 
+ 
         CREATE TABLE `KeyValue2` (
             Key String,
             Value String,
@@ -258,95 +258,95 @@ void TKikimrRunner::CreateSampleTables() {
 
 
         CREATE TABLE `Test` (
-            Group Uint32,
-            Name String,
-            Amount Uint64,
-            Comment String,
-            PRIMARY KEY (Group, Name)
-        );
-
+            Group Uint32, 
+            Name String, 
+            Amount Uint64, 
+            Comment String, 
+            PRIMARY KEY (Group, Name) 
+        ); 
+ 
         CREATE TABLE `Join1` (
-            Key Int32,
-            Fk21 Uint32,
-            Fk22 String,
-            Value String,
-            PRIMARY KEY (Key)
-        )
-        WITH (
-            PARTITION_AT_KEYS = (5)
-        );
-
+            Key Int32, 
+            Fk21 Uint32, 
+            Fk22 String, 
+            Value String, 
+            PRIMARY KEY (Key) 
+        ) 
+        WITH ( 
+            PARTITION_AT_KEYS = (5) 
+        ); 
+ 
         CREATE TABLE `Join2` (
-            Key1 Uint32,
-            Key2 String,
-            Name String,
-            Value2 String,
-            PRIMARY KEY (Key1, Key2)
-        )
-        WITH (
-            PARTITION_AT_KEYS = (105)
-        );
-    )").GetValueSync());
-
-    AssertSuccessResult(session.ExecuteDataQuery(R"(
+            Key1 Uint32, 
+            Key2 String, 
+            Name String, 
+            Value2 String, 
+            PRIMARY KEY (Key1, Key2) 
+        ) 
+        WITH ( 
+            PARTITION_AT_KEYS = (105) 
+        ); 
+    )").GetValueSync()); 
+ 
+    AssertSuccessResult(session.ExecuteDataQuery(R"( 
         PRAGMA kikimr.UseNewEngine = "true";
 
         REPLACE INTO `TwoShard` (Key, Value1, Value2) VALUES
-            (1u, "One", -1),
-            (2u, "Two", 0),
-            (3u, "Three", 1),
-            (4000000001u, "BigOne", -1),
-            (4000000002u, "BigTwo", 0),
-            (4000000003u, "BigThree", 1);
-
+            (1u, "One", -1), 
+            (2u, "Two", 0), 
+            (3u, "Three", 1), 
+            (4000000001u, "BigOne", -1), 
+            (4000000002u, "BigTwo", 0), 
+            (4000000003u, "BigThree", 1); 
+ 
         REPLACE INTO `EightShard` (Key, Text, Data) VALUES
-            (101u, "Value1",  1),
-            (201u, "Value1",  2),
-            (301u, "Value1",  3),
-            (401u, "Value1",  1),
-            (501u, "Value1",  2),
-            (601u, "Value1",  3),
-            (701u, "Value1",  1),
-            (801u, "Value1",  2),
-            (102u, "Value2",  3),
-            (202u, "Value2",  1),
-            (302u, "Value2",  2),
-            (402u, "Value2",  3),
-            (502u, "Value2",  1),
-            (602u, "Value2",  2),
-            (702u, "Value2",  3),
-            (802u, "Value2",  1),
-            (103u, "Value3",  2),
-            (203u, "Value3",  3),
-            (303u, "Value3",  1),
-            (403u, "Value3",  2),
-            (503u, "Value3",  3),
-            (603u, "Value3",  1),
-            (703u, "Value3",  2),
-            (803u, "Value3",  3);
-
+            (101u, "Value1",  1), 
+            (201u, "Value1",  2), 
+            (301u, "Value1",  3), 
+            (401u, "Value1",  1), 
+            (501u, "Value1",  2), 
+            (601u, "Value1",  3), 
+            (701u, "Value1",  1), 
+            (801u, "Value1",  2), 
+            (102u, "Value2",  3), 
+            (202u, "Value2",  1), 
+            (302u, "Value2",  2), 
+            (402u, "Value2",  3), 
+            (502u, "Value2",  1), 
+            (602u, "Value2",  2), 
+            (702u, "Value2",  3), 
+            (802u, "Value2",  1), 
+            (103u, "Value3",  2), 
+            (203u, "Value3",  3), 
+            (303u, "Value3",  1), 
+            (403u, "Value3",  2), 
+            (503u, "Value3",  3), 
+            (603u, "Value3",  1), 
+            (703u, "Value3",  2), 
+            (803u, "Value3",  3); 
+ 
         REPLACE INTO `KeyValue` (Key, Value) VALUES
-            (1u, "One"),
-            (2u, "Two");
-
+            (1u, "One"), 
+            (2u, "Two"); 
+ 
         REPLACE INTO `KeyValue2` (Key, Value) VALUES
             ("1", "One"),
             ("2", "Two");
 
         REPLACE INTO `Test` (Group, Name, Amount, Comment) VALUES
-            (1u, "Anna", 3500ul, "None"),
-            (1u, "Paul", 300ul, "None"),
-            (2u, "Tony", 7200ul, "None");
+            (1u, "Anna", 3500ul, "None"), 
+            (1u, "Paul", 300ul, "None"), 
+            (2u, "Tony", 7200ul, "None"); 
 
         REPLACE INTO `Logs` (App, Ts, Host, Message) VALUES
             ("apache", 0, "front-42", " GET /index.html HTTP/1.1"),
             ("nginx", 1, "nginx-10", "GET /index.html HTTP/1.1"),
             ("nginx", 2, "nginx-23", "PUT /form HTTP/1.1"),
             ("nginx", 3, "nginx-23", "GET /cat.jpg HTTP/1.1"),
-            ("kikimr-db", 1, "kikimr-db-10", "Write Data"),
-            ("kikimr-db", 2, "kikimr-db-21", "Read Data"),
-            ("kikimr-db", 3, "kikimr-db-21", "Stream Read Data"),
-            ("kikimr-db", 4, "kikimr-db-53", "Discover"),
+            ("kikimr-db", 1, "kikimr-db-10", "Write Data"), 
+            ("kikimr-db", 2, "kikimr-db-21", "Read Data"), 
+            ("kikimr-db", 3, "kikimr-db-21", "Stream Read Data"), 
+            ("kikimr-db", 4, "kikimr-db-53", "Discover"), 
             ("ydb", 0, "ydb-1000", "some very very very very long string");
 
         REPLACE INTO `Join1` (Key, Fk21, Fk22, Value) VALUES
@@ -357,8 +357,8 @@ void TKikimrRunner::CreateSampleTables() {
             (5, 105, "One", "Value3"),
             (6, 106, "Two", "Value3"),
             (7, 107, "One", "Value4"),
-            (8, 108, "One", "Value5"),
-            (9, 101, "Two", "Value1");
+            (8, 108, "One", "Value5"), 
+            (9, 101, "Two", "Value1"); 
 
         REPLACE INTO `Join2` (Key1, Key2, Name, Value2) VALUES
             (101, "One",   "Name1", "Value21"),
@@ -371,87 +371,87 @@ void TKikimrRunner::CreateSampleTables() {
             (105, "Two",   "Name4", "Value28"),
             (106, "One",   "Name3", "Value29"),
             (108, "One",    NULL,   "Value31");
-    )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync());
-
-}
-
-void TKikimrRunner::Initialize(const TKikimrSettings& settings) {
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::FLAT_TX_SCHEMESHARD, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_YQL, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_YQL, NActors::NLog::PRI_INFO);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::TX_DATASHARD, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::TX_COORDINATOR, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_COMPUTE, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_TASKS_RUNNER, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::TX_PROXY_SCHEME_CACHE, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::SCHEME_BOARD_REPLICA, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_WORKER, NActors::NLog::PRI_DEBUG);
+    )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync()); 
+
+} 
+ 
+void TKikimrRunner::Initialize(const TKikimrSettings& settings) { 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::FLAT_TX_SCHEMESHARD, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_YQL, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_YQL, NActors::NLog::PRI_INFO); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::TX_DATASHARD, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::TX_COORDINATOR, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_COMPUTE, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_TASKS_RUNNER, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::TX_PROXY_SCHEME_CACHE, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::SCHEME_BOARD_REPLICA, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_WORKER, NActors::NLog::PRI_DEBUG); 
     // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_SESSION, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::TABLET_EXECUTOR, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_SLOW_LOG, NActors::NLog::PRI_TRACE);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_PROXY, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_COMPILE_SERVICE, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_COMPILE_ACTOR, NActors::NLog::PRI_DEBUG);
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::TABLET_EXECUTOR, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_SLOW_LOG, NActors::NLog::PRI_TRACE); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_PROXY, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_COMPILE_SERVICE, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_COMPILE_ACTOR, NActors::NLog::PRI_DEBUG); 
     // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_COMPILE_REQUEST, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_GATEWAY, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::RPC_REQUEST, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_RESOURCE_MANAGER, NActors::NLog::PRI_DEBUG);
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_GATEWAY, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::RPC_REQUEST, NActors::NLog::PRI_DEBUG); 
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_RESOURCE_MANAGER, NActors::NLog::PRI_DEBUG); 
     // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_NODE, NActors::NLog::PRI_DEBUG);
-    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_BLOBS_STORAGE, NActors::NLog::PRI_DEBUG);
-
-    Client->InitRootScheme(settings.DomainRoot);
-
+    // Server->GetRuntime()->SetLogPriority(NKikimrServices::KQP_BLOBS_STORAGE, NActors::NLog::PRI_DEBUG); 
+ 
+    Client->InitRootScheme(settings.DomainRoot); 
+ 
     NKikimr::NKqp::WaitForKqpProxyInit(GetDriver());
 
-    if (settings.WithSampleTables) {
+    if (settings.WithSampleTables) { 
         CreateSampleTables();
-    }
-}
-
-TString ReformatYson(const TString& yson) {
-    TStringStream ysonInput(yson);
-    TStringStream output;
+    } 
+} 
+ 
+TString ReformatYson(const TString& yson) { 
+    TStringStream ysonInput(yson); 
+    TStringStream output; 
     NYson::ReformatYsonStream(&ysonInput, &output, NYson::EYsonFormat::Text);
-    return output.Str();
-}
-
-void CompareYson(const TString& expected, const TString& actual) {
-    UNIT_ASSERT_NO_DIFF(ReformatYson(expected), ReformatYson(actual));
-}
-
-void CompareYson(const TString& expected, const NKikimrMiniKQL::TResult& actual) {
-    TStringStream ysonStream;
+    return output.Str(); 
+} 
+ 
+void CompareYson(const TString& expected, const TString& actual) { 
+    UNIT_ASSERT_NO_DIFF(ReformatYson(expected), ReformatYson(actual)); 
+} 
+ 
+void CompareYson(const TString& expected, const NKikimrMiniKQL::TResult& actual) { 
+    TStringStream ysonStream; 
     NYson::TYsonWriter writer(&ysonStream, NYson::EYsonFormat::Text);
-    NYql::IDataProvider::TFillSettings fillSettings;
-    bool truncated;
-    KikimrResultToYson(ysonStream, writer, actual, {}, fillSettings, truncated);
-    UNIT_ASSERT(!truncated);
-
-    CompareYson(expected, ysonStream.Str());
-}
-
-bool HasIssue(const NYql::TIssues& issues, ui32 code,
-    std::function<bool(const NYql::TIssue& issue)> predicate)
-{
-    bool hasIssue = false;
-
-    for (auto& issue : issues) {
-        WalkThroughIssues(issue, false, [code, predicate, &hasIssue] (const NYql::TIssue& issue, int level) {
-            Y_UNUSED(level);
-            if (issue.GetCode() == code) {
-                bool issueMatch = predicate
-                    ? predicate(issue)
-                    : true;
-
-                hasIssue = hasIssue || issueMatch;
-            }
-        });
-    }
-
-    return hasIssue;
-}
-
+    NYql::IDataProvider::TFillSettings fillSettings; 
+    bool truncated; 
+    KikimrResultToYson(ysonStream, writer, actual, {}, fillSettings, truncated); 
+    UNIT_ASSERT(!truncated); 
+ 
+    CompareYson(expected, ysonStream.Str()); 
+} 
+ 
+bool HasIssue(const NYql::TIssues& issues, ui32 code, 
+    std::function<bool(const NYql::TIssue& issue)> predicate) 
+{ 
+    bool hasIssue = false; 
+ 
+    for (auto& issue : issues) { 
+        WalkThroughIssues(issue, false, [code, predicate, &hasIssue] (const NYql::TIssue& issue, int level) { 
+            Y_UNUSED(level); 
+            if (issue.GetCode() == code) { 
+                bool issueMatch = predicate 
+                    ? predicate(issue) 
+                    : true; 
+ 
+                hasIssue = hasIssue || issueMatch; 
+            } 
+        }); 
+    } 
+ 
+    return hasIssue; 
+} 
+ 
 void PrintQueryStats(const TDataQueryResult& result) {
     if (!result.GetStats().Defined()) {
         return;
@@ -473,36 +473,36 @@ void PrintQueryStats(const TDataQueryResult& result) {
     }
 }
 
-void AssertTableStats(const TDataQueryResult& result, TStringBuf table, const TExpectedTableStats& expectedStats) {
+void AssertTableStats(const TDataQueryResult& result, TStringBuf table, const TExpectedTableStats& expectedStats) { 
     auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
 
-    ui64 actualReads = 0;
-    ui64 actualUpdates = 0;
-    ui64 actualDeletes = 0;
+    ui64 actualReads = 0; 
+    ui64 actualUpdates = 0; 
+    ui64 actualDeletes = 0; 
 
     for (const auto& phase : stats.query_phases()) {
         for (const auto& access : phase.table_access()) {
             if (access.name() == table) {
-                actualReads += access.reads().rows();
-                actualUpdates += access.updates().rows();
-                actualDeletes += access.deletes().rows();
+                actualReads += access.reads().rows(); 
+                actualUpdates += access.updates().rows(); 
+                actualDeletes += access.deletes().rows(); 
             }
         }
     }
 
-    if (expectedStats.ExpectedReads) {
-        UNIT_ASSERT_EQUAL_C(*expectedStats.ExpectedReads, actualReads, "table: " << table
-            << ", reads expected " << *expectedStats.ExpectedReads << ", actual " << actualReads);
+    if (expectedStats.ExpectedReads) { 
+        UNIT_ASSERT_EQUAL_C(*expectedStats.ExpectedReads, actualReads, "table: " << table 
+            << ", reads expected " << *expectedStats.ExpectedReads << ", actual " << actualReads); 
     }
 
-    if (expectedStats.ExpectedUpdates) {
-        UNIT_ASSERT_EQUAL_C(*expectedStats.ExpectedUpdates, actualUpdates, "table: " << table
-            << ", updates expected " << *expectedStats.ExpectedUpdates << ", actual " << actualUpdates);
+    if (expectedStats.ExpectedUpdates) { 
+        UNIT_ASSERT_EQUAL_C(*expectedStats.ExpectedUpdates, actualUpdates, "table: " << table 
+            << ", updates expected " << *expectedStats.ExpectedUpdates << ", actual " << actualUpdates); 
     }
 
-    if (expectedStats.ExpectedDeletes) {
-        UNIT_ASSERT_EQUAL_C(*expectedStats.ExpectedDeletes, actualDeletes, "table: " << table
-            << ", deletes expected " << *expectedStats.ExpectedDeletes << ", actual " << actualDeletes);
+    if (expectedStats.ExpectedDeletes) { 
+        UNIT_ASSERT_EQUAL_C(*expectedStats.ExpectedDeletes, actualDeletes, "table: " << table 
+            << ", deletes expected " << *expectedStats.ExpectedDeletes << ", actual " << actualDeletes); 
     }
 }
 
@@ -525,30 +525,30 @@ TDataQueryResult ExecQueryAndTestResult(TSession& session, const TString& query,
 }
 
 void FillProfile(NYdb::NTable::TScanQueryPart& streamPart, NYson::TYsonWriter& writer, TVector<TString>* profiles,
-    ui32 profileIndex)
-{
-    Y_UNUSED(streamPart);
-    Y_UNUSED(writer);
-    Y_UNUSED(profiles);
-    Y_UNUSED(profileIndex);
-}
-
+    ui32 profileIndex) 
+{ 
+    Y_UNUSED(streamPart); 
+    Y_UNUSED(writer); 
+    Y_UNUSED(profiles); 
+    Y_UNUSED(profileIndex); 
+} 
+ 
 void FillProfile(NYdb::NExperimental::TStreamPart& streamPart, NYson::TYsonWriter& writer, TVector<TString>* profiles,
-    ui32 profileIndex)
-{
-    if (streamPart.HasProfile()) {
-        if (profiles) {
-            profiles->emplace_back(streamPart.ExtractProfile());
-        } else {
-            writer.OnListItem();
-            writer.OnBeginMap();
-            writer.OnKeyedItem(TStringBuilder() << "_profile_" << profileIndex);
-            writer.OnStringScalar(streamPart.ExtractProfile());
-            writer.OnEndMap();
-        }
-    }
-}
-
+    ui32 profileIndex) 
+{ 
+    if (streamPart.HasProfile()) { 
+        if (profiles) { 
+            profiles->emplace_back(streamPart.ExtractProfile()); 
+        } else { 
+            writer.OnListItem(); 
+            writer.OnBeginMap(); 
+            writer.OnKeyedItem(TStringBuilder() << "_profile_" << profileIndex); 
+            writer.OnStringScalar(streamPart.ExtractProfile()); 
+            writer.OnEndMap(); 
+        } 
+    } 
+} 
+ 
 void PrintResultSet(const NYdb::TResultSet& resultSet, NYson::TYsonWriter& writer) {
     auto columns = resultSet.GetColumnsMeta();
 
@@ -564,8 +564,8 @@ void PrintResultSet(const NYdb::TResultSet& resultSet, NYson::TYsonWriter& write
     }
 }
 
-template<typename TIterator>
-TString StreamResultToYsonImpl(TIterator& it, TVector<TString>* profiles) {
+template<typename TIterator> 
+TString StreamResultToYsonImpl(TIterator& it, TVector<TString>* profiles) { 
     TStringStream out;
     NYson::TYsonWriter writer(&out, NYson::EYsonFormat::Text, ::NYson::EYsonType::Node, true);
     writer.OnBeginList();
@@ -584,8 +584,8 @@ TString StreamResultToYsonImpl(TIterator& it, TVector<TString>* profiles) {
             PrintResultSet(resultSet, writer);
         }
 
-        FillProfile(streamPart, writer, profiles, profileIndex);
-        profileIndex++;
+        FillProfile(streamPart, writer, profiles, profileIndex); 
+        profileIndex++; 
     }
 
     writer.OnEndList();
@@ -593,14 +593,14 @@ TString StreamResultToYsonImpl(TIterator& it, TVector<TString>* profiles) {
     return out.Str();
 }
 
-TString StreamResultToYson(NYdb::NExperimental::TStreamPartIterator& it, TVector<TString>* profiles) {
-    return StreamResultToYsonImpl(it, profiles);
-}
-
-TString StreamResultToYson(NYdb::NTable::TScanQueryPartIterator& it) {
-    return StreamResultToYsonImpl(it, nullptr);
-}
-
+TString StreamResultToYson(NYdb::NExperimental::TStreamPartIterator& it, TVector<TString>* profiles) { 
+    return StreamResultToYsonImpl(it, profiles); 
+} 
+ 
+TString StreamResultToYson(NYdb::NTable::TScanQueryPartIterator& it) { 
+    return StreamResultToYsonImpl(it, nullptr); 
+} 
+ 
 TString StreamResultToYson(NYdb::NScripting::TYqlResultPartIterator& it) {
     TStringStream out;
     NYson::TYsonWriter writer(&out, NYson::EYsonFormat::Text, ::NYson::EYsonType::Node, true);
@@ -653,11 +653,11 @@ TCollectedStreamResult CollectStreamResultImpl(TIterator& it) {
             break;
         }
 
-        if constexpr (std::is_same_v<TIterator, NYdb::NTable::TScanQueryPartIterator>) {
-            UNIT_ASSERT_C(streamPart.HasResultSet() || streamPart.HasQueryStats(),
-                "Unexpected empty scan query response.");
-        }
-
+        if constexpr (std::is_same_v<TIterator, NYdb::NTable::TScanQueryPartIterator>) { 
+            UNIT_ASSERT_C(streamPart.HasResultSet() || streamPart.HasQueryStats(), 
+                "Unexpected empty scan query response."); 
+        } 
+ 
         if (streamPart.HasResultSet()) {
             auto resultSet = streamPart.ExtractResultSet();
             PrintResultSet(resultSet, resultSetWriter);
@@ -666,11 +666,11 @@ TCollectedStreamResult CollectStreamResultImpl(TIterator& it) {
         if constexpr (std::is_same_v<TIterator, NYdb::NTable::TScanQueryPartIterator>) {
             if (streamPart.HasQueryStats() ) {
                 res.QueryStats = NYdb::TProtoAccessor::GetProto(streamPart.GetQueryStats());
-
-                auto plan = res.QueryStats->query_plan();
-                if (!plan.empty()) {
-                    res.PlanJson = plan;
-                }
+ 
+                auto plan = res.QueryStats->query_plan(); 
+                if (!plan.empty()) { 
+                    res.PlanJson = plan; 
+                } 
             }
         } else {
             if (streamPart.HasPlan()) {
@@ -877,5 +877,5 @@ void WaitForKqpProxyInit(const NYdb::TDriver& driver) {
     }
 }
 
-} // namspace NKqp
-} // namespace NKikimr
+} // namspace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/common/kqp_ut_common.h b/ydb/core/kqp/ut/common/kqp_ut_common.h
index c1d64b65c3..c2d96d923c 100644
--- a/ydb/core/kqp/ut/common/kqp_ut_common.h
+++ b/ydb/core/kqp/ut/common/kqp_ut_common.h
@@ -1,22 +1,22 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/testlib/test_client.h>
-
+ 
 #include <ydb/public/lib/experimental/ydb_experimental.h>
 #include <ydb/public/lib/yson_value/ydb_yson_value.h>
 #include <ydb/public/sdk/cpp/client/ydb_scheme/scheme.h>
 #include <ydb/public/sdk/cpp/client/ydb_table/table.h>
 #include <ydb/public/sdk/cpp/client/draft/ydb_scripting.h>
-
+ 
 #include <library/cpp/yson/node/node_io.h>
-
+ 
 #include <ydb/library/yql/core/issue/yql_issue.h>
-
+ 
 #include <library/cpp/json/json_reader.h>
 #include <library/cpp/testing/unittest/tests_data.h>
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/yson/writer.h>
-
+ 
 #define Y_UNIT_TEST_TWIN(N, OPT)                                                                                   \
     template <bool OPT>                                                                                            \
     struct TTestCase##N : public TCurrentTestCase {                                                                \
@@ -65,54 +65,54 @@ TString Query(const TString& tmpl) {
 #define Q_(expr) Query<UseNewEngine, false>(expr)
 #define Q1_(expr) Query<UseNewEngine, true>(expr)
 
-namespace NKikimr {
-namespace NKqp {
-
-const TString KikimrDefaultUtDomainRoot = "Root";
-
+namespace NKikimr { 
+namespace NKqp { 
+ 
+const TString KikimrDefaultUtDomainRoot = "Root"; 
+ 
 TVector<NKikimrKqp::TKqpSetting> SyntaxV1Settings();
 
 struct TKikimrSettings: public TTestFeatureFlagsHolder<TKikimrSettings> {
-    NKikimrConfig::TAppConfig AppConfig;
-    TVector<NKikimrKqp::TKqpSetting> KqpSettings;
-    TString AuthToken;
-    TString DomainRoot = KikimrDefaultUtDomainRoot;
-    ui32 NodeCount = 1;
-    bool WithSampleTables = true;
+    NKikimrConfig::TAppConfig AppConfig; 
+    TVector<NKikimrKqp::TKqpSetting> KqpSettings; 
+    TString AuthToken; 
+    TString DomainRoot = KikimrDefaultUtDomainRoot; 
+    ui32 NodeCount = 1; 
+    bool WithSampleTables = true; 
     TDuration KeepSnapshotTimeout = TDuration::Zero();
     IOutputStream* LogStream = nullptr;
-
-    TKikimrSettings& SetAppConfig(const NKikimrConfig::TAppConfig& value) { AppConfig = value; return *this; }
-    TKikimrSettings& SetFeatureFlags(const NKikimrConfig::TFeatureFlags& value) { FeatureFlags = value; return *this; }
-    TKikimrSettings& SetKqpSettings(const TVector<NKikimrKqp::TKqpSetting>& value) { KqpSettings = value; return *this; }
-    TKikimrSettings& SetAuthToken(const TString& value) { AuthToken = value; return *this; }
-    TKikimrSettings& SetDomainRoot(const TString& value) { DomainRoot = value; return *this; }
-    TKikimrSettings& SetNodeCount(ui32 value) { NodeCount = value; return *this; }
-    TKikimrSettings& SetWithSampleTables(bool value) { WithSampleTables = value; return *this; }
+ 
+    TKikimrSettings& SetAppConfig(const NKikimrConfig::TAppConfig& value) { AppConfig = value; return *this; } 
+    TKikimrSettings& SetFeatureFlags(const NKikimrConfig::TFeatureFlags& value) { FeatureFlags = value; return *this; } 
+    TKikimrSettings& SetKqpSettings(const TVector<NKikimrKqp::TKqpSetting>& value) { KqpSettings = value; return *this; } 
+    TKikimrSettings& SetAuthToken(const TString& value) { AuthToken = value; return *this; } 
+    TKikimrSettings& SetDomainRoot(const TString& value) { DomainRoot = value; return *this; } 
+    TKikimrSettings& SetNodeCount(ui32 value) { NodeCount = value; return *this; } 
+    TKikimrSettings& SetWithSampleTables(bool value) { WithSampleTables = value; return *this; } 
     TKikimrSettings& SetKeepSnapshotTimeout(TDuration value) { KeepSnapshotTimeout = value; return *this; }
     TKikimrSettings& SetLogStream(IOutputStream* follower) { LogStream = follower; return *this; };
 
-};
-
-class TKikimrRunner {
-public:
-    TKikimrRunner(const TKikimrSettings& settings);
-
-    TKikimrRunner(const TVector<NKikimrKqp::TKqpSetting>& kqpSettings, const TString& authToken = "",
+}; 
+ 
+class TKikimrRunner { 
+public: 
+    TKikimrRunner(const TKikimrSettings& settings); 
+ 
+    TKikimrRunner(const TVector<NKikimrKqp::TKqpSetting>& kqpSettings, const TString& authToken = "", 
         const TString& domainRoot = KikimrDefaultUtDomainRoot, ui32 nodeCount = 1);
-
-    TKikimrRunner(const NKikimrConfig::TAppConfig& appConfig, const TString& authToken = "",
-        const TString& domainRoot = KikimrDefaultUtDomainRoot, ui32 nodeCount = 1);
-
-    TKikimrRunner(const NKikimrConfig::TAppConfig& appConfig, const TVector<NKikimrKqp::TKqpSetting>& kqpSettings,
-        const TString& authToken = "", const TString& domainRoot = KikimrDefaultUtDomainRoot, ui32 nodeCount = 1);
-
-    TKikimrRunner(const NKikimrConfig::TFeatureFlags& featureFlags, const TString& authToken = "",
+ 
+    TKikimrRunner(const NKikimrConfig::TAppConfig& appConfig, const TString& authToken = "", 
         const TString& domainRoot = KikimrDefaultUtDomainRoot, ui32 nodeCount = 1);
-
+ 
+    TKikimrRunner(const NKikimrConfig::TAppConfig& appConfig, const TVector<NKikimrKqp::TKqpSetting>& kqpSettings, 
+        const TString& authToken = "", const TString& domainRoot = KikimrDefaultUtDomainRoot, ui32 nodeCount = 1); 
+ 
+    TKikimrRunner(const NKikimrConfig::TFeatureFlags& featureFlags, const TString& authToken = "", 
+        const TString& domainRoot = KikimrDefaultUtDomainRoot, ui32 nodeCount = 1); 
+ 
     TKikimrRunner(const TString& authToken = "", const TString& domainRoot = KikimrDefaultUtDomainRoot,
-        ui32 nodeCount = 1);
-
+        ui32 nodeCount = 1); 
+ 
     ~TKikimrRunner() {
         Driver->Stop(true);
         Server.Reset();
@@ -120,41 +120,41 @@ public:
     }
 
     const TString& GetEndpoint() const { return Endpoint; }
-    const NYdb::TDriver& GetDriver() const { return *Driver; }
+    const NYdb::TDriver& GetDriver() const { return *Driver; } 
     NYdb::NScheme::TSchemeClient GetSchemeClient() const { return NYdb::NScheme::TSchemeClient(*Driver); }
-    Tests::TClient& GetTestClient() const { return *Client; }
-    Tests::TServer& GetTestServer() const { return *Server; }
-
-    NYdb::TDriverConfig GetDriverConfig() const { return DriverConfig; }
-
-    NYdb::NTable::TTableClient GetTableClient() const {
-        return NYdb::NTable::TTableClient(*Driver, NYdb::NTable::TClientSettings()
-            .UseQueryCache(false));
-    }
-
+    Tests::TClient& GetTestClient() const { return *Client; } 
+    Tests::TServer& GetTestServer() const { return *Server; } 
+ 
+    NYdb::TDriverConfig GetDriverConfig() const { return DriverConfig; } 
+ 
+    NYdb::NTable::TTableClient GetTableClient() const { 
+        return NYdb::NTable::TTableClient(*Driver, NYdb::NTable::TClientSettings() 
+            .UseQueryCache(false)); 
+    } 
+ 
     bool IsUsingSnapshotReads() const {
         return Server->GetRuntime()->GetAppData().FeatureFlags.GetEnableMvccSnapshotReads();
     }
 
-private:
-    void Initialize(const TKikimrSettings& settings);
+private: 
+    void Initialize(const TKikimrSettings& settings); 
     void WaitForKqpProxyInit();
     void CreateSampleTables();
-
-private:
-    THolder<Tests::TServerSettings> ServerSettings;
-    THolder<Tests::TServer> Server;
-    THolder<Tests::TClient> Client;
+ 
+private: 
+    THolder<Tests::TServerSettings> ServerSettings; 
+    THolder<Tests::TServer> Server; 
+    THolder<Tests::TClient> Client; 
     TPortManager PortManager;
-    TString Endpoint;
-    NYdb::TDriverConfig DriverConfig;
-    THolder<NYdb::TDriver> Driver;
-};
-
+    TString Endpoint; 
+    NYdb::TDriverConfig DriverConfig; 
+    THolder<NYdb::TDriver> Driver; 
+}; 
+ 
 struct TCollectedStreamResult {
     TString ResultSetYson;
-    TMaybe<TString> PlanJson;
-    TMaybe<Ydb::TableStats::QueryStats> QueryStats;
+    TMaybe<TString> PlanJson; 
+    TMaybe<Ydb::TableStats::QueryStats> QueryStats; 
 };
 
 TCollectedStreamResult CollectStreamResult(NYdb::NExperimental::TStreamPartIterator& it);
@@ -187,26 +187,26 @@ inline NYdb::NTable::EIndexType IndexTypeSqlToIndexType(EIndexTypeSql type) {
     }
 }
 
-TString ReformatYson(const TString& yson);
-void CompareYson(const TString& expected, const TString& actual);
-void CompareYson(const TString& expected, const NKikimrMiniKQL::TResult& actual);
-
-bool HasIssue(const NYql::TIssues& issues, ui32 code,
-    std::function<bool(const NYql::TIssue& issue)> predicate = {});
-
+TString ReformatYson(const TString& yson); 
+void CompareYson(const TString& expected, const TString& actual); 
+void CompareYson(const TString& expected, const NKikimrMiniKQL::TResult& actual); 
+ 
+bool HasIssue(const NYql::TIssues& issues, ui32 code, 
+    std::function<bool(const NYql::TIssue& issue)> predicate = {}); 
+ 
 void PrintQueryStats(const NYdb::NTable::TDataQueryResult& result);
 
-struct TExpectedTableStats {
-    TMaybe<ui64> ExpectedReads;
-    TMaybe<ui64> ExpectedUpdates;
-    TMaybe<ui64> ExpectedDeletes;
-};
-
-void AssertTableStats(const NYdb::NTable::TDataQueryResult& result, TStringBuf table,
-    const TExpectedTableStats& expectedStats);
-
-inline void AssertTableReads(const NYdb::NTable::TDataQueryResult& result, TStringBuf table, ui64 expectedReads) {
-    AssertTableStats(result, table, { .ExpectedReads = expectedReads });
+struct TExpectedTableStats { 
+    TMaybe<ui64> ExpectedReads; 
+    TMaybe<ui64> ExpectedUpdates; 
+    TMaybe<ui64> ExpectedDeletes; 
+}; 
+
+void AssertTableStats(const NYdb::NTable::TDataQueryResult& result, TStringBuf table, 
+    const TExpectedTableStats& expectedStats); 
+ 
+inline void AssertTableReads(const NYdb::NTable::TDataQueryResult& result, TStringBuf table, ui64 expectedReads) { 
+    AssertTableStats(result, table, { .ExpectedReads = expectedReads }); 
 }
 
 NYdb::NTable::TDataQueryResult ExecQueryAndTestResult(NYdb::NTable::TSession& session, const TString& query,
@@ -219,7 +219,7 @@ inline NYdb::NTable::TDataQueryResult ExecQueryAndTestResult(NYdb::NTable::TSess
 }
 
 TString StreamResultToYson(NYdb::NExperimental::TStreamPartIterator& it, TVector<TString>* profiles = nullptr);
-TString StreamResultToYson(NYdb::NTable::TScanQueryPartIterator& it);
+TString StreamResultToYson(NYdb::NTable::TScanQueryPartIterator& it); 
 TString StreamResultToYson(NYdb::NScripting::TYqlResultPartIterator& it);
 
 ui32 CountPlanNodesByKv(const NJson::TJsonValue& plan, const TString& key, const TString& value);
@@ -227,7 +227,7 @@ NJson::TJsonValue FindPlanNodeByKv(const NJson::TJsonValue& plan, const TString&
 
 TString ReadTablePartToYson(NYdb::NTable::TSession session, const TString& table);
 
-inline void AssertSuccessResult(const NYdb::TStatus& result) {
+inline void AssertSuccessResult(const NYdb::TStatus& result) { 
     UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
 }
 
@@ -239,4 +239,4 @@ void CreateSampleTablesWithIndex(NYdb::NTable::TSession& session);
 void WaitForKqpProxyInit(const NYdb::TDriver& driver);
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/common/ya.make b/ydb/core/kqp/ut/common/ya.make
index 0112bcd57c..9d602f47d3 100644
--- a/ydb/core/kqp/ut/common/ya.make
+++ b/ydb/core/kqp/ut/common/ya.make
@@ -1,16 +1,16 @@
-LIBRARY()
-
-OWNER(
-    spuchin
-    g:kikimr
-)
-
-SRCS(
-    kqp_ut_common.cpp
-    kqp_ut_common.h
-)
-
-PEERDIR(
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
+    g:kikimr 
+) 
+ 
+SRCS( 
+    kqp_ut_common.cpp 
+    kqp_ut_common.h 
+) 
+ 
+PEERDIR( 
     ydb/core/testlib
     ydb/library/yql/public/udf
     ydb/library/yql/utils/backtrace
@@ -19,8 +19,8 @@ PEERDIR(
     ydb/public/sdk/cpp/client/ydb_proto
     ydb/public/sdk/cpp/client/ydb_scheme
     ydb/public/sdk/cpp/client/ydb_table
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-END()
+END() 
diff --git a/ydb/core/kqp/ut/kqp_acl_ut.cpp b/ydb/core/kqp/ut/kqp_acl_ut.cpp
index 203c8ba618..ec3b7b3f03 100644
--- a/ydb/core/kqp/ut/kqp_acl_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_acl_ut.cpp
@@ -11,7 +11,7 @@ using namespace NYdb::NTable;
 
 Y_UNIT_TEST_SUITE(KqpNewEngineAcl) {
     Y_UNIT_TEST(FailNavigate) {
-        TKikimrRunner kikimr("user0@builtin");
+        TKikimrRunner kikimr("user0@builtin"); 
 
         auto db = kikimr.GetTableClient();
         auto session = db.CreateSession().GetValueSync().GetSession();
@@ -24,7 +24,7 @@ Y_UNIT_TEST_SUITE(KqpNewEngineAcl) {
     }
 
     Y_UNIT_TEST(FailResolve) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         {
             NYdb::NScheme::TPermissions permissions("user0@builtin",
                 {"ydb.deprecated.describe_schema"}
@@ -64,7 +64,7 @@ Y_UNIT_TEST_SUITE(KqpNewEngineAcl) {
     }
 
     Y_UNIT_TEST(ReadSuccess) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         {
             NYdb::NScheme::TPermissions permissions("user0@builtin",
                 {"ydb.deprecated.describe_schema", "ydb.deprecated.select_row"}
@@ -93,7 +93,7 @@ Y_UNIT_TEST_SUITE(KqpNewEngineAcl) {
     }
 
     Y_UNIT_TEST(WriteSuccess) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         {
             NYdb::NScheme::TPermissions permissions("user0@builtin",
                 {"ydb.deprecated.describe_schema", "ydb.deprecated.update_row"}
diff --git a/ydb/core/kqp/ut/kqp_document_api_ut.cpp b/ydb/core/kqp/ut/kqp_document_api_ut.cpp
index d51bb01516..a6c1d76f36 100644
--- a/ydb/core/kqp/ut/kqp_document_api_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_document_api_ut.cpp
@@ -1,49 +1,49 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/public/sdk/cpp/client/draft/ydb_scripting.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-static void CreateSampleTables(TSession session) {
-    auto tableDesc = TTableBuilder()
-        .AddNullableColumn("Key1", EPrimitiveType::String)
-        .AddNullableColumn("Key2", EPrimitiveType::String)
-        .AddNullableColumn("Value", EPrimitiveType::Json)
-        .SetPrimaryKeyColumns({"Key1", "Key2"})
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+static void CreateSampleTables(TSession session) { 
+    auto tableDesc = TTableBuilder() 
+        .AddNullableColumn("Key1", EPrimitiveType::String) 
+        .AddNullableColumn("Key2", EPrimitiveType::String) 
+        .AddNullableColumn("Value", EPrimitiveType::Json) 
+        .SetPrimaryKeyColumns({"Key1", "Key2"}) 
         .AddAttribute("__document_api_version", "1")
-        .Build();
-
-    auto schemeResult = session.CreateTable("/Root/DocumentApiTest", std::move(tableDesc)).ExtractValueSync();
-    UNIT_ASSERT_VALUES_EQUAL_C(schemeResult.GetStatus(), EStatus::SUCCESS, schemeResult.GetIssues().ToString());
-}
-
-Y_UNIT_TEST_SUITE(KqpDocumentApi) {
-    Y_UNIT_TEST(RestrictWrite) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        auto query = R"(
-            UPSERT INTO [/Root/DocumentApiTest] (Key1, Key2, Value) VALUES
-                ("Key1_1", "Key2_1", CAST("{Value: 10}" AS Json));
-        )";
-
-        auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(!result.IsSuccess());
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION));
-
-        auto settings = TExecDataQuerySettings().RequestType("_document_api_request");
-        result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), settings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-    }
-
+        .Build(); 
+ 
+    auto schemeResult = session.CreateTable("/Root/DocumentApiTest", std::move(tableDesc)).ExtractValueSync(); 
+    UNIT_ASSERT_VALUES_EQUAL_C(schemeResult.GetStatus(), EStatus::SUCCESS, schemeResult.GetIssues().ToString()); 
+} 
+ 
+Y_UNIT_TEST_SUITE(KqpDocumentApi) { 
+    Y_UNIT_TEST(RestrictWrite) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        auto query = R"( 
+            UPSERT INTO [/Root/DocumentApiTest] (Key1, Key2, Value) VALUES 
+                ("Key1_1", "Key2_1", CAST("{Value: 10}" AS Json)); 
+        )"; 
+ 
+        auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(!result.IsSuccess()); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION)); 
+ 
+        auto settings = TExecDataQuerySettings().RequestType("_document_api_request"); 
+        result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), settings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+    } 
+ 
     Y_UNIT_TEST(RestrictWriteExplicitPrepare) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -89,76 +89,76 @@ Y_UNIT_TEST_SUITE(KqpDocumentApi) {
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
     }
 
-    Y_UNIT_TEST(AllowRead) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        auto query = R"(
-            SELECT * FROM [/Root/DocumentApiTest];
-        )";
-
-        auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST(RestrictAlter) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        auto query = R"(
-            ALTER TABLE [/Root/DocumentApiTest] DROP COLUMN Value;
-        )";
-
-        auto result = session.ExecuteSchemeQuery(query).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(!result.IsSuccess());
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION));
-    }
-
-    Y_UNIT_TEST(RestrictDrop) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        auto query = R"(
-            DROP TABLE [/Root/DocumentApiTest];
-        )";
-
-        auto result = session.ExecuteSchemeQuery(query).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(!result.IsSuccess());
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION));
-    }
-
-    Y_UNIT_TEST(Scripting) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        NYdb::NScripting::TScriptingClient client(kikimr.GetDriver());
-
-        auto script = R"(
-            SELECT * FROM [/Root/DocumentApiTest];
-            COMMIT;
-            ALTER TABLE [/Root/DocumentApiTest] DROP COLUMN Value;
-        )";
-
-        auto result = client.ExecuteYqlScript(script).GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(!result.IsSuccess());
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION));
-    }
-}
-
-} // namspace NKqp
-} // namespace NKikimr
+    Y_UNIT_TEST(AllowRead) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        auto query = R"( 
+            SELECT * FROM [/Root/DocumentApiTest]; 
+        )"; 
+ 
+        auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+    } 
+ 
+    Y_UNIT_TEST(RestrictAlter) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        auto query = R"( 
+            ALTER TABLE [/Root/DocumentApiTest] DROP COLUMN Value; 
+        )"; 
+ 
+        auto result = session.ExecuteSchemeQuery(query).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(!result.IsSuccess()); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION)); 
+    } 
+ 
+    Y_UNIT_TEST(RestrictDrop) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        auto query = R"( 
+            DROP TABLE [/Root/DocumentApiTest]; 
+        )"; 
+ 
+        auto result = session.ExecuteSchemeQuery(query).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(!result.IsSuccess()); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION)); 
+    } 
+ 
+    Y_UNIT_TEST(Scripting) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        NYdb::NScripting::TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto script = R"( 
+            SELECT * FROM [/Root/DocumentApiTest]; 
+            COMMIT; 
+            ALTER TABLE [/Root/DocumentApiTest] DROP COLUMN Value; 
+        )"; 
+ 
+        auto result = client.ExecuteYqlScript(script).GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(!result.IsSuccess()); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION)); 
+    } 
+} 
+ 
+} // namspace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_effects_perf_ut.cpp b/ydb/core/kqp/ut/kqp_effects_perf_ut.cpp
index 1b2691d120..ee72e44d34 100644
--- a/ydb/core/kqp/ut/kqp_effects_perf_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_effects_perf_ut.cpp
@@ -1,475 +1,475 @@
-#include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
-#include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
-namespace NKikimr::NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-namespace {
-
-TParams BuildUpdateParams(TTableClient& client) {
-    return client.GetParamsBuilder()
-        .AddParam("$items")
-            .BeginList()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").Uint64(101)
-                    .AddMember("Text").String("New")
-                .EndStruct()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").Uint64(209)
-                    .AddMember("Text").String("New")
-                .EndStruct()
-            .EndList()
-        .Build()
-    .Build();
-}
-
-TParams BuildInsertParams(TTableClient& client) {
-    return client.GetParamsBuilder()
-        .AddParam("$items")
-            .BeginList()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").Uint64(109)
-                    .AddMember("Text").String("New")
-                .EndStruct()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").Uint64(209)
-                    .AddMember("Text").String("New")
-                .EndStruct()
-            .EndList()
-        .Build()
-    .Build();
-}
-
-TParams BuildDeleteParams(TTableClient& client) {
-    return client.GetParamsBuilder()
-        .AddParam("$items")
-            .BeginList()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").Uint64(101)
-                .EndStruct()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").Uint64(209)
-                .EndStruct()
-            .EndList()
-        .Build()
-    .Build();
-}
-
-TParams BuildUpdateIndexParams(TTableClient& client) {
-    return client.GetParamsBuilder()
-        .AddParam("$items")
-            .BeginList()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").String("Primary1")
-                    .AddMember("Index2").String("SecondaryNew1")
-                    .AddMember("Value").String("ValueNew1")
-                .EndStruct()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").String("Primary5")
-                    .AddMember("Index2").String("SecondaryNew2")
-                    .AddMember("Value").String("ValueNew2")
-                .EndStruct()
-            .EndList()
-        .Build()
-    .Build();
-}
-
-TParams BuildDeleteIndexParams(TTableClient& client) {
-    return client.GetParamsBuilder()
-        .AddParam("$items")
-            .BeginList()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").String("Primary1")
-                .EndStruct()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").String("Primary5")
-                .EndStruct()
-            .EndList()
-        .Build()
-    .Build();
-}
-
-TParams BuildInsertIndexParams(TTableClient& client) {
-    return client.GetParamsBuilder()
-        .AddParam("$items")
-            .BeginList()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Key").String("Primary10")
-                    .AddMember("Index2").String("SecondaryNew10")
-                    .AddMember("Value").String("ValueNew10")
-                .EndStruct()
-            .EndList()
-        .Build()
-    .Build();
-}
-
-} // namespace
-
-Y_UNIT_TEST_SUITE(KqpEffectsPerf) {
-    Y_UNIT_TEST_TWIN(Upsert, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = BuildUpdateParams(db);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':Uint64,'Text':String>>;
-
-            UPSERT INTO EightShard
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/EightShard", {
-            .ExpectedReads = 0,
-            .ExpectedUpdates = 2,
-        });
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        // TODO: Get rid of additional precompute stage for adding optionality to row members in NewEngine
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 2 : 1);
-
-        for (const auto& phase : stats.query_phases()) {
-            UNIT_ASSERT(phase.affected_shards() <= 2);
-        }
-    }
-
-    Y_UNIT_TEST_TWIN(Replace, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = BuildUpdateParams(db);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':Uint64,'Text':String>>;
-
-            REPLACE INTO EightShard
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/EightShard", {
-            .ExpectedReads = 0,
-            .ExpectedUpdates = 2,
-        });
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        // Single-phase REPLACE in NewEngine require additional runtime write callable
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 2 : 1);
-
-        for (const auto& phase : stats.query_phases()) {
-            UNIT_ASSERT(phase.affected_shards() <= 2);
-        }
-    }
-
-    Y_UNIT_TEST_TWIN(UpdateOn, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = BuildUpdateParams(db);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':Uint64,'Text':String>>;
-
-            UPDATE EightShard ON
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/EightShard", {
-            .ExpectedReads = 1, // Non-existing keys don't count in reads
-            .ExpectedUpdates = 1,
-        });
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        // Two-phase UPDATE ON in NewEngine require more complex runtime callables
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 3 : 2);
-
-        for (const auto& phase : stats.query_phases()) {
-            UNIT_ASSERT(phase.affected_shards() <= 2);
-        }
-    }
-
-    Y_UNIT_TEST_TWIN(Insert, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = BuildInsertParams(db);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':Uint64,'Text':String>>;
-
-            INSERT INTO EightShard
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/EightShard", {
-            .ExpectedReads = 0, // Non-existing keys don't count in reads
-            .ExpectedUpdates = 2,
-        });
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        // Three-phase INSERT in NewEngine require more complex runtime callables
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 3);
-
-        for (const auto& phase : stats.query_phases()) {
-            UNIT_ASSERT(phase.affected_shards() <= 2);
-        }
-    }
-
-    Y_UNIT_TEST_TWIN(DeleteOn, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = BuildDeleteParams(db);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':Uint64>>;
-
-            DELETE FROM EightShard ON
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/EightShard", {
-            .ExpectedReads = 0,
-            .ExpectedDeletes = 2,
-        });
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        // TODO: Get rid of additional precompute stage for adding optionality to row members in NewEngine
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 2 : 1);
-
-        for (const auto& phase : stats.query_phases()) {
-            UNIT_ASSERT(phase.affected_shards() <= 2);
-        }
-    }
-
-    Y_UNIT_TEST_TWIN(Update, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key").Uint64(201).Build()
-        .Build();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $key AS Uint64;
-
-            UPDATE EightShard
-            SET Data = Data + 1
-            WHERE Key = $key;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/EightShard", {
-            .ExpectedReads = 1,
-            .ExpectedUpdates = 1,
-        });
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2);
-
-        for (const auto& phase : stats.query_phases()) {
-            UNIT_ASSERT(phase.affected_shards() <= 1);
-        }
-    }
-
-    Y_UNIT_TEST_TWIN(Delete, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key").Uint64(201).Build()
-            .AddParam("$text").String("Value1").Build()
-        .Build();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $key AS Uint64;
-            DECLARE $text AS String;
-
-            DELETE FROM EightShard
-            WHERE Key = $key AND Text = $text;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/EightShard", {
-            .ExpectedReads = 1,
-            .ExpectedDeletes = 1,
-        });
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2);
-
-        for (const auto& phase : stats.query_phases()) {
-            UNIT_ASSERT(phase.affected_shards() <= 1);
-        }
-    }
-
-    Y_UNIT_TEST_TWIN(IndexUpsert, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        CreateSampleTablesWithIndex(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto params = BuildUpdateIndexParams(db);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':String,'Index2':String,'Value':String>>;
-
-            UPSERT INTO SecondaryWithDataColumns
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 3);
-    }
-
-    Y_UNIT_TEST_TWIN(IndexReplace, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        CreateSampleTablesWithIndex(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto params = BuildUpdateIndexParams(db);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':String,'Index2':String,'Value':String>>;
-
-            REPLACE INTO SecondaryWithDataColumns
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 3);
-    }
-
-    Y_UNIT_TEST_TWIN(IndexUpdateOn, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        CreateSampleTablesWithIndex(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto params = BuildUpdateIndexParams(db);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':String,'Index2':String,'Value':String>>;
-
-            UPDATE SecondaryWithDataColumns ON
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 2);
-    }
-
-    Y_UNIT_TEST_TWIN(IndexDeleteOn, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        CreateSampleTablesWithIndex(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto params = BuildDeleteIndexParams(db);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':String>>;
-
-            DELETE FROM SecondaryWithDataColumns ON
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 2);
-    }
-
-    Y_UNIT_TEST_TWIN(IndexInsert, UseNewEngine) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        CreateSampleTablesWithIndex(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto params = BuildInsertIndexParams(db);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':String,'Index2':String,'Value':String>>;
-
-            INSERT INTO SecondaryWithDataColumns
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 5 : 3);
-    }
-}
-
-} // namespace NKikimr::NKqp
+#include <ydb/core/kqp/ut/common/kqp_ut_common.h> 
+ 
+#include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h> 
+ 
+namespace NKikimr::NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+namespace { 
+ 
+TParams BuildUpdateParams(TTableClient& client) { 
+    return client.GetParamsBuilder() 
+        .AddParam("$items") 
+            .BeginList() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").Uint64(101) 
+                    .AddMember("Text").String("New") 
+                .EndStruct() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").Uint64(209) 
+                    .AddMember("Text").String("New") 
+                .EndStruct() 
+            .EndList() 
+        .Build() 
+    .Build(); 
+} 
+ 
+TParams BuildInsertParams(TTableClient& client) { 
+    return client.GetParamsBuilder() 
+        .AddParam("$items") 
+            .BeginList() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").Uint64(109) 
+                    .AddMember("Text").String("New") 
+                .EndStruct() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").Uint64(209) 
+                    .AddMember("Text").String("New") 
+                .EndStruct() 
+            .EndList() 
+        .Build() 
+    .Build(); 
+} 
+ 
+TParams BuildDeleteParams(TTableClient& client) { 
+    return client.GetParamsBuilder() 
+        .AddParam("$items") 
+            .BeginList() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").Uint64(101) 
+                .EndStruct() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").Uint64(209) 
+                .EndStruct() 
+            .EndList() 
+        .Build() 
+    .Build(); 
+} 
+ 
+TParams BuildUpdateIndexParams(TTableClient& client) { 
+    return client.GetParamsBuilder() 
+        .AddParam("$items") 
+            .BeginList() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").String("Primary1") 
+                    .AddMember("Index2").String("SecondaryNew1") 
+                    .AddMember("Value").String("ValueNew1") 
+                .EndStruct() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").String("Primary5") 
+                    .AddMember("Index2").String("SecondaryNew2") 
+                    .AddMember("Value").String("ValueNew2") 
+                .EndStruct() 
+            .EndList() 
+        .Build() 
+    .Build(); 
+} 
+ 
+TParams BuildDeleteIndexParams(TTableClient& client) { 
+    return client.GetParamsBuilder() 
+        .AddParam("$items") 
+            .BeginList() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").String("Primary1") 
+                .EndStruct() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").String("Primary5") 
+                .EndStruct() 
+            .EndList() 
+        .Build() 
+    .Build(); 
+} 
+ 
+TParams BuildInsertIndexParams(TTableClient& client) { 
+    return client.GetParamsBuilder() 
+        .AddParam("$items") 
+            .BeginList() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Key").String("Primary10") 
+                    .AddMember("Index2").String("SecondaryNew10") 
+                    .AddMember("Value").String("ValueNew10") 
+                .EndStruct() 
+            .EndList() 
+        .Build() 
+    .Build(); 
+} 
+ 
+} // namespace 
+ 
+Y_UNIT_TEST_SUITE(KqpEffectsPerf) { 
+    Y_UNIT_TEST_TWIN(Upsert, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = BuildUpdateParams(db); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':Uint64,'Text':String>>; 
+ 
+            UPSERT INTO EightShard 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/EightShard", { 
+            .ExpectedReads = 0, 
+            .ExpectedUpdates = 2, 
+        }); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        // TODO: Get rid of additional precompute stage for adding optionality to row members in NewEngine 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 2 : 1); 
+ 
+        for (const auto& phase : stats.query_phases()) { 
+            UNIT_ASSERT(phase.affected_shards() <= 2); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(Replace, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = BuildUpdateParams(db); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':Uint64,'Text':String>>; 
+ 
+            REPLACE INTO EightShard 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/EightShard", { 
+            .ExpectedReads = 0, 
+            .ExpectedUpdates = 2, 
+        }); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        // Single-phase REPLACE in NewEngine require additional runtime write callable 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 2 : 1); 
+ 
+        for (const auto& phase : stats.query_phases()) { 
+            UNIT_ASSERT(phase.affected_shards() <= 2); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(UpdateOn, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = BuildUpdateParams(db); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':Uint64,'Text':String>>; 
+ 
+            UPDATE EightShard ON 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/EightShard", { 
+            .ExpectedReads = 1, // Non-existing keys don't count in reads 
+            .ExpectedUpdates = 1, 
+        }); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        // Two-phase UPDATE ON in NewEngine require more complex runtime callables 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 3 : 2); 
+ 
+        for (const auto& phase : stats.query_phases()) { 
+            UNIT_ASSERT(phase.affected_shards() <= 2); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(Insert, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = BuildInsertParams(db); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':Uint64,'Text':String>>; 
+ 
+            INSERT INTO EightShard 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/EightShard", { 
+            .ExpectedReads = 0, // Non-existing keys don't count in reads 
+            .ExpectedUpdates = 2, 
+        }); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        // Three-phase INSERT in NewEngine require more complex runtime callables 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 3); 
+ 
+        for (const auto& phase : stats.query_phases()) { 
+            UNIT_ASSERT(phase.affected_shards() <= 2); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(DeleteOn, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = BuildDeleteParams(db); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':Uint64>>; 
+ 
+            DELETE FROM EightShard ON 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/EightShard", { 
+            .ExpectedReads = 0, 
+            .ExpectedDeletes = 2, 
+        }); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        // TODO: Get rid of additional precompute stage for adding optionality to row members in NewEngine 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 2 : 1); 
+ 
+        for (const auto& phase : stats.query_phases()) { 
+            UNIT_ASSERT(phase.affected_shards() <= 2); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(Update, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key").Uint64(201).Build() 
+        .Build(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $key AS Uint64; 
+ 
+            UPDATE EightShard 
+            SET Data = Data + 1 
+            WHERE Key = $key; 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/EightShard", { 
+            .ExpectedReads = 1, 
+            .ExpectedUpdates = 1, 
+        }); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2); 
+ 
+        for (const auto& phase : stats.query_phases()) { 
+            UNIT_ASSERT(phase.affected_shards() <= 1); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(Delete, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key").Uint64(201).Build() 
+            .AddParam("$text").String("Value1").Build() 
+        .Build(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $key AS Uint64; 
+            DECLARE $text AS String; 
+ 
+            DELETE FROM EightShard 
+            WHERE Key = $key AND Text = $text; 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/EightShard", { 
+            .ExpectedReads = 1, 
+            .ExpectedDeletes = 1, 
+        }); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2); 
+ 
+        for (const auto& phase : stats.query_phases()) { 
+            UNIT_ASSERT(phase.affected_shards() <= 1); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(IndexUpsert, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        CreateSampleTablesWithIndex(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto params = BuildUpdateIndexParams(db); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':String,'Index2':String,'Value':String>>; 
+ 
+            UPSERT INTO SecondaryWithDataColumns 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 3); 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(IndexReplace, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        CreateSampleTablesWithIndex(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto params = BuildUpdateIndexParams(db); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':String,'Index2':String,'Value':String>>; 
+ 
+            REPLACE INTO SecondaryWithDataColumns 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 3); 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(IndexUpdateOn, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        CreateSampleTablesWithIndex(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto params = BuildUpdateIndexParams(db); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':String,'Index2':String,'Value':String>>; 
+ 
+            UPDATE SecondaryWithDataColumns ON 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 2); 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(IndexDeleteOn, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        CreateSampleTablesWithIndex(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto params = BuildDeleteIndexParams(db); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':String>>; 
+ 
+            DELETE FROM SecondaryWithDataColumns ON 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 4 : 2); 
+    } 
+ 
+    Y_UNIT_TEST_TWIN(IndexInsert, UseNewEngine) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        CreateSampleTablesWithIndex(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto params = BuildInsertIndexParams(db); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':String,'Index2':String,'Value':String>>; 
+ 
+            INSERT INTO SecondaryWithDataColumns 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 5 : 3); 
+    } 
+} 
+ 
+} // namespace NKikimr::NKqp 
diff --git a/ydb/core/kqp/ut/kqp_explain_ut.cpp b/ydb/core/kqp/ut/kqp_explain_ut.cpp
index c3a0683636..7e5f846c86 100644
--- a/ydb/core/kqp/ut/kqp_explain_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_explain_ut.cpp
@@ -58,12 +58,12 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
 
+        Cerr << *res.PlanJson; 
+ 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto join = FindPlanNodeByKv(plan, "Node Type", "Aggregate-InnerJoin (MapJoin)-Filter-TableFullScan");
         UNIT_ASSERT(join.IsDefined());
@@ -85,11 +85,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto join = FindPlanNodeByKv(plan, "Node Type", "Aggregate-InnerJoin (MapJoin)-Filter-TableFullScan");
         UNIT_ASSERT(join.IsDefined());
@@ -128,11 +128,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto read = FindPlanNodeByKv(plan, "Node Type", "Aggregate-Filter-TableFullScan");
         UNIT_ASSERT(read.IsDefined());
@@ -171,10 +171,10 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
+        UNIT_ASSERT(res.PlanJson); 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto join = FindPlanNodeByKv(
             plan,
@@ -200,11 +200,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto node = FindPlanNodeByKv(plan, "Node Type", "TopSort-TableRangesScan");
         UNIT_ASSERT(node.IsDefined());
@@ -229,11 +229,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto read = FindPlanNodeByKv(plan, "Node Type", "Limit-TablePointLookup");
         auto& operators = read.GetMapSafe().at("Operators").GetArraySafe();
@@ -256,11 +256,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto scanSort = FindPlanNodeByKv(plan, "Node Type", "Sort-TableRangesScan");
         UNIT_ASSERT(scanSort.IsDefined());
@@ -278,11 +278,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto limit = FindPlanNodeByKv(plan, "Limit", "10");
         UNIT_ASSERT(limit.IsDefined());
@@ -313,11 +313,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto join1 = FindPlanNodeByKv(plan, "Node Type", "Sort-InnerJoin (MapJoin)-Filter-Aggregate-Sort");
         UNIT_ASSERT(join1.IsDefined());
@@ -337,11 +337,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto constExpr = FindPlanNodeByKv(plan, "Node Type", "ConstantExpr");
         UNIT_ASSERT(constExpr.IsDefined());
@@ -364,11 +364,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
 
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         bool containCte = false;
         auto& plans = plan.GetMapSafe().at("Plan").GetMapSafe().at("Plans");
@@ -400,11 +400,11 @@ Y_UNIT_TEST_SUITE(KqpExplain) {
         auto it = db.StreamExecuteScanQuery(query, settings).GetValueSync();
         auto res = CollectStreamResult(it);
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        UNIT_ASSERT(res.PlanJson);
-        Cerr << *res.PlanJson;
+        UNIT_ASSERT(res.PlanJson); 
+        Cerr << *res.PlanJson; 
 
         NJson::TJsonValue plan;
-        NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+        NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
 
         auto unionNode = FindPlanNodeByKv(plan, "Node Type", "Sort-Union");
         UNIT_ASSERT_EQUAL(unionNode.GetMap().at("Plans").GetArraySafe().size(), 4);
diff --git a/ydb/core/kqp/ut/kqp_flip_join_ut.cpp b/ydb/core/kqp/ut/kqp_flip_join_ut.cpp
index 593e1a1876..a67749b928 100644
--- a/ydb/core/kqp/ut/kqp_flip_join_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_flip_join_ut.cpp
@@ -52,15 +52,15 @@ static const bool EnableJoinFlip = false;
 static const bool DisableJoinFlip = true;
 
 static const char* FormatPragma(bool disableFlip) {
-    if (!disableFlip) {
-        return "PRAGMA Kikimr.OptDisableJoinReverseTableLookup = 'False';";
-    }
-    return "";
-}
-
-static const char* FormatLeftSemiPragma(bool disableFlip) {
+    if (!disableFlip) { 
+        return "PRAGMA Kikimr.OptDisableJoinReverseTableLookup = 'False';"; 
+    } 
+    return ""; 
+} 
+ 
+static const char* FormatLeftSemiPragma(bool disableFlip) { 
     if (disableFlip) {
-        return "PRAGMA Kikimr.OptDisableJoinReverseTableLookupLeftSemi = 'True';";
+        return "PRAGMA Kikimr.OptDisableJoinReverseTableLookupLeftSemi = 'True';"; 
     }
     return "";
 }
@@ -560,19 +560,19 @@ Y_UNIT_TEST_SUITE(KqpFlipJoin) {
                     ORDER BY t3.Key, t3.Value
                 )", FormatPragma(disableFlip));
 
-            auto result = ExecQueryAndTestResult(session, query, NoParams, R"([])");
+            auto result = ExecQueryAndTestResult(session, query, NoParams, R"([])"); 
             assertFn(result);
         };
 
         test(DisableJoinFlip, [](const TDataQueryResult& result) {
             AssertTableReads(result, "/Root/FJ_Table_1", 4);
-            AssertTableReads(result, "/Root/FJ_Table_2", 0);
+            AssertTableReads(result, "/Root/FJ_Table_2", 0); 
             AssertTableReads(result, "/Root/FJ_Table_3", 4);
         });
 
         test(EnableJoinFlip, [](const TDataQueryResult& result) {
-            AssertTableReads(result, "/Root/FJ_Table_1", 3);
-            AssertTableReads(result, "/Root/FJ_Table_2", 0);
+            AssertTableReads(result, "/Root/FJ_Table_1", 3); 
+            AssertTableReads(result, "/Root/FJ_Table_2", 0); 
             AssertTableReads(result, "/Root/FJ_Table_3", 4);
         });
     }
diff --git a/ydb/core/kqp/ut/kqp_indexes_ut.cpp b/ydb/core/kqp/ut/kqp_indexes_ut.cpp
index 505cf09e6b..4b41c31dbd 100644
--- a/ydb/core/kqp/ut/kqp_indexes_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_indexes_ut.cpp
@@ -1,5 +1,5 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/core/client/minikql_compile/mkql_compile_service.h>
 #include <ydb/core/kqp/kqp_impl.h>
 #include <ydb/core/kqp/kqp_metadata_loader.h>
@@ -10,17 +10,17 @@
 
 #include <ydb/library/yql/core/services/mounts/yql_mounts.h>
 #include <ydb/library/yql/providers/common/provider/yql_provider.h>
-
+ 
 #include <library/cpp/json/json_reader.h>
 
 #include <util/string/printf.h>
 
 namespace NKikimr {
 namespace NKqp {
-
+ 
 using namespace NYdb;
 using namespace NYdb::NTable;
-using namespace NYdb::NScripting;
+using namespace NYdb::NScripting; 
 
 using NYql::TExprContext;
 using NYql::TExprNode;
@@ -1110,8 +1110,8 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         {
@@ -1138,10 +1138,10 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
                                  query1,
                                  TTxControl::BeginTx(TTxSettings::SerializableRW()))
                           .ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result1.GetStatus(), NYdb::EStatus::SUCCESS);
+        UNIT_ASSERT_VALUES_EQUAL(result1.GetStatus(), NYdb::EStatus::SUCCESS); 
         {
             auto yson = NYdb::FormatResultSetYson(result1.GetResultSet(0));
-            UNIT_ASSERT_VALUES_EQUAL(yson, R"([[["Secondary1"]]])");
+            UNIT_ASSERT_VALUES_EQUAL(yson, R"([[["Secondary1"]]])"); 
         }
 
         {
@@ -1272,8 +1272,8 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         {
@@ -1300,18 +1300,18 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
             auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
 
             if (UseNewEngine) {
-                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 4);
-
-                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access().size(), 1);
-                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).name(), "/Root/TestTable");
-
-                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access().size(), 2);
-                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access(0).name(), "/Root/TestTable");
-                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access(0).updates().rows(), 1);
-
-                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access(1).name(), "/Root/TestTable/Index/indexImplTable");
-                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access(1).updates().rows(), 1);
-                UNIT_ASSERT(!stats.query_phases(3).table_access(0).has_deletes());
+                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 4); 
+
+                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access().size(), 1); 
+                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).name(), "/Root/TestTable"); 
+ 
+                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access().size(), 2); 
+                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access(0).name(), "/Root/TestTable"); 
+                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access(0).updates().rows(), 1); 
+
+                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access(1).name(), "/Root/TestTable/Index/indexImplTable"); 
+                UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(3).table_access(1).updates().rows(), 1); 
+                UNIT_ASSERT(!stats.query_phases(3).table_access(0).has_deletes()); 
             } else {
                 UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 3);
 
@@ -1823,8 +1823,8 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         {
@@ -1907,8 +1907,8 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
 
         const auto& config = kikimr.GetTestServer().GetSettings().AppConfig;
         auto& tableSettings = config.GetTableServiceConfig();
-        bool useSchemeCacheMeta = tableSettings.GetUseSchemeCacheMetadata();
-
+        bool useSchemeCacheMeta = tableSettings.GetUseSchemeCacheMetadata(); 
+ 
         {
             auto tableBuilder = db.GetTableBuilder();
             tableBuilder
@@ -1918,8 +1918,8 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         {
@@ -1951,7 +1951,7 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[["Secondary1"];["Primary1"]];[["Secondary2"];["Primary2"]];[["Secondary3"];["Primary3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
@@ -1968,9 +1968,9 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
                                      query,
                                      TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                               .ExtractValueSync();
-            // KIKIMR-7997
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(),
-                useSchemeCacheMeta ? NYdb::EStatus::SCHEME_ERROR : NYdb::EStatus::GENERIC_ERROR);
+            // KIKIMR-7997 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), 
+                useSchemeCacheMeta ? NYdb::EStatus::SCHEME_ERROR : NYdb::EStatus::GENERIC_ERROR); 
         }
 
         {
@@ -1982,7 +1982,7 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
                                      query,
                                      TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                               .ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::SCHEME_ERROR);
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::SCHEME_ERROR); 
         }
 
         {
@@ -1995,7 +1995,7 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
                                      TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                               .ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            UNIT_ASSERT_VALUES_EQUAL(NYdb::FormatResultSetYson(result.GetResultSet(0)), "[[[\"Value2\"]]]");
+            UNIT_ASSERT_VALUES_EQUAL(NYdb::FormatResultSetYson(result.GetResultSet(0)), "[[[\"Value2\"]]]"); 
         }
 
         {
@@ -2013,7 +2013,7 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[["Secondary2"];["Primary2"]];[["Secondary3"];["Primary3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
@@ -2031,7 +2031,7 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[["Secondary3"];["Primary3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
@@ -2049,13 +2049,13 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable");
             const TString expected = R"([[["Primary3"];["Secondary3_1"];["Value3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[["Secondary3_1"];["Primary3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
@@ -2073,13 +2073,13 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable");
             const TString expected = R"([[["Primary3"];["Secondary3_2"];["Value3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[["Secondary3_2"];["Primary3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
     }
 
@@ -2102,8 +2102,8 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2", "Index2A"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         const TString query1(Q_(R"(
@@ -2122,7 +2122,7 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[["Secondary1"];["Secondary1A"];["Primary1"]];[["Secondary2"];["Secondary2A"];["Primary2"]];[["Secondary3"];["Secondary3A"];["Primary3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
@@ -2140,13 +2140,13 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable");
             const TString expected = R"([[["Primary1"];["Secondary1_1"];["Secondary1A"]];[["Primary2"];["Secondary2"];["Secondary2A"]];[["Primary3"];["Secondary3"];["Secondary3A"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[["Secondary1_1"];["Secondary1A"];["Primary1"]];[["Secondary2"];["Secondary2A"];["Primary2"]];[["Secondary3"];["Secondary3A"];["Primary3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
@@ -2164,13 +2164,13 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable");
             const TString expected = R"([[["Primary1"];["Secondary1_2"];["Secondary1A"]];[["Primary2"];["Secondary2"];["Secondary2A"]];[["Primary3"];["Secondary3"];["Secondary3A"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[["Secondary1_2"];["Secondary1A"];["Primary1"]];[["Secondary2"];["Secondary2A"];["Primary2"]];[["Secondary3"];["Secondary3A"];["Primary3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
     }
 
@@ -2193,8 +2193,8 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index", "Index2");
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         const TString query1(Q_(R"(
@@ -2211,7 +2211,7 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[["Secondary1"];["Primary1"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
 
         {
@@ -3027,8 +3027,8 @@ Y_UNIT_TEST_SUITE(KqpIndexes) {
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key", "KeyA"});
             tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2", "Index2A"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         {
@@ -3104,8 +3104,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         {
@@ -3120,14 +3120,14 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                 query,
                 TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                 .ExtractValueSync();
-            result.GetIssues().PrintTo(Cerr);
+            result.GetIssues().PrintTo(Cerr); 
             UNIT_ASSERT(result.IsSuccess());
         }
 
         {
             const auto& yson = ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable");
             const TString expected = R"([[#;["Primary1"]];[#;["Primary2"]];[#;["Primary3"]]])";
-            UNIT_ASSERT_VALUES_EQUAL(yson, expected);
+            UNIT_ASSERT_VALUES_EQUAL(yson, expected); 
         }
     }
 
@@ -3151,8 +3151,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             tableBuilder.AddSecondaryIndex("Index1", "Value1");
             tableBuilder.AddSecondaryIndex("Index2", "Value2");
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         const TString query1(Q_(R"(
@@ -3217,8 +3217,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             tableBuilder.AddSecondaryIndex("Index1", TVector<TString>{"Value1", "Value3"});
             tableBuilder.AddSecondaryIndex("Index2", TVector<TString>{"Value2", "Value3"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         {
@@ -3260,7 +3260,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                 TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                 .ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            UNIT_ASSERT_VALUES_EQUAL(NYdb::FormatResultSetYson(result.GetResultSet(0)), "[[[\"Val2\"]]]");
+            UNIT_ASSERT_VALUES_EQUAL(NYdb::FormatResultSetYson(result.GetResultSet(0)), "[[[\"Val2\"]]]"); 
         }
 
         {
@@ -3555,8 +3555,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             tableBuilder.AddSecondaryIndex("Index1", TVector<TString>{"Value1", "KeyA"});
             tableBuilder.AddSecondaryIndex("Index2", TVector<TString>{"Key", "Value1"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         {
@@ -3599,7 +3599,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                 TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                 .ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            UNIT_ASSERT_VALUES_EQUAL(NYdb::FormatResultSetYson(result.GetResultSet(0)), "[[[\"Primary1\"]]]");
+            UNIT_ASSERT_VALUES_EQUAL(NYdb::FormatResultSetYson(result.GetResultSet(0)), "[[[\"Primary1\"]]]"); 
         }
 
         {
@@ -3882,8 +3882,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index1", "Value");
             auto result = session.CreateTable("/Root/TestTable1", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
         {
             auto tableBuilder = db.GetTableBuilder();
@@ -3893,8 +3893,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index1", "Value");
             auto result = session.CreateTable("/Root/TestTable2", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
         {
             const TString query1(Q_(R"(
@@ -4076,8 +4076,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index1", "Value");
             auto result = session.CreateTable("/Root/TestTable1", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
         {
             auto tableBuilder = db.GetTableBuilder();
@@ -4088,8 +4088,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index1", "Value");
             auto result = session.CreateTable("/Root/TestTable2", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
         {
             const TString query1(Q_(R"(
@@ -4210,8 +4210,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
 
             const TString query1(Q_(R"(
                 UPSERT INTO `/Root/TestTable` (Key, Index2, Value) VALUES
@@ -4235,7 +4235,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                                  TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                           .ExtractValueSync();
             UNIT_ASSERT(result.GetIssues().ToString().Contains("Unexpected token"));
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR);
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR); 
         }
 
         {
@@ -4248,7 +4248,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                                  TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                           .ExtractValueSync();
             UNIT_ASSERT(result.GetIssues().ToString().Contains("Unexpected token"));
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR);
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR); 
         }
 
         {
@@ -4261,7 +4261,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                                      TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                               .ExtractValueSync();
             UNIT_ASSERT(result.GetIssues().ToString().Contains("Unexpected token"));
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR);
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR); 
         }
 
         {
@@ -4274,7 +4274,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                                      TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx())
                               .ExtractValueSync();
             UNIT_ASSERT(result.GetIssues().ToString().Contains("Unexpected token"));
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR);
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR); 
         }
 
     }
@@ -4297,8 +4297,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                 .AddNullableColumn("Value", EPrimitiveType::String);
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
             auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
         }
 
         {
@@ -4308,14 +4308,14 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                 .AddNullableColumn("Key", EPrimitiveType::String);
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Value"});
             auto result = session.CreateTable("/Root/TestTable/Index", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
         }
 
         {
             auto result = scheme.MakeDirectory("/Root/TestTable/Index").ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
         }
 
         {
@@ -4325,7 +4325,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                 .AddNullableColumn("Key", EPrimitiveType::String);
             tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Value"});
             auto result = session.CreateTable("/Root/TestTable/Index/indexImplTable", tableBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
         }
     }
@@ -4348,8 +4348,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
         tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
         tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
         auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+        UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
 
         {
             const TString query(Q_(R"(
@@ -4385,8 +4385,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
         tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
         tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
         auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+        UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
 
         {
             const TString query(Q_(R"(
@@ -4423,8 +4423,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
         tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
         tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
         auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+        UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
 
         {
             const TString query(Q1_(R"(
@@ -4492,7 +4492,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                 ReadTablePartToYson(session, "/Root/TestTable/Index/indexImplTable"));
         }
     }
-
+ 
     Y_UNIT_TEST_QUAD(MultipleModifications, WithMvcc, UseNewEngine) {
         auto setting = NKikimrKqp::TKqpSetting();
         auto serverSettings = TKikimrSettings()
@@ -4511,8 +4511,8 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
         tableBuilder.SetPrimaryKeyColumns(TVector<TString>{"Key"});
         tableBuilder.AddSecondaryIndex("Index", TVector<TString>{"Index2"});
         auto result = session.CreateTable("/Root/TestTable", tableBuilder.Build()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+        UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
 
         {
             const TString query1(Q_(R"(
@@ -4540,7 +4540,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             UNIT_ASSERT_VALUES_EQUAL(yson, "");
         }
     }
-
+ 
     template <bool WithMvcc, bool UseNewEngine>
     void CreateTableWithIndexSQL(EIndexTypeSql type, bool enableAsyncIndexes = false) {
         auto kqpSetting = NKikimrKqp::TKqpSetting();
@@ -4569,7 +4569,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
                 ")", typeStr.data(), typeStr.data());
         {
             auto result = session.ExecuteSchemeQuery(createTableSql).GetValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), expectedStatus);
         }
 
@@ -4577,7 +4577,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
         {
 
             auto result = session.ExecuteSchemeQuery(createTableSql).GetValueSync();
-            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false);
+            UNIT_ASSERT_VALUES_EQUAL(result.IsTransportError(), false); 
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), expectedStatus);
         }
 
@@ -4680,7 +4680,7 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
         const auto variants = TVector<std::pair<TTxSettings, EStatus>>{
             {TTxSettings::SerializableRW(), UseNewEngine ? EStatus::PRECONDITION_FAILED : EStatus::GENERIC_ERROR},
             {TTxSettings::OnlineRO(), UseNewEngine ? EStatus::PRECONDITION_FAILED : EStatus::GENERIC_ERROR},
-            {TTxSettings::StaleRO(), EStatus::SUCCESS},
+            {TTxSettings::StaleRO(), EStatus::SUCCESS}, 
         };
 
         for (const auto& [settings, status] : variants) {
@@ -4971,207 +4971,207 @@ R"([[#;#;["Primary1"];[41u]];[["Secondary2"];[2u];["Primary2"];[42u]];[["Seconda
             UNIT_ASSERT_VALUES_EQUAL(execQuery(query1), expected);
         }
     }
-
-    Y_UNIT_TEST_QUAD(DeleteByIndex, WithMvcc, UseNewEngine) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        auto serverSettings = TKikimrSettings()
-            .SetEnableMvcc(WithMvcc)
-            .SetEnableMvccSnapshotReads(WithMvcc)
-            .SetKqpSettings({setting});
-        TKikimrRunner kikimr(serverSettings);
-
-        TScriptingClient client(kikimr.GetDriver());
-        auto scriptResult = client.ExecuteYqlScript(R"(
-            --!syntax_v1
-            CREATE TABLE TestTable (
-                Key Int32,
-                Subkey Utf8,
-                Value Utf8,
-                PRIMARY KEY (Key, Subkey),
-                INDEX SecondaryIndex GLOBAL ON (Subkey)
-            );
-
-            COMMIT;
-
-            UPSERT INTO TestTable (Key, Subkey, Value) VALUES
-                (1, "One", "Value1"),
-                (1, "Two", "Value2"),
-                (2, "One", "Value3"),
-                (3, "One", "Value4");
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(scriptResult.GetStatus(), EStatus::SUCCESS, scriptResult.GetIssues().ToString());
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto query = Q1_(R"(
-            DECLARE $subkey AS Utf8;
-            DECLARE $keys AS List<Int32>;
-
-            $to_delete =
-                SELECT Key FROM TestTable VIEW SecondaryIndex
-                WHERE Subkey = $subkey AND Key NOT IN $keys;
-
-            DELETE FROM TestTable
-            WHERE Key IN $to_delete;
-        )");
-
-        auto explainResult = session.ExplainDataQuery(query).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(explainResult.GetStatus(), EStatus::SUCCESS, explainResult.GetIssues().ToString());
-
-        NJson::TJsonValue plan;
-        NJson::ReadJsonTree(explainResult.GetPlan(), &plan, true);
-        // NJson::WriteJson(&Cerr, &plan["tables"], true);
-
-        auto tablePlan = FindPlanNodeByKv(plan["tables"], "name", "/Root/TestTable");
-        UNIT_ASSERT(tablePlan.IsDefined());
-        // TODO: KIKIMR-14074 (Unnecessary left semi join with own index table)
-        UNIT_ASSERT_VALUES_EQUAL(tablePlan["reads"].GetArraySafe().size(), 1);
-        for (const auto& read : tablePlan["reads"].GetArraySafe()) {
-            UNIT_ASSERT_VALUES_UNEQUAL(read["type"].GetString(), "");
-            UNIT_ASSERT_VALUES_UNEQUAL(read["type"].GetString(), "FullScan");
-        }
-
-        auto indexPlan = FindPlanNodeByKv(plan["tables"], "name", "/Root/TestTable/SecondaryIndex/indexImplTable");
-        UNIT_ASSERT(indexPlan.IsDefined());
-        for (const auto& read : indexPlan["reads"].GetArraySafe()) {
-            UNIT_ASSERT_VALUES_UNEQUAL(read["type"].GetString(), "");
-            UNIT_ASSERT_VALUES_UNEQUAL(read["type"].GetString(), "FullScan");
-        }
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$subkey")
-                .Utf8("One")
-                .Build()
-            .AddParam("$keys")
-                .BeginList()
-                    .AddListItem().Int32(1)
-                .EndList()
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(Q1_(R"(
-            SELECT * FROM TestTable ORDER BY Key, Subkey;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-
-        CompareYson(R"([
-            [[1];["One"];["Value1"]];
-            [[1];["Two"];["Value2"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST_QUAD(UpdateDeletePlan, WithMvcc, UseNewEngine) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        auto serverSettings = TKikimrSettings()
-            .SetEnableMvcc(WithMvcc)
-            .SetEnableMvccSnapshotReads(WithMvcc)
-            .SetKqpSettings({setting});
-        TKikimrRunner kikimr(serverSettings);
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto schemeResult = session.ExecuteSchemeQuery(R"(
-            --!syntax_v1
-            CREATE TABLE TestTable (
-                Key Int32,
-                Subkey Utf8,
-                Value Utf8,
-                PRIMARY KEY (Key),
-                INDEX SecondaryIndex GLOBAL ON (Subkey)
-            );
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(schemeResult.GetStatus(), EStatus::SUCCESS, schemeResult.GetIssues().ToString());
-
-        auto checkPlan = [](const TString& planJson, ui32 tableReads, ui32 tableWrites, TMaybe<ui32> indexWrites) {
-            NJson::TJsonValue plan;
-            NJson::ReadJsonTree(planJson, &plan, true);
-            const auto& tables = plan["tables"];
-            // NJson::WriteJson(&Cerr, &tables, true);
-
-            auto tablePlan = FindPlanNodeByKv(tables, "name", "/Root/TestTable");
-            auto indexPlan = FindPlanNodeByKv(tables, "name", "/Root/TestTable/SecondaryIndex/indexImplTable");
-
-            UNIT_ASSERT_VALUES_EQUAL(tablePlan["reads"].GetArraySafe().size(), tableReads);
-            UNIT_ASSERT_VALUES_EQUAL(tablePlan["writes"].GetArraySafe().size(), tableWrites);
-            if (indexWrites) {
-                UNIT_ASSERT_VALUES_EQUAL(indexPlan["writes"].GetArraySafe().size(), *indexWrites);
-            }
-        };
-
-        auto result = session.ExplainDataQuery(Q1_(R"(
-            UPDATE TestTable SET Subkey = "Updated" WHERE Value = "Value2";
-        )")).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        checkPlan(result.GetPlan(), 1, 1, 2);
-
-        result = session.ExplainDataQuery(Q1_(R"(
-            UPDATE TestTable SET Value = "Updated" WHERE Value = "Value2";
-        )")).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        checkPlan(result.GetPlan(), 1, 1, {});
-
-        result = session.ExplainDataQuery(Q1_(R"(
-            DELETE FROM TestTable WHERE Value = "Value2";
-        )")).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        checkPlan(result.GetPlan(), 1, 1, 1);
-    }
-
-    Y_UNIT_TEST_QUAD(UpsertNoIndexColumns, WithMvcc, UseNewEngine) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        auto serverSettings = TKikimrSettings()
-            .SetEnableMvcc(WithMvcc)
-            .SetEnableMvccSnapshotReads(WithMvcc)
-            .SetKqpSettings({setting});
-        TKikimrRunner kikimr(serverSettings);
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        CreateSampleTablesWithIndex(session);
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Int32(2)
-                        .AddMember("Value").String("Upsert2")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Int32(3)
-                        .AddMember("Value").String("Upsert3")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $rows AS List<Struct<'Key': Int32, 'Value': String>>;
-
-            UPSERT INTO SecondaryKeys
-            SELECT * FROM AS_TABLE($rows);
-        )"), TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(Q1_(R"(
-            SELECT Key, Fk, Value FROM SecondaryKeys WHERE Key IN [2, 3] ORDER BY Key;
-            SELECT Key FROM SecondaryKeys VIEW Index WHERE Fk IS NULL ORDER BY Key;
-            SELECT Key FROM SecondaryKeys VIEW Index WHERE Fk = 2 ORDER BY Key;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-
-        CompareYson(R"([
-            [[2];[2];["Upsert2"]];
-            [[3];#;["Upsert3"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        CompareYson(R"([[#];[[3]];[[7]]])", FormatResultSetYson(result.GetResultSet(1)));
-        CompareYson(R"([[[2]]])", FormatResultSetYson(result.GetResultSet(2)));
-    }
+ 
+    Y_UNIT_TEST_QUAD(DeleteByIndex, WithMvcc, UseNewEngine) { 
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        auto serverSettings = TKikimrSettings() 
+            .SetEnableMvcc(WithMvcc) 
+            .SetEnableMvccSnapshotReads(WithMvcc) 
+            .SetKqpSettings({setting}); 
+        TKikimrRunner kikimr(serverSettings); 
+ 
+        TScriptingClient client(kikimr.GetDriver()); 
+        auto scriptResult = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
+            CREATE TABLE TestTable ( 
+                Key Int32, 
+                Subkey Utf8, 
+                Value Utf8, 
+                PRIMARY KEY (Key, Subkey), 
+                INDEX SecondaryIndex GLOBAL ON (Subkey) 
+            ); 
+ 
+            COMMIT; 
+ 
+            UPSERT INTO TestTable (Key, Subkey, Value) VALUES 
+                (1, "One", "Value1"), 
+                (1, "Two", "Value2"), 
+                (2, "One", "Value3"), 
+                (3, "One", "Value4"); 
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(scriptResult.GetStatus(), EStatus::SUCCESS, scriptResult.GetIssues().ToString()); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto query = Q1_(R"( 
+            DECLARE $subkey AS Utf8; 
+            DECLARE $keys AS List<Int32>; 
+ 
+            $to_delete = 
+                SELECT Key FROM TestTable VIEW SecondaryIndex 
+                WHERE Subkey = $subkey AND Key NOT IN $keys; 
+ 
+            DELETE FROM TestTable 
+            WHERE Key IN $to_delete; 
+        )"); 
+ 
+        auto explainResult = session.ExplainDataQuery(query).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(explainResult.GetStatus(), EStatus::SUCCESS, explainResult.GetIssues().ToString()); 
+ 
+        NJson::TJsonValue plan; 
+        NJson::ReadJsonTree(explainResult.GetPlan(), &plan, true); 
+        // NJson::WriteJson(&Cerr, &plan["tables"], true); 
+ 
+        auto tablePlan = FindPlanNodeByKv(plan["tables"], "name", "/Root/TestTable"); 
+        UNIT_ASSERT(tablePlan.IsDefined()); 
+        // TODO: KIKIMR-14074 (Unnecessary left semi join with own index table) 
+        UNIT_ASSERT_VALUES_EQUAL(tablePlan["reads"].GetArraySafe().size(), 1); 
+        for (const auto& read : tablePlan["reads"].GetArraySafe()) { 
+            UNIT_ASSERT_VALUES_UNEQUAL(read["type"].GetString(), ""); 
+            UNIT_ASSERT_VALUES_UNEQUAL(read["type"].GetString(), "FullScan"); 
+        } 
+ 
+        auto indexPlan = FindPlanNodeByKv(plan["tables"], "name", "/Root/TestTable/SecondaryIndex/indexImplTable"); 
+        UNIT_ASSERT(indexPlan.IsDefined()); 
+        for (const auto& read : indexPlan["reads"].GetArraySafe()) { 
+            UNIT_ASSERT_VALUES_UNEQUAL(read["type"].GetString(), ""); 
+            UNIT_ASSERT_VALUES_UNEQUAL(read["type"].GetString(), "FullScan"); 
+        } 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$subkey") 
+                .Utf8("One") 
+                .Build() 
+            .AddParam("$keys") 
+                .BeginList() 
+                    .AddListItem().Int32(1) 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(Q1_(R"( 
+            SELECT * FROM TestTable ORDER BY Key, Subkey; 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+ 
+        CompareYson(R"([ 
+            [[1];["One"];["Value1"]]; 
+            [[1];["Two"];["Value2"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST_QUAD(UpdateDeletePlan, WithMvcc, UseNewEngine) { 
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        auto serverSettings = TKikimrSettings() 
+            .SetEnableMvcc(WithMvcc) 
+            .SetEnableMvccSnapshotReads(WithMvcc) 
+            .SetKqpSettings({setting}); 
+        TKikimrRunner kikimr(serverSettings); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto schemeResult = session.ExecuteSchemeQuery(R"( 
+            --!syntax_v1 
+            CREATE TABLE TestTable ( 
+                Key Int32, 
+                Subkey Utf8, 
+                Value Utf8, 
+                PRIMARY KEY (Key), 
+                INDEX SecondaryIndex GLOBAL ON (Subkey) 
+            ); 
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(schemeResult.GetStatus(), EStatus::SUCCESS, schemeResult.GetIssues().ToString()); 
+ 
+        auto checkPlan = [](const TString& planJson, ui32 tableReads, ui32 tableWrites, TMaybe<ui32> indexWrites) { 
+            NJson::TJsonValue plan; 
+            NJson::ReadJsonTree(planJson, &plan, true); 
+            const auto& tables = plan["tables"]; 
+            // NJson::WriteJson(&Cerr, &tables, true); 
+ 
+            auto tablePlan = FindPlanNodeByKv(tables, "name", "/Root/TestTable"); 
+            auto indexPlan = FindPlanNodeByKv(tables, "name", "/Root/TestTable/SecondaryIndex/indexImplTable"); 
+ 
+            UNIT_ASSERT_VALUES_EQUAL(tablePlan["reads"].GetArraySafe().size(), tableReads); 
+            UNIT_ASSERT_VALUES_EQUAL(tablePlan["writes"].GetArraySafe().size(), tableWrites); 
+            if (indexWrites) { 
+                UNIT_ASSERT_VALUES_EQUAL(indexPlan["writes"].GetArraySafe().size(), *indexWrites); 
+            } 
+        }; 
+ 
+        auto result = session.ExplainDataQuery(Q1_(R"( 
+            UPDATE TestTable SET Subkey = "Updated" WHERE Value = "Value2"; 
+        )")).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        checkPlan(result.GetPlan(), 1, 1, 2); 
+ 
+        result = session.ExplainDataQuery(Q1_(R"( 
+            UPDATE TestTable SET Value = "Updated" WHERE Value = "Value2"; 
+        )")).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        checkPlan(result.GetPlan(), 1, 1, {}); 
+ 
+        result = session.ExplainDataQuery(Q1_(R"( 
+            DELETE FROM TestTable WHERE Value = "Value2"; 
+        )")).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        checkPlan(result.GetPlan(), 1, 1, 1); 
+    } 
+ 
+    Y_UNIT_TEST_QUAD(UpsertNoIndexColumns, WithMvcc, UseNewEngine) { 
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        auto serverSettings = TKikimrSettings() 
+            .SetEnableMvcc(WithMvcc) 
+            .SetEnableMvccSnapshotReads(WithMvcc) 
+            .SetKqpSettings({setting}); 
+        TKikimrRunner kikimr(serverSettings); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        CreateSampleTablesWithIndex(session); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Int32(2) 
+                        .AddMember("Value").String("Upsert2") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Int32(3) 
+                        .AddMember("Value").String("Upsert3") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $rows AS List<Struct<'Key': Int32, 'Value': String>>; 
+ 
+            UPSERT INTO SecondaryKeys 
+            SELECT * FROM AS_TABLE($rows); 
+        )"), TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(Q1_(R"( 
+            SELECT Key, Fk, Value FROM SecondaryKeys WHERE Key IN [2, 3] ORDER BY Key; 
+            SELECT Key FROM SecondaryKeys VIEW Index WHERE Fk IS NULL ORDER BY Key; 
+            SELECT Key FROM SecondaryKeys VIEW Index WHERE Fk = 2 ORDER BY Key; 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+ 
+        CompareYson(R"([ 
+            [[2];[2];["Upsert2"]]; 
+            [[3];#;["Upsert3"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        CompareYson(R"([[#];[[3]];[[7]]])", FormatResultSetYson(result.GetResultSet(1))); 
+        CompareYson(R"([[[2]]])", FormatResultSetYson(result.GetResultSet(2))); 
+    } 
 }
 
 }
diff --git a/ydb/core/kqp/ut/kqp_join_ut.cpp b/ydb/core/kqp/ut/kqp_join_ut.cpp
index 8fa59d31b3..1270888b12 100644
--- a/ydb/core/kqp/ut/kqp_join_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_join_ut.cpp
@@ -1,98 +1,98 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-static TParams BuildPureTableParams(TTableClient& client) {
-    return client.GetParamsBuilder()
-        .AddParam("$rows")
-            .BeginList()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Row").Uint32(1)
-                    .AddMember("Value").String("Value1")
-                .EndStruct()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Row").Uint32(2)
-                    .AddMember("Value").String("Value4")
-                .EndStruct()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Row").Uint32(3)
-                    .AddMember("Value").String("Value4")
-                .EndStruct()
-            .AddListItem()
-                .BeginStruct()
-                    .AddMember("Row").Uint32(4)
-                    .AddMember("Value").String("Value10")
-                .EndStruct()
-            .EndList()
-        .Build()
-    .Build();
-}
-
-static void CreateSampleTables(TSession session) {
-    UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+static TParams BuildPureTableParams(TTableClient& client) { 
+    return client.GetParamsBuilder() 
+        .AddParam("$rows") 
+            .BeginList() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Row").Uint32(1) 
+                    .AddMember("Value").String("Value1") 
+                .EndStruct() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Row").Uint32(2) 
+                    .AddMember("Value").String("Value4") 
+                .EndStruct() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Row").Uint32(3) 
+                    .AddMember("Value").String("Value4") 
+                .EndStruct() 
+            .AddListItem() 
+                .BeginStruct() 
+                    .AddMember("Row").Uint32(4) 
+                    .AddMember("Value").String("Value10") 
+                .EndStruct() 
+            .EndList() 
+        .Build() 
+    .Build(); 
+} 
+ 
+static void CreateSampleTables(TSession session) { 
+    UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
         CREATE TABLE `/Root/Join1_1` (
-            Key Int32,
-            Fk21 Int32,
-            Fk22 String,
-            Value String,
-            PRIMARY KEY (Key)
-        );
+            Key Int32, 
+            Fk21 Int32, 
+            Fk22 String, 
+            Value String, 
+            PRIMARY KEY (Key) 
+        ); 
         CREATE TABLE `/Root/Join1_2` (
-            Key1 Int32,
-            Key2 String,
-            Fk3 String,
-            Value String,
-            PRIMARY KEY (Key1, Key2)
-        );
+            Key1 Int32, 
+            Key2 String, 
+            Fk3 String, 
+            Value String, 
+            PRIMARY KEY (Key1, Key2) 
+        ); 
         CREATE TABLE `/Root/Join1_3` (
-            Key String,
-            Value Int32,
-            PRIMARY KEY (Key)
-        );
-    )").GetValueSync().IsSuccess());
-
-     UNIT_ASSERT(session.ExecuteDataQuery(R"(
+            Key String, 
+            Value Int32, 
+            PRIMARY KEY (Key) 
+        ); 
+    )").GetValueSync().IsSuccess()); 
+ 
+     UNIT_ASSERT(session.ExecuteDataQuery(R"( 
         PRAGMA kikimr.UseNewEngine = "true";
 
         REPLACE INTO `/Root/Join1_1` (Key, Fk21, Fk22, Value) VALUES
-            (1, 101, "One", "Value1"),
-            (2, 102, "Two", "Value1"),
-            (3, 103, "One", "Value2"),
-            (4, 104, "Two", "Value2"),
-            (5, 105, "One", "Value3"),
-            (6, 106, "Two", "Value3"),
-            (7, 107, "One", "Value4"),
-            (8, 108, "One", "Value5");
-
+            (1, 101, "One", "Value1"), 
+            (2, 102, "Two", "Value1"), 
+            (3, 103, "One", "Value2"), 
+            (4, 104, "Two", "Value2"), 
+            (5, 105, "One", "Value3"), 
+            (6, 106, "Two", "Value3"), 
+            (7, 107, "One", "Value4"), 
+            (8, 108, "One", "Value5"); 
+ 
         REPLACE INTO `/Root/Join1_2` (Key1, Key2, Fk3, Value) VALUES
-            (101, "One",   "Name1", "Value21"),
-            (101, "Two",   "Name1", "Value22"),
-            (101, "Three", "Name3", "Value23"),
-            (102, "One",   "Name2", "Value24"),
-            (103, "One",   "Name1", "Value25"),
-            (104, "One",   "Name3", "Value26"),
-            (105, "One",   "Name2", "Value27"),
-            (105, "Two",   "Name4", "Value28"),
-            (106, "One",   "Name3", "Value29"),
+            (101, "One",   "Name1", "Value21"), 
+            (101, "Two",   "Name1", "Value22"), 
+            (101, "Three", "Name3", "Value23"), 
+            (102, "One",   "Name2", "Value24"), 
+            (103, "One",   "Name1", "Value25"), 
+            (104, "One",   "Name3", "Value26"), 
+            (105, "One",   "Name2", "Value27"), 
+            (105, "Two",   "Name4", "Value28"), 
+            (106, "One",   "Name3", "Value29"), 
             (108, "One",    NULL,   "Value31"),
             (109, "Four",   NULL,   "Value41");
-
+ 
         REPLACE INTO `/Root/Join1_3` (Key, Value) VALUES
-            ("Name1", 1001),
-            ("Name2", 1002),
-            ("Name4", 1004);
-    )", TTxControl::BeginTx().CommitTx()).GetValueSync().IsSuccess());
-}
-
+            ("Name1", 1001), 
+            ("Name2", 1002), 
+            ("Name4", 1004); 
+    )", TTxControl::BeginTx().CommitTx()).GetValueSync().IsSuccess()); 
+} 
+ 
 static void CreateRightSemiJoinSampleTables(TSession& session) {
     UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
         CREATE TABLE `/Root/RSJ_SimpleKey_1` (
@@ -179,36 +179,36 @@ static TDataQueryResult ExecQuery(TSession& session, const TString& query, const
 
 static TParams NoParams = TParamsBuilder().Build();
 
-Y_UNIT_TEST_SUITE(KqpJoin) {
+Y_UNIT_TEST_SUITE(KqpJoin) { 
     Y_UNIT_TEST_NEW_ENGINE(IdxLookupLeftPredicate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Join1_1` AS t1
             INNER JOIN `/Root/Join1_2` AS t2
             ON t1.Fk21 = t2.Key1 AND t1.Fk22 = t2.Key2
             WHERE t1.Value = 'Value3' AND t2.Value IS NOT NULL
         )"), TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([[[105];["One"];[5];["Value3"];["Name2"];[105];["One"];["Value27"]]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([[[105];["One"];[5];["Value3"];["Name2"];[105];["One"];["Value27"]]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), kikimr.IsUsingSnapshotReads() && !UseNewEngine ? 2 : 3);
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/Join1_1");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 8);
-
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/Join1_1"); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 8); 
+ 
         ui32 index = 1;
         if (UseNewEngine) {
             UNIT_ASSERT(stats.query_phases(1).table_access().empty()); // keys extraction for lookups
@@ -218,41 +218,41 @@ Y_UNIT_TEST_SUITE(KqpJoin) {
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(index).table_access().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(index).table_access(0).name(), "/Root/Join1_2");
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(index).table_access(0).reads().rows(), 1);
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(IdxLookupPartialLeftPredicate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Join1_1` AS t1
             INNER JOIN `/Root/Join1_2` AS t2
-            ON t1.Fk21 == t2.Key1
-            WHERE t1.Value == "Value3";
+            ON t1.Fk21 == t2.Key1 
+            WHERE t1.Value == "Value3"; 
         )"), TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([
-            [[105];["One"];[5];["Value3"];["Name2"];[105];["One"];["Value27"]];
-            [[105];["One"];[5];["Value3"];["Name4"];[105];["Two"];["Value28"]];
-            [[106];["Two"];[6];["Value3"];["Name3"];[106];["One"];["Value29"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([ 
+            [[105];["One"];[5];["Value3"];["Name2"];[105];["One"];["Value27"]]; 
+            [[105];["One"];[5];["Value3"];["Name4"];[105];["Two"];["Value28"]]; 
+            [[106];["Two"];[6];["Value3"];["Name3"];[106];["One"];["Value29"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
         Cerr << stats.DebugString() << Endl;
-
+ 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), kikimr.IsUsingSnapshotReads() && !UseNewEngine ? 2 : 3);
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/Join1_1");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 8);
-
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/Join1_1"); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 8); 
+ 
         ui32 index = 1;
         if (UseNewEngine) {
             UNIT_ASSERT(stats.query_phases(1).table_access().empty()); // keys extraction for lookups
@@ -262,8 +262,8 @@ Y_UNIT_TEST_SUITE(KqpJoin) {
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(index).table_access().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(index).table_access(0).name(), "/Root/Join1_2");
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(index).table_access(0).reads().rows(), 3);
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(IdxLookupPartialWithTempTable) {
         TKikimrRunner kikimr(SyntaxV1Settings());
         auto db = kikimr.GetTableClient();
@@ -302,25 +302,25 @@ Y_UNIT_TEST_SUITE(KqpJoin) {
     }
 
     Y_UNIT_TEST_NEW_ENGINE(LeftJoinWithNull) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Join1_1` AS t1
             INNER JOIN `/Root/Join1_2` AS t2
-            ON t1.Fk21 == t2.Key1 AND t1.Fk22 == t2.Key2
+            ON t1.Fk21 == t2.Key1 AND t1.Fk22 == t2.Key2 
             LEFT JOIN `/Root/Join1_3` AS t3
-            ON t2.Fk3 = t3.Key
-            WHERE t1.Value == "Value5" AND t2.Value == "Value31";
+            ON t2.Fk3 = t3.Key 
+            WHERE t1.Value == "Value5" AND t2.Value == "Value31"; 
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([[[108];["One"];[8];["Value5"];#;[108];["One"];["Value31"];#;#]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-    }
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([[[108];["One"];[8];["Value5"];#;[108];["One"];["Value31"];#;#]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+    } 
 
     // join on not key column => Full Scan
     Y_UNIT_TEST_NEW_ENGINE(RightSemiJoin_FullScan) {
@@ -725,49 +725,49 @@ Y_UNIT_TEST_SUITE(KqpJoin) {
     Y_UNIT_TEST_NEW_ENGINE(RightTableValuePredicate) {
         TestInnerJoinWithPredicate<UseNewEngine>("r.Value = \"Payload2\"", "[[[105];[5];[\"Payload2\"];[105]]]");
     }
-
+ 
     Y_UNIT_TEST_NEW_ENGINE(JoinAggregateSingleRow) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key1")
-                .Int32(101)
-                .Build()
-            .AddParam("$key2")
-                .String("Two")
-                .Build()
-            .Build();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key1") 
+                .Int32(101) 
+                .Build() 
+            .AddParam("$key2") 
+                .String("Two") 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            DECLARE $key1 AS Int32;
-            DECLARE $key2 AS String;
-
-            SELECT
-                j2.Key2 AS Key,
-                SOME(j2.Value),
-                SOME(j3.Value)
+            DECLARE $key1 AS Int32; 
+            DECLARE $key2 AS String; 
+ 
+            SELECT 
+                j2.Key2 AS Key, 
+                SOME(j2.Value), 
+                SOME(j3.Value) 
             FROM `/Root/Join1_2` AS j2
             LEFT JOIN `/Root/Join1_3` AS j3
-            ON j3.Key = j2.Fk3
-            WHERE j2.Key1 = $key1 AND j2.Key2 = $key2
-            GROUP BY j2.Key2;
+            ON j3.Key = j2.Fk3 
+            WHERE j2.Key1 = $key1 AND j2.Key2 = $key2 
+            GROUP BY j2.Key2; 
         )"), TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([[["Two"];["Value22"];[1001]]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([[["Two"];["Value22"];[1001]]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(JoinAggregate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        CreateSampleTables(session);
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        CreateSampleTables(session); 
+ 
         {
             auto result = session.ExecuteDataQuery(Q_(R"(
                 SELECT t1.Value, SUM(t3.Value)
@@ -779,7 +779,7 @@ Y_UNIT_TEST_SUITE(KqpJoin) {
                 GROUP BY t1.Value;
             )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
             UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+ 
             CompareYson(R"([[["Value1"];[3004]];[["Value2"];[1001]];[["Value3"];[2006]];[["Value5"];#]])",
                 FormatResultSetYson(result.GetResultSet(0)));
         }
@@ -799,40 +799,40 @@ Y_UNIT_TEST_SUITE(KqpJoin) {
             CompareYson(R"([[["Value1"];[3004]];[["Value2"];[1001]];[["Value3"];[2006]]])",
                 FormatResultSetYson(result.GetResultSet(0)));
         }
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(JoinConvert) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        CreateSampleTables(session);
-
-        UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        CreateSampleTables(session); 
+ 
+        UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
             CREATE TABLE `/Root/Join1_3_ui64` (
-                Key String,
-                Value Int64,
-                PRIMARY KEY (Key)
-            );
-        )").GetValueSync().IsSuccess());
-
+                Key String, 
+                Value Int64, 
+                PRIMARY KEY (Key) 
+            ); 
+        )").GetValueSync().IsSuccess()); 
+ 
         UNIT_ASSERT(session.ExecuteDataQuery(Q_(R"(
             REPLACE INTO `/Root/Join1_3_ui64` (Key, Value) VALUES
-                ("Name1", 108);
+                ("Name1", 108); 
         )"), TTxControl::BeginTx().CommitTx()).GetValueSync().IsSuccess());
-
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT t1.Value, t2.Value, t3.Value FROM `/Root/Join1_1` AS t1
             INNER JOIN `/Root/Join1_2` AS t2
-            ON t1.Fk21 == t2.Key1 AND t1.Fk22 == t2.Key2
+            ON t1.Fk21 == t2.Key1 AND t1.Fk22 == t2.Key2 
             LEFT JOIN `/Root/Join1_3_ui64` AS t3
-            ON t2.Key1 = t3.Value
-            WHERE t1.Value == "Value5";
+            ON t2.Key1 = t3.Value 
+            WHERE t1.Value == "Value5"; 
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([[["Value5"];["Value31"];[108]]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-    }
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([[["Value5"];["Value31"];[108]]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+    } 
 
     Y_UNIT_TEST_NEW_ENGINE(ExclusionJoin) {
         TKikimrRunner kikimr;
@@ -976,78 +976,78 @@ Y_UNIT_TEST_SUITE(KqpJoin) {
             [[2];#;#]
         ])", FormatResultSetYson(result.GetResultSet(0)));
     }
-
-    Y_UNIT_TEST_NEW_ENGINE(JoinLeftPureInner) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $rows AS List<Struct<Row: Uint32, Value: String>>;
-
-            SELECT COUNT(*)
-            FROM AS_TABLE($rows) AS tl
-            INNER JOIN Join1 AS tr
-            ON tl.Value = tr.Value;
-        )"), TTxControl::BeginTx().CommitTx(), BuildPureTableParams(db)).GetValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[5u]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(JoinLeftPureFull) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $rows AS List<Struct<Row: Uint32, Value: String>>;
-
-            SELECT COUNT(*)
-            FROM AS_TABLE($rows) AS tl
-            FULL JOIN Join1 AS tr
-            ON tl.Value = tr.Value;
-        )"), TTxControl::BeginTx().CommitTx(), BuildPureTableParams(db)).GetValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[11u]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(JoinLeftPureExclusion) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $rows AS List<Struct<Row: Uint32, Value: String>>;
-
-            SELECT COUNT(*)
-            FROM AS_TABLE($rows) AS tl
-            EXCLUSION JOIN Join1 AS tr
-            ON tl.Value = tr.Value;
-        )"), TTxControl::BeginTx().CommitTx(), BuildPureTableParams(db)).GetValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[6u]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(JoinLeftPureCross) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $rows AS List<Struct<Row: Uint32, Value: String>>;
-
-            SELECT COUNT(*)
-            FROM AS_TABLE($rows) AS tl
-            CROSS JOIN Join1 AS tr;
-        )"), TTxControl::BeginTx().CommitTx(), BuildPureTableParams(db)).GetValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[36u]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-}
-
+ 
+    Y_UNIT_TEST_NEW_ENGINE(JoinLeftPureInner) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $rows AS List<Struct<Row: Uint32, Value: String>>; 
+ 
+            SELECT COUNT(*) 
+            FROM AS_TABLE($rows) AS tl 
+            INNER JOIN Join1 AS tr 
+            ON tl.Value = tr.Value; 
+        )"), TTxControl::BeginTx().CommitTx(), BuildPureTableParams(db)).GetValueSync(); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[5u]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(JoinLeftPureFull) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $rows AS List<Struct<Row: Uint32, Value: String>>; 
+ 
+            SELECT COUNT(*) 
+            FROM AS_TABLE($rows) AS tl 
+            FULL JOIN Join1 AS tr 
+            ON tl.Value = tr.Value; 
+        )"), TTxControl::BeginTx().CommitTx(), BuildPureTableParams(db)).GetValueSync(); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[11u]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(JoinLeftPureExclusion) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $rows AS List<Struct<Row: Uint32, Value: String>>; 
+ 
+            SELECT COUNT(*) 
+            FROM AS_TABLE($rows) AS tl 
+            EXCLUSION JOIN Join1 AS tr 
+            ON tl.Value = tr.Value; 
+        )"), TTxControl::BeginTx().CommitTx(), BuildPureTableParams(db)).GetValueSync(); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[6u]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(JoinLeftPureCross) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $rows AS List<Struct<Row: Uint32, Value: String>>; 
+ 
+            SELECT COUNT(*) 
+            FROM AS_TABLE($rows) AS tl 
+            CROSS JOIN Join1 AS tr; 
+        )"), TTxControl::BeginTx().CommitTx(), BuildPureTableParams(db)).GetValueSync(); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[36u]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_limits_ut.cpp b/ydb/core/kqp/ut/kqp_limits_ut.cpp
index 0e2478dad7..578dfd9d44 100644
--- a/ydb/core/kqp/ut/kqp_limits_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_limits_ut.cpp
@@ -1,148 +1,148 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-static const ui32 LargeTableShards = 8;
-static const ui32 LargeTableKeysPerShard = 1000000;
-
-static void CreateLargeTable(TKikimrRunner& kikimr, ui32 rowsPerShard, ui32 keyTextSize,
-    ui32 dataTextSize, ui32 batchSizeRows = 100, ui32 fillShardsCount = LargeTableShards)
-{
-    kikimr.GetTestClient().CreateTable("/Root", R"(
-        Name: "LargeTable"
-        Columns { Name: "Key", Type: "Uint64" }
-        Columns { Name: "KeyText", Type: "String" }
-        Columns { Name: "Data", Type: "Int64" }
-        Columns { Name: "DataText", Type: "String" }
-        KeyColumnNames: ["Key", "KeyText"],
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 1000000 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 2000000 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 3000000 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 4000000 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 5000000 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 6000000 } } } }
-        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 7000000 } } } }
-    )");
-
-    auto client = kikimr.GetTableClient();
-
-    for (ui32 shardIdx = 0; shardIdx < fillShardsCount; ++shardIdx) {
-        ui32 rowIndex = 0;
-        while (rowIndex < rowsPerShard) {
-
-            auto rowsBuilder = TValueBuilder();
-            rowsBuilder.BeginList();
-            for (ui32 i = 0; i < batchSizeRows; ++i) {
-                rowsBuilder.AddListItem()
-                    .BeginStruct()
-                    .AddMember("Key")
-                        .OptionalUint64(shardIdx * LargeTableKeysPerShard + rowIndex)
-                    .AddMember("KeyText")
-                        .OptionalString(TString(keyTextSize, '0' + (i + shardIdx) % 10))
-                    .AddMember("Data")
-                        .OptionalInt64(rowIndex)
-                    .AddMember("DataText")
-                        .OptionalString(TString(dataTextSize, '0' + (i + shardIdx + 1) % 10))
-                    .EndStruct();
-
-                ++rowIndex;
-                if (rowIndex == rowsPerShard) {
-                    break;
-                }
-            }
-            rowsBuilder.EndList();
-
-            auto result = client.BulkUpsert("/Root/LargeTable", rowsBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        }
-    }
-}
-
-Y_UNIT_TEST_SUITE(KqpLimits) {
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+static const ui32 LargeTableShards = 8; 
+static const ui32 LargeTableKeysPerShard = 1000000; 
+ 
+static void CreateLargeTable(TKikimrRunner& kikimr, ui32 rowsPerShard, ui32 keyTextSize, 
+    ui32 dataTextSize, ui32 batchSizeRows = 100, ui32 fillShardsCount = LargeTableShards) 
+{ 
+    kikimr.GetTestClient().CreateTable("/Root", R"( 
+        Name: "LargeTable" 
+        Columns { Name: "Key", Type: "Uint64" } 
+        Columns { Name: "KeyText", Type: "String" } 
+        Columns { Name: "Data", Type: "Int64" } 
+        Columns { Name: "DataText", Type: "String" } 
+        KeyColumnNames: ["Key", "KeyText"], 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 1000000 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 2000000 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 3000000 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 4000000 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 5000000 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 6000000 } } } } 
+        SplitBoundary { KeyPrefix { Tuple { Optional { Uint64: 7000000 } } } } 
+    )"); 
+ 
+    auto client = kikimr.GetTableClient(); 
+ 
+    for (ui32 shardIdx = 0; shardIdx < fillShardsCount; ++shardIdx) { 
+        ui32 rowIndex = 0; 
+        while (rowIndex < rowsPerShard) { 
+ 
+            auto rowsBuilder = TValueBuilder(); 
+            rowsBuilder.BeginList(); 
+            for (ui32 i = 0; i < batchSizeRows; ++i) { 
+                rowsBuilder.AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Key") 
+                        .OptionalUint64(shardIdx * LargeTableKeysPerShard + rowIndex) 
+                    .AddMember("KeyText") 
+                        .OptionalString(TString(keyTextSize, '0' + (i + shardIdx) % 10)) 
+                    .AddMember("Data") 
+                        .OptionalInt64(rowIndex) 
+                    .AddMember("DataText") 
+                        .OptionalString(TString(dataTextSize, '0' + (i + shardIdx + 1) % 10)) 
+                    .EndStruct(); 
+ 
+                ++rowIndex; 
+                if (rowIndex == rowsPerShard) { 
+                    break; 
+                } 
+            } 
+            rowsBuilder.EndList(); 
+ 
+            auto result = client.BulkUpsert("/Root/LargeTable", rowsBuilder.Build()).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        } 
+    } 
+} 
+ 
+Y_UNIT_TEST_SUITE(KqpLimits) { 
     Y_UNIT_TEST_NEW_ENGINE(DatashardProgramSize) {
         auto app = NKikimrConfig::TAppConfig();
         app.MutableTableServiceConfig()->MutableResourceManager()->SetMkqlLightProgramMemoryLimit(1'000'000'000);
 
         TKikimrRunner kikimr(app);
-        CreateLargeTable(kikimr, 0, 0, 0);
-
+        CreateLargeTable(kikimr, 0, 0, 0); 
+ 
         kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_SLOW_LOG, NActors::NLog::PRI_ERROR);
 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto paramsBuilder = db.GetParamsBuilder();
-        auto& rowsParam = paramsBuilder.AddParam("$rows");
-
-        rowsParam.BeginList();
-        for (ui32 i = 0; i < 10000; ++i) {
-            rowsParam.AddListItem()
-                .BeginStruct()
-                .AddMember("Key")
-                    .OptionalUint64(i)
-                .AddMember("KeyText")
-                    .OptionalString(TString(5000, '0' + i % 10))
-                .AddMember("Data")
-                    .OptionalInt64(i)
-                .AddMember("DataText")
-                    .OptionalString(TString(16, '0' + (i + 1) % 10))
-                .EndStruct();
-        }
-        rowsParam.EndList();
-        rowsParam.Build();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto paramsBuilder = db.GetParamsBuilder(); 
+        auto& rowsParam = paramsBuilder.AddParam("$rows"); 
+ 
+        rowsParam.BeginList(); 
+        for (ui32 i = 0; i < 10000; ++i) { 
+            rowsParam.AddListItem() 
+                .BeginStruct() 
+                .AddMember("Key") 
+                    .OptionalUint64(i) 
+                .AddMember("KeyText") 
+                    .OptionalString(TString(5000, '0' + i % 10)) 
+                .AddMember("Data") 
+                    .OptionalInt64(i) 
+                .AddMember("DataText") 
+                    .OptionalString(TString(16, '0' + (i + 1) % 10)) 
+                .EndStruct(); 
+        } 
+        rowsParam.EndList(); 
+        rowsParam.Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q1_(R"(
             DECLARE $rows AS List<Struct<Key: Uint64?, KeyText: String?, Data: Int64?, DataText: String?>>;
-
+ 
             UPSERT INTO `/Root/LargeTable`
-            SELECT * FROM AS_TABLE($rows);
+            SELECT * FROM AS_TABLE($rows); 
         )"), TTxControl::BeginTx().CommitTx(), paramsBuilder.Build()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NKikimrIssues::TIssuesIds::SHARD_PROGRAM_SIZE_EXCEEDED));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(DatashardReplySize) {
-        auto app = NKikimrConfig::TAppConfig();
-        auto& queryLimits = *app.MutableTableServiceConfig()->MutableQueryLimits();
-        queryLimits.MutablePhaseLimits()->SetComputeNodeMemoryLimitBytes(1'000'000'000);
-        TKikimrRunner kikimr(app);
-        CreateLargeTable(kikimr, 100, 10, 1'000'000, 1, 2);
-
-        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_SLOW_LOG, NActors::NLog::PRI_ERROR);
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            SELECT * FROM `/Root/LargeTable`;
-        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::UNDETERMINED);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_RESULT_UNAVAILABLE));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(QueryReplySize) {
-        TKikimrRunner kikimr;
-        CreateLargeTable(kikimr, 10, 10, 1'000'000, 1);
-
-        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_SLOW_LOG, NActors::NLog::PRI_ERROR);
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            SELECT * FROM `/Root/LargeTable`;
-        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::UNDETERMINED);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_RESULT_UNAVAILABLE));
-    }
-
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NKikimrIssues::TIssuesIds::SHARD_PROGRAM_SIZE_EXCEEDED)); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(DatashardReplySize) { 
+        auto app = NKikimrConfig::TAppConfig(); 
+        auto& queryLimits = *app.MutableTableServiceConfig()->MutableQueryLimits(); 
+        queryLimits.MutablePhaseLimits()->SetComputeNodeMemoryLimitBytes(1'000'000'000); 
+        TKikimrRunner kikimr(app); 
+        CreateLargeTable(kikimr, 100, 10, 1'000'000, 1, 2); 
+ 
+        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_SLOW_LOG, NActors::NLog::PRI_ERROR); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            SELECT * FROM `/Root/LargeTable`; 
+        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::UNDETERMINED); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_RESULT_UNAVAILABLE)); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(QueryReplySize) { 
+        TKikimrRunner kikimr; 
+        CreateLargeTable(kikimr, 10, 10, 1'000'000, 1); 
+ 
+        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_SLOW_LOG, NActors::NLog::PRI_ERROR); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            SELECT * FROM `/Root/LargeTable`; 
+        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::UNDETERMINED); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_RESULT_UNAVAILABLE)); 
+    } 
+ 
     Y_UNIT_TEST(TooBigQuery) {
         auto app = NKikimrConfig::TAppConfig();
         app.MutableTableServiceConfig()->MutableResourceManager()->SetMkqlLightProgramMemoryLimit(1'000'000'000);
@@ -185,42 +185,42 @@ Y_UNIT_TEST_SUITE(KqpLimits) {
     }
 
     Y_UNIT_TEST_NEW_ENGINE(AffectedShardsLimit) {
-        NKikimrConfig::TAppConfig appConfig;
-        auto& queryLimits = *appConfig.MutableTableServiceConfig()->MutableQueryLimits();
-        queryLimits.MutablePhaseLimits()->SetAffectedShardsLimit(20);
-
-        TKikimrRunner kikimr(appConfig);
-
-        kikimr.GetTestClient().CreateTable("/Root", R"(
-            Name: "ManyShard20"
-            Columns { Name: "Key", Type: "Uint32" }
-            Columns { Name: "Value1", Type: "String" }
-            Columns { Name: "Value2", Type: "Int32" }
-            KeyColumnNames: ["Key"]
-            UniformPartitionsCount: 20
-        )");
-
-        kikimr.GetTestClient().CreateTable("/Root", R"(
-            Name: "ManyShard21"
-            Columns { Name: "Key", Type: "Uint32" }
-            Columns { Name: "Value1", Type: "String" }
-            Columns { Name: "Value2", Type: "Int32" }
-            KeyColumnNames: ["Key"]
-            UniformPartitionsCount: 21
-        )");
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        NKikimrConfig::TAppConfig appConfig; 
+        auto& queryLimits = *appConfig.MutableTableServiceConfig()->MutableQueryLimits(); 
+        queryLimits.MutablePhaseLimits()->SetAffectedShardsLimit(20); 
+ 
+        TKikimrRunner kikimr(appConfig); 
+ 
+        kikimr.GetTestClient().CreateTable("/Root", R"( 
+            Name: "ManyShard20" 
+            Columns { Name: "Key", Type: "Uint32" } 
+            Columns { Name: "Value1", Type: "String" } 
+            Columns { Name: "Value2", Type: "Int32" } 
+            KeyColumnNames: ["Key"] 
+            UniformPartitionsCount: 20 
+        )"); 
+ 
+        kikimr.GetTestClient().CreateTable("/Root", R"( 
+            Name: "ManyShard21" 
+            Columns { Name: "Key", Type: "Uint32" } 
+            Columns { Name: "Value1", Type: "String" } 
+            Columns { Name: "Value2", Type: "Int32" } 
+            KeyColumnNames: ["Key"] 
+            UniformPartitionsCount: 21 
+        )"); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT COUNT(*) FROM `/Root/ManyShard20`
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT COUNT(*) FROM `/Root/ManyShard21`
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+        result.GetIssues().PrintTo(Cerr); 
         if (UseNewEngine) {
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED);
             UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_PRECONDITION_FAILED));
@@ -228,29 +228,29 @@ Y_UNIT_TEST_SUITE(KqpLimits) {
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
             UNIT_ASSERT(HasIssue(result.GetIssues(), NKikimrIssues::TIssuesIds::ENGINE_ERROR));
         }
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(ReadsetCountLimit) {
-        NKikimrConfig::TAppConfig appConfig;
-        auto& queryLimits = *appConfig.MutableTableServiceConfig()->MutableQueryLimits();
-        queryLimits.MutablePhaseLimits()->SetReadsetCountLimit(50);
-
-        TKikimrRunner kikimr(appConfig);
-        CreateLargeTable(kikimr, 10, 10, 100);
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        NKikimrConfig::TAppConfig appConfig; 
+        auto& queryLimits = *appConfig.MutableTableServiceConfig()->MutableQueryLimits(); 
+        queryLimits.MutablePhaseLimits()->SetReadsetCountLimit(50); 
+ 
+        TKikimrRunner kikimr(appConfig); 
+        CreateLargeTable(kikimr, 10, 10, 100); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             UPDATE `/Root/LargeTable`
-            SET Data = CAST(Key AS Int64) + 10
-            WHERE Key < 7000000;
+            SET Data = CAST(Key AS Int64) + 10 
+            WHERE Key < 7000000; 
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             UPDATE `/Root/LargeTable`
-            SET Data = CAST(Key AS Int64) + 10;
+            SET Data = CAST(Key AS Int64) + 10; 
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
         if (UseNewEngine) {
             // TODO: ???
@@ -259,24 +259,24 @@ Y_UNIT_TEST_SUITE(KqpLimits) {
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
             UNIT_ASSERT(HasIssue(result.GetIssues(), NKikimrIssues::TIssuesIds::ENGINE_ERROR));
         }
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(TotalReadSizeLimit) {
-        NKikimrConfig::TAppConfig appConfig;
-        auto& queryLimits = *appConfig.MutableTableServiceConfig()->MutableQueryLimits();
-        queryLimits.MutablePhaseLimits()->SetTotalReadSizeLimitBytes(100'000'000);
-
-        TKikimrRunner kikimr(appConfig);
-        CreateLargeTable(kikimr, 20, 10, 1'000'000, 1);
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        NKikimrConfig::TAppConfig appConfig; 
+        auto& queryLimits = *appConfig.MutableTableServiceConfig()->MutableQueryLimits(); 
+        queryLimits.MutablePhaseLimits()->SetTotalReadSizeLimitBytes(100'000'000); 
+ 
+        TKikimrRunner kikimr(appConfig); 
+        CreateLargeTable(kikimr, 20, 10, 1'000'000, 1); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            SELECT Key, KeyText, SUBSTRING(DataText, 0, 10) AS DataText
+            SELECT Key, KeyText, SUBSTRING(DataText, 0, 10) AS DataText 
             FROM `/Root/LargeTable`;
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+        result.GetIssues().PrintTo(Cerr); 
         if (UseNewEngine) {
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED);
             UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_PRECONDITION_FAILED,
@@ -289,98 +289,98 @@ Y_UNIT_TEST_SUITE(KqpLimits) {
             UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR,
                 [] (const NYql::TIssue& issue) {
                     return issue.Message.Contains("Transaction total read size");
-            }));
+            })); 
         }
-
+ 
         result = session.ExecuteDataQuery(Q_(R"(
-            SELECT Key, KeyText, SUBSTRING(DataText, 0, 10) AS DataText
+            SELECT Key, KeyText, SUBSTRING(DataText, 0, 10) AS DataText 
             FROM `/Root/LargeTable`
-            WHERE Key < 4000000;
+            WHERE Key < 4000000; 
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(ComputeNodeMemoryLimit) {
-        NKikimrConfig::TAppConfig appConfig;
+        NKikimrConfig::TAppConfig appConfig; 
         appConfig.MutableTableServiceConfig()->MutableResourceManager()->SetMkqlLightProgramMemoryLimit(1'000'000'000);
-        auto& queryLimits = *appConfig.MutableTableServiceConfig()->MutableQueryLimits();
-        queryLimits.MutablePhaseLimits()->SetComputeNodeMemoryLimitBytes(100'000'000);
-
-        TKikimrRunner kikimr(appConfig);
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto& queryLimits = *appConfig.MutableTableServiceConfig()->MutableQueryLimits(); 
+        queryLimits.MutablePhaseLimits()->SetComputeNodeMemoryLimitBytes(100'000'000); 
+ 
+        TKikimrRunner kikimr(appConfig); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            SELECT ToDict(
-                ListMap(
-                    ListFromRange(0ul, 5000000ul),
-                    ($x) -> { RETURN AsTuple($x, $x + 1); }
-                )
-            );
+            SELECT ToDict( 
+                ListMap( 
+                    ListFromRange(0ul, 5000000ul), 
+                    ($x) -> { RETURN AsTuple($x, $x + 1); } 
+                ) 
+            ); 
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(),
-            UseNewEngine ? EStatus::PRECONDITION_FAILED : EStatus::GENERIC_ERROR);
-
-        auto issueId = UseNewEngine ? NYql::TIssuesIds::KIKIMR_PRECONDITION_FAILED : NYql::TIssuesIds::DEFAULT_ERROR;
-        UNIT_ASSERT(HasIssue(result.GetIssues(), issueId,
-            [] (const NYql::TIssue& issue) {
-                return issue.Message.Contains("Memory limit exceeded");
-            }));
-    }
-
+        result.GetIssues().PrintTo(Cerr); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), 
+            UseNewEngine ? EStatus::PRECONDITION_FAILED : EStatus::GENERIC_ERROR); 
+ 
+        auto issueId = UseNewEngine ? NYql::TIssuesIds::KIKIMR_PRECONDITION_FAILED : NYql::TIssuesIds::DEFAULT_ERROR; 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), issueId, 
+            [] (const NYql::TIssue& issue) { 
+                return issue.Message.Contains("Memory limit exceeded"); 
+            })); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryExecCancel) {
-        TKikimrRunner kikimr;
-        CreateLargeTable(kikimr, 500000, 10, 100, 5000, 1);
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        CreateLargeTable(kikimr, 500000, 10, 100, 5000, 1); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto prepareResult = session.PrepareDataQuery(Q_(R"(
             SELECT COUNT(*) FROM `/Root/LargeTable` WHERE SUBSTRING(DataText, 50, 5) = "11111";
         )")).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(prepareResult.GetStatus(), EStatus::SUCCESS, prepareResult.GetIssues().ToString());
-        auto dataQuery = prepareResult.GetQuery();
-
-        auto settings = TExecDataQuerySettings()
-            .CancelAfter(TDuration::MilliSeconds(100));
-
-        auto result = dataQuery.Execute(TTxControl::BeginTx().CommitTx(), settings).GetValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::CANCELLED);
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(prepareResult.GetStatus(), EStatus::SUCCESS, prepareResult.GetIssues().ToString()); 
+        auto dataQuery = prepareResult.GetQuery(); 
+ 
+        auto settings = TExecDataQuerySettings() 
+            .CancelAfter(TDuration::MilliSeconds(100)); 
+ 
+        auto result = dataQuery.Execute(TTxControl::BeginTx().CommitTx(), settings).GetValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::CANCELLED); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryExecTimeout) {
-        NKikimrConfig::TAppConfig appConfig;
+        NKikimrConfig::TAppConfig appConfig; 
         appConfig.MutableTableServiceConfig()->MutableResourceManager()->SetMkqlLightProgramMemoryLimit(10'000'000'000);
-
-        TKikimrRunner kikimr(appConfig);
-
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+ 
+        TKikimrRunner kikimr(appConfig); 
+ 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto prepareResult = session.PrepareDataQuery(Q_(R"(
-            SELECT ToDict(
-                ListMap(
-                    ListFromRange(0ul, 10000000ul),
-                    ($x) -> { RETURN AsTuple($x, $x + 1); }
-                )
-            );
+            SELECT ToDict( 
+                ListMap( 
+                    ListFromRange(0ul, 10000000ul), 
+                    ($x) -> { RETURN AsTuple($x, $x + 1); } 
+                ) 
+            ); 
         )")).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(prepareResult.GetStatus(), EStatus::SUCCESS, prepareResult.GetIssues().ToString());
-        auto dataQuery = prepareResult.GetQuery();
-
+        UNIT_ASSERT_VALUES_EQUAL_C(prepareResult.GetStatus(), EStatus::SUCCESS, prepareResult.GetIssues().ToString()); 
+        auto dataQuery = prepareResult.GetQuery(); 
+ 
         auto settings = TExecDataQuerySettings()
             .OperationTimeout(TDuration::MilliSeconds(500));
         auto result = dataQuery.Execute(TTxControl::BeginTx().CommitTx(), settings).GetValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::TIMEOUT);
-    }
-}
-
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::TIMEOUT); 
+    } 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_locks_ut.cpp b/ydb/core/kqp/ut/kqp_locks_ut.cpp
index bd9d9ede5b..b9b227ef29 100644
--- a/ydb/core/kqp/ut/kqp_locks_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_locks_ut.cpp
@@ -1,120 +1,120 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-Y_UNIT_TEST_SUITE(KqpLocks) {
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+Y_UNIT_TEST_SUITE(KqpLocks) { 
     Y_UNIT_TEST_NEW_ENGINE(Invalidate) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-
-        auto session1 = db.CreateSession().GetValueSync().GetSession();
-        auto session2 = db.CreateSession().GetValueSync().GetSession();
-
+ 
+        auto session1 = db.CreateSession().GetValueSync().GetSession(); 
+        auto session2 = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session1.ExecuteDataQuery(Q_(R"(
             UPSERT INTO `/Root/Test`
             SELECT Group + 10U AS Group, Name, Amount, Comment ?? "" || "Updated" AS Comment
             FROM `/Root/Test`
             WHERE Group == 1U AND Name == "Paul";
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto tx1 = result.GetTransaction();
-        UNIT_ASSERT(tx1);
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto tx1 = result.GetTransaction(); 
+        UNIT_ASSERT(tx1); 
+ 
         result = session2.ExecuteDataQuery(Q_(R"(
             UPSERT INTO `/Root/Test` (Group, Name, Comment)
             VALUES (1U, "Paul", "Changed");
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         result = session1.ExecuteDataQuery(Q_(R"(
             UPSERT INTO `/Root/Test` (Group, Name, Comment)
             VALUES (11U, "Sergey", "BadRow");
         )"), TTxControl::Tx(*tx1).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::ABORTED, result.GetIssues().ToString());
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED,
-            [] (const NYql::TIssue& issue) {
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::ABORTED, result.GetIssues().ToString()); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED, 
+            [] (const NYql::TIssue& issue) { 
                 return issue.Message.Contains("/Root/Test");
-            }));
-
+            })); 
+ 
         result = session2.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Test` WHERE Name == "Paul" ORDER BY Group, Name;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[300u];["Changed"];[1u];["Paul"]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[300u];["Changed"];[1u];["Paul"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(InvalidateOnCommit) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-
-        auto session1 = db.CreateSession().GetValueSync().GetSession();
-        auto session2 = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+ 
+        auto session1 = db.CreateSession().GetValueSync().GetSession(); 
+        auto session2 = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session1.ExecuteDataQuery(Q_(R"(
             UPSERT INTO `/Root/Test`
-            SELECT Group + 10U AS Group, Name, Amount, Comment ?? "" || "Updated" AS Comment
+            SELECT Group + 10U AS Group, Name, Amount, Comment ?? "" || "Updated" AS Comment 
             FROM `/Root/Test`
-            WHERE Group == 1U AND Name == "Paul";
+            WHERE Group == 1U AND Name == "Paul"; 
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto tx1 = result.GetTransaction();
-        UNIT_ASSERT(tx1);
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto tx1 = result.GetTransaction(); 
+        UNIT_ASSERT(tx1); 
+ 
         result = session2.ExecuteDataQuery(Q_(R"(
             UPSERT INTO `/Root/Test` (Group, Name, Comment)
-            VALUES (1U, "Paul", "Changed");
+            VALUES (1U, "Paul", "Changed"); 
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto commitResult = tx1->Commit().GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::ABORTED, commitResult.GetIssues().ToString());
-        commitResult.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(HasIssue(commitResult.GetIssues(), NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED,
-            [] (const NYql::TIssue& issue) {
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto commitResult = tx1->Commit().GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::ABORTED, commitResult.GetIssues().ToString()); 
+        commitResult.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(HasIssue(commitResult.GetIssues(), NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED, 
+            [] (const NYql::TIssue& issue) { 
                 return issue.Message.Contains("/Root/Test");
-            }));
-
+            })); 
+ 
         result = session2.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Test` WHERE Name == "Paul" ORDER BY Group, Name;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[300u];["Changed"];[1u];["Paul"]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[300u];["Changed"];[1u];["Paul"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(DifferentKeyUpdate) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-
-        auto session1 = db.CreateSession().GetValueSync().GetSession();
-        auto session2 = db.CreateSession().GetValueSync().GetSession();
-
+ 
+        auto session1 = db.CreateSession().GetValueSync().GetSession(); 
+        auto session2 = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session1.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Test` WHERE Group = 1;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        auto tx1 = result.GetTransaction();
-        UNIT_ASSERT(tx1);
-
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        auto tx1 = result.GetTransaction(); 
+        UNIT_ASSERT(tx1); 
+ 
         result = session2.ExecuteDataQuery(Q_(R"(
             UPSERT INTO `/Root/Test` (Group, Name, Comment)
             VALUES (2U, "Paul", "Changed");
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
         result = session1.ExecuteDataQuery(Q_(R"(
-            SELECT "Nothing";
+            SELECT "Nothing"; 
         )"), TTxControl::Tx(*tx1).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-    }
-}
-
+        UNIT_ASSERT(result.IsSuccess()); 
+    } 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_newengine_flowcontrol_ut.cpp b/ydb/core/kqp/ut/kqp_newengine_flowcontrol_ut.cpp
index 16c89eceb5..c6b6f3de3f 100644
--- a/ydb/core/kqp/ut/kqp_newengine_flowcontrol_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_newengine_flowcontrol_ut.cpp
@@ -72,7 +72,7 @@ void DoFlowControlTest(ui64 limit, bool hasBlockedByCapacity) {
     NYql::NDq::GetDqExecutionSettingsForTests().FlowControl.InFlightBytesOvercommit = 1.0f;
 
     auto settings = NExperimental::TExecuteStreamQuerySettings()
-        .ProfileMode(NExperimental::EStreamQueryProfileMode::Full);
+        .ProfileMode(NExperimental::EStreamQueryProfileMode::Full); 
 
     auto result = db.ExecuteStreamQuery(R"(
             $r = (select * from `/Root/FourShard` where Key > 201);
diff --git a/ydb/core/kqp/ut/kqp_newengine_ut.cpp b/ydb/core/kqp/ut/kqp_newengine_ut.cpp
index 3737687d8d..5838e0ca37 100644
--- a/ydb/core/kqp/ut/kqp_newengine_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_newengine_ut.cpp
@@ -1,12 +1,12 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
-namespace NKikimr::NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
+ 
+namespace NKikimr::NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
 namespace {
 
 TKikimrRunner KikimrRunnerWithSessionActor() {
@@ -18,28 +18,28 @@ TKikimrRunner KikimrRunnerWithSessionActor() {
 
 }
 
-Y_UNIT_TEST_SUITE(KqpNewEngine) {
+Y_UNIT_TEST_SUITE(KqpNewEngine) { 
 
     void TestSimpleSelect(const TKikimrRunner& kikimr) {
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT Value1, Value2, Key FROM [/Root/TwoShard] WHERE Value2 != 0 ORDER BY Key DESC;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
+ 
+        CompareYson(R"( 
+            [ 
                 [["BigThree"];[1];[4000000003u]];
                 [["BigOne"];[-1];[4000000001u]];
                 [["Three"];[1];[3u]];
                 [["One"];[-1];[1u]]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST(SimpleSelectWithSessionActor) {
         return;
         TestSimpleSelect(KikimrRunnerWithSessionActor());
@@ -49,36 +49,36 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         TestSimpleSelect(TKikimrRunner{});
     }
 
-    Y_UNIT_TEST(PkSelect1) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto query = R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $key AS Uint64;
-
+    Y_UNIT_TEST(PkSelect1) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto query = R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $key AS Uint64; 
+ 
             SELECT * FROM `/Root/EightShard` WHERE Key = $key;
-        )";
-
-        auto explainResult = session.ExplainDataQuery(query).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(explainResult.GetStatus(), EStatus::SUCCESS, explainResult.GetIssues().ToString());
-        UNIT_ASSERT_C(explainResult.GetAst().Contains("KqpLookupTable"), explainResult.GetAst());
-
-        auto params = kikimr.GetTableClient().GetParamsBuilder()
-            .AddParam("$key").Uint64(302).Build()
-            .Build();
-
+        )"; 
+ 
+        auto explainResult = session.ExplainDataQuery(query).GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(explainResult.GetStatus(), EStatus::SUCCESS, explainResult.GetIssues().ToString()); 
+        UNIT_ASSERT_C(explainResult.GetAst().Contains("KqpLookupTable"), explainResult.GetAst()); 
+ 
+        auto params = kikimr.GetTableClient().GetParamsBuilder() 
+            .AddParam("$key").Uint64(302).Build() 
+            .Build(); 
+ 
         NYdb::NTable::TExecDataQuerySettings execSettings;
         execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
 
-        auto result = session.ExecuteDataQuery(query,
+        auto result = session.ExecuteDataQuery(query, 
             TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[2];[302u];["Value2"]]])", FormatResultSetYson(result.GetResultSet(0)));
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[2];[302u];["Value2"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
         auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
         UNIT_ASSERT_VALUES_EQUAL(1, stats.query_phases().size()); // no LiteralExecuter phase
         UNIT_ASSERT_VALUES_EQUAL(1, stats.query_phases()[0].table_access().size());
@@ -86,14 +86,14 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         UNIT_ASSERT_VALUES_EQUAL("/Root/EightShard", stats.query_phases()[0].table_access()[0].name());
         UNIT_ASSERT_VALUES_EQUAL(1, stats.query_phases()[0].table_access()[0].partitions_count());
 
-        params = kikimr.GetTableClient().GetParamsBuilder()
-            .AddParam("$key").Uint64(330).Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(query,
+        params = kikimr.GetTableClient().GetParamsBuilder() 
+            .AddParam("$key").Uint64(330).Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(query, 
             TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0)));
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0))); 
 
         stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
         UNIT_ASSERT_VALUES_EQUAL(1, stats.query_phases().size()); // no LiteralExecuter phase
@@ -101,213 +101,213 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         UNIT_ASSERT_VALUES_EQUAL(1, stats.query_phases()[0].affected_shards());
         UNIT_ASSERT_VALUES_EQUAL("/Root/EightShard", stats.query_phases()[0].table_access()[0].name());
         UNIT_ASSERT_VALUES_EQUAL(1, stats.query_phases()[0].table_access()[0].partitions_count());
-    }
-
-    Y_UNIT_TEST(PkSelect2) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto query = R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $group AS Uint32?;
-            DECLARE $name AS String?;
-
+    } 
+ 
+    Y_UNIT_TEST(PkSelect2) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto query = R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $group AS Uint32?; 
+            DECLARE $name AS String?; 
+ 
             SELECT * FROM `/Root/Test` WHERE Group = $group AND Name = $name;
-        )";
-
-        auto explainResult = session.ExplainDataQuery(query).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(explainResult.GetStatus(), EStatus::SUCCESS, explainResult.GetIssues().ToString());
-        UNIT_ASSERT_C(explainResult.GetAst().Contains("KqpLookupTable"), explainResult.GetAst());
-
-        auto params = kikimr.GetTableClient().GetParamsBuilder()
-            .AddParam("$group").OptionalUint32(1).Build()
-            .AddParam("$name").OptionalString("Paul").Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(query,
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[300u];["None"];[1u];["Paul"]]])", FormatResultSetYson(result.GetResultSet(0)));
-
-        params = kikimr.GetTableClient().GetParamsBuilder()
-            .AddParam("$group").OptionalUint32(1).Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(query,
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(PkRangeSelect1) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = kikimr.GetTableClient().GetParamsBuilder()
-            .AddParam("$low")
-                .Uint64(202)
-                .Build()
-            .AddParam("$high")
-                .Uint64(402)
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $low AS Uint64;
-            DECLARE $high AS Uint64;
-
+        )"; 
+ 
+        auto explainResult = session.ExplainDataQuery(query).GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(explainResult.GetStatus(), EStatus::SUCCESS, explainResult.GetIssues().ToString()); 
+        UNIT_ASSERT_C(explainResult.GetAst().Contains("KqpLookupTable"), explainResult.GetAst()); 
+ 
+        auto params = kikimr.GetTableClient().GetParamsBuilder() 
+            .AddParam("$group").OptionalUint32(1).Build() 
+            .AddParam("$name").OptionalString("Paul").Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(query, 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[300u];["None"];[1u];["Paul"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        params = kikimr.GetTableClient().GetParamsBuilder() 
+            .AddParam("$group").OptionalUint32(1).Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(query, 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(PkRangeSelect1) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = kikimr.GetTableClient().GetParamsBuilder() 
+            .AddParam("$low") 
+                .Uint64(202) 
+                .Build() 
+            .AddParam("$high") 
+                .Uint64(402) 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $low AS Uint64; 
+            DECLARE $high AS Uint64; 
+ 
             SELECT * FROM [/Root/EightShard] WHERE Key > $low AND Key < $high ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
         AssertSuccessResult(result);
-
-        CompareYson(R"([
-            [[3];[203u];["Value3"]];
-            [[3];[301u];["Value1"]];
-            [[2];[302u];["Value2"]];
-            [[1];[303u];["Value3"]];
-            [[1];[401u];["Value1"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(PkRangeSelect2) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = kikimr.GetTableClient().GetParamsBuilder()
-            .AddParam("$low")
-                .Uint64(202)
-                .Build()
-            .AddParam("$high")
-                .Uint64(402)
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $low AS Uint64;
-            DECLARE $high AS Uint64;
-
+ 
+        CompareYson(R"([ 
+            [[3];[203u];["Value3"]]; 
+            [[3];[301u];["Value1"]]; 
+            [[2];[302u];["Value2"]]; 
+            [[1];[303u];["Value3"]]; 
+            [[1];[401u];["Value1"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(PkRangeSelect2) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = kikimr.GetTableClient().GetParamsBuilder() 
+            .AddParam("$low") 
+                .Uint64(202) 
+                .Build() 
+            .AddParam("$high") 
+                .Uint64(402) 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $low AS Uint64; 
+            DECLARE $high AS Uint64; 
+ 
             SELECT * FROM [/Root/EightShard] WHERE Key >= $low AND Key <= $high ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
         AssertSuccessResult(result);
-
-        CompareYson(R"([
-            [[1];[202u];["Value2"]];
-            [[3];[203u];["Value3"]];
-            [[3];[301u];["Value1"]];
-            [[2];[302u];["Value2"]];
-            [[1];[303u];["Value3"]];
-            [[1];[401u];["Value1"]];
-            [[3];[402u];["Value2"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(PkRangeSelect3) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = kikimr.GetTableClient().GetParamsBuilder()
-            .AddParam("$low")
-                .Uint64(602)
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $low AS Uint64;
-
+ 
+        CompareYson(R"([ 
+            [[1];[202u];["Value2"]]; 
+            [[3];[203u];["Value3"]]; 
+            [[3];[301u];["Value1"]]; 
+            [[2];[302u];["Value2"]]; 
+            [[1];[303u];["Value3"]]; 
+            [[1];[401u];["Value1"]]; 
+            [[3];[402u];["Value2"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(PkRangeSelect3) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = kikimr.GetTableClient().GetParamsBuilder() 
+            .AddParam("$low") 
+                .Uint64(602) 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $low AS Uint64; 
+ 
             SELECT * FROM [/Root/EightShard] WHERE Key > $low ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
         AssertSuccessResult(result);
-
-        CompareYson(R"([
-            [[1];[603u];["Value3"]];
-            [[1];[701u];["Value1"]];
-            [[3];[702u];["Value2"]];
-            [[2];[703u];["Value3"]];
-            [[2];[801u];["Value1"]];
-            [[1];[802u];["Value2"]];
-            [[3];[803u];["Value3"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(PkRangeSelect4) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = kikimr.GetTableClient().GetParamsBuilder()
-            .AddParam("$high")
-                .Uint64(202)
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $high AS Uint64;
-
+ 
+        CompareYson(R"([ 
+            [[1];[603u];["Value3"]]; 
+            [[1];[701u];["Value1"]]; 
+            [[3];[702u];["Value2"]]; 
+            [[2];[703u];["Value3"]]; 
+            [[2];[801u];["Value1"]]; 
+            [[1];[802u];["Value2"]]; 
+            [[3];[803u];["Value3"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(PkRangeSelect4) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = kikimr.GetTableClient().GetParamsBuilder() 
+            .AddParam("$high") 
+                .Uint64(202) 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $high AS Uint64; 
+ 
             SELECT * FROM [/Root/EightShard] WHERE Key < $high ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
         AssertSuccessResult(result);
-
-        CompareYson(R"([
-            [[1];[101u];["Value1"]];
-            [[3];[102u];["Value2"]];
-            [[2];[103u];["Value3"]];
-            [[2];[201u];["Value1"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(MultiSelect) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        CompareYson(R"([ 
+            [[1];[101u];["Value1"]]; 
+            [[3];[102u];["Value2"]]; 
+            [[2];[103u];["Value3"]]; 
+            [[2];[201u];["Value1"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(MultiSelect) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient();
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/TwoShard] WHERE Value2 = 0 ORDER BY Value1 DESC, Key;
             SELECT * FROM [/Root/Test] WHERE Group = 1 ORDER BY Amount, Group, Name;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[2u];["Two"];[0]];
-            [[4000000002u];["BigTwo"];[0]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        CompareYson(R"([
-            [[300u];["None"];[1u];["Paul"]];
-            [[3500u];["None"];[1u];["Anna"]]
-        ])", FormatResultSetYson(result.GetResultSet(1)));
-
-        result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[2u];["Two"];[0]]; 
+            [[4000000002u];["BigTwo"];[0]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        CompareYson(R"([ 
+            [[300u];["None"];[1u];["Paul"]]; 
+            [[3500u];["None"];[1u];["Anna"]] 
+        ])", FormatResultSetYson(result.GetResultSet(1))); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/Test] WHERE Group = 2 ORDER BY Amount, Group, Name;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[7200u];["None"];[2u];["Tony"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[7200u];["None"];[2u];["Tony"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST(MultiOutput) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
         auto session = db.CreateSession().GetValueSync().GetSession();
 
@@ -331,66 +331,66 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         ])", FormatResultSetYson(result.GetResultSet(1)));
     }
 
-    Y_UNIT_TEST(InShardsWrite) {
-        TKikimrRunner kikimr;
+    Y_UNIT_TEST(InShardsWrite) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             UPSERT INTO [/Root/TwoShard]
             SELECT Key, Value1, Value2 + 1 AS Value2 FROM [/Root/TwoShard];
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        result = session.ExecuteDataQuery(R"(
+ 
+        result = session.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
             SELECT * FROM [/Root/TwoShard] ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [[1u];["One"];[0]];
-                [[2u];["Two"];[1]];
-                [[3u];["Three"];[2]];
-                [[4000000001u];["BigOne"];[0]];
-                [[4000000002u];["BigTwo"];[1]];
-                [[4000000003u];["BigThree"];[2]]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(ShuffleWrite) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        CompareYson(R"( 
+            [ 
+                [[1u];["One"];[0]]; 
+                [[2u];["Two"];[1]]; 
+                [[3u];["Three"];[2]]; 
+                [[4000000001u];["BigOne"];[0]]; 
+                [[4000000002u];["BigTwo"];[1]]; 
+                [[4000000003u];["BigThree"];[2]] 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(ShuffleWrite) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient();
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             UPSERT INTO [/Root/TwoShard]
             SELECT Key - 3u AS Key, Value1, Value2 + 100 AS Value2 FROM [/Root/TwoShard];
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        result = session.ExecuteDataQuery(R"(
+ 
+        result = session.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
             SELECT * FROM [/Root/TwoShard] WHERE Value2 > 10 ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [[0u];["Three"];[101]];
-                [[3999999998u];["BigOne"];[99]];
-                [[3999999999u];["BigTwo"];[100]];
-                [[4000000000u];["BigThree"];[101]];
-                [[4294967294u];["One"];[99]];
-                [[4294967295u];["Two"];[100]]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+ 
+        CompareYson(R"( 
+            [ 
+                [[0u];["Three"];[101]]; 
+                [[3999999998u];["BigOne"];[99]]; 
+                [[3999999999u];["BigTwo"];[100]]; 
+                [[4000000000u];["BigThree"];[101]]; 
+                [[4294967294u];["One"];[99]]; 
+                [[4294967295u];["Two"];[100]] 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST(KeyColumnOrder) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -470,246 +470,246 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         }
     }
 
-    Y_UNIT_TEST(BlindWrite) {
-        TKikimrRunner kikimr;
+    Y_UNIT_TEST(BlindWrite) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
             UPSERT INTO [/Root/TwoShard] (Key, Value1, Value2) VALUES
-                (10u, "One", -10),
-                (20u, "Two", -20);
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+                (10u, "One", -10), 
+                (20u, "Two", -20); 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        result = session.ExecuteDataQuery(R"(
+ 
+        result = session.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
             SELECT * FROM [/Root/TwoShard] WHERE Value2 <= -10 ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [[10u];["One"];[-10]];
-                [[20u];["Two"];[-20]]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(BlindWriteParameters) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key1")
-                .Uint32(10)
-                .Build()
-            .AddParam("$value1")
-                .String("New")
-                .Build()
-            .AddParam("$key2")
-                .Uint32(4000000010u)
-                .Build()
-            .AddParam("$value2")
-                .String("New")
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $key1 AS Uint32;
-            DECLARE $value1 AS String;
-            DECLARE $key2 AS Uint32;
-            DECLARE $value2 AS String;
-
+ 
+        CompareYson(R"( 
+            [ 
+                [[10u];["One"];[-10]]; 
+                [[20u];["Two"];[-20]] 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(BlindWriteParameters) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient();
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key1") 
+                .Uint32(10) 
+                .Build() 
+            .AddParam("$value1") 
+                .String("New") 
+                .Build() 
+            .AddParam("$key2") 
+                .Uint32(4000000010u) 
+                .Build() 
+            .AddParam("$value2") 
+                .String("New") 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $key1 AS Uint32; 
+            DECLARE $value1 AS String; 
+            DECLARE $key2 AS Uint32; 
+            DECLARE $value2 AS String; 
+ 
             UPSERT INTO [/Root/TwoShard] (Key, Value1) VALUES
-                ($key1, $value1),
-                ($key2, $value2);
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(),
-            std::move(params)).ExtractValueSync();
-
+                ($key1, $value1), 
+                ($key2, $value2); 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), 
+            std::move(params)).ExtractValueSync(); 
+ 
         AssertSuccessResult(result);
-
-        result = session.ExecuteDataQuery(R"(
+ 
+        result = session.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
             SELECT * FROM [/Root/TwoShard] WHERE Value1 = "New" ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [[10u];["New"];#];
-                [[4000000010u];["New"];#]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(BlindWriteListParameter) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$items")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                    .AddMember("Key")
-                        .OptionalUint32(10)
-                    .AddMember("Value1")
-                        .OptionalString("New")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                    .AddMember("Key")
-                        .OptionalUint32(4000000010u)
-                    .AddMember("Value1")
-                        .OptionalString("New")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $items AS 'List<Struct<Key:Uint32?, Value1:String?>>';
-
+ 
+        CompareYson(R"( 
+            [ 
+                [[10u];["New"];#]; 
+                [[4000000010u];["New"];#] 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(BlindWriteListParameter) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient();
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$items") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Key") 
+                        .OptionalUint32(10) 
+                    .AddMember("Value1") 
+                        .OptionalString("New") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Key") 
+                        .OptionalUint32(4000000010u) 
+                    .AddMember("Value1") 
+                        .OptionalString("New") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $items AS 'List<Struct<Key:Uint32?, Value1:String?>>'; 
+ 
             UPSERT INTO [/Root/TwoShard]
-            SELECT * FROM AS_TABLE($items);
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), std::move(params)).ExtractValueSync();
+            SELECT * FROM AS_TABLE($items); 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), std::move(params)).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        result = session.ExecuteDataQuery(R"(
+ 
+        result = session.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
             SELECT * FROM [/Root/TwoShard] WHERE Value1 = "New" ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [[10u];["New"];#];
-                [[4000000010u];["New"];#]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(BatchUpload) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto queryText = R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-            DECLARE $items AS
-                'List<Struct<
-                    Key1: Uint32?,
-                    Key2: String?,
-                    Value1: Int64?,
-                    Value2: Double?,
-                    Blob1: String?,
-                    Blob2: String?>>';
-
-            $itemsSource = (
-                SELECT
-                    Item.Key1 AS Key1,
-                    Item.Key2 AS Key2,
-                    Item.Value1 AS Value1,
-                    Item.Value2 AS Value2,
-                    Item.Blob1 AS Blob1,
-                    Item.Blob2 AS Blob2
-                FROM (SELECT $items AS List) FLATTEN BY List AS Item
-            );
-
-            UPSERT INTO [/Root/BatchUpload]
-            SELECT * FROM $itemsSource;
-        )";
-
-        auto query = session.PrepareDataQuery(queryText).ExtractValueSync().GetQuery();
-
-        const ui32 BatchSize = 200;
-        const ui32 BatchCount = 5;
-        const ui32 Blob1Size = 100;
-        const ui32 Blob2Size = 400;
-
-        TDuration totalLatency;
-        for (ui32 i = 0; i < BatchCount; ++i) {
-            auto paramsBuilder = query.GetParamsBuilder();
-            auto& itemsParam = paramsBuilder.AddParam("$items");
-
-            itemsParam.BeginList();
-            for (ui32 i = 0; i < BatchSize; ++i) {
-                itemsParam.AddListItem()
-                    .BeginStruct()
-                    .AddMember("Blob1")
-                        .OptionalString(TString(Blob1Size, '0' + i % 10))
-                    .AddMember("Blob2")
-                        .OptionalString(TString(Blob2Size, '0' + (i + 1) % 10))
-                    .AddMember("Key1")
-                        .OptionalUint32(RandomNumber<ui32>())
-                    .AddMember("Key2")
-                        .OptionalString(CreateGuidAsString())
-                    .AddMember("Value1")
-                        .OptionalInt64(i)
-                    .AddMember("Value2")
-                        .OptionalDouble(RandomNumber<ui64>())
-                    .EndStruct();
-            }
-            itemsParam.EndList();
-            itemsParam.Build();
-
-            auto beginTime = TInstant::Now();
-
-            auto result = query.Execute(TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(),
-                paramsBuilder.Build()).ExtractValueSync();
+ 
+        CompareYson(R"( 
+            [ 
+                [[10u];["New"];#]; 
+                [[4000000010u];["New"];#] 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(BatchUpload) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient();
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto queryText = R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+            DECLARE $items AS 
+                'List<Struct< 
+                    Key1: Uint32?, 
+                    Key2: String?, 
+                    Value1: Int64?, 
+                    Value2: Double?, 
+                    Blob1: String?, 
+                    Blob2: String?>>'; 
+ 
+            $itemsSource = ( 
+                SELECT 
+                    Item.Key1 AS Key1, 
+                    Item.Key2 AS Key2, 
+                    Item.Value1 AS Value1, 
+                    Item.Value2 AS Value2, 
+                    Item.Blob1 AS Blob1, 
+                    Item.Blob2 AS Blob2 
+                FROM (SELECT $items AS List) FLATTEN BY List AS Item 
+            ); 
+ 
+            UPSERT INTO [/Root/BatchUpload] 
+            SELECT * FROM $itemsSource; 
+        )"; 
+ 
+        auto query = session.PrepareDataQuery(queryText).ExtractValueSync().GetQuery(); 
+ 
+        const ui32 BatchSize = 200; 
+        const ui32 BatchCount = 5; 
+        const ui32 Blob1Size = 100; 
+        const ui32 Blob2Size = 400; 
+ 
+        TDuration totalLatency; 
+        for (ui32 i = 0; i < BatchCount; ++i) { 
+            auto paramsBuilder = query.GetParamsBuilder(); 
+            auto& itemsParam = paramsBuilder.AddParam("$items"); 
+ 
+            itemsParam.BeginList(); 
+            for (ui32 i = 0; i < BatchSize; ++i) { 
+                itemsParam.AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Blob1") 
+                        .OptionalString(TString(Blob1Size, '0' + i % 10)) 
+                    .AddMember("Blob2") 
+                        .OptionalString(TString(Blob2Size, '0' + (i + 1) % 10)) 
+                    .AddMember("Key1") 
+                        .OptionalUint32(RandomNumber<ui32>()) 
+                    .AddMember("Key2") 
+                        .OptionalString(CreateGuidAsString()) 
+                    .AddMember("Value1") 
+                        .OptionalInt64(i) 
+                    .AddMember("Value2") 
+                        .OptionalDouble(RandomNumber<ui64>()) 
+                    .EndStruct(); 
+            } 
+            itemsParam.EndList(); 
+            itemsParam.Build(); 
+ 
+            auto beginTime = TInstant::Now(); 
+ 
+            auto result = query.Execute(TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), 
+                paramsBuilder.Build()).ExtractValueSync(); 
             AssertSuccessResult(result);
-
-            auto batchLatency = TInstant::Now() - beginTime;
-            totalLatency += batchLatency;
-        }
-        Cout << "Total upload latency: " << totalLatency << Endl;
-    }
-
+ 
+            auto batchLatency = TInstant::Now() - beginTime; 
+            totalLatency += batchLatency; 
+        } 
+        Cout << "Total upload latency: " << totalLatency << Endl; 
+    } 
+ 
 #if !defined(_ubsan_enabled_)
-    Y_UNIT_TEST(Aggregate) {
-        TKikimrRunner kikimr;
+    Y_UNIT_TEST(Aggregate) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT Data, SUM(Key) AS Total FROM [/Root/EightShard] GROUP BY Data ORDER BY Data;
-        )", TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+        )", TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
         AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [[[1];[3615u]];[[2];[3616u]];[[3];[3617u]]]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(AggregateTuple) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        CompareYson(R"( 
+            [[[1];[3615u]];[[2];[3616u]];[[3];[3617u]]] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(AggregateTuple) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient();
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT Data, Text, COUNT(Key) AS Total FROM [/Root/EightShard] GROUP BY Data, Text ORDER BY Data, Text;
-        )", TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+        )", TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
         AssertSuccessResult(result);
-
-        CompareYson(R"([
-            [[1];["Value1"];3u];[[1];["Value2"];3u];[[1];["Value3"];2u];
-            [[2];["Value1"];3u];[[2];["Value2"];2u];[[2];["Value3"];3u];
-            [[3];["Value1"];2u];[[3];["Value2"];3u];[[3];["Value3"];3u]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
+ 
+        CompareYson(R"([ 
+            [[1];["Value1"];3u];[[1];["Value2"];3u];[[1];["Value3"];2u]; 
+            [[2];["Value1"];3u];[[2];["Value2"];2u];[[2];["Value3"];3u]; 
+            [[3];["Value1"];2u];[[3];["Value2"];3u];[[3];["Value3"];3u] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
 #endif
-
+ 
     Y_UNIT_TEST(PureExpr) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -772,30 +772,30 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         CompareYson(R"([[[101u]]])", FormatResultSetYson(result.GetResultSet(3)));
     }
 
-    Y_UNIT_TEST(LocksSingleShard) {
-        TKikimrRunner kikimr;
+    Y_UNIT_TEST(LocksSingleShard) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session1 = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session1.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+        auto session1 = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session1.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/TwoShard] WHERE Key = 1;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW())).GetValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW())).GetValueSync(); 
         AssertSuccessResult(result);
-
-        auto tx = result.GetTransaction();
-
-        auto session2 = db.CreateSession().GetValueSync().GetSession();
-        result = session2.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        auto tx = result.GetTransaction(); 
+ 
+        auto session2 = db.CreateSession().GetValueSync().GetSession(); 
+        result = session2.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             UPSERT INTO [/Root/TwoShard] (Key, Value1) VALUES(1, "NewValue");
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync(); 
         AssertSuccessResult(result);
-
-        result = session1.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        result = session1.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/TwoShard] WHERE Key = 2;
-        )", TTxControl::Tx(*tx).CommitTx()).GetValueSync();
+        )", TTxControl::Tx(*tx).CommitTx()).GetValueSync(); 
 
         if (kikimr.IsUsingSnapshotReads()) {
             UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
@@ -805,32 +805,32 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::ABORTED);
             UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED));
         }
-    }
-
-    Y_UNIT_TEST(LocksMultiShard) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session1 = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session1.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+    } 
+ 
+    Y_UNIT_TEST(LocksMultiShard) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient();
+        auto session1 = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session1.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/TwoShard];
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW())).GetValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW())).GetValueSync(); 
         AssertSuccessResult(result);
-
-        auto tx = result.GetTransaction();
-
-        auto session2 = db.CreateSession().GetValueSync().GetSession();
-        result = session2.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        auto tx = result.GetTransaction(); 
+ 
+        auto session2 = db.CreateSession().GetValueSync().GetSession(); 
+        result = session2.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             UPSERT INTO [/Root/TwoShard] (Key, Value1) VALUES(101, "NewValue");
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync(); 
         AssertSuccessResult(result);
-
-        result = session1.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        result = session1.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/EightShard];
-        )", TTxControl::Tx(*tx).CommitTx()).GetValueSync();
+        )", TTxControl::Tx(*tx).CommitTx()).GetValueSync(); 
 
         if (kikimr.IsUsingSnapshotReads()) {
             UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
@@ -840,67 +840,67 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::ABORTED);
             UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED));
         }
-    }
-
-    Y_UNIT_TEST(LocksMultiShardOk) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+    } 
+ 
+    Y_UNIT_TEST(LocksMultiShardOk) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient();
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/TwoShard];
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW())).GetValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW())).GetValueSync(); 
         AssertSuccessResult(result);
-
-        auto tx = result.GetTransaction();
-
-        result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        auto tx = result.GetTransaction(); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/EightShard];
-        )", TTxControl::Tx(*tx).CommitTx()).GetValueSync();
+        )", TTxControl::Tx(*tx).CommitTx()).GetValueSync(); 
         AssertSuccessResult(result);
-    }
-
-    Y_UNIT_TEST(LocksEffects) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session1 = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session1.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+    } 
+ 
+    Y_UNIT_TEST(LocksEffects) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient();
+        auto session1 = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session1.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/TwoShard] WHERE Key = 1;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW())).GetValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW())).GetValueSync(); 
         AssertSuccessResult(result);
-
-        auto tx = result.GetTransaction();
-
-        auto session2 = db.CreateSession().GetValueSync().GetSession();
-        result = session2.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        auto tx = result.GetTransaction(); 
+ 
+        auto session2 = db.CreateSession().GetValueSync().GetSession(); 
+        result = session2.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             UPSERT INTO [/Root/TwoShard] (Key, Value1) VALUES(1, "NewValue");
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync(); 
         AssertSuccessResult(result);
-
-        result = session1.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+ 
+        result = session1.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             UPSERT INTO [/Root/TwoShard] (Key,Value1) VALUES(2, "NewValue");
-        )", TTxControl::Tx(*tx).CommitTx()).GetValueSync();
-        UNIT_ASSERT(!result.IsSuccess());
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::ABORTED);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED));
-
-        result = session2.ExecuteDataQuery(R"(
+        )", TTxControl::Tx(*tx).CommitTx()).GetValueSync(); 
+        UNIT_ASSERT(!result.IsSuccess()); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::ABORTED); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED)); 
+ 
+        result = session2.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
             SELECT * FROM [/Root/TwoShard] WHERE Key <= 2;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync(); 
         AssertSuccessResult(result);
-
-        CompareYson(R"([[[1u];["NewValue"];[-1]];[[2u];["Two"];[0]]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+ 
+        CompareYson(R"([[[1u];["NewValue"];[-1]];[[2u];["Two"];[0]]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST(LocksNoMutations) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -1058,71 +1058,71 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0)));
     }
 
-    Y_UNIT_TEST(DeferredEffects) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
+    Y_UNIT_TEST(DeferredEffects) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
             UPSERT INTO [/Root/TwoShard]
             SELECT Key + 1u AS Key, Value1 FROM [/Root/TwoShard];
-        )", TTxControl::BeginTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto tx = result.GetTransaction();
-        UNIT_ASSERT(tx);
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key")
-                .Uint32(100)
-                .Build()
-            .AddParam("$value")
-                .String("New")
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $key AS Uint32;
-            DECLARE $value AS String;
-
+        )", TTxControl::BeginTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto tx = result.GetTransaction(); 
+        UNIT_ASSERT(tx); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key") 
+                .Uint32(100) 
+                .Build() 
+            .AddParam("$value") 
+                .String("New") 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $key AS Uint32; 
+            DECLARE $value AS String; 
+ 
             UPSERT INTO [/Root/TwoShard] (Key, Value1) VALUES
-                ($key, $value);
-        )", TTxControl::Tx(*tx), std::move(params)).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+                ($key, $value); 
+        )", TTxControl::Tx(*tx), std::move(params)).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT COUNT(*) FROM [/Root/TwoShard];
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[6u]])", FormatResultSetYson(result.GetResultSet(0)));
-
-        auto commitResult = tx->Commit().ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::SUCCESS, commitResult.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[6u]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto commitResult = tx->Commit().ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::SUCCESS, commitResult.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
             SELECT * FROM [/Root/TwoShard] ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1u];["One"];[-1]];
-            [[2u];["One"];[0]];
-            [[3u];["Two"];[1]];
-            [[4u];["Three"];#];
-            [[100u];["New"];#];
-            [[4000000001u];["BigOne"];[-1]];
-            [[4000000002u];["BigOne"];[0]];
-            [[4000000003u];["BigTwo"];[1]];
-            [[4000000004u];["BigThree"];#]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1u];["One"];[-1]]; 
+            [[2u];["One"];[0]]; 
+            [[3u];["Two"];[1]]; 
+            [[4u];["Three"];#]; 
+            [[100u];["New"];#]; 
+            [[4000000001u];["BigOne"];[-1]]; 
+            [[4000000002u];["BigOne"];[0]]; 
+            [[4000000003u];["BigTwo"];[1]]; 
+            [[4000000004u];["BigThree"];#] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST(PrunePartitionsByLiteral) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -1153,43 +1153,43 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         UNIT_ASSERT(stats.query_phases(0).duration_us() > 0);
     }
 
-    Y_UNIT_TEST(PrunePartitionsByExpr) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = TParamsBuilder()
-            .AddParam("$key").Uint64(300).Build()
-            .Build();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-            DECLARE $key AS Uint64;
+    Y_UNIT_TEST(PrunePartitionsByExpr) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = TParamsBuilder() 
+            .AddParam("$key").Uint64(300).Build() 
+            .Build(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+            DECLARE $key AS Uint64; 
             SELECT * FROM [/Root/EightShard] WHERE Key = $key + 1;
-        )", TTxControl::BeginTx().CommitTx(), params, execSettings).GetValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([[[3];[301u];["Value1"]]])", FormatResultSetYson(result.GetResultSet(0)));
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2);
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 0);
+        )", TTxControl::BeginTx().CommitTx(), params, execSettings).GetValueSync(); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([[[3];[301u];["Value1"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 0); 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).affected_shards(), 0);
         UNIT_ASSERT(stats.query_phases(0).table_access().size() == 0);
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access().size(), 1);
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access().size(), 1); 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).affected_shards(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).partitions_count(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).name(), "/Root/EightShard");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).reads().rows(), 1);
-        UNIT_ASSERT(stats.query_phases(1).table_access(0).reads().bytes() > 0);
-        UNIT_ASSERT(stats.query_phases(1).duration_us() > 0);
-    }
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).name(), "/Root/EightShard"); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).reads().rows(), 1); 
+        UNIT_ASSERT(stats.query_phases(1).table_access(0).reads().bytes() > 0); 
+        UNIT_ASSERT(stats.query_phases(1).duration_us() > 0); 
+    } 
 
     Y_UNIT_TEST(PruneWritePartitions) {
         TKikimrRunner kikimr;
@@ -1236,111 +1236,111 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         ])", FormatResultSetYson(result.GetResultSet(0)));
     }
 
-    Y_UNIT_TEST(Truncated) {
-        TVector<NKikimrKqp::TKqpSetting> settings;
-        NKikimrKqp::TKqpSetting setting;
-        setting.SetName("_ResultRowsLimit");
-        setting.SetValue("5");
-        settings.push_back(setting);
-
-        TKikimrRunner kikimr(settings);
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
+    Y_UNIT_TEST(Truncated) { 
+        TVector<NKikimrKqp::TKqpSetting> settings; 
+        NKikimrKqp::TKqpSetting setting; 
+        setting.SetName("_ResultRowsLimit"); 
+        setting.SetValue("5"); 
+        settings.push_back(setting); 
+ 
+        TKikimrRunner kikimr(settings); 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM [/Root/EightShard];
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 5);
-        UNIT_ASSERT(result.GetResultSet(0).Truncated());
-    }
-
-    Y_UNIT_TEST(Replace) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 5); 
+        UNIT_ASSERT(result.GetResultSet(0).Truncated()); 
+    } 
+ 
+    Y_UNIT_TEST(Replace) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
             REPLACE INTO [/Root/TwoShard] (Value1, Key) VALUES
-                ("Newvalue 1", 1u),
-                ("Newvalue 5", 5u);
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+                ("Newvalue 1", 1u), 
+                ("Newvalue 5", 5u); 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(R"(
+ 
+        result = session.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
 
             SELECT * FROM [/Root/TwoShard] WHERE Key <= 5 ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1u];["Newvalue 1"];#];
-            [[2u];["Two"];[0]];
-            [[3u];["Three"];[1]];
-            [[5u];["Newvalue 5"];#]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
+ 
+        CompareYson(R"([ 
+            [[1u];["Newvalue 1"];#]; 
+            [[2u];["Two"];[0]]; 
+            [[3u];["Three"];[1]]; 
+            [[5u];["Newvalue 5"];#] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
             REPLACE INTO `/Root/Logs` (App, Ts, Host, Message) VALUES
-                ("new_app_1", 100, "new_app_host_1.search.yandex.net", "Initialize"),
-                ("new_app_1", 200, "new_app_host_2.search.yandex.net", "Initialized");
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+                ("new_app_1", 100, "new_app_host_1.search.yandex.net", "Initialize"), 
+                ("new_app_1", 200, "new_app_host_2.search.yandex.net", "Initialized"); 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(R"(
+ 
+        result = session.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
 
             SELECT * FROM `/Root/Logs` WHERE App = "new_app_1" ORDER BY App, Ts, Host;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [["new_app_1"];["new_app_host_1.search.yandex.net"];["Initialize"];[100]];
-            [["new_app_1"];["new_app_host_2.search.yandex.net"];["Initialized"];[200]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
+ 
+        CompareYson(R"([ 
+            [["new_app_1"];["new_app_host_1.search.yandex.net"];["Initialize"];[100]]; 
+            [["new_app_1"];["new_app_host_2.search.yandex.net"];["Initialized"];[200]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
             REPLACE INTO `/Root/Logs` (App, Host, Message) VALUES
-                ("new_app_2", "host_2_1", "Empty"),
-                ("new_app_2", "host_2_2", "Empty");
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_C(!result.IsSuccess(), result.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST(Join) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            SELECT t1.Key AS Key, t2.Value2 AS Value
+                ("new_app_2", "host_2_1", "Empty"), 
+                ("new_app_2", "host_2_2", "Empty"); 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_C(!result.IsSuccess(), result.GetIssues().ToString()); 
+    } 
+ 
+    Y_UNIT_TEST(Join) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            SELECT t1.Key AS Key, t2.Value2 AS Value 
             FROM [/Root/KeyValue] AS t1
             INNER JOIN [/Root/Join2] AS t2
-            ON t1.Value = t2.Key2
-            WHERE t2.Name == "Name1"
-            ORDER BY Key, Value;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1u];["Value21"]];
-            [[1u];["Value25"]];
-            [[2u];["Value22"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+            ON t1.Value = t2.Key2 
+            WHERE t2.Name == "Name1" 
+            ORDER BY Key, Value; 
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1u];["Value21"]]; 
+            [[1u];["Value25"]]; 
+            [[2u];["Value22"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST(JoinWithParams) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -1373,53 +1373,53 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         ])", FormatResultSetYson(result.GetResultSet(0)));
     }
 
-    Y_UNIT_TEST(JoinIdxLookup) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            $input = (
-                SELECT Key, CAST(Fk21 AS Uint32) AS Fk21
+    Y_UNIT_TEST(JoinIdxLookup) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            $input = ( 
+                SELECT Key, CAST(Fk21 AS Uint32) AS Fk21 
                 FROM [/Root/Join1] WHERE Value == "Value1"
-            );
-
-            SELECT t1.Key AS Key, t2.Value2 AS Value
-            FROM $input AS t1
+            ); 
+ 
+            SELECT t1.Key AS Key, t2.Value2 AS Value 
+            FROM $input AS t1 
             INNER JOIN [/Root/Join2] AS t2
-            ON t1.Fk21 = t2.Key1
-            ORDER BY Key, Value;
-        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1];["Value21"]];
-            [[1];["Value22"]];
-            [[1];["Value23"]];
-            [[2];["Value24"]];
-            [[9];["Value21"]];
-            [[9];["Value22"]];
-            [[9];["Value23"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 3);
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/Join1");
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access().size(), 0);
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(2).table_access().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(2).table_access(0).name(), "/Root/Join2");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(2).table_access(0).reads().rows(), 4);
-    }
-
+            ON t1.Fk21 = t2.Key1 
+            ORDER BY Key, Value; 
+        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1];["Value21"]]; 
+            [[1];["Value22"]]; 
+            [[1];["Value23"]]; 
+            [[2];["Value24"]]; 
+            [[9];["Value21"]]; 
+            [[9];["Value22"]]; 
+            [[9];["Value23"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 3); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/Join1"); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access().size(), 0); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(2).table_access().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(2).table_access(0).name(), "/Root/Join2"); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(2).table_access(0).reads().rows(), 4); 
+    } 
+ 
     Y_UNIT_TEST(LeftSemiJoin) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -1458,51 +1458,51 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
     }
 
     Y_UNIT_TEST_NEW_ENGINE(JoinPure) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q1_(R"(
-            $list1 = AsList(
-                AsStruct("One" AS Key1, 1 AS Value1),
-                AsStruct("Two" AS Key1, 2 AS Value1),
-            );
-
-            $list2 = AsList(
-                AsStruct("One" AS Key2, 10 AS Value2),
-                AsStruct("Three" AS Key2, 30 AS Value2),
-            );
-
-            $list3 = AsList(
-                AsStruct("v1" AS Value3),
-                AsStruct("v2" AS Value3),
-            );
-
+            $list1 = AsList( 
+                AsStruct("One" AS Key1, 1 AS Value1), 
+                AsStruct("Two" AS Key1, 2 AS Value1), 
+            ); 
+ 
+            $list2 = AsList( 
+                AsStruct("One" AS Key2, 10 AS Value2), 
+                AsStruct("Three" AS Key2, 30 AS Value2), 
+            ); 
+ 
+            $list3 = AsList( 
+                AsStruct("v1" AS Value3), 
+                AsStruct("v2" AS Value3), 
+            ); 
+ 
             $list4 = AsList(
                 AsStruct((Cast ("One" AS String?)) AS Key4, 100 AS Value4),
                 AsStruct((Cast ("Two" AS String?)) AS Key4, 200 AS Value4),
                 AsStruct((Cast (Null AS String?))  AS Key4, 300 AS Value4),
             );
 
-            $table1 = SELECT * FROM AS_TABLE($list1);
-            $table2 = SELECT * FROM AS_TABLE($list2);
-            $table3 = SELECT * FROM AS_TABLE($list3);
+            $table1 = SELECT * FROM AS_TABLE($list1); 
+            $table2 = SELECT * FROM AS_TABLE($list2); 
+            $table3 = SELECT * FROM AS_TABLE($list3); 
             $table4 = SELECT * FROM AS_TABLE($list4);
-
-            SELECT * FROM $table1 as t1
-            JOIN $table2 as t2 ON t1.Key1 = t2.Key2
+ 
+            SELECT * FROM $table1 as t1 
+            JOIN $table2 as t2 ON t1.Key1 = t2.Key2 
             JOIN $table4 as t4 ON t1.Key1 = t4.Key4
-            CROSS JOIN $table3 as t3
-            ORDER BY Value3;
+            CROSS JOIN $table3 as t3 
+            ORDER BY Value3; 
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
             ["One";"One";["One"];1;10;"v1";100];
             ["One";"One";["One"];1;10;"v2";100]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(JoinPureUncomparableKeys) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -1526,43 +1526,43 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0)));
     }
 
-    Y_UNIT_TEST_NEW_ENGINE(SelfJoin) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            SELECT a.Key AS Key FROM TwoShard AS a
-            INNER JOIN (SELECT * FROM TwoShard WHERE Value1 = "Three") AS b
-            ON a.Value2 = b.Value2
-            ORDER BY Key;
-        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[3u]];
-            [[4000000003u]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(Update) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-
+    Y_UNIT_TEST_NEW_ENGINE(SelfJoin) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            SELECT a.Key AS Key FROM TwoShard AS a 
+            INNER JOIN (SELECT * FROM TwoShard WHERE Value1 = "Three") AS b 
+            ON a.Value2 = b.Value2 
+            ORDER BY Key; 
+        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[3u]]; 
+            [[4000000003u]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(Update) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
             UPDATE [/Root/TwoShard]
-            SET Value1 = "Updated"
-            WHERE Value2 = 1;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
+            SET Value1 = "Updated" 
+            WHERE Value2 = 1; 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2);
 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
@@ -1610,43 +1610,43 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
 
         auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1);
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/TwoShard");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).updates().rows(), 2);
-        UNIT_ASSERT(stats.query_phases(0).table_access(0).updates().bytes() > 0);
-        UNIT_ASSERT(stats.query_phases(0).duration_us() > 0);
-
-        result = session.ExecuteDataQuery(R"(
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/TwoShard"); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).updates().rows(), 2); 
+        UNIT_ASSERT(stats.query_phases(0).table_access(0).updates().bytes() > 0); 
+        UNIT_ASSERT(stats.query_phases(0).duration_us() > 0); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             PRAGMA kikimr.UseNewEngine = "true";
             SELECT * FROM [/Root/TwoShard] ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1u];["One"];[-1]];
-            [[2u];["Two"];[0]];
-            [[3u];["Updated"];[1]];
-            [[4000000001u];["BigOne"];[-1]];
-            [[4000000002u];["BigTwo"];[0]];
-            [[4000000003u];["Updated"];[1]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1u];["One"];[-1]]; 
+            [[2u];["Two"];[0]]; 
+            [[3u];["Updated"];[1]]; 
+            [[4000000001u];["BigOne"];[-1]]; 
+            [[4000000002u];["BigTwo"];[0]]; 
+            [[4000000003u];["Updated"];[1]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST(Delete) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
         auto session = db.CreateSession().GetValueSync().GetSession();
-
+ 
         NYdb::NTable::TExecDataQuerySettings execSettings;
         execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
+ 
         auto result = session.ExecuteDataQuery(R"(
             PRAGMA kikimr.UseNewEngine = "true";
 
             DELETE FROM [/Root/TwoShard]
-            WHERE Value2 = -1;
+            WHERE Value2 = -1; 
         )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
 
@@ -1657,13 +1657,13 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         UNIT_ASSERT(stats.query_phases(0).duration_us() > 0);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/TwoShard");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 6);
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 6); 
 
         // Phase deleting rows
         UNIT_ASSERT(stats.query_phases(1).duration_us() > 0);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).name(), "/Root/TwoShard");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).deletes().rows(), 2);
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).deletes().rows(), 2); 
 
         result = session.ExecuteDataQuery(R"(
             PRAGMA kikimr.UseNewEngine = "true";
@@ -1692,7 +1692,7 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
             PRAGMA kikimr.UseNewEngine = "true";
 
             DELETE FROM [/Root/TwoShard] ON
-            SELECT * FROM [/Root/TwoShard] WHERE Value2 = 1;
+            SELECT * FROM [/Root/TwoShard] WHERE Value2 = 1; 
         )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
 
@@ -1703,13 +1703,13 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         UNIT_ASSERT(stats.query_phases(0).duration_us() > 0);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/TwoShard");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 6);
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 6); 
 
         // Phase deleting rows
         UNIT_ASSERT(stats.query_phases(1).duration_us() > 0);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).name(), "/Root/TwoShard");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).deletes().rows(), 2);
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(1).table_access(0).deletes().rows(), 2); 
 
         result = session.ExecuteDataQuery(R"(
             PRAGMA kikimr.UseNewEngine = "true";
@@ -2012,169 +2012,169 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
 //            select Key, Value from `/Root/KeyValue` limit $limit ?? 7;
 //        )");
     }
-
-    Y_UNIT_TEST(OnlineRO_Consistent) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_INFO);
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-            SELECT Value1, Value2, Key FROM [/Root/TwoShard] WHERE Value2 != 0 ORDER BY Key DESC;
-        )", TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx()).ExtractValueSync();
-        AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [["BigThree"];[1];[4000000003u]];
-                [["BigOne"];[-1];[4000000001u]];
-                [["Three"];[1];[3u]];
-                [["One"];[-1];[1u]]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(OnlineRO_Inconsistent) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_INFO);
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-            SELECT Value1, Value2, Key FROM [/Root/TwoShard] WHERE Value2 != 0 ORDER BY Key DESC;
-        )", TTxControl::BeginTx(TTxSettings::OnlineRO(TTxOnlineSettings().AllowInconsistentReads(true))).CommitTx())
-            .ExtractValueSync();
-        AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [["BigThree"];[1];[4000000003u]];
-                [["BigOne"];[-1];[4000000001u]];
-                [["Three"];[1];[3u]];
-                [["One"];[-1];[1u]]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(StaleRO) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        AssertSuccessResult(session.ExecuteSchemeQuery(R"(
-            --!syntax_v1
+ 
+    Y_UNIT_TEST(OnlineRO_Consistent) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_INFO); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+            SELECT Value1, Value2, Key FROM [/Root/TwoShard] WHERE Value2 != 0 ORDER BY Key DESC; 
+        )", TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx()).ExtractValueSync(); 
+        AssertSuccessResult(result); 
+ 
+        CompareYson(R"( 
+            [ 
+                [["BigThree"];[1];[4000000003u]]; 
+                [["BigOne"];[-1];[4000000001u]]; 
+                [["Three"];[1];[3u]]; 
+                [["One"];[-1];[1u]] 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(OnlineRO_Inconsistent) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_INFO); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+            SELECT Value1, Value2, Key FROM [/Root/TwoShard] WHERE Value2 != 0 ORDER BY Key DESC; 
+        )", TTxControl::BeginTx(TTxSettings::OnlineRO(TTxOnlineSettings().AllowInconsistentReads(true))).CommitTx()) 
+            .ExtractValueSync(); 
+        AssertSuccessResult(result); 
+ 
+        CompareYson(R"( 
+            [ 
+                [["BigThree"];[1];[4000000003u]]; 
+                [["BigOne"];[-1];[4000000001u]]; 
+                [["Three"];[1];[3u]]; 
+                [["One"];[-1];[1u]] 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(StaleRO) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        AssertSuccessResult(session.ExecuteSchemeQuery(R"( 
+            --!syntax_v1 
             CREATE TABLE `FollowersKv` (
-                Key Uint64,
-                Value String,
-                PRIMARY KEY (Key)
-            )
-            WITH (
-                PARTITION_AT_KEYS = (10, 20, 30),
-                READ_REPLICAS_SETTINGS = "ANY_AZ:1"
-            );
-        )").GetValueSync());
-
-        AssertSuccessResult(session.ExecuteDataQuery(R"(
-            --!syntax_v1
+                Key Uint64, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ) 
+            WITH ( 
+                PARTITION_AT_KEYS = (10, 20, 30), 
+                READ_REPLICAS_SETTINGS = "ANY_AZ:1" 
+            ); 
+        )").GetValueSync()); 
+ 
+        AssertSuccessResult(session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
             PRAGMA kikimr.UseNewEngine = "true";
 
             REPLACE INTO `FollowersKv` (Key, Value) VALUES
-                (1u, "One"),
-                (11u, "Two"),
-                (21u, "Three"),
-                (31u, "Four");
-        )", TTxControl::BeginTx().CommitTx()).GetValueSync());
-
-        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_INFO);
-        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::PIPE_CLIENT, NActors::NLog::PRI_DEBUG);
-        //kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::PIPE_SERVER, NActors::NLog::PRI_DEBUG);
-
+                (1u, "One"), 
+                (11u, "Two"), 
+                (21u, "Three"), 
+                (31u, "Four"); 
+        )", TTxControl::BeginTx().CommitTx()).GetValueSync()); 
+ 
+        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_INFO); 
+        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::PIPE_CLIENT, NActors::NLog::PRI_DEBUG); 
+        //kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::PIPE_SERVER, NActors::NLog::PRI_DEBUG); 
+ 
         // Followers immediate
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM FollowersKv WHERE Key = 21;
-        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync();
-        AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [[21u];["Three"]];
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-
+        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync(); 
+        AssertSuccessResult(result); 
+ 
+        CompareYson(R"( 
+            [ 
+                [[21u];["Three"]]; 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+ 
         // Followers distributed
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
             SELECT * FROM FollowersKv WHERE Value != "One" ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync();
-        AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [[11u];["Two"]];
-                [[21u];["Three"]];
-                [[31u];["Four"]];
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-
+        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync(); 
+        AssertSuccessResult(result); 
+ 
+        CompareYson(R"( 
+            [ 
+                [[11u];["Two"]]; 
+                [[21u];["Three"]]; 
+                [[31u];["Four"]]; 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+ 
         // No followers immediate
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-            SELECT * FROM TwoShard WHERE Key = 2;
-        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync();
-        AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [[2u];["Two"];[0]];
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+            SELECT * FROM TwoShard WHERE Key = 2; 
+        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync(); 
+        AssertSuccessResult(result); 
+ 
+        CompareYson(R"( 
+            [ 
+                [[2u];["Two"];[0]]; 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+ 
         // No followers distributed
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-            SELECT * FROM TwoShard WHERE Value2 < 0 ORDER BY Key;
-        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync();
-        AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [[1u];["One"];[-1]];
-                [[4000000001u];["BigOne"];[-1]]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(StaleRO_Immediate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_INFO);
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-            SELECT Value1, Value2, Key FROM [/Root/TwoShard] WHERE Value2 != 0 ORDER BY Key DESC;
-        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync();
-        AssertSuccessResult(result);
-
-        CompareYson(R"(
-            [
-                [["BigThree"];[1];[4000000003u]];
-                [["BigOne"];[-1];[4000000001u]];
-                [["Three"];[1];[3u]];
-                [["One"];[-1];[1u]]
-            ]
-        )", FormatResultSetYson(result.GetResultSet(0)));
-    }
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+            SELECT * FROM TwoShard WHERE Value2 < 0 ORDER BY Key; 
+        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync(); 
+        AssertSuccessResult(result); 
+ 
+        CompareYson(R"( 
+            [ 
+                [[1u];["One"];[-1]]; 
+                [[4000000001u];["BigOne"];[-1]] 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(StaleRO_Immediate) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::KQP_EXECUTER, NActors::NLog::PRI_INFO); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+            SELECT Value1, Value2, Key FROM [/Root/TwoShard] WHERE Value2 != 0 ORDER BY Key DESC; 
+        )", TTxControl::BeginTx(TTxSettings::StaleRO()).CommitTx()).ExtractValueSync(); 
+        AssertSuccessResult(result); 
+ 
+        CompareYson(R"( 
+            [ 
+                [["BigThree"];[1];[4000000003u]]; 
+                [["BigOne"];[-1];[4000000001u]]; 
+                [["Three"];[1];[3u]]; 
+                [["One"];[-1];[1u]] 
+            ] 
+        )", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
 
     Y_UNIT_TEST(ReadRangeWithParams) {
         TKikimrRunner kikimr;
@@ -2195,32 +2195,32 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         UNIT_ASSERT(range.IsDefined());
     }
 
-    Y_UNIT_TEST(Nondeterministic) { // TODO: KIKIMR-4759
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA Kikimr.UseNewEngine = "true";
-
-            UPSERT INTO `/Root/TwoShard`
-            SELECT
-                100u AS Key,
-                CAST(CurrentUtcTimestamp() AS String) AS Value1;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA Kikimr.UseNewEngine = "true";
-
-            SELECT * FROM `/Root/TwoShard` WHERE Key = 100;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 1);
-    }
-
+    Y_UNIT_TEST(Nondeterministic) { // TODO: KIKIMR-4759 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA Kikimr.UseNewEngine = "true"; 
+ 
+            UPSERT INTO `/Root/TwoShard` 
+            SELECT 
+                100u AS Key, 
+                CAST(CurrentUtcTimestamp() AS String) AS Value1; 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA Kikimr.UseNewEngine = "true"; 
+ 
+            SELECT * FROM `/Root/TwoShard` WHERE Key = 100; 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 1); 
+    } 
+ 
     Y_UNIT_TEST(ScalarFunctions) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -2408,24 +2408,24 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
             CompareYson(item.second, CollectStreamResult(it).ResultSetYson);
         }
     }
-
-    Y_UNIT_TEST(DeleteWithBuiltin) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UseNewEngine = "true";
-            DELETE FROM TwoShard WHERE Value1 != TestUdfs::RandString(10);
-        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_EQUAL(stats.query_phases().size(), 2);
-    }
+ 
+    Y_UNIT_TEST(DeleteWithBuiltin) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+            DELETE FROM TwoShard WHERE Value1 != TestUdfs::RandString(10); 
+        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_EQUAL(stats.query_phases().size(), 2); 
+    } 
 
     Y_UNIT_TEST(MultiEffectsOnSameTable) {
         TKikimrRunner kikimr;
@@ -2454,34 +2454,34 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
         CompareYson("[[[100500u];[100]]]", FormatResultSetYson(result.GetResultSet(0)));
     }
-
-    Y_UNIT_TEST(MultiUsagePrecompute) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            $input1 = SELECT * FROM EightShard WHERE Text = "Value1";
-            $input2 = SELECT * FROM EightShard WHERE Text = "Value2";
-
-            $value = SELECT COUNT(Data) FROM $input1;
-
-            SELECT Data FROM $input2 WHERE Data <= $value
-            ORDER BY Data
-            LIMIT 5;
-
-        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson("[[[1]];[[1]];[[1]];[[2]];[[2]]]", FormatResultSetYson(result.GetResultSet(0)));
-    }
+ 
+    Y_UNIT_TEST(MultiUsagePrecompute) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+ 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            $input1 = SELECT * FROM EightShard WHERE Text = "Value1"; 
+            $input2 = SELECT * FROM EightShard WHERE Text = "Value2"; 
+ 
+            $value = SELECT COUNT(Data) FROM $input1; 
+ 
+            SELECT Data FROM $input2 WHERE Data <= $value 
+            ORDER BY Data 
+            LIMIT 5; 
+ 
+        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson("[[[1]];[[1]];[[1]];[[2]];[[2]]]", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
 
     Y_UNIT_TEST(SqlInFromCompact) {
         TKikimrRunner kikimr;
@@ -2546,57 +2546,57 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
 
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
     }
-
-    Y_UNIT_TEST(PrecomputeKey) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            $key = SELECT Fk22 AS Key2 FROM Join1 WHERE Key = 1;
-
-            SELECT Value2 FROM Join2 WHERE Key1 = 101 AND Key2 = $key;
-        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([[["Value21"]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(UnionAllPure) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            $data =
-                SELECT * FROM KeyValue
-                UNION ALL
-                SELECT 100ul AS Key, "NewValue" AS Value;
-
-            SELECT * FROM $data ORDER BY Key;
-        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1u];["One"]];
-            [[2u];["Two"]];
-            [[100u];["NewValue"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
+ 
+    Y_UNIT_TEST(PrecomputeKey) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+ 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            $key = SELECT Fk22 AS Key2 FROM Join1 WHERE Key = 1; 
+ 
+            SELECT Value2 FROM Join2 WHERE Key1 = 101 AND Key2 = $key; 
+        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([[["Value21"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(UnionAllPure) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+ 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            $data = 
+                SELECT * FROM KeyValue 
+                UNION ALL 
+                SELECT 100ul AS Key, "NewValue" AS Value; 
+ 
+            SELECT * FROM $data ORDER BY Key; 
+        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1u];["One"]]; 
+            [[2u];["Two"]]; 
+            [[100u];["NewValue"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
 
     Y_UNIT_TEST(JoinWithPrecompute) {
         TKikimrRunner kikimr;
@@ -2630,298 +2630,298 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
 
         CompareYson(R"([[106u;[101u];["One"]]])", FormatResultSetYson(result.GetResultSet(0)));
     }
-
-    Y_UNIT_TEST(JoinProjectMulti) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            SELECT t1.Key AS Key, t2.Value2 AS Value, t2.Value2 AS Text
-            FROM KeyValue AS t1
-            INNER JOIN Join2 AS t2
-            ON t1.Value = t2.Key2
-            WHERE t2.Name == "Name1"
-            ORDER BY Key, Value;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1u];["Value21"];["Value21"]];
-            [[1u];["Value25"];["Value25"]];
-            [[2u];["Value22"];["Value22"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(JoinMultiConsumer) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$items")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                    .AddMember("Key")
-                        .String("One")
-                    .AddMember("Text")
-                        .String("Text1")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $items AS List<Struct<
-                Key: String,
-                Text: String
-            >>;
-
-            $list = SELECT * FROM AS_TABLE($items);
-
-            $data = SELECT * FROM KeyValue WHERE Value != "Two";
-
-            SELECT t1.Key AS Key, t2.Text AS Text
-            FROM $data AS t1
-            INNER JOIN $list AS t2
-            ON t1.Value = t2.Key
-            ORDER BY Key, Text;
-
-            UPSERT INTO KeyValue
-            SELECT Key + 1 AS Key, Value FROM $data;
-        )", TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1u];"Text1"]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(UpsertEmptyInput) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto param = db.GetParamsBuilder()
-            .AddParam("$rows")
-                .EmptyList(
-                    TTypeBuilder()
-                        .BeginStruct()
-                            .AddMember("Key").BeginOptional().Primitive(EPrimitiveType::Uint32).EndOptional()
-                            .AddMember("Value1").BeginOptional().Primitive(EPrimitiveType::String).EndOptional()
-                            .AddMember("Value2").BeginOptional().Primitive(EPrimitiveType::Int32).EndOptional()
-                        .EndStruct()
-                    .Build()
-                )
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $rows AS List<Struct<
-                Key : Uint32?,
-                Value1 : String?,
-                Value2 : Int32?
-            >>;
-
-            UPSERT INTO `/Root/TwoShard`
-            SELECT * FROM AS_TABLE($rows);
-        )", TTxControl::BeginTx().CommitTx(), param).ExtractValueSync();
-        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST(DeleteByKey) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto params = TParamsBuilder()
-            .AddParam("$group").Uint32(1).Build()
-            .AddParam("$name").String("Paul").Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $group AS Uint32;
-            DECLARE $name AS String;
-
-            DELETE FROM Test WHERE Group = $group AND Name = $name;
-        )", TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/Test", {
-            .ExpectedReads = 0,
-            .ExpectedDeletes = 1,
-        });
-
-        params = TParamsBuilder()
-            .AddParam("$groups")
-                .BeginList()
-                .AddListItem().Uint32(2)
-                .AddListItem().Uint32(3)
-                .EndList()
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $groups AS List<Uint32>;
-
-            DELETE FROM Test WHERE Group IN $groups;
-        )", TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/Test", {
-            .ExpectedReads = 1,
-            .ExpectedDeletes = 1,
-        });
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            SELECT * FROM Test;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-
-        CompareYson(R"([
-            [[3500u];["None"];[1u];["Anna"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        params = TParamsBuilder()
-            .AddParam("$keys")
-                .BeginList()
-                .AddListItem().Uint32(1)
-                .AddListItem().Uint32(2)
-                .EndList()
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            DECLARE $keys AS List<Uint32>;
-
-            DELETE FROM TwoShard WHERE Key IN $keys;
-        )", TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/TwoShard", {
-            .ExpectedReads = 0,
-            .ExpectedDeletes = 2,
-        });
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            SELECT * FROM TwoShard WHERE Key < 10;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-
-        CompareYson(R"([
-            [[3u];["Three"];[1]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(DeleteWithInputMultiConsumption) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA Kikimr.UseNewEngine = "true";
-
-            $keys = SELECT Fk21 AS Key1, Fk22 AS Key2 FROM Join1 WHERE Value = "Value1";
-
-            DELETE FROM Join2 ON
-            SELECT * FROM $keys;
-
-            SELECT COUNT(*) FROM $keys;
-        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/Join1", {
-            .ExpectedReads = 9,
-        });
-
-        AssertTableStats(result, "/Root/Join2", {
-            .ExpectedDeletes = 3,
-        });
-
-        CompareYson(R"([
-            [3u]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            SELECT * FROM Join2 WHERE Key1 = 101 ORDER BY Key1, Key2;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[101u];["Three"];["Name3"];["Value23"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(DeleteWithInputMultiConsumptionLimit) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA Kikimr.UseNewEngine = "true";
-
-            $keys =
-                SELECT Group, Name, Amount FROM Test
-                WHERE Amount > 1000
-                ORDER BY Group, Name
-                LIMIT 1;
-
-            DELETE FROM Test ON
-            SELECT Group, Name FROM $keys;
-
-            DELETE FROM Test ON
-            SELECT Group, "Paul" AS Name FROM $keys;
-
-            SELECT * FROM $keys;
-        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        AssertTableStats(result, "/Root/Test", {
-            .ExpectedReads = 2,
-            .ExpectedDeletes = 2,
-        });
-
-        CompareYson(R"([
-            [[3500u];[1u];["Anna"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
+ 
+    Y_UNIT_TEST(JoinProjectMulti) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            SELECT t1.Key AS Key, t2.Value2 AS Value, t2.Value2 AS Text 
+            FROM KeyValue AS t1 
+            INNER JOIN Join2 AS t2 
+            ON t1.Value = t2.Key2 
+            WHERE t2.Name == "Name1" 
+            ORDER BY Key, Value; 
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1u];["Value21"];["Value21"]]; 
+            [[1u];["Value25"];["Value25"]]; 
+            [[2u];["Value22"];["Value22"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(JoinMultiConsumer) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$items") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Key") 
+                        .String("One") 
+                    .AddMember("Text") 
+                        .String("Text1") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $items AS List<Struct< 
+                Key: String, 
+                Text: String 
+            >>; 
+ 
+            $list = SELECT * FROM AS_TABLE($items); 
+ 
+            $data = SELECT * FROM KeyValue WHERE Value != "Two"; 
+ 
+            SELECT t1.Key AS Key, t2.Text AS Text 
+            FROM $data AS t1 
+            INNER JOIN $list AS t2 
+            ON t1.Value = t2.Key 
+            ORDER BY Key, Text; 
+ 
+            UPSERT INTO KeyValue 
+            SELECT Key + 1 AS Key, Value FROM $data; 
+        )", TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1u];"Text1"] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(UpsertEmptyInput) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto param = db.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .EmptyList( 
+                    TTypeBuilder() 
+                        .BeginStruct() 
+                            .AddMember("Key").BeginOptional().Primitive(EPrimitiveType::Uint32).EndOptional() 
+                            .AddMember("Value1").BeginOptional().Primitive(EPrimitiveType::String).EndOptional() 
+                            .AddMember("Value2").BeginOptional().Primitive(EPrimitiveType::Int32).EndOptional() 
+                        .EndStruct() 
+                    .Build() 
+                ) 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $rows AS List<Struct< 
+                Key : Uint32?, 
+                Value1 : String?, 
+                Value2 : Int32? 
+            >>; 
+ 
+            UPSERT INTO `/Root/TwoShard` 
+            SELECT * FROM AS_TABLE($rows); 
+        )", TTxControl::BeginTx().CommitTx(), param).ExtractValueSync(); 
+        UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString()); 
+    } 
+ 
+    Y_UNIT_TEST(DeleteByKey) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto params = TParamsBuilder() 
+            .AddParam("$group").Uint32(1).Build() 
+            .AddParam("$name").String("Paul").Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $group AS Uint32; 
+            DECLARE $name AS String; 
+ 
+            DELETE FROM Test WHERE Group = $group AND Name = $name; 
+        )", TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/Test", { 
+            .ExpectedReads = 0, 
+            .ExpectedDeletes = 1, 
+        }); 
+ 
+        params = TParamsBuilder() 
+            .AddParam("$groups") 
+                .BeginList() 
+                .AddListItem().Uint32(2) 
+                .AddListItem().Uint32(3) 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $groups AS List<Uint32>; 
+ 
+            DELETE FROM Test WHERE Group IN $groups; 
+        )", TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/Test", { 
+            .ExpectedReads = 1, 
+            .ExpectedDeletes = 1, 
+        }); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            SELECT * FROM Test; 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+ 
+        CompareYson(R"([ 
+            [[3500u];["None"];[1u];["Anna"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        params = TParamsBuilder() 
+            .AddParam("$keys") 
+                .BeginList() 
+                .AddListItem().Uint32(1) 
+                .AddListItem().Uint32(2) 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            DECLARE $keys AS List<Uint32>; 
+ 
+            DELETE FROM TwoShard WHERE Key IN $keys; 
+        )", TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/TwoShard", { 
+            .ExpectedReads = 0, 
+            .ExpectedDeletes = 2, 
+        }); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            SELECT * FROM TwoShard WHERE Key < 10; 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+ 
+        CompareYson(R"([ 
+            [[3u];["Three"];[1]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(DeleteWithInputMultiConsumption) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA Kikimr.UseNewEngine = "true"; 
+ 
+            $keys = SELECT Fk21 AS Key1, Fk22 AS Key2 FROM Join1 WHERE Value = "Value1"; 
+ 
+            DELETE FROM Join2 ON 
+            SELECT * FROM $keys; 
+ 
+            SELECT COUNT(*) FROM $keys; 
+        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/Join1", { 
+            .ExpectedReads = 9, 
+        }); 
+ 
+        AssertTableStats(result, "/Root/Join2", { 
+            .ExpectedDeletes = 3, 
+        }); 
+ 
+        CompareYson(R"([ 
+            [3u] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            SELECT * FROM Join2 WHERE Key1 = 101 ORDER BY Key1, Key2; 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[101u];["Three"];["Name3"];["Value23"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(DeleteWithInputMultiConsumptionLimit) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA Kikimr.UseNewEngine = "true"; 
+ 
+            $keys = 
+                SELECT Group, Name, Amount FROM Test 
+                WHERE Amount > 1000 
+                ORDER BY Group, Name 
+                LIMIT 1; 
+ 
+            DELETE FROM Test ON 
+            SELECT Group, Name FROM $keys; 
+ 
+            DELETE FROM Test ON 
+            SELECT Group, "Paul" AS Name FROM $keys; 
+ 
+            SELECT * FROM $keys; 
+        )", TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        AssertTableStats(result, "/Root/Test", { 
+            .ExpectedReads = 2, 
+            .ExpectedDeletes = 2, 
+        }); 
+ 
+        CompareYson(R"([ 
+            [[3500u];[1u];["Anna"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
 
     // https://st.yandex-team.ru/KIKIMR-14022
     Y_UNIT_TEST(JoinSameKey) {
@@ -2969,33 +2969,33 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
             [101;[101u];["Two"];["Name1"];["Value22"]]
         ])", FormatResultSetYson(result.GetResultSet(0)));
     }
-
-    Y_UNIT_TEST(AsyncIndexUpdate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto schemeResult = session.ExecuteSchemeQuery(R"(
-            --!syntax_v1
-
-            CREATE TABLE TestTable (
-                Key Int64,
-                Data Uint32,
-                Value Utf8,
-                PRIMARY KEY (Key),
-                INDEX AsyncIndex GLOBAL ASYNC ON (Data, Value)
-            );
-        )").GetValueSync();
-        UNIT_ASSERT_C(schemeResult.IsSuccess(), schemeResult.GetIssues().ToString());
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UseNewEngine = "true";
-
-            UPDATE TestTable SET Data = 10 WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-    }
+ 
+    Y_UNIT_TEST(AsyncIndexUpdate) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto schemeResult = session.ExecuteSchemeQuery(R"( 
+            --!syntax_v1 
+ 
+            CREATE TABLE TestTable ( 
+                Key Int64, 
+                Data Uint32, 
+                Value Utf8, 
+                PRIMARY KEY (Key), 
+                INDEX AsyncIndex GLOBAL ASYNC ON (Data, Value) 
+            ); 
+        )").GetValueSync(); 
+        UNIT_ASSERT_C(schemeResult.IsSuccess(), schemeResult.GetIssues().ToString()); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UseNewEngine = "true"; 
+ 
+            UPDATE TestTable SET Data = 10 WHERE Key = 1; 
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+    } 
 
     Y_UNIT_TEST(DuplicatedResults) {
         TKikimrRunner kikimr;
@@ -3019,6 +3019,6 @@ Y_UNIT_TEST_SUITE(KqpNewEngine) {
         CompareYson(R"([[[1u];["One"]];[[2u];["Two"]]])", FormatResultSetYson(result.GetResultSet(3)));
         CompareYson(R"([[[3500u];["None"];[1u];["Anna"]];[[300u];["None"];[1u];["Paul"]];[[7200u];["None"];[2u];["Tony"]]])", FormatResultSetYson(result.GetResultSet(4)));
     }
-}
-
-} // namespace NKikimr::NKqp
+} 
+ 
+} // namespace NKikimr::NKqp 
diff --git a/ydb/core/kqp/ut/kqp_olap_ut.cpp b/ydb/core/kqp/ut/kqp_olap_ut.cpp
index 908fc34a13..db32be6f2f 100644
--- a/ydb/core/kqp/ut/kqp_olap_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_olap_ut.cpp
@@ -782,15 +782,15 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
             CompareYson(result, R"([[23000u;]])");
         }
     }
-
-    Y_UNIT_TEST(PushdownFilter) {
+ 
+    Y_UNIT_TEST(PushdownFilter) { 
         static bool enableLog = false;
 
         auto doTest = [](std::optional<bool> viaSettings, std::optional<bool> viaPragma, bool pushdownPresent) {
             auto settings = TKikimrSettings()
                 .SetWithSampleTables(false)
                 .SetEnableOlapSchemaOperations(true);
-
+ 
             if (enableLog) {
                 Cerr << "Run test:" << Endl;
                 Cerr << "viaSettings is " << (viaSettings.has_value() ? "" : "not ") << "present.";
@@ -814,22 +814,22 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
             }
 
             TKikimrRunner kikimr(settings);
-            kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::TX_COLUMNSHARD, NActors::NLog::PRI_DEBUG);
-
-            auto client = kikimr.GetTableClient();
-
-            CreateTestOlapTable(kikimr);
-            WriteTestData(kikimr, "/Root/olapStore/olapTable", 0, 1000000, 10);
-
+            kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::TX_COLUMNSHARD, NActors::NLog::PRI_DEBUG); 
+ 
+            auto client = kikimr.GetTableClient(); 
+ 
+            CreateTestOlapTable(kikimr); 
+            WriteTestData(kikimr, "/Root/olapStore/olapTable", 0, 1000000, 10); 
+ 
             TStreamExecScanQuerySettings scanSettings;
             scanSettings.Explain(true);
 
-            {
+            { 
                 TString query = TString(R"(
-                    --!syntax_v1
-                    SELECT * FROM `/Root/olapStore/olapTable` WHERE resource_id = "5"u;
+                    --!syntax_v1 
+                    SELECT * FROM `/Root/olapStore/olapTable` WHERE resource_id = "5"u; 
                 )");
-
+ 
                 if (viaPragma.has_value()) {
                     TString pragma = TString(R"(
                         PRAGMA Kikimr.KqpPushOlapProcess = "<ENABLE_PUSH>";
@@ -840,9 +840,9 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
 
                 auto it = client.StreamExecuteScanQuery(query).GetValueSync();
 
-                UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-                TString result = StreamResultToYson(it);
-
+                UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString()); 
+                TString result = StreamResultToYson(it); 
+ 
                 CompareYson(result, R"([[
                     [0];
                     ["some prefix xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"];
@@ -863,9 +863,9 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
                 }
 
                 UNIT_ASSERT(pushdown.IsDefined());
-            }
-        };
-
+            } 
+        }; 
+ 
         TVector<std::tuple<std::optional<bool>, std::optional<bool>, bool>> testData = {
             {std::nullopt, std::nullopt, false},
             {false, std::nullopt, false},
@@ -880,7 +880,7 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
         for (auto &data: testData) {
             doTest(std::get<0>(data), std::get<1>(data), std::get<2>(data));
         }
-    }
+    } 
 
     Y_UNIT_TEST(PKDescScan) {
         auto settings = TKikimrSettings()
diff --git a/ydb/core/kqp/ut/kqp_params_ut.cpp b/ydb/core/kqp/ut/kqp_params_ut.cpp
index 1eee111329..0087894617 100644
--- a/ydb/core/kqp/ut/kqp_params_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_params_ut.cpp
@@ -1,235 +1,235 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-Y_UNIT_TEST_SUITE(KqpParams) {
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+Y_UNIT_TEST_SUITE(KqpParams) { 
     Y_UNIT_TEST_NEW_ENGINE(RowsList) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = session.PrepareDataQuery(Q1_(R"(
             DECLARE $rows AS List<Struct<Group: Uint32?, Name: String?, Amount: Uint64?, Comment: String?>>;
-
+ 
             UPSERT INTO `/Root/Test`
-            SELECT Group, Name, Amount FROM AS_TABLE($rows);
+            SELECT Group, Name, Amount FROM AS_TABLE($rows); 
         )")).ExtractValueSync().GetQuery();
-
-        auto params = query.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Amount").OptionalUint64(1000)
-                        .AddMember("Comment").OptionalString("New")
-                        .AddMember("Group").OptionalUint32(137)
-                        .AddMember("Name").OptionalString("Sergey")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Amount").OptionalUint64(2000)
-                        .AddMember("Comment").OptionalString("New")
-                        .AddMember("Group").OptionalUint32(137)
-                        .AddMember("Name").OptionalString("Boris")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .Build();
-
-        auto result = query.Execute(
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(),
-            std::move(params)).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
+ 
+        auto params = query.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Amount").OptionalUint64(1000) 
+                        .AddMember("Comment").OptionalString("New") 
+                        .AddMember("Group").OptionalUint32(137) 
+                        .AddMember("Name").OptionalString("Sergey") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Amount").OptionalUint64(2000) 
+                        .AddMember("Comment").OptionalString("New") 
+                        .AddMember("Group").OptionalUint32(137) 
+                        .AddMember("Name").OptionalString("Boris") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        auto result = query.Execute( 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), 
+            std::move(params)).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Test` WHERE Group = 137;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([
-            [[2000u];#;[137u];["Boris"]];
-            [[1000u];#;[137u];["Sergey"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(MissingParameter) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$name")
-                .String("Sergey")
-                .Build()
-            .Build();
-
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([ 
+            [[2000u];#;[137u];["Boris"]]; 
+            [[1000u];#;[137u];["Sergey"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(MissingParameter) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$name") 
+                .String("Sergey") 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            DECLARE $group AS Uint32;
-            DECLARE $name AS String;
-
+            DECLARE $group AS Uint32; 
+            DECLARE $name AS String; 
+ 
             SELECT * FROM `/Root/Test` WHERE Group = $group AND Name = $name;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-
+ 
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::BAD_REQUEST, result.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(BadParameterType) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$name")
-                .String("Sergey")
-                .Build()
-            .AddParam("$group")
-                .Int32(1)
-                .Build()
-            .Build();
-
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(BadParameterType) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$name") 
+                .String("Sergey") 
+                .Build() 
+            .AddParam("$group") 
+                .Int32(1) 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $group AS Uint32;
-            DECLARE $name AS String;
-
+            DECLARE $group AS Uint32; 
+            DECLARE $name AS String; 
+ 
             SELECT * FROM `/Root/Test` WHERE Group = $group AND Name = $name;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-
+ 
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::BAD_REQUEST, result.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(DefaultParameterValue) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$value1")
-                .OptionalUint32(11)
-                .Build()
-            .Build();
-
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(DefaultParameterValue) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$value1") 
+                .OptionalUint32(11) 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q1_(R"(
             DECLARE $value1 AS Uint32?;
             DECLARE $value2 AS String?;
-
-            SELECT $value1, $value2;
+ 
+            SELECT $value1, $value2; 
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[11u];#]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(ParameterTypes) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$ParamBool").Bool(true).Build()
-            .AddParam("$ParamByte").Uint8(5).Build()
-            .AddParam("$ParamInt32").Int32(-10).Build()
-            .AddParam("$ParamUint32").Uint32(10).Build()
-            .AddParam("$ParamInt64").Int64(-20).Build()
-            .AddParam("$ParamUint64").Uint64(20).Build()
-            .AddParam("$ParamFloat").Float(30.5).Build()
-            .AddParam("$ParamDouble").Double(40.5).Build()
-            .AddParam("$ParamString").String("StringValue").Build()
-            .AddParam("$ParamUtf8").Utf8("Utf8Value").Build()
-            .AddParam("$ParamYson").Yson("[{Value=50}]").Build()
-            .AddParam("$ParamJson").Json("[{\"Value\":60}]").Build()
-            .AddParam("$ParamDate").Date(TInstant::ParseIso8601("2020-01-10")).Build()
-            .AddParam("$ParamDatetime").Datetime(TInstant::ParseIso8601("2020-01-11 15:04:53")).Build()
-            .AddParam("$ParamTimestamp").Timestamp(TInstant::ParseIso8601("2020-01-12 21:18:37")).Build()
-            .AddParam("$ParamInterval").Interval(3600).Build()
-            .AddParam("$ParamOpt").OptionalString("Opt").Build()
-            .AddParam("$ParamTuple")
-                .BeginTuple()
-                .AddElement().Utf8("Tuple0")
-                .AddElement().Int32(1)
-                .EndTuple()
-                .Build()
-            .AddParam("$ParamList")
-                .BeginList()
-                .AddListItem().Uint64(17)
-                .AddListItem().Uint64(19)
-                .EndList()
-                .Build()
-            .AddParam("$ParamEmptyList")
-                .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint64).Build())
-                .Build()
-            .AddParam("$ParamStruct")
-                .BeginStruct()
-                .AddMember("Name").Utf8("Paul")
-                .AddMember("Value").Int64(-5)
-                .EndStruct()
-                .Build()
-            .AddParam("$ParamDict")
-                .BeginDict()
-                .AddDictItem()
-                    .DictKey().String("Key1")
-                    .DictPayload().Uint32(10)
-                .AddDictItem()
-                    .DictKey().String("Key2")
-                    .DictPayload().Uint32(20)
-                .EndDict()
-                .Build()
-            .Build();
-
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[11u];#]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(ParameterTypes) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$ParamBool").Bool(true).Build() 
+            .AddParam("$ParamByte").Uint8(5).Build() 
+            .AddParam("$ParamInt32").Int32(-10).Build() 
+            .AddParam("$ParamUint32").Uint32(10).Build() 
+            .AddParam("$ParamInt64").Int64(-20).Build() 
+            .AddParam("$ParamUint64").Uint64(20).Build() 
+            .AddParam("$ParamFloat").Float(30.5).Build() 
+            .AddParam("$ParamDouble").Double(40.5).Build() 
+            .AddParam("$ParamString").String("StringValue").Build() 
+            .AddParam("$ParamUtf8").Utf8("Utf8Value").Build() 
+            .AddParam("$ParamYson").Yson("[{Value=50}]").Build() 
+            .AddParam("$ParamJson").Json("[{\"Value\":60}]").Build() 
+            .AddParam("$ParamDate").Date(TInstant::ParseIso8601("2020-01-10")).Build() 
+            .AddParam("$ParamDatetime").Datetime(TInstant::ParseIso8601("2020-01-11 15:04:53")).Build() 
+            .AddParam("$ParamTimestamp").Timestamp(TInstant::ParseIso8601("2020-01-12 21:18:37")).Build() 
+            .AddParam("$ParamInterval").Interval(3600).Build() 
+            .AddParam("$ParamOpt").OptionalString("Opt").Build() 
+            .AddParam("$ParamTuple") 
+                .BeginTuple() 
+                .AddElement().Utf8("Tuple0") 
+                .AddElement().Int32(1) 
+                .EndTuple() 
+                .Build() 
+            .AddParam("$ParamList") 
+                .BeginList() 
+                .AddListItem().Uint64(17) 
+                .AddListItem().Uint64(19) 
+                .EndList() 
+                .Build() 
+            .AddParam("$ParamEmptyList") 
+                .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint64).Build()) 
+                .Build() 
+            .AddParam("$ParamStruct") 
+                .BeginStruct() 
+                .AddMember("Name").Utf8("Paul") 
+                .AddMember("Value").Int64(-5) 
+                .EndStruct() 
+                .Build() 
+            .AddParam("$ParamDict") 
+                .BeginDict() 
+                .AddDictItem() 
+                    .DictKey().String("Key1") 
+                    .DictPayload().Uint32(10) 
+                .AddDictItem() 
+                    .DictKey().String("Key2") 
+                    .DictPayload().Uint32(20) 
+                .EndDict() 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $ParamBool AS Bool;
-            DECLARE $ParamByte AS Uint8;
-            DECLARE $ParamInt32 AS Int32;
-            DECLARE $ParamUint32 AS Uint32;
-            DECLARE $ParamInt64 AS Int64;
-            DECLARE $ParamUint64 AS Uint64;
-            DECLARE $ParamFloat AS Float;
-            DECLARE $ParamDouble AS Double;
-            DECLARE $ParamString AS String;
-            DECLARE $ParamUtf8 AS Utf8;
-            DECLARE $ParamYson AS Yson;
-            DECLARE $ParamJson AS Json;
-            DECLARE $ParamDate AS Date;
-            DECLARE $ParamDatetime AS Datetime;
-            DECLARE $ParamTimestamp AS Timestamp;
-            DECLARE $ParamInterval AS Interval;
-
+            DECLARE $ParamBool AS Bool; 
+            DECLARE $ParamByte AS Uint8; 
+            DECLARE $ParamInt32 AS Int32; 
+            DECLARE $ParamUint32 AS Uint32; 
+            DECLARE $ParamInt64 AS Int64; 
+            DECLARE $ParamUint64 AS Uint64; 
+            DECLARE $ParamFloat AS Float; 
+            DECLARE $ParamDouble AS Double; 
+            DECLARE $ParamString AS String; 
+            DECLARE $ParamUtf8 AS Utf8; 
+            DECLARE $ParamYson AS Yson; 
+            DECLARE $ParamJson AS Json; 
+            DECLARE $ParamDate AS Date; 
+            DECLARE $ParamDatetime AS Datetime; 
+            DECLARE $ParamTimestamp AS Timestamp; 
+            DECLARE $ParamInterval AS Interval; 
+ 
             DECLARE $ParamOpt AS String?;
             DECLARE $ParamTuple AS Tuple<Utf8, Int32>;
             DECLARE $ParamList AS List<Uint64>;
             DECLARE $ParamEmptyList AS List<Uint64>;
             DECLARE $ParamStruct AS Struct<Name:Utf8,Value:Int64>;
             DECLARE $ParamDict AS Dict<String,Uint32>;
-
-            SELECT
-                $ParamBool AS ValueBool,
-                $ParamByte AS ValueByte,
-                $ParamInt32 AS ValueInt32,
-                $ParamUint32 AS ValueUint32,
-                $ParamInt64 AS ValueInt64,
-                $ParamUint64 AS ValueUint64,
-                $ParamFloat AS ValueFloat,
-                $ParamDouble AS ValueDouble,
-                $ParamString AS ValueString,
-                $ParamUtf8 AS ValueUtf8,
-                $ParamYson AS ValueYson,
-                $ParamJson AS ValueJson,
-                $ParamDate AS ValueDate,
-                $ParamDatetime AS ValueDatetime,
-                $ParamTimestamp AS ValueTimestamp,
-                $ParamInterval AS ValueInterval,
-                $ParamOpt AS ValueOpt,
-                $ParamTuple AS ValueTuple,
-                $ParamList AS ValueList,
-                $ParamEmptyList AS ValueEmptyList,
-                $ParamStruct AS ValueStruct,
-                $ParamDict AS ValueDict;
+ 
+            SELECT 
+                $ParamBool AS ValueBool, 
+                $ParamByte AS ValueByte, 
+                $ParamInt32 AS ValueInt32, 
+                $ParamUint32 AS ValueUint32, 
+                $ParamInt64 AS ValueInt64, 
+                $ParamUint64 AS ValueUint64, 
+                $ParamFloat AS ValueFloat, 
+                $ParamDouble AS ValueDouble, 
+                $ParamString AS ValueString, 
+                $ParamUtf8 AS ValueUtf8, 
+                $ParamYson AS ValueYson, 
+                $ParamJson AS ValueJson, 
+                $ParamDate AS ValueDate, 
+                $ParamDatetime AS ValueDatetime, 
+                $ParamTimestamp AS ValueTimestamp, 
+                $ParamInterval AS ValueInterval, 
+                $ParamOpt AS ValueOpt, 
+                $ParamTuple AS ValueTuple, 
+                $ParamList AS ValueList, 
+                $ParamEmptyList AS ValueEmptyList, 
+                $ParamStruct AS ValueStruct, 
+                $ParamDict AS ValueDict; 
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
 
         auto actual = ReformatYson(FormatResultSetYson(result.GetResultSet(0)));
         auto expected1 = ReformatYson(R"([[
@@ -244,47 +244,47 @@ Y_UNIT_TEST_SUITE(KqpParams) {
         ]])");
 
         UNIT_ASSERT_C(actual == expected1 || actual == expected2, "expected: " << expected1 << ", got: " << actual);
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(InvalidJson) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto schemeResult = session.ExecuteSchemeQuery(R"(
-            --!syntax_v1
-
-            CREATE TABLE TestJson (
-                Key Int32,
-                Value Json,
-                PRIMARY KEY (Key)
-            ) WITH (
-                PARTITION_AT_KEYS = (10)
-            );
-        )").GetValueSync();
-        UNIT_ASSERT_C(schemeResult.IsSuccess(), schemeResult.GetIssues().ToString());
-
-        auto params = kikimr.GetTableClient().GetParamsBuilder()
-            .AddParam("$key1").Int32(5).Build()
-            .AddParam("$value1").Json("{'bad': 5}").Build()
-            .AddParam("$key2").Int32(15).Build()
-            .AddParam("$value2").Json("{\"ok\": \"15\"}").Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $key1 AS Int32;
-            DECLARE $value1 AS Json;
-            DECLARE $key2 AS Int32;
-            DECLARE $value2 AS Json;
-
-            UPSERT INTO TestJson (Key, Value) VALUES
-                ($key1, $value1),
-                ($key2, $value2);
-        )"), TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
-    }
-}
-
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(InvalidJson) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto schemeResult = session.ExecuteSchemeQuery(R"( 
+            --!syntax_v1 
+ 
+            CREATE TABLE TestJson ( 
+                Key Int32, 
+                Value Json, 
+                PRIMARY KEY (Key) 
+            ) WITH ( 
+                PARTITION_AT_KEYS = (10) 
+            ); 
+        )").GetValueSync(); 
+        UNIT_ASSERT_C(schemeResult.IsSuccess(), schemeResult.GetIssues().ToString()); 
+ 
+        auto params = kikimr.GetTableClient().GetParamsBuilder() 
+            .AddParam("$key1").Int32(5).Build() 
+            .AddParam("$value1").Json("{'bad': 5}").Build() 
+            .AddParam("$key2").Int32(15).Build() 
+            .AddParam("$value2").Json("{\"ok\": \"15\"}").Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $key1 AS Int32; 
+            DECLARE $value1 AS Json; 
+            DECLARE $key2 AS Int32; 
+            DECLARE $value2 AS Json; 
+ 
+            UPSERT INTO TestJson (Key, Value) VALUES 
+                ($key1, $value1), 
+                ($key2, $value2); 
+        )"), TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST); 
+    } 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_pragma_ut.cpp b/ydb/core/kqp/ut/kqp_pragma_ut.cpp
index cdf99e4043..44e50400b8 100644
--- a/ydb/core/kqp/ut/kqp_pragma_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_pragma_ut.cpp
@@ -1,74 +1,74 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/public/sdk/cpp/client/draft/ydb_scripting.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-Y_UNIT_TEST_SUITE(KqpPragma) {
-    Y_UNIT_TEST(Static) {
-        TKikimrRunner kikimr;
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+Y_UNIT_TEST_SUITE(KqpPragma) { 
+    Y_UNIT_TEST(Static) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UnwrapReadTableValues = "true";
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UnwrapReadTableValues = "true"; 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([[1u;"One"]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([[1u;"One"]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(Runtime) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            PRAGMA kikimr.IsolationLevel = "ReadCommitted";
+            PRAGMA kikimr.IsolationLevel = "ReadCommitted"; 
             SELECT * FROM `/Root/KeyValue` WHERE Key = 1;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_PRAGMA_NOT_SUPPORTED));
-    }
-
+ 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_PRAGMA_NOT_SUPPORTED)); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(Auth) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            PRAGMA kikimr.Auth = "default_kikimr";
+            PRAGMA kikimr.Auth = "default_kikimr"; 
             SELECT * FROM `/Root/KeyValue` WHERE Key = 1;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_PRAGMA_NOT_SUPPORTED));
-    }
-
-    Y_UNIT_TEST(ResetPerQuery) {
-        TKikimrRunner kikimr;
+ 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), NYdb::EStatus::GENERIC_ERROR); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_PRAGMA_NOT_SUPPORTED)); 
+    } 
+ 
+    Y_UNIT_TEST(ResetPerQuery) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
-            PRAGMA kikimr.UnwrapReadTableValues = "true";
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            PRAGMA kikimr.UnwrapReadTableValues = "true"; 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-        CompareYson(R"([[1u;"One"]])", FormatResultSetYson(result.GetResultSet(0)));
-
-        result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+        CompareYson(R"([[1u;"One"]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-        CompareYson(R"([[[1u];["One"]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+        CompareYson(R"([[[1u];["One"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
 
     Y_UNIT_TEST(OrderedColumns) {
         TKikimrRunner kikimr;
@@ -96,7 +96,7 @@ Y_UNIT_TEST_SUITE(KqpPragma) {
             [[3u];[2u];[1u]]
         ])", FormatResultSetYson(result.GetResultSet(0)));
     }
-}
-
-} // namspace NKqp
-} // namespace NKikimr
+} 
+ 
+} // namspace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_query_ut.cpp b/ydb/core/kqp/ut/kqp_query_ut.cpp
index 5ef6d18f38..77a3d8e9b0 100644
--- a/ydb/core/kqp/ut/kqp_query_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_query_ut.cpp
@@ -1,88 +1,88 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/core/tx/datashard/datashard_failpoints.h>
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.h>
 #include <ydb/core/kqp/counters/kqp_counters.h>
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
+ 
 #include <ydb/library/yql/ast/yql_ast.h>
 #include <ydb/library/yql/ast/yql_expr.h>
 #include <ydb/library/yql/core/yql_expr_optimize.h>
-
+ 
 #include <library/cpp/json/json_reader.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-Y_UNIT_TEST_SUITE(KqpQuery) {
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+Y_UNIT_TEST_SUITE(KqpQuery) { 
     Y_UNIT_TEST_NEW_ENGINE(PreparedQueryInvalidate) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto prepareResult = session.PrepareDataQuery(Q_(R"(
             SELECT * FROM `/Root/Test`
         )")).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(prepareResult.GetStatus(), EStatus::SUCCESS);
-
-        auto query = prepareResult.GetQuery();
-
-        auto result = query.Execute(TTxControl::BeginTx().CommitTx()).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-
+        UNIT_ASSERT_VALUES_EQUAL(prepareResult.GetStatus(), EStatus::SUCCESS); 
+ 
+        auto query = prepareResult.GetQuery(); 
+ 
+        auto result = query.Execute(TTxControl::BeginTx().CommitTx()).GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+ 
         auto alterResult = session.AlterTable("/Root/Test",
-            TAlterTableSettings()
-                .AppendDropColumns("Comment")
-        ).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(alterResult.GetStatus(), EStatus::SUCCESS);
-
-        ui32 retries = 0;
-        do {
-            ++retries;
-            if (retries > 5) {
-                UNIT_FAIL("Too many retries.");
-            }
-
-            result = query.Execute(TTxControl::BeginTx().CommitTx()).GetValueSync();
-        } while (result.GetStatus() == EStatus::UNAVAILABLE || result.GetStatus() == EStatus::ABORTED);
-
-        result.GetIssues().PrintTo(Cerr);
+            TAlterTableSettings() 
+                .AppendDropColumns("Comment") 
+        ).GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(alterResult.GetStatus(), EStatus::SUCCESS); 
+ 
+        ui32 retries = 0; 
+        do { 
+            ++retries; 
+            if (retries > 5) { 
+                UNIT_FAIL("Too many retries."); 
+            } 
+ 
+            result = query.Execute(TTxControl::BeginTx().CommitTx()).GetValueSync(); 
+        } while (result.GetStatus() == EStatus::UNAVAILABLE || result.GetStatus() == EStatus::ABORTED); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
         UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
 
         TKqpCounters counters(kikimr.GetTestServer().GetRuntime()->GetAppData().Counters);
         UNIT_ASSERT_VALUES_EQUAL(counters.RecompileRequestGet()->Val(), 1);
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryCache) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
             SELECT * FROM `/Root/Test`;
         )");
-
-        auto txControl = TTxControl::BeginTx().CommitTx();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.KeepInQueryCache(true);
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(query, txControl, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-        auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), false);
-
-        result = session.ExecuteDataQuery(query, txControl, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-
-        stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), true);
-    }
-
+ 
+        auto txControl = TTxControl::BeginTx().CommitTx(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.KeepInQueryCache(true); 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(query, txControl, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+        auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), false); 
+ 
+        result = session.ExecuteDataQuery(query, txControl, execSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+ 
+        stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), true); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryCacheTtl) {
         NKikimrConfig::TAppConfig appConfig;
         appConfig.MutableTableServiceConfig()->SetCompileQueryCacheTTLSec(2);
@@ -132,152 +132,152 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
     }
 
     Y_UNIT_TEST_NEW_ENGINE(QueryCacheInvalidate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
             SELECT * FROM `/Root/Test`;
         )");
-
-        auto txControl = TTxControl::BeginTx().CommitTx();
-
-        auto result = session.ExecuteDataQuery(query, txControl, TExecDataQuerySettings().KeepInQueryCache(true))
-            .ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto dataQuery = result.GetQuery();
-        UNIT_ASSERT(dataQuery);
-
-        auto alterResult = session.AlterTable("/Root/Test", TAlterTableSettings().AppendDropColumns("Comment"))
-            .ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(alterResult.GetStatus(), EStatus::SUCCESS, alterResult.GetIssues().ToString());
-
-        result = dataQuery->Execute(txControl).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync();
+ 
+        auto txControl = TTxControl::BeginTx().CommitTx(); 
+ 
+        auto result = session.ExecuteDataQuery(query, txControl, TExecDataQuerySettings().KeepInQueryCache(true)) 
+            .ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto dataQuery = result.GetQuery(); 
+        UNIT_ASSERT(dataQuery); 
+ 
+        auto alterResult = session.AlterTable("/Root/Test", TAlterTableSettings().AppendDropColumns("Comment")) 
+            .ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(alterResult.GetStatus(), EStatus::SUCCESS, alterResult.GetIssues().ToString()); 
+ 
+        result = dataQuery->Execute(txControl).ExtractValueSync(); 
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+ 
+        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
 
         TKqpCounters counters(kikimr.GetTestServer().GetRuntime()->GetAppData().Counters);
         UNIT_ASSERT_VALUES_EQUAL(counters.RecompileRequestGet()->Val(), 1);
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryCachePermissionsLoss) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto setPermissions = [&](bool allow) {
-            NYdb::NScheme::TPermissions permissions("user0@builtin",
-                {"ydb.deprecated.describe_schema", "ydb.deprecated.select_row"}
-            );
-
-            auto permissionsSettings = allow
-                ? NYdb::NScheme::TModifyPermissionsSettings().AddGrantPermissions(permissions)
-                : NYdb::NScheme::TModifyPermissionsSettings().AddRevokePermissions(permissions);
-
-            auto schemeClient = kikimr.GetSchemeClient();
-            auto result = schemeClient.ModifyPermissions("/Root/Test", permissionsSettings).ExtractValueSync();
-            AssertSuccessResult(result);
-        };
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto setPermissions = [&](bool allow) { 
+            NYdb::NScheme::TPermissions permissions("user0@builtin", 
+                {"ydb.deprecated.describe_schema", "ydb.deprecated.select_row"} 
+            ); 
+ 
+            auto permissionsSettings = allow 
+                ? NYdb::NScheme::TModifyPermissionsSettings().AddGrantPermissions(permissions) 
+                : NYdb::NScheme::TModifyPermissionsSettings().AddRevokePermissions(permissions); 
+ 
+            auto schemeClient = kikimr.GetSchemeClient(); 
+            auto result = schemeClient.ModifyPermissions("/Root/Test", permissionsSettings).ExtractValueSync(); 
+            AssertSuccessResult(result); 
+        }; 
+ 
         auto query = Q_(R"(
             SELECT * FROM `/Root/Test`
         )");
-
-        setPermissions(true);
-        {
-            auto driverConfig = TDriverConfig()
-                .SetEndpoint(kikimr.GetEndpoint())
-                .SetAuthToken("user0@builtin");
-            auto driver = TDriver(driverConfig);
+ 
+        setPermissions(true); 
+        { 
+            auto driverConfig = TDriverConfig() 
+                .SetEndpoint(kikimr.GetEndpoint()) 
+                .SetAuthToken("user0@builtin"); 
+            auto driver = TDriver(driverConfig); 
             auto db = NYdb::NTable::TTableClient(driver);
-
-            auto session = db.CreateSession().GetValueSync().GetSession();
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        }
-
-        setPermissions(false);
-        {
-            auto driverConfig = TDriverConfig()
-                .SetEndpoint(kikimr.GetEndpoint())
-                .SetAuthToken("user0@builtin");
-            auto driver = TDriver(driverConfig);
+ 
+            auto session = db.CreateSession().GetValueSync().GetSession(); 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        } 
+ 
+        setPermissions(false); 
+        { 
+            auto driverConfig = TDriverConfig() 
+                .SetEndpoint(kikimr.GetEndpoint()) 
+                .SetAuthToken("user0@builtin"); 
+            auto driver = TDriver(driverConfig); 
             auto db = NYdb::NTable::TTableClient(driver);
-
-            auto session = db.CreateSession().GetValueSync().GetSession();
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR);
-        }
-    }
-
+ 
+            auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR); 
+        } 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryTimeout) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
             SELECT * FROM `/Root/TwoShard`;
         )");
-
-        auto txControl = TTxControl::BeginTx().CommitTx();
-
+ 
+        auto txControl = TTxControl::BeginTx().CommitTx(); 
+ 
         NDataShard::gSkipRepliesFailPoint.Enable(-1, -1, 1);
-
-        auto result = session.ExecuteDataQuery(
-            query,
-            txControl,
-            TExecDataQuerySettings()
-                .OperationTimeout(TDuration::MilliSeconds(50))
-        ).ExtractValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::TIMEOUT);
-
+ 
+        auto result = session.ExecuteDataQuery( 
+            query, 
+            txControl, 
+            TExecDataQuerySettings() 
+                .OperationTimeout(TDuration::MilliSeconds(50)) 
+        ).ExtractValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::TIMEOUT); 
+ 
         NDataShard::gSkipRepliesFailPoint.Disable();
-
+ 
         // Check session is ready or busy
-        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync();
+        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync(); 
         UNIT_ASSERT_C(result.GetStatus() == EStatus::SUCCESS || result.GetStatus() == EStatus::SESSION_BUSY, result.GetIssues().ToString());
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryTimeoutImmediate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
             SELECT * FROM `/Root/TwoShard` WHERE Key == 1;
         )");
-
-        auto txControl = TTxControl::BeginTx().CommitTx();
-
+ 
+        auto txControl = TTxControl::BeginTx().CommitTx(); 
+ 
         NDataShard::gSkipRepliesFailPoint.Enable(-1, -1, 1);
-
-        auto result = session.ExecuteDataQuery(
-            query,
-            txControl,
-            TExecDataQuerySettings()
-                .OperationTimeout(TDuration::MilliSeconds(50))
-        ).ExtractValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::TIMEOUT);
-
+ 
+        auto result = session.ExecuteDataQuery( 
+            query, 
+            txControl, 
+            TExecDataQuerySettings() 
+                .OperationTimeout(TDuration::MilliSeconds(50)) 
+        ).ExtractValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::TIMEOUT); 
+ 
         NDataShard::gSkipRepliesFailPoint.Disable();
-
+ 
         // Check session is ready or busy (both possible)
-        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync();
+        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync(); 
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus() == EStatus::SUCCESS || result.GetStatus() == EStatus::SESSION_BUSY, true, result.GetIssues().ToString());
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryClientTimeout) {
         TStringStream logStream;
-
+ 
         {
             TKikimrRunner kikimr(
                 TKikimrSettings()
@@ -286,15 +286,15 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
             auto session = db.CreateSession().GetValueSync().GetSession();
 
             kikimr.GetTestServer().GetRuntime()->SetLogPriority(NKikimrServices::GRPC_SERVER, NActors::NLog::PRI_DEBUG);
-
+ 
             auto query = Q_(R"(
                 SELECT * FROM `/Root/TwoShard`;
             )");
-
+ 
             auto txControl = TTxControl::BeginTx().CommitTx();
-
+ 
             NDataShard::gSkipRepliesFailPoint.Enable(-1, -1, 1);
-
+ 
             auto result = session.ExecuteDataQuery(
                 query,
                 txControl,
@@ -302,7 +302,7 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
                     .UseClientTimeoutForOperation(false)
                     .ClientTimeout(TDuration::Seconds(3))
             ).ExtractValueSync();
-
+ 
             result.GetIssues().PrintTo(Cerr);
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::CLIENT_DEADLINE_EXCEEDED);
 
@@ -328,225 +328,225 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
 
         UNIT_ASSERT(v);
         UNIT_ASSERT_C(v <= 3, "got " << v);
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryCancel) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
             SELECT * FROM `/Root/TwoShard`
         )");
-
-        auto txControl = TTxControl::BeginTx().CommitTx();
-
+ 
+        auto txControl = TTxControl::BeginTx().CommitTx(); 
+ 
         NDataShard::gCancelTxFailPoint.Enable(-1, -1, 1);
-
-        auto result = session.ExecuteDataQuery(
-            query,
-            txControl
-        ).ExtractValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::CANCELLED);
-
+ 
+        auto result = session.ExecuteDataQuery( 
+            query, 
+            txControl 
+        ).ExtractValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::CANCELLED); 
+ 
         NDataShard::gCancelTxFailPoint.Disable();
-
-        // Check session is ready
-        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-    }
-
+ 
+        // Check session is ready 
+        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryCancelImmediate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
             SELECT * FROM `/Root/TwoShard` WHERE Key == 1;
         )");
-
-        auto txControl = TTxControl::BeginTx().CommitTx();
-
+ 
+        auto txControl = TTxControl::BeginTx().CommitTx(); 
+ 
         NDataShard::gCancelTxFailPoint.Enable(-1, -1, 0);
-
-        auto result = session.ExecuteDataQuery(
-            query,
-            txControl
-        ).ExtractValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::CANCELLED);
-
+ 
+        auto result = session.ExecuteDataQuery( 
+            query, 
+            txControl 
+        ).ExtractValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::CANCELLED); 
+ 
         NDataShard::gCancelTxFailPoint.Disable();
-
-        // Check session is ready
-        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-    }
-
+ 
+        // Check session is ready 
+        result = session.ExecuteDataQuery(query, txControl).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryCancelWrite) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
             UPSERT INTO `/Root/TwoShard` (Key, Value1) VALUES
-                (4, "Four"),
-                (4000000000u, "BigZero");
+                (4, "Four"), 
+                (4000000000u, "BigZero"); 
         )");
-
-        auto txControl = TTxControl::BeginTx().CommitTx();
-
+ 
+        auto txControl = TTxControl::BeginTx().CommitTx(); 
+ 
         NDataShard::gCancelTxFailPoint.Enable(-1, -1, 0);
-
-        auto result = session.ExecuteDataQuery(
-            query,
-            txControl
-        ).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+ 
+        auto result = session.ExecuteDataQuery( 
+            query, 
+            txControl 
+        ).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         NDataShard::gCancelTxFailPoint.Disable();
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryCancelWriteImmediate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
             UPSERT INTO `/Root/TwoShard` (Key, Value1) VALUES
-                (4, "Four");
+                (4, "Four"); 
         )");
-
-        auto txControl = TTxControl::BeginTx().CommitTx();
-
+ 
+        auto txControl = TTxControl::BeginTx().CommitTx(); 
+ 
         NDataShard::gCancelTxFailPoint.Enable(-1, -1, 0);
-
-        auto result = session.ExecuteDataQuery(
-            query,
-            txControl
-        ).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+ 
+        auto result = session.ExecuteDataQuery( 
+            query, 
+            txControl 
+        ).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         NDataShard::gCancelTxFailPoint.Disable();
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryResultsTruncated) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
             CREATE TABLE `/Root/Tmp` (
-                Key Uint64,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-        )").GetValueSync().IsSuccess());
-
-        const ui32 RowsCount = 1000;
-
+                Key Uint64, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+        )").GetValueSync().IsSuccess()); 
+ 
+        const ui32 RowsCount = 1000; 
+ 
         auto replaceQuery = Q1_(R"(
-            DECLARE $rows AS
+            DECLARE $rows AS 
                 List<Struct<
-                    Key: Uint64?,
-                    Value: String?
+                    Key: Uint64?, 
+                    Value: String? 
                 >>;
-
+ 
             REPLACE INTO `/Root/Tmp`
-            SELECT * FROM AS_TABLE($rows);
+            SELECT * FROM AS_TABLE($rows); 
         )");
-
-        {
-            auto paramsBuilder = session.GetParamsBuilder();
-            auto& rowsParam = paramsBuilder.AddParam("$rows");
-
-            rowsParam.BeginList();
-            for (ui32 i = 0; i < RowsCount; ++i) {
-                rowsParam.AddListItem()
-                    .BeginStruct()
-                    .AddMember("Key")
-                        .OptionalUint64(i)
-                    .AddMember("Value")
-                        .OptionalString(ToString(i))
-                    .EndStruct();
-            }
-            rowsParam.EndList();
-            rowsParam.Build();
-
-            auto result = session.ExecuteDataQuery(replaceQuery, TTxControl::BeginTx().CommitTx(),
-                paramsBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        }
-
+ 
+        { 
+            auto paramsBuilder = session.GetParamsBuilder(); 
+            auto& rowsParam = paramsBuilder.AddParam("$rows"); 
+ 
+            rowsParam.BeginList(); 
+            for (ui32 i = 0; i < RowsCount; ++i) { 
+                rowsParam.AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Key") 
+                        .OptionalUint64(i) 
+                    .AddMember("Value") 
+                        .OptionalString(ToString(i)) 
+                    .EndStruct(); 
+            } 
+            rowsParam.EndList(); 
+            rowsParam.Build(); 
+ 
+            auto result = session.ExecuteDataQuery(replaceQuery, TTxControl::BeginTx().CommitTx(), 
+                paramsBuilder.Build()).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        } 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Tmp`;
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT(!result.GetResultSet(0).Truncated());
-        UNIT_ASSERT(result.GetResultSet(0).RowsCount() == RowsCount);
-
-        {
-            auto paramsBuilder = session.GetParamsBuilder();
-            auto& rowsParam = paramsBuilder.AddParam("$rows");
-
-            rowsParam.BeginList();
-            rowsParam.AddListItem()
-                .BeginStruct()
-                .AddMember("Key")
-                    .OptionalUint64(RowsCount)
-                .AddMember("Value")
-                    .OptionalString(ToString(RowsCount))
-                .EndStruct();
-            rowsParam.EndList();
-            rowsParam.Build();
-
-            auto result = session.ExecuteDataQuery(replaceQuery, TTxControl::BeginTx().CommitTx(),
-                paramsBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT(!result.GetResultSet(0).Truncated()); 
+        UNIT_ASSERT(result.GetResultSet(0).RowsCount() == RowsCount); 
+ 
+        { 
+            auto paramsBuilder = session.GetParamsBuilder(); 
+            auto& rowsParam = paramsBuilder.AddParam("$rows"); 
+ 
+            rowsParam.BeginList(); 
+            rowsParam.AddListItem() 
+                .BeginStruct() 
+                .AddMember("Key") 
+                    .OptionalUint64(RowsCount) 
+                .AddMember("Value") 
+                    .OptionalString(ToString(RowsCount)) 
+                .EndStruct(); 
+            rowsParam.EndList(); 
+            rowsParam.Build(); 
+ 
+            auto result = session.ExecuteDataQuery(replaceQuery, TTxControl::BeginTx().CommitTx(), 
+                paramsBuilder.Build()).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        } 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Tmp`;
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT(result.GetResultSet(0).Truncated());
-        UNIT_ASSERT(result.GetResultSet(0).RowsCount() == RowsCount);
-
-         {
-            auto paramsBuilder = session.GetParamsBuilder();
-            auto& rowsParam = paramsBuilder.AddParam("$rows");
-
-            rowsParam.BeginList();
-            rowsParam.AddListItem()
-                .BeginStruct()
-                .AddMember("Key")
-                    .OptionalUint64(RowsCount + 1)
-                .AddMember("Value")
-                    .OptionalString(ToString(RowsCount + 1))
-                .EndStruct();
-            rowsParam.EndList();
-            rowsParam.Build();
-
-            auto result = session.ExecuteDataQuery(replaceQuery, TTxControl::BeginTx().CommitTx(),
-                paramsBuilder.Build()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        }
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT(result.GetResultSet(0).Truncated()); 
+        UNIT_ASSERT(result.GetResultSet(0).RowsCount() == RowsCount); 
+ 
+         { 
+            auto paramsBuilder = session.GetParamsBuilder(); 
+            auto& rowsParam = paramsBuilder.AddParam("$rows"); 
+ 
+            rowsParam.BeginList(); 
+            rowsParam.AddListItem() 
+                .BeginStruct() 
+                .AddMember("Key") 
+                    .OptionalUint64(RowsCount + 1) 
+                .AddMember("Value") 
+                    .OptionalString(ToString(RowsCount + 1)) 
+                .EndStruct(); 
+            rowsParam.EndList(); 
+            rowsParam.Build(); 
+ 
+            auto result = session.ExecuteDataQuery(replaceQuery, TTxControl::BeginTx().CommitTx(), 
+                paramsBuilder.Build()).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        } 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Tmp`;
         )"), TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT(result.GetResultSet(0).Truncated());
-        UNIT_ASSERT(result.GetResultSet(0).RowsCount() == RowsCount);
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT(result.GetResultSet(0).Truncated()); 
+        UNIT_ASSERT(result.GetResultSet(0).RowsCount() == RowsCount); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
         if (UseNewEngine) {
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2);
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 0);
@@ -560,57 +560,57 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/Tmp");
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 1001);
         }
-    }
-
-    Y_UNIT_TEST(YqlSyntaxV0) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
+    } 
+ 
+    Y_UNIT_TEST(YqlSyntaxV0) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(!result.IsSuccess());
-
-        result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(!result.IsSuccess()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             SELECT * FROM `/Root/KeyValue` WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-    }
-
-    Y_UNIT_TEST(YqlSyntaxV1) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        setting.SetName("_KqpYqlSyntaxVersion");
-        setting.SetValue("1");
-
-        TKikimrRunner kikimr({setting});
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+    } 
+ 
+    Y_UNIT_TEST(YqlSyntaxV1) { 
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        setting.SetName("_KqpYqlSyntaxVersion"); 
+        setting.SetValue("1"); 
+ 
+        TKikimrRunner kikimr({setting}); 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(!result.IsSuccess());
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v0
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(!result.IsSuccess()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v0 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             SELECT * FROM `/Root/KeyValue` WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-    }
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+    } 
 
     Y_UNIT_TEST_NEW_ENGINE(YqlTableSample) {
         auto setting = NKikimrKqp::TKqpSetting();
@@ -629,63 +629,63 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
         }));
     }
 
-    Y_UNIT_TEST(YqlSyntaxServiceOverride) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        setting.SetName("_KqpYqlSyntaxVersion");
-        setting.SetValue("0");
-
-        NKikimrConfig::TAppConfig appConfig;
-        appConfig.MutableTableServiceConfig()->SetSqlVersion(1);
-
-        TKikimrRunner kikimr(appConfig, {setting});
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
+    Y_UNIT_TEST(YqlSyntaxServiceOverride) { 
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        setting.SetName("_KqpYqlSyntaxVersion"); 
+        setting.SetValue("0"); 
+ 
+        NKikimrConfig::TAppConfig appConfig; 
+        appConfig.MutableTableServiceConfig()->SetSqlVersion(1); 
+ 
+        TKikimrRunner kikimr(appConfig, {setting}); 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(!result.IsSuccess());
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v0
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(!result.IsSuccess()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v0 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             SELECT * FROM `/Root/KeyValue` WHERE Key = 1;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-    }
-
-    Y_UNIT_TEST(QueryExplain) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExplainDataQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+    } 
+ 
+    Y_UNIT_TEST(QueryExplain) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExplainDataQuery(R"( 
             PRAGMA Kikimr.UseNewEngine = 'false';
             SELECT * FROM [/Root/Test] WHERE Group = 1 AND Name > "Name";
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        Cerr << "AST:" << Endl << result.GetAst() << Endl;
-        Cerr << "Plan:" << Endl << result.GetPlan() << Endl;
-
-        auto astRes = NYql::ParseAst(result.GetAst());
-        UNIT_ASSERT(astRes.IsOk());
-        NYql::TExprContext exprCtx;
-        NYql::TExprNode::TPtr exprRoot;
-        UNIT_ASSERT(CompileExpr(*astRes.Root, exprRoot, exprCtx, nullptr));
-
-        UNIT_ASSERT(NYql::NNodes::TMaybeNode<NYql::NNodes::TKiProgram>(exprRoot));
-        UNIT_ASSERT(NYql::FindNode(exprRoot, [](const NYql::TExprNode::TPtr& node) {
-            return NYql::NNodes::TMaybeNode<NYql::NNodes::TKiSelectRange>(node).IsValid();
-        }));
-
-        UNIT_ASSERT(NJson::ValidateJson(result.GetPlan()));
-    }
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        Cerr << "AST:" << Endl << result.GetAst() << Endl; 
+        Cerr << "Plan:" << Endl << result.GetPlan() << Endl; 
+ 
+        auto astRes = NYql::ParseAst(result.GetAst()); 
+        UNIT_ASSERT(astRes.IsOk()); 
+        NYql::TExprContext exprCtx; 
+        NYql::TExprNode::TPtr exprRoot; 
+        UNIT_ASSERT(CompileExpr(*astRes.Root, exprRoot, exprCtx, nullptr)); 
+ 
+        UNIT_ASSERT(NYql::NNodes::TMaybeNode<NYql::NNodes::TKiProgram>(exprRoot)); 
+        UNIT_ASSERT(NYql::FindNode(exprRoot, [](const NYql::TExprNode::TPtr& node) { 
+            return NYql::NNodes::TMaybeNode<NYql::NNodes::TKiSelectRange>(node).IsValid(); 
+        })); 
+ 
+        UNIT_ASSERT(NJson::ValidateJson(result.GetPlan())); 
+    } 
 
     Y_UNIT_TEST_NEW_ENGINE(RewriteIfPresentToMap) {
         TKikimrRunner kikimr;
@@ -717,77 +717,77 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
         auto result = prepareResult.GetQuery().Execute(TTxControl::BeginTx().CommitTx(), params).GetValueSync();
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
     }
-
+ 
     Y_UNIT_TEST_NEW_ENGINE(Pure) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
-            SELECT 1 + 1;
+            SELECT 1 + 1; 
         )");
-
-        auto result = session.ExecuteDataQuery(
-            query,
-            TTxControl::BeginTx().CommitTx()
-        ).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[2]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+ 
+        auto result = session.ExecuteDataQuery( 
+            query, 
+            TTxControl::BeginTx().CommitTx() 
+        ).ExtractValueSync(); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[2]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(Now) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
             SELECT YQL::Now(), YQL::Now();
         )");
-
-        const ui32 QueriesCount = 5;
-
-        TSet<ui64> timestamps;
-        for (ui32 i = 0; i < QueriesCount; ++i) {
-            auto result = session.ExecuteDataQuery(
-                query,
-                TTxControl::BeginTx().CommitTx()
-            ).ExtractValueSync();
-
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-            TResultSetParser parser(result.GetResultSet(0));
-            UNIT_ASSERT(parser.TryNextRow());
-
-            auto value = parser.ColumnParser(0).GetUint64();
+ 
+        const ui32 QueriesCount = 5; 
+ 
+        TSet<ui64> timestamps; 
+        for (ui32 i = 0; i < QueriesCount; ++i) { 
+            auto result = session.ExecuteDataQuery( 
+                query, 
+                TTxControl::BeginTx().CommitTx() 
+            ).ExtractValueSync(); 
+ 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+            TResultSetParser parser(result.GetResultSet(0)); 
+            UNIT_ASSERT(parser.TryNextRow()); 
+ 
+            auto value = parser.ColumnParser(0).GetUint64(); 
             UNIT_ASSERT(value == parser.ColumnParser(1).GetUint64());
-            timestamps.insert(value);
-        }
-
-        UNIT_ASSERT_VALUES_EQUAL(timestamps.size(), QueriesCount);
-
-        timestamps.clear();
-        for (ui32 i = 0; i < QueriesCount; ++i) {
-            auto result = session.ExecuteDataQuery(
-                query,
-                TTxControl::BeginTx().CommitTx(),
-                TExecDataQuerySettings().KeepInQueryCache(true)
-            ).ExtractValueSync();
-
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-            TResultSetParser parser(result.GetResultSet(0));
-            UNIT_ASSERT(parser.TryNextRow());
-
-            auto value = parser.ColumnParser(0).GetUint64();
+            timestamps.insert(value); 
+        } 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(timestamps.size(), QueriesCount); 
+ 
+        timestamps.clear(); 
+        for (ui32 i = 0; i < QueriesCount; ++i) { 
+            auto result = session.ExecuteDataQuery( 
+                query, 
+                TTxControl::BeginTx().CommitTx(), 
+                TExecDataQuerySettings().KeepInQueryCache(true) 
+            ).ExtractValueSync(); 
+ 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+            TResultSetParser parser(result.GetResultSet(0)); 
+            UNIT_ASSERT(parser.TryNextRow()); 
+ 
+            auto value = parser.ColumnParser(0).GetUint64(); 
             UNIT_ASSERT(value == parser.ColumnParser(1).GetUint64());
-            timestamps.insert(value);
-        }
-
+            timestamps.insert(value); 
+        } 
+ 
         UNIT_ASSERT_VALUES_EQUAL(timestamps.size(), QueriesCount);
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(RandomNumber) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -857,116 +857,116 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
         }
     }
 
-    Y_UNIT_TEST(UnsafeTimestampCastV0) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
-            CREATE TABLE `/Root/TsTest` (
-                Key Timestamp,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-        )").GetValueSync().IsSuccess());
-
-        const TString query = R"(
-            --!syntax_v0
-            DECLARE $key AS Uint64;
-            DECLARE $value AS String;
-
-            UPSERT INTO `/Root/TsTest` (Key, Value) VALUES
-                ($key, $value);
-        )";
-
-        auto params = TParamsBuilder()
-            .AddParam("$key").Uint64(1).Build()
-            .AddParam("$value").String("foo").Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(
-            query,
-            TTxControl::BeginTx().CommitTx(),
-            params
-        ).ExtractValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-    }
+    Y_UNIT_TEST(UnsafeTimestampCastV0) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
+            CREATE TABLE `/Root/TsTest` ( 
+                Key Timestamp, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+        )").GetValueSync().IsSuccess()); 
+ 
+        const TString query = R"( 
+            --!syntax_v0 
+            DECLARE $key AS Uint64; 
+            DECLARE $value AS String; 
+ 
+            UPSERT INTO `/Root/TsTest` (Key, Value) VALUES 
+                ($key, $value); 
+        )"; 
+ 
+        auto params = TParamsBuilder() 
+            .AddParam("$key").Uint64(1).Build() 
+            .AddParam("$value").String("foo").Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery( 
+            query, 
+            TTxControl::BeginTx().CommitTx(), 
+            params 
+        ).ExtractValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+    } 
 
     Y_UNIT_TEST_NEW_ENGINE(UnsafeTimestampCastV1) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
-            CREATE TABLE `/Root/TsTest` (
-                Key Timestamp,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-        )").GetValueSync().IsSuccess());
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
+            CREATE TABLE `/Root/TsTest` ( 
+                Key Timestamp, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+        )").GetValueSync().IsSuccess()); 
+ 
         const TString query = Q1_(R"(
-            DECLARE $key AS Uint64;
-            DECLARE $value AS String;
-
-            UPSERT INTO `/Root/TsTest` (Key, Value) VALUES
-                ($key, $value);
+            DECLARE $key AS Uint64; 
+            DECLARE $value AS String; 
+ 
+            UPSERT INTO `/Root/TsTest` (Key, Value) VALUES 
+                ($key, $value); 
         )");
-
-        auto params = TParamsBuilder()
-            .AddParam("$key").Uint64(1).Build()
-            .AddParam("$value").String("foo").Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(
-            query,
-            TTxControl::BeginTx().CommitTx(),
-            params
-        ).ExtractValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::GENERIC_ERROR, result.GetIssues().ToString());
-    }
-
+ 
+        auto params = TParamsBuilder() 
+            .AddParam("$key").Uint64(1).Build() 
+            .AddParam("$value").String("foo").Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery( 
+            query, 
+            TTxControl::BeginTx().CommitTx(), 
+            params 
+        ).ExtractValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::GENERIC_ERROR, result.GetIssues().ToString()); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(QueryStats) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             UPSERT INTO `/Root/EightShard`
-            SELECT
-                Key,
-                Value1 AS Text,
-                Value2 AS Data
+            SELECT 
+                Key, 
+                Value1 AS Text, 
+                Value2 AS Data 
             FROM `/Root/TwoShard`
-            WHERE Key < 10;
+            WHERE Key < 10; 
         )"), TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        TString statsStr;
-        NProtoBuf::TextFormat::PrintToString(stats, &statsStr);
-        Cerr << statsStr << Endl;
-
-        UNIT_ASSERT(stats.process_cpu_time_us() > 0);
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        TString statsStr; 
+        NProtoBuf::TextFormat::PrintToString(stats, &statsStr); 
+        Cerr << statsStr << Endl; 
+ 
+        UNIT_ASSERT(stats.process_cpu_time_us() > 0); 
         UNIT_ASSERT(stats.total_cpu_time_us() > 0);
         UNIT_ASSERT(stats.total_duration_us() > 0);
-
-        UNIT_ASSERT(stats.has_compilation());
-        auto& compile = stats.compilation();
-        UNIT_ASSERT_VALUES_EQUAL(compile.from_cache(), false);
-        UNIT_ASSERT(compile.duration_us() > 0);
-        UNIT_ASSERT(compile.cpu_time_us() > 0);
-
+ 
+        UNIT_ASSERT(stats.has_compilation()); 
+        auto& compile = stats.compilation(); 
+        UNIT_ASSERT_VALUES_EQUAL(compile.from_cache(), false); 
+        UNIT_ASSERT(compile.duration_us() > 0); 
+        UNIT_ASSERT(compile.cpu_time_us() > 0); 
+ 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 3 : 2);
-
+ 
         uint64_t totalDurationUs = 0;
         uint64_t totalCpuTimeUs = 0;
 
@@ -978,21 +978,21 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
         }
 
         auto& phase0 = stats.query_phases(UseNewEngine ? 1 : 0);
-        UNIT_ASSERT(phase0.duration_us() > 0);
-        UNIT_ASSERT(phase0.cpu_time_us() > 0);
+        UNIT_ASSERT(phase0.duration_us() > 0); 
+        UNIT_ASSERT(phase0.cpu_time_us() > 0); 
         totalDurationUs += phase0.duration_us();
         totalCpuTimeUs += phase0.cpu_time_us();
 
-        UNIT_ASSERT_VALUES_EQUAL(phase0.table_access().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(phase0.table_access(0).name(), "/Root/TwoShard");
-        UNIT_ASSERT_VALUES_EQUAL(phase0.table_access(0).reads().rows(), 3);
-        UNIT_ASSERT(phase0.table_access(0).reads().bytes() > 0);
-        UNIT_ASSERT(!phase0.table_access(0).has_updates());
-        UNIT_ASSERT(!phase0.table_access(0).has_deletes());
-
+        UNIT_ASSERT_VALUES_EQUAL(phase0.table_access().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(phase0.table_access(0).name(), "/Root/TwoShard"); 
+        UNIT_ASSERT_VALUES_EQUAL(phase0.table_access(0).reads().rows(), 3); 
+        UNIT_ASSERT(phase0.table_access(0).reads().bytes() > 0); 
+        UNIT_ASSERT(!phase0.table_access(0).has_updates()); 
+        UNIT_ASSERT(!phase0.table_access(0).has_deletes()); 
+ 
         auto& phase1 = stats.query_phases(UseNewEngine ? 2 : 1);
-        UNIT_ASSERT(phase1.duration_us() > 0);
-        UNIT_ASSERT(phase1.cpu_time_us() > 0);
+        UNIT_ASSERT(phase1.duration_us() > 0); 
+        UNIT_ASSERT(phase1.cpu_time_us() > 0); 
         totalDurationUs += phase1.duration_us();
         totalCpuTimeUs += phase1.cpu_time_us();
         UNIT_ASSERT_VALUES_EQUAL(phase1.table_access().size(), UseNewEngine ? 1 : 2);
@@ -1003,53 +1003,53 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
             UNIT_ASSERT(!phase1.table_access(1).has_deletes());
         }
         UNIT_ASSERT_VALUES_EQUAL(phase1.table_access(0).name(), "/Root/EightShard");
-        UNIT_ASSERT(!phase1.table_access(0).has_reads());
+        UNIT_ASSERT(!phase1.table_access(0).has_reads()); 
         UNIT_ASSERT_VALUES_EQUAL(phase1.table_access(0).updates().rows(), 3);
         UNIT_ASSERT(phase1.table_access(0).updates().bytes() > 0);
-        UNIT_ASSERT(!phase1.table_access(0).has_deletes());
+        UNIT_ASSERT(!phase1.table_access(0).has_deletes()); 
 
         UNIT_ASSERT_VALUES_EQUAL(stats.total_duration_us(), totalDurationUs);
         UNIT_ASSERT_VALUES_EQUAL(stats.total_cpu_time_us(), totalCpuTimeUs);
     }
-
+ 
     Y_UNIT_TEST_NEW_ENGINE(RowsLimit) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        setting.SetName("_ResultRowsLimit");
-        setting.SetValue("5");
-
-        TKikimrRunner kikimr({setting});
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        setting.SetName("_ResultRowsLimit"); 
+        setting.SetValue("5"); 
+ 
+        TKikimrRunner kikimr({setting}); 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/EightShard` WHERE Text = "Value2";
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        UNIT_ASSERT(result.GetResultSet(0).Truncated());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 5);
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        UNIT_ASSERT(result.GetResultSet(0).Truncated()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 5); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(RowsLimitServiceOverride) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        setting.SetName("_ResultRowsLimit");
-        setting.SetValue("5");
-
-        NKikimrConfig::TAppConfig appConfig;
-        appConfig.MutableTableServiceConfig()->MutableQueryLimits()->SetResultRowsLimit(6);
-
-        TKikimrRunner kikimr(appConfig, {setting});
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        setting.SetName("_ResultRowsLimit"); 
+        setting.SetValue("5"); 
+ 
+        NKikimrConfig::TAppConfig appConfig; 
+        appConfig.MutableTableServiceConfig()->MutableQueryLimits()->SetResultRowsLimit(6); 
+ 
+        TKikimrRunner kikimr(appConfig, {setting}); 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/EightShard` WHERE Text = "Value2";
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        UNIT_ASSERT(result.GetResultSet(0).Truncated());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 6);
-    }
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        UNIT_ASSERT(result.GetResultSet(0).Truncated()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 6); 
+    } 
 
     Y_UNIT_TEST_NEW_ENGINE(NoEvaluate) {
         TKikimrRunner kikimr;
@@ -1121,133 +1121,133 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
             }));
         }
     }
-
+ 
     Y_UNIT_TEST_NEW_ENGINE(UdfTerminate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            SELECT * FROM `/Root/KeyValue`
-            WHERE TestUdfs::TestFilterTerminate(Cast(Key as Int64) ?? 0, 10)
+            SELECT * FROM `/Root/KeyValue` 
+            WHERE TestUdfs::TestFilterTerminate(Cast(Key as Int64) ?? 0, 10) 
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) {
-            return issue.Message.Contains("Execution failed");
-        }));
-    }
-
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) { 
+            return issue.Message.Contains("Execution failed"); 
+        })); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(UdfMemoryLimit) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        // NOTE: 10MB is greater than default memory allocation for datashard tx.
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        // NOTE: 10MB is greater than default memory allocation for datashard tx. 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            SELECT * FROM `/Root/KeyValue`
-            WHERE Value < TestUdfs::RandString(10000000);
+            SELECT * FROM `/Root/KeyValue` 
+            WHERE Value < TestUdfs::RandString(10000000); 
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        result.GetIssues().PrintTo(Cerr);
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(DdlInDataQuery) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q_(R"(
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        result.GetIssues().PrintTo(Cerr); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(DdlInDataQuery) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q_(R"( 
             CREATE TABLE `/Root/Tmp` (
-                Key Uint64,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) {
-            return issue.Message.Contains("not supported");
-        }));
-
-        result = session.ExecuteDataQuery(Q_(R"(
+                Key Uint64, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) { 
+            return issue.Message.Contains("not supported"); 
+        })); 
+ 
+        result = session.ExecuteDataQuery(Q_(R"( 
             DROP TABLE `/Root/KeyValue`;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) {
-            return issue.Message.Contains("not supported");
-        }));
-
-        result = session.ExecuteDataQuery(Q_(R"(
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) { 
+            return issue.Message.Contains("not supported"); 
+        })); 
+ 
+        result = session.ExecuteDataQuery(Q_(R"( 
             ALTER TABLE `/Root/KeyValue` DROP COLUMN Value;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) {
-            return issue.Message.Contains("not supported");
-        }));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(DyNumberCompare) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        // Compare DyNumber
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            $dn1 = CAST("13.1" AS DyNumber);
-            $dn2 = CAST("10.2" AS DyNumber);
-
-            SELECT
-                $dn1 = $dn2,
-                $dn1 != $dn2,
-                $dn1 > $dn2,
-                $dn1 <= $dn2;
-        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[%false];[%true];[%true];[%false]]])", FormatResultSetYson(result.GetResultSet(0)));
-
-        // Compare to float
-        result = session.ExecuteDataQuery(Q1_(R"(
-            $dn1 = CAST("13.1" AS DyNumber);
-
-            SELECT
-                $dn1 = 13.1,
-                $dn1 != 13.1,
-                $dn1 > 10.2,
-                $dn1 <= 10.2,
-        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        // Compare to int
-        result = session.ExecuteDataQuery(Q1_(R"(
-            $dn1 = CAST("15" AS DyNumber);
-
-            SELECT
-                $dn1 = 15,
-                $dn1 != 15,
-                $dn1 > 10,
-                $dn1 <= 10,
-        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        // Compare to decimal
-        result = session.ExecuteDataQuery(Q1_(R"(
-            $dn1 = CAST("13.1" AS DyNumber);
-            $dc1 = CAST("13.1" AS Decimal(22,9));
-
-            SELECT
-                $dn1 = $dc1,
-                $dn1 != $dc1,
-                $dn1 > $dc1,
-                $dn1 <= $dc1,
-        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-    }
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) { 
+            return issue.Message.Contains("not supported"); 
+        })); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(DyNumberCompare) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        // Compare DyNumber 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            $dn1 = CAST("13.1" AS DyNumber); 
+            $dn2 = CAST("10.2" AS DyNumber); 
+ 
+            SELECT 
+                $dn1 = $dn2, 
+                $dn1 != $dn2, 
+                $dn1 > $dn2, 
+                $dn1 <= $dn2; 
+        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[%false];[%true];[%true];[%false]]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        // Compare to float 
+        result = session.ExecuteDataQuery(Q1_(R"( 
+            $dn1 = CAST("13.1" AS DyNumber); 
+ 
+            SELECT 
+                $dn1 = 13.1, 
+                $dn1 != 13.1, 
+                $dn1 > 10.2, 
+                $dn1 <= 10.2, 
+        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        // Compare to int 
+        result = session.ExecuteDataQuery(Q1_(R"( 
+            $dn1 = CAST("15" AS DyNumber); 
+ 
+            SELECT 
+                $dn1 = 15, 
+                $dn1 != 15, 
+                $dn1 > 10, 
+                $dn1 <= 10, 
+        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        // Compare to decimal 
+        result = session.ExecuteDataQuery(Q1_(R"( 
+            $dn1 = CAST("13.1" AS DyNumber); 
+            $dc1 = CAST("13.1" AS Decimal(22,9)); 
+ 
+            SELECT 
+                $dn1 = $dc1, 
+                $dn1 != $dc1, 
+                $dn1 > $dc1, 
+                $dn1 <= $dc1, 
+        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+    } 
 
     Y_UNIT_TEST_NEW_ENGINE(SelectNull) {
         TKikimrRunner kikimr;
@@ -1274,7 +1274,7 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
         }
     }
 
-}
+} 
 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_scan_spilling_ut.cpp b/ydb/core/kqp/ut/kqp_scan_spilling_ut.cpp
index 613724e640..71943756f0 100644
--- a/ydb/core/kqp/ut/kqp_scan_spilling_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_scan_spilling_ut.cpp
@@ -33,7 +33,7 @@ NKikimrConfig::TAppConfig AppCfg() {
 
 } // anonymous namespace
 
-Y_UNIT_TEST_SUITE(KqpScanSpilling) {
+Y_UNIT_TEST_SUITE(KqpScanSpilling) { 
 
 Y_UNIT_TEST(SelfJoin) {
     Cerr << "cwd: " << NFs::CurrentWorkingDirectory() << Endl;
@@ -68,7 +68,7 @@ Y_UNIT_TEST(SelfJoin) {
         order by t1.Key
     )";
 
-    auto it = db.StreamExecuteScanQuery(query).GetValueSync();
+    auto it = db.StreamExecuteScanQuery(query).GetValueSync(); 
 
     UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
     CompareYson(R"([
diff --git a/ydb/core/kqp/ut/kqp_scan_ut.cpp b/ydb/core/kqp/ut/kqp_scan_ut.cpp
index 347ca35441..46eb7ab46b 100644
--- a/ydb/core/kqp/ut/kqp_scan_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_scan_ut.cpp
@@ -1,18 +1,18 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
 #include <ydb/core/kqp/counters/kqp_counters.h>
-
+ 
 #include <ydb/public/lib/experimental/ydb_experimental.h>
-
+ 
 #include <ydb/library/yql/dq/actors/compute/dq_compute_actor.h>
 
 #include <util/generic/size_literals.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
 
 namespace {
 
@@ -93,7 +93,7 @@ void CreateNullSampleTables(TKikimrRunner& kikimr) {
 
 } // namespace
 
-Y_UNIT_TEST_SUITE(KqpScan) {
+Y_UNIT_TEST_SUITE(KqpScan) { 
     Y_UNIT_TEST(IsNull) {
         TKikimrRunner kikimr;
         CreateNullSampleTables(kikimr);
@@ -189,7 +189,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         )", TTxControl::BeginTx().CommitTx(), params).GetValueSync();
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
 
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         auto it = db.StreamExecuteScanQuery("select Key, max(Value) from `/Root/DecimalTest` group by Key order by Key").GetValueSync();
         CompareYson(R"([
             [["1"];["10.123456789"]];
@@ -215,9 +215,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(Limit) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT * FROM `/Root/KeyValue` LIMIT 10
         )").GetValueSync();
 
@@ -227,9 +227,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(TopSort) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT * FROM `/Root/KeyValue` ORDER BY Key LIMIT 1
         )").GetValueSync();
 
@@ -239,30 +239,30 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(Grep) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT * FROM `/Root/EightShard` WHERE Data == 1 ORDER BY Key;
-        )").GetValueSync();
+        )").GetValueSync(); 
 
         UNIT_ASSERT(it.IsSuccess());
 
-        CompareYson(R"([
-            [[1];[101u];["Value1"]];
-            [[1];[202u];["Value2"]];
-            [[1];[303u];["Value3"]];
-            [[1];[401u];["Value1"]];
-            [[1];[502u];["Value2"]];
-            [[1];[603u];["Value3"]];
-            [[1];[701u];["Value1"]];
-            [[1];[802u];["Value2"]]])", StreamResultToYson(it));
-    }
+        CompareYson(R"([ 
+            [[1];[101u];["Value1"]]; 
+            [[1];[202u];["Value2"]]; 
+            [[1];[303u];["Value3"]]; 
+            [[1];[401u];["Value1"]]; 
+            [[1];[502u];["Value2"]]; 
+            [[1];[603u];["Value3"]]; 
+            [[1];[701u];["Value1"]]; 
+            [[1];[802u];["Value2"]]])", StreamResultToYson(it)); 
+    } 
 
     Y_UNIT_TEST(GrepByString) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             $value = 'some very very very very long string';
             SELECT * FROM `/Root/Logs` WHERE Message == $value ORDER BY App, Ts;
         )").GetValueSync();;
@@ -272,7 +272,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         CompareYson(R"([
             [["ydb"];["ydb-1000"];["some very very very very long string"];[0]]])", StreamResultToYson(it));
     }
-
+ 
     Y_UNIT_TEST(Order) {
         TKikimrRunner kikimr(AppCfg());
         auto db = kikimr.GetTableClient();
@@ -300,155 +300,155 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         ])", StreamResultToYson(it));
     }
 
-    Y_UNIT_TEST(GrepRange) {
-        TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$low")
-                .Uint64(202)
-                .Build()
-            .AddParam("$high")
-                .Uint64(502)
-                .Build()
-            .Build();
-
-        auto it = db.StreamExecuteScanQuery(R"(
-            DECLARE $low AS Uint64;
-            DECLARE $high AS Uint64;
-
+    Y_UNIT_TEST(GrepRange) { 
+        TKikimrRunner kikimr(AppCfg());
+        auto db = kikimr.GetTableClient(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$low") 
+                .Uint64(202) 
+                .Build() 
+            .AddParam("$high") 
+                .Uint64(502) 
+                .Build() 
+            .Build(); 
+ 
+        auto it = db.StreamExecuteScanQuery(R"( 
+            DECLARE $low AS Uint64; 
+            DECLARE $high AS Uint64; 
+ 
             SELECT * FROM `/Root/EightShard` WHERE Key >= $low AND Key <= $high AND Data == 1 ORDER BY Key;
-        )", params).GetValueSync();
-
-        UNIT_ASSERT(it.IsSuccess());
-
-        CompareYson(R"([
-            [[1];[202u];["Value2"]];
-            [[1];[303u];["Value3"]];
-            [[1];[401u];["Value1"]];
-            [[1];[502u];["Value2"]]
-        ])", StreamResultToYson(it));
-    }
-
-    Y_UNIT_TEST(GrepLimit) {
-        TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$app")
-                .Utf8("kikimr-db")
-                .Build()
-            .AddParam("$tsFrom")
-                .Int64(1)
-                .Build()
-            .AddParam("$tsTo")
-                .Int64(4)
-                .Build()
-            .Build();
-
-        auto it = db.StreamExecuteScanQuery(R"(
-            DECLARE $app AS Utf8;
-            DECLARE $tsFrom AS Int64;
-            DECLARE $tsTo AS Int64;
-
-            SELECT *
+        )", params).GetValueSync(); 
+ 
+        UNIT_ASSERT(it.IsSuccess()); 
+ 
+        CompareYson(R"([ 
+            [[1];[202u];["Value2"]]; 
+            [[1];[303u];["Value3"]]; 
+            [[1];[401u];["Value1"]]; 
+            [[1];[502u];["Value2"]] 
+        ])", StreamResultToYson(it)); 
+    } 
+
+    Y_UNIT_TEST(GrepLimit) { 
+        TKikimrRunner kikimr(AppCfg());
+        auto db = kikimr.GetTableClient(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$app") 
+                .Utf8("kikimr-db") 
+                .Build() 
+            .AddParam("$tsFrom") 
+                .Int64(1) 
+                .Build() 
+            .AddParam("$tsTo") 
+                .Int64(4) 
+                .Build() 
+            .Build(); 
+ 
+        auto it = db.StreamExecuteScanQuery(R"( 
+            DECLARE $app AS Utf8; 
+            DECLARE $tsFrom AS Int64; 
+            DECLARE $tsTo AS Int64; 
+ 
+            SELECT * 
             FROM `/Root/Logs`
-            WHERE
-                App == $app
-                AND Ts > $tsFrom
-                AND Ts <= $tsTo
-            LIMIT 2;
-        )", params).GetValueSync();;
-
-        UNIT_ASSERT(it.IsSuccess());
-
-        CompareYson(R"([
-            [["kikimr-db"];["kikimr-db-21"];["Read Data"];[2]];
-            [["kikimr-db"];["kikimr-db-21"];["Stream Read Data"];[3]]
-        ])", StreamResultToYson(it));
-    }
-
-    Y_UNIT_TEST(GrepNonKeyColumns) {
-        TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+            WHERE 
+                App == $app 
+                AND Ts > $tsFrom 
+                AND Ts <= $tsTo 
+            LIMIT 2; 
+        )", params).GetValueSync();; 
+ 
+        UNIT_ASSERT(it.IsSuccess()); 
+ 
+        CompareYson(R"([ 
+            [["kikimr-db"];["kikimr-db-21"];["Read Data"];[2]]; 
+            [["kikimr-db"];["kikimr-db-21"];["Stream Read Data"];[3]] 
+        ])", StreamResultToYson(it)); 
+    } 
+ 
+    Y_UNIT_TEST(GrepNonKeyColumns) { 
+        TKikimrRunner kikimr(AppCfg());
+        auto db = kikimr.GetTableClient(); 
 
         TParamsBuilder params;
         params.AddParam("$app").Utf8("nginx").Build();
         params.AddParam("$tsFrom").Uint64(0).Build();
         params.AddParam("$tsTo").Uint64(5).Build();
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             DECLARE $app AS Utf8;
             DECLARE $tsFrom AS Uint64;
             DECLARE $tsTo AS Uint64;
 
             SELECT
-                Message,
-                Ts
+                Message, 
+                Ts 
             FROM `/Root/Logs`
             WHERE
-                App == $app
-                AND Ts > $tsFrom
-                AND Ts <= $tsTo
-            ORDER BY Ts;
+                App == $app 
+                AND Ts > $tsFrom 
+                AND Ts <= $tsTo 
+            ORDER BY Ts; 
         )", params.Build()).GetValueSync();;
 
         UNIT_ASSERT(it.IsSuccess());
 
         CompareYson(R"([
-            [["GET /index.html HTTP/1.1"];[1]];
-            [["PUT /form HTTP/1.1"];[2]];
-            [["GET /cat.jpg HTTP/1.1"];[3]]
+            [["GET /index.html HTTP/1.1"];[1]]; 
+            [["PUT /form HTTP/1.1"];[2]]; 
+            [["GET /cat.jpg HTTP/1.1"];[3]] 
         ])", StreamResultToYson(it));
     }
-
-    Y_UNIT_TEST(SingleKey) {
-        TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key")
-                .Uint64(202)
-                .Build()
-            .Build();
-
-        auto it = db.StreamExecuteScanQuery(R"(
-            DECLARE $key AS Uint64;
-
+ 
+    Y_UNIT_TEST(SingleKey) { 
+        TKikimrRunner kikimr(AppCfg());
+        auto db = kikimr.GetTableClient(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key") 
+                .Uint64(202) 
+                .Build() 
+            .Build(); 
+ 
+        auto it = db.StreamExecuteScanQuery(R"( 
+            DECLARE $key AS Uint64; 
+ 
             SELECT * FROM `/Root/EightShard` WHERE Key = $key;
-        )", params).GetValueSync();
-
-        UNIT_ASSERT(it.IsSuccess());
-
-        CompareYson(R"([
-            [[1];[202u];["Value2"]]
-        ])", StreamResultToYson(it));
-    }
-
+        )", params).GetValueSync(); 
+ 
+        UNIT_ASSERT(it.IsSuccess()); 
+ 
+        CompareYson(R"([ 
+            [[1];[202u];["Value2"]] 
+        ])", StreamResultToYson(it)); 
+    } 
+ 
     Y_UNIT_TEST(AggregateByColumn) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
-
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto db = kikimr.GetTableClient(); 
+ 
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT Text, SUM(Key) AS Total FROM `/Root/EightShard`
-            GROUP BY Text
-            ORDER BY Total DESC;
-        )").GetValueSync();
-
-        UNIT_ASSERT(it.IsSuccess());
-
-        CompareYson(R"([
-            [["Value3"];[3624u]];
-            [["Value2"];[3616u]];
-            [["Value1"];[3608u]]
-        ])", StreamResultToYson(it));
-    }
+            GROUP BY Text 
+            ORDER BY Total DESC; 
+        )").GetValueSync(); 
+ 
+        UNIT_ASSERT(it.IsSuccess()); 
+ 
+        CompareYson(R"([ 
+            [["Value3"];[3624u]]; 
+            [["Value2"];[3616u]]; 
+            [["Value1"];[3608u]] 
+        ])", StreamResultToYson(it)); 
+    } 
 
     Y_UNIT_TEST(AggregateNoColumn) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT SUM(Data), AVG(Data), COUNT(*), MAX(Data), MIN(Data), SUM(Data * 3 + Key * 2) as foo
             FROM `/Root/EightShard`
             WHERE Key > 300
@@ -461,9 +461,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(AggregateNoColumnNoRemaps) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
                 SELECT SUM(Data), AVG(Data), COUNT(*)
                 FROM `/Root/EightShard`
                 WHERE Key > 300
@@ -476,9 +476,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(AggregateWithFunction) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT (SUM(Data) * 100) / (MIN(Data) + 10)
             FROM `/Root/EightShard`
         )").GetValueSync();
@@ -490,7 +490,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(AggregateCountStar) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
         auto it = db.StreamExecuteScanQuery("SELECT COUNT(*) FROM `/Root/EightShard`").GetValueSync();
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
@@ -499,7 +499,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(AggregateEmptyCountStar) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
         auto it = db.StreamExecuteScanQuery("SELECT COUNT(*) FROM `/Root/EightShard` WHERE Key < 10").GetValueSync();
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
@@ -508,7 +508,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(AggregateEmptySum) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
         auto it = db.StreamExecuteScanQuery("SELECT SUM(Data) FROM `/Root/EightShard` WHERE Key < 10").GetValueSync();
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
@@ -517,34 +517,34 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(JoinSimple) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT *
             FROM `/Root/EightShard` AS l JOIN `/Root/FourShard` AS r ON l.Key = r.Key
-            ORDER BY Key, Text, Data, Value1, Value2
+            ORDER BY Key, Text, Data, Value1, Value2 
         )").GetValueSync();
 
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
 
         CompareYson(R"([
-             [[1];[101u];["Value1"];["Value-101"];["101"]];
-             [[3];[102u];["Value2"];["Value-102"];["102"]];
-             [[2];[201u];["Value1"];["Value-201"];["201"]];
-             [[1];[202u];["Value2"];["Value-202"];["202"]];
-             [[3];[301u];["Value1"];["Value-301"];["301"]];
-             [[2];[302u];["Value2"];["Value-302"];["302"]]
+             [[1];[101u];["Value1"];["Value-101"];["101"]]; 
+             [[3];[102u];["Value2"];["Value-102"];["102"]]; 
+             [[2];[201u];["Value1"];["Value-201"];["201"]]; 
+             [[1];[202u];["Value2"];["Value-202"];["202"]]; 
+             [[3];[301u];["Value1"];["Value-301"];["301"]]; 
+             [[2];[302u];["Value2"];["Value-302"];["302"]] 
         ])", StreamResultToYson(it));
     }
 
     Y_UNIT_TEST(Join) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
         auto test = [&](bool simpleColumns) {
-            auto it = db.StreamExecuteScanQuery(Sprintf(R"(
+            auto it = db.StreamExecuteScanQuery(Sprintf(R"( 
                 PRAGMA %sSimpleColumns;
                 $r = (select * from `/Root/FourShard` where Key > 201);
 
@@ -568,34 +568,34 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(Join2) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT *
             FROM `/Root/EightShard` AS l
             JOIN `/Root/FourShard` AS r
             ON l.Key = r.Key
             WHERE l.Text != "Value1" AND r.Value2 > "1"
-            ORDER BY Key, Text, Data, Value1, Value2
+            ORDER BY Key, Text, Data, Value1, Value2 
         )").GetValueSync();
 
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
 
         CompareYson(R"([
-            [[3];[102u];["Value2"];["Value-102"];["102"]];
-            [[1];[202u];["Value2"];["Value-202"];["202"]];
-            [[2];[302u];["Value2"];["Value-302"];["302"]]
+            [[3];[102u];["Value2"];["Value-102"];["102"]]; 
+            [[1];[202u];["Value2"];["Value-202"];["202"]]; 
+            [[2];[302u];["Value2"];["Value-302"];["302"]] 
         ])", StreamResultToYson(it));
     }
 
     Y_UNIT_TEST(Join3) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
         auto test = [&](bool simpleColumns) {
-            auto it = db.StreamExecuteScanQuery(Sprintf(R"(
+            auto it = db.StreamExecuteScanQuery(Sprintf(R"( 
                 PRAGMA %sSimpleColumns;
                 $join = (
                     SELECT l.Key as Key, l.Text as Text, l.Data as Data, r.Value1 as Value1, r.Value2 as Value2
@@ -707,33 +707,33 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         )", StreamResultToYson(it));
     }
 
-    Y_UNIT_TEST(JoinWithParams) {
-        TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
-        auto params = TParamsBuilder().AddParam("$in")
-            .BeginList()
-                .AddListItem().BeginStruct().AddMember("key").Uint64(1).EndStruct()
-            .EndList()
-            .Build().Build();
-        // table join params
-        auto query1 = R"(
-            declare $in as List<Struct<key: UInt64>>;
-            select l.Key, l.Value
+    Y_UNIT_TEST(JoinWithParams) { 
+        TKikimrRunner kikimr(AppCfg()); 
+        auto db = kikimr.GetTableClient(); 
+        auto params = TParamsBuilder().AddParam("$in") 
+            .BeginList() 
+                .AddListItem().BeginStruct().AddMember("key").Uint64(1).EndStruct() 
+            .EndList() 
+            .Build().Build(); 
+        // table join params 
+        auto query1 = R"( 
+            declare $in as List<Struct<key: UInt64>>; 
+            select l.Key, l.Value 
             from `/Root/KeyValue` as l join AS_TABLE($in) as r on l.Key = r.key
-        )";
-        // params join table
-        auto query2 = R"(
-            declare $in as List<Struct<key: UInt64>>;
-            select r.Key, r.Value
+        )"; 
+        // params join table 
+        auto query2 = R"( 
+            declare $in as List<Struct<key: UInt64>>; 
+            select r.Key, r.Value 
             from AS_TABLE($in) as l join `/Root/KeyValue` as r on l.key = r.Key
-        )";
-        for (auto& query : {query1, query2}) {
-            auto it = db.StreamExecuteScanQuery(query, params).GetValueSync();
-            UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-            CompareYson(R"([[[1u];["One"]]])", StreamResultToYson(it));
-        }
-    }
-
+        )"; 
+        for (auto& query : {query1, query2}) { 
+            auto it = db.StreamExecuteScanQuery(query, params).GetValueSync(); 
+            UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString()); 
+            CompareYson(R"([[[1u];["One"]]])", StreamResultToYson(it)); 
+        } 
+    } 
+ 
     Y_UNIT_TEST(NoTruncate) {
         TKikimrRunner kikimr(AppCfg());
         auto db = kikimr.GetTableClient();
@@ -782,8 +782,8 @@ Y_UNIT_TEST_SUITE(KqpScan) {
             UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
         }
 
-        auto it = db.StreamExecuteScanQuery(R"(
-            SELECT * FROM `/Root/Tmp`;
+        auto it = db.StreamExecuteScanQuery(R"( 
+            SELECT * FROM `/Root/Tmp`; 
         )").GetValueSync();
 
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
@@ -809,11 +809,11 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(Join3TablesNoRemap) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
-        auto it = db.StreamExecuteScanQuery(R"(
-            PRAGMA DisableSimpleColumns;
+        auto it = db.StreamExecuteScanQuery(R"( 
+            PRAGMA DisableSimpleColumns; 
             SELECT *
             FROM `/Root/EightShard` AS t8
               JOIN `/Root/FourShard` AS t4
@@ -838,11 +838,11 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(Join3Tables) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
         auto test = [&](bool simpleColumns) {
-            auto it = db.StreamExecuteScanQuery(Sprintf(R"(
+            auto it = db.StreamExecuteScanQuery(Sprintf(R"( 
                 PRAGMA %sSimpleColumns;
                 SELECT t8.Key as key, t8.Text as text, t4.Value1, t2.Value2
                 FROM `/Root/EightShard` AS t8
@@ -870,11 +870,11 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(JoinLeftOnly) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
         auto test = [&](bool simpleColumns) {
-            auto it = db.StreamExecuteScanQuery(Sprintf(R"(
+            auto it = db.StreamExecuteScanQuery(Sprintf(R"( 
                 PRAGMA %sSimpleColumns;
                 SELECT *
                 FROM `/Root/EightShard` AS l
@@ -903,10 +903,10 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(CrossJoin) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT l.Key, r.Key, l.Text, r.Value1
             FROM `/Root/EightShard` AS l CROSS JOIN `/Root/FourShard` AS r
             WHERE l.Key > r.Key AND l.Data = 1 AND r.Value2 > "200"
@@ -946,10 +946,10 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(SelfJoin3xSameLabels) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             $foo = (
                 SELECT t1.Key AS Key
                 FROM `/Root/KeyValue` AS t1
@@ -972,10 +972,10 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(SelfJoin3x) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             $foo = (
                 SELECT t1.Key AS Key
                 FROM `/Root/KeyValue` AS t1
@@ -999,14 +999,14 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 #if 0
     Y_UNIT_TEST(JoinParams) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
         auto params = TParamsBuilder().AddParam("$in").BeginList()
                 .AddListItem().BeginStruct().AddMember("k").Uint64(1).AddMember("v").String("v1").EndStruct()
                 .AddListItem().BeginStruct().AddMember("k").Uint64(2).AddMember("v").String("v2").EndStruct()
                 .EndList().Build().Build();
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             DECLARE $in AS 'List<Struct<k: Uint64, v: String>>';
             SELECT *
             FROM `/Root/KeyValue` AS l
@@ -1021,7 +1021,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(JoinParams2) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
         auto params = TParamsBuilder()
                 .AddParam("$in1").BeginList()
@@ -1034,7 +1034,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                 .EndList().Build()
                 .Build();
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
                 DECLARE $in1 AS 'List<Struct<k: Uint64, v: String>>';
                 DECLARE $in2 AS 'List<Struct<k: Uint64, v: String>>';
                 SELECT *
@@ -1051,7 +1051,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(JoinParams3) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
         auto params = TParamsBuilder()
                 .AddParam("$in1").BeginList()
@@ -1064,7 +1064,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                 .EndList().Build()
                 .Build();
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
                     DECLARE $in1 AS 'List<Struct<k: Uint64, v: String>>';
                     DECLARE $in2 AS 'List<Struct<k: Uint64, v: String>>';
 
@@ -1082,7 +1082,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         Cerr << StreamResultToYson(it) << Endl;
     }
 #endif
-
+ 
     Y_UNIT_TEST(PrunePartitionsByLiteral) {
         TKikimrRunner kikimr(AppCfg());
         NExperimental::TStreamQueryClient db(kikimr.GetDriver());
@@ -1122,29 +1122,29 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         }
     }
 
-    Y_UNIT_TEST(PrunePartitionsByExpr) {
+    Y_UNIT_TEST(PrunePartitionsByExpr) { 
         TKikimrRunner kikimr(AppCfg());
-        NExperimental::TStreamQueryClient db(kikimr.GetDriver());
-
-        auto settings = NExperimental::TExecuteStreamQuerySettings()
-            .ProfileMode(NExperimental::EStreamQueryProfileMode::Basic);
-
-        auto params = TParamsBuilder()
-            .AddParam("$key").Uint64(300).Build()
-            .Build();
-
-        auto it = db.ExecuteStreamQuery(R"(
-            DECLARE $key AS Uint64;
+        NExperimental::TStreamQueryClient db(kikimr.GetDriver()); 
+ 
+        auto settings = NExperimental::TExecuteStreamQuerySettings() 
+            .ProfileMode(NExperimental::EStreamQueryProfileMode::Basic); 
+ 
+        auto params = TParamsBuilder() 
+            .AddParam("$key").Uint64(300).Build() 
+            .Build(); 
+ 
+        auto it = db.ExecuteStreamQuery(R"( 
+            DECLARE $key AS Uint64; 
             SELECT * FROM `/Root/EightShard` WHERE Key = $key + 1;
-        )", params, settings).GetValueSync();
-
-        UNIT_ASSERT(it.IsSuccess());
-
+        )", params, settings).GetValueSync(); 
+ 
+        UNIT_ASSERT(it.IsSuccess()); 
+ 
         TVector<TString> profiles;
         CompareYson(R"([[[3];[301u];["Value1"]]])", StreamResultToYson(it, &profiles));
-
+ 
         UNIT_ASSERT_EQUAL(2, profiles.size());
-
+ 
         {
             NYql::NDqProto::TDqExecutionStats stats;
             google::protobuf::TextFormat::ParseFromString(profiles[0], &stats);
@@ -1164,7 +1164,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
             UNIT_ASSERT(stats.GetExtra().UnpackTo(&extraStats));
             UNIT_ASSERT_VALUES_EQUAL(extraStats.GetAffectedShards(), 1);
         }
-    }
+    } 
 
     Y_UNIT_TEST(TooManyComputeActors) {
         TVector<NKikimrKqp::TKqpSetting> settings;
@@ -1174,10 +1174,10 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         settings.push_back(setting);
 
         TKikimrRunner kikimr{settings};
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         CreateSampleTables(kikimr);
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             $join = (
                 SELECT l.Key as Key, l.Text as Text, l.Data as Data, r.Value1 as Value1, r.Value2 as Value2
                 FROM `/Root/EightShard` AS l JOIN `/Root/FourShard` AS r ON l.Key = r.Key
@@ -1232,50 +1232,50 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                 TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync());
         }
 
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
         auto it = db.StreamExecuteScanQuery("SELECT * FROM `/Root/EightShard` LIMIT 2").GetValueSync();
 
         Cerr << StreamResultToYson(it) << Endl;
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
     }
 
-    Y_UNIT_TEST(MultipleResults) {
-        TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
-
-        auto it = db.StreamExecuteScanQuery(R"(
+    Y_UNIT_TEST(MultipleResults) { 
+        TKikimrRunner kikimr(AppCfg()); 
+        auto db = kikimr.GetTableClient(); 
+ 
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT * FROM `/Root/KeyValue`;
             SELECT * FROM `/Root/EightShard`;
-        )").GetValueSync();
-        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-
-        auto part = it.ReadNext().GetValueSync();
-        part.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_EQUAL_C(part.GetStatus(), EStatus::PRECONDITION_FAILED, part.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST(Effects) {
-        TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
-
-        auto it = db.StreamExecuteScanQuery(R"(
+        )").GetValueSync(); 
+        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString()); 
+ 
+        auto part = it.ReadNext().GetValueSync(); 
+        part.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_EQUAL_C(part.GetStatus(), EStatus::PRECONDITION_FAILED, part.GetIssues().ToString()); 
+    } 
+ 
+    Y_UNIT_TEST(Effects) { 
+        TKikimrRunner kikimr(AppCfg()); 
+        auto db = kikimr.GetTableClient(); 
+ 
+        auto it = db.StreamExecuteScanQuery(R"( 
             UPSERT INTO `/Root/KeyValue`
             SELECT Key, Text AS Value FROM `/Root/EightShard`;
-
+ 
             SELECT * FROM `/Root/EightShard`;
-        )").GetValueSync();
-        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-
-        auto part = it.ReadNext().GetValueSync();
-        part.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_EQUAL_C(part.GetStatus(), EStatus::PRECONDITION_FAILED, part.GetIssues().ToString());
-    }
-
+        )").GetValueSync(); 
+        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString()); 
+ 
+        auto part = it.ReadNext().GetValueSync(); 
+        part.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_EQUAL_C(part.GetStatus(), EStatus::PRECONDITION_FAILED, part.GetIssues().ToString()); 
+    } 
+ 
     Y_UNIT_TEST(PureExpr) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT '42', 42, 5*5;
         )").GetValueSync();
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
@@ -1285,9 +1285,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(UnionWithPureExpr) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT '42', 42, 5*5
             UNION ALL
             SELECT 'forty-two';
@@ -1299,9 +1299,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(MiltiExprWithPure) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT Key FROM `/Root/KeyValue` ORDER BY Key LIMIT 1;
             SELECT 2;
         )").GetValueSync();
@@ -1313,9 +1313,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(UnionBasic) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             (SELECT Key FROM `/Root/KeyValue` ORDER BY Key LIMIT 1)
             UNION ALL
             (SELECT Key FROM `/Root/EightShard` ORDER BY Key LIMIT 1);
@@ -1327,9 +1327,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(UnionMixed) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT 42
             UNION ALL
             (SELECT Key FROM `/Root/EightShard` ORDER BY Key LIMIT 1);
@@ -1341,9 +1341,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(UnionThree) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             (SELECT Key FROM `/Root/KeyValue` ORDER BY Key LIMIT 1)
             UNION ALL
             (SELECT Key FROM `/Root/EightShard` ORDER BY Key LIMIT 1)
@@ -1357,9 +1357,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(UnionSameTable) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             (SELECT Key FROM `/Root/KeyValue` ORDER BY Key LIMIT 1)
             UNION ALL
             (SELECT Key FROM `/Root/KeyValue` ORDER BY Key LIMIT 1);
@@ -1369,27 +1369,27 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         CompareYson(R"([[[1u]];[[1u]]])", res);
     }
 
-    Y_UNIT_TEST(UnionAggregate) {
-        TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
-
-        auto it = db.StreamExecuteScanQuery(R"(
+    Y_UNIT_TEST(UnionAggregate) { 
+        TKikimrRunner kikimr(AppCfg()); 
+        auto db = kikimr.GetTableClient(); 
+ 
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT COUNT(*) FROM `/Root/KeyValue`
-            UNION ALL
+            UNION ALL 
             SELECT COUNT(*) FROM `/Root/EightShard`
-            UNION ALL
+            UNION ALL 
             SELECT SUM(Amount) FROM `/Root/Test`;
-        )").GetValueSync();
-        auto res = StreamResultToYson(it);
-        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        CompareYson(R"([[[2u]];[[24u]];[[11000u]]])", res);
-    }
-
+        )").GetValueSync(); 
+        auto res = StreamResultToYson(it); 
+        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString()); 
+        CompareYson(R"([[[2u]];[[24u]];[[11000u]]])", res); 
+    } 
+ 
     Y_UNIT_TEST(CountDistinct) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT count(*) AS c1, count(DISTINCT Value) AS c2
             FROM `/Root/KeyValue` GROUP BY Key;
         )").GetValueSync();
@@ -1400,9 +1400,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(FullFrameWindow) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT group_total, count(*) FROM (
                 SELECT Key, Text, SUM(Data) OVER w1 AS group_total
                 FROM `/Root/EightShard` WINDOW w1 AS (partition by Text)
@@ -1415,9 +1415,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(SimpleWindow) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT Text, running_total FROM (
                 SELECT Key, Text, SUM(Data) OVER w1 AS running_total
                 FROM `/Root/EightShard`
@@ -1442,9 +1442,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(TwoAggregatesOneFullFrameWindow) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT tot, avg, count(*) FROM (
                 SELECT Key, Text, SUM(Data) OVER w1 AS tot, avg(Data) OVER w1 AS avg
                 FROM `/Root/EightShard`
@@ -1459,9 +1459,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(TwoAggregatesTwoWindows) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT Key, Text, sum(Data) OVER w1 AS tot, sum(Data) OVER w2 AS avg
             FROM `/Root/EightShard`
             WHERE Text = 'Value2'
@@ -1485,9 +1485,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(CustomWindow) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT Key, sum_short_win FROM (
                 SELECT Key, Text, SUM(Data) OVER w1 AS sum_short_win
                 FROM `/Root/EightShard`
@@ -1511,9 +1511,9 @@ Y_UNIT_TEST_SUITE(KqpScan) {
 
     Y_UNIT_TEST(EmptySet) {
         TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
+        auto db = kikimr.GetTableClient(); 
 
-        auto it = db.StreamExecuteScanQuery(R"(
+        auto it = db.StreamExecuteScanQuery(R"( 
             SELECT Key FROM `/Root/EightShard` WHERE false;
         )").GetValueSync();
         auto res = StreamResultToYson(it);
@@ -1521,21 +1521,21 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         CompareYson("[]",res);
     }
 
-     Y_UNIT_TEST(RestrictSqlV0) {
-        TKikimrRunner kikimr(AppCfg());
-        auto db = kikimr.GetTableClient();
-
-        auto it = db.StreamExecuteScanQuery(R"(
-            --!syntax_v0
+     Y_UNIT_TEST(RestrictSqlV0) { 
+        TKikimrRunner kikimr(AppCfg()); 
+        auto db = kikimr.GetTableClient(); 
+ 
+        auto it = db.StreamExecuteScanQuery(R"( 
+            --!syntax_v0 
             SELECT * FROM [/Root/EightShard] WHERE Key = 1;
-        )").GetValueSync();
-        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        auto part = it.ReadNext().GetValueSync();
-
-        part.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_EQUAL_C(part.GetStatus(), EStatus::GENERIC_ERROR, part.GetStatus());
-    }
-
+        )").GetValueSync(); 
+        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString()); 
+        auto part = it.ReadNext().GetValueSync(); 
+ 
+        part.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_EQUAL_C(part.GetStatus(), EStatus::GENERIC_ERROR, part.GetStatus()); 
+    } 
+ 
     Y_UNIT_TEST(LongStringCombiner) {
         TKikimrRunner kikimr(AppCfg());
         auto db = kikimr.GetTableClient();
@@ -1743,11 +1743,11 @@ Y_UNIT_TEST_SUITE(KqpScan) {
             UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
 
             auto res = CollectStreamResult(result);
-            UNIT_ASSERT(res.PlanJson);
+            UNIT_ASSERT(res.PlanJson); 
             // Cerr << res.PlanJson << Endl;
 
             NJson::TJsonValue plan;
-            NJson::ReadJsonTree(*res.PlanJson, &plan, /* throwOnError */ true);
+            NJson::ReadJsonTree(*res.PlanJson, &plan, /* throwOnError */ true); 
 
             auto node = FindPlanNodeByKv(plan, "Tables", NJson::TJsonArray({tableRlPath}).GetStringRobust());
             UNIT_ASSERT_C(node.IsDefined(), query);
@@ -1899,7 +1899,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
         CompareYson("[[%false]]", StreamResultToYson(result));
     }
-}
-
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_scheme_ut.cpp b/ydb/core/kqp/ut/kqp_scheme_ut.cpp
index ca7ffa42a4..0aaba80110 100644
--- a/ydb/core/kqp/ut/kqp_scheme_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_scheme_ut.cpp
@@ -1,104 +1,104 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
+ 
 #include <library/cpp/threading/local_executor/local_executor.h>
-
+ 
 #include <util/string/printf.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-Y_UNIT_TEST_SUITE(KqpScheme) {
-    Y_UNIT_TEST(UseUnauthorizedTable) {
-        TKikimrRunner kikimr("test_user@builtin");
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+Y_UNIT_TEST_SUITE(KqpScheme) { 
+    Y_UNIT_TEST(UseUnauthorizedTable) { 
+        TKikimrRunner kikimr("test_user@builtin"); 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto& tableSettings = kikimr.GetTestServer().GetSettings().AppConfig.GetTableServiceConfig();
-        bool useSchemeCacheMeta = tableSettings.GetUseSchemeCacheMetadata();
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto& tableSettings = kikimr.GetTestServer().GetSettings().AppConfig.GetTableServiceConfig(); 
+        bool useSchemeCacheMeta = tableSettings.GetUseSchemeCacheMetadata(); 
 
-        auto result = session.ExecuteDataQuery(R"(
+        auto result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/KeyValue];
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(),
-            useSchemeCacheMeta ? EStatus::SCHEME_ERROR : EStatus::UNAUTHORIZED, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), 
+            useSchemeCacheMeta ? EStatus::SCHEME_ERROR : EStatus::UNAUTHORIZED, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/NonExistent];
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(),
-            useSchemeCacheMeta ? EStatus::SCHEME_ERROR : EStatus::UNAUTHORIZED, result.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST(UseNonexistentTable) {
-        TKikimrRunner kikimr;
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), 
+            useSchemeCacheMeta ? EStatus::SCHEME_ERROR : EStatus::UNAUTHORIZED, result.GetIssues().ToString()); 
+    } 
+ 
+    Y_UNIT_TEST(UseNonexistentTable) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/KeyValue];
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-
-        result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/NonExistent];
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR);
-    }
-
-    Y_UNIT_TEST(UseDroppedTable) {
-        TKikimrRunner kikimr;
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR); 
+    } 
+ 
+    Y_UNIT_TEST(UseDroppedTable) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(R"(
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/KeyValue];
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-
-        auto schemeResult = session.ExecuteSchemeQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+ 
+        auto schemeResult = session.ExecuteSchemeQuery(R"( 
             DROP TABLE [/Root/KeyValue];
-        )").ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(schemeResult.GetStatus(), EStatus::SUCCESS);
-
-        result = session.ExecuteDataQuery(R"(
+        )").ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(schemeResult.GetStatus(), EStatus::SUCCESS); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/KeyValue];
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR);
-    }
-
-    Y_UNIT_TEST(CreateDroppedTable) {
-        TKikimrRunner kikimr;
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR); 
+    } 
+ 
+    Y_UNIT_TEST(CreateDroppedTable) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto schemeResult = session.ExecuteSchemeQuery(R"(
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto schemeResult = session.ExecuteSchemeQuery(R"( 
             DROP TABLE [/Root/KeyValue];
-        )").ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(schemeResult.GetStatus(), EStatus::SUCCESS);
-
-        schemeResult = session.ExecuteSchemeQuery(R"(
+        )").ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(schemeResult.GetStatus(), EStatus::SUCCESS); 
+ 
+        schemeResult = session.ExecuteSchemeQuery(R"( 
             CREATE TABLE [/Root/KeyValue] (
-                Key Uint32,
-                Value String,
-                PRIMARY KEY(Key)
-            );
-        )").ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(schemeResult.GetStatus(), EStatus::SUCCESS);
-
-        auto result = session.ExecuteDataQuery(R"(
+                Key Uint32, 
+                Value String, 
+                PRIMARY KEY(Key) 
+            ); 
+        )").ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(schemeResult.GetStatus(), EStatus::SUCCESS); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
             SELECT * FROM [/Root/KeyValue];
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-    }
-
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+    } 
+ 
     Y_UNIT_TEST(CreateDropTableMultipleTime) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -191,87 +191,87 @@ Y_UNIT_TEST_SUITE(KqpScheme) {
         }, 0, inflight, NPar::TLocalExecutor::WAIT_COMPLETE | NPar::TLocalExecutor::MED_PRIORITY);
     }
 
-    Y_UNIT_TEST(QueryWithAlter) {
+    Y_UNIT_TEST(QueryWithAlter) { 
         auto kikimr = std::make_shared<TKikimrRunner>();
-        auto db = kikimr->GetTableClient();
-
-        const ui32 Inflight = 10;
-        const TDuration WaitDuration = TDuration::Seconds(1);
-
-        TAtomic finishing = false;
-        NPar::LocalExecutor().RunAdditionalThreads(Inflight + 1);
+        auto db = kikimr->GetTableClient(); 
+ 
+        const ui32 Inflight = 10; 
+        const TDuration WaitDuration = TDuration::Seconds(1); 
+ 
+        TAtomic finishing = false; 
+        NPar::LocalExecutor().RunAdditionalThreads(Inflight + 1); 
         NPar::LocalExecutor().ExecRange([=, &db, &finishing](int id) mutable {
-            if (id == Inflight) {
-                Sleep(WaitDuration);
-
-                auto status = db.RetryOperationSync([](TSession session) {
-                    return session.ExecuteSchemeQuery(R"(
+            if (id == Inflight) { 
+                Sleep(WaitDuration); 
+ 
+                auto status = db.RetryOperationSync([](TSession session) { 
+                    return session.ExecuteSchemeQuery(R"( 
                         ALTER TABLE [/Root/EightShard] DROP COLUMN Data;
-                    )").ExtractValueSync();
-                });
-                UNIT_ASSERT_VALUES_EQUAL_C(status.GetStatus(), EStatus::SUCCESS, status.GetIssues().ToString());
-
-                Sleep(WaitDuration);
-
-                AtomicSet(finishing, true);
-                return;
-            }
-
-            auto retrySettings = TRetryOperationSettings().MaxRetries(100);
-
-            while (!AtomicGet(finishing)) {
-                if (id % 2) {
-                    // Immediate
-                    auto status = db.RetryOperationSync([](TSession session) {
-                        return session.ExecuteDataQuery(R"(
+                    )").ExtractValueSync(); 
+                }); 
+                UNIT_ASSERT_VALUES_EQUAL_C(status.GetStatus(), EStatus::SUCCESS, status.GetIssues().ToString()); 
+ 
+                Sleep(WaitDuration); 
+ 
+                AtomicSet(finishing, true); 
+                return; 
+            } 
+ 
+            auto retrySettings = TRetryOperationSettings().MaxRetries(100); 
+ 
+            while (!AtomicGet(finishing)) { 
+                if (id % 2) { 
+                    // Immediate 
+                    auto status = db.RetryOperationSync([](TSession session) { 
+                        return session.ExecuteDataQuery(R"( 
                             SELECT * FROM [/Root/EightShard] WHERE Key = 501u;
-                        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-                    }, retrySettings);
-                    UNIT_ASSERT_VALUES_EQUAL_C(status.GetStatus(), EStatus::SUCCESS, status.GetIssues().ToString());
-                } else {
-                    // Planned
-                    auto status = db.RetryOperationSync([](TSession session) {
-                        return session.ExecuteDataQuery(R"(
+                        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+                    }, retrySettings); 
+                    UNIT_ASSERT_VALUES_EQUAL_C(status.GetStatus(), EStatus::SUCCESS, status.GetIssues().ToString()); 
+                } else { 
+                    // Planned 
+                    auto status = db.RetryOperationSync([](TSession session) { 
+                        return session.ExecuteDataQuery(R"( 
                             SELECT * FROM [/Root/EightShard];
-                        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-                    }, retrySettings);
-                    UNIT_ASSERT_VALUES_EQUAL_C(status.GetStatus(), EStatus::SUCCESS, status.GetIssues().ToString());
-                }
-            }
-        }, 0, Inflight + 1, NPar::TLocalExecutor::WAIT_COMPLETE | NPar::TLocalExecutor::MED_PRIORITY);
-    }
+                        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+                    }, retrySettings); 
+                    UNIT_ASSERT_VALUES_EQUAL_C(status.GetStatus(), EStatus::SUCCESS, status.GetIssues().ToString()); 
+                } 
+            } 
+        }, 0, Inflight + 1, NPar::TLocalExecutor::WAIT_COMPLETE | NPar::TLocalExecutor::MED_PRIORITY); 
+    } 
 
-    Y_UNIT_TEST_NEW_ENGINE(SchemaVersionMissmatch) {
-        TKikimrRunner kikimr;
+    Y_UNIT_TEST_NEW_ENGINE(SchemaVersionMissmatch) { 
+        TKikimrRunner kikimr; 
 
         auto db = kikimr.GetTableClient();
         auto session = db.CreateSession().GetValueSync().GetSession();
 
-        const TString query = Q_(R"(
+        const TString query = Q_(R"( 
             SELECT * FROM [/Root/KeyValue] WHERE Value = "New";
-        )");
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.KeepInQueryCache(true);
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        {
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(),
-                TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync();
-
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        }
-
-        {
-            auto result = session.ExecuteDataQuery(query,
-                TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-            auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-            UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), true);
-        }
-
-        {
+        )"); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.KeepInQueryCache(true); 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        {
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), 
+                TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync(); 
+
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        }
+ 
+        {
+            auto result = session.ExecuteDataQuery(query, 
+                TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+            auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+            UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), true); 
+        } 
+ 
+        { 
             auto type = TTypeBuilder()
                 .BeginOptional()
                     .Primitive(EPrimitiveType::Utf8)
@@ -280,47 +280,47 @@ Y_UNIT_TEST_SUITE(KqpScheme) {
 
             auto result = session.AlterTable("/Root/KeyValue", TAlterTableSettings()
                 .AppendAddColumns(TColumn{"NewColumn", type})).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
         }
 
         {
             auto result = session.ExecuteDataQuery(query,
-                TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+                TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
 
-            auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-            UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), false);
+            auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+            UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), false); 
         }
     }
 
-    void CheckInvalidationAfterDropCreateTable(bool withCompatSchema) {
-        TKikimrRunner kikimr;
+    void CheckInvalidationAfterDropCreateTable(bool withCompatSchema) { 
+        TKikimrRunner kikimr; 
 
         auto db = kikimr.GetTableClient();
         auto session = db.CreateSession().GetValueSync().GetSession();
         const TString sql = "UPSERT INTO [/Root/KeyValue] (Key, Value) VALUES(1, \"One\")";
 
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.KeepInQueryCache(true);
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.KeepInQueryCache(true); 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
         {
-            auto result = session.ExecuteDataQuery(sql,
-                TTxControl::BeginTx().CommitTx(), TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync();
+            auto result = session.ExecuteDataQuery(sql, 
+                TTxControl::BeginTx().CommitTx(), TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync(); 
 
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
         }
 
         {
-            auto result = session.ExecuteDataQuery(sql,
-                TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-            auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-            UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), true);
-        }
-
-        {
+            auto result = session.ExecuteDataQuery(sql, 
+                TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+            auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+            UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), true); 
+        } 
+ 
+        { 
             auto result = session.DropTable("/Root/KeyValue").ExtractValueSync();
 
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
@@ -347,31 +347,31 @@ Y_UNIT_TEST_SUITE(KqpScheme) {
         }
 
         {
-            auto result = session.ExecuteDataQuery(sql,
-                TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
+            auto result = session.ExecuteDataQuery(sql, 
+                TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync(); 
 
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
 
-            auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-            UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), false);
+            auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+            UNIT_ASSERT_VALUES_EQUAL(stats.compilation().from_cache(), false); 
         }
 
         {
             // New session
             auto session2 = db.CreateSession().GetValueSync().GetSession();
-            auto result = session2.ExecuteDataQuery(sql,
-                TTxControl::BeginTx().CommitTx(), TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync();
+            auto result = session2.ExecuteDataQuery(sql, 
+                TTxControl::BeginTx().CommitTx(), TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync(); 
 
             UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
         }
     }
 
     Y_UNIT_TEST(InvalidationAfterDropCreate) {
-        CheckInvalidationAfterDropCreateTable(false);
+        CheckInvalidationAfterDropCreateTable(false); 
     }
 
     Y_UNIT_TEST(InvalidationAfterDropCreateCompatSchema) {
-        CheckInvalidationAfterDropCreateTable(true);
+        CheckInvalidationAfterDropCreateTable(true); 
     }
 
     void CheckInvalidationAfterDropCreateTable2(bool multistageTx, bool select) {
@@ -1602,49 +1602,49 @@ Y_UNIT_TEST_SUITE(KqpScheme) {
         auto resultDropColumn = session.ExecuteSchemeQuery(queryDropColumn).GetValueSync();
         UNIT_ASSERT_VALUES_EQUAL_C(resultDropColumn.GetStatus(), EStatus::SUCCESS, resultDropColumn.GetIssues().ToString());
     }
-
-    Y_UNIT_TEST(AddDropColumn) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteSchemeQuery(R"(
-            --!syntax_v1
-            ALTER TABLE `/Root/KeyValue` ADD Value2 String;
-        )").ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto describeResult = session.DescribeTable("/Root/KeyValue").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(describeResult.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(describeResult.GetTableDescription().GetColumns().size(), 3);
-
-        result = session.ExecuteSchemeQuery(R"(
-            --!syntax_v1
-            ALTER TABLE `/Root/KeyValue` DROP Value;
-        )").ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        describeResult = session.DescribeTable("/Root/KeyValue").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(describeResult.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(describeResult.GetTableDescription().GetColumns().size(), 2);
-    }
-
-    Y_UNIT_TEST(DropKeyColumn) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteSchemeQuery(R"(
-            --!syntax_v1
-            ALTER TABLE `/Root/KeyValue` DROP Key;
-        )").ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
+ 
+    Y_UNIT_TEST(AddDropColumn) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteSchemeQuery(R"( 
+            --!syntax_v1 
+            ALTER TABLE `/Root/KeyValue` ADD Value2 String; 
+        )").ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto describeResult = session.DescribeTable("/Root/KeyValue").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(describeResult.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(describeResult.GetTableDescription().GetColumns().size(), 3); 
+ 
+        result = session.ExecuteSchemeQuery(R"( 
+            --!syntax_v1 
+            ALTER TABLE `/Root/KeyValue` DROP Value; 
+        )").ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        describeResult = session.DescribeTable("/Root/KeyValue").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(describeResult.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(describeResult.GetTableDescription().GetColumns().size(), 2); 
+    } 
+ 
+    Y_UNIT_TEST(DropKeyColumn) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteSchemeQuery(R"( 
+            --!syntax_v1 
+            ALTER TABLE `/Root/KeyValue` DROP Key; 
+        )").ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
     Y_UNIT_TEST(DropIndexDataColumn) {
         auto setting = NKikimrKqp::TKqpSetting();
         TKikimrRunner kikimr({setting});
@@ -1663,25 +1663,25 @@ Y_UNIT_TEST_SUITE(KqpScheme) {
         UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED);
     }
 
-    Y_UNIT_TEST(PathWithNoRoot) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteSchemeQuery(R"(
-            --!syntax_v1
+    Y_UNIT_TEST(PathWithNoRoot) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteSchemeQuery(R"( 
+            --!syntax_v1 
             CREATE TABLE `/TablePathWithNoRoot` (
-                Id Uint32,
-                Value String,
-                PRIMARY KEY (Id)
-            );
-        )").ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_EXEC));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
+                Id Uint32, 
+                Value String, 
+                PRIMARY KEY (Id) 
+            ); 
+        )").ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_EXEC)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
 
     Y_UNIT_TEST(CreateTableWithDecimalColumn) {
         TKikimrRunner kikimr;
@@ -2151,7 +2151,7 @@ Y_UNIT_TEST_SUITE(KqpScheme) {
             UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
         }
     }
-}
-
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_scripting_ut.cpp b/ydb/core/kqp/ut/kqp_scripting_ut.cpp
index 65e75ac303..d5a9e68350 100644
--- a/ydb/core/kqp/ut/kqp_scripting_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_scripting_ut.cpp
@@ -1,180 +1,180 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
+ 
 #include <ydb/public/sdk/cpp/client/draft/ydb_scripting.h>
-
+ 
 #include <library/cpp/json/json_prettifier.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NScripting;
-
-Y_UNIT_TEST_SUITE(KqpScripting) {
-    Y_UNIT_TEST(EndOfQueryCommit) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            CREATE TABLE [/Root/ScriptingTest] (
-                Key Uint64,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-            COMMIT;
-
-            REPLACE INTO [/Root/ScriptingTest] (Key, Value) VALUES
-                (1, "One"),
-                (2, "Two");
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 0);
-
-        result = client.ExecuteYqlScript(R"(
-            SELECT COUNT(*) FROM [/Root/ScriptingTest];
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets()[0].RowsCount(), 1);
-        TResultSetParser rs0(result.GetResultSets()[0]);
-        UNIT_ASSERT(rs0.TryNextRow());
-        UNIT_ASSERT_VALUES_EQUAL(rs0.ColumnParser(0).GetUint64(), 2u);
-    }
-
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NScripting; 
+ 
+Y_UNIT_TEST_SUITE(KqpScripting) { 
+    Y_UNIT_TEST(EndOfQueryCommit) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            CREATE TABLE [/Root/ScriptingTest] ( 
+                Key Uint64, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+            COMMIT; 
+ 
+            REPLACE INTO [/Root/ScriptingTest] (Key, Value) VALUES 
+                (1, "One"), 
+                (2, "Two"); 
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 0); 
+ 
+        result = client.ExecuteYqlScript(R"( 
+            SELECT COUNT(*) FROM [/Root/ScriptingTest]; 
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets()[0].RowsCount(), 1); 
+        TResultSetParser rs0(result.GetResultSets()[0]); 
+        UNIT_ASSERT(rs0.TryNextRow()); 
+        UNIT_ASSERT_VALUES_EQUAL(rs0.ColumnParser(0).GetUint64(), 2u); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(UnsafeTimestampCast) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
         auto result = client.ExecuteYqlScript(Q_(R"(
-            CREATE TABLE [/Root/TsTest] (
-                Key Timestamp,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-            COMMIT;
-
-            UPSERT INTO [/Root/TsTest]
-            SELECT * FROM [/Root/KeyValue];
+            CREATE TABLE [/Root/TsTest] ( 
+                Key Timestamp, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+            COMMIT; 
+ 
+            UPSERT INTO [/Root/TsTest] 
+            SELECT * FROM [/Root/KeyValue]; 
         )")).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         result = client.ExecuteYqlScript(Q1_(R"(
-            UPSERT INTO `/Root/TsTest`
-            SELECT * FROM `/Root/KeyValue`;
+            UPSERT INTO `/Root/TsTest` 
+            SELECT * FROM `/Root/KeyValue`; 
         )")).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::GENERIC_ERROR, result.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST(ScanQuery) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto params = client.GetParamsBuilder()
-            .AddParam("$text").String("Value1").Build()
-            .Build();
-
-        auto result = client.ExecuteYqlScript(R"(
-            PRAGMA kikimr.ScanQuery = "true";
-            DECLARE $text AS String;
-            SELECT COUNT(*) FROM [/Root/EightShard] WHERE Text = $text;
-        )", params).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1);
-
-        TResultSetParser rs0(result.GetResultSets()[0]);
-        UNIT_ASSERT(rs0.TryNextRow());
-        UNIT_ASSERT_VALUES_EQUAL(rs0.ColumnParser(0).GetUint64(), 8u);
-    }
-
-    Y_UNIT_TEST(ScanQueryInvalid) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            PRAGMA kikimr.ScanQuery = "true";
-            SELECT COUNT(*) FROM [/Root/EightShard];
-            SELECT COUNT(*) FROM [/Root/TwoShard];
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::PRECONDITION_FAILED, result.GetIssues().ToString());
-
-        result = client.ExecuteYqlScript(R"(
-            PRAGMA kikimr.ScanQuery = "true";
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::GENERIC_ERROR, result.GetIssues().ToString()); 
+    } 
+ 
+    Y_UNIT_TEST(ScanQuery) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto params = client.GetParamsBuilder() 
+            .AddParam("$text").String("Value1").Build() 
+            .Build(); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            PRAGMA kikimr.ScanQuery = "true"; 
+            DECLARE $text AS String; 
+            SELECT COUNT(*) FROM [/Root/EightShard] WHERE Text = $text; 
+        )", params).GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1); 
+ 
+        TResultSetParser rs0(result.GetResultSets()[0]); 
+        UNIT_ASSERT(rs0.TryNextRow()); 
+        UNIT_ASSERT_VALUES_EQUAL(rs0.ColumnParser(0).GetUint64(), 8u); 
+    } 
+ 
+    Y_UNIT_TEST(ScanQueryInvalid) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            PRAGMA kikimr.ScanQuery = "true"; 
+            SELECT COUNT(*) FROM [/Root/EightShard]; 
+            SELECT COUNT(*) FROM [/Root/TwoShard]; 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::PRECONDITION_FAILED, result.GetIssues().ToString()); 
+ 
+        result = client.ExecuteYqlScript(R"( 
+            PRAGMA kikimr.ScanQuery = "true"; 
             UPSERT INTO [/Root/KeyValue]
             SELECT Key, Text AS Value FROM [/Root/EightShard];
-
-            SELECT * FROM [/Root/EightShard];
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::PRECONDITION_FAILED, result.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST(ScanQueryDisable) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            PRAGMA kikimr.ScanQuery = "true";
-            SELECT COUNT(*) FROM [/Root/EightShard] WHERE Text = "Value1";
-            COMMIT;
-
-            PRAGMA kikimr.ScanQuery = default;
-            SELECT COUNT(*) FROM [/Root/EightShard];
-            SELECT COUNT(*) FROM [/Root/TwoShard];
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 3);
-    }
-
-    Y_UNIT_TEST(ScanQueryTruncate) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        setting.SetName("_ResultRowsLimit");
-        setting.SetValue("5");
-
-        TKikimrRunner kikimr({setting});
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            PRAGMA kikimr.ScanQuery = "true";
+ 
             SELECT * FROM [/Root/EightShard];
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1);
-        UNIT_ASSERT(result.GetResultSet(0).Truncated());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 5);
-    }
-
-    Y_UNIT_TEST(QueryStats) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        NYdb::NScripting::TExecuteYqlRequestSettings execSettings;
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::PRECONDITION_FAILED, result.GetIssues().ToString()); 
+    } 
+ 
+    Y_UNIT_TEST(ScanQueryDisable) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            PRAGMA kikimr.ScanQuery = "true"; 
+            SELECT COUNT(*) FROM [/Root/EightShard] WHERE Text = "Value1"; 
+            COMMIT; 
+ 
+            PRAGMA kikimr.ScanQuery = default; 
+            SELECT COUNT(*) FROM [/Root/EightShard]; 
+            SELECT COUNT(*) FROM [/Root/TwoShard]; 
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 3); 
+    } 
+ 
+    Y_UNIT_TEST(ScanQueryTruncate) { 
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        setting.SetName("_ResultRowsLimit"); 
+        setting.SetValue("5"); 
+ 
+        TKikimrRunner kikimr({setting}); 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            PRAGMA kikimr.ScanQuery = "true"; 
+            SELECT * FROM [/Root/EightShard]; 
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1); 
+        UNIT_ASSERT(result.GetResultSet(0).Truncated()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSet(0).RowsCount(), 5); 
+    } 
+ 
+    Y_UNIT_TEST(QueryStats) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        NYdb::NScripting::TExecuteYqlRequestSettings execSettings; 
         execSettings.CollectQueryStats(NYdb::NTable::ECollectQueryStatsMode::Basic);
-
-        auto result = client.ExecuteYqlScript(R"(
-            PRAGMA kikimr.ScanQuery = "false";
-            SELECT COUNT(*) FROM [/Root/EightShard];
-            COMMIT;
-            SELECT COUNT(*) FROM [/Root/TwoShard];
-            COMMIT;
-            PRAGMA kikimr.ScanQuery = "true";
-            SELECT COUNT(*) FROM [/Root/KeyValue];
-        )", execSettings).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 3);
-
-        UNIT_ASSERT(result.GetStats());
-        auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        UNIT_ASSERT(stats.process_cpu_time_us() > 0);
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            PRAGMA kikimr.ScanQuery = "false"; 
+            SELECT COUNT(*) FROM [/Root/EightShard]; 
+            COMMIT; 
+            SELECT COUNT(*) FROM [/Root/TwoShard]; 
+            COMMIT; 
+            PRAGMA kikimr.ScanQuery = "true"; 
+            SELECT COUNT(*) FROM [/Root/KeyValue]; 
+        )", execSettings).GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 3); 
+ 
+        UNIT_ASSERT(result.GetStats()); 
+        auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        UNIT_ASSERT(stats.process_cpu_time_us() > 0); 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 4);
         ui32 phaseNo = 0;
 
         uint64_t totalDurationUs = 0;
         uint64_t totalCpuTimeUs = 0;
 
-        for (auto& phase : stats.query_phases()) {
+        for (auto& phase : stats.query_phases()) { 
             if (phaseNo++ == 3) {
                 UNIT_ASSERT_VALUES_EQUAL(phase.table_access().size(), 0);
                 UNIT_ASSERT(phase.cpu_time_us() > 0);
@@ -183,89 +183,89 @@ Y_UNIT_TEST_SUITE(KqpScripting) {
                 totalCpuTimeUs += phase.cpu_time_us();
                 continue;
             }
-            UNIT_ASSERT_VALUES_EQUAL(phase.table_access().size(), 1);
-            UNIT_ASSERT(phase.table_access(0).partitions_count() > 0);
-            UNIT_ASSERT(phase.table_access(0).reads().rows() > 0);
-            UNIT_ASSERT(phase.table_access(0).reads().bytes() > 0);
-            UNIT_ASSERT(phase.cpu_time_us() > 0);
-            UNIT_ASSERT(phase.affected_shards() > 0);
+            UNIT_ASSERT_VALUES_EQUAL(phase.table_access().size(), 1); 
+            UNIT_ASSERT(phase.table_access(0).partitions_count() > 0); 
+            UNIT_ASSERT(phase.table_access(0).reads().rows() > 0); 
+            UNIT_ASSERT(phase.table_access(0).reads().bytes() > 0); 
+            UNIT_ASSERT(phase.cpu_time_us() > 0); 
+            UNIT_ASSERT(phase.affected_shards() > 0); 
             totalDurationUs += phase.duration_us();
             totalCpuTimeUs += phase.cpu_time_us();
-        }
+        } 
         UNIT_ASSERT_VALUES_EQUAL(stats.total_duration_us(), totalDurationUs);
         UNIT_ASSERT_VALUES_EQUAL(stats.total_cpu_time_us(), totalCpuTimeUs);
-    }
-
-    Y_UNIT_TEST(SystemTables) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
+    } 
+ 
+    Y_UNIT_TEST(SystemTables) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
             SELECT * FROM `/Root/.sys/partition_stats`;
-            COMMIT;
+            COMMIT; 
             SELECT * FROM `/Root/.sys/partition_stats`;
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 2);
-
-        result = client.ExecuteYqlScript(R"(
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 2); 
+ 
+        result = client.ExecuteYqlScript(R"( 
             SELECT * FROM `/Root/.sys/partition_stats`;
             SELECT * FROM `/Root/.sys/partition_stats`;
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        result = client.ExecuteYqlScript(R"(
-            SELECT *
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        result = client.ExecuteYqlScript(R"( 
+            SELECT * 
             FROM `/Root/TwoShard` AS ts
             JOIN `/Root/.sys/partition_stats`AS ps
-            ON ts.Key = ps.PartIdx;
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST(Pure) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            SELECT 1 + 1;
-        )").GetValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1);
-
-        TResultSetParser rs0(result.GetResultSets()[0]);
-        UNIT_ASSERT(rs0.TryNextRow());
-        UNIT_ASSERT_VALUES_EQUAL(rs0.ColumnParser(0).GetInt32(), 2u);
-    }
-
-    Y_UNIT_TEST(NoAstSizeLimit) {
-        NKikimrConfig::TAppConfig appConfig;
-        appConfig.MutableTableServiceConfig()->SetQueryLimitBytes(200);
-
-        TKikimrRunner kikimr(TKikimrSettings()
-            .SetAppConfig(appConfig)
-            .SetWithSampleTables(false));
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
+            ON ts.Key = ps.PartIdx; 
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+    } 
+ 
+    Y_UNIT_TEST(Pure) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            SELECT 1 + 1; 
+        )").GetValueSync(); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1); 
+ 
+        TResultSetParser rs0(result.GetResultSets()[0]); 
+        UNIT_ASSERT(rs0.TryNextRow()); 
+        UNIT_ASSERT_VALUES_EQUAL(rs0.ColumnParser(0).GetInt32(), 2u); 
+    } 
+ 
+    Y_UNIT_TEST(NoAstSizeLimit) { 
+        NKikimrConfig::TAppConfig appConfig; 
+        appConfig.MutableTableServiceConfig()->SetQueryLimitBytes(200); 
+ 
+        TKikimrRunner kikimr(TKikimrSettings() 
+            .SetAppConfig(appConfig) 
+            .SetWithSampleTables(false)); 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
             CREATE TABLE `/Root/TestTable` (
-                Key Uint64,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-
-        result = client.ExecuteYqlScript(R"(
+                Key Uint64, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+ 
+        result = client.ExecuteYqlScript(R"( 
             REPLACE INTO `/Root/TestTable` (Key, Value) VALUES
-                (1u, "One"),
-                (2u, "Two");
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-    }
+                (1u, "One"), 
+                (2u, "Two"); 
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+    } 
 
     Y_UNIT_TEST(ScriptExplain) {
         TKikimrRunner kikimr;
@@ -474,8 +474,8 @@ Y_UNIT_TEST_SUITE(KqpScripting) {
         TKikimrRunner kikimr;
         TScriptingClient client(kikimr.GetDriver());
         auto it = client.StreamExecuteYqlScript(R"(
-            SELECT Key FROM [/Root/EightShard] WHERE Text = "Value1"
-            ORDER BY Key;
+            SELECT Key FROM [/Root/EightShard] WHERE Text = "Value1" 
+            ORDER BY Key; 
             COMMIT;
 
             PRAGMA kikimr.ScanQuery = "true";
@@ -491,11 +491,11 @@ Y_UNIT_TEST_SUITE(KqpScripting) {
         )").GetValueSync();
 
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-        CompareYson(R"([
-            [[[101u]];[[201u]];[[301u]];[[401u]];[[501u]];[[601u]];[[701u]];[[801u]]];
-            [[8u]];
-            [[8u]];
-            [[8u]]])", StreamResultToYson(it));
+        CompareYson(R"([ 
+            [[[101u]];[[201u]];[[301u]];[[401u]];[[501u]];[[601u]];[[701u]];[[801u]]]; 
+            [[8u]]; 
+            [[8u]]; 
+            [[8u]]])", StreamResultToYson(it)); 
     }
 
     Y_UNIT_TEST(StreamExecuteYqlScriptLeadingEmptyScan) {
@@ -631,62 +631,62 @@ Y_UNIT_TEST_SUITE(KqpScripting) {
         auto streamPart = it.ReadNext().GetValueSync();
         UNIT_ASSERT_VALUES_EQUAL_C(streamPart.GetStatus(), EStatus::TIMEOUT, it.GetIssues().ToString());
     }
-
-    Y_UNIT_TEST(SecondaryIndexes) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-        CreateSampleTablesWithIndex(session);
-
-        TScriptingClient client(kikimr.GetDriver());
-        auto it = client.StreamExecuteYqlScript(R"(
-            --!syntax_v1
-
-            SELECT Value
-            FROM `/Root/SecondaryKeys` VIEW Index
-            WHERE Fk = 5;
-        )").GetValueSync();
-        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[["Payload5"]]]
-        ])", StreamResultToYson(it));
-    }
-
-    Y_UNIT_TEST(JoinIndexLookup) {
-        TKikimrRunner kikimr;
-
-        auto settings = TExecuteYqlRequestSettings()
-            .CollectQueryStats(NYdb::NTable::ECollectQueryStatsMode::Basic);
-
-        TScriptingClient client(kikimr.GetDriver());
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
-
-            SELECT Key, Value2 FROM Join1 AS j1
-            JOIN Join2 AS j2
-            ON j1.Fk21 = j2.Key1 AND j1.Fk22 = j2.Key2
-            WHERE Key = 1;
-        )", settings).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1);
-
-        UNIT_ASSERT(result.GetStats());
-        auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        for (auto& phase : stats.query_phases()) {
-            for (auto& table : phase.table_access()) {
+ 
+    Y_UNIT_TEST(SecondaryIndexes) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+        CreateSampleTablesWithIndex(session); 
+ 
+        TScriptingClient client(kikimr.GetDriver()); 
+        auto it = client.StreamExecuteYqlScript(R"( 
+            --!syntax_v1 
+ 
+            SELECT Value 
+            FROM `/Root/SecondaryKeys` VIEW Index 
+            WHERE Fk = 5; 
+        )").GetValueSync(); 
+        UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[["Payload5"]]] 
+        ])", StreamResultToYson(it)); 
+    } 
+ 
+    Y_UNIT_TEST(JoinIndexLookup) { 
+        TKikimrRunner kikimr; 
+ 
+        auto settings = TExecuteYqlRequestSettings() 
+            .CollectQueryStats(NYdb::NTable::ECollectQueryStatsMode::Basic); 
+ 
+        TScriptingClient client(kikimr.GetDriver()); 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
+ 
+            SELECT Key, Value2 FROM Join1 AS j1 
+            JOIN Join2 AS j2 
+            ON j1.Fk21 = j2.Key1 AND j1.Fk22 = j2.Key2 
+            WHERE Key = 1; 
+        )", settings).GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetResultSets().size(), 1); 
+ 
+        UNIT_ASSERT(result.GetStats()); 
+        auto stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        for (auto& phase : stats.query_phases()) { 
+            for (auto& table : phase.table_access()) { 
                 if (table.has_reads()) {
                     UNIT_ASSERT_VALUES_EQUAL(table.reads().rows(), 1);
                 }
-            }
-        }
-
-        CompareYson(R"([
-            [[1];["Value21"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-}
-
+            } 
+        } 
+ 
+        CompareYson(R"([ 
+            [[1];["Value21"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_service_ut.cpp b/ydb/core/kqp/ut/kqp_service_ut.cpp
index 37e178c810..7bc6c63895 100644
--- a/ydb/core/kqp/ut/kqp_service_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_service_ut.cpp
@@ -1,133 +1,133 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <library/cpp/threading/local_executor/local_executor.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-Y_UNIT_TEST_SUITE(KqpService) {
-    Y_UNIT_TEST(Shutdown) {
-        const ui32 Inflight = 50;
-        const TDuration WaitDuration = TDuration::Seconds(1);
-
-        THolder<TKikimrRunner> kikimr;
-        kikimr.Reset(MakeHolder<TKikimrRunner>());
-
-        NPar::LocalExecutor().RunAdditionalThreads(Inflight);
-        auto driverConfig = kikimr->GetDriverConfig();
-
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+Y_UNIT_TEST_SUITE(KqpService) { 
+    Y_UNIT_TEST(Shutdown) { 
+        const ui32 Inflight = 50; 
+        const TDuration WaitDuration = TDuration::Seconds(1); 
+ 
+        THolder<TKikimrRunner> kikimr; 
+        kikimr.Reset(MakeHolder<TKikimrRunner>()); 
+ 
+        NPar::LocalExecutor().RunAdditionalThreads(Inflight); 
+        auto driverConfig = kikimr->GetDriverConfig(); 
+ 
         NYdb::TDriver driver(driverConfig);
         NPar::LocalExecutor().ExecRange([driver](int id) {
-            NYdb::NTable::TTableClient db(driver);
-
-            auto sessionResult = db.CreateSession().GetValueSync();
-            if (!sessionResult.IsSuccess()) {
-                if (!sessionResult.IsTransportError()) {
-                    sessionResult.GetIssues().PrintTo(Cerr);
-                }
-
-                return;
-            }
-
-            auto session = sessionResult.GetSession();
-
-            while (true) {
-                auto params = session.GetParamsBuilder()
-                    .AddParam("$key").Uint32(id).Build()
-                    .AddParam("$value").Int32(id).Build()
-                    .Build();
-
-                auto result = session.ExecuteDataQuery(R"(
-                    DECLARE $key AS Uint32;
-                    DECLARE $value AS Int32;
-
+            NYdb::NTable::TTableClient db(driver); 
+ 
+            auto sessionResult = db.CreateSession().GetValueSync(); 
+            if (!sessionResult.IsSuccess()) { 
+                if (!sessionResult.IsTransportError()) { 
+                    sessionResult.GetIssues().PrintTo(Cerr); 
+                } 
+ 
+                return; 
+            } 
+ 
+            auto session = sessionResult.GetSession(); 
+ 
+            while (true) { 
+                auto params = session.GetParamsBuilder() 
+                    .AddParam("$key").Uint32(id).Build() 
+                    .AddParam("$value").Int32(id).Build() 
+                    .Build(); 
+ 
+                auto result = session.ExecuteDataQuery(R"( 
+                    DECLARE $key AS Uint32; 
+                    DECLARE $value AS Int32; 
+ 
                     SELECT * FROM [/Root/EightShard];
-
+ 
                     UPSERT INTO [/Root/TwoShard] (Key, Value2) VALUES
-                        ($key, $value);
-                )", TTxControl::BeginTx().CommitTx(), params).GetValueSync();
-
-                if (result.IsTransportError()) {
-                    return;
-                }
-
-                result.GetIssues().PrintTo(Cerr);
-            }
-
-        }, 0, Inflight, NPar::TLocalExecutor::MED_PRIORITY);
-
-        Sleep(WaitDuration);
-        kikimr.Reset();
-        Sleep(WaitDuration);
+                        ($key, $value); 
+                )", TTxControl::BeginTx().CommitTx(), params).GetValueSync(); 
+ 
+                if (result.IsTransportError()) { 
+                    return; 
+                } 
+ 
+                result.GetIssues().PrintTo(Cerr); 
+            } 
+ 
+        }, 0, Inflight, NPar::TLocalExecutor::MED_PRIORITY); 
+ 
+        Sleep(WaitDuration); 
+        kikimr.Reset(); 
+        Sleep(WaitDuration); 
         driver.Stop(true);
-    }
-
-    Y_UNIT_TEST(CloseSessionsWithLoad) {
+    } 
+ 
+    Y_UNIT_TEST(CloseSessionsWithLoad) { 
         auto kikimr = std::make_shared<TKikimrRunner>();
-        auto db = kikimr->GetTableClient();
-
-        const ui32 SessionsCount = 50;
-        const TDuration WaitDuration = TDuration::Seconds(1);
-
-        TVector<TSession> sessions;
-        for (ui32 i = 0; i < SessionsCount; ++i) {
-            auto sessionResult = db.CreateSession().GetValueSync();
-            UNIT_ASSERT_C(sessionResult.IsSuccess(), sessionResult.GetIssues().ToString());
-
-            sessions.push_back(sessionResult.GetSession());
-        }
-
-        NPar::LocalExecutor().RunAdditionalThreads(SessionsCount + 1);
-        NPar::LocalExecutor().ExecRange([kikimr, sessions, WaitDuration](int id) mutable {
-            if (id == (i32)sessions.size()) {
-                Sleep(WaitDuration);
-
-                for (ui32 i = 0; i < sessions.size(); ++i) {
-                    sessions[i].Close();
-                }
-
-                return;
-            }
-
-            auto session = sessions[id];
-            TMaybe<TTransaction> tx;
-
-            while (true) {
-                if (tx) {
-                    auto result = tx->Commit().GetValueSync();
-                    if (!result.IsSuccess()) {
-                        return;
-                    }
-
-                    tx = {};
-                    continue;
-                }
-
-                auto query = Sprintf(R"(
+        auto db = kikimr->GetTableClient(); 
+ 
+        const ui32 SessionsCount = 50; 
+        const TDuration WaitDuration = TDuration::Seconds(1); 
+ 
+        TVector<TSession> sessions; 
+        for (ui32 i = 0; i < SessionsCount; ++i) { 
+            auto sessionResult = db.CreateSession().GetValueSync(); 
+            UNIT_ASSERT_C(sessionResult.IsSuccess(), sessionResult.GetIssues().ToString()); 
+ 
+            sessions.push_back(sessionResult.GetSession()); 
+        } 
+ 
+        NPar::LocalExecutor().RunAdditionalThreads(SessionsCount + 1); 
+        NPar::LocalExecutor().ExecRange([kikimr, sessions, WaitDuration](int id) mutable { 
+            if (id == (i32)sessions.size()) { 
+                Sleep(WaitDuration); 
+ 
+                for (ui32 i = 0; i < sessions.size(); ++i) { 
+                    sessions[i].Close(); 
+                } 
+ 
+                return; 
+            } 
+ 
+            auto session = sessions[id]; 
+            TMaybe<TTransaction> tx; 
+ 
+            while (true) { 
+                if (tx) { 
+                    auto result = tx->Commit().GetValueSync(); 
+                    if (!result.IsSuccess()) { 
+                        return; 
+                    } 
+ 
+                    tx = {}; 
+                    continue; 
+                } 
+ 
+                auto query = Sprintf(R"( 
                     SELECT Key, Text, Data FROM [/Root/EightShard] WHERE Key=%1$d + 0;
                     SELECT Key, Data, Text FROM [/Root/EightShard] WHERE Key=%1$d + 1;
                     SELECT Text, Key, Data FROM [/Root/EightShard] WHERE Key=%1$d + 2;
                     SELECT Text, Data, Key FROM [/Root/EightShard] WHERE Key=%1$d + 3;
                     SELECT Data, Key, Text FROM [/Root/EightShard] WHERE Key=%1$d + 4;
                     SELECT Data, Text, Key FROM [/Root/EightShard] WHERE Key=%1$d + 5;
-
+ 
                     UPSERT INTO [/Root/EightShard] (Key, Text) VALUES
-                        (%2$dul, "New");
-                )", RandomNumber<ui32>(), RandomNumber<ui32>());
-
-                auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx()).GetValueSync();
-                if (!result.IsSuccess()) {
-                    return;
-                }
-
-                tx = result.GetTransaction();
-            }
-        }, 0, SessionsCount + 1, NPar::TLocalExecutor::WAIT_COMPLETE | NPar::TLocalExecutor::MED_PRIORITY);
-    }
-
+                        (%2$dul, "New"); 
+                )", RandomNumber<ui32>(), RandomNumber<ui32>()); 
+ 
+                auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx()).GetValueSync(); 
+                if (!result.IsSuccess()) { 
+                    return; 
+                } 
+ 
+                tx = result.GetTransaction(); 
+            } 
+        }, 0, SessionsCount + 1, NPar::TLocalExecutor::WAIT_COMPLETE | NPar::TLocalExecutor::MED_PRIORITY); 
+    } 
+ 
     TVector<TAsyncDataQueryResult> simulateSessionBusy(ui32 count, TSession& session) {
         TVector<TAsyncDataQueryResult> futures;
         for (ui32 i = 0; i < count; ++i) {
@@ -141,25 +141,25 @@ Y_UNIT_TEST_SUITE(KqpService) {
         return futures;
     }
 
-    Y_UNIT_TEST(SessionBusy) {
-        NKikimrConfig::TAppConfig appConfig;
-        appConfig.MutableTableServiceConfig()->SetUseSessionBusyStatus(true);
-
-        TKikimrRunner kikimr(appConfig);
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+    Y_UNIT_TEST(SessionBusy) { 
+        NKikimrConfig::TAppConfig appConfig; 
+        appConfig.MutableTableServiceConfig()->SetUseSessionBusyStatus(true); 
+ 
+        TKikimrRunner kikimr(appConfig); 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto futures = simulateSessionBusy(10, session);
-
+ 
         NThreading::WaitExceptionOrAll(futures).GetValueSync();
-
-        for (auto& future : futures) {
-            auto result = future.GetValue();
-            if (!result.IsSuccess()) {
-                UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SESSION_BUSY, result.GetIssues().ToString());
-            }
-        }
-    }
+ 
+        for (auto& future : futures) { 
+            auto result = future.GetValue(); 
+            if (!result.IsSuccess()) { 
+                UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SESSION_BUSY, result.GetIssues().ToString()); 
+            } 
+        } 
+    } 
 
     Y_UNIT_TEST(SessionBusyRetryOperation) {
         NKikimrConfig::TAppConfig appConfig;
@@ -225,7 +225,7 @@ Y_UNIT_TEST_SUITE(KqpService) {
          UNIT_ASSERT_VALUES_EQUAL_C(status.GetStatus(), EStatus::SUCCESS, status.GetIssues().ToString());
     }
 
-}
-
-} // namspace NKqp
-} // namespace NKikimr
+} 
+ 
+} // namspace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_sort_ut.cpp b/ydb/core/kqp/ut/kqp_sort_ut.cpp
index 0b7c65a3d5..df9d1a0b04 100644
--- a/ydb/core/kqp/ut/kqp_sort_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_sort_ut.cpp
@@ -6,7 +6,7 @@ namespace NKqp {
 using namespace NYdb;
 using namespace NYdb::NTable;
 
-Y_UNIT_TEST_SUITE(KqpSort) {
+Y_UNIT_TEST_SUITE(KqpSort) { 
     Y_UNIT_TEST_NEW_ENGINE(ReverseDefault) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -21,12 +21,12 @@ Y_UNIT_TEST_SUITE(KqpSort) {
         {
             auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-
-            CompareYson(R"([
-                [[2u];["Tony"];[7200u];["None"]];
-                [[1u];["Paul"];[300u];["None"]];
-                [[1u];["Anna"];[3500u];["None"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
+ 
+            CompareYson(R"([ 
+                [[2u];["Tony"];[7200u];["None"]]; 
+                [[1u];["Paul"];[300u];["None"]]; 
+                [[1u];["Anna"];[3500u];["None"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
         }
     }
 
@@ -66,11 +66,11 @@ Y_UNIT_TEST_SUITE(KqpSort) {
         {
             auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            CompareYson(R"([
-                [[2u];["Tony"];[7200u];["None"]];
-                [[1u];["Paul"];[300u];["None"]];
-                [[1u];["Anna"];[3500u];["None"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
+            CompareYson(R"([ 
+                [[2u];["Tony"];[7200u];["None"]]; 
+                [[1u];["Paul"];[300u];["None"]]; 
+                [[1u];["Anna"];[3500u];["None"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
         }
     }
 
@@ -154,11 +154,11 @@ Y_UNIT_TEST_SUITE(KqpSort) {
         {
             auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            CompareYson(R"([
-                [[2u];["Tony"];[7200u];["None"]];
-                [[1u];["Paul"];[300u];["None"]];
-                [[1u];["Anna"];[3500u];["None"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
+            CompareYson(R"([ 
+                [[2u];["Tony"];[7200u];["None"]]; 
+                [[1u];["Paul"];[300u];["None"]]; 
+                [[1u];["Anna"];[3500u];["None"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
         }
     }
 
@@ -197,11 +197,11 @@ Y_UNIT_TEST_SUITE(KqpSort) {
         {
             auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            CompareYson(R"([
-                [[2u];["Tony"];[7200u];["None"]];
-                [[1u];["Anna"];[3500u];["None"]];
-                [[1u];["Paul"];[300u];["None"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
+            CompareYson(R"([ 
+                [[2u];["Tony"];[7200u];["None"]]; 
+                [[1u];["Anna"];[3500u];["None"]]; 
+                [[1u];["Paul"];[300u];["None"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
         }
     }
 
@@ -243,10 +243,10 @@ Y_UNIT_TEST_SUITE(KqpSort) {
         {
             auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            CompareYson(R"([
-                [[1u];["Paul"];[300u];["None"]];
-                [[1u];["Anna"];[3500u];["None"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
+            CompareYson(R"([ 
+                [[1u];["Paul"];[300u];["None"]]; 
+                [[1u];["Anna"];[3500u];["None"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
         }
     }
 
@@ -293,9 +293,9 @@ Y_UNIT_TEST_SUITE(KqpSort) {
         {
             auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            CompareYson(R"([
-                [[2u];["Tony"];[7200u];["None"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
+            CompareYson(R"([ 
+                [[2u];["Tony"];[7200u];["None"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
         }
     }
 
@@ -343,9 +343,9 @@ Y_UNIT_TEST_SUITE(KqpSort) {
         {
             auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            CompareYson(R"([
-                [[1u];["Paul"];[300u];["None"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
+            CompareYson(R"([ 
+                [[1u];["Paul"];[300u];["None"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
         }
     }
 
@@ -389,40 +389,40 @@ Y_UNIT_TEST_SUITE(KqpSort) {
         {
             auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
-            CompareYson(R"([
-                [[803u];["Value3"];[3]];
-                [[802u];["Value2"];[1]];
-                [[801u];["Value1"];[2]];
-                [[703u];["Value3"];[2]];
-                [[702u];["Value2"];[3]];
-                [[701u];["Value1"];[1]];
-                [[603u];["Value3"];[1]];
-                [[602u];["Value2"];[2]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
+            CompareYson(R"([ 
+                [[803u];["Value3"];[3]]; 
+                [[802u];["Value2"];[1]]; 
+                [[801u];["Value1"];[2]]; 
+                [[703u];["Value3"];[2]]; 
+                [[702u];["Value2"];[3]]; 
+                [[701u];["Value1"];[1]]; 
+                [[603u];["Value3"];[1]]; 
+                [[602u];["Value2"];[2]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
         }
     }
 
     Y_UNIT_TEST_NEW_ENGINE(TopSortParameter) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         TString query = Q_(R"(
-            DECLARE $limit AS Uint32;
-            DECLARE $offset AS Uint32;
-            DECLARE $minKey AS Uint64;
-
-            SELECT *
+            DECLARE $limit AS Uint32; 
+            DECLARE $offset AS Uint32; 
+            DECLARE $minKey AS Uint64; 
+ 
+            SELECT * 
             FROM `/Root/EightShard`
-            WHERE Key >= $minKey
-            ORDER BY Data, Key DESC
-            LIMIT $limit OFFSET $offset;
-        )");
-
+            WHERE Key >= $minKey 
+            ORDER BY Data, Key DESC 
+            LIMIT $limit OFFSET $offset; 
+        )"); 
+ 
         {
-            auto result = session.ExplainDataQuery(query).GetValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            auto result = session.ExplainDataQuery(query).GetValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
 
             if (UseNewEngine) {
                 NJson::TJsonValue plan;
@@ -432,55 +432,55 @@ Y_UNIT_TEST_SUITE(KqpSort) {
             } else {
                 UNIT_ASSERT_C(result.GetAst().Contains("KiPartialTake"), result.GetAst());
             }
-        }
-
-        {
-            auto params = db.GetParamsBuilder()
-                .AddParam("$limit")
-                    .Uint32(5)
-                    .Build()
-                .AddParam("$offset")
-                    .Uint32(3)
-                    .Build()
-                .AddParam("$minKey")
-                    .Uint64(300)
-                    .Build()
-                .Build();
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-            UNIT_ASSERT(result.IsSuccess());
-
-            CompareYson(R"([
-                [[1];[502u];["Value2"]];
-                [[1];[401u];["Value1"]];
-                [[1];[303u];["Value3"]];
-                [[2];[801u];["Value1"]];
-                [[2];[703u];["Value3"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
-        }
-    }
-
+        } 
+ 
+        { 
+            auto params = db.GetParamsBuilder() 
+                .AddParam("$limit") 
+                    .Uint32(5) 
+                    .Build() 
+                .AddParam("$offset") 
+                    .Uint32(3) 
+                    .Build() 
+                .AddParam("$minKey") 
+                    .Uint64(300) 
+                    .Build() 
+                .Build(); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+            UNIT_ASSERT(result.IsSuccess()); 
+ 
+            CompareYson(R"([ 
+                [[1];[502u];["Value2"]]; 
+                [[1];[401u];["Value1"]]; 
+                [[1];[303u];["Value3"]]; 
+                [[2];[801u];["Value1"]]; 
+                [[2];[703u];["Value3"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
+        } 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(TopSortExpr) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         TString query = Q_(R"(
-            DECLARE $limit AS Uint32;
-            DECLARE $offset AS Uint32;
-            DECLARE $minKey AS Uint64;
-
-            SELECT *
+            DECLARE $limit AS Uint32; 
+            DECLARE $offset AS Uint32; 
+            DECLARE $minKey AS Uint64; 
+ 
+            SELECT * 
             FROM `/Root/EightShard`
-            WHERE Key >= $minKey
-            ORDER BY Data, Key DESC
-            LIMIT $limit + 1 OFFSET $offset - 1;
-        )");
-
+            WHERE Key >= $minKey 
+            ORDER BY Data, Key DESC 
+            LIMIT $limit + 1 OFFSET $offset - 1; 
+        )"); 
+ 
         {
-            auto result = session.ExplainDataQuery(query).GetValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
+            auto result = session.ExplainDataQuery(query).GetValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
 
             if (UseNewEngine) {
                 NJson::TJsonValue plan;
@@ -490,84 +490,84 @@ Y_UNIT_TEST_SUITE(KqpSort) {
             } else {
                 UNIT_ASSERT_C(result.GetAst().Contains("KiPartialTake"), result.GetAst());
             }
-        }
-
-        {
-            auto params = db.GetParamsBuilder()
-                .AddParam("$limit")
-                    .Uint32(4)
-                    .Build()
-                .AddParam("$offset")
-                    .Uint32(4)
-                    .Build()
-                .AddParam("$minKey")
-                    .Uint64(300)
-                    .Build()
-                .Build();
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-            UNIT_ASSERT(result.IsSuccess());
-
-            CompareYson(R"([
-                [[1];[502u];["Value2"]];
-                [[1];[401u];["Value1"]];
-                [[1];[303u];["Value3"]];
-                [[2];[801u];["Value1"]];
-                [[2];[703u];["Value3"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
-        }
-    }
-
+        } 
+ 
+        { 
+            auto params = db.GetParamsBuilder() 
+                .AddParam("$limit") 
+                    .Uint32(4) 
+                    .Build() 
+                .AddParam("$offset") 
+                    .Uint32(4) 
+                    .Build() 
+                .AddParam("$minKey") 
+                    .Uint64(300) 
+                    .Build() 
+                .Build(); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+            UNIT_ASSERT(result.IsSuccess()); 
+ 
+            CompareYson(R"([ 
+                [[1];[502u];["Value2"]]; 
+                [[1];[401u];["Value1"]]; 
+                [[1];[303u];["Value3"]]; 
+                [[2];[801u];["Value1"]]; 
+                [[2];[703u];["Value3"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
+        } 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(TopSortExprPk) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         TString query = Q_(R"(
-            DECLARE $limit AS Uint32;
-            DECLARE $offset AS Uint32;
-            DECLARE $minKey AS Uint64;
-
-            SELECT *
+            DECLARE $limit AS Uint32; 
+            DECLARE $offset AS Uint32; 
+            DECLARE $minKey AS Uint64; 
+ 
+            SELECT * 
             FROM `/Root/EightShard`
-            WHERE Key >= $minKey
-            ORDER BY Key
-            LIMIT $limit + 1 OFFSET $offset - 1;
-        )");
-
-        {
-            auto result = session.ExplainDataQuery(query).GetValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-            UNIT_ASSERT_C(result.GetAst().Contains("ItemsLimit"), result.GetAst());
-        }
-
+            WHERE Key >= $minKey 
+            ORDER BY Key 
+            LIMIT $limit + 1 OFFSET $offset - 1; 
+        )"); 
+ 
         {
-            auto params = db.GetParamsBuilder()
-                .AddParam("$limit")
-                    .Uint32(4)
-                    .Build()
-                .AddParam("$offset")
-                    .Uint32(4)
-                    .Build()
-                .AddParam("$minKey")
-                    .Uint64(300)
-                    .Build()
-                .Build();
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-            UNIT_ASSERT(result.IsSuccess());
-
-            CompareYson(R"([
-                [[1];[401u];["Value1"]];
-                [[3];[402u];["Value2"]];
-                [[2];[403u];["Value3"]];
-                [[2];[501u];["Value1"]];
-                [[1];[502u];["Value2"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
-        }
-    }
-
+            auto result = session.ExplainDataQuery(query).GetValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+            UNIT_ASSERT_C(result.GetAst().Contains("ItemsLimit"), result.GetAst()); 
+        } 
+ 
+        { 
+            auto params = db.GetParamsBuilder() 
+                .AddParam("$limit") 
+                    .Uint32(4) 
+                    .Build() 
+                .AddParam("$offset") 
+                    .Uint32(4) 
+                    .Build() 
+                .AddParam("$minKey") 
+                    .Uint64(300) 
+                    .Build() 
+                .Build(); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+            UNIT_ASSERT(result.IsSuccess()); 
+ 
+            CompareYson(R"([ 
+                [[1];[401u];["Value1"]]; 
+                [[3];[402u];["Value2"]]; 
+                [[2];[403u];["Value3"]]; 
+                [[2];[501u];["Value1"]]; 
+                [[1];[502u];["Value2"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
+        } 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(ComplexPkExclusiveSecondOptionalPredicate) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -781,212 +781,212 @@ Y_UNIT_TEST_SUITE(KqpSort) {
     }
 
     Y_UNIT_TEST_NEW_ENGINE(TopSortTableExpr) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         TString query = Q_(R"(
-            DECLARE $key AS Uint32;
-
-            $fetch = (
+            DECLARE $key AS Uint32; 
+ 
+            $fetch = ( 
                 SELECT Value2 + 1 AS ComputedLimit FROM `/Root/TwoShard`
-                WHERE Key = $key
-            );
-
-            SELECT *
+                WHERE Key = $key 
+            ); 
+ 
+            SELECT * 
             FROM `/Root/EightShard`
-            ORDER BY Data DESC, Key
-            LIMIT CAST($fetch AS Uint64) ?? 0;
-        )");
-
-        {
-            auto result = session.ExplainDataQuery(query).GetValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-            UNIT_ASSERT_C(!result.GetAst().Contains("KiPartialTake"), result.GetAst());
-        }
-
-        {
-            auto params = db.GetParamsBuilder()
-                .AddParam("$key")
-                    .Uint32(3)
-                    .Build()
-                .Build();
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-            UNIT_ASSERT(result.IsSuccess());
-
-            CompareYson(R"([
-                [[3];[102u];["Value2"]];
-                [[3];[203u];["Value3"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
-        }
-    }
-
+            ORDER BY Data DESC, Key 
+            LIMIT CAST($fetch AS Uint64) ?? 0; 
+        )"); 
+ 
+        { 
+            auto result = session.ExplainDataQuery(query).GetValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+            UNIT_ASSERT_C(!result.GetAst().Contains("KiPartialTake"), result.GetAst()); 
+        } 
+ 
+        { 
+            auto params = db.GetParamsBuilder() 
+                .AddParam("$key") 
+                    .Uint32(3) 
+                    .Build() 
+                .Build(); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+            UNIT_ASSERT(result.IsSuccess()); 
+ 
+            CompareYson(R"([ 
+                [[3];[102u];["Value2"]]; 
+                [[3];[203u];["Value3"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
+        } 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(TopSortTableExprOffset) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         TString query = Q_(R"(
-            DECLARE $key AS Uint32;
-
-            $fetch = (
+            DECLARE $key AS Uint32; 
+ 
+            $fetch = ( 
                 SELECT Value2 + 1 AS Take FROM `/Root/TwoShard`
-                WHERE Key = $key
-            );
-
-            SELECT *
+                WHERE Key = $key 
+            ); 
+ 
+            SELECT * 
             FROM `/Root/EightShard`
-            ORDER BY Data DESC, Key
-            LIMIT 2 OFFSET CAST($fetch AS Uint64) ?? 0;
-        )");
-
-        {
-            auto result = session.ExplainDataQuery(query).GetValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-            UNIT_ASSERT_C(!result.GetAst().Contains("KiPartialTake"), result.GetAst());
-        }
-
-        {
-            auto params = db.GetParamsBuilder()
-                .AddParam("$key")
-                    .Uint32(3)
-                    .Build()
-                .Build();
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-            UNIT_ASSERT(result.IsSuccess());
-
-            CompareYson(R"([
-                [[3];[301u];["Value1"]];
-                [[3];[402u];["Value2"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
-        }
-    }
-
+            ORDER BY Data DESC, Key 
+            LIMIT 2 OFFSET CAST($fetch AS Uint64) ?? 0; 
+        )"); 
+ 
+        { 
+            auto result = session.ExplainDataQuery(query).GetValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+            UNIT_ASSERT_C(!result.GetAst().Contains("KiPartialTake"), result.GetAst()); 
+        } 
+ 
+        { 
+            auto params = db.GetParamsBuilder() 
+                .AddParam("$key") 
+                    .Uint32(3) 
+                    .Build() 
+                .Build(); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+            UNIT_ASSERT(result.IsSuccess()); 
+ 
+            CompareYson(R"([ 
+                [[3];[301u];["Value1"]]; 
+                [[3];[402u];["Value2"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
+        } 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(TopSortResults) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto table = db.GetTableBuilder()
-            .AddNullableColumn("Key", EPrimitiveType::Uint64)
-            .AddNullableColumn("Value1", EPrimitiveType::Int32)
-            .AddNullableColumn("Value2", EPrimitiveType::String)
-            .AddNullableColumn("Value3", EPrimitiveType::Uint32)
-            .SetPrimaryKeyColumns(TVector<TString>{"Key"})
-            .Build();
-
-        auto createSettings = TCreateTableSettings()
-            .PartitioningPolicy(TPartitioningPolicy().UniformPartitions(10));
-
-        auto tableResult = session.CreateTable("/Root/TopSortTest", std::move(table),
-            createSettings).ExtractValueSync();
-        tableResult.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(tableResult.IsSuccess());
-
-        const ui32 BatchSize = 200;
-        const ui32 BatchCount = 5;
-        for (ui32 i = 0; i < BatchCount; ++i) {
-            auto paramsBuilder = session.GetParamsBuilder();
-            auto& rowsParam = paramsBuilder.AddParam("$rows");
-
-            rowsParam.BeginList();
-            for (ui32 j = 0; j < BatchSize; ++j) {
-                rowsParam.AddListItem()
-                    .BeginStruct()
-                    .AddMember("Key").Uint64(RandomNumber<ui64>())
-                    .AddMember("Value1").Int32(i)
-                    .AddMember("Value2").String(CreateGuidAsString())
-                    .AddMember("Value3").Uint32(RandomNumber<ui32>())
-                    .EndStruct();
-            }
-            rowsParam.EndList();
-            rowsParam.Build();
-
-            auto result = session.ExecuteDataQuery(R"(
-                DECLARE $rows AS
-                    'List<Struct<
-                        Key: Uint64,
-                        Value1: Int32,
-                        Value2: String,
-                        Value3: Uint32>>';
-
-                REPLACE INTO [/Root/TopSortTest]
-                SELECT * FROM AS_TABLE($rows);
-            )", TTxControl::BeginTx().CommitTx(), paramsBuilder.Build(),
-                TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync();
-
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT(result.IsSuccess());
-        }
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto table = db.GetTableBuilder() 
+            .AddNullableColumn("Key", EPrimitiveType::Uint64) 
+            .AddNullableColumn("Value1", EPrimitiveType::Int32) 
+            .AddNullableColumn("Value2", EPrimitiveType::String) 
+            .AddNullableColumn("Value3", EPrimitiveType::Uint32) 
+            .SetPrimaryKeyColumns(TVector<TString>{"Key"}) 
+            .Build(); 
+ 
+        auto createSettings = TCreateTableSettings() 
+            .PartitioningPolicy(TPartitioningPolicy().UniformPartitions(10)); 
+ 
+        auto tableResult = session.CreateTable("/Root/TopSortTest", std::move(table), 
+            createSettings).ExtractValueSync(); 
+        tableResult.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(tableResult.IsSuccess()); 
+ 
+        const ui32 BatchSize = 200; 
+        const ui32 BatchCount = 5; 
+        for (ui32 i = 0; i < BatchCount; ++i) { 
+            auto paramsBuilder = session.GetParamsBuilder(); 
+            auto& rowsParam = paramsBuilder.AddParam("$rows"); 
+ 
+            rowsParam.BeginList(); 
+            for (ui32 j = 0; j < BatchSize; ++j) { 
+                rowsParam.AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Key").Uint64(RandomNumber<ui64>()) 
+                    .AddMember("Value1").Int32(i) 
+                    .AddMember("Value2").String(CreateGuidAsString()) 
+                    .AddMember("Value3").Uint32(RandomNumber<ui32>()) 
+                    .EndStruct(); 
+            } 
+            rowsParam.EndList(); 
+            rowsParam.Build(); 
+ 
+            auto result = session.ExecuteDataQuery(R"( 
+                DECLARE $rows AS 
+                    'List<Struct< 
+                        Key: Uint64, 
+                        Value1: Int32, 
+                        Value2: String, 
+                        Value3: Uint32>>'; 
+ 
+                REPLACE INTO [/Root/TopSortTest] 
+                SELECT * FROM AS_TABLE($rows); 
+            )", TTxControl::BeginTx().CommitTx(), paramsBuilder.Build(), 
+                TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync(); 
+ 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT(result.IsSuccess()); 
+        } 
+ 
         auto queryTemplate = Q_(R"(
-            PRAGMA kikimr.OptDisableTopSort = '%s';
-
-            DECLARE $filter AS Int32;
-            DECLARE $limit AS Uint64;
-            DECLARE $offset AS Uint64;
-
-            SELECT * FROM [/Root/TopSortTest]
-            WHERE Value1 != $filter
-            ORDER BY Value2 DESC, Value3, Key DESC
-            LIMIT $limit OFFSET $offset;
+            PRAGMA kikimr.OptDisableTopSort = '%s'; 
+ 
+            DECLARE $filter AS Int32; 
+            DECLARE $limit AS Uint64; 
+            DECLARE $offset AS Uint64; 
+ 
+            SELECT * FROM [/Root/TopSortTest] 
+            WHERE Value1 != $filter 
+            ORDER BY Value2 DESC, Value3, Key DESC 
+            LIMIT $limit OFFSET $offset; 
         )");
-
+ 
         auto query = Sprintf(queryTemplate.c_str(), "False");
         auto queryDisabled = Sprintf(queryTemplate.c_str(), "True");
-
-        const ui32 QueriesCount = 20;
-        for (ui32 i = 0; i < QueriesCount; ++i) {
-            auto params = db.GetParamsBuilder()
-                .AddParam("$filter")
-                    .Int32(RandomNumber<ui32>(BatchCount))
-                    .Build()
-                .AddParam("$limit")
-                    .Uint64(RandomNumber<ui64>(BatchSize * BatchCount))
-                    .Build()
-                .AddParam("$offset")
-                    .Uint64(RandomNumber<ui64>(BatchSize * BatchCount))
-                    .Build()
-                .Build();
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params,
-                TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT(result.IsSuccess());
-
-            auto resultDisabled = session.ExecuteDataQuery(queryDisabled, TTxControl::BeginTx().CommitTx(), params,
-                TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync();
-            resultDisabled.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT(resultDisabled.IsSuccess());
-
-            CompareYson(FormatResultSetYson(result.GetResultSet(0)),
-                FormatResultSetYson(resultDisabled.GetResultSet(0)));
-        }
-    }
-
+ 
+        const ui32 QueriesCount = 20; 
+        for (ui32 i = 0; i < QueriesCount; ++i) { 
+            auto params = db.GetParamsBuilder() 
+                .AddParam("$filter") 
+                    .Int32(RandomNumber<ui32>(BatchCount)) 
+                    .Build() 
+                .AddParam("$limit") 
+                    .Uint64(RandomNumber<ui64>(BatchSize * BatchCount)) 
+                    .Build() 
+                .AddParam("$offset") 
+                    .Uint64(RandomNumber<ui64>(BatchSize * BatchCount)) 
+                    .Build() 
+                .Build(); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params, 
+                TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT(result.IsSuccess()); 
+ 
+            auto resultDisabled = session.ExecuteDataQuery(queryDisabled, TTxControl::BeginTx().CommitTx(), params, 
+                TExecDataQuerySettings().KeepInQueryCache(true)).ExtractValueSync(); 
+            resultDisabled.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT(resultDisabled.IsSuccess()); 
+ 
+            CompareYson(FormatResultSetYson(result.GetResultSet(0)), 
+                FormatResultSetYson(resultDisabled.GetResultSet(0))); 
+        } 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(TopParameter) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         TString query = Q_(R"(
-            DECLARE $limit AS Uint64;
-
-            SELECT *
+            DECLARE $limit AS Uint64; 
+ 
+            SELECT * 
             FROM `/Root/TwoShard`
             ORDER BY Key
-            LIMIT $limit;
-        )");
-
+            LIMIT $limit; 
+        )"); 
+ 
         {
-            auto result = session.ExplainDataQuery(query).GetValueSync();
-            result.GetIssues().PrintTo(Cerr);
-
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+            auto result = session.ExplainDataQuery(query).GetValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+ 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
 
             if (UseNewEngine) {
                 NJson::TJsonValue plan;
@@ -996,47 +996,47 @@ Y_UNIT_TEST_SUITE(KqpSort) {
             } else {
                 UNIT_ASSERT_C(!result.GetAst().Contains("KiPartialTake"), result.GetAst());
             }
-        }
-
-        {
-            auto params = db.GetParamsBuilder()
-                .AddParam("$limit")
-                    .Uint64(2)
-                    .Build()
-                .Build();
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-            CompareYson(R"([
-                [[1u];["One"];[-1]];
-                [[2u];["Two"];[0]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
-        }
-    }
-
+        } 
+ 
+        { 
+            auto params = db.GetParamsBuilder() 
+                .AddParam("$limit") 
+                    .Uint64(2) 
+                    .Build() 
+                .Build(); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+            CompareYson(R"([ 
+                [[1u];["One"];[-1]]; 
+                [[2u];["Two"];[0]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
+        } 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(TopParameterFilter) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = Q_(R"(
-            DECLARE $limit AS Uint64;
-            DECLARE $value AS Int32;
-
-            SELECT *
+            DECLARE $limit AS Uint64; 
+            DECLARE $value AS Int32; 
+ 
+            SELECT * 
             FROM `/Root/TwoShard`
-            WHERE Value2 != $value
-            LIMIT $limit;
-        )");
-
-        {
-            auto result = session.ExplainDataQuery(query).GetValueSync();
-            result.GetIssues().PrintTo(Cerr);
-
-            Cerr << result.GetAst() << Endl;
-
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+            WHERE Value2 != $value 
+            LIMIT $limit; 
+        )"); 
+ 
+        { 
+            auto result = session.ExplainDataQuery(query).GetValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+ 
+            Cerr << result.GetAst() << Endl; 
+ 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
 
             if (UseNewEngine) {
                 NJson::TJsonValue plan;
@@ -1048,21 +1048,21 @@ Y_UNIT_TEST_SUITE(KqpSort) {
             } else {
                 UNIT_ASSERT_C(result.GetAst().Contains("KiPartialTake"), result.GetAst());
             }
-        }
-
-        {
-            auto params = db.GetParamsBuilder()
-                .AddParam("$limit")
-                    .Uint64(2)
-                    .Build()
-                .AddParam("$value")
-                    .Int32(0)
-                    .Build()
-                .Build();
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+        } 
+ 
+        { 
+            auto params = db.GetParamsBuilder() 
+                .AddParam("$limit") 
+                    .Uint64(2) 
+                    .Build() 
+                .AddParam("$value") 
+                    .Int32(0) 
+                    .Build() 
+                .Build(); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
             auto actual = ReformatYson(FormatResultSetYson(result.GetResultSet(0)));
 
             if (ReformatYson(R"([
@@ -1079,8 +1079,8 @@ Y_UNIT_TEST_SUITE(KqpSort) {
             ])";
 
             UNIT_ASSERT_NO_DIFF(ReformatYson(expected), actual);
-        }
-    }
+        } 
+    } 
 
     // https://st.yandex-team.ru/KIKIMR-11523
     Y_UNIT_TEST_NEW_ENGINE(PassLimit) {
diff --git a/ydb/core/kqp/ut/kqp_sqlin_ut.cpp b/ydb/core/kqp/ut/kqp_sqlin_ut.cpp
index b41df7c39e..4a6838e2aa 100644
--- a/ydb/core/kqp/ut/kqp_sqlin_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_sqlin_ut.cpp
@@ -512,7 +512,7 @@ Y_UNIT_TEST_SUITE(KqpSqlIn) {
             auto query = TStringBuilder()
                 << Q1_(Sprintf(R"(
                     PRAGMA Kikimr.OptDisableSqlInToJoin = "True";
-                    PRAGMA Kikimr.OptDisableJoinReverseTableLookupLeftSemi = "%s"; -- not depends on `Kikimr.OptDisableSqlInToJoin` pragma
+                    PRAGMA Kikimr.OptDisableJoinReverseTableLookupLeftSemi = "%s"; -- not depends on `Kikimr.OptDisableSqlInToJoin` pragma 
                     DECLARE $in AS List<Struct<k: Uint32, v: String>>;
                     SELECT Group AS g, Amount AS a, Comment
                     FROM `/Root/Test`
@@ -867,7 +867,7 @@ Y_UNIT_TEST_SUITE(KqpSqlIn) {
         auto test = [&](bool disableOpt, std::function<void(const TDataQueryResult&)> assertFn) {
             const TString query = Q1_(Sprintf(R"(
                     PRAGMA Kikimr.OptDisableSqlInToJoin = "True";
-                    PRAGMA Kikimr.OptDisableJoinReverseTableLookupLeftSemi = "%s";
+                    PRAGMA Kikimr.OptDisableJoinReverseTableLookupLeftSemi = "%s"; 
                     DECLARE $in AS List<Struct<k: Int32?, v: String>>;
                     SELECT Value
                     FROM `/Root/SecondaryComplexKeys` VIEW Index
@@ -973,42 +973,42 @@ Y_UNIT_TEST_SUITE(KqpSqlIn) {
                 .ExtractValueSync();
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
 
-        AssertTableStats(result, "/Root/KeyValue", {
-            .ExpectedReads = UseNewEngine ? 0 : 2,
-            .ExpectedDeletes = UseNewEngine ? 3 : 2,
-        });
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(InWithCast) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$keys")
-                .BeginList()
-                .AddListItem().Uint64(1)
-                .EndList()
-                .Build()
-            .Build();
-
-        NYdb::NTable::TExecDataQuerySettings settings;
-        settings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $keys AS List<Uint64>;
-            SELECT * FROM `/Root/TwoShard` WHERE Key IN $keys
-        )"), TTxControl::BeginTx().CommitTx(), params, settings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1u];["One"];[-1]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        AssertTableStats(result, "/Root/TwoShard", {
-            .ExpectedReads = UseNewEngine ? 1 : 6,
-        });
+        AssertTableStats(result, "/Root/KeyValue", { 
+            .ExpectedReads = UseNewEngine ? 0 : 2, 
+            .ExpectedDeletes = UseNewEngine ? 3 : 2, 
+        }); 
     }
+ 
+    Y_UNIT_TEST_NEW_ENGINE(InWithCast) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$keys") 
+                .BeginList() 
+                .AddListItem().Uint64(1) 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings settings; 
+        settings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $keys AS List<Uint64>; 
+            SELECT * FROM `/Root/TwoShard` WHERE Key IN $keys 
+        )"), TTxControl::BeginTx().CommitTx(), params, settings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1u];["One"];[-1]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        AssertTableStats(result, "/Root/TwoShard", { 
+            .ExpectedReads = UseNewEngine ? 1 : 6, 
+        }); 
+    } 
 }
 
 } // namespace NKqp
diff --git a/ydb/core/kqp/ut/kqp_stats_ut.cpp b/ydb/core/kqp/ut/kqp_stats_ut.cpp
index f7815c016e..ebdb97f6f6 100644
--- a/ydb/core/kqp/ut/kqp_stats_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_stats_ut.cpp
@@ -28,9 +28,9 @@ Y_UNIT_TEST(MultiTxStatsFullExp) {
     UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
     UNIT_ASSERT_VALUES_EQUAL(res.ResultSetYson, R"([[[1];[202u];["Value2"]];[[2];[201u];["Value1"]];[[3];[203u];["Value3"]]])");
 
-    UNIT_ASSERT(res.PlanJson);
+    UNIT_ASSERT(res.PlanJson); 
     NJson::TJsonValue plan;
-    NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+    NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
     auto node = FindPlanNodeByKv(plan, "Node Type", "TopSort-TableRangesScan");
     UNIT_ASSERT_EQUAL(node.GetMap().at("Stats").GetMapSafe().at("TotalTasks").GetIntegerSafe(), 2);
 }
@@ -47,10 +47,10 @@ Y_UNIT_TEST(JoinNoStats) {
 
     auto res = CollectStreamResult(it);
     UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-    UNIT_ASSERT_VALUES_EQUAL(res.ResultSetYson, "[[16u]]");
+    UNIT_ASSERT_VALUES_EQUAL(res.ResultSetYson, "[[16u]]"); 
 
-    UNIT_ASSERT(!res.QueryStats);
-    UNIT_ASSERT(!res.PlanJson);
+    UNIT_ASSERT(!res.QueryStats); 
+    UNIT_ASSERT(!res.PlanJson); 
 }
 
 Y_UNIT_TEST(JoinStatsBasic) {
@@ -68,21 +68,21 @@ Y_UNIT_TEST(JoinStatsBasic) {
 
     UNIT_ASSERT_VALUES_EQUAL(res.ResultSetYson, "[[16u]]");
 
-    UNIT_ASSERT(res.QueryStats);
+    UNIT_ASSERT(res.QueryStats); 
     UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases().size(), 2);
-    if (res.QueryStats->query_phases(0).table_access(0).name() == "/Root/KeyValue") {
-        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(0).name(), "/Root/KeyValue");
-        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(0).partitions_count(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(1).name(), "/Root/EightShard");
-        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(1).partitions_count(), 8);
+    if (res.QueryStats->query_phases(0).table_access(0).name() == "/Root/KeyValue") { 
+        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(0).name(), "/Root/KeyValue"); 
+        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(0).partitions_count(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(1).name(), "/Root/EightShard"); 
+        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(1).partitions_count(), 8); 
     } else {
-        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(0).name(), "/Root/EightShard");
-        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(0).partitions_count(), 8);
-        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(1).name(), "/Root/KeyValue");
-        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(1).partitions_count(), 1);
+        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(0).name(), "/Root/EightShard"); 
+        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(0).partitions_count(), 8); 
+        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(1).name(), "/Root/KeyValue"); 
+        UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(0).table_access(1).partitions_count(), 1); 
     }
-
-    UNIT_ASSERT(!res.PlanJson);
+ 
+    UNIT_ASSERT(!res.PlanJson); 
 }
 
 Y_UNIT_TEST(MultiTxStatsFull) {
@@ -102,14 +102,14 @@ Y_UNIT_TEST(MultiTxStatsFull) {
         R"([[[1];[202u];["Value2"]];[[2];[201u];["Value1"]];[[3];[203u];["Value3"]]])"
     );
 
-    UNIT_ASSERT(res.QueryStats);
-    UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases().size(), 2);
-    UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(1).table_access(0).name(), "/Root/EightShard");
-    UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(1).table_access(0).partitions_count(), 2);
-
-    UNIT_ASSERT(res.PlanJson);
+    UNIT_ASSERT(res.QueryStats); 
+    UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases().size(), 2); 
+    UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(1).table_access(0).name(), "/Root/EightShard"); 
+    UNIT_ASSERT_VALUES_EQUAL(res.QueryStats->query_phases(1).table_access(0).partitions_count(), 2); 
+ 
+    UNIT_ASSERT(res.PlanJson); 
     NJson::TJsonValue plan;
-    NJson::ReadJsonTree(*res.PlanJson, &plan, true);
+    NJson::ReadJsonTree(*res.PlanJson, &plan, true); 
     auto node = FindPlanNodeByKv(plan, "Node Type", "TopSort-TableRangesScan");
     UNIT_ASSERT_EQUAL(node.GetMap().at("Stats").GetMapSafe().at("TotalTasks").GetIntegerSafe(), 2);
 }
@@ -130,7 +130,7 @@ Y_UNIT_TEST(DeferredEffects) {
         UPSERT INTO `/Root/TwoShard`
         SELECT Key + 100u AS Key, Value1 FROM `/Root/TwoShard` WHERE Key in (1,2,3,4,5);
     )", TTxControl::BeginTx(), settings).ExtractValueSync();
-    UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+    UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
 
     // TODO(sk): do proper phase dependency tracking
     //
@@ -158,22 +158,22 @@ Y_UNIT_TEST(DeferredEffects) {
 
         UPSERT INTO `/Root/TwoShard` (Key, Value1) VALUES
             ($key, $value);
-    )", TTxControl::Tx(*tx).CommitTx(), std::move(params), settings).ExtractValueSync();
-    UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+    )", TTxControl::Tx(*tx).CommitTx(), std::move(params), settings).ExtractValueSync(); 
+    UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
 
     NJson::ReadJsonTree(result.GetQueryPlan(), &plan, true);
-    UNIT_ASSERT_VALUES_EQUAL(plan.GetMapSafe().at("Plan").GetMapSafe().at("Plans").GetArraySafe().size(), 3);
+    UNIT_ASSERT_VALUES_EQUAL(plan.GetMapSafe().at("Plan").GetMapSafe().at("Plans").GetArraySafe().size(), 3); 
 
     result = session.ExecuteDataQuery(R"(
         PRAGMA kikimr.UseNewEngine = "true";
         SELECT * FROM `/Root/TwoShard`;
         UPDATE `/Root/TwoShard` SET Value1 = "XXX" WHERE Key in (3,600);
-    )", TTxControl::BeginTx().CommitTx(), settings).ExtractValueSync();
+    )", TTxControl::BeginTx().CommitTx(), settings).ExtractValueSync(); 
     result.GetIssues().PrintTo(Cerr);
-    UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+    UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
 
     NJson::ReadJsonTree(result.GetQueryPlan(), &plan, true);
-    UNIT_ASSERT_VALUES_EQUAL(plan.GetMapSafe().at("Plan").GetMapSafe().at("Plans").GetArraySafe().size(), 4);
+    UNIT_ASSERT_VALUES_EQUAL(plan.GetMapSafe().at("Plan").GetMapSafe().at("Plans").GetArraySafe().size(), 4); 
 
     auto ru = result.GetResponseMetadata().find(NYdb::YDB_CONSUMED_UNITS_HEADER);
     UNIT_ASSERT(ru != result.GetResponseMetadata().end());
diff --git a/ydb/core/kqp/ut/kqp_sys_col_ut.cpp b/ydb/core/kqp/ut/kqp_sys_col_ut.cpp
index 13fb8fa8ec..bc8cafd732 100644
--- a/ydb/core/kqp/ut/kqp_sys_col_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_sys_col_ut.cpp
@@ -21,9 +21,9 @@ TDataQueryResult ExecuteDataQuery(TKikimrRunner& kikimr, const TString& query) {
     return result;
 }
 
-TDataQueryResult ExecuteDataQuery(const TString& query) {
-    TKikimrRunner kikimr;
-    return ExecuteDataQuery(kikimr, query);
+TDataQueryResult ExecuteDataQuery(const TString& query) { 
+    TKikimrRunner kikimr; 
+    return ExecuteDataQuery(kikimr, query); 
 }
 
 TStreamPartIterator ExecuteStreamQuery(TKikimrRunner& kikimr, const TString& query) {
@@ -40,7 +40,7 @@ void SelectRowAsteriskCommon(bool useNewEngine) {
         PRAGMA kikimr.EnableSystemColumns = "true";
         SELECT * FROM `/Root/TwoShard` WHERE Key = 1;
     )";
-    auto result = ExecuteDataQuery(query);
+    auto result = ExecuteDataQuery(query); 
     UNIT_ASSERT(result.GetResultSets().size());
     CompareYson(R"([[[1u];["One"];[-1]]])",
         FormatResultSetYson(result.GetResultSet(0)));
@@ -53,7 +53,7 @@ void SelectRowByIdCommon(bool useNewEngine) {
         PRAGMA kikimr.EnableSystemColumns = "true";
         SELECT * FROM `/Root/TwoShard` WHERE _yql_partition_id = 72075186224037888ul;
     )";
-    auto result = ExecuteDataQuery(query);
+    auto result = ExecuteDataQuery(query); 
     UNIT_ASSERT(result.GetResultSets().size());
     CompareYson(R"([[[1u];["One"];[-1]];[[2u];["Two"];[0]];[[3u];["Three"];[1]]])",
         FormatResultSetYson(result.GetResultSet(0)));
@@ -66,9 +66,9 @@ void SelectRangeCommon(bool useNewEngine) {
         PRAGMA kikimr.EnableSystemColumns = "true";
         SELECT _yql_partition_id FROM `/Root/TwoShard` WHERE Key < 3;
     )";
-    auto result = ExecuteDataQuery(query);
+    auto result = ExecuteDataQuery(query); 
     UNIT_ASSERT(result.GetResultSets().size());
-    CompareYson(R"([[[72075186224037888u]];[[72075186224037888u]]])",
+    CompareYson(R"([[[72075186224037888u]];[[72075186224037888u]]])", 
         FormatResultSetYson(result.GetResultSet(0)));
 }
 
@@ -111,7 +111,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV0) {
             auto query = R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 SELECT COUNT(*) FROM [/Root/TwoShard]
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -4;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -4; 
             )";
             auto result = ExecuteDataQuery(kikimr, query);
             UNIT_ASSERT(result.GetResultSets().size());
@@ -122,7 +122,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV0) {
             auto query = R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 UPDATE [/Root/TwoShard] SET Value2 = -44
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -4;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -4; 
             )";
             ExecuteDataQuery(kikimr, query);
         }
@@ -130,7 +130,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV0) {
             auto query = R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 SELECT COUNT(*) FROM [/Root/TwoShard]
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44; 
             )";
             auto result = ExecuteDataQuery(kikimr, query);
             UNIT_ASSERT(result.GetResultSets().size());
@@ -141,7 +141,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV0) {
             auto query = R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 DELETE FROM [/Root/TwoShard]
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44; 
             )";
             auto result = ExecuteDataQuery(kikimr, query);
         }
@@ -149,7 +149,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV0) {
             auto query = R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 SELECT COUNT(*) FROM [/Root/TwoShard]
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44; 
             )";
             auto result = ExecuteDataQuery(kikimr, query);
             UNIT_ASSERT(result.GetResultSets().size());
@@ -168,7 +168,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV0) {
         )";
         auto result = ExecuteDataQuery(query);
         UNIT_ASSERT(result.GetResultSets().size());
-        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];#;["Value31"]]])",
+        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];#;["Value31"]]])", 
             FormatResultSetYson(result.GetResultSet(0)));
     }
 
@@ -182,7 +182,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV0) {
         )";
         auto result = ExecuteDataQuery(query);
         UNIT_ASSERT(result.GetResultSets().size());
-        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];["Value31"]]])",
+        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];["Value31"]]])", 
             FormatResultSetYson(result.GetResultSet(0)));
     }
 
@@ -196,7 +196,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV0) {
         )";
         auto result = ExecuteDataQuery(query);
         UNIT_ASSERT(result.GetResultSets().size());
-        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];#;["Value31"]]])",
+        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];#;["Value31"]]])", 
             FormatResultSetYson(result.GetResultSet(0)));
     }
 }
@@ -231,7 +231,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
         )");
         auto result = ExecuteDataQuery(query);
         UNIT_ASSERT(result.GetResultSets().size());
-        CompareYson(R"([[[72075186224037888u]];[[72075186224037888u]]])",
+        CompareYson(R"([[[72075186224037888u]];[[72075186224037888u]]])", 
             FormatResultSetYson(result.GetResultSet(0)));
     }
 
@@ -249,7 +249,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
             auto query = Q_(R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 SELECT COUNT(*) FROM `/Root/TwoShard`
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -4;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -4; 
             )");
             auto result = ExecuteDataQuery(kikimr, query);
             UNIT_ASSERT(result.GetResultSets().size());
@@ -260,7 +260,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
             auto query = Q_(R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 UPDATE `/Root/TwoShard` SET Value2 = -44
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -4;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -4; 
             )");
             ExecuteDataQuery(kikimr, query);
         }
@@ -268,7 +268,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
             auto query = Q_(R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 SELECT COUNT(*) FROM `/Root/TwoShard`
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44; 
             )");
             auto result = ExecuteDataQuery(kikimr, query);
             UNIT_ASSERT(result.GetResultSets().size());
@@ -279,7 +279,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
             auto query = Q_(R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 DELETE FROM `/Root/TwoShard`
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44; 
             )");
             auto result = ExecuteDataQuery(kikimr, query);
         }
@@ -287,7 +287,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
             auto query = Q_(R"(
                 PRAGMA kikimr.EnableSystemColumns = "true";
                 SELECT COUNT(*) FROM `/Root/TwoShard`
-                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44;
+                WHERE _yql_partition_id = 72075186224037888ul AND Value2 = -44; 
             )");
             auto result = ExecuteDataQuery(kikimr, query);
             UNIT_ASSERT(result.GetResultSets().size());
@@ -306,7 +306,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
         )");
         auto result = ExecuteDataQuery(query);
         UNIT_ASSERT(result.GetResultSets().size());
-        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];#;["Value31"]]])",
+        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];#;["Value31"]]])", 
             FormatResultSetYson(result.GetResultSet(0)));
     }
 
@@ -320,7 +320,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
         )");
         auto result = ExecuteDataQuery(query);
         UNIT_ASSERT(result.GetResultSets().size());
-        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];["Value31"]]])",
+        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];["Value31"]]])", 
             FormatResultSetYson(result.GetResultSet(0)));
     }
 
@@ -334,7 +334,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
         )");
         auto result = ExecuteDataQuery(query);
         UNIT_ASSERT(result.GetResultSets().size());
-        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];#;["Value31"]]])",
+        CompareYson(R"([[[108u];["One"];[8];["Value5"];[108u];["One"];#;["Value31"]]])", 
             FormatResultSetYson(result.GetResultSet(0)));
     }
 
@@ -365,7 +365,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
             SELECT _yql_partition_id FROM `/Root/TwoShard` WHERE Key < 3;
         )";
         auto it = ExecuteStreamQuery(kikimr, query);
-        CompareYson(R"([[[72075186224037888u]];[[72075186224037888u]]])", StreamResultToYson(it));
+        CompareYson(R"([[[72075186224037888u]];[[72075186224037888u]]])", StreamResultToYson(it)); 
     }
 
     Y_UNIT_TEST(StreamInnerJoinTables) {
@@ -378,7 +378,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
             WHERE t1.Value == "Value5" AND t2.Value2 == "Value31";
         )";
         auto it = ExecuteStreamQuery(kikimr, query);
-        CompareYson(R"([[[108u];["One"];[8];[108u];["One"];#;["Value5"];["Value31"]]])", StreamResultToYson(it));
+        CompareYson(R"([[[108u];["One"];[8];[108u];["One"];#;["Value5"];["Value31"]]])", StreamResultToYson(it)); 
     }
 
     Y_UNIT_TEST(StreamInnerJoinSelect) {
@@ -391,7 +391,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
             WHERE t1.Value == "Value5" AND t2.Value2 == "Value31";
         )";
         auto it = ExecuteStreamQuery(kikimr, query);
-        CompareYson(R"([[[108u];["One"];[8];[108u];["One"];["Value5"];["Value31"]]])", StreamResultToYson(it));
+        CompareYson(R"([[[108u];["One"];[8];[108u];["One"];["Value5"];["Value31"]]])", StreamResultToYson(it)); 
     }
 
     Y_UNIT_TEST(StreamInnerJoinSelectAsterisk) {
@@ -404,7 +404,7 @@ Y_UNIT_TEST_SUITE(KqpSysColV1) {
             WHERE t1.Value == "Value5" AND t2.Value2 == "Value31";
         )";
         auto it = ExecuteStreamQuery(kikimr, query);
-        CompareYson(R"([[[108u];["One"];[8];[108u];["One"];#;["Value5"];["Value31"]]])", StreamResultToYson(it));
+        CompareYson(R"([[[108u];["One"];[8];[108u];["One"];#;["Value5"];["Value31"]]])", StreamResultToYson(it)); 
     }
 }
 
diff --git a/ydb/core/kqp/ut/kqp_sys_view_ut.cpp b/ydb/core/kqp/ut/kqp_sys_view_ut.cpp
index 1f8988517c..9553584c47 100644
--- a/ydb/core/kqp/ut/kqp_sys_view_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_sys_view_ut.cpp
@@ -19,7 +19,7 @@ Y_UNIT_TEST_SUITE(KqpSystemView) {
 
         while (true) {
             auto it = client.StreamExecuteScanQuery(
-                "select NodeId from `/Root/.sys/partition_stats` where Path = '/Root/KeyValue' limit 1"
+                "select NodeId from `/Root/.sys/partition_stats` where Path = '/Root/KeyValue' limit 1" 
             ).GetValueSync();
             UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
             if (StreamResultToYson(it) == "[[#]]") {
@@ -80,7 +80,7 @@ Y_UNIT_TEST_SUITE(KqpSystemView) {
             [[72057594046644480u];[7u];["/Root/BatchUpload"];[5u]];
             [[72057594046644480u];[8u];["/Root/BatchUpload"];[5u]];
             [[72057594046644480u];[9u];["/Root/BatchUpload"];[5u]];
-            [[72057594046644480u];[0u];["/Root/KeyValue"];[6u]];
+            [[72057594046644480u];[0u];["/Root/KeyValue"];[6u]]; 
             [[72057594046644480u];[0u];["/Root/KeyValue2"];[7u]];
             [[72057594046644480u];[0u];["/Root/Test"];[8u]];
             [[72057594046644480u];[0u];["/Root/Join1"];[9u]];
@@ -106,7 +106,7 @@ Y_UNIT_TEST_SUITE(KqpSystemView) {
         )";
 
         TString expectedYson = R"([
-            [[72057594046644480u];[6u];[0u];["/Root/KeyValue"]];
+            [[72057594046644480u];[6u];[0u];["/Root/KeyValue"]]; 
             [[72057594046644480u];[7u];[0u];["/Root/KeyValue2"]];
             [[72057594046644480u];[8u];[0u];["/Root/Test"]];
             [[72057594046644480u];[9u];[0u];["/Root/Join1"]];
@@ -137,7 +137,7 @@ Y_UNIT_TEST_SUITE(KqpSystemView) {
         )";
 
         TString expectedYson = R"([
-            [[72057594046644480u];[6u];[0u];["/Root/KeyValue"]];
+            [[72057594046644480u];[6u];[0u];["/Root/KeyValue"]]; 
             [[72057594046644480u];[7u];[0u];["/Root/KeyValue2"]];
             [[72057594046644480u];[8u];[0u];["/Root/Test"]]
         ])";
@@ -277,30 +277,30 @@ Y_UNIT_TEST_SUITE(KqpSystemView) {
             auto it = client.StreamExecuteScanQuery(request.Str()).GetValueSync();
 
             UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
-
-            TSet<ui64> readBytesSet;
-            for (;;) {
-                auto streamPart = it.ReadNext().GetValueSync();
-                if (!streamPart.IsSuccess()) {
-                    UNIT_ASSERT_C(streamPart.EOS(), streamPart.GetIssues().ToString());
-                    break;
-                }
-
-                if (streamPart.HasResultSet()) {
-                    auto resultSet = streamPart.ExtractResultSet();
-
-                    NYdb::TResultSetParser parser(resultSet);
-                    while (parser.TryNextRow()) {
-                        auto value = parser.ColumnParser("ReadBytes").GetOptionalUint64();
-                        UNIT_ASSERT(value);
-                        readBytesSet.emplace(*value);
-                    }
-                }
-            }
-
-            UNIT_ASSERT(readBytesSet.contains(0)); // Pure
-            UNIT_ASSERT(readBytesSet.contains(79)); // TwoShard
-            UNIT_ASSERT(readBytesSet.contains(432)); // EightShard
+ 
+            TSet<ui64> readBytesSet; 
+            for (;;) { 
+                auto streamPart = it.ReadNext().GetValueSync(); 
+                if (!streamPart.IsSuccess()) { 
+                    UNIT_ASSERT_C(streamPart.EOS(), streamPart.GetIssues().ToString()); 
+                    break; 
+                } 
+ 
+                if (streamPart.HasResultSet()) { 
+                    auto resultSet = streamPart.ExtractResultSet(); 
+ 
+                    NYdb::TResultSetParser parser(resultSet); 
+                    while (parser.TryNextRow()) { 
+                        auto value = parser.ColumnParser("ReadBytes").GetOptionalUint64(); 
+                        UNIT_ASSERT(value); 
+                        readBytesSet.emplace(*value); 
+                    } 
+                } 
+            } 
+ 
+            UNIT_ASSERT(readBytesSet.contains(0)); // Pure 
+            UNIT_ASSERT(readBytesSet.contains(79)); // TwoShard 
+            UNIT_ASSERT(readBytesSet.contains(432)); // EightShard 
         };
 
         checkTable("`/Root/.sys/top_queries_by_read_bytes_one_minute`");
diff --git a/ydb/core/kqp/ut/kqp_table_predicate_ut.cpp b/ydb/core/kqp/ut/kqp_table_predicate_ut.cpp
index 5ab5108968..b8808421da 100644
--- a/ydb/core/kqp/ut/kqp_table_predicate_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_table_predicate_ut.cpp
@@ -1,122 +1,122 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/core/kqp/provider/yql_kikimr_expr_nodes.h>
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
+ 
 #include <ydb/library/yql/ast/yql_ast.h>
 #include <ydb/library/yql/ast/yql_expr.h>
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 
 #include <library/cpp/json/json_reader.h>
 
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-static void CreateSampleTables(TSession session) {
-    UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+static void CreateSampleTables(TSession session) { 
+    UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
         CREATE TABLE [/Root/TestNulls] (
-            Key1 Uint32,
-            Key2 Uint32,
-            Value String,
-            PRIMARY KEY (Key1, Key2)
-        );
-    )").GetValueSync().IsSuccess());
-
-    UNIT_ASSERT(session.ExecuteDataQuery(R"(
+            Key1 Uint32, 
+            Key2 Uint32, 
+            Value String, 
+            PRIMARY KEY (Key1, Key2) 
+        ); 
+    )").GetValueSync().IsSuccess()); 
+ 
+    UNIT_ASSERT(session.ExecuteDataQuery(R"( 
         REPLACE INTO [/Root/TestNulls] (Key1, Key2, Value) VALUES
-            (NULL, NULL, "One"),
-            (NULL, 100u, "Two"),
-            (NULL, 200u, "Three"),
-            (1u,   NULL, "Four"),
-            (1u,   100u, "Five"),
-            (1u,   200u, "Six"),
-            (2u,   NULL, "Seven"),
-            (2u,   100u, "Eight"),
-            (2u,   200u, "Nine"),
-            (3u,   100u, "Ten"),
-            (3u,   200u, "Eleven"),
-            (3u,   300u, "Twelve"),
-            (3u,   400u, "Thirteen"),
-            (3u,   500u, "Fourteen");
-    )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync().IsSuccess());
-
-    UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
+            (NULL, NULL, "One"), 
+            (NULL, 100u, "Two"), 
+            (NULL, 200u, "Three"), 
+            (1u,   NULL, "Four"), 
+            (1u,   100u, "Five"), 
+            (1u,   200u, "Six"), 
+            (2u,   NULL, "Seven"), 
+            (2u,   100u, "Eight"), 
+            (2u,   200u, "Nine"), 
+            (3u,   100u, "Ten"), 
+            (3u,   200u, "Eleven"), 
+            (3u,   300u, "Twelve"), 
+            (3u,   400u, "Thirteen"), 
+            (3u,   500u, "Fourteen"); 
+    )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync().IsSuccess()); 
+
+    UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
         CREATE TABLE [/Root/TestDate] (
-            Key Date,
-            Value String,
-            PRIMARY KEY (Key)
-        );
-    )").GetValueSync().IsSuccess());
-
-    UNIT_ASSERT(session.ExecuteDataQuery(R"(
+            Key Date, 
+            Value String, 
+            PRIMARY KEY (Key) 
+        ); 
+    )").GetValueSync().IsSuccess()); 
+ 
+    UNIT_ASSERT(session.ExecuteDataQuery(R"( 
         REPLACE INTO [/Root/TestDate] (Key, Value) VALUES
-            (NULL, "One"),
-            (Date("2019-05-08"), "Two"),
-            (Date("2019-07-01"), "Three");
-    )", TTxControl::BeginTx().CommitTx()).GetValueSync().IsSuccess());
-
-    {
-        auto builder = TTableBuilder()
-            .AddNullableColumn("Key", EPrimitiveType::Uint32)
-            .AddNullableColumn("Value", EPrimitiveType::Utf8)
-            .AddNullableColumn("ValueInt", EPrimitiveType::Int32)
-            .SetPrimaryKeyColumn("Key");
+            (NULL, "One"), 
+            (Date("2019-05-08"), "Two"), 
+            (Date("2019-07-01"), "Three"); 
+    )", TTxControl::BeginTx().CommitTx()).GetValueSync().IsSuccess()); 
+ 
+    { 
+        auto builder = TTableBuilder() 
+            .AddNullableColumn("Key", EPrimitiveType::Uint32) 
+            .AddNullableColumn("Value", EPrimitiveType::Utf8) 
+            .AddNullableColumn("ValueInt", EPrimitiveType::Int32) 
+            .SetPrimaryKeyColumn("Key"); 
 
         UNIT_ASSERT(session.CreateTable("/Root/MultiShardTable",
-            builder.Build(),
-            TCreateTableSettings()
-                .PartitioningPolicy(
-                    TPartitioningPolicy()
-                        .UniformPartitions(5)
-                )
-            ).GetValueSync().IsSuccess());
-
-        UNIT_ASSERT(session.ExecuteDataQuery(R"(
+            builder.Build(), 
+            TCreateTableSettings() 
+                .PartitioningPolicy( 
+                    TPartitioningPolicy() 
+                        .UniformPartitions(5) 
+                ) 
+            ).GetValueSync().IsSuccess()); 
+
+        UNIT_ASSERT(session.ExecuteDataQuery(R"( 
             REPLACE INTO [/Root/MultiShardTable] (Key, Value) VALUES
-                (1, "One"),
-                (2, "Two"),
-                (3, "Three"),
-                (4, "Four"),
-                (4294967295, "LastOne");
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync().IsSuccess());
-
-        UNIT_ASSERT(session.ExecuteDataQuery(R"(
+                (1, "One"), 
+                (2, "Two"), 
+                (3, "Three"), 
+                (4, "Four"), 
+                (4294967295, "LastOne"); 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync().IsSuccess()); 
+
+        UNIT_ASSERT(session.ExecuteDataQuery(R"( 
             REPLACE INTO [/Root/MultiShardTable] (Key, ValueInt) VALUES
-                (10, 10);
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync().IsSuccess());
-    }
+                (10, 10); 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync().IsSuccess()); 
+    } 
 
-    {
-        auto builder = TTableBuilder()
-            .AddNullableColumn("Key1", EPrimitiveType::Uint32)
-            .AddNullableColumn("Key2", EPrimitiveType::String)
-            .AddNullableColumn("ValueInt", EPrimitiveType::Int32)
-            .SetPrimaryKeyColumns({"Key1", "Key2"});
+    { 
+        auto builder = TTableBuilder() 
+            .AddNullableColumn("Key1", EPrimitiveType::Uint32) 
+            .AddNullableColumn("Key2", EPrimitiveType::String) 
+            .AddNullableColumn("ValueInt", EPrimitiveType::Int32) 
+            .SetPrimaryKeyColumns({"Key1", "Key2"}); 
 
         UNIT_ASSERT(session.CreateTable("/Root/MultiShardTableCk",
-            builder.Build(),
-            TCreateTableSettings()
-                .PartitioningPolicy(
-                    TPartitioningPolicy()
-                        .UniformPartitions(5)
-                )
-            ).GetValueSync().IsSuccess());
-
-        UNIT_ASSERT(session.ExecuteDataQuery(R"(
+            builder.Build(), 
+            TCreateTableSettings() 
+                .PartitioningPolicy( 
+                    TPartitioningPolicy() 
+                        .UniformPartitions(5) 
+                ) 
+            ).GetValueSync().IsSuccess()); 
+ 
+        UNIT_ASSERT(session.ExecuteDataQuery(R"( 
             REPLACE INTO [/Root/MultiShardTableCk] (Key1, Key2, ValueInt) VALUES
-                (1, "One", NULL),
-                (2, "Two", NULL),
-                (3, "Three", NULL),
-                (4, "Four", NULL),
-                (4294967295, "LastOne", NULL),
-                (10, "Ten", 10);
-        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync().IsSuccess());
-    }
-}
-
+                (1, "One", NULL), 
+                (2, "Two", NULL), 
+                (3, "Three", NULL), 
+                (4, "Four", NULL), 
+                (4294967295, "LastOne", NULL), 
+                (10, "Ten", 10); 
+        )", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).GetValueSync().IsSuccess()); 
+    } 
+} 
+ 
 namespace {
 
 void CreateTableWithIntKey(TSession session, ui64 partitions, ui32 rangesPerPartition) {
@@ -342,88 +342,88 @@ void RunPredicateTest(const std::vector<TString>& predicates, bool withNulls) {
 
 } // anonymous namespace end
 
-Y_UNIT_TEST_SUITE(KqpTablePredicate) {
+Y_UNIT_TEST_SUITE(KqpTablePredicate) { 
     Y_UNIT_TEST_NEW_ENGINE(IsNull) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
         auto result = session.ExecuteDataQuery(Q_(R"(
                 SELECT Value FROM [/Root/TestNulls] WHERE
                     Key1 IS NULL AND Key2 IS NULL
             )"),
             TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        CompareYson(R"([[["One"]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+ 
+        CompareYson(R"([[["One"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(IsNullPartial) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
                 SELECT * FROM [/Root/Test]
                 WHERE Group == 1 AND Name IS NULL
             )"),
             TTxControl::BeginTx().CommitTx()).ExtractValueSync();
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
-        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+ 
+        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(NullInKey) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT Value FROM [/Root/TestNulls] WHERE
                 Key1 <= 1
             ORDER BY Value
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
         UNIT_ASSERT_C(result.IsSuccess(), result.GetIssues().ToString());
-
+ 
         CompareYson(R"([[["Five"]];[["Four"]];[["Six"]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(NullInKeySuffix) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
                 SELECT Value FROM [/Root/TestNulls] WHERE Key1 > 1
             )"),
             TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([
-            [["Seven"]];[["Eight"]];[["Nine"]];[["Ten"]];[["Eleven"]];[["Twelve"]];[["Thirteen"]];[["Fourteen"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([ 
+            [["Seven"]];[["Eight"]];[["Nine"]];[["Ten"]];[["Eleven"]];[["Twelve"]];[["Thirteen"]];[["Fourteen"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(NullInPredicate) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key1")
-                .OptionalUint32(1)
-                .Build()
-            .Build();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key1") 
+                .OptionalUint32(1) 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
                 DECLARE $key1 AS 'Uint32?';
                 DECLARE $key2 AS 'Uint32?';
@@ -431,24 +431,24 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
                     Key1 = $key1 AND Key2 >= $key2
             )"),
             TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), std::move(params)).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(NullInPredicateRow) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key1")
-                .OptionalUint32(1)
-                .Build()
-            .Build();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key1") 
+                .OptionalUint32(1) 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
                 DECLARE $key1 AS 'Uint32?';
                 DECLARE $key2 AS 'Uint32?';
@@ -456,61 +456,61 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
                     Key1 = $key1 AND Key2 == $key2
             )"),
             TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), std::move(params)).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST(AllowNullCompareInIndex) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key2")
-                .OptionalUint32(100)
-                .Build()
-            .Build();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key2") 
+                .OptionalUint32(100) 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(R"(
                 PRAGMA Kikimr.UseNewEngine = 'false';
                 PRAGMA kikimr.AllowNullCompareInIndex = "true";
-
+ 
                 DECLARE $key1 AS 'Uint32?';
                 DECLARE $key2 AS 'Uint32?';
                 SELECT Value FROM [/Root/TestNulls] WHERE
                     Key1 = $key1 AND Key2 <= $key2
             )",
             TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), std::move(params)).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([[["One"]];[["Two"]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([[["One"]];[["Two"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(WhereInSubquery) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$name")
-                .String("Paul")
-                .Build()
-            .Build();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$name") 
+                .String("Paul") 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            DECLARE $name AS String;
+            DECLARE $name AS String; 
             $groups = (SELECT Group FROM `/Root/Test` WHERE Name = $name);
             SELECT * FROM `/Root/TwoShard` WHERE Key in $groups;
         )"), TTxControl::BeginTx().CommitTx(), std::move(params)).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([[[1u];["One"];[-1]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([[[1u];["One"];[-1]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
 
     Y_UNIT_TEST_NEW_ENGINE(UpdateMulti) {
         TKikimrRunner kikimr;
@@ -623,46 +623,46 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
 
         auto result = session.ExecuteDataQuery(Q_(R"(
             UPDATE `/Root/MultiShardTable` SET ValueInt = ValueInt + 1 WHERE Key IN
-                (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
-                31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,
-                61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
-                91,92,93,94,95,96,97,98,99,100)
+                (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30, 
+                31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60, 
+                61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90, 
+                91,92,93,94,95,96,97,98,99,100) 
         )"), TTxControl::BeginTx().CommitTx()).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         {
             auto result = session.ExecuteDataQuery(Q_(R"(
                 SELECT Key, ValueInt FROM `/Root/MultiShardTable` ORDER BY Key
             )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-            CompareYson(R"([[[1u];#];[[2u];#];[[3u];#];[[4u];#];[[10u];[11]];[[4294967295u];#]])",
-                FormatResultSetYson(result.GetResultSet(0)));
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+            CompareYson(R"([[[1u];#];[[2u];#];[[3u];#];[[4u];#];[[10u];[11]];[[4294967295u];#]])", 
+                FormatResultSetYson(result.GetResultSet(0))); 
         }
-    }
+    } 
 
     Y_UNIT_TEST_NEW_ENGINE(UpdateWhereInBigLiteralListPrefix) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             UPDATE `/Root/MultiShardTableCk` SET ValueInt = ValueInt + 1 WHERE Key1 IN
-                (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
-                31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,
-                61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
-                91,92,93,94,95,96,97,98,99,100)
+                (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30, 
+                31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60, 
+                61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90, 
+                91,92,93,94,95,96,97,98,99,100) 
         )"), TTxControl::BeginTx().CommitTx()).GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         {
             auto result = session.ExecuteDataQuery(Q_(R"(
                 SELECT Key1, ValueInt FROM `/Root/MultiShardTableCk` ORDER BY Key1;
             )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+            UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
 
             CompareYson(R"([[[1u];#];[[2u];#];[[3u];#];[[4u];#];[[10u];[11]];[[4294967295u];#]])",
                 FormatResultSetYson(result.GetResultSet(0)));
@@ -704,22 +704,22 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
             )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
             UNIT_ASSERT(result.IsSuccess());
 
-            CompareYson(R"([
-                [#;["One"]];
-                [#;["Two"]];
-                [#;["Three"]];
-                [[1u];["qq"]];
-                [[1u];["qq"]];
-                [[1u];["qq"]];
-                [[2u];["qq"]];
-                [[2u];["qq"]];
-                [[2u];["qq"]];
-                [[3u];["Ten"]];
-                [[3u];["Eleven"]];
-                [[3u];["Twelve"]];
-                [[3u];["Thirteen"]];
-                [[3u];["Fourteen"]]
-            ])", FormatResultSetYson(result.GetResultSet(0)));
+            CompareYson(R"([ 
+                [#;["One"]]; 
+                [#;["Two"]]; 
+                [#;["Three"]]; 
+                [[1u];["qq"]]; 
+                [[1u];["qq"]]; 
+                [[1u];["qq"]]; 
+                [[2u];["qq"]]; 
+                [[2u];["qq"]]; 
+                [[2u];["qq"]]; 
+                [[3u];["Ten"]]; 
+                [[3u];["Eleven"]]; 
+                [[3u];["Twelve"]]; 
+                [[3u];["Thirteen"]]; 
+                [[3u];["Fourteen"]] 
+            ])", FormatResultSetYson(result.GetResultSet(0))); 
         }
     }
 
@@ -808,78 +808,78 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
             }
         }
     }
-
+ 
     Y_UNIT_TEST_NEW_ENGINE(DateKeyPredicate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT Value FROM [/Root/TestDate]
-            WHERE Key = Date("2019-07-01")
+            WHERE Key = Date("2019-07-01") 
         )"), TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(result.IsSuccess());
-
-        CompareYson(R"([[["Three"]]])", FormatResultSetYson(result.GetResultSet(0)));
-
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        CompareYson(R"([[["Three"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
         auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).affected_shards(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).partitions_count(), 1);
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(DuplicateKeyPredicateLiteral) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT Key FROM [/Root/EightShard] WHERE
-                Key > 200 AND Key >= 301 AND
-                Key < 600 AND Key <= 501
-            ORDER BY Key;
+                Key > 200 AND Key >= 301 AND 
+                Key < 600 AND Key <= 501 
+            ORDER BY Key; 
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[301u]];[[302u]];[[303u]];[[401u]];[[402u]];[[403u]];[[501u]]])",
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[301u]];[[302u]];[[303u]];[[401u]];[[402u]];[[403u]];[[501u]]])", 
                 FormatResultSetYson(result.GetResultSet(0)));
     }
-
+ 
     Y_UNIT_TEST_NEW_ENGINE(DuplicateKeyPredicateParam) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
         auto session = db.CreateSession().GetValueSync().GetSession();
 
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key_from_1").Uint64(200).Build()
-            .AddParam("$key_from_2").Uint64(301).Build()
-            .AddParam("$key_to_1").Uint64(600).Build()
-            .AddParam("$key_to_2").Uint64(501).Build()
-            .Build();
-
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key_from_1").Uint64(200).Build() 
+            .AddParam("$key_from_2").Uint64(301).Build() 
+            .AddParam("$key_to_1").Uint64(600).Build() 
+            .AddParam("$key_to_2").Uint64(501).Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            DECLARE $key_from_1 AS Uint64;
-            DECLARE $key_from_2 AS Uint64;
-            DECLARE $key_to_1 AS Uint64;
-            DECLARE $key_to_2 AS Uint64;
-
+            DECLARE $key_from_1 AS Uint64; 
+            DECLARE $key_from_2 AS Uint64; 
+            DECLARE $key_to_1 AS Uint64; 
+            DECLARE $key_to_2 AS Uint64; 
+ 
             SELECT Key FROM [/Root/EightShard] WHERE
-                Key > $key_from_1 AND Key >= $key_from_2 AND
-                Key < $key_to_1 AND Key <= $key_to_2
-            ORDER BY Key;
+                Key > $key_from_1 AND Key >= $key_from_2 AND 
+                Key < $key_to_1 AND Key <= $key_to_2 
+            ORDER BY Key; 
         )"), TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[301u]];[[302u]];[[303u]];[[401u]];[[402u]];[[403u]];[[501u]]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[301u]];[[302u]];[[303u]];[[401u]];[[402u]];[[403u]];[[501u]]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+ 
     }
 
     Y_UNIT_TEST_NEW_ENGINE(DuplicateKeyPredicateMixed) {
@@ -888,112 +888,112 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
         auto session = db.CreateSession().GetValueSync().GetSession();
 
         auto params = db.GetParamsBuilder()
-            .AddParam("$key_from_1").Uint64(200).Build()
-            .AddParam("$key_to_1").Uint64(600).Build()
-            .Build();
-
+            .AddParam("$key_from_1").Uint64(200).Build() 
+            .AddParam("$key_to_1").Uint64(600).Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
-            DECLARE $key_from_1 AS Uint64;
-            DECLARE $key_to_1 AS Uint64;
-
+            DECLARE $key_from_1 AS Uint64; 
+            DECLARE $key_to_1 AS Uint64; 
+ 
             SELECT Key FROM [/Root/EightShard] WHERE
-                Key > $key_from_1 AND Key >= 301 AND
-                Key < $key_to_1 AND Key <= 501
-            ORDER BY Key;
+                Key > $key_from_1 AND Key >= 301 AND 
+                Key < $key_to_1 AND Key <= 501 
+            ORDER BY Key; 
         )"), TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[301u]];[[302u]];[[303u]];[[401u]];[[402u]];[[403u]];[[501u]]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[301u]];[[302u]];[[303u]];[[401u]];[[402u]];[[403u]];[[501u]]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(DuplicateCompositeKeyPredicate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT Key2 FROM [/Root/TestNulls] WHERE Key1 = 3 AND
-                Key2 >= 100 AND Key2 > 200 AND
-                Key2 <= 600 AND Key2 < 500
-            ORDER BY Key2;
+                Key2 >= 100 AND Key2 > 200 AND 
+                Key2 <= 600 AND Key2 < 500 
+            ORDER BY Key2; 
         )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[300u]];[[400u]]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key_from_1").OptionalUint32(100).Build()
-            .AddParam("$key_from_2").OptionalUint32(200).Build()
-            .AddParam("$key_to_1").OptionalUint32(600).Build()
-            .AddParam("$key_to_2").OptionalUint32(500).Build()
-            .Build();
-
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[300u]];[[400u]]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key_from_1").OptionalUint32(100).Build() 
+            .AddParam("$key_from_2").OptionalUint32(200).Build() 
+            .AddParam("$key_to_1").OptionalUint32(600).Build() 
+            .AddParam("$key_to_2").OptionalUint32(500).Build() 
+            .Build(); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
-            DECLARE $key_from_1 AS 'Uint32?';
-            DECLARE $key_from_2 AS 'Uint32?';
-            DECLARE $key_to_1 AS 'Uint32?';
-            DECLARE $key_to_2 AS 'Uint32?';
-
+            DECLARE $key_from_1 AS 'Uint32?'; 
+            DECLARE $key_from_2 AS 'Uint32?'; 
+            DECLARE $key_to_1 AS 'Uint32?'; 
+            DECLARE $key_to_2 AS 'Uint32?'; 
+ 
             SELECT Key2 FROM [/Root/TestNulls] WHERE Key1 = 3 AND
-                Key2 >= $key_from_1 AND Key2 > $key_from_2 AND
-                Key2 <= $key_to_1 AND Key2 < $key_to_2
-            ORDER BY Key2;
+                Key2 >= $key_from_1 AND Key2 > $key_from_2 AND 
+                Key2 <= $key_to_1 AND Key2 < $key_to_2 
+            ORDER BY Key2; 
         )"), TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[300u]];[[400u]]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-
-        params = db.GetParamsBuilder()
-            .AddParam("$key_from_2").OptionalUint32(200).Build()
-            .AddParam("$key_to_2").OptionalUint32(500).Build()
-            .Build();
-
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[300u]];[[400u]]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        params = db.GetParamsBuilder() 
+            .AddParam("$key_from_2").OptionalUint32(200).Build() 
+            .AddParam("$key_to_2").OptionalUint32(500).Build() 
+            .Build(); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
-            DECLARE $key_from_2 AS 'Uint32?';
-            DECLARE $key_to_2 AS 'Uint32?';
-
+            DECLARE $key_from_2 AS 'Uint32?'; 
+            DECLARE $key_to_2 AS 'Uint32?'; 
+ 
             SELECT Key2 FROM [/Root/TestNulls] WHERE Key1 = 3 AND
-                Key2 >= 100 AND Key2 > $key_from_2 AND
-                Key2 <= 600 AND Key2 < $key_to_2
-            ORDER BY Key2;
+                Key2 >= 100 AND Key2 > $key_from_2 AND 
+                Key2 <= 600 AND Key2 < $key_to_2 
+            ORDER BY Key2; 
         )"), TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[300u]];[[400u]]])",
-            FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(ScanKeyPrefix) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto query = R"(
+ 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[300u]];[[400u]]])", 
+            FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(ScanKeyPrefix) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto query = R"( 
             PRAGMA Kikimr.UseNewEngine = 'false';
-            DECLARE $key1_from AS Uint32;
-            DECLARE $name AS String;
+            DECLARE $key1_from AS Uint32; 
+            DECLARE $name AS String; 
             SELECT * FROM [/Root/Join2] WHERE Key1 > $key1_from AND Name = $name;
-        )";
-
-        auto result = session.ExplainDataQuery(query).GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        NJson::TJsonValue plan;
-        UNIT_ASSERT(NJson::ReadJsonTree(result.GetPlan(), &plan));
-
-        UNIT_ASSERT_VALUES_EQUAL(plan["tables"].GetArray().size(), 1);
+        )"; 
+ 
+        auto result = session.ExplainDataQuery(query).GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        NJson::TJsonValue plan; 
+        UNIT_ASSERT(NJson::ReadJsonTree(result.GetPlan(), &plan)); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(plan["tables"].GetArray().size(), 1); 
         UNIT_ASSERT_VALUES_EQUAL(plan["tables"][0]["name"], "/Root/Join2");
-        UNIT_ASSERT_VALUES_EQUAL(plan["tables"][0]["reads"].GetArray().size(), 1);
-        auto& read = plan["tables"][0]["reads"][0];
-        UNIT_ASSERT(!read.Has("lookup_by"));
-        UNIT_ASSERT_VALUES_EQUAL(read["scan_by"].GetArray().size(), 2);
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL(plan["tables"][0]["reads"].GetArray().size(), 1); 
+        auto& read = plan["tables"][0]["reads"][0]; 
+        UNIT_ASSERT(!read.Has("lookup_by")); 
+        UNIT_ASSERT_VALUES_EQUAL(read["scan_by"].GetArray().size(), 2); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(DeleteNotFullScan) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -1041,61 +1041,61 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
     }
 
     Y_UNIT_TEST_NEW_ENGINE(LiteralOr) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/EightShard`
-            WHERE Key = 101 OR Key = 302 OR Key = 403 OR Key = 705
-            ORDER BY Key;
+            WHERE Key = 101 OR Key = 302 OR Key = 403 OR Key = 705 
+            ORDER BY Key; 
         )"), TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1];[101u];["Value1"]];
-            [[2];[302u];["Value2"]];
-            [[2];[403u];["Value3"]]])", FormatResultSetYson(result.GetResultSet(0)));
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1];[101u];["Value1"]]; 
+            [[2];[302u];["Value2"]]; 
+            [[2];[403u];["Value3"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).affected_shards(), 4);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 3);
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).partitions_count(), 4);
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(LiteralOrCompisite) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Logs`
-            WHERE
-                App = "apache" AND Ts = 0 OR
-                App = "nginx" AND Ts = 2 OR
-                App = "kikimr-db" AND Ts = 4 OR
-                App = "ydb" AND Ts = 5
-            ORDER BY App, Ts;
+            WHERE 
+                App = "apache" AND Ts = 0 OR 
+                App = "nginx" AND Ts = 2 OR 
+                App = "kikimr-db" AND Ts = 4 OR 
+                App = "ydb" AND Ts = 5 
+            ORDER BY App, Ts; 
         )"), TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [["apache"];["front-42"];[" GET /index.html HTTP/1.1"];[0]];
-            [["kikimr-db"];["kikimr-db-53"];["Discover"];[4]];
-            [["nginx"];["nginx-23"];["PUT /form HTTP/1.1"];[2]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [["apache"];["front-42"];[" GET /index.html HTTP/1.1"];[0]]; 
+            [["kikimr-db"];["kikimr-db-53"];["Discover"];[4]]; 
+            [["nginx"];["nginx-23"];["PUT /form HTTP/1.1"];[2]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
         if (UseNewEngine) {
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2);
 
@@ -1108,35 +1108,35 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 3);
         }
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(LiteralOrCompisiteCollision) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        CreateSampleTables(session);
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        CreateSampleTables(session); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/Logs`
-            WHERE
-                App = "apache" AND Ts = 0 OR
-                App = "nginx" AND Ts = 2 OR
-                App = "nginx" AND Ts = 3 OR
-                App = "ydb" AND Ts = 5
-            ORDER BY App, Ts;
+            WHERE 
+                App = "apache" AND Ts = 0 OR 
+                App = "nginx" AND Ts = 2 OR 
+                App = "nginx" AND Ts = 3 OR 
+                App = "ydb" AND Ts = 5 
+            ORDER BY App, Ts; 
         )"), TTxControl::BeginTx().CommitTx(), execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [["apache"];["front-42"];[" GET /index.html HTTP/1.1"];[0]];
-            [["nginx"];["nginx-23"];["PUT /form HTTP/1.1"];[2]];
-            [["nginx"];["nginx-23"];["GET /cat.jpg HTTP/1.1"];[3]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [["apache"];["front-42"];[" GET /index.html HTTP/1.1"];[0]]; 
+            [["nginx"];["nginx-23"];["PUT /form HTTP/1.1"];[2]]; 
+            [["nginx"];["nginx-23"];["GET /cat.jpg HTTP/1.1"];[3]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
         if (UseNewEngine) {
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 2);
 
@@ -1149,7 +1149,7 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
             UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 3);
         }
-    }
+    } 
 
     Y_UNIT_TEST(NoFullScanAtScanQuery) {
         TVector<std::tuple<TString, TString, ui64, ui32>> testData = {
@@ -1475,36 +1475,36 @@ Y_UNIT_TEST_SUITE(KqpTablePredicate) {
             CompareYson(expectedYson, FormatResultSetYson(result.GetResultSet(0)));
         }
     }
-
-    Y_UNIT_TEST_NEW_ENGINE(CastKeyBounds) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key_from").Uint64(1).Build()
-            .AddParam("$key_to").Int32(3).Build()
-            .Build();
-
-        NYdb::NTable::TExecDataQuerySettings settings;
-        settings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $key_from AS Uint64;
-            DECLARE $key_to AS Int32;
-            SELECT * FROM `/Root/TwoShard` WHERE Key > $key_from AND Key < $key_to;
-        )"), TTxControl::BeginTx().CommitTx(), params, settings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[2u];["Two"];[0]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        AssertTableStats(result, "/Root/TwoShard", {
-            .ExpectedReads = 1,
-        });
-    }
-}
-
+ 
+    Y_UNIT_TEST_NEW_ENGINE(CastKeyBounds) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key_from").Uint64(1).Build() 
+            .AddParam("$key_to").Int32(3).Build() 
+            .Build(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings settings; 
+        settings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $key_from AS Uint64; 
+            DECLARE $key_to AS Int32; 
+            SELECT * FROM `/Root/TwoShard` WHERE Key > $key_from AND Key < $key_to; 
+        )"), TTxControl::BeginTx().CommitTx(), params, settings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[2u];["Two"];[0]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        AssertTableStats(result, "/Root/TwoShard", { 
+            .ExpectedReads = 1, 
+        }); 
+    } 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_tx_ut.cpp b/ydb/core/kqp/ut/kqp_tx_ut.cpp
index 5837331604..e4664c08a4 100644
--- a/ydb/core/kqp/ut/kqp_tx_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_tx_ut.cpp
@@ -1,179 +1,179 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-Y_UNIT_TEST_SUITE(KqpTx) {
-    Y_UNIT_TEST_NEW_ENGINE(DeferredEffects) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q_(R"(
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+Y_UNIT_TEST_SUITE(KqpTx) { 
+    Y_UNIT_TEST_NEW_ENGINE(DeferredEffects) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q_(R"( 
             UPSERT INTO [/Root/Test]
-            SELECT Group, "Sergey" AS Name
+            SELECT Group, "Sergey" AS Name 
             FROM [/Root/Test];
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto tx = result.GetTransaction();
-
-        result = session.ExecuteDataQuery(Q_(R"(
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto tx = result.GetTransaction(); 
+ 
+        result = session.ExecuteDataQuery(Q_(R"( 
             SELECT * FROM [/Root/Test] WHERE Group = 1;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([
-            [[3500u];["None"];[1u];["Anna"]];
-            [[300u];["None"];[1u];["Paul"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-
-        auto commitResult = tx->Commit().ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::SUCCESS, commitResult.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(Q_(R"(
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([ 
+            [[3500u];["None"];[1u];["Anna"]]; 
+            [[300u];["None"];[1u];["Paul"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto commitResult = tx->Commit().ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::SUCCESS, commitResult.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(Q_(R"( 
             SELECT * FROM [/Root/Test] WHERE Group = 1;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([
-            [[3500u];["None"];[1u];["Anna"]];
-            [[300u];["None"];[1u];["Paul"]];
-            [#;#;[1u];["Sergey"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([ 
+            [[3500u];["None"];[1u];["Anna"]]; 
+            [[300u];["None"];[1u];["Paul"]]; 
+            [#;#;[1u];["Sergey"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(ExplicitTcl) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto tx = session.BeginTransaction(TTxSettings::SerializableRW())
-            .ExtractValueSync()
-            .GetTransaction();
-        UNIT_ASSERT(tx.IsActive());
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto tx = session.BeginTransaction(TTxSettings::SerializableRW()) 
+            .ExtractValueSync() 
+            .GetTransaction(); 
+        UNIT_ASSERT(tx.IsActive()); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             UPSERT INTO [/Root/KeyValue] (Key, Value) VALUES (10u, "New");
         )"), TTxControl::Tx(tx)).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM [/Root/KeyValue] WHERE Value = "New";
         )"), TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0)));
-
-        auto commitResult = tx.Commit().ExtractValueSync();
+        UNIT_ASSERT(result.IsSuccess()); 
+        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        auto commitResult = tx.Commit().ExtractValueSync(); 
         UNIT_ASSERT_C(commitResult.IsSuccess(), commitResult.GetIssues().ToString());
-
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM [/Root/KeyValue] WHERE Value = "New";
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-        CompareYson(R"([[[10u];["New"]]])", FormatResultSetYson(result.GetResultSet(0)));
-
-        commitResult = tx.Commit().ExtractValueSync();
-        UNIT_ASSERT(!commitResult.IsSuccess());
-        UNIT_ASSERT(HasIssue(commitResult.GetIssues(), NYql::TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(InteractiveTx) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q_(R"(
+        UNIT_ASSERT(result.IsSuccess()); 
+        CompareYson(R"([[[10u];["New"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        commitResult = tx.Commit().ExtractValueSync(); 
+        UNIT_ASSERT(!commitResult.IsSuccess()); 
+        UNIT_ASSERT(HasIssue(commitResult.GetIssues(), NYql::TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND)); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(InteractiveTx) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q_(R"( 
             SELECT * FROM [/Root/KeyValue] WHERE Key = 1;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        TResultSetParser parser(result.GetResultSet(0));
-        UNIT_ASSERT(parser.TryNextRow());
-        auto value = parser.ColumnParser("Value").GetOptionalString();
-
-        auto tx = result.GetTransaction();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$name")
-                .String(*value)
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(Q_(R"(
-            DECLARE $name AS String;
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        TResultSetParser parser(result.GetResultSet(0)); 
+        UNIT_ASSERT(parser.TryNextRow()); 
+        auto value = parser.ColumnParser("Value").GetOptionalString(); 
+ 
+        auto tx = result.GetTransaction(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$name") 
+                .String(*value) 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(Q_(R"( 
+            DECLARE $name AS String; 
             UPSERT INTO [/Root/Test] (Group, Name, Amount) VALUES
-                (10, $name, 500);
-        )"), TTxControl::Tx(*tx).CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(Q_(R"(
+                (10, $name, 500); 
+        )"), TTxControl::Tx(*tx).CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(Q_(R"( 
             SELECT * FROM [/Root/Test] WHERE Group = 10;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[[500u];#;[10u];["One"]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(BeginTransactionBadMode) {
-        TKikimrRunner kikimr;
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[[500u];#;[10u];["One"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(BeginTransactionBadMode) { 
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.BeginTransaction(TTxSettings::OnlineRO()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
-
-        result = session.BeginTransaction(TTxSettings::StaleRO()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
-    }
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.BeginTransaction(TTxSettings::OnlineRO()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST); 
+ 
+        result = session.BeginTransaction(TTxSettings::StaleRO()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(CommitRequired) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM [/Root/KeyValue] WHERE Value = "New";
         )"), TTxControl::BeginTx(TTxSettings::OnlineRO())).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
-
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM [/Root/KeyValue] WHERE Value = "New";
         )"), TTxControl::BeginTx(TTxSettings::StaleRO())).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(RollbackTx) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         // with effects, without locks
         auto result = session.ExecuteDataQuery(Q_(R"(
             UPSERT INTO [/Root/KeyValue] (Key, Value) VALUES (10u, "New");
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        auto tx = result.GetTransaction();
-        UNIT_ASSERT(tx);
-        UNIT_ASSERT(tx->IsActive());
-
-        auto rollbackResult = tx->Rollback().ExtractValueSync();
-        UNIT_ASSERT(rollbackResult.IsSuccess());
-
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        auto tx = result.GetTransaction(); 
+        UNIT_ASSERT(tx); 
+        UNIT_ASSERT(tx->IsActive()); 
+ 
+        auto rollbackResult = tx->Rollback().ExtractValueSync(); 
+        UNIT_ASSERT(rollbackResult.IsSuccess()); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM [/Root/KeyValue] WHERE Value = "New";
         )"), TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0)));
-
-        rollbackResult = tx->Rollback().ExtractValueSync();
-        UNIT_ASSERT(!rollbackResult.IsSuccess());
-        UNIT_ASSERT(HasIssue(rollbackResult.GetIssues(), NYql::TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND));
-    }
-
+        UNIT_ASSERT(result.IsSuccess()); 
+        CompareYson(R"([])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        rollbackResult = tx->Rollback().ExtractValueSync(); 
+        UNIT_ASSERT(!rollbackResult.IsSuccess()); 
+        UNIT_ASSERT(HasIssue(rollbackResult.GetIssues(), NYql::TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND)); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(RollbackTx2) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();
@@ -274,175 +274,175 @@ Y_UNIT_TEST_SUITE(KqpTx) {
     }
 
     Y_UNIT_TEST_NEW_ENGINE(EmptyTxOnCommit) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             UPSERT INTO [/Root/KeyValue] (Key, Value) VALUES (10u, "New");
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        auto tx = result.GetTransaction();
-        UNIT_ASSERT(tx);
-        UNIT_ASSERT(!tx->IsActive());
-    }
-
-    Y_UNIT_TEST(TooManyTx) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        setting.SetName("_KqpMaxActiveTxPerSession");
-        setting.SetValue("2");
-
-        TKikimrRunner kikimr({setting});
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        auto tx = result.GetTransaction(); 
+        UNIT_ASSERT(tx); 
+        UNIT_ASSERT(!tx->IsActive()); 
+    } 
+ 
+    Y_UNIT_TEST(TooManyTx) { 
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        setting.SetName("_KqpMaxActiveTxPerSession"); 
+        setting.SetValue("2"); 
+ 
+        TKikimrRunner kikimr({setting}); 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-        auto tx = result.GetTransaction();
-
-        result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_SESSION);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_TOO_MANY_TRANSACTIONS));
-
-        auto rollbackResult = tx.Rollback().GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(rollbackResult.GetStatus(), EStatus::BAD_SESSION);
-    }
-
-    Y_UNIT_TEST(RollbackByIdle) {
-        TVector<NKikimrKqp::TKqpSetting> settings;
-        auto setting = NKikimrKqp::TKqpSetting();
-        setting.SetName("_KqpMaxActiveTxPerSession");
-        setting.SetValue("2");
-        settings.push_back(setting);
-        setting.SetName("_KqpTxIdleTimeoutSec");
-        setting.SetValue("0");
-        settings.push_back(setting);
-
-        TKikimrRunner kikimr(settings);
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+        auto tx = result.GetTransaction(); 
+ 
+        result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_SESSION); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_TOO_MANY_TRANSACTIONS)); 
+ 
+        auto rollbackResult = tx.Rollback().GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(rollbackResult.GetStatus(), EStatus::BAD_SESSION); 
+    } 
+ 
+    Y_UNIT_TEST(RollbackByIdle) { 
+        TVector<NKikimrKqp::TKqpSetting> settings; 
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        setting.SetName("_KqpMaxActiveTxPerSession"); 
+        setting.SetValue("2"); 
+        settings.push_back(setting); 
+        setting.SetName("_KqpTxIdleTimeoutSec"); 
+        setting.SetValue("0"); 
+        settings.push_back(setting); 
+ 
+        TKikimrRunner kikimr(settings); 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-        auto tx1 = result.GetTransaction();
-
-        result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-        auto tx2 = result.GetTransaction();
-
-        result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        auto commitResult = tx1.Commit().ExtractValueSync();
-        UNIT_ASSERT(!commitResult.IsSuccess());
-        UNIT_ASSERT(HasIssue(commitResult.GetIssues(), NYql::TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND));
-
-        commitResult = tx2.Commit().ExtractValueSync();
-        UNIT_ASSERT(commitResult.IsSuccess());
-    }
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+        auto tx1 = result.GetTransaction(); 
+ 
+        result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+        auto tx2 = result.GetTransaction(); 
+ 
+        result = session.BeginTransaction(TTxSettings::SerializableRW()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        auto commitResult = tx1.Commit().ExtractValueSync(); 
+        UNIT_ASSERT(!commitResult.IsSuccess()); 
+        UNIT_ASSERT(HasIssue(commitResult.GetIssues(), NYql::TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND)); 
+ 
+        commitResult = tx2.Commit().ExtractValueSync(); 
+        UNIT_ASSERT(commitResult.IsSuccess()); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(RollbackInvalidated) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             UPSERT INTO [/Root/KeyValue] (Key, Value) VALUES (10u, "New");
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto tx = result.GetTransaction();
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto tx = result.GetTransaction(); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
-            SELECT * FROM [BadTable];
+            SELECT * FROM [BadTable]; 
         )"), TTxControl::Tx(*tx)).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SCHEME_ERROR, result.GetIssues().ToString());
-
-        UNIT_ASSERT(result.GetTransaction());
-        UNIT_ASSERT(!result.GetTransaction()->IsActive());
-
-        auto commitResult = tx->Commit().ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::NOT_FOUND, result.GetIssues().ToString());
-        UNIT_ASSERT(HasIssue(commitResult.GetIssues(), NYql::TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND));
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SCHEME_ERROR, result.GetIssues().ToString()); 
+ 
+        UNIT_ASSERT(result.GetTransaction()); 
+        UNIT_ASSERT(!result.GetTransaction()->IsActive()); 
+ 
+        auto commitResult = tx->Commit().ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::NOT_FOUND, result.GetIssues().ToString()); 
+        UNIT_ASSERT(HasIssue(commitResult.GetIssues(), NYql::TIssuesIds::KIKIMR_TRANSACTION_NOT_FOUND)); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(CommitPrepared) {
-        TKikimrRunner kikimr;
+        TKikimrRunner kikimr; 
         auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
         auto query = session.PrepareDataQuery(Q_(R"(
             UPSERT INTO [/Root/KeyValue] (Key, Value) VALUES (10u, "New");
         )")).ExtractValueSync().GetQuery();
-
-        auto result = query.Execute(TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-
-        auto tx = result.GetTransaction();
-        UNIT_ASSERT(!tx->IsActive());
-
+ 
+        auto result = query.Execute(TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        auto tx = result.GetTransaction(); 
+        UNIT_ASSERT(!tx->IsActive()); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM [/Root/KeyValue] WHERE Value = "New";
         )"), TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT(result.IsSuccess());
-        CompareYson(R"([[[10u];["New"]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
+        UNIT_ASSERT(result.IsSuccess()); 
+        CompareYson(R"([[[10u];["New"]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(InvalidateOnError) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto tx = session.BeginTransaction(TTxSettings::SerializableRW())
-            .ExtractValueSync()
-            .GetTransaction();
-        UNIT_ASSERT(tx.IsActive());
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto tx = session.BeginTransaction(TTxSettings::SerializableRW()) 
+            .ExtractValueSync() 
+            .GetTransaction(); 
+        UNIT_ASSERT(tx.IsActive()); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             INSERT INTO [/Root/KeyValue] (Key, Value) VALUES (1u, "New");
         )"), TTxControl::Tx(tx)).ExtractValueSync();
         // result.GetIssues().PrintTo(Cerr);
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::PRECONDITION_FAILED, result.GetIssues().ToString());
-
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             UPSERT INTO [/Root/KeyValue] (Key, Value) VALUES (1u, "New");
         )"), TTxControl::Tx(tx)).ExtractValueSync();
         // result.GetIssues().PrintTo(Cerr);
         UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::NOT_FOUND, result.GetIssues().ToString());
-    }
-
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(CommitStats) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto tx = session.BeginTransaction(TTxSettings::SerializableRW())
-            .ExtractValueSync()
-            .GetTransaction();
-        UNIT_ASSERT(tx.IsActive());
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto tx = session.BeginTransaction(TTxSettings::SerializableRW()) 
+            .ExtractValueSync() 
+            .GetTransaction(); 
+        UNIT_ASSERT(tx.IsActive()); 
+ 
         auto result = session.ExecuteDataQuery(Q_(R"(
             UPSERT INTO [/Root/KeyValue] (Key, Value) VALUES (10u, "New");
         )"), TTxControl::Tx(tx)).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        NYdb::NTable::TCommitTxSettings commitSettings;
-        commitSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto commitResult = tx.Commit(commitSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::SUCCESS, commitResult.GetIssues().ToString());
-
-        UNIT_ASSERT(commitResult.GetStats());
-        auto stats = NYdb::TProtoAccessor::GetProto(*commitResult.GetStats());
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/KeyValue");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).updates().rows(), 1);
-    }
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        NYdb::NTable::TCommitTxSettings commitSettings; 
+        commitSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto commitResult = tx.Commit(commitSettings).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(commitResult.GetStatus(), EStatus::SUCCESS, commitResult.GetIssues().ToString()); 
+ 
+        UNIT_ASSERT(commitResult.GetStats()); 
+        auto stats = NYdb::TProtoAccessor::GetProto(*commitResult.GetStats()); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/KeyValue"); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).updates().rows(), 1); 
+    } 
 
     Y_UNIT_TEST(MixEnginesOldNew) {
         TKikimrRunner kikimr;
@@ -474,7 +474,7 @@ Y_UNIT_TEST_SUITE(KqpTx) {
             [[2u];["Two"]]
             ])", FormatResultSetYson(result.GetResultSet(0)));
     }
-}
-
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_write_ut.cpp b/ydb/core/kqp/ut/kqp_write_ut.cpp
index d260211f58..b5a82a2c47 100644
--- a/ydb/core/kqp/ut/kqp_write_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_write_ut.cpp
@@ -1,697 +1,697 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NTable;
-
-Y_UNIT_TEST_SUITE(KqpWrite) {
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+ 
+Y_UNIT_TEST_SUITE(KqpWrite) { 
     Y_UNIT_TEST_NEW_ENGINE(UpsertNullKey) {
-        auto setting = NKikimrKqp::TKqpSetting();
-        setting.SetName("_KqpYqlSyntaxVersion");
-        setting.SetValue("1");
-
-        TKikimrRunner kikimr({setting});
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        {
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        setting.SetName("_KqpYqlSyntaxVersion"); 
+        setting.SetValue("1"); 
+ 
+        TKikimrRunner kikimr({setting}); 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        { 
             const TString query = Q_(R"(
-                UPSERT INTO `/Root/KeyValue` (Key, Value) VALUES
-                    (Null, "Value1");
-            )");
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT(result.IsSuccess());
-        }
-
-        {
-
+                UPSERT INTO `/Root/KeyValue` (Key, Value) VALUES 
+                    (Null, "Value1"); 
+            )"); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT(result.IsSuccess()); 
+        } 
+ 
+        { 
+ 
             auto result = session.ExecuteDataQuery(Q_(R"(
                 SELECT * FROM `/Root/KeyValue`;
             )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT(result.IsSuccess());
-            UNIT_ASSERT_VALUES_EQUAL("[[#;[\"Value1\"]];[[1u];[\"One\"]];[[2u];[\"Two\"]]]",
-                    NYdb::FormatResultSetYson(result.GetResultSet(0)));
-        }
-
-        {
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT(result.IsSuccess()); 
+            UNIT_ASSERT_VALUES_EQUAL("[[#;[\"Value1\"]];[[1u];[\"One\"]];[[2u];[\"Two\"]]]", 
+                    NYdb::FormatResultSetYson(result.GetResultSet(0))); 
+        } 
+ 
+        { 
             const TString query = Q_(R"(
-                UPSERT INTO `/Root/KeyValue` (Key, Value) VALUES
-                    (Null, "Value2");
-            )");
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT(result.IsSuccess());
-        }
-
-        {
-
+                UPSERT INTO `/Root/KeyValue` (Key, Value) VALUES 
+                    (Null, "Value2"); 
+            )"); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT(result.IsSuccess()); 
+        } 
+ 
+        { 
+ 
             auto result = session.ExecuteDataQuery(Q_(R"(
                 SELECT * FROM `/Root/KeyValue`;
             )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT(result.IsSuccess());
-            UNIT_ASSERT_VALUES_EQUAL("[[#;[\"Value2\"]];[[1u];[\"One\"]];[[2u];[\"Two\"]]]",
-                    NYdb::FormatResultSetYson(result.GetResultSet(0)));
-        }
-
-        {
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT(result.IsSuccess()); 
+            UNIT_ASSERT_VALUES_EQUAL("[[#;[\"Value2\"]];[[1u];[\"One\"]];[[2u];[\"Two\"]]]", 
+                    NYdb::FormatResultSetYson(result.GetResultSet(0))); 
+        } 
+ 
+        { 
             const TString query = Q_(R"(
-                UPSERT INTO `/Root/KeyValue` (Key) VALUES
-                    (Null);
-            )");
-
-            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT(result.IsSuccess());
-        }
-
-        {
-
+                UPSERT INTO `/Root/KeyValue` (Key) VALUES 
+                    (Null); 
+            )"); 
+ 
+            auto result = session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT(result.IsSuccess()); 
+        } 
+ 
+        { 
+ 
             auto result = session.ExecuteDataQuery(Q_(R"(
                 SELECT * FROM `/Root/KeyValue`;
             )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-            result.GetIssues().PrintTo(Cerr);
-            UNIT_ASSERT(result.IsSuccess());
-            UNIT_ASSERT_VALUES_EQUAL("[[#;[\"Value2\"]];[[1u];[\"One\"]];[[2u];[\"Two\"]]]",
-                    NYdb::FormatResultSetYson(result.GetResultSet(0)));
-        }
-    }
-
-    Y_UNIT_TEST(InplaceUpdate) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key").Uint64(201).Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
+            result.GetIssues().PrintTo(Cerr); 
+            UNIT_ASSERT(result.IsSuccess()); 
+            UNIT_ASSERT_VALUES_EQUAL("[[#;[\"Value2\"]];[[1u];[\"One\"]];[[2u];[\"Two\"]]]", 
+                    NYdb::FormatResultSetYson(result.GetResultSet(0))); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST(InplaceUpdate) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key").Uint64(201).Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
             PRAGMA Kikimr.UseNewEngine = 'false';
-            PRAGMA kikimr.CommitSafety = "Moderate";
-
-            DECLARE $key AS Uint64;
-
+            PRAGMA kikimr.CommitSafety = "Moderate"; 
+ 
+            DECLARE $key AS Uint64; 
+ 
             $data = (SELECT Data FROM [/Root/EightShard] WHERE Key = $key);
-            $newData = COALESCE($data, 0u) + 1;
-            $tuple = (SELECT $key AS Key, $newData AS Data);
-
+            $newData = COALESCE($data, 0u) + 1; 
+            $tuple = (SELECT $key AS Key, $newData AS Data); 
+ 
             UPSERT INTO [/Root/EightShard]
-            SELECT * FROM $tuple;
-        )", TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(result.IsSuccess());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/EightShard");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 2); // KIKIMR-7302
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).updates().rows(), 1);
-    }
-
-    Y_UNIT_TEST(InplaceUpdateBatch) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto queryPrefix = R"(
+            SELECT * FROM $tuple; 
+        )", TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/EightShard"); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 2); // KIKIMR-7302 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).updates().rows(), 1); 
+    } 
+ 
+    Y_UNIT_TEST(InplaceUpdateBatch) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto queryPrefix = R"( 
             PRAGMA Kikimr.UseNewEngine = 'false';
-            PRAGMA kikimr.CommitSafety = "Moderate";
-        )";
-
-        auto declareTemplate = R"(
-            DECLARE $key%1$d AS Uint64;
-        )";
-
-        auto readTemplate = R"(
+            PRAGMA kikimr.CommitSafety = "Moderate"; 
+        )"; 
+ 
+        auto declareTemplate = R"( 
+            DECLARE $key%1$d AS Uint64; 
+        )"; 
+ 
+        auto readTemplate = R"( 
             $data%1$d = (SELECT Data FROM [/Root/EightShard] WHERE Key = $key%1$d);
-            $newData%1$d = COALESCE($data%1$d, 0u) + 1;
-            $tuple%1$d = (SELECT $key%1$d AS Key, $newData%1$d AS Data);
-        )";
-
-        auto writeTemplate = R"(
+            $newData%1$d = COALESCE($data%1$d, 0u) + 1; 
+            $tuple%1$d = (SELECT $key%1$d AS Key, $newData%1$d AS Data); 
+        )"; 
+ 
+        auto writeTemplate = R"( 
             UPSERT INTO [/Root/EightShard]
-            SELECT * FROM $tuple%1$d;
-        )";
-
-        auto makeQuery = [&](ui32 batchSize) {
-            auto paramsBuilder = db.GetParamsBuilder();
-            TStringBuilder queryDeclares;
-            TStringBuilder queryReads;
-            TStringBuilder queryWrites;
-            for (ui32 i = 0; i < batchSize; ++i) {
-                queryDeclares << Sprintf(declareTemplate, i);
-                queryReads << Sprintf(readTemplate, i);
-                queryWrites << Sprintf(writeTemplate, i);
-
-                paramsBuilder.AddParam(Sprintf("$key%1$d", i)).Uint64(100 + i).Build();
-            }
-
-            auto query = TStringBuilder() << queryPrefix << queryDeclares << queryReads << queryWrites;
-
-            NYdb::NTable::TExecDataQuerySettings execSettings;
-            execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-            return session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(),
-                paramsBuilder.Build(), execSettings).ExtractValueSync();
-        };
-
-        auto result10 = makeQuery(10);
-        UNIT_ASSERT_VALUES_EQUAL_C(result10.GetStatus(), EStatus::SUCCESS, result10.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result10.GetStats());
-
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/EightShard");
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 6); // KIKIMR-7302
-        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).updates().rows(), 10);
-
-        auto result20 = makeQuery(20);
-        UNIT_ASSERT_VALUES_EQUAL_C(result20.GetStatus(), EStatus::GENERIC_ERROR, result20.GetIssues().ToString());
-    }
-
-    Y_UNIT_TEST(InplaceUpdateBigRow) {
-        auto keysLimitSetting = NKikimrKqp::TKqpSetting();
-        keysLimitSetting.SetName("_CommitPerShardKeysSizeLimitBytes");
-        keysLimitSetting.SetValue("100");
-
-        TKikimrRunner kikimr({keysLimitSetting});
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
+            SELECT * FROM $tuple%1$d; 
+        )"; 
+ 
+        auto makeQuery = [&](ui32 batchSize) { 
+            auto paramsBuilder = db.GetParamsBuilder(); 
+            TStringBuilder queryDeclares; 
+            TStringBuilder queryReads; 
+            TStringBuilder queryWrites; 
+            for (ui32 i = 0; i < batchSize; ++i) { 
+                queryDeclares << Sprintf(declareTemplate, i); 
+                queryReads << Sprintf(readTemplate, i); 
+                queryWrites << Sprintf(writeTemplate, i); 
+ 
+                paramsBuilder.AddParam(Sprintf("$key%1$d", i)).Uint64(100 + i).Build(); 
+            } 
+ 
+            auto query = TStringBuilder() << queryPrefix << queryDeclares << queryReads << queryWrites; 
+ 
+            NYdb::NTable::TExecDataQuerySettings execSettings; 
+            execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+            return session.ExecuteDataQuery(query, TTxControl::BeginTx().CommitTx(), 
+                paramsBuilder.Build(), execSettings).ExtractValueSync(); 
+        }; 
+ 
+        auto result10 = makeQuery(10); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result10.GetStatus(), EStatus::SUCCESS, result10.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result10.GetStats()); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access().size(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).name(), "/Root/EightShard"); 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).reads().rows(), 6); // KIKIMR-7302 
+        UNIT_ASSERT_VALUES_EQUAL(stats.query_phases(0).table_access(0).updates().rows(), 10); 
+ 
+        auto result20 = makeQuery(20); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result20.GetStatus(), EStatus::GENERIC_ERROR, result20.GetIssues().ToString()); 
+    } 
+ 
+    Y_UNIT_TEST(InplaceUpdateBigRow) { 
+        auto keysLimitSetting = NKikimrKqp::TKqpSetting(); 
+        keysLimitSetting.SetName("_CommitPerShardKeysSizeLimitBytes"); 
+        keysLimitSetting.SetValue("100"); 
+ 
+        TKikimrRunner kikimr({keysLimitSetting}); 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
             CREATE TABLE [/Root/Temp] (
-                Key Uint32,
-                Value1 String,
-                Value2 String,
-                PRIMARY KEY (Key)
-            );
-        )").GetValueSync().IsSuccess());
-
-        auto result = session.ExecuteDataQuery(R"(
+                Key Uint32, 
+                Value1 String, 
+                Value2 String, 
+                PRIMARY KEY (Key) 
+            ); 
+        )").GetValueSync().IsSuccess()); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
             REPLACE INTO [/Root/Temp] (Key, Value1) VALUES
-                (1u, "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"),
-                (3u, "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        TString query(R"(
+                (1u, "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"), 
+                (3u, "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"); 
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        TString query(R"( 
             PRAGMA Kikimr.UseNewEngine = 'false';
-            PRAGMA kikimr.CommitSafety = "%s";
-
-            DECLARE $Key AS Uint32;
-
+            PRAGMA kikimr.CommitSafety = "%s"; 
+ 
+            DECLARE $Key AS Uint32; 
+ 
             $value1 = (SELECT Value1 FROM [/Root/Temp] WHERE Key = $Key);
-            $tuple = (SELECT $Key AS Key, $value1 AS Value1, $value1 AS Value2);
-
+            $tuple = (SELECT $Key AS Key, $value1 AS Value1, $value1 AS Value2); 
+ 
             UPSERT INTO [/Root/Temp]
-            SELECT * FROM $tuple;
-        )");
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$Key").Uint32(1).Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(Sprintf(query.c_str(), "Moderate"),
-            TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) {
-            return issue.Message.Contains("READ_SIZE_EXECEEDED");
-        }));
-
-        result = session.ExecuteDataQuery(R"(
+            SELECT * FROM $tuple; 
+        )"); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$Key").Uint32(1).Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(Sprintf(query.c_str(), "Moderate"), 
+            TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR, [](const NYql::TIssue& issue) { 
+            return issue.Message.Contains("READ_SIZE_EXECEEDED"); 
+        })); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             SELECT Value2 FROM [/Root/Temp] ORDER BY Value2;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([[#];[#]])", FormatResultSetYson(result.GetResultSet(0)));
-
-        result = session.ExecuteDataQuery(Sprintf(query.c_str(), "Safe"),
-            TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([[#];[#]])", FormatResultSetYson(result.GetResultSet(0))); 
+ 
+        result = session.ExecuteDataQuery(Sprintf(query.c_str(), "Safe"), 
+            TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
             SELECT Value2 FROM [/Root/Temp] ORDER BY Value2;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([
-            [#];[["123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(CommitSafetyDisabled) {
-        NKikimrConfig::TAppConfig appConfig;
-        appConfig.MutableTableServiceConfig()->SetAllowUnsafeCommit(false);
-
-        TKikimrRunner kikimr(appConfig);
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$key").Uint64(201).Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(R"(
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([ 
+            [#];[["123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(CommitSafetyDisabled) { 
+        NKikimrConfig::TAppConfig appConfig; 
+        appConfig.MutableTableServiceConfig()->SetAllowUnsafeCommit(false); 
+ 
+        TKikimrRunner kikimr(appConfig); 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$key").Uint64(201).Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
             PRAGMA Kikimr.UseNewEngine = 'false';
-            PRAGMA kikimr.CommitSafety = "Moderate";
-
-            DECLARE $key AS Uint64;
-
+            PRAGMA kikimr.CommitSafety = "Moderate"; 
+ 
+            DECLARE $key AS Uint64; 
+ 
             $data = (SELECT Data FROM [/Root/EightShard] WHERE Key = $key);
-            $newData = COALESCE($data, 0u) + 1;
-            $tuple = (SELECT $key AS Key, $newData AS Data);
-
+            $newData = COALESCE($data, 0u) + 1; 
+            $tuple = (SELECT $key AS Key, $newData AS Data); 
+ 
             UPSERT INTO [/Root/EightShard]
-            SELECT * FROM $tuple;
-        )", TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(!result.IsSuccess());
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION));
-    }
-
+            SELECT * FROM $tuple; 
+        )", TTxControl::BeginTx().CommitTx(), params).ExtractValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(!result.IsSuccess()); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_BAD_OPERATION)); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(Insert) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
             CREATE TABLE [/Root/TxCheck] (
-                Id Uint32,
-                PRIMARY KEY (Id)
-            );
-        )").GetValueSync().IsSuccess());
-
+                Id Uint32, 
+                PRIMARY KEY (Id) 
+            ); 
+        )").GetValueSync().IsSuccess()); 
+ 
         auto insertQuery = Q1_(R"(
             DECLARE $rows AS List<Struct<Key: Uint64, Value: String>>;
-            DECLARE $id AS Uint32;
-
+            DECLARE $id AS Uint32; 
+ 
             INSERT INTO `/Root/KeyValue`
-            SELECT * FROM AS_TABLE($rows);
-
+            SELECT * FROM AS_TABLE($rows); 
+ 
             UPSERT INTO `/Root/TxCheck` (Id) VALUES ($id);
         )");
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(1)
-                        .AddMember("Value").String("One1")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(10)
-                        .AddMember("Value").String("Ten1")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .AddParam("$id")
-                .Uint32(1)
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(insertQuery,
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(1) 
+                        .AddMember("Value").String("One1") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(10) 
+                        .AddMember("Value").String("Ten1") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .AddParam("$id") 
+                .Uint32(1) 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(insertQuery, 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
         UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED);
         UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION));
-
-        params = db.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(10)
-                        .AddMember("Value").String("Ten2")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(11)
-                        .AddMember("Value").String("Eleven2")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(10)
-                        .AddMember("Value").String("None2")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .AddParam("$id")
-                .Uint32(2)
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(insertQuery,
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
+ 
+        params = db.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(10) 
+                        .AddMember("Value").String("Ten2") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(11) 
+                        .AddMember("Value").String("Eleven2") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(10) 
+                        .AddMember("Value").String("None2") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .AddParam("$id") 
+                .Uint32(2) 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(insertQuery, 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
         UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED);
         UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION));
-
-        params = db.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(10)
-                        .AddMember("Value").String("Ten3")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(11)
-                        .AddMember("Value").String("Eleven3")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .AddParam("$id")
-                .Uint32(3)
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(insertQuery,
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+ 
+        params = db.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(10) 
+                        .AddMember("Value").String("Ten3") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(11) 
+                        .AddMember("Value").String("Eleven3") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .AddParam("$id") 
+                .Uint32(3) 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(insertQuery, 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/KeyValue`;
             SELECT * FROM `/Root/TxCheck`;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([
-            [[1u];["One"]];
-            [[2u];["Two"]];
-            [[10u];["Ten3"]];
-            [[11u];["Eleven3"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-        CompareYson(R"([[[3u]]])", FormatResultSetYson(result.GetResultSet(1)));
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([ 
+            [[1u];["One"]]; 
+            [[2u];["Two"]]; 
+            [[10u];["Ten3"]]; 
+            [[11u];["Eleven3"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+        CompareYson(R"([[[3u]]])", FormatResultSetYson(result.GetResultSet(1))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(InsertRevert) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
             CREATE TABLE `/Root/TxCheck` (
-                Id Uint32,
-                PRIMARY KEY (Id)
-            );
-        )").GetValueSync().IsSuccess());
-
+                Id Uint32, 
+                PRIMARY KEY (Id) 
+            ); 
+        )").GetValueSync().IsSuccess()); 
+ 
         auto insertQuery = Q1_(R"(
             DECLARE $rows AS List<Struct<Key: Uint64, Value: String>>;
-            DECLARE $id AS Uint32;
-
+            DECLARE $id AS Uint32; 
+ 
             INSERT OR REVERT INTO `/Root/KeyValue`
-            SELECT * FROM AS_TABLE($rows);
-
+            SELECT * FROM AS_TABLE($rows); 
+ 
             UPSERT INTO `/Root/TxCheck` (Id) VALUES ($id);
         )");
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(1)
-                        .AddMember("Value").String("One1")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(10)
-                        .AddMember("Value").String("Ten1")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .AddParam("$id")
-                .Uint32(1)
-                .Build()
-            .Build();
-
-        auto result = session.ExecuteDataQuery(insertQuery,
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(1) 
+                        .AddMember("Value").String("One1") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(10) 
+                        .AddMember("Value").String("Ten1") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .AddParam("$id") 
+                .Uint32(1) 
+                .Build() 
+            .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(insertQuery, 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
         if constexpr (UseNewEngine) {
             // ¯\_(ツ)_/¯
             UNIT_ASSERT_C(result.GetIssues().Size() == 0, result.GetIssues().ToString());
         } else {
             UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_OPERATION_REVERTED));
         }
-
-        params = db.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(10)
-                        .AddMember("Value").String("Ten2")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(11)
-                        .AddMember("Value").String("Eleven2")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(10)
-                        .AddMember("Value").String("None2")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .AddParam("$id")
-                .Uint32(2)
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(insertQuery,
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
+ 
+        params = db.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(10) 
+                        .AddMember("Value").String("Ten2") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(11) 
+                        .AddMember("Value").String("Eleven2") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(10) 
+                        .AddMember("Value").String("None2") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .AddParam("$id") 
+                .Uint32(2) 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(insertQuery, 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
         if constexpr (UseNewEngine) {
             // ¯\_(ツ)_/¯
             UNIT_ASSERT_C(result.GetIssues().Size() == 0, result.GetIssues().ToString());
         } else {
             UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_OPERATION_REVERTED));
         }
-
-        params = db.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(10)
-                        .AddMember("Value").String("Ten3")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Uint64(11)
-                        .AddMember("Value").String("Eleven3")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .AddParam("$id")
-                .Uint32(3)
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(insertQuery,
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
+ 
+        params = db.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(10) 
+                        .AddMember("Value").String("Ten3") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Uint64(11) 
+                        .AddMember("Value").String("Eleven3") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .AddParam("$id") 
+                .Uint32(3) 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(insertQuery, 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
         result = session.ExecuteDataQuery(Q_(R"(
             SELECT * FROM `/Root/KeyValue`;
             SELECT * FROM `/Root/TxCheck`;
         )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        CompareYson(R"([
-            [[1u];["One"]];
-            [[2u];["Two"]];
-            [[10u];["Ten3"]];
-            [[11u];["Eleven3"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-        CompareYson(R"([[[1u]];[[2u]];[[3u]]])", FormatResultSetYson(result.GetResultSet(1)));
-    }
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        CompareYson(R"([ 
+            [[1u];["One"]]; 
+            [[2u];["Two"]]; 
+            [[10u];["Ten3"]]; 
+            [[11u];["Eleven3"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+        CompareYson(R"([[[1u]];[[2u]];[[3u]]])", FormatResultSetYson(result.GetResultSet(1))); 
+    } 
+ 
     Y_UNIT_TEST_NEW_ENGINE(ProjectReplace) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        NYdb::NTable::TExecDataQuerySettings execSettings;
-        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic);
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("In_Group").OptionalUint32(10)
-                        .AddMember("In_Name").OptionalString("Replace1")
-                        .AddMember("In_Amount").OptionalUint64(100)
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("In_Group").OptionalUint32(10)
-                        .AddMember("In_Name").OptionalString("Replace2")
-                        .AddMember("In_Amount").OptionalUint64(200)
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .Build();
-
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        NYdb::NTable::TExecDataQuerySettings execSettings; 
+        execSettings.CollectQueryStats(ECollectQueryStatsMode::Basic); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("In_Group").OptionalUint32(10) 
+                        .AddMember("In_Name").OptionalString("Replace1") 
+                        .AddMember("In_Amount").OptionalUint64(100) 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("In_Group").OptionalUint32(10) 
+                        .AddMember("In_Name").OptionalString("Replace2") 
+                        .AddMember("In_Amount").OptionalUint64(200) 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
         auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $rows AS List<Struct<
-                In_Group : Uint32?,
-                In_Name : String?,
-                In_Amount : Uint64?
-            >>;
-
+            DECLARE $rows AS List<Struct< 
+                In_Group : Uint32?, 
+                In_Name : String?, 
+                In_Amount : Uint64? 
+            >>; 
+ 
             REPLACE INTO `/Root/Test`
-            SELECT
-                In_Group AS Group,
-                In_Name AS Name,
-                In_Amount AS Amount
-            FROM AS_TABLE($rows);
+            SELECT 
+                In_Group AS Group, 
+                In_Name AS Name, 
+                In_Amount AS Amount 
+            FROM AS_TABLE($rows); 
         )"), TTxControl::BeginTx().CommitTx(), params, execSettings).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats());
-
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        auto& stats = NYdb::TProtoAccessor::GetProto(*result.GetStats()); 
+ 
         UNIT_ASSERT_VALUES_EQUAL(stats.query_phases().size(), UseNewEngine ? 2 : 1);
-    }
-
-    Y_UNIT_TEST(Uint8Key) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        UNIT_ASSERT(session.ExecuteSchemeQuery(R"(
-            --!syntax_v1
+    } 
+ 
+    Y_UNIT_TEST(Uint8Key) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        UNIT_ASSERT(session.ExecuteSchemeQuery(R"( 
+            --!syntax_v1 
             CREATE TABLE `/Root/Temp` (
-                Key Uint8,
-                PRIMARY KEY (Key)
-            );
-        )").GetValueSync().IsSuccess());
-
-        auto result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
+                Key Uint8, 
+                PRIMARY KEY (Key) 
+            ); 
+        )").GetValueSync().IsSuccess()); 
+ 
+        auto result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
             PRAGMA Kikimr.UseNewEngine = 'false';
             UPSERT INTO `/Root/Temp` (Key) VALUES (127);
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
             PRAGMA Kikimr.UseNewEngine = 'false';
             UPSERT INTO `/Root/Temp` (Key) VALUES (128);
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
             PRAGMA Kikimr.UseNewEngine = 'false';
             DELETE FROM `/Root/Temp` ON (Key) VALUES (140);
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        result = session.ExecuteDataQuery(R"(
-            --!syntax_v1
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        result = session.ExecuteDataQuery(R"( 
+            --!syntax_v1 
             PRAGMA Kikimr.UseNewEngine = 'false';
             SELECT * FROM `/Root/Temp`;
-        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([[[127u]]])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(CastValues) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$items")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").Int32(101)
-                        .AddMember("Data").Uint32(1000)
-                    .EndStruct()
-                .EndList()
-            .Build()
-        .Build();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':Int32,'Data':Uint32>>;
-
-            UPSERT INTO EightShard
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(Q1_(R"(
-            SELECT * FROM EightShard WHERE Key = 101;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1000];[101u];["Value1"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(CastValuesOptional) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto params = db.GetParamsBuilder()
-            .AddParam("$items")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").OptionalInt32(101)
-                        .AddMember("Data").OptionalUint32(1000)
-                    .EndStruct()
-                .EndList()
-            .Build()
-        .Build();
-
-        auto result = session.ExecuteDataQuery(Q1_(R"(
-            DECLARE $items AS List<Struct<'Key':Int32?,'Data':Uint32?>>;
-
-            UPSERT INTO EightShard
-            SELECT * FROM AS_TABLE($items);
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        result = session.ExecuteDataQuery(Q1_(R"(
-            SELECT * FROM EightShard WHERE Key = 101;
-        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1000];[101u];["Value1"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-}
-
+        )", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([[[127u]]])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(CastValues) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$items") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").Int32(101) 
+                        .AddMember("Data").Uint32(1000) 
+                    .EndStruct() 
+                .EndList() 
+            .Build() 
+        .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':Int32,'Data':Uint32>>; 
+ 
+            UPSERT INTO EightShard 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(Q1_(R"( 
+            SELECT * FROM EightShard WHERE Key = 101; 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1000];[101u];["Value1"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(CastValuesOptional) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto params = db.GetParamsBuilder() 
+            .AddParam("$items") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").OptionalInt32(101) 
+                        .AddMember("Data").OptionalUint32(1000) 
+                    .EndStruct() 
+                .EndList() 
+            .Build() 
+        .Build(); 
+ 
+        auto result = session.ExecuteDataQuery(Q1_(R"( 
+            DECLARE $items AS List<Struct<'Key':Int32?,'Data':Uint32?>>; 
+ 
+            UPSERT INTO EightShard 
+            SELECT * FROM AS_TABLE($items); 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), params).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        result = session.ExecuteDataQuery(Q1_(R"( 
+            SELECT * FROM EightShard WHERE Key = 101; 
+        )"), TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1000];[101u];["Value1"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+} 
+ 
 } // namespace NKqp
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/kqp_yql_ut.cpp b/ydb/core/kqp/ut/kqp_yql_ut.cpp
index 99fee295a6..45dae11203 100644
--- a/ydb/core/kqp/ut/kqp_yql_ut.cpp
+++ b/ydb/core/kqp/ut/kqp_yql_ut.cpp
@@ -1,86 +1,86 @@
 #include <ydb/core/kqp/ut/common/kqp_ut_common.h>
-
+ 
 #include <ydb/public/sdk/cpp/client/draft/ydb_scripting.h>
-
-namespace NKikimr {
-namespace NKqp {
-
-using namespace NYdb;
-using namespace NYdb::NScripting;
-using namespace NYdb::NTable;
-
-Y_UNIT_TEST_SUITE(KqpYql) {
-    Y_UNIT_TEST(RefSelect) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
-            PRAGMA RefSelect;
+ 
+namespace NKikimr { 
+namespace NKqp { 
+ 
+using namespace NYdb; 
+using namespace NYdb::NScripting; 
+using namespace NYdb::NTable; 
+ 
+Y_UNIT_TEST_SUITE(KqpYql) { 
+    Y_UNIT_TEST(RefSelect) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
+            PRAGMA RefSelect; 
             SELECT * FROM `/Root/Test`;
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_OPTIMIZATION));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
-    Y_UNIT_TEST(TableConcat) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_OPTIMIZATION)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
+    Y_UNIT_TEST(TableConcat) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             SELECT * FROM CONCAT(`/Root/Test`, `/Root/Test`)
-            WHERE Group = 1;
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_INTENT));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
-    Y_UNIT_TEST(TableRange) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+            WHERE Group = 1; 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_INTENT)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
+    Y_UNIT_TEST(TableRange) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             SELECT * FROM RANGE(`Root`, `/Root/Test`, `/Root/Test`)
-            WHERE Group = 1;
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_INTENT));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
-    Y_UNIT_TEST(TableUseBeforeCreate) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+            WHERE Group = 1; 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_INTENT)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
+    Y_UNIT_TEST(TableUseBeforeCreate) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             SELECT * FROM `/Root/NewTable`;
-
-            COMMIT;
-
+ 
+            COMMIT; 
+ 
             CREATE TABLE `/Root/NewTable` (
-                Id Uint32,
-                Value String,
-                PRIMARY KEY(Id)
-            );
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
+                Id Uint32, 
+                Value String, 
+                PRIMARY KEY(Id) 
+            ); 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
     Y_UNIT_TEST(ColumnNameConflict) {
         TKikimrRunner kikimr;
         TScriptingClient client(kikimr.GetDriver());
@@ -101,215 +101,215 @@ Y_UNIT_TEST_SUITE(KqpYql) {
         UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
     }
 
-    Y_UNIT_TEST(TableNameConflict) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+    Y_UNIT_TEST(TableNameConflict) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             SELECT * FROM `/Root/Test`;
-
-            COMMIT;
-
+ 
+            COMMIT; 
+ 
             DROP TABLE `/Root/Test`;
-
+ 
             CREATE TABLE `/Root/Test` (
-                Id Uint32,
-                Value String,
-                PRIMARY KEY (Id)
-            );
-
-            COMMIT;
-
+                Id Uint32, 
+                Value String, 
+                PRIMARY KEY (Id) 
+            ); 
+ 
+            COMMIT; 
+ 
             SELECT * FROM `/Root/Test`;
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
-    Y_UNIT_TEST(DdlDmlMix) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
+    Y_UNIT_TEST(DdlDmlMix) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             SELECT * FROM `/Root/Test`;
             DROP TABLE `/Root/Test`;
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_MIXED_SCHEME_DATA_TX));
-    }
-
-    Y_UNIT_TEST(ScriptUdf) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
-            $extractor = @@
-            def inc_value(value):
-                return value + 1
-            @@;
-
-            $udf = Python::inc_value(Callable<(Uint64)->Uint64>, $extractor);
-
-            SELECT $udf(10) AS Result;
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
-    Y_UNIT_TEST(UpdatePk) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_MIXED_SCHEME_DATA_TX)); 
+    } 
+ 
+    Y_UNIT_TEST(ScriptUdf) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
+            $extractor = @@ 
+            def inc_value(value): 
+                return value + 1 
+            @@; 
+ 
+            $udf = Python::inc_value(Callable<(Uint64)->Uint64>, $extractor); 
+ 
+            SELECT $udf(10) AS Result; 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
+    Y_UNIT_TEST(UpdatePk) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             UPDATE `/Root/Test`
-            SET Group = Group + 1
-            WHERE Name != "Paul";
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
-    Y_UNIT_TEST(UpdateBadType) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+            SET Group = Group + 1 
+            WHERE Name != "Paul"; 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
+    Y_UNIT_TEST(UpdateBadType) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             UPDATE `/Root/Test`
-            SET Amount = Name;
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
-    Y_UNIT_TEST(InsertCV) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+            SET Amount = Name; 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_TYPE_ANN)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
+    Y_UNIT_TEST(InsertCV) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             INSERT INTO `/Root/Test` (Group, Name, Amount) VALUES
-                (1u, "Anna", 10000);
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION));
-    }
-
-    Y_UNIT_TEST(InsertCVList) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+                (1u, "Anna", 10000); 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION)); 
+    } 
+ 
+    Y_UNIT_TEST(InsertCVList) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             INSERT INTO `/Root/Test` (Group, Name, Amount) VALUES
-                (100u, "NewName1", 10),
-                (110u, "NewName2", 20),
-                (100u, "NewName1", 30);
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION));
-    }
-
-    Y_UNIT_TEST(InsertIgnore) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+                (100u, "NewName1", 10), 
+                (110u, "NewName2", 20), 
+                (100u, "NewName1", 30); 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_CONSTRAINT_VIOLATION)); 
+    } 
+ 
+    Y_UNIT_TEST(InsertIgnore) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             INSERT OR IGNORE INTO `/Root/Test` (Group, Name, Amount) VALUES
-                (1u, "Anna", 10000),
-                (100u, "NewName1", 10);
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_INTENT));
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR));
-    }
-
-    Y_UNIT_TEST_NEW_ENGINE(StrictDml) {
-        TKikimrRunner kikimr;
-        auto db = kikimr.GetTableClient();
-        auto session = db.CreateSession().GetValueSync().GetSession();
-
-        auto result = session.ExecuteDataQuery(Q_(R"(
-            --!syntax_v1
+                (1u, "Anna", 10000), 
+                (100u, "NewName1", 10); 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+ 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::CORE_INTENT)); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::DEFAULT_ERROR)); 
+    } 
+ 
+    Y_UNIT_TEST_NEW_ENGINE(StrictDml) { 
+        TKikimrRunner kikimr; 
+        auto db = kikimr.GetTableClient(); 
+        auto session = db.CreateSession().GetValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteDataQuery(Q_(R"( 
+            --!syntax_v1 
             DELETE FROM `/Root/Test` WHERE Group = 1;
             UPDATE `/Root/Test` SET Comment = "Updated" WHERE Group = 2;
-        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
-        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_READ_MODIFIED_TABLE));
-    }
-
-    Y_UNIT_TEST(UnwrapReadTableValues) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
-            PRAGMA kikimr.UnwrapReadTableValues = "true";
+        )"), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR); 
+        UNIT_ASSERT(HasIssue(result.GetIssues(), NYql::TIssuesIds::KIKIMR_READ_MODIFIED_TABLE)); 
+    } 
+ 
+    Y_UNIT_TEST(UnwrapReadTableValues) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
+            PRAGMA kikimr.UnwrapReadTableValues = "true"; 
             SELECT LENGTH(Name) == 4 AND Amount > 1000 FROM `/Root/Test`;
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [%true];[%false];[%true]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-
-    Y_UNIT_TEST(CreateUseTable) {
-        TKikimrRunner kikimr;
-        TScriptingClient client(kikimr.GetDriver());
-
-        auto result = client.ExecuteYqlScript(R"(
-            --!syntax_v1
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [%true];[%false];[%true] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+ 
+    Y_UNIT_TEST(CreateUseTable) { 
+        TKikimrRunner kikimr; 
+        TScriptingClient client(kikimr.GetDriver()); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            --!syntax_v1 
             CREATE TABLE `/Root/NewTable` (
-                Id Uint32,
-                Value String,
-                PRIMARY KEY(Id)
-            );
-            COMMIT;
-
+                Id Uint32, 
+                Value String, 
+                PRIMARY KEY(Id) 
+            ); 
+            COMMIT; 
+ 
             REPLACE INTO `/Root/NewTable` (Id, Value) VALUES
-                (1, "One"),
-                (2, "Two");
-            COMMIT;
-
+                (1, "One"), 
+                (2, "Two"); 
+            COMMIT; 
+ 
             SELECT * FROM `/Root/NewTable`;
-        )").GetValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-
-        CompareYson(R"([
-            [[1u];["One"]];
-            [[2u];["Two"]]
-        ])", FormatResultSetYson(result.GetResultSet(0)));
-    }
-}
-
-} // namespace NKqp
-} // namespace NKikimr
+        )").GetValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+ 
+        CompareYson(R"([ 
+            [[1u];["One"]]; 
+            [[2u];["Two"]] 
+        ])", FormatResultSetYson(result.GetResultSet(0))); 
+    } 
+} 
+ 
+} // namespace NKqp 
+} // namespace NKikimr 
diff --git a/ydb/core/kqp/ut/ya.make b/ydb/core/kqp/ut/ya.make
index 609ec3237f..16bfde1ee4 100644
--- a/ydb/core/kqp/ut/ya.make
+++ b/ydb/core/kqp/ut/ya.make
@@ -1,12 +1,12 @@
 UNITTEST_FOR(ydb/core/kqp)
-
+ 
 OWNER(
     spuchin
     g:kikimr
 )
-
-FORK_SUBTESTS()
-
+ 
+FORK_SUBTESTS() 
+ 
 IF (WITH_VALGRIND)
     TIMEOUT(2400)
     TAG(ya:fat)
@@ -17,48 +17,48 @@ ELSE()
     TIMEOUT(600)
     SIZE(MEDIUM)
 ENDIF()
-
-SRCS(
+ 
+SRCS( 
     kqp_acl_ut.cpp
     kqp_arrow_in_channels_ut.cpp
-    kqp_document_api_ut.cpp
-    kqp_effects_perf_ut.cpp
+    kqp_document_api_ut.cpp 
+    kqp_effects_perf_ut.cpp 
     kqp_explain_ut.cpp
     kqp_flip_join_ut.cpp
     kqp_index_lookup_join_ut.cpp
     kqp_indexes_ut.cpp
     kqp_indexes_multishard_ut.cpp
-    kqp_join_ut.cpp
-    kqp_limits_ut.cpp
-    kqp_locks_ut.cpp
+    kqp_join_ut.cpp 
+    kqp_limits_ut.cpp 
+    kqp_locks_ut.cpp 
     kqp_merge_connection_ut.cpp
     kqp_mvcc_ut.cpp
     kqp_newengine_effects_ut.cpp
     kqp_newengine_flowcontrol_ut.cpp
-    kqp_newengine_ut.cpp
+    kqp_newengine_ut.cpp 
     kqp_not_null_columns_ut.cpp
     kqp_olap_ut.cpp
-    kqp_params_ut.cpp
-    kqp_pragma_ut.cpp
-    kqp_query_ut.cpp
-    kqp_scan_spilling_ut.cpp
-    kqp_scan_ut.cpp
-    kqp_scheme_ut.cpp
-    kqp_scripting_ut.cpp
-    kqp_service_ut.cpp
-    kqp_sort_ut.cpp
+    kqp_params_ut.cpp 
+    kqp_pragma_ut.cpp 
+    kqp_query_ut.cpp 
+    kqp_scan_spilling_ut.cpp 
+    kqp_scan_ut.cpp 
+    kqp_scheme_ut.cpp 
+    kqp_scripting_ut.cpp 
+    kqp_service_ut.cpp 
+    kqp_sort_ut.cpp 
     kqp_stats_ut.cpp
     kqp_sqlin_ut.cpp
     kqp_sys_view_ut.cpp
     kqp_sys_col_ut.cpp
-    kqp_table_predicate_ut.cpp
-    kqp_tx_ut.cpp
+    kqp_table_predicate_ut.cpp 
+    kqp_tx_ut.cpp 
     kqp_types_arrow_ut.cpp
-    kqp_write_ut.cpp
-    kqp_yql_ut.cpp
-)
-
-PEERDIR(
+    kqp_write_ut.cpp 
+    kqp_yql_ut.cpp 
+) 
+ 
+PEERDIR( 
     library/cpp/threading/local_executor
     ydb/core/client/minikql_compile
     ydb/core/kqp
@@ -68,14 +68,14 @@ PEERDIR(
     ydb/core/kqp/ut/common
     ydb/public/sdk/cpp/client/draft
     ydb/public/sdk/cpp/client/ydb_proto
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
 REQUIREMENTS(ram:12)
 
-END()
-
+END() 
+ 
 RECURSE(
     fat
     ../rm/ut
diff --git a/ydb/core/kqp/ya.make b/ydb/core/kqp/ya.make
index 795edda64f..f76cef1110 100644
--- a/ydb/core/kqp/ya.make
+++ b/ydb/core/kqp/ya.make
@@ -1,28 +1,28 @@
-LIBRARY()
-
-OWNER(
-    spuchin
+LIBRARY() 
+ 
+OWNER( 
+    spuchin 
     g:kikimr
-)
-
-SRCS(
-    kqp_compile_actor.cpp
-    kqp_compile_request.cpp
-    kqp_compile_service.cpp
+) 
+ 
+SRCS( 
+    kqp_compile_actor.cpp 
+    kqp_compile_request.cpp 
+    kqp_compile_service.cpp 
     kqp_shutdown_controller.cpp
     kqp_query_replay.h
-    kqp_ic_gateway.cpp
+    kqp_ic_gateway.cpp 
     kqp_ic_gateway_actors.h
     kqp_metadata_loader.cpp
     kqp_metadata_loader.h
-    kqp_impl.h
-    kqp_response.cpp
-    kqp_worker_actor.cpp
+    kqp_impl.h 
+    kqp_response.cpp 
+    kqp_worker_actor.cpp 
     kqp_session_actor.cpp
-    kqp.h
-)
-
-PEERDIR(
+    kqp.h 
+) 
+ 
+PEERDIR( 
     contrib/libs/apache/arrow
     library/cpp/actors/core
     library/cpp/actors/helpers
@@ -55,15 +55,15 @@ PEERDIR(
     ydb/public/api/protos
     ydb/public/lib/base
     ydb/public/lib/operation_id
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-RESOURCE(
+RESOURCE( 
     ydb/core/kqp/kqp_default_settings.txt kqp_default_settings.txt
-)
-
-END()
+) 
+ 
+END() 
 
 RECURSE(
     common
diff --git a/ydb/core/protos/config.proto b/ydb/core/protos/config.proto
index d64169d4fc..bd86d31e76 100644
--- a/ydb/core/protos/config.proto
+++ b/ydb/core/protos/config.proto
@@ -548,8 +548,8 @@ message TTabletsConfig {
 
 message TKQPConfig {
     optional bool Enable = 1 [default = true];
-
-    repeated NKikimrKqp.TKqpSetting Settings = 10;
+ 
+    repeated NKikimrKqp.TKqpSetting Settings = 10; 
 }
 
 message TMemoryLogConfig {
@@ -641,7 +641,7 @@ message TFeatureFlags {
     optional bool DisableDataShardBarrier = 26 [default = false];
     optional bool EnablePutBatchingForBlobStorage = 27 [default = true];
     optional bool EnableKqpWideFlow = 28 [default = true]; // deprecated: always true
-    optional bool EnableKqpScanQueries = 29 [default = true]; // deprecated: always true
+    optional bool EnableKqpScanQueries = 29 [default = true]; // deprecated: always true 
     optional bool EnablePersistentPartitionStats = 30 [default = false];
     optional bool EnableTtlOnIndexedTables = 31 [default = true]; // deprecated: always true
     optional bool AllowUpdateChannelsBindingOfSolomonPartitions = 32 [default = false];
@@ -674,8 +674,8 @@ message TFeatureFlags {
     // Dangerous settings we don't want in the public api unless required
     optional bool EnablePublicApiExternalBlobs = 59 [default = false];
     optional bool EnablePublicApiKeepInMemory = 60 [default = false];
-    optional bool EnableImplicitScanQueryInScripts = 61 [default = true];
-    optional bool EnablePredicateExtractForScanQueries = 62 [default = true];
+    optional bool EnableImplicitScanQueryInScripts = 61 [default = true]; 
+    optional bool EnablePredicateExtractForScanQueries = 62 [default = true]; 
 }
 
 message TSqsConfig {
@@ -944,15 +944,15 @@ message TTableProfilesConfig {
     repeated TCachingPolicy CachingPolicies = 7;
 }
 
-message TTableServiceConfig {
-    message TResourceManager {
-        optional uint32 ComputeActorsCount = 1 [default = 1000];
+message TTableServiceConfig { 
+    message TResourceManager { 
+        optional uint32 ComputeActorsCount = 1 [default = 1000]; 
         optional uint64 ChannelBufferSize = 2 [default = 4194304];              //  4 MB
         optional uint64 ScanBufferSize = 3 [default = 8388608];                 //  8 MB
         optional uint64 MkqlLightProgramMemoryLimit = 4 [default = 31457280];   // 30 MB
         optional uint64 MkqlHeavyProgramMemoryLimit = 5 [default = 31457280];   // 30 MB
         optional uint64 QueryMemoryLimit = 6 [default = 32212254720];           // 30 GB
-        optional uint32 PublishStatisticsIntervalSec = 7 [default = 2];
+        optional uint32 PublishStatisticsIntervalSec = 7 [default = 2]; 
         optional bool EnableInstantMkqlMemoryAlloc = 8 [default = true];
         reserved 9;  // optional uint32 InstantMkqlMemoryAllocWaitTimeMs = 9 [default = 20];
         reserved 10; // optional uint32 InstantMkqlMemoryAllocStepTimeMs = 10 [default = 1];
@@ -962,8 +962,8 @@ message TTableServiceConfig {
 
         optional uint64 MaxTotalScanBuffersSize = 13 [default = 4294967296];    // 4 GB
         optional uint64 MinScanBufferSize = 14 [default = 2097152];             // 2 MB
-    }
-
+    } 
+ 
     message TSpillingServiceConfig {
         message TLocalFileConfig {
             optional bool Enable = 1 [default = false];
@@ -982,21 +982,21 @@ message TTableServiceConfig {
         optional TLocalFileConfig LocalFileConfig = 1;
     }
 
-    message TQueryPhaseLimits {
-        optional uint32 AffectedShardsLimit = 1;
-        optional uint32 ReadsetCountLimit = 2;
-        optional uint64 ComputeNodeMemoryLimitBytes = 3;
-        optional uint64 TotalReadSizeLimitBytes = 4;
-    }
-
-    message TQueryLimits {
-        optional TQueryPhaseLimits PhaseLimits = 1;
-        optional uint32 SchemeQueryTimeoutMs = 2 [default = 600000];
-        optional uint32 DataQueryTimeoutMs = 3 [default = 300000];
-        optional uint32 ScanQueryTimeoutMs = 4 [default = 300000];
-        optional uint32 ResultRowsLimit = 5;
-    }
-
+    message TQueryPhaseLimits { 
+        optional uint32 AffectedShardsLimit = 1; 
+        optional uint32 ReadsetCountLimit = 2; 
+        optional uint64 ComputeNodeMemoryLimitBytes = 3; 
+        optional uint64 TotalReadSizeLimitBytes = 4; 
+    } 
+ 
+    message TQueryLimits { 
+        optional TQueryPhaseLimits PhaseLimits = 1; 
+        optional uint32 SchemeQueryTimeoutMs = 2 [default = 600000]; 
+        optional uint32 DataQueryTimeoutMs = 3 [default = 300000]; 
+        optional uint32 ScanQueryTimeoutMs = 4 [default = 300000]; 
+        optional uint32 ResultRowsLimit = 5; 
+    } 
+ 
     message TShutdownSettings {
         optional uint32 ShutdownTimeoutMs = 1 [default = 30000];
         optional uint32 HardTimeoutMs = 2 [default = 10000];
@@ -1006,7 +1006,7 @@ message TTableServiceConfig {
     message TSessionBalancerSettings {
         optional bool Enabled = 1 [default = false];
         // MaxSessionsShutdownInFlightSize option determines the number of sessions
-        // that we can keep in shutdown state at the moment.
+        // that we can keep in shutdown state at the moment. 
         optional uint32 MaxSessionsShutdownInFlightSize = 2 [default = 3];
         //         GREEN ZONE         YELLOW ZONE               RED ZONE
         //                     MinCV                   MaxCV
@@ -1055,21 +1055,21 @@ message TTableServiceConfig {
         optional uint32 LeakyBucketQuotaBucketDurationSeconds = 6 [default = 60];
     }
 
-    optional uint32 QueryLimitBytes = 1;
-    optional uint32 ParametersLimitBytes = 2;
-    optional uint32 SessionsLimitPerNode = 3;
+    optional uint32 QueryLimitBytes = 1; 
+    optional uint32 ParametersLimitBytes = 2; 
+    optional uint32 SessionsLimitPerNode = 3; 
     reserved 4; // obsolete: optional uint32 SessionQueryCacheSize = 4 [default = 1000];
-    reserved 5; // UseCompileService (always true)
-    optional uint32 CompileQueryCacheSize = 6 [default = 1000];
-    optional uint32 CompileMaxActiveRequests = 7 [default = 4];
-    optional uint32 CompileRequestQueueSize = 8 [default = 1000];
-    optional bool UseSchemeCacheMetadata = 9 [default = true];
-    optional bool UseSessionBusyStatus = 10 [default = true];
-    optional bool AllowUnsafeCommit = 11 [default = true];
-    optional uint32 CompileTimeoutMs = 12 [default = 60000];
-    optional TResourceManager ResourceManager = 13;
-    optional TQueryLimits QueryLimits = 14;
-    optional uint32 SqlVersion = 15;
+    reserved 5; // UseCompileService (always true) 
+    optional uint32 CompileQueryCacheSize = 6 [default = 1000]; 
+    optional uint32 CompileMaxActiveRequests = 7 [default = 4]; 
+    optional uint32 CompileRequestQueueSize = 8 [default = 1000]; 
+    optional bool UseSchemeCacheMetadata = 9 [default = true]; 
+    optional bool UseSessionBusyStatus = 10 [default = true]; 
+    optional bool AllowUnsafeCommit = 11 [default = true]; 
+    optional uint32 CompileTimeoutMs = 12 [default = 60000]; 
+    optional TResourceManager ResourceManager = 13; 
+    optional TQueryLimits QueryLimits = 14; 
+    optional uint32 SqlVersion = 15; 
     optional TSpillingServiceConfig SpillingServiceConfig = 16;
     optional TShutdownSettings ShutdownSettings = 17;
     optional TSessionBalancerSettings SessionBalancerSettings = 18;
@@ -1082,8 +1082,8 @@ message TTableServiceConfig {
     optional uint32 ForceNewEngineLevel = 22 [default = 0];
     optional uint32 CompileQueryCacheTTLSec = 20 [default = 0];
     optional TQueryReplayConfig QueryReplayConfig = 21;
-};
-
+}; 
+ 
 // Config describes immediate controls and allows
 // to manage their values (not variety and limits)
 // via CMS. All fields should be either [u]int64 or
@@ -1366,7 +1366,7 @@ message TAppConfig {
     optional NKikimrProto.TKeyConfig KeyConfig = 35;
     optional NKikimrProto.TKeyConfig PDiskKeyConfig = 51;
     optional NKikimrNodeBroker.TConfig NodeBrokerConfig = 36;
-    optional TTableServiceConfig TableServiceConfig = 37;
+    optional TTableServiceConfig TableServiceConfig = 37; 
     optional NKikimrSharedCache.TSharedCacheConfig SharedCacheConfig = 38; // dynamic configuration via cms
     optional TImmediateControlsConfig ImmediateControlsConfig = 39;
     optional TAllocatorConfig AllocatorConfig = 40;
diff --git a/ydb/core/protos/console_base.proto b/ydb/core/protos/console_base.proto
index 373311c5d1..4f95fef6c0 100644
--- a/ydb/core/protos/console_base.proto
+++ b/ydb/core/protos/console_base.proto
@@ -4,6 +4,6 @@ package NKikimrConsole;
 option java_package = "ru.yandex.kikimr.proto";
 
 message TStatus {
-    optional Ydb.StatusIds.StatusCode Code = 1;
+    optional Ydb.StatusIds.StatusCode Code = 1; 
     optional string Reason = 2;
 }
diff --git a/ydb/core/protos/console_config.proto b/ydb/core/protos/console_config.proto
index d5a32d05c6..98475dcd10 100644
--- a/ydb/core/protos/console_config.proto
+++ b/ydb/core/protos/console_config.proto
@@ -98,7 +98,7 @@ message TConfigItem {
         TableProfilesConfigItem = 34;
         KeyConfigItem = 35;
         NodeBrokerConfigItem = 36;
-        TableServiceConfigItem = 37;
+        TableServiceConfigItem = 37; 
         SharedCacheConfigItem = 38;
         ImmediateControlsConfigItem = 39;
         AllocatorConfigItem = 40;
@@ -490,4 +490,4 @@ message TConfigsConfig {
 
     optional TUsageScopeRestrictions UsageScopeRestrictions = 1;
     optional TValidationOptions ValidationOptions = 2;
-}
+} 
diff --git a/ydb/core/protos/counters_datashard.proto b/ydb/core/protos/counters_datashard.proto
index 956a136937..a76bba018e 100644
--- a/ydb/core/protos/counters_datashard.proto
+++ b/ydb/core/protos/counters_datashard.proto
@@ -56,12 +56,12 @@ enum ECumulativeCounters {
     COUNTER_READSET_RECEIVED_COUNT = 30                   [(CounterOpts) = {Name: "ReadsetReceivedCount"}];
     COUNTER_READSET_RECEIVED_SIZE = 31                    [(CounterOpts) = {Name: "ReadsetReceivedSize"}];
     COUNTER_TX_RESULT_SIZE = 32                           [(CounterOpts) = {Name: "TxResultSize"}];
-    COUNTER_LOCKS_REJECTED = 33                           [(CounterOpts) = {Name: "LocksRejected"}];
-    COUNTER_LOCKS_ACQUIRED = 34                           [(CounterOpts) = {Name: "LocksAcquired"}];
-    COUNTER_LOCKS_EVICTED = 35                            [(CounterOpts) = {Name: "LocksEvicted"}];
-    COUNTER_LOCKS_BROKEN = 36                             [(CounterOpts) = {Name: "LocksBroken"}];
-    COUNTER_LOCKS_ERASED = 37                             [(CounterOpts) = {Name: "LocksErased"}];
-    COUNTER_LOCKS_REMOVED = 38                            [(CounterOpts) = {Name: "LocksRemoved"}];
+    COUNTER_LOCKS_REJECTED = 33                           [(CounterOpts) = {Name: "LocksRejected"}]; 
+    COUNTER_LOCKS_ACQUIRED = 34                           [(CounterOpts) = {Name: "LocksAcquired"}]; 
+    COUNTER_LOCKS_EVICTED = 35                            [(CounterOpts) = {Name: "LocksEvicted"}]; 
+    COUNTER_LOCKS_BROKEN = 36                             [(CounterOpts) = {Name: "LocksBroken"}]; 
+    COUNTER_LOCKS_ERASED = 37                             [(CounterOpts) = {Name: "LocksErased"}]; 
+    COUNTER_LOCKS_REMOVED = 38                            [(CounterOpts) = {Name: "LocksRemoved"}]; 
     COUNTER_LOCKS_REJECT_BROKEN = 39                      [(CounterOpts) = {Name: "LocksRejectBroken"}];
     COUNTER_LOCKS_LOST = 40                               [(CounterOpts) = {Name: "LocksLost"}];
     COUNTER_INACTIVE_TX_DATA_RELEASES = 41                [(CounterOpts) = {Name: "InactiveTxDataReleases"}];
@@ -138,34 +138,34 @@ enum EPercentileCounters {
     COUNTER_PLAN_TO_EXECUTE_LATENCY = 3                   [(CounterOpts) = {Name: "PlanToExecuteLatency"}];
     COUNTER_PREPARE_EXEC_LATENCY = 4                      [(CounterOpts) = {Name: "PrepareExecLatency"}];
     COUNTER_TX_PROGRESS_EXEC_LATENCY = 5                  [(CounterOpts) = {Name: "TxProgressExecLatency"}];
-
-    COUNTER_LOCKS_ACTIVE_PER_SHARD = 6                    [(CounterOpts) = {Name: "LocksActivePerShard",
+ 
+    COUNTER_LOCKS_ACTIVE_PER_SHARD = 6                    [(CounterOpts) = {Name: "LocksActivePerShard", 
                                                               Ranges: { Value: 0     Name: "0"},
                                                               Ranges: { Value: 1     Name: "1-10"},
-                                                              Ranges: { Value: 10    Name: "10-100"}
-                                                              Ranges: { Value: 100   Name: "100-500"}
-                                                              Ranges: { Value: 500   Name: "500-1000"}
-                                                              Ranges: { Value: 1000  Name: "1000-4000"}
-                                                              Ranges: { Value: 4000  Name: "4000-8000"}
-                                                              Ranges: { Value: 8000  Name: "8000-12000"}
-                                                              Ranges: { Value: 12000 Name: "12000-16000"}
-                                                              Ranges: { Value: 16000 Name: "16000-Inf"}
-                                                          }];
-
-    COUNTER_LOCKS_BROKEN_PER_SHARD = 7                    [(CounterOpts) = {Name: "LocksBrokenPerShard",
+                                                              Ranges: { Value: 10    Name: "10-100"} 
+                                                              Ranges: { Value: 100   Name: "100-500"} 
+                                                              Ranges: { Value: 500   Name: "500-1000"} 
+                                                              Ranges: { Value: 1000  Name: "1000-4000"} 
+                                                              Ranges: { Value: 4000  Name: "4000-8000"} 
+                                                              Ranges: { Value: 8000  Name: "8000-12000"} 
+                                                              Ranges: { Value: 12000 Name: "12000-16000"} 
+                                                              Ranges: { Value: 16000 Name: "16000-Inf"} 
+                                                          }]; 
+ 
+    COUNTER_LOCKS_BROKEN_PER_SHARD = 7                    [(CounterOpts) = {Name: "LocksBrokenPerShard", 
                                                               Ranges: { Value: 0     Name: "0"},
                                                               Ranges: { Value: 1     Name: "1-10"},
-                                                              Ranges: { Value: 10    Name: "10-100"}
-                                                              Ranges: { Value: 100   Name: "100-500"}
-                                                              Ranges: { Value: 500   Name: "500-1000"}
-                                                              Ranges: { Value: 1000  Name: "1000-4000"}
-                                                              Ranges: { Value: 4000  Name: "4000-8000"}
-                                                              Ranges: { Value: 8000  Name: "8000-12000"}
-                                                              Ranges: { Value: 12000 Name: "12000-16000"}
-                                                              Ranges: { Value: 16000 Name: "16000-Inf"}
-                                                          }];
-
-    COUNTER_LOCKS_LIFETIME = 8                            [(CounterOpts) = {Name: "LocksLifetime"}];
+                                                              Ranges: { Value: 10    Name: "10-100"} 
+                                                              Ranges: { Value: 100   Name: "100-500"} 
+                                                              Ranges: { Value: 500   Name: "500-1000"} 
+                                                              Ranges: { Value: 1000  Name: "1000-4000"} 
+                                                              Ranges: { Value: 4000  Name: "4000-8000"} 
+                                                              Ranges: { Value: 8000  Name: "8000-12000"} 
+                                                              Ranges: { Value: 12000 Name: "12000-16000"} 
+                                                              Ranges: { Value: 16000 Name: "16000-Inf"} 
+                                                          }]; 
+ 
+    COUNTER_LOCKS_LIFETIME = 8                            [(CounterOpts) = {Name: "LocksLifetime"}]; 
 
     COUNTER_PROPOSE_QUEUE_LATENCY = 9                     [(CounterOpts) = {Name: "ProposeQueueLatency"}];
 
diff --git a/ydb/core/protos/flat_scheme_op.proto b/ydb/core/protos/flat_scheme_op.proto
index 33e598c1c2..bb09448d6e 100644
--- a/ydb/core/protos/flat_scheme_op.proto
+++ b/ydb/core/protos/flat_scheme_op.proto
@@ -1307,7 +1307,7 @@ message TDescribePath {
     optional TDescribeOptions Options = 7;
 }
 
-// Must be sync with Ydb::EntryType
+// Must be sync with Ydb::EntryType 
 enum EPathType {
     EPathTypeInvalid = 0;
     EPathTypeDir = 1;
diff --git a/ydb/core/protos/issue_id.proto b/ydb/core/protos/issue_id.proto
index 1c82c0d95e..f878691a57 100644
--- a/ydb/core/protos/issue_id.proto
+++ b/ydb/core/protos/issue_id.proto
@@ -22,7 +22,7 @@ message TIssuesIds {
         GENERIC_DATASHARD_ERROR = 200300;
 
         GENERIC_RESOLVE_ERROR = 200400;
-        RESOLVE_LOOKUP_ERROR = 200401;
+        RESOLVE_LOOKUP_ERROR = 200401; 
 
         GENERIC_TXPROXY_ERROR = 200500;
         KEY_PARSE_ERROR = 200501;
@@ -33,7 +33,7 @@ message TIssuesIds {
         TX_STATE_UNKNOWN = 200506;
         TX_DECLINED_BY_COORDINATOR = 200507;
         TX_DECLINED_IMPLICIT_COORDINATOR = 200508;
-        SHARD_PROGRAM_SIZE_EXCEEDED = 200509;
+        SHARD_PROGRAM_SIZE_EXCEEDED = 200509; 
 
         SCOPE_REQPROXY = 200600;
 
diff --git a/ydb/core/protos/kesus.proto b/ydb/core/protos/kesus.proto
index 7c03a3ccd9..0106c71041 100644
--- a/ydb/core/protos/kesus.proto
+++ b/ydb/core/protos/kesus.proto
@@ -11,7 +11,7 @@ import "ydb/public/api/protos/ydb_status_codes.proto";
 import "ydb/public/api/protos/ydb_issue_message.proto";
 
 message TKesusError {
-    Ydb.StatusIds.StatusCode Status = 1;
+    Ydb.StatusIds.StatusCode Status = 1; 
     repeated Ydb.Issue.IssueMessage Issues = 2;
 }
 
diff --git a/ydb/core/protos/kqp.proto b/ydb/core/protos/kqp.proto
index 9b46b720e1..ead010f900 100644
--- a/ydb/core/protos/kqp.proto
+++ b/ydb/core/protos/kqp.proto
@@ -1,7 +1,7 @@
-package NKikimrKqp;
-option java_package = "ru.yandex.kikimr.proto";
+package NKikimrKqp; 
+option java_package = "ru.yandex.kikimr.proto"; 
 option cc_enable_arenas = true;
-
+ 
 import "library/cpp/actors/protos/actors.proto";
 import "ydb/core/protos/kqp_physical.proto";
 import "ydb/core/protos/kqp_stats.proto";
@@ -15,85 +15,85 @@ import "ydb/library/mkql_proto/protos/minikql.proto";
 import "ydb/library/yql/dq/actors/protos/dq_events.proto";
 import "ydb/library/yql/dq/actors/protos/dq_stats.proto";
 import "ydb/library/yql/dq/proto/dq_tasks.proto";
-
-enum ERequestType {
-    REQUEST_TYPE_PROCESS_QUERY = 1;
-    REQUEST_TYPE_CLOSE_SESSION = 2;
-    REQUEST_TYPE_CREATE_SESSION = 3;
-};
-
-enum EQueryType {
-    QUERY_TYPE_UNDEFINED = 0;
-
+ 
+enum ERequestType { 
+    REQUEST_TYPE_PROCESS_QUERY = 1; 
+    REQUEST_TYPE_CLOSE_SESSION = 2; 
+    REQUEST_TYPE_CREATE_SESSION = 3; 
+}; 
+ 
+enum EQueryType { 
+    QUERY_TYPE_UNDEFINED = 0; 
+ 
     reserved 1, 2, 3;
-
-    QUERY_TYPE_SQL_DML = 4;
-    QUERY_TYPE_SQL_DDL = 5;
-    QUERY_TYPE_PREPARED_DML = 6;
-    QUERY_TYPE_AST_DML = 7;
-    QUERY_TYPE_SQL_SCRIPT = 8;
-    QUERY_TYPE_SQL_SCAN = 9;
-    QUERY_TYPE_AST_SCAN = 10;
+ 
+    QUERY_TYPE_SQL_DML = 4; 
+    QUERY_TYPE_SQL_DDL = 5; 
+    QUERY_TYPE_PREPARED_DML = 6; 
+    QUERY_TYPE_AST_DML = 7; 
+    QUERY_TYPE_SQL_SCRIPT = 8; 
+    QUERY_TYPE_SQL_SCAN = 9; 
+    QUERY_TYPE_AST_SCAN = 10; 
     QUERY_TYPE_SQL_SCRIPT_STREAMING = 11;
-};
-
-enum EQueryAction {
-    QUERY_ACTION_EXECUTE = 1;
-    QUERY_ACTION_EXPLAIN = 2;
-    QUERY_ACTION_VALIDATE = 3;
-    QUERY_ACTION_PREPARE = 4;
-    QUERY_ACTION_EXECUTE_PREPARED = 5;
-    QUERY_ACTION_BEGIN_TX = 6;
-    QUERY_ACTION_COMMIT_TX = 7;
-    QUERY_ACTION_ROLLBACK_TX = 8;
+}; 
+ 
+enum EQueryAction { 
+    QUERY_ACTION_EXECUTE = 1; 
+    QUERY_ACTION_EXPLAIN = 2; 
+    QUERY_ACTION_VALIDATE = 3; 
+    QUERY_ACTION_PREPARE = 4; 
+    QUERY_ACTION_EXECUTE_PREPARED = 5; 
+    QUERY_ACTION_BEGIN_TX = 6; 
+    QUERY_ACTION_COMMIT_TX = 7; 
+    QUERY_ACTION_ROLLBACK_TX = 8; 
     QUERY_ACTION_PARSE = 9;
-};
-
-enum EIsolationLevel {
-    ISOLATION_LEVEL_UNDEFINED = 0;
-    ISOLATION_LEVEL_SERIALIZABLE = 1;
-    ISOLATION_LEVEL_READ_COMMITTED = 2;
-    ISOLATION_LEVEL_READ_UNCOMMITTED = 3;
-    ISOLATION_LEVEL_READ_STALE = 4;
-};
-
-enum EQueryReplyFlags {
-    QUERY_REPLY_FLAG_RESULTS = 1;
-    QUERY_REPLY_FLAG_PLAN = 2;
-    QUERY_REPLY_FLAG_AST = 4;
-};
-
-message TKqlSettings {
-    optional bool CommitTx = 1;
-    optional bool RollbackTx = 2;
-    optional bool RawResults = 3;
-    optional EIsolationLevel IsolationLevel = 5;
-    optional bool NewEngine = 6;
-};
-
-message TQueryRequest {
-    optional bytes SessionId = 1;
-    optional string Query = 2;
-    optional EQueryType Type = 3;
-    optional TKqlSettings KqlSettings = 4;
-    optional bool KeepSession = 5;
-    optional bytes Cluster = 6;
-    optional NKikimrMiniKQL.TParams Parameters = 7;
+}; 
+ 
+enum EIsolationLevel { 
+    ISOLATION_LEVEL_UNDEFINED = 0; 
+    ISOLATION_LEVEL_SERIALIZABLE = 1; 
+    ISOLATION_LEVEL_READ_COMMITTED = 2; 
+    ISOLATION_LEVEL_READ_UNCOMMITTED = 3; 
+    ISOLATION_LEVEL_READ_STALE = 4; 
+}; 
+ 
+enum EQueryReplyFlags { 
+    QUERY_REPLY_FLAG_RESULTS = 1; 
+    QUERY_REPLY_FLAG_PLAN = 2; 
+    QUERY_REPLY_FLAG_AST = 4; 
+}; 
+ 
+message TKqlSettings { 
+    optional bool CommitTx = 1; 
+    optional bool RollbackTx = 2; 
+    optional bool RawResults = 3; 
+    optional EIsolationLevel IsolationLevel = 5; 
+    optional bool NewEngine = 6; 
+}; 
+ 
+message TQueryRequest { 
+    optional bytes SessionId = 1; 
+    optional string Query = 2; 
+    optional EQueryType Type = 3; 
+    optional TKqlSettings KqlSettings = 4; 
+    optional bool KeepSession = 5; 
+    optional bytes Cluster = 6; 
+    optional NKikimrMiniKQL.TParams Parameters = 7; 
     reserved 8; // (deprecated) SqlAutoCommit
-    optional EQueryAction Action = 9;
-    optional bool Profile = 10; // DEPRECATED, use StatsMode instead
-    optional bytes PreparedQuery = 11;
-    optional uint32 ReplyFlags = 12 [default = 1];
+    optional EQueryAction Action = 9; 
+    optional bool Profile = 10; // DEPRECATED, use StatsMode instead 
+    optional bytes PreparedQuery = 11; 
+    optional uint32 ReplyFlags = 12 [default = 1]; 
     optional Ydb.Table.TransactionControl TxControl = 13;
-    optional string Database = 14;
-    optional Ydb.Table.QueryCachePolicy QueryCachePolicy = 15;
-    optional uint64 CancelAfterMs = 16;
-    optional uint64 TimeoutMs = 17;
-    optional Ydb.YqlInternal.ExecQuerySettings QuerySettings = 18;
-    reserved 19; // (deprecated) StatsMode
+    optional string Database = 14; 
+    optional Ydb.Table.QueryCachePolicy QueryCachePolicy = 15; 
+    optional uint64 CancelAfterMs = 16; 
+    optional uint64 TimeoutMs = 17; 
+    optional Ydb.YqlInternal.ExecQuerySettings QuerySettings = 18; 
+    reserved 19; // (deprecated) StatsMode 
     optional NYql.NDqProto.EDqStatsMode StatsMode = 20;
-}
-
+} 
+ 
 message TKqpPathIdProto {
     optional uint32 OwnerId = 1;
     optional uint32 TableId = 2;
@@ -144,245 +144,245 @@ message TRlPath {
     optional string ResourcePath = 2;
 }
 
-message TEvQueryRequest {
-    optional TQueryRequest Request = 1;
-    optional string TraceId = 2;
-    optional string UserToken = 3;
+message TEvQueryRequest { 
+    optional TQueryRequest Request = 1; 
+    optional string TraceId = 2; 
+    optional string UserToken = 3; 
     optional NActorsProto.TActorId RequestActorId = 4;
-    optional string RequestType = 5;
+    optional string RequestType = 5; 
     optional TRlPath RlPath = 6;
-}
-
-message TMkqlProfile {
-    optional string Query = 1;
+} 
+ 
+message TMkqlProfile { 
+    optional string Query = 1; 
     optional NKikimrQueryStats.TTxStats TxStats = 2;
-};
-
-message TTransformProfile {
-    optional string Name = 1;
-    optional uint64 TransformDurationUs = 2;
-    optional uint64 WaitDurationUs = 3;
-    optional int32 NewExprNodes = 4;
-    optional int32 NewTypeNodes = 5;
-    optional uint32 Repeats = 6;
-    optional uint32 Restarts = 7;
-
-    repeated TTransformProfile Stages = 100;
-}
-
-
-message TKqlProfile {
-    optional string Query = 1;
-    repeated TMkqlProfile MkqlProfiles = 2;
-    optional EIsolationLevel EffectiveIsolationLevel = 3;
-    optional TTransformProfile TransformStats = 4;
-}
-
-message TQueryProfile {
-    repeated TKqlProfile KqlProfiles = 1;
-    optional TTransformProfile TransformStats = 2;
-};
-
-message TParameterBinding {
-    optional string Name = 1;
-    optional uint32 MkqlIndex = 2;
-    optional uint32 ResultIndex = 3;
-}
-
-message TPreparedMkql {
-    optional string Program = 1;
-    repeated TParameterBinding Bindings = 2;
-    optional string ProgramText = 3;
-    optional bool IsPure = 4;
-};
-
-message TPreparedEffect {
-    optional string NodeAst = 1;
-    repeated TParameterBinding Bindings = 2;
-}
-
-message TPreparedKql {
-    optional TKqlSettings Settings = 1;
-    repeated TPreparedMkql Mkqls = 2;
-    repeated TPreparedEffect Effects = 3;
-    repeated NKqpProto.TKqpTableOp Operations = 4;
-    repeated NKqpProto.TKqpTableInfo TableInfo = 5;
-    optional string Ast = 6;
-    optional string Plan = 7;
-};
-
-message TPreparedResult {
-    optional uint32 KqlIndex = 1;
-    optional uint32 ResultIndex = 2;
-    repeated string ColumnHints = 3;
-    optional uint64 RowsLimit = 4;
-};
-
-message TParameterDescription {
-    optional string Name = 1;
-    optional NKikimrMiniKQL.TType Type = 2;
-}
-
-message TPreparedQuery {
-    enum EVersion {
-        VERSION_UNSPECIFIED = 0;
-        VERSION_V1 = 1;
-        VERSION_PHYSICAL_V1 = 11;
-    };
-
-    optional uint32 Version = 1;
-    repeated TPreparedKql Kqls = 2;
-    repeated TPreparedResult Results = 3;
-    repeated TParameterDescription Parameters = 4;
-    optional string Text = 5;
-    optional NKqpProto.TKqpPhyQuery PhysicalQuery = 6;
-};
-
-message TQueryResponse {
-    optional bytes SessionId = 1;
-    reserved 2; // (deprecated) QueryErrors
-    repeated NKikimrMiniKQL.TResult Results = 3;
-    optional TQueryProfile Profile = 4; // TODO: Deprecate, use QueryStats
-    optional bytes PreparedQuery = 5;
-    optional string QueryAst = 6;
-    reserved 7;
+}; 
+ 
+message TTransformProfile { 
+    optional string Name = 1; 
+    optional uint64 TransformDurationUs = 2; 
+    optional uint64 WaitDurationUs = 3; 
+    optional int32 NewExprNodes = 4; 
+    optional int32 NewTypeNodes = 5; 
+    optional uint32 Repeats = 6; 
+    optional uint32 Restarts = 7; 
+ 
+    repeated TTransformProfile Stages = 100; 
+} 
+ 
+
+message TKqlProfile { 
+    optional string Query = 1; 
+    repeated TMkqlProfile MkqlProfiles = 2; 
+    optional EIsolationLevel EffectiveIsolationLevel = 3; 
+    optional TTransformProfile TransformStats = 4; 
+} 
+ 
+message TQueryProfile { 
+    repeated TKqlProfile KqlProfiles = 1; 
+    optional TTransformProfile TransformStats = 2; 
+}; 
+ 
+message TParameterBinding { 
+    optional string Name = 1; 
+    optional uint32 MkqlIndex = 2; 
+    optional uint32 ResultIndex = 3; 
+} 
+ 
+message TPreparedMkql { 
+    optional string Program = 1; 
+    repeated TParameterBinding Bindings = 2; 
+    optional string ProgramText = 3; 
+    optional bool IsPure = 4; 
+}; 
+ 
+message TPreparedEffect { 
+    optional string NodeAst = 1; 
+    repeated TParameterBinding Bindings = 2; 
+} 
+ 
+message TPreparedKql { 
+    optional TKqlSettings Settings = 1; 
+    repeated TPreparedMkql Mkqls = 2; 
+    repeated TPreparedEffect Effects = 3; 
+    repeated NKqpProto.TKqpTableOp Operations = 4; 
+    repeated NKqpProto.TKqpTableInfo TableInfo = 5; 
+    optional string Ast = 6; 
+    optional string Plan = 7; 
+}; 
+ 
+message TPreparedResult { 
+    optional uint32 KqlIndex = 1; 
+    optional uint32 ResultIndex = 2; 
+    repeated string ColumnHints = 3; 
+    optional uint64 RowsLimit = 4; 
+}; 
+ 
+message TParameterDescription { 
+    optional string Name = 1; 
+    optional NKikimrMiniKQL.TType Type = 2; 
+} 
+ 
+message TPreparedQuery { 
+    enum EVersion { 
+        VERSION_UNSPECIFIED = 0; 
+        VERSION_V1 = 1; 
+        VERSION_PHYSICAL_V1 = 11; 
+    }; 
+ 
+    optional uint32 Version = 1; 
+    repeated TPreparedKql Kqls = 2; 
+    repeated TPreparedResult Results = 3; 
+    repeated TParameterDescription Parameters = 4; 
+    optional string Text = 5; 
+    optional NKqpProto.TKqpPhyQuery PhysicalQuery = 6; 
+}; 
+ 
+message TQueryResponse { 
+    optional bytes SessionId = 1; 
+    reserved 2; // (deprecated) QueryErrors 
+    repeated NKikimrMiniKQL.TResult Results = 3; 
+    optional TQueryProfile Profile = 4; // TODO: Deprecate, use QueryStats 
+    optional bytes PreparedQuery = 5; 
+    optional string QueryAst = 6; 
+    reserved 7; 
     repeated Ydb.Issue.IssueMessage QueryIssues = 8;
-    optional bytes QueryPlan = 9;
-    repeated TParameterDescription QueryParameters = 10;
+    optional bytes QueryPlan = 9; 
+    repeated TParameterDescription QueryParameters = 10; 
     optional Ydb.Table.TransactionMeta TxMeta = 11;
-    optional NKqpProto.TKqpStatsQuery QueryStats = 12;
-}
-
-message TEvQueryResponse {
-    reserved 1; // (deprecated) KqpStatus
-    reserved 2; // (deprecated) KqpError
-    optional TQueryResponse Response = 3;
-    optional Ydb.StatusIds.StatusCode YdbStatus = 4;
+    optional NKqpProto.TKqpStatsQuery QueryStats = 12; 
+} 
+ 
+message TEvQueryResponse { 
+    reserved 1; // (deprecated) KqpStatus 
+    reserved 2; // (deprecated) KqpError 
+    optional TQueryResponse Response = 3; 
+    optional Ydb.StatusIds.StatusCode YdbStatus = 4; 
     reserved 5; // (deprecated) ForcedNewEngine
     optional uint64 ConsumedRu = 6;
     optional bool WorkerIsClosing = 7 [default = false];
-}
-
-message TCloseSessionRequest {
-    optional bytes SessionId = 1;
-}
-
-message TEvCloseSessionRequest {
-    optional TCloseSessionRequest Request = 1;
-    optional string TraceId = 2;
-}
-
-message TCloseSessionResponse {
-    optional bytes SessionId = 1;
-    optional bool Closed = 2;
-}
-
-message TEvCloseSessionResponse {
-    optional Ydb.StatusIds.StatusCode Status = 1;
-    repeated Ydb.Issue.IssueMessage Issues = 2;
-    optional TCloseSessionResponse Response = 3;
-}
-
-message TEvProcessResponse {
-    reserved 1; // (deprecated) KqpStatus
-    optional bytes Error = 2;
-    optional Ydb.StatusIds.StatusCode YdbStatus = 3;
+} 
+ 
+message TCloseSessionRequest { 
+    optional bytes SessionId = 1; 
+} 
+ 
+message TEvCloseSessionRequest { 
+    optional TCloseSessionRequest Request = 1; 
+    optional string TraceId = 2; 
+} 
+ 
+message TCloseSessionResponse { 
+    optional bytes SessionId = 1; 
+    optional bool Closed = 2; 
+} 
+ 
+message TEvCloseSessionResponse { 
+    optional Ydb.StatusIds.StatusCode Status = 1; 
+    repeated Ydb.Issue.IssueMessage Issues = 2; 
+    optional TCloseSessionResponse Response = 3; 
+} 
+ 
+message TEvProcessResponse { 
+    reserved 1; // (deprecated) KqpStatus 
+    optional bytes Error = 2; 
+    optional Ydb.StatusIds.StatusCode YdbStatus = 3; 
     optional bool WorkerIsClosing = 4 [default = false];
-}
-
-message TKqpSetting {
-    required string Name = 1;
-    required string Value = 2;
-}
-
-message TKqpDefaultSettings {
-    repeated TKqpSetting DefaultSettings = 1;
-}
-
-message TCreateSessionRequest {
-    optional string Database = 1;
-}
-
-message TEvCreateSessionRequest {
-    optional TCreateSessionRequest Request = 1;
-    optional string TraceId = 2;
+} 
+ 
+message TKqpSetting { 
+    required string Name = 1; 
+    required string Value = 2; 
+} 
+ 
+message TKqpDefaultSettings { 
+    repeated TKqpSetting DefaultSettings = 1; 
+}
+ 
+message TCreateSessionRequest { 
+    optional string Database = 1; 
+} 
+ 
+message TEvCreateSessionRequest { 
+    optional TCreateSessionRequest Request = 1; 
+    optional string TraceId = 2; 
     optional uint64 DeadlineUs = 3;
-}
-
-message TCreateSessionResponse {
-    optional bytes SessionId = 1;
-}
-
-message TEvCreateSessionResponse {
-    reserved 1; // (deprecated) KqpStatus
-    optional bytes Error = 2;
-    optional TCreateSessionResponse Response = 3;
-    optional Ydb.StatusIds.StatusCode YdbStatus = 4;
+} 
+ 
+message TCreateSessionResponse { 
+    optional bytes SessionId = 1; 
+} 
+ 
+message TEvCreateSessionResponse { 
+    reserved 1; // (deprecated) KqpStatus 
+    optional bytes Error = 2; 
+    optional TCreateSessionResponse Response = 3; 
+    optional Ydb.StatusIds.StatusCode YdbStatus = 4; 
     optional bool ResourceExhausted = 5 [default = false];
-}
-
-message TPingSessionRequest {
-    optional bytes SessionId = 1;
+} 
+ 
+message TPingSessionRequest { 
+    optional bytes SessionId = 1; 
     optional uint32 TimeoutMs = 2 [default = 5000];
-}
-
-message TEvPingSessionRequest {
-    optional TPingSessionRequest Request = 1;
-    optional string TraceId = 2;
-}
-
-message TPingSessionResponse {
-    optional Ydb.Table.KeepAliveResult.SessionStatus SessionStatus = 1;
+} 
+ 
+message TEvPingSessionRequest { 
+    optional TPingSessionRequest Request = 1; 
+    optional string TraceId = 2; 
+} 
+ 
+message TPingSessionResponse { 
+    optional Ydb.Table.KeepAliveResult.SessionStatus SessionStatus = 1; 
     optional bool WorkerIsClosing = 2 [default = false];
-}
-
-message TEvPingSessionResponse {
-    optional Ydb.StatusIds.StatusCode Status = 1;
-    repeated Ydb.Issue.IssueMessage Issues = 2;
-    optional TPingSessionResponse Response = 3;
+} 
+ 
+message TEvPingSessionResponse { 
+    optional Ydb.StatusIds.StatusCode Status = 1; 
+    repeated Ydb.Issue.IssueMessage Issues = 2; 
+    optional TPingSessionResponse Response = 3; 
     optional bool WorkerIsClosing = 4 [default = false];
-}
-
+} 
+ 
 message TEvDataQueryStreamPart {
     optional NActorsProto.TActorId GatewayActorId = 1;
     repeated NKikimrMiniKQL.TResult Results = 2;
 };
 
-// Executer
-
-message TExecuterTxRequest {
-    optional uint64 TxId = 1;
-};
-
-message TEvExecuterTxRequest {
-    optional TExecuterTxRequest Request = 1;
+// Executer 
+ 
+message TExecuterTxRequest { 
+    optional uint64 TxId = 1; 
+}; 
+ 
+message TEvExecuterTxRequest { 
+    optional TExecuterTxRequest Request = 1; 
     optional NActorsProto.TActorId Target = 2;
-    optional string TraceId = 3;
-    optional string UserToken = 4;
-};
-
-message TExecuterTxResult {
-    repeated NKikimrMiniKQL.TResult Results = 3;
-    optional NKikimrMiniKQL.TResult Locks = 4;
-    reserved 5; // (deprecated) Stats
+    optional string TraceId = 3; 
+    optional string UserToken = 4; 
+}; 
+ 
+message TExecuterTxResult { 
+    repeated NKikimrMiniKQL.TResult Results = 3; 
+    optional NKikimrMiniKQL.TResult Locks = 4; 
+    reserved 5; // (deprecated) Stats 
     optional NYql.NDqProto.TDqExecutionStats Stats = 6;
-};
-
-message TExecuterTxResponse {
-    optional Ydb.StatusIds.StatusCode Status = 1;
+}; 
+ 
+message TExecuterTxResponse { 
+    optional Ydb.StatusIds.StatusCode Status = 1; 
     repeated Ydb.Issue.IssueMessage Issues = 2;
-    optional TExecuterTxResult Result = 3;
-};
-
-message TEvExecuterTxResponse {
-    optional TExecuterTxResponse Response = 1;
-};
-
-message TEvExecuterStreamData {
-    optional Ydb.ResultSet ResultSet = 1;
+    optional TExecuterTxResult Result = 3; 
+}; 
+ 
+message TEvExecuterTxResponse { 
+    optional TExecuterTxResponse Response = 1; 
+}; 
+ 
+message TEvExecuterStreamData { 
+    optional Ydb.ResultSet ResultSet = 1; 
     optional uint64 SeqNo = 2;
-};
-
+}; 
+ 
 message TEvExecuterStreamDataAck {
     optional uint64 SeqNo = 1;
     optional int64 FreeSpace = 2;
@@ -390,7 +390,7 @@ message TEvExecuterStreamDataAck {
 };
 
 message TEvExecuterStreamProfile {
-    reserved 1; // (deprecated) Profile
+    reserved 1; // (deprecated) Profile 
     optional NYql.NDqProto.TDqExecutionStats Profile = 2;
 };
 
@@ -416,7 +416,7 @@ message TKqpSnapshot {
 message TEvStartComputeTasks {
     optional uint64 TxId = 1;
     repeated NYql.NDqProto.TDqTask Tasks = 2;
-    reserved 3; // (deprecated) WaitResourcesTimeoutMs
+    reserved 3; // (deprecated) WaitResourcesTimeoutMs 
     optional NYql.NDqProto.TComputeRuntimeSettings RuntimeSettings = 4;
     optional NActorsProto.TActorId ExecuterActorId = 5; // overwrite for ev->Sender
 
diff --git a/ydb/core/protos/kqp_physical.proto b/ydb/core/protos/kqp_physical.proto
index 44d8f58716..03b2359cac 100644
--- a/ydb/core/protos/kqp_physical.proto
+++ b/ydb/core/protos/kqp_physical.proto
@@ -1,15 +1,15 @@
-syntax = "proto3";
-option cc_enable_arenas = true;
-
-package NKqpProto;
-option java_package = "ru.yandex.kikimr.proto";
-
+syntax = "proto3"; 
+option cc_enable_arenas = true; 
+ 
+package NKqpProto; 
+option java_package = "ru.yandex.kikimr.proto"; 
+ 
 import "ydb/library/mkql_proto/protos/minikql.proto";
 import "ydb/library/yql/dq/proto/dq_tasks.proto";
-
-message TKqpPhyExternalBinding {
-}
-
+ 
+message TKqpPhyExternalBinding { 
+} 
+ 
 message TKqpPhyInternalBinding {
     enum EType {
         PARAM_UNSPECIFIED = 0;
@@ -25,49 +25,49 @@ message TKqpPhyInternalBinding {
     EType Type = 1;
 }
 
-message TKqpPhyTxResultBinding {
-    uint32 TxIndex = 1;
-    uint32 ResultIndex = 2;
-}
-
-message TKqpPhyParamBinding {
-    string Name = 1;
-
-    oneof Type {
-        TKqpPhyExternalBinding ExternalBinding = 2;
-        TKqpPhyTxResultBinding TxResultBinding = 3;
+message TKqpPhyTxResultBinding { 
+    uint32 TxIndex = 1; 
+    uint32 ResultIndex = 2; 
+} 
+ 
+message TKqpPhyParamBinding { 
+    string Name = 1; 
+ 
+    oneof Type { 
+        TKqpPhyExternalBinding ExternalBinding = 2; 
+        TKqpPhyTxResultBinding TxResultBinding = 3; 
         TKqpPhyInternalBinding InternalBinding = 4;
-    }
-}
-
-message TKqpPhyResultBinding {
-    oneof Type {
-        TKqpPhyTxResultBinding TxResultBinding = 1;
-    }
-}
-
-message TKqpPhyColumn {
-    uint32 Id = 1;
-    string Name = 2;
-}
-
-message TKqpPhyTable {
-    string Path = 1;
-    uint64 OwnerId = 2;
-    uint64 TableId = 3;
-    string SysView = 4;
-    uint64 Version = 5;
-}
-
-message TKqpPhyParamValue {
-    string ParamName = 1;
-}
-
-message TKqpPhyParamElementValue {
-    string ParamName = 1;
-    uint32 ElementIndex = 2;
-}
-
+    } 
+} 
+ 
+message TKqpPhyResultBinding { 
+    oneof Type { 
+        TKqpPhyTxResultBinding TxResultBinding = 1; 
+    } 
+} 
+ 
+message TKqpPhyColumn { 
+    uint32 Id = 1; 
+    string Name = 2; 
+} 
+ 
+message TKqpPhyTable { 
+    string Path = 1; 
+    uint64 OwnerId = 2; 
+    uint64 TableId = 3; 
+    string SysView = 4; 
+    uint64 Version = 5; 
+} 
+ 
+message TKqpPhyParamValue { 
+    string ParamName = 1; 
+} 
+ 
+message TKqpPhyParamElementValue { 
+    string ParamName = 1; 
+    uint32 ElementIndex = 2; 
+} 
+ 
 message TKqpPhyLiteralValue {
     NKikimrMiniKQL.TType Type = 1;
     NKikimrMiniKQL.TValue Value = 2;
@@ -88,53 +88,53 @@ message TKqpPhyRowsList {
     repeated TRow Rows = 1;
 }
 
-message TKqpPhyValue {
-    oneof Kind {
+message TKqpPhyValue { 
+    oneof Kind { 
         TKqpPhyParamValue ParamValue = 1;               // any type here (value, list of structs, ...)
         TKqpPhyParamElementValue ParamElementValue = 2; // any type here (value, list of structs, ...)
         TKqpPhyRowsList RowsList = 3;                   // list of structs
         TKqpPhyLiteralValue LiteralValue = 4;          // value
-    }
-}
-
-message TKqpPhyKeyBound {
-    repeated TKqpPhyValue Values = 1;
-    bool IsInclusive = 2;
-}
-
-message TKqpPhyKeyRange {
-    TKqpPhyKeyBound From = 1;
-    TKqpPhyKeyBound To = 2;
-}
-
-message TKqpPhyOpReadRange {
-    TKqpPhyKeyRange KeyRange = 1;
+    } 
+} 
+ 
+message TKqpPhyKeyBound { 
+    repeated TKqpPhyValue Values = 1; 
+    bool IsInclusive = 2; 
+} 
+ 
+message TKqpPhyKeyRange { 
+    TKqpPhyKeyBound From = 1; 
+    TKqpPhyKeyBound To = 2; 
+} 
+ 
+message TKqpPhyOpReadRange { 
+    TKqpPhyKeyRange KeyRange = 1; 
     TKqpPhyParamValue ItemsLimit = 2;
     bool Reverse = 3;
     repeated bool SkipNullKeys = 4;
-}
-
-message TKqpPhyOpUpsertRows {
-    TKqpPhyValue RowsValue = 1;
-}
-
+} 
+ 
+message TKqpPhyOpUpsertRows { 
+    TKqpPhyValue RowsValue = 1; 
+} 
+ 
 message TKqpPhyOpDeleteRows {
     TKqpPhyValue RowsValue = 1;
 }
 
-message TKqpPhyOpLookup {
-    TKqpPhyValue KeysValue = 1;
-}
-
+message TKqpPhyOpLookup { 
+    TKqpPhyValue KeysValue = 1; 
+} 
+ 
 message TKqpPhyOpReadOlapRanges {
     // Parameter come here from computation stage. It has type Tuple(List(Tuple(RangeBegin, RangeEnd))))
     // Where RangeBegin and RangeEnd are Tuple(KeyColumns, Inclusive)
     // Where KeyColumns is values of start/end of range for corresponding key column in table
     TKqpPhyParamValue KeyRanges = 1;
     // Limit value, shard may stop after reading limit rows
-    TKqpPhyParamValue ItemsLimit = 2;
+    TKqpPhyParamValue ItemsLimit = 2; 
     // Reverse sign, i.e. if user ask ORDER BY ... DESC we need to read table in reverse direction
-    bool Reverse = 3;
+    bool Reverse = 3; 
     // Program in NKikimrSSA.TProgram format
     bytes OlapProgram = 4;
     /*
@@ -143,8 +143,8 @@ message TKqpPhyOpReadOlapRanges {
      * it is done a bit later in executor, so we need separate field for parameter names.
      */
     repeated string OlapProgramParameterNames = 5;
-}
-
+} 
+ 
 message TKqpPhyOpReadRanges {
     // Parameter come here from computation stage. It has type Tuple(List(Tuple(RangeBegin, RangeEnd))))
     // Where RangeBegin and RangeEnd are Tuple(KeyColumns, Inclusive)
@@ -157,45 +157,45 @@ message TKqpPhyOpReadRanges {
     bool Reverse = 3;
 }
 
-message TKqpPhyTableOperation {
-    TKqpPhyTable Table = 1;
-    repeated TKqpPhyColumn Columns = 2;
-
-    oneof Type {
-        TKqpPhyOpReadRange ReadRange = 3;
-        TKqpPhyOpUpsertRows UpsertRows = 4;
+message TKqpPhyTableOperation { 
+    TKqpPhyTable Table = 1; 
+    repeated TKqpPhyColumn Columns = 2; 
+ 
+    oneof Type { 
+        TKqpPhyOpReadRange ReadRange = 3; 
+        TKqpPhyOpUpsertRows UpsertRows = 4; 
         TKqpPhyOpDeleteRows DeleteRows = 5;
-        TKqpPhyOpLookup Lookup = 6;
+        TKqpPhyOpLookup Lookup = 6; 
         TKqpPhyOpReadOlapRanges ReadOlapRange = 7;
         TKqpPhyOpReadRanges ReadRanges = 8;
-    }
-}
-
-message TKqpPhyCnUnionAll {
-}
-
-message TKqpPhyCnMap {
-}
-
+    } 
+} 
+ 
+message TKqpPhyCnUnionAll { 
+} 
+ 
+message TKqpPhyCnMap { 
+} 
+ 
 message TKqpPhyCnHashShuffle {
-    repeated string KeyColumns = 1;
-}
-
-message TKqpPhyCnBroadcast {
-}
-
-message TKqpPhyCnMapShard {
-}
-
-message TKqpPhyCnShuffleShard {
-}
-
-message TKqpPhyCnResult {
-}
-
-message TKqpPhyCnValue {
-}
-
+    repeated string KeyColumns = 1; 
+} 
+ 
+message TKqpPhyCnBroadcast { 
+} 
+ 
+message TKqpPhyCnMapShard { 
+} 
+ 
+message TKqpPhyCnShuffleShard { 
+} 
+ 
+message TKqpPhyCnResult { 
+} 
+ 
+message TKqpPhyCnValue { 
+} 
+ 
 message TKqpPhySortColumn {
     string Column = 1;
     bool Ascending = 2;
@@ -205,95 +205,95 @@ message TKqpPhyCnMerge {
     repeated TKqpPhySortColumn SortColumns = 1;
 }
 
-message TKqpPhyConnection {
-    uint32 StageIndex = 1;
-    uint32 OutputIndex = 2;
-
-    oneof Type {
-        TKqpPhyCnUnionAll UnionAll = 3;
-        TKqpPhyCnMap Map = 4;
+message TKqpPhyConnection { 
+    uint32 StageIndex = 1; 
+    uint32 OutputIndex = 2; 
+ 
+    oneof Type { 
+        TKqpPhyCnUnionAll UnionAll = 3; 
+        TKqpPhyCnMap Map = 4; 
         TKqpPhyCnHashShuffle HashShuffle = 5;
-        TKqpPhyCnBroadcast Broadcast = 6;
-        TKqpPhyCnMapShard MapShard = 7;
-        TKqpPhyCnShuffleShard ShuffleShard = 8;
-        TKqpPhyCnResult Result = 9;
-        TKqpPhyCnValue Value = 10;
+        TKqpPhyCnBroadcast Broadcast = 6; 
+        TKqpPhyCnMapShard MapShard = 7; 
+        TKqpPhyCnShuffleShard ShuffleShard = 8; 
+        TKqpPhyCnResult Result = 9; 
+        TKqpPhyCnValue Value = 10; 
         TKqpPhyCnMerge Merge = 11;
-    };
-}
-
-message TKqpPhyStage {
-    NYql.NDqProto.TProgram Program = 1;
-    repeated string ProgramParameters = 2;
-    string ProgramAst = 3;
-    repeated TKqpPhyConnection Inputs = 4;
-    uint32 OutputsCount = 5;
-    repeated TKqpPhyTableOperation TableOps = 6;
-    bool IsEffectsStage = 7;
+    }; 
+} 
+ 
+message TKqpPhyStage { 
+    NYql.NDqProto.TProgram Program = 1; 
+    repeated string ProgramParameters = 2; 
+    string ProgramAst = 3; 
+    repeated TKqpPhyConnection Inputs = 4; 
+    uint32 OutputsCount = 5; 
+    repeated TKqpPhyTableOperation TableOps = 6; 
+    bool IsEffectsStage = 7; 
     string StageGuid = 8;
-}
-
-message TKqpPhyResult {
-    TKqpPhyConnection Connection = 1;
-    NKikimrMiniKQL.TType ItemType = 2;
-    bool IsStream = 3;
+} 
+ 
+message TKqpPhyResult { 
+    TKqpPhyConnection Connection = 1; 
+    NKikimrMiniKQL.TType ItemType = 2; 
+    bool IsStream = 3; 
     repeated string ColumnHints = 4;
-}
-
-message TKqpPhyTx {
-    enum EType {
-        TYPE_UNSPECIFIED = 0;
-        TYPE_COMPUTE = 1;
-        TYPE_DATA = 2;
-        TYPE_SCAN = 3;
-    };
-
-    EType Type = 1;
-    repeated TKqpPhyStage Stages = 2;
-    repeated TKqpPhyResult Results = 3;
-    repeated TKqpPhyParamBinding ParamBindings = 4;
+} 
+ 
+message TKqpPhyTx { 
+    enum EType { 
+        TYPE_UNSPECIFIED = 0; 
+        TYPE_COMPUTE = 1; 
+        TYPE_DATA = 2; 
+        TYPE_SCAN = 3; 
+    }; 
+ 
+    EType Type = 1; 
+    repeated TKqpPhyStage Stages = 2; 
+    repeated TKqpPhyResult Results = 3; 
+    repeated TKqpPhyParamBinding ParamBindings = 4; 
     string Plan = 5;
     bool HasEffects = 6; // at least one stage has flag TKqpPhyStage::IsEffectStage set
-}
-
-message TKqpTableInfo {
-    message TId {
-        uint64 OwnerId = 1;
-        uint64 TableId = 2;
-    }
-
-    TId TableId = 1;
-    string TableName = 2;
-    uint64 SchemaVersion = 3;
-    bool HasIndexTables = 4;
-}
-
-message TKqpTableOp {
-    message TPosition {
-        uint32 Row = 1;
-        uint32 Column = 2;
-    }
-
-    TPosition Position = 1;
-    string Table = 2;
-    uint32 Operation = 3;
-};
-
-message TKqpPhyQuery {
-    enum EType {
-        TYPE_UNSPECIFIED = 0;
-        TYPE_DATA = 1;
-        TYPE_SCAN = 2;
-    };
-
-    EType Type = 1;
-    repeated TKqpPhyTx Transactions = 2;
-    reserved 3; // Deprecated, (repeated TKqpPhyTx Effects = 3);
-    repeated TKqpPhyResultBinding ResultBindings = 4;
+} 
+ 
+message TKqpTableInfo { 
+    message TId { 
+        uint64 OwnerId = 1; 
+        uint64 TableId = 2; 
+    } 
+ 
+    TId TableId = 1; 
+    string TableName = 2; 
+    uint64 SchemaVersion = 3; 
+    bool HasIndexTables = 4; 
+} 
+ 
+message TKqpTableOp { 
+    message TPosition { 
+        uint32 Row = 1; 
+        uint32 Column = 2; 
+    } 
+ 
+    TPosition Position = 1; 
+    string Table = 2; 
+    uint32 Operation = 3; 
+}; 
+ 
+message TKqpPhyQuery { 
+    enum EType { 
+        TYPE_UNSPECIFIED = 0; 
+        TYPE_DATA = 1; 
+        TYPE_SCAN = 2; 
+    }; 
+ 
+    EType Type = 1; 
+    repeated TKqpPhyTx Transactions = 2; 
+    reserved 3; // Deprecated, (repeated TKqpPhyTx Effects = 3); 
+    repeated TKqpPhyResultBinding ResultBindings = 4; 
     string QueryPlan = 5;
     string QueryAst = 6;
-
-    // StrictDml constraints info
-    repeated TKqpTableOp TableOps = 7;
-    repeated TKqpTableInfo TableInfos = 8;
-}
+ 
+    // StrictDml constraints info 
+    repeated TKqpTableOp TableOps = 7; 
+    repeated TKqpTableInfo TableInfos = 8; 
+} 
diff --git a/ydb/core/protos/kqp_stats.proto b/ydb/core/protos/kqp_stats.proto
index c2579c24ff..6a941af01f 100644
--- a/ydb/core/protos/kqp_stats.proto
+++ b/ydb/core/protos/kqp_stats.proto
@@ -1,17 +1,17 @@
-syntax = "proto3";
-option cc_enable_arenas = true;
-
-package NKqpProto;
-option java_package = "ru.yandex.kikimr.proto";
-
+syntax = "proto3"; 
+option cc_enable_arenas = true; 
+ 
+package NKqpProto; 
+option java_package = "ru.yandex.kikimr.proto"; 
+ 
 import "ydb/library/yql/dq/actors/protos/dq_stats.proto";
-
-message TKqpStatsCompile {
-    bool FromCache = 1;
-    uint64 DurationUs = 2;
-    uint64 CpuTimeUs = 3;
-}
-
+ 
+message TKqpStatsCompile { 
+    bool FromCache = 1; 
+    uint64 DurationUs = 2; 
+    uint64 CpuTimeUs = 3; 
+} 
+ 
 // Per datashard table extra stats
 message TKqpShardTableExtraStats {
     uint64 ShardId = 1;
@@ -58,17 +58,17 @@ message TKqpExecutionExtraStats {
     uint64 ResolveWallTimeUs = 101;
 }
 
-message TKqpStatsQuery {
-    // Basic stats
-    uint64 DurationUs = 1;
-    TKqpStatsCompile Compilation = 2;
+message TKqpStatsQuery { 
+    // Basic stats 
+    uint64 DurationUs = 1; 
+    TKqpStatsCompile Compilation = 2; 
 
     reserved 3; // repeated TKqpStatsExecution Executions = 3;
 
-    uint64 WorkerCpuTimeUs = 4;
+    uint64 WorkerCpuTimeUs = 4; 
     uint64 ReadSetsCount = 5;
     uint64 MaxShardProgramSize = 6;
     uint64 MaxShardReplySize = 7;
 
     repeated NYql.NDqProto.TDqExecutionStats Executions = 8;
-}
+} 
diff --git a/ydb/core/protos/minikql_engine.proto b/ydb/core/protos/minikql_engine.proto
index ca3ea7212b..03b4b28dff 100644
--- a/ydb/core/protos/minikql_engine.proto
+++ b/ydb/core/protos/minikql_engine.proto
@@ -13,7 +13,7 @@ enum EResult {
     SnapshotNotExist = 8;
     SnapshotNotReady = 9;
     TooManyRS = 10;
-    ResultTooBig = 11;
+    ResultTooBig = 11; 
     Cancelled = 12;
 };
 
diff --git a/ydb/core/protos/msgbus.proto b/ydb/core/protos/msgbus.proto
index df7cda5980..3034099428 100644
--- a/ydb/core/protos/msgbus.proto
+++ b/ydb/core/protos/msgbus.proto
@@ -100,7 +100,7 @@ message TResponse {
             {Value: 2 Name: "EmptyAffectedSet" Man: "Program must touch at least one shard but touches none" },
             {Value: 3 Name: "NotImplemented" Man: "Not yet implemented feature requested" },
             {Value: 4 Name: "ResolveError" Man: "Some keys not resolved, see UnresolvedKeys for details" },
-            {Value: 5 Name: "AccessDenied" Man: "Access denied for request" },
+            {Value: 5 Name: "AccessDenied" Man: "Access denied for request" }, 
             {Value: 6 Name: "DomainLocalityError" Man: "Cross database transactions not allowed"},
             {Value: 16 Name: "ProxyNotReady" Man: "Transaction proxy not ready for handling requests, try later. Most known case is temporary lack of txid-s" },
             {Value: 17 Name: "ProxyAccepted" Man: "Request accepted by proxy. Transitional status" },
@@ -120,9 +120,9 @@ message TResponse {
             {Value: 50 Name: "ExecAborted" Man: "Request aborted, particular meaning depends on context" },
             {Value: 51 Name: "ExecTimeout" Man: "Proxy got no execution reply in timeout period" },
             {Value: 52 Name: "ExecError" Man: "Execution failed" },
-            {Value: 53 Name: "ExecInProgress" Man: "Request accepted and now runs" },
-            {Value: 55 Name: "ExecResultUnavailable" Man: "Execution results unavailable" },
-            {Value: 56 Name: "ExecCancelled" Man: "Execution was cancelled" }
+            {Value: 53 Name: "ExecInProgress" Man: "Request accepted and now runs" }, 
+            {Value: 55 Name: "ExecResultUnavailable" Man: "Execution results unavailable" }, 
+            {Value: 56 Name: "ExecCancelled" Man: "Execution was cancelled" } 
         ]}
     ]; // see tx_proxy.h - TResultStatus::EStatus
 
@@ -167,7 +167,7 @@ message TResponse {
 
     optional NKikimrTxUserProxy.TMiniKQLCompileResults MiniKQLCompileResults = 108;
     optional bool HadFollowerReads = 109;
-    optional bytes SerializedReadTableResponse = 110; // Serialized Ydb.Db.TResultSet
+    optional bytes SerializedReadTableResponse = 110; // Serialized Ydb.Db.TResultSet 
 
     optional uint32 BSAssignedID = 40;
 
@@ -497,7 +497,7 @@ message TJSON {
     optional string SecurityToken = 2;
     optional TJsonSettings JsonSettings = 3;
 };
-
+ 
 message TChooseProxyRequest {
     optional uint32 DataCenterNum = 1;
     optional string DataCenter = 3;
diff --git a/ydb/core/protos/query_stats.proto b/ydb/core/protos/query_stats.proto
index 453b303401..d0ed40285b 100644
--- a/ydb/core/protos/query_stats.proto
+++ b/ydb/core/protos/query_stats.proto
@@ -42,7 +42,7 @@ message TPerShardStats {
 message TTxStats {
     repeated TTableAccessStats TableAccessStats = 1;
     optional uint64 DurationUs = 2;
-    optional uint64 ComputeCpuTimeUsec = 3;
+    optional uint64 ComputeCpuTimeUsec = 3; 
     repeated TPerShardStats PerShardStats = 4;
 
     // TODO:
diff --git a/ydb/core/protos/services.proto b/ydb/core/protos/services.proto
index c17c8a7dc3..d723bbd55a 100644
--- a/ydb/core/protos/services.proto
+++ b/ydb/core/protos/services.proto
@@ -105,7 +105,7 @@ enum EServiceKikimr {
 
     // MINIKQL section
     MINIKQL_ENGINE = 340;
-    KQP_TASKS_RUNNER = 341;
+    KQP_TASKS_RUNNER = 341; 
 
     // JOBRUNNER section - deprecated, left for compatibility with existing logger configuration
     JOBRUNNER = 350;
@@ -121,7 +121,7 @@ enum EServiceKikimr {
     KWCALC_PROXY_WORKER = 363; // deprecated, left for compatibility reasons
     YQL_EXECUTION = 364;
     YAMR_PROXY = 365;
-    YQL_KIKIMR_PROXY = 366;
+    YQL_KIKIMR_PROXY = 366; 
 
     // TRIGGER section
     TRIGGER = 370;
@@ -191,7 +191,7 @@ enum EServiceKikimr {
     HEALTH = 500;
 
     MEMORY_PROFILER = 510;
-
+ 
     DATASHARD_BACKUP = 522;
 
     CMS = 523;
@@ -204,22 +204,22 @@ enum EServiceKikimr {
     CMS_CONFIGS = 528;
     CMS_CLUSTER = 529;
 
-    KQP_PROXY = 530;
-    KQP_WORKER = 531;
-    KQP_GATEWAY = 532;
-    KQP_YQL = 533;
-    KQP_EXECUTER = 534;
-    KQP_COMPUTE = 535;
-    KQP_SLOW_LOG = 536;
-    KQP_COMPILE_SERVICE = 537;
-    KQP_COMPILE_ACTOR = 538;
+    KQP_PROXY = 530; 
+    KQP_WORKER = 531; 
+    KQP_GATEWAY = 532; 
+    KQP_YQL = 533; 
+    KQP_EXECUTER = 534; 
+    KQP_COMPUTE = 535; 
+    KQP_SLOW_LOG = 536; 
+    KQP_COMPILE_SERVICE = 537; 
+    KQP_COMPILE_ACTOR = 538; 
     KQP_RESOURCE_MANAGER = 539;
     KQP_BLOBS_STORAGE = 541;
-    KQP_COMPILE_REQUEST = 542;
+    KQP_COMPILE_REQUEST = 542; 
     KQP_NODE = 543;
     KQP_LOAD_TEST = 544;
     KQP_SESSION = 545;
-
+ 
     TABLET_RESOURCE_BROKER = 540;
 
     // KESUS section
@@ -798,11 +798,11 @@ message TActivity {
         SCHEME_BOARD_INFO_REQUESTER_ACTOR = 479;
         METERING_WRITER_ACTOR = 480;
         SEQUENCE_PROXY_SERVICE = 481;
-        KQP_TABLE_SCAN_PROXY = 482;
-        KQP_TABLE_RESOLVER = 483;
-        KQP_RESULT_CHANNEL_PROXY = 484;
-        KQP_SHARDS_RESOLVER = 485;
-        KQP_COMPILE_REQUEST = 486;
+        KQP_TABLE_SCAN_PROXY = 482; 
+        KQP_TABLE_RESOLVER = 483; 
+        KQP_RESULT_CHANNEL_PROXY = 484; 
+        KQP_SHARDS_RESOLVER = 485; 
+        KQP_COMPILE_REQUEST = 486; 
         BS_DEFRAG = 487;
         BS_DEFRAG_QUANTUM = 488;
         KQP_LITERAL_EXECUTER_ACTOR = 489;
diff --git a/ydb/core/protos/sys_view.proto b/ydb/core/protos/sys_view.proto
index cfc0366272..f290fd85f0 100644
--- a/ydb/core/protos/sys_view.proto
+++ b/ydb/core/protos/sys_view.proto
@@ -71,16 +71,16 @@ message TEvGetPartitionStatsResult {
     optional bool Overloaded = 4;
 }
 
-message TQueryDataStats {
-    optional uint64 ReadRows = 1;
-    optional uint64 ReadBytes = 2;
-    optional uint64 UpdateRows = 3;
-    optional uint64 UpdateBytes = 4;
-    optional uint64 DeleteRows = 5;
+message TQueryDataStats { 
+    optional uint64 ReadRows = 1; 
+    optional uint64 ReadBytes = 2; 
+    optional uint64 UpdateRows = 3; 
+    optional uint64 UpdateBytes = 4; 
+    optional uint64 DeleteRows = 5; 
     optional uint64 DeleteBytes = 6; // deprecated
     optional uint64 PartitionCount = 7;
 }
-
+ 
 message TStatsAggr {
     optional uint64 Min = 1;
     optional uint64 Max = 2;
@@ -93,7 +93,7 @@ message TQueryStats {
     optional uint64 QueryTextHash = 2;
     optional uint64 DurationMs = 3;
     optional uint64 EndTimeMs = 4;
-    optional TQueryDataStats Stats = 5;
+    optional TQueryDataStats Stats = 5; 
     optional string UserSID = 6;
     optional uint64 ParametersSize = 7;
     optional uint64 CompileDurationMs = 8;
diff --git a/ydb/core/protos/tx_datashard.proto b/ydb/core/protos/tx_datashard.proto
index 89863b2540..616abfbe5c 100644
--- a/ydb/core/protos/tx_datashard.proto
+++ b/ydb/core/protos/tx_datashard.proto
@@ -113,7 +113,7 @@ message TReadTableTransaction {
 }
 
 message TKqpLocks {
-    repeated TLock Locks = 1;
+    repeated TLock Locks = 1; 
     repeated uint64 SendingShards = 2;   // empty at Erase
     repeated uint64 ReceivingShards = 3; // empty at Erase
 
@@ -124,26 +124,26 @@ message TKqpLocks {
         Erase = 3;
     }
     optional ELocksOp Op = 4;
-}
-
-message TKqpValidateLocksResult {
-    optional bool Success = 1;
-    repeated TLock BrokenLocks = 2;
-};
-
-enum EKqpTransactionType {
-    KQP_TX_TYPE_UNSPECIFIED = 0;
-    KQP_TX_TYPE_DATA = 1;
-    KQP_TX_TYPE_SCAN = 2;
-}
-
+} 
+ 
+message TKqpValidateLocksResult { 
+    optional bool Success = 1; 
+    repeated TLock BrokenLocks = 2; 
+}; 
+ 
+enum EKqpTransactionType { 
+    KQP_TX_TYPE_UNSPECIFIED = 0; 
+    KQP_TX_TYPE_DATA = 1; 
+    KQP_TX_TYPE_SCAN = 2; 
+} 
+ 
 enum EScanDataFormat {
     UNSPECIFIED = 0;
     CELLVEC = 1;
     ARROW = 2;
 }
 
-message TKqpTransaction {
+message TKqpTransaction { 
     message TColumnMeta {
         optional uint32 Id = 1;
         optional string Name = 2;
@@ -215,7 +215,7 @@ message TKqpTransaction {
          optional NKikimrSSA.TOlapProgram OlapProgram = 10; // Currently only for OLAP tables
     }
 
-    optional EKqpTransactionType Type = 1;
+    optional EKqpTransactionType Type = 1; 
     repeated NYql.NDqProto.TDqTask Tasks = 2;
     optional TKqpLocks Locks = 3;
 
@@ -223,23 +223,23 @@ message TKqpTransaction {
     reserved 5;
 
     optional NKikimrKqp.TKqpSnapshot Snapshot = 6;
-}
-
-message TKqpTaskInfo {
-    optional uint64 TaskId = 1;
+} 
+ 
+message TKqpTaskInfo { 
+    optional uint64 TaskId = 1; 
     optional NActorsProto.TActorId ComputeActor = 2;
-}
-
-message TKqpReply {
+} 
+ 
+message TKqpReply { 
     repeated NYql.NDqProto.TChannelData Outputs = 1;
-    repeated TKqpTaskInfo Tasks = 2;
-}
-
-message TKqpReadset {
+    repeated TKqpTaskInfo Tasks = 2; 
+} 
+ 
+message TKqpReadset { 
     repeated NYql.NDqProto.TChannelData Outputs = 1;
-    optional TKqpValidateLocksResult ValidateLocksResult = 2;
-}
-
+    optional TKqpValidateLocksResult ValidateLocksResult = 2; 
+} 
+ 
 message TDataTransaction {
     optional TRWTransaction RWTransaction = 1;  // DEPRECATED
     optional TROTransaction ROTransaction = 2;  // DEPRECATED
@@ -247,16 +247,16 @@ message TDataTransaction {
     optional bool Immediate = 4;
     optional fixed64 LockTxId = 5;
     optional bool NeedDiagnostics = 6;
-    optional bool ReadOnly = 7;
+    optional bool ReadOnly = 7; 
     optional TReadTableTransaction ReadTableTransaction = 8;
     optional bool StreamResponse = 9;
     optional NActorsProto.TActorId Sink = 10;
-    optional bool LlvmRuntime = 11;
-    optional uint64 PerShardKeysSizeLimitBytes = 12;
-    optional TKqpTransaction KqpTransaction = 13;
-    optional uint64 CancelDeadlineMs = 14; // Wallclock timestamp from datareq (not duration)
-    optional uint64 CancelAfterMs = 15; // Duration from tx start local to datashard
-    optional bool CollectStats = 16;
+    optional bool LlvmRuntime = 11; 
+    optional uint64 PerShardKeysSizeLimitBytes = 12; 
+    optional TKqpTransaction KqpTransaction = 13; 
+    optional uint64 CancelDeadlineMs = 14; // Wallclock timestamp from datareq (not duration) 
+    optional uint64 CancelAfterMs = 15; // Duration from tx start local to datashard 
+    optional bool CollectStats = 16; 
 }
 
 message TCreateVolatileSnapshot {
@@ -505,9 +505,9 @@ message TError {
         OUT_OF_SPACE = 14;
         READ_SIZE_EXECEEDED = 15;
         SHARD_IS_BLOCKED = 16;
-        UNKNOWN = 17;
-        REPLY_SIZE_EXECEEDED = 18;
-        EXECUTION_CANCELLED = 19;
+        UNKNOWN = 17; 
+        REPLY_SIZE_EXECEEDED = 18; 
+        EXECUTION_CANCELLED = 19; 
     }
 
     optional EKind Kind = 1;
@@ -541,10 +541,10 @@ message TEvProposeTransactionResult {
         TRY_LATER = 5;
         OVERLOADED = 6;
         RESPONSE_DATA = 7;
-        EXEC_ERROR = 8;
-        RESULT_UNAVAILABLE = 9;
-        LOCKS_BROKEN = 10;
-        CANCELLED = 11;
+        EXEC_ERROR = 8; 
+        RESULT_UNAVAILABLE = 9; 
+        LOCKS_BROKEN = 10; 
+        CANCELLED = 11; 
         BAD_REQUEST = 12;
     };
 
diff --git a/ydb/core/protos/tx_proxy.proto b/ydb/core/protos/tx_proxy.proto
index dedd2f9cbb..31b6bf2906 100644
--- a/ydb/core/protos/tx_proxy.proto
+++ b/ydb/core/protos/tx_proxy.proto
@@ -138,13 +138,13 @@ message TMiniKQLTransaction {
         COMPILE = 2;
     };
 
-    message TLimits {
-        optional uint32 AffectedShardsLimit = 1;
-        optional uint32 ReadsetCountLimit = 2;
-        optional uint64 ComputeNodeMemoryLimitBytes = 3;
-        optional uint64 TotalReadSizeLimitBytes = 4;
-    };
-
+    message TLimits { 
+        optional uint32 AffectedShardsLimit = 1; 
+        optional uint32 ReadsetCountLimit = 2; 
+        optional uint64 ComputeNodeMemoryLimitBytes = 3; 
+        optional uint64 TotalReadSizeLimitBytes = 4; 
+    }; 
+ 
     optional EMode Mode = 1 [default = COMPILE_AND_EXEC];
     optional TMiniKQLProgram Program = 2;
     optional TMiniKQLParams Params = 3;
@@ -152,10 +152,10 @@ message TMiniKQLTransaction {
     optional bool EvaluateResultType = 50 [default = true];
     optional bool EvaluateResultValue = 51 [default = true];
     optional bool FlatMKQL = 52 [default = true];
-    optional bool LlvmRuntime = 53;
-    optional uint64 PerShardKeysSizeLimitBytes = 54;
+    optional bool LlvmRuntime = 53; 
+    optional uint64 PerShardKeysSizeLimitBytes = 54; 
     optional bool CollectStats = 55;
-    optional TLimits Limits = 56;
+    optional TLimits Limits = 56; 
     optional uint64 SnapshotStep = 9;
     optional uint64 SnapshotTxId = 10;
 };
@@ -191,7 +191,7 @@ message TEvProposeTransaction {
     optional uint64 ExecTimeoutPeriod = 3;
     optional string UserToken = 4; // already built and serialized user's token
     optional bool StreamResponse = 5;
-    optional uint64 CancelAfterMs = 6;
+    optional uint64 CancelAfterMs = 6; 
     optional string DatabaseName = 7;
     optional string RequestType = 8;
 }
diff --git a/ydb/core/protos/ya.make b/ydb/core/protos/ya.make
index 70bb65514c..54e34039b6 100644
--- a/ydb/core/protos/ya.make
+++ b/ydb/core/protos/ya.make
@@ -67,9 +67,9 @@ SRCS(
     issue_id.proto
     kesus.proto
     kqp_query_settings.proto
-    kqp_physical.proto
-    kqp_stats.proto
-    kqp.proto
+    kqp_physical.proto 
+    kqp_stats.proto 
+    kqp.proto 
     local.proto
     long_tx_service.proto
     metrics.proto
@@ -124,7 +124,7 @@ SRCS(
     grpc.proto
     grpc_pq_old.proto
     grpc_status_proxy.proto
-    ydb_result_set_old.proto
+    ydb_result_set_old.proto 
     ydb_table_impl.proto
     scheme_board.proto
     scheme_board_mon.proto
diff --git a/ydb/core/protos/ydb_result_set_old.proto b/ydb/core/protos/ydb_result_set_old.proto
index 9f7e4ebfc4..b93114c1aa 100644
--- a/ydb/core/protos/ydb_result_set_old.proto
+++ b/ydb/core/protos/ydb_result_set_old.proto
@@ -1,109 +1,109 @@
-syntax = "proto3";
-option cc_enable_arenas = true;
-
-import "google/protobuf/struct.proto";
+syntax = "proto3"; 
+option cc_enable_arenas = true; 
+ 
+import "google/protobuf/struct.proto"; 
 import "ydb/library/yql/public/types/yql_types.proto";
-
-package YdbOld;
-option java_package = "ru.yandex.ydb.old";
-option java_outer_classname = "ValueProtos";
-
-message DataType {
-    NYql.NProto.TypeIds id = 1;
-}
-
-message OptionalType {
-    Type item = 1;
-}
-
-message ListType {
-    Type item = 1;
-}
-
-message Variant {
-    Type item = 1;
-}
-
-message TupleType {
-    repeated Type elements = 1;
-}
-
-message Member {
-    string name = 1;
-    Type type = 2;
-}
-
-message StructType {
-    repeated Member members = 1;
-}
-
-message DictType {
-    Type key = 1;
-    Type payload = 2;
-}
-
-message Type {
-    oneof type_type {
-        DataType data_type = 1;
-        OptionalType optional_type = 2;
-        ListType list_type = 3;
-        TupleType tuple_type = 4;
-        StructType struct_type = 5;
-        DictType dict_type = 6;
-        Variant variant_type = 7;
-        google.protobuf.NullValue void_type = 8;
-    }
-}
-
-/**
- * Holds a pair to represent Dict type
- */
-
-message ValuePair {
-    Value key = 1;
-    Value payload = 2;
-}
-
-/**
- * This message represents any of the supported by transport value types.
- * Note, this is not actually a Ydb types. See NYql.NProto.TypeIds for Ydb types.
- *
- * For scalar types, just oneof value used.
- * For composite types repeated Items or Pairs used. See below.
- *
- * The idea is, we do not represent explicitly Optional<T> if value is not null (most common case)
- * - just represents value of T. Numbers of Optional levels we can get from type.
- * Variant<T> type always represent explicitly
- */
-
-message Value {
-    oneof value_value {
-        bool bool_value = 1;
-        sfixed32 int32_value = 2;
-        fixed32 uint32_value = 3;
-        sfixed64 int64_value = 4;
-        fixed64 uint64_value = 5;
-        float float_value = 6;
-        double double_value = 7;
-        bytes bytes_value = 8;
-        string text_value = 9;
-        google.protobuf.NullValue null_flag_value = 10; // Set if current TValue is terminal Null
-        Value nested_value = 11; // Represents nested TValue for Optional<Optional<T>>(Null), or Variant<T> types
+ 
+package YdbOld; 
+option java_package = "ru.yandex.ydb.old"; 
+option java_outer_classname = "ValueProtos"; 
+ 
+message DataType { 
+    NYql.NProto.TypeIds id = 1; 
+} 
+ 
+message OptionalType { 
+    Type item = 1; 
+} 
+ 
+message ListType { 
+    Type item = 1; 
+} 
+ 
+message Variant { 
+    Type item = 1; 
+} 
+ 
+message TupleType { 
+    repeated Type elements = 1; 
+} 
+ 
+message Member { 
+    string name = 1; 
+    Type type = 2; 
+} 
+ 
+message StructType { 
+    repeated Member members = 1; 
+} 
+ 
+message DictType { 
+    Type key = 1; 
+    Type payload = 2; 
+} 
+ 
+message Type { 
+    oneof type_type { 
+        DataType data_type = 1; 
+        OptionalType optional_type = 2; 
+        ListType list_type = 3; 
+        TupleType tuple_type = 4; 
+        StructType struct_type = 5; 
+        DictType dict_type = 6; 
+        Variant variant_type = 7; 
+        google.protobuf.NullValue void_type = 8; 
+    } 
+} 
+ 
+/** 
+ * Holds a pair to represent Dict type 
+ */ 
+ 
+message ValuePair { 
+    Value key = 1; 
+    Value payload = 2; 
+} 
+ 
+/** 
+ * This message represents any of the supported by transport value types. 
+ * Note, this is not actually a Ydb types. See NYql.NProto.TypeIds for Ydb types. 
+ * 
+ * For scalar types, just oneof value used. 
+ * For composite types repeated Items or Pairs used. See below. 
+ * 
+ * The idea is, we do not represent explicitly Optional<T> if value is not null (most common case) 
+ * - just represents value of T. Numbers of Optional levels we can get from type. 
+ * Variant<T> type always represent explicitly 
+ */ 
+ 
+message Value { 
+    oneof value_value { 
+        bool bool_value = 1; 
+        sfixed32 int32_value = 2; 
+        fixed32 uint32_value = 3; 
+        sfixed64 int64_value = 4; 
+        fixed64 uint64_value = 5; 
+        float float_value = 6; 
+        double double_value = 7; 
+        bytes bytes_value = 8; 
+        string text_value = 9; 
+        google.protobuf.NullValue null_flag_value = 10; // Set if current TValue is terminal Null 
+        Value nested_value = 11; // Represents nested TValue for Optional<Optional<T>>(Null), or Variant<T> types 
         fixed64 low_128 = 15;
-    }
-    repeated Value items = 12; // Used for List, Tuple, Struct types
-    repeated ValuePair pairs = 13; // Used for Dict type
-    uint32 variant_index = 14; // Used for Variant type
+    } 
+    repeated Value items = 12; // Used for List, Tuple, Struct types 
+    repeated ValuePair pairs = 13; // Used for Dict type 
+    uint32 variant_index = 14; // Used for Variant type 
     fixed64 high_128 = 16;
-}
-
-message ColumnMeta {
-    string name = 1;
-    Type type = 2;
-};
-
-message ResultSet {
-    repeated ColumnMeta column_meta = 1; /*!< Metadata of columns */
-    repeated Value rows = 2; /*!< Rows of table */
-    bool truncated = 3; /*!< Flag indicates the result was truncated */
-};
+} 
+ 
+message ColumnMeta { 
+    string name = 1; 
+    Type type = 2; 
+}; 
+ 
+message ResultSet { 
+    repeated ColumnMeta column_meta = 1; /*!< Metadata of columns */ 
+    repeated Value rows = 2; /*!< Rows of table */ 
+    bool truncated = 3; /*!< Flag indicates the result was truncated */ 
+}; 
diff --git a/ydb/core/scheme/scheme_tabledefs.h b/ydb/core/scheme/scheme_tabledefs.h
index 190233fdee..c993210bff 100644
--- a/ydb/core/scheme/scheme_tabledefs.h
+++ b/ydb/core/scheme/scheme_tabledefs.h
@@ -10,9 +10,9 @@
 
 #include <library/cpp/deprecated/enum_codegen/enum_codegen.h>
 
-#include <util/generic/maybe.h>
+#include <util/generic/maybe.h> 
 #include <util/generic/map.h>
-
+ 
 namespace NKikimr {
 
 using TSchemaVersion = ui64;
@@ -50,8 +50,8 @@ struct TTableId {
     // ctors from TPathId
     TTableId(const TPathId& pathId, const TString& sysViewInfo, ui64 schemaVersion)
         : TTableId(pathId.OwnerId, pathId.LocalPathId, sysViewInfo, schemaVersion)
-    {}
-
+    {} 
+ 
     TTableId(const TPathId& pathId, const TString& sysViewInfo)
         : TTableId(pathId, sysViewInfo, 0)
     {}
@@ -76,37 +76,37 @@ struct TTableId {
         return !SysViewInfo.empty();
     }
 
-    bool operator==(const TTableId& x) const {
-        return PathId == x.PathId && SysViewInfo == x.SysViewInfo && SchemaVersion == x.SchemaVersion;
-    }
-
-    bool operator!=(const TTableId& x) const {
-        return !operator==(x);
-    }
-
-    ui64 Hash() const noexcept {
-        auto hash = PathId.Hash();
-        if (SysViewInfo) {
-            hash = CombineHashes(hash, THash<TString>()(SysViewInfo));
-        }
-        if (SchemaVersion) {
-            hash = CombineHashes(hash, THash<TSchemaVersion>()(SchemaVersion));
-        }
-
-        return hash;
-    }
-
+    bool operator==(const TTableId& x) const { 
+        return PathId == x.PathId && SysViewInfo == x.SysViewInfo && SchemaVersion == x.SchemaVersion; 
+    } 
+ 
+    bool operator!=(const TTableId& x) const { 
+        return !operator==(x); 
+    } 
+ 
+    ui64 Hash() const noexcept { 
+        auto hash = PathId.Hash(); 
+        if (SysViewInfo) { 
+            hash = CombineHashes(hash, THash<TString>()(SysViewInfo)); 
+        } 
+        if (SchemaVersion) { 
+            hash = CombineHashes(hash, THash<TSchemaVersion>()(SchemaVersion)); 
+        } 
+ 
+        return hash; 
+    } 
+ 
     ui64 PathHash() const noexcept {
         auto hash = PathId.Hash();
-        if (SysViewInfo) {
+        if (SysViewInfo) { 
             hash = CombineHashes(hash, THash<TString>()(SysViewInfo));
-        }
-
+        } 
+ 
         return hash;
     }
 };
 
-struct TIndexId {
+struct TIndexId { 
     TPathId PathId;
     TSchemaVersion SchemaVersion = 0;
 
@@ -154,15 +154,15 @@ public:
     bool InclusiveTo;
     bool Point;
 
-    explicit TTableRange(TConstArrayRef<TCell> point)
+    explicit TTableRange(TConstArrayRef<TCell> point) 
         : From(point)
         , To()
         , InclusiveFrom(true)
         , InclusiveTo(true)
-        , Point(true) {}
+        , Point(true) {} 
 
-    TTableRange(TConstArrayRef<TCell> fromValues, bool inclusiveFrom, TConstArrayRef<TCell> toValues, bool inclusiveTo,
-        bool point = false)
+    TTableRange(TConstArrayRef<TCell> fromValues, bool inclusiveFrom, TConstArrayRef<TCell> toValues, bool inclusiveTo, 
+        bool point = false) 
         : From(fromValues)
         , To(toValues)
         , InclusiveFrom(inclusiveFrom || point)
@@ -181,33 +181,33 @@ class TSerializedTableRange {
 public:
     TSerializedCellVec From;
     TSerializedCellVec To;
-    bool FromInclusive = false;
-    bool ToInclusive = false;
+    bool FromInclusive = false; 
+    bool ToInclusive = false; 
     bool Point = false;
 
-    TSerializedTableRange() {}
+    TSerializedTableRange() {} 
 
-    TSerializedTableRange(const TString& from, const TString& to, bool fromInclusive, bool toInclusive)
+    TSerializedTableRange(const TString& from, const TString& to, bool fromInclusive, bool toInclusive) 
         : From(from)
         , To(to)
         , FromInclusive(fromInclusive)
         , ToInclusive(toInclusive) {}
 
-    TSerializedTableRange(TConstArrayRef<TCell> fromValues, bool inclusiveFrom, TConstArrayRef<TCell> toValues,
-        bool inclusiveTo)
-        : From(TSerializedCellVec::Serialize(fromValues))
-        , To(TSerializedCellVec::Serialize(toValues))
-        , FromInclusive(inclusiveFrom)
+    TSerializedTableRange(TConstArrayRef<TCell> fromValues, bool inclusiveFrom, TConstArrayRef<TCell> toValues, 
+        bool inclusiveTo) 
+        : From(TSerializedCellVec::Serialize(fromValues)) 
+        , To(TSerializedCellVec::Serialize(toValues)) 
+        , FromInclusive(inclusiveFrom) 
         , ToInclusive(inclusiveTo) {}
-
-
-    explicit TSerializedTableRange(const TTableRange& range)
-        : TSerializedTableRange(range.From, range.InclusiveFrom, range.To, range.InclusiveTo)
+ 
+ 
+    explicit TSerializedTableRange(const TTableRange& range) 
+        : TSerializedTableRange(range.From, range.InclusiveFrom, range.To, range.InclusiveTo) 
     {
         Point = range.Point;
     }
-
-    explicit TSerializedTableRange(const NKikimrTx::TKeyRange& range) {
+ 
+    explicit TSerializedTableRange(const NKikimrTx::TKeyRange& range) { 
         Load(range);
     }
 
@@ -216,14 +216,14 @@ public:
     TSerializedTableRange &operator=(const TSerializedTableRange &other) = default;
     TSerializedTableRange &operator=(TSerializedTableRange &&other) = default;
 
-    void Load(const NKikimrTx::TKeyRange& range) {
+    void Load(const NKikimrTx::TKeyRange& range) { 
         From.Parse(range.GetFrom());
         To.Parse(range.GetTo());
         FromInclusive = range.GetFromInclusive();
         ToInclusive = range.GetToInclusive();
     }
 
-    void Serialize(NKikimrTx::TKeyRange& range) const {
+    void Serialize(NKikimrTx::TKeyRange& range) const { 
         range.SetFrom(From.GetBuffer());
         range.SetFromInclusive(FromInclusive);
         if (Point) {
@@ -238,7 +238,7 @@ public:
 
     bool IsEmpty(TConstArrayRef<NScheme::TTypeId> type) const;
 
-    TTableRange ToTableRange() const {
+    TTableRange ToTableRange() const { 
         return TTableRange(From.GetCells(), FromInclusive, To.GetCells(), ToInclusive, Point);
     }
 };
@@ -646,22 +646,22 @@ public:
         {}
     };
 
-    struct TPartitionRangeInfo {
-        TSerializedCellVec EndKeyPrefix;
-        bool IsInclusive = false;
-        bool IsPoint = false;
-    };
-
-    struct TPartitionInfo {
-        TPartitionInfo() {}
-
-        TPartitionInfo(ui64 shardId)
-            : ShardId(shardId) {}
-
-        ui64 ShardId = 0;
-        TMaybe<TPartitionRangeInfo> Range;
-    };
-
+    struct TPartitionRangeInfo { 
+        TSerializedCellVec EndKeyPrefix; 
+        bool IsInclusive = false; 
+        bool IsPoint = false; 
+    }; 
+ 
+    struct TPartitionInfo { 
+        TPartitionInfo() {} 
+ 
+        TPartitionInfo(ui64 shardId) 
+            : ShardId(shardId) {} 
+ 
+        ui64 ShardId = 0; 
+        TMaybe<TPartitionRangeInfo> Range; 
+    }; 
+ 
     // in
     const TTableId TableId;
     const TOwnedTableRange Range;
@@ -675,7 +675,7 @@ public:
     // out
     EStatus Status;
     TVector<TColumnInfo> ColumnInfos;
-    TVector<TPartitionInfo> Partitions;
+    TVector<TPartitionInfo> Partitions; 
     TIntrusivePtr<TSecurityObject> SecurityObject;
 
     bool IsSystemView() const { return Partitions.empty(); }
@@ -721,22 +721,22 @@ inline int CompareRangeKeys(const TKeyDesc& rangeX, const TKeyDesc& rangeY) {
     return CompareRanges(rangeX.Range, rangeY.Range, rangeX.KeyColumnTypes);
 }
 
-} // namespace NKikimr
-
-template<>
-struct THash<NKikimr::TTableId> {
-    inline ui64 operator()(const NKikimr::TTableId& x) const noexcept {
-        return x.Hash();
-    }
-};
-
-template<>
-inline void Out<NKikimr::TTableId>(IOutputStream& o, const NKikimr::TTableId& x) {
-    o << '[' << x.PathId.OwnerId << ':' << x.PathId.LocalPathId << ':' << x.SchemaVersion;
-    if (x.SysViewInfo) {
-        o << ":" << x.SysViewInfo;
-    }
-    o << ']';
+} // namespace NKikimr 
+ 
+template<> 
+struct THash<NKikimr::TTableId> { 
+    inline ui64 operator()(const NKikimr::TTableId& x) const noexcept { 
+        return x.Hash(); 
+    } 
+}; 
+ 
+template<> 
+inline void Out<NKikimr::TTableId>(IOutputStream& o, const NKikimr::TTableId& x) { 
+    o << '[' << x.PathId.OwnerId << ':' << x.PathId.LocalPathId << ':' << x.SchemaVersion; 
+    if (x.SysViewInfo) { 
+        o << ":" << x.SysViewInfo; 
+    } 
+    o << ']'; 
 }
 
 template<>
diff --git a/ydb/core/scheme_types/scheme_types_defs.h b/ydb/core/scheme_types/scheme_types_defs.h
index bb06b09702..d97c6c6377 100644
--- a/ydb/core/scheme_types/scheme_types_defs.h
+++ b/ydb/core/scheme_types/scheme_types_defs.h
@@ -17,7 +17,7 @@ namespace NScheme {
 const ui32 MaxKeyValueSize = 4096;
 
 ////////////////////////////////////////////////////////
-template<typename T, typename TDerived, TTypeId TypeId_, const char* Name_>
+template<typename T, typename TDerived, TTypeId TypeId_, const char* Name_> 
 class TTypedType : public IType {
 public:
     //
@@ -41,7 +41,7 @@ public:
 
     // IType interface
     const char* GetName() const override {
-        return Name_;
+        return Name_; 
     }
 
     static constexpr ui32 GetFixedSize() {
@@ -52,9 +52,9 @@ public:
         return TRawTypeValue((void*)&value, sizeof(T), TypeId);
     }
 
-    static const char* TypeName() {
-        return Name_;
-    }
+    static const char* TypeName() { 
+        return Name_; 
+    } 
 };
 
 ////////////////////////////////////////////////////////
@@ -246,7 +246,7 @@ class TInterval : public IIntegerTypeWithKeyString<i64, NTypeIds::Interval, NNam
     xx(String4k, TSmallBoundedString, __VA_ARGS__) \
     xx(String2m, TLargeBoundedString, __VA_ARGS__) \
     xx(Utf8, TUtf8, __VA_ARGS__) \
-    xx(Yson, TYson, __VA_ARGS__) \
+    xx(Yson, TYson, __VA_ARGS__) \ 
     xx(Json, TJson, __VA_ARGS__) \
     xx(JsonDocument, TJsonDocument, __VA_ARGS__) \
     xx(Decimal, TDecimal, __VA_ARGS__) \
@@ -266,18 +266,18 @@ static inline bool IsValidMinikqlTypeId(TTypeId typeId) {
 }
 
 static inline ::TString GetTypeName(TTypeId typeId) {
-    #define getTypeName(v, t, ...) if (NTypeIds::v == typeId) return t::TypeName();
-    KIKIMR_FOREACH_MINIKQL_TYPE(getTypeName)
-    #undef getTypeName
+    #define getTypeName(v, t, ...) if (NTypeIds::v == typeId) return t::TypeName(); 
+    KIKIMR_FOREACH_MINIKQL_TYPE(getTypeName) 
+    #undef getTypeName 
     return ::TString("UnknownType(" + ToString(typeId) + ")");
-}
-
-static inline bool TryGetTypeName(TTypeId typeId, ::TString& typeName) {
-    #define getTypeName(v, t, ...) if (NTypeIds::v == typeId) { typeName = t::TypeName(); return true; }
-    KIKIMR_FOREACH_MINIKQL_TYPE(getTypeName)
-    #undef getTypeName
-    return false;
-}
-
+} 
+
+static inline bool TryGetTypeName(TTypeId typeId, ::TString& typeName) { 
+    #define getTypeName(v, t, ...) if (NTypeIds::v == typeId) { typeName = t::TypeName(); return true; } 
+    KIKIMR_FOREACH_MINIKQL_TYPE(getTypeName) 
+    #undef getTypeName 
+    return false; 
+} 
+ 
 } // namespace NScheme
 } // namespace NKikimr
diff --git a/ydb/core/testlib/minikql_compile.h b/ydb/core/testlib/minikql_compile.h
index 4d76ca8d73..eadcf2aa24 100644
--- a/ydb/core/testlib/minikql_compile.h
+++ b/ydb/core/testlib/minikql_compile.h
@@ -38,13 +38,13 @@ public:
                 result.Table = table;
                 result.TableId.Reset(new NKikimr::TTableId(*data->TableId));
                 result.KeyColumnCount = data->KeyColumnCount;
-
+ 
                 for (auto& column : table.ColumnNames) {
-                    auto columnInfo = data->Columns.FindPtr(column);
-                    Y_VERIFY(column);
+                    auto columnInfo = data->Columns.FindPtr(column); 
+                    Y_VERIFY(column); 
 
-                    auto insertResult = result.Columns.insert(std::make_pair(column, *columnInfo));
-                    Y_VERIFY(insertResult.second);
+                    auto insertResult = result.Columns.insert(std::make_pair(column, *columnInfo)); 
+                    Y_VERIFY(insertResult.second); 
                 }
             }
 
diff --git a/ydb/core/testlib/tenant_runtime.cpp b/ydb/core/testlib/tenant_runtime.cpp
index 974cc166d0..24e54b4351 100644
--- a/ydb/core/testlib/tenant_runtime.cpp
+++ b/ydb/core/testlib/tenant_runtime.cpp
@@ -1094,7 +1094,7 @@ void TTenantTestRuntime::Setup(bool createTenantPools)
         SendToConsole(req);
         TAutoPtr<IEventHandle> handle;
         auto reply = GrabEdgeEventRethrow<TEvConsole::TEvSetConfigResponse>(handle);
-        UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), Ydb::StatusIds::SUCCESS);
+        UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus().GetCode(), Ydb::StatusIds::SUCCESS); 
     }
 
     // Create Tenant Slot Broker
diff --git a/ydb/core/testlib/test_client.cpp b/ydb/core/testlib/test_client.cpp
index d4907c26f1..45d4564afc 100644
--- a/ydb/core/testlib/test_client.cpp
+++ b/ydb/core/testlib/test_client.cpp
@@ -121,14 +121,14 @@ namespace Tests {
         TDuration::Seconds(120)
     ).MilliSeconds();
 
-    NMiniKQL::IFunctionRegistry* DefaultFrFactory(const NScheme::TTypeRegistry& typeRegistry) {
+    NMiniKQL::IFunctionRegistry* DefaultFrFactory(const NScheme::TTypeRegistry& typeRegistry) { 
         Y_UNUSED(typeRegistry);
-        // register test UDFs
+        // register test UDFs 
         auto freg = NKikimr::NMiniKQL::CreateFunctionRegistry(NKikimr::NMiniKQL::CreateBuiltinRegistry())->Clone();
         NKikimr::NMiniKQL::FillStaticModules(*freg);
-        return freg.Release();
-    }
-
+        return freg.Release(); 
+    } 
+ 
     ui64 ChangeDomain(ui64 tabletId, ui32 domainUid) {
         return MakeTabletID(StateStorageGroupFromTabletID(tabletId), domainUid, UniqPartFromTabletID(tabletId));
     }
@@ -151,8 +151,8 @@ namespace Tests {
     TServer::TServer(const TServerSettings &settings, bool init)
         : TServer(new TServerSettings(settings), init)
     {
-    }
-
+    } 
+ 
     void TServer::Initialize() {
         if (Settings->SupportsRedirect && IsServerRedirected())
             return;
@@ -187,7 +187,7 @@ namespace Tests {
         }
 
         SetupLogging();
-
+ 
         SetupMessageBus(Settings->Port, Settings->TracePath);
         SetupDomains(app);
 
@@ -302,9 +302,9 @@ namespace Tests {
         GRpcServer->AddService(grpcService);
         GRpcServer->AddService(new NGRpcService::TGRpcYdbExportService(system, counters, grpcRequestProxyId));
         GRpcServer->AddService(new NGRpcService::TGRpcYdbImportService(system, counters, grpcRequestProxyId));
-        GRpcServer->AddService(new NGRpcService::TGRpcYdbSchemeService(system, counters, grpcRequestProxyId));
-        GRpcServer->AddService(new NGRpcService::TGRpcYdbTableService(system, counters, grpcRequestProxyId));
-        GRpcServer->AddService(new NGRpcService::TGRpcYdbScriptingService(system, counters, grpcRequestProxyId));
+        GRpcServer->AddService(new NGRpcService::TGRpcYdbSchemeService(system, counters, grpcRequestProxyId)); 
+        GRpcServer->AddService(new NGRpcService::TGRpcYdbTableService(system, counters, grpcRequestProxyId)); 
+        GRpcServer->AddService(new NGRpcService::TGRpcYdbScriptingService(system, counters, grpcRequestProxyId)); 
         GRpcServer->AddService(new NGRpcService::TGRpcOperationService(system, counters, grpcRequestProxyId));
         GRpcServer->AddService(new NGRpcService::V1::TGRpcPersQueueService(system, counters, NMsgBusProxy::CreatePersQueueMetaCacheV2Id(), grpcRequestProxyId));
         GRpcServer->AddService(new NGRpcService::TGRpcPQClusterDiscoveryService(system, counters, grpcRequestProxyId));
@@ -563,7 +563,7 @@ namespace Tests {
                                         TMailboxType::Revolving, 0);
         Runtime->RegisterService(MakeTenantPoolRootID(), poolId, nodeIdx);
         if (Settings->EnableConfigsDispatcher) {
-            auto *dispatcher = NConsole::CreateConfigsDispatcher(Settings->AppConfig);
+            auto *dispatcher = NConsole::CreateConfigsDispatcher(Settings->AppConfig); 
             auto aid = Runtime->Register(dispatcher, nodeIdx, appData.SystemPoolId, TMailboxType::Revolving, 0);
             Runtime->RegisterService(NConsole::MakeConfigsDispatcherID(Runtime->GetNodeId(nodeIdx)), aid);
         }
@@ -590,7 +590,7 @@ namespace Tests {
             TActorId ticketParserId = Runtime->Register(ticketParser, nodeIdx);
             Runtime->RegisterService(MakeTicketParserID(), ticketParserId, nodeIdx);
         }
-
+ 
         {
             IActor* healthCheck = NHealthCheck::CreateHealthCheckService();
             TActorId healthCheckId = Runtime->Register(healthCheck, nodeIdx);
@@ -604,14 +604,14 @@ namespace Tests {
         }
 
         {
-            IActor* kqpProxyService = NKqp::CreateKqpProxyService(Settings->AppConfig.GetLogConfig(),
+            IActor* kqpProxyService = NKqp::CreateKqpProxyService(Settings->AppConfig.GetLogConfig(), 
                                                                   Settings->AppConfig.GetTableServiceConfig(),
                                                                   TVector<NKikimrKqp::TKqpSetting>(Settings->KqpSettings),
                                                                   nullptr);
             TActorId kqpProxyServiceId = Runtime->Register(kqpProxyService, nodeIdx);
             Runtime->RegisterService(NKqp::MakeKqpProxyID(Runtime->GetNodeId(nodeIdx)), kqpProxyServiceId, nodeIdx);
         }
-
+ 
         {
             IActor* txProxy = CreateTxProxy(Runtime->GetTxAllocatorTabletIds());
             TActorId txProxyId = Runtime->Register(txProxy, nodeIdx);
@@ -651,7 +651,7 @@ namespace Tests {
                 }
             }
         }
-
+ 
         {
             auto driverConfig = NYdb::TDriverConfig().SetEndpoint(TStringBuilder() << "localhost:" << Settings->GrpcPort);
             if (!Driver) {
@@ -821,12 +821,12 @@ namespace Tests {
     }
 
     void TServer::SetupLogging() {
-        Runtime->SetLogPriority(NKikimrServices::FLAT_TX_SCHEMESHARD, NLog::PRI_WARN);
+        Runtime->SetLogPriority(NKikimrServices::FLAT_TX_SCHEMESHARD, NLog::PRI_WARN); 
         //Runtime->SetLogPriority(NKikimrServices::SCHEMESHARD_DESCRIBE, NLog::PRI_DEBUG);
-        //Runtime->SetLogPriority(NKikimrServices::HIVE, NActors::NLog::PRI_DEBUG);
+        //Runtime->SetLogPriority(NKikimrServices::HIVE, NActors::NLog::PRI_DEBUG); 
         //Runtime->SetLogPriority(NKikimrServices::LOCAL, NActors::NLog::PRI_DEBUG);
 
-        Runtime->SetLogPriority(NKikimrServices::BS_CONTROLLER, NLog::PRI_WARN);
+        Runtime->SetLogPriority(NKikimrServices::BS_CONTROLLER, NLog::PRI_WARN); 
         Runtime->SetLogPriority(NKikimrServices::MSGBUS_REQUEST, NLog::PRI_WARN);
 
         //Runtime->SetLogPriority(NKikimrServices::TX_COORDINATOR, NLog::PRI_DEBUG);
@@ -835,8 +835,8 @@ namespace Tests {
         //Runtime->SetLogPriority(NKikimrServices::TX_PROXY_SCHEME_CACHE, NLog::PRI_DEBUG);
 
         //Runtime->SetLogPriority(NKikimrServices::MINIKQL_ENGINE, NLog::PRI_DEBUG);
-        //Runtime->SetLogPriority(NKikimrServices::KQP_PROXY, NLog::PRI_DEBUG);
-        //Runtime->SetLogPriority(NKikimrServices::KQP_WORKER, NLog::PRI_DEBUG);
+        //Runtime->SetLogPriority(NKikimrServices::KQP_PROXY, NLog::PRI_DEBUG); 
+        //Runtime->SetLogPriority(NKikimrServices::KQP_WORKER, NLog::PRI_DEBUG); 
 
         //Runtime->SetLogPriority(NKikimrServices::TX_PROXY, NActors::NLog::PRI_TRACE);
         //Runtime->SetLogPriority(NKikimrServices::TX_PROXY_SCHEME_CACHE, NActors::NLog::PRI_TRACE);
@@ -872,7 +872,7 @@ namespace Tests {
 
     const NMiniKQL::IFunctionRegistry* TServer::GetFunctionRegistry() {
         return Runtime->GetAppData().FunctionRegistry;
-    }
+    } 
 
     TServer::~TServer() {
         if (Runtime->GetAppData().Mon) {
@@ -883,9 +883,9 @@ namespace Tests {
             GRpcServer->Stop();
         }
 
-        if (Runtime) {
-            Runtime.Destroy();
-        }
+        if (Runtime) { 
+            Runtime.Destroy(); 
+        } 
 
         if (Bus) {
             Bus->Stop();
@@ -1904,7 +1904,7 @@ namespace Tests {
                 if (opts.CollectStats)
                     mkqlTx->SetCollectStats(true);
             }
-
+ 
             TAutoPtr<NBus::TBusMessage> reply;
             NBus::EMessageStatus msgStatus = SyncCall(request, reply);
             UNIT_ASSERT_EQUAL(msgStatus, NBus::MESSAGE_OK);
@@ -1929,10 +1929,10 @@ namespace Tests {
         FlatQueryRaw(query, opts, response);
 
         if (!response.GetDataShardErrors().empty()) {
-            Cerr << "DataShardErrors:" << Endl << response.GetDataShardErrors() << Endl;
+            Cerr << "DataShardErrors:" << Endl << response.GetDataShardErrors() << Endl; 
         }
         if (!response.GetMiniKQLErrors().empty()) {
-            Cerr << "MiniKQLErrors:" << Endl << response.GetMiniKQLErrors() << Endl;
+            Cerr << "MiniKQLErrors:" << Endl << response.GetMiniKQLErrors() << Endl; 
         }
         if (response.HasProxyErrorCode()) {
             if (response.GetProxyErrorCode() != TEvTxUserProxy::TResultStatus::ExecComplete)
diff --git a/ydb/core/testlib/test_client.h b/ydb/core/testlib/test_client.h
index 2064752ab4..c821c75ded 100644
--- a/ydb/core/testlib/test_client.h
+++ b/ydb/core/testlib/test_client.h
@@ -73,7 +73,7 @@ namespace Tests {
 
     ui64 ChangeDomain(ui64 tabletId, ui32 domainUid);
     ui64 ChangeStateStorage(ui64 tabletId, ui32 ssUid);
-    NMiniKQL::IFunctionRegistry* DefaultFrFactory(const NScheme::TTypeRegistry& typeRegistry);
+    NMiniKQL::IFunctionRegistry* DefaultFrFactory(const NScheme::TTypeRegistry& typeRegistry); 
 
 
     struct TServerSettings: public TThrRefBase, public TTestFeatureFlagsHolder<TServerSettings> {
@@ -86,28 +86,28 @@ namespace Tests {
         using TControls = NKikimrConfig::TImmediateControlsConfig;
         using TLoggerInitializer = std::function<void (TTestActorRuntime&)>;
         using TStoragePoolKinds = TDomainsInfo::TDomain::TStoragePoolKinds;
-
-        ui16 Port;
+ 
+        ui16 Port; 
         ui16 GrpcPort = 0;
         NKikimrProto::TAuthConfig AuthConfig;
         NKikimrPQ::TPQConfig PQConfig;
         NKikimrPQ::TPQClusterDiscoveryConfig PQClusterDiscoveryConfig;
         NKikimrNetClassifier::TNetClassifierConfig NetClassifierConfig;
         ui32 Domain = TestDomain;
-        bool SupportsRedirect = true;
-        TString TracePath;
-        TString DomainName = TestDomainName;
-        ui32 NodeCount = 1;
+        bool SupportsRedirect = true; 
+        TString TracePath; 
+        TString DomainName = TestDomainName; 
+        ui32 NodeCount = 1; 
         ui32 DynamicNodeCount = 0;
         NFake::TStorage CustomDiskParams;
         TControls Controls;
         TAppPrepare::TFnReg FrFactory = &DefaultFrFactory;
         TIntrusivePtr<TFormatFactory> Formats;
-        bool EnableMockOnSingleNode = true;
-        TAutoPtr<TLogBackend> LogBackend;
+        bool EnableMockOnSingleNode = true; 
+        TAutoPtr<TLogBackend> LogBackend; 
         TLoggerInitializer LoggerInitializer;
         TStoragePoolKinds StoragePoolTypes;
-        TVector<NKikimrKqp::TKqpSetting> KqpSettings;
+        TVector<NKikimrKqp::TKqpSetting> KqpSettings; 
         bool EnableConsole = true;
         bool EnableConfigsDispatcher = true;
         bool UseRealThreads = true;
@@ -116,12 +116,12 @@ namespace Tests {
         TDuration KeepSnapshotTimeout = TDuration::Zero();
         ui64 ChangesQueueItemsLimit = 0;
         ui64 ChangesQueueBytesLimit = 0;
-        NKikimrConfig::TAppConfig AppConfig;
+        NKikimrConfig::TAppConfig AppConfig; 
         NKikimrConfig::TCompactionConfig CompactionConfig;
         TMap<ui32, TString> NodeKeys;
         ui64 DomainPlanResolution = 0;
         std::shared_ptr<NKikimr::NMsgBusProxy::IPersQueueGetReadSessionsInfoWorkerFactory> PersQueueGetReadSessionsInfoWorkerFactory;
-
+ 
         bool EnableMetering = false;
         TString MeteringFilePath;
 
@@ -129,29 +129,29 @@ namespace Tests {
         std::shared_ptr<TGrpcServiceFactory> GrpcServiceFactory;
 
         TServerSettings& SetGrpcPort(ui16 value) { GrpcPort = value; return *this; }
-        TServerSettings& SetSupportsRedirect(bool value) { SupportsRedirect = value; return *this; }
-        TServerSettings& SetTracePath(const TString& value) { TracePath = value; return *this; }
+        TServerSettings& SetSupportsRedirect(bool value) { SupportsRedirect = value; return *this; } 
+        TServerSettings& SetTracePath(const TString& value) { TracePath = value; return *this; } 
         TServerSettings& SetDomain(ui32 value) { Domain = value; return *this; }
         TServerSettings& SetDomainName(const TString& value);
-        TServerSettings& SetNodeCount(ui32 value) { NodeCount = value; return *this; }
+        TServerSettings& SetNodeCount(ui32 value) { NodeCount = value; return *this; } 
         TServerSettings& SetDynamicNodeCount(ui32 value) { DynamicNodeCount = value; return *this; }
         TServerSettings& SetCustomDiskParams(const NFake::TStorage& value) { CustomDiskParams = value; return *this; }
         TServerSettings& SetControls(const TControls& value) { Controls = value; return *this; }
         TServerSettings& SetFrFactory(const TAppPrepare::TFnReg& value) { FrFactory = value; return *this; }
-        TServerSettings& SetEnableMockOnSingleNode(bool value) { EnableMockOnSingleNode = value; return *this; }
+        TServerSettings& SetEnableMockOnSingleNode(bool value) { EnableMockOnSingleNode = value; return *this; } 
         TServerSettings& SetLogBackend(TAutoPtr<TLogBackend> value) { LogBackend = value; return *this; }
         TServerSettings& SetLoggerInitializer(TLoggerInitializer value) { LoggerInitializer = std::move(value); return *this; }
         TServerSettings& AddStoragePoolType(const TString& poolKind, ui32 encryptionMode = 0);
         TServerSettings& AddStoragePool(const TString& poolKind, const TString& poolName = {}, ui32 numGroups = 1, ui32 encryptionMode = 0);
-        TServerSettings& SetKqpSettings(const TVector<NKikimrKqp::TKqpSetting>& settings) { KqpSettings = settings; return *this; }
+        TServerSettings& SetKqpSettings(const TVector<NKikimrKqp::TKqpSetting>& settings) { KqpSettings = settings; return *this; } 
         TServerSettings& SetEnableConsole(bool value) { EnableConsole = value; return *this; }
         TServerSettings& SetEnableConfigsDispatcher(bool value) { EnableConfigsDispatcher = value; return *this; }
         TServerSettings& SetUseRealThreads(bool value) { UseRealThreads = value; return *this; }
-        TServerSettings& SetAppConfig(const NKikimrConfig::TAppConfig value) { AppConfig = value; return *this; }
+        TServerSettings& SetAppConfig(const NKikimrConfig::TAppConfig value) { AppConfig = value; return *this; } 
         TServerSettings& SetKeyFor(ui32 nodeId, TString keyValue) { NodeKeys[nodeId] = keyValue; return *this; }
         TServerSettings& SetEnableKqpSpilling(bool value) { EnableKqpSpilling = value; return *this; }
         TServerSettings& SetDomainPlanResolution(ui64 resolution) { DomainPlanResolution = resolution; return *this; }
-        TServerSettings& SetFeatureFlags(const NKikimrConfig::TFeatureFlags& value) { FeatureFlags = value; return *this; }
+        TServerSettings& SetFeatureFlags(const NKikimrConfig::TFeatureFlags& value) { FeatureFlags = value; return *this; } 
         TServerSettings& SetCompactionConfig(const NKikimrConfig::TCompactionConfig& value) { CompactionConfig = value; return *this; }
         TServerSettings& SetEnableDbCounters(bool value) { FeatureFlags.SetEnableDbCounters(value); return *this; }
         TServerSettings& SetEnableYq(bool value) { EnableYq = value; return *this; }
@@ -165,7 +165,7 @@ namespace Tests {
             PersQueueGetReadSessionsInfoWorkerFactory = factory;
             return *this;
         }
-
+ 
         // Add additional grpc services
         template <typename TService>
         TServerSettings& RegisterGrpcService(
@@ -180,7 +180,7 @@ namespace Tests {
         }
 
         explicit TServerSettings(ui16 port, const NKikimrProto::TAuthConfig authConfig = {}, const NKikimrPQ::TPQConfig pqConfig = {})
-            : Port(port)
+            : Port(port) 
             , AuthConfig(authConfig)
             , PQConfig(pqConfig)
         {
@@ -188,8 +188,8 @@ namespace Tests {
         }
 
         TServerSettings(const TServerSettings& settings) = default;
-    };
-
+    }; 
+ 
     class TServer : public TThrRefBase, TMoveOnly {
     protected:
         void SetupStorage();
@@ -212,7 +212,7 @@ namespace Tests {
 
         TServer(const TServerSettings& settings, bool defaultInit = true);
         TServer(TServerSettings::TConstPtr settings, bool defaultInit = true);
-
+ 
         TServer(TServer&& server) = default;
         TServer& operator =(TServer&& server) = default;
         virtual ~TServer();
diff --git a/ydb/core/tx/columnshard/columnshard__scan.cpp b/ydb/core/tx/columnshard/columnshard__scan.cpp
index e2f7ba5a51..9029dd00ef 100644
--- a/ydb/core/tx/columnshard/columnshard__scan.cpp
+++ b/ydb/core/tx/columnshard/columnshard__scan.cpp
@@ -612,8 +612,8 @@ bool TTxScan::Execute(TTransactionContext& txc, const TActorContext& ctx) {
 
     if (!parseResult) {
         return true;
-    }
-
+    } 
+ 
     if (!record.RangesSize()) {
         auto range = CreateReadMetadata(ctx, read, isIndexStats, record.GetReverse(), itemsLimit);
         if (range) {
diff --git a/ydb/core/tx/datashard/build_kqp_data_tx_out_rs_unit.cpp b/ydb/core/tx/datashard/build_kqp_data_tx_out_rs_unit.cpp
index 50a3c1f401..443e3a36fe 100644
--- a/ydb/core/tx/datashard/build_kqp_data_tx_out_rs_unit.cpp
+++ b/ydb/core/tx/datashard/build_kqp_data_tx_out_rs_unit.cpp
@@ -23,8 +23,8 @@ public:
     ~TBuildKqpDataTxOutRSUnit() override;
 
     bool IsReadyToExecute(TOperation::TPtr op) const override;
-    EExecutionStatus Execute(TOperation::TPtr op, TTransactionContext& txc, const TActorContext& ctx) override;
-    void Complete(TOperation::TPtr op, const TActorContext& ctx) override;
+    EExecutionStatus Execute(TOperation::TPtr op, TTransactionContext& txc, const TActorContext& ctx) override; 
+    void Complete(TOperation::TPtr op, const TActorContext& ctx) override; 
 
 private:
     EExecutionStatus OnTabletNotReady(TActiveTransaction& tx, TValidatedDataTx& dataTx, TTransactionContext& txc,
@@ -32,17 +32,17 @@ private:
 };
 
 TBuildKqpDataTxOutRSUnit::TBuildKqpDataTxOutRSUnit(TDataShard& dataShard, TPipeline& pipeline)
-    : TExecutionUnit(EExecutionUnitKind::BuildKqpDataTxOutRS, true, dataShard, pipeline) {}
+    : TExecutionUnit(EExecutionUnitKind::BuildKqpDataTxOutRS, true, dataShard, pipeline) {} 
 
-TBuildKqpDataTxOutRSUnit::~TBuildKqpDataTxOutRSUnit() {}
+TBuildKqpDataTxOutRSUnit::~TBuildKqpDataTxOutRSUnit() {} 
 
 bool TBuildKqpDataTxOutRSUnit::IsReadyToExecute(TOperation::TPtr) const {
     return true;
 }
 
-EExecutionStatus TBuildKqpDataTxOutRSUnit::Execute(TOperation::TPtr op, TTransactionContext& txc,
-    const TActorContext& ctx)
-{
+EExecutionStatus TBuildKqpDataTxOutRSUnit::Execute(TOperation::TPtr op, TTransactionContext& txc, 
+    const TActorContext& ctx) 
+{ 
     TSetupSysLocks guardLocks(op, DataShard);
     TActiveTransaction* tx = dynamic_cast<TActiveTransaction*>(op.Get());
     Y_VERIFY_S(tx, "cannot cast operation of kind " << op->GetKind());
@@ -58,7 +58,7 @@ EExecutionStatus TBuildKqpDataTxOutRSUnit::Execute(TOperation::TPtr op, TTransac
             case ERestoreDataStatus::Error:
                 Y_FAIL("Failed to restore tx data: %s", tx->GetDataTx()->GetErrors().c_str());
         }
-    }
+    } 
 
     const auto& dataTx = tx->GetDataTx();
     ui64 tabletId = DataShard.TabletID();
@@ -119,7 +119,7 @@ EExecutionStatus TBuildKqpDataTxOutRSUnit::Execute(TOperation::TPtr op, TTransac
     } catch (const TNotReadyTabletException&) {
         LOG_C("Unexpected TNotReadyTabletException exception at build out rs");
         return OnTabletNotReady(*tx, *dataTx, txc, ctx);
-    } catch (const yexception& e) {
+    } catch (const yexception& e) { 
         LOG_C("Exception while preparing out-readsets for KQP transaction " << *op << " at " << DataShard.TabletID()
             << ": " << e.what());
         if (op->IsReadOnly() || op->IsImmediate()) {
@@ -135,7 +135,7 @@ EExecutionStatus TBuildKqpDataTxOutRSUnit::Execute(TOperation::TPtr op, TTransac
     return EExecutionStatus::Executed;
 }
 
-void TBuildKqpDataTxOutRSUnit::Complete(TOperation::TPtr, const TActorContext&) {}
+void TBuildKqpDataTxOutRSUnit::Complete(TOperation::TPtr, const TActorContext&) {} 
 
 EExecutionStatus TBuildKqpDataTxOutRSUnit::OnTabletNotReady(TActiveTransaction& tx, TValidatedDataTx& dataTx,
     TTransactionContext& txc, const TActorContext& ctx)
diff --git a/ydb/core/tx/datashard/datashard.h b/ydb/core/tx/datashard/datashard.h
index 5a93c03502..8589a7a16c 100644
--- a/ydb/core/tx/datashard/datashard.h
+++ b/ydb/core/tx/datashard/datashard.h
@@ -92,8 +92,8 @@ namespace NDataShard {
             // All input RS for operation were loaded from
             // local database
             LoadedInRS = 1ULL << 32,
-            // Operation is using new execution engine in scan mode
-            KqpScanTransaction = 1ULL << 33,
+            // Operation is using new execution engine in scan mode 
+            KqpScanTransaction = 1ULL << 33, 
             // Operation is waiting for stream clearance
             WaitingForStreamClearance = 1ULL << 34,
             // Operation is interested in interconnect disconnects
@@ -121,7 +121,7 @@ namespace NDataShard {
 
             PrivateFlagsMask = 0xFFFFFFFFFFFF0000ULL,
             PreservedPrivateFlagsMask = ReadOnly | ProposeBlocker | NeedDiagnostics | GlobalReader
-                | GlobalWriter | KqpDataTransaction | KqpScanTransaction
+                | GlobalWriter | KqpDataTransaction | KqpScanTransaction 
                 | BlockingImmediateOps | BlockingImmediateWrites,
         };
     };
@@ -534,35 +534,35 @@ struct TEvDataShard {
             Record.SetTxResult(txResult.data(), txResult.size());
         }
 
-        void SetExecutionError(const NKikimrTxDataShard::TError::EKind& error, const TStringBuf& message) {
-            switch (error) {
-                case NKikimrTxDataShard::TError::REPLY_SIZE_EXECEEDED:
-                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::RESULT_UNAVAILABLE);
-                    break;
-                case NKikimrTxDataShard::TError::EXECUTION_CANCELLED:
-                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::CANCELLED);
-                    break;
-                default:
-                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::EXEC_ERROR);
-                    break;
-            }
-
-            AddError(error, message);
-        }
-
-        void SetProcessError(const NKikimrTxDataShard::TError::EKind& error, const TStringBuf& message) {
-            switch (error) {
-                case NKikimrTxDataShard::TError::PROGRAM_ERROR:
-                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::EXEC_ERROR);
-                    break;
-                default:
-                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::ERROR);
-                    break;
-            }
-
-            AddError(error, message);
-        }
-
+        void SetExecutionError(const NKikimrTxDataShard::TError::EKind& error, const TStringBuf& message) { 
+            switch (error) { 
+                case NKikimrTxDataShard::TError::REPLY_SIZE_EXECEEDED: 
+                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::RESULT_UNAVAILABLE); 
+                    break; 
+                case NKikimrTxDataShard::TError::EXECUTION_CANCELLED: 
+                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::CANCELLED); 
+                    break; 
+                default: 
+                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::EXEC_ERROR); 
+                    break; 
+            } 
+ 
+            AddError(error, message); 
+        } 
+ 
+        void SetProcessError(const NKikimrTxDataShard::TError::EKind& error, const TStringBuf& message) { 
+            switch (error) { 
+                case NKikimrTxDataShard::TError::PROGRAM_ERROR: 
+                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::EXEC_ERROR); 
+                    break; 
+                default: 
+                    Record.SetStatus(NKikimrTxDataShard::TEvProposeTransactionResult::ERROR); 
+                    break; 
+            } 
+ 
+            AddError(error, message); 
+        } 
+ 
         void SetStepOrderId(const std::pair<ui64, ui64>& stepOrderId) {
             Record.SetStep(stepOrderId.first);
             Record.SetOrderId(stepOrderId.second);
diff --git a/ydb/core/tx/datashard/datashard__engine_host.cpp b/ydb/core/tx/datashard/datashard__engine_host.cpp
index 876c337093..fd84be8132 100644
--- a/ydb/core/tx/datashard/datashard__engine_host.cpp
+++ b/ydb/core/tx/datashard/datashard__engine_host.cpp
@@ -15,31 +15,31 @@
 
 #include <library/cpp/actors/core/log.h>
 
-#include <util/generic/cast.h>
-
+#include <util/generic/cast.h> 
+ 
 namespace NKikimr {
 namespace NDataShard {
 
 using namespace NMiniKQL;
 using namespace NTabletFlatExecutor;
 
-namespace {
-
+namespace { 
+ 
 NUdf::TUnboxedValue CreateRow(const TVector<TCell>& inRow,
                               const TVector<NScheme::TTypeId>& inType,
                               const THolderFactory& holderFactory) {
     NUdf::TUnboxedValue* rowItems = nullptr;
     auto row = holderFactory.CreateDirectArrayHolder(inRow.size(), rowItems);
-
-    for (ui32 i = 0; i < inRow.size(); ++i) {
+ 
+    for (ui32 i = 0; i < inRow.size(); ++i) { 
         rowItems[i] = GetCellValue(inRow[i], inType[i]);
-    }
-
+    } 
+ 
     return std::move(row);
-}
-
-} // namespace
-
+} 
+ 
+} // namespace 
+ 
 ///
 struct ItemInfo {
     ui32 ColumnId;
@@ -80,20 +80,20 @@ struct TRowResultInfo {
     }
 
     NUdf::TUnboxedValue CreateResult(TVector<TCell>&& inRow, const THolderFactory& holderFactory) const {
-        if (inRow.empty()) {
+        if (inRow.empty()) { 
             return NUdf::TUnboxedValuePod();
-        }
+        } 
 
-        Y_VERIFY(inRow.size() >= ItemInfos.size());
+        Y_VERIFY(inRow.size() >= ItemInfos.size()); 
 
-        // reorder columns
+        // reorder columns 
         TVector<TCell> outRow(Reserve(ItemInfos.size()));
         TVector<NScheme::TTypeId> outTypes(Reserve(ItemInfos.size()));
-        for (ui32 i = 0; i < ItemInfos.size(); ++i) {
-            ui32 colId = ItemInfos[i].ColumnId;
-            outRow.emplace_back(std::move(inRow[colId]));
+        for (ui32 i = 0; i < ItemInfos.size(); ++i) { 
+            ui32 colId = ItemInfos[i].ColumnId; 
+            outRow.emplace_back(std::move(inRow[colId])); 
             outTypes.emplace_back(ItemInfos[i].SchemeType);
-        }
+        } 
 
         return CreateRow(outRow, outTypes, holderFactory);
     }
@@ -105,7 +105,7 @@ struct TRangeResultInfo {
     TStructType* RowType;
     TSmallVec<ItemInfo> ItemInfos;
     mutable ui64 Bytes = 0;
-    TDefaultListRepresentation Rows;
+    TDefaultListRepresentation Rows; 
     TString FirstKey;
 
     // optimisation: reuse vectors
@@ -165,19 +165,19 @@ struct TRangeResultInfo {
             TmpTypes.push_back(ItemInfos[i].SchemeType);
         }
 
-        Bytes += 8; // per row overhead
+        Bytes += 8; // per row overhead 
         Rows = Rows.Append(CreateRow(TmpRow, TmpTypes, holderFactory));
-
-        if (!FirstKey) {
+ 
+        if (!FirstKey) { 
             FirstKey = Serialize(TmpRow, TmpTypes);
-        }
+        } 
     }
 
     NUdf::TUnboxedValue CreateResult(const THolderFactory& holderFactory) {
         NUdf::TUnboxedValue* resultItems = nullptr;
         auto result = holderFactory.CreateDirectArrayHolder(4, resultItems);
 
-        resultItems[0] = holderFactory.CreateDirectListHolder(std::move(Rows));
+        resultItems[0] = holderFactory.CreateDirectListHolder(std::move(Rows)); 
         resultItems[1] = NUdf::TUnboxedValuePod(false);
         resultItems[2] = MakeString(FirstKey);
         resultItems[3] = NUdf::TUnboxedValuePod(Bytes);
@@ -209,7 +209,7 @@ public:
 
     NUdf::TUnboxedValue SelectRow(const TArrayRef<const TCell>& row, TStructLiteral* columnIds,
         TOptionalType* returnType, const TReadTarget& readTarget, const THolderFactory& holderFactory) const
-    {
+    { 
         Y_UNUSED(readTarget);
 
         TRowResultInfo result(columnIds, Columns, returnType);
@@ -360,20 +360,20 @@ public:
 
     NUdf::TUnboxedValue SelectRow(const TTableId& tableId, const TArrayRef<const TCell>& row,
         TStructLiteral* columnIds, TOptionalType* returnType, const TReadTarget& readTarget,
-        const THolderFactory& holderFactory) override
+        const THolderFactory& holderFactory) override 
     {
-        if (TSysTables::IsSystemTable(tableId)) {
+        if (TSysTables::IsSystemTable(tableId)) { 
             return DataShardSysTable(tableId).SelectRow(row, columnIds, returnType, readTarget, holderFactory);
-        }
+        } 
 
         Self->SysLocksTable().SetLock(tableId, row, LockTxId);
 
         Self->SetTableAccessTime(tableId, Now);
-        return TEngineHost::SelectRow(tableId, row, columnIds, returnType, readTarget, holderFactory);
+        return TEngineHost::SelectRow(tableId, row, columnIds, returnType, readTarget, holderFactory); 
     }
 
     NUdf::TUnboxedValue SelectRange(const TTableId& tableId, const TTableRange& range,
-        TStructLiteral* columnIds,  TListLiteral* skipNullKeys, TStructType* returnType,
+        TStructLiteral* columnIds,  TListLiteral* skipNullKeys, TStructType* returnType, 
         const TReadTarget& readTarget, ui64 itemsLimit, ui64 bytesLimit, bool reverse,
         std::pair<const TListLiteral*, const TListLiteral*> forbidNullArgs, const THolderFactory& holderFactory) override
     {
@@ -382,7 +382,7 @@ public:
         Self->SysLocksTable().SetLock(tableId, range, LockTxId);
 
         Self->SetTableAccessTime(tableId, Now);
-        return TEngineHost::SelectRange(tableId, range, columnIds, skipNullKeys, returnType, readTarget,
+        return TEngineHost::SelectRange(tableId, range, columnIds, skipNullKeys, returnType, readTarget, 
             itemsLimit, bytesLimit, reverse, forbidNullArgs, holderFactory);
     }
 
@@ -473,7 +473,7 @@ public:
     }
 
     ui64 LocalTableId(const TTableId &tableId) const override {
-        return Self->GetLocalTableId(tableId);
+        return Self->GetLocalTableId(tableId); 
     }
 
     ui64 GetTableSchemaVersion(const TTableId& tableId) const override {
@@ -510,55 +510,55 @@ private:
 
 TEngineBay::TEngineBay(TDataShard * self, TTransactionContext& txc, const TActorContext& ctx,
                        std::pair<ui64, ui64> stepTxId)
-    : StepTxId(stepTxId)
-    , LockTxId(0)
+    : StepTxId(stepTxId) 
+    , LockTxId(0) 
 {
-    auto now = TAppData::TimeProvider->Now();
+    auto now = TAppData::TimeProvider->Now(); 
     EngineHost = MakeHolder<TDataShardEngineHost>(self, txc.DB, EngineHostCounters, LockTxId, now);
 
-    EngineSettings = MakeHolder<TEngineFlatSettings>(IEngineFlat::EProtocol::V1, AppData(ctx)->FunctionRegistry,
+    EngineSettings = MakeHolder<TEngineFlatSettings>(IEngineFlat::EProtocol::V1, AppData(ctx)->FunctionRegistry, 
         *TAppData::RandomProvider, *TAppData::TimeProvider, EngineHost.Get(), self->AllocCounters);
-
+ 
     ui64 tabletId = self->TabletID();
-    TraceMessage = Sprintf("Shard %" PRIu64 ", txid %" PRIu64, tabletId, stepTxId.second);
+    TraceMessage = Sprintf("Shard %" PRIu64 ", txid %" PRIu64, tabletId, stepTxId.second); 
     const TActorSystem* actorSystem = ctx.ExecutorThread.ActorSystem;
-    EngineSettings->LogErrorWriter = [actorSystem, this](const TString& message) {
-        LOG_ERROR_S(*actorSystem, NKikimrServices::MINIKQL_ENGINE, TraceMessage
-            << ", engine error: " << message);
-    };
-
+    EngineSettings->LogErrorWriter = [actorSystem, this](const TString& message) { 
+        LOG_ERROR_S(*actorSystem, NKikimrServices::MINIKQL_ENGINE, TraceMessage 
+            << ", engine error: " << message); 
+    }; 
+ 
     if (ctx.LoggerSettings()->Satisfies(NLog::PRI_DEBUG, NKikimrServices::MINIKQL_ENGINE, stepTxId.second)) {
-        EngineSettings->BacktraceWriter =
-            [actorSystem, this](const char * operation, ui32 line, const TBackTrace* backtrace)
-            {
-                LOG_DEBUG(*actorSystem, NKikimrServices::MINIKQL_ENGINE, "%s, %s (%" PRIu32 ")\n%s",
+        EngineSettings->BacktraceWriter = 
+            [actorSystem, this](const char * operation, ui32 line, const TBackTrace* backtrace) 
+            { 
+                LOG_DEBUG(*actorSystem, NKikimrServices::MINIKQL_ENGINE, "%s, %s (%" PRIu32 ")\n%s", 
                     TraceMessage.data(), operation, line, backtrace ? backtrace->PrintToString().data() : "");
-            };
-    }
-
-    KqpLogFunc = [actorSystem, this](const TStringBuf& message) {
-        LOG_DEBUG_S(*actorSystem, NKikimrServices::KQP_TASKS_RUNNER, TraceMessage
-            << ": " << message);
-    };
-
+            }; 
+    }
+ 
+    KqpLogFunc = [actorSystem, this](const TStringBuf& message) { 
+        LOG_DEBUG_S(*actorSystem, NKikimrServices::KQP_TASKS_RUNNER, TraceMessage 
+            << ": " << message); 
+    }; 
+ 
     ComputeCtx = MakeHolder<TKqpDatashardComputeContext>(self, EngineHostCounters, now);
-    ComputeCtx->Database = &txc.DB;
-
-    auto kqpApplyCtx = MakeHolder<TKqpDatashardApplyContext>();
-    kqpApplyCtx->Host = EngineHost.Get();
-
-    KqpApplyCtx.Reset(kqpApplyCtx.Release());
-
+    ComputeCtx->Database = &txc.DB; 
+ 
+    auto kqpApplyCtx = MakeHolder<TKqpDatashardApplyContext>(); 
+    kqpApplyCtx->Host = EngineHost.Get(); 
+ 
+    KqpApplyCtx.Reset(kqpApplyCtx.Release()); 
+ 
     KqpAlloc = MakeHolder<TScopedAlloc>(TAlignedPagePoolCounters(), AppData(ctx)->FunctionRegistry->SupportsSizedAllocators());
     KqpTypeEnv = MakeHolder<TTypeEnvironment>(*KqpAlloc);
     KqpAlloc->Release();
 
-    KqpExecCtx.FuncRegistry = AppData(ctx)->FunctionRegistry;
-    KqpExecCtx.ComputeCtx = ComputeCtx.Get();
-    KqpExecCtx.ComputationFactory = GetKqpDatashardComputeFactory(ComputeCtx.Get());
-    KqpExecCtx.RandomProvider = TAppData::RandomProvider.Get();
-    KqpExecCtx.TimeProvider = TAppData::TimeProvider.Get();
-    KqpExecCtx.ApplyCtx = KqpApplyCtx.Get();
+    KqpExecCtx.FuncRegistry = AppData(ctx)->FunctionRegistry; 
+    KqpExecCtx.ComputeCtx = ComputeCtx.Get(); 
+    KqpExecCtx.ComputationFactory = GetKqpDatashardComputeFactory(ComputeCtx.Get()); 
+    KqpExecCtx.RandomProvider = TAppData::RandomProvider.Get(); 
+    KqpExecCtx.TimeProvider = TAppData::TimeProvider.Get(); 
+    KqpExecCtx.ApplyCtx = KqpApplyCtx.Get(); 
     KqpExecCtx.Alloc = KqpAlloc.Get();
     KqpExecCtx.TypeEnv = KqpTypeEnv.Get();
 }
@@ -607,7 +607,7 @@ void TEngineBay::AddWriteRange(const TTableId& tableId, const TTableRange& range
     Info.Loaded = true;
 }
 
-TEngineBay::TSizes TEngineBay::CalcSizes(bool needsTotalKeysSize) const {
+TEngineBay::TSizes TEngineBay::CalcSizes(bool needsTotalKeysSize) const { 
     Y_VERIFY(EngineHost);
 
     TSizes outSizes;
@@ -618,17 +618,17 @@ TEngineBay::TSizes TEngineBay::CalcSizes(bool needsTotalKeysSize) const {
             continue;
 
         readKeys.emplace_back(validKey.Key.get());
-        if (needsTotalKeysSize || validKey.NeedSizeCalculation()) {
+        if (needsTotalKeysSize || validKey.NeedSizeCalculation()) { 
             ui64 size = EngineHost->CalculateResultSize(*validKey.Key);
-
-            if (needsTotalKeysSize) {
-                outSizes.TotalKeysSize += size;
-            }
-
+ 
+            if (needsTotalKeysSize) { 
+                outSizes.TotalKeysSize += size; 
+            } 
+ 
             if (validKey.IsResultPart) {
                 outSizes.ReplySize += size;
             }
-
+ 
             for (ui64 shard : validKey.TargetShards) {
                 outSizes.OutReadSetSize[shard] += size;
             }
@@ -671,23 +671,23 @@ TVector<IChangeCollector::TChange> TEngineBay::GetCollectedChanges() const {
 }
 
 IEngineFlat * TEngineBay::GetEngine() {
-    if (!Engine) {
-        Engine = CreateEngineFlat(*EngineSettings);
-        Engine->SetStepTxId(StepTxId);
-    }
-
-    return Engine.Get();
-}
-
-void TEngineBay::SetLockTxId(ui64 lockTxId) {
-    LockTxId = lockTxId;
-    if (ComputeCtx) {
-        ComputeCtx->SetLockTxId(lockTxId);
-    }
-}
-
+    if (!Engine) { 
+        Engine = CreateEngineFlat(*EngineSettings); 
+        Engine->SetStepTxId(StepTxId); 
+    } 
+ 
+    return Engine.Get(); 
+} 
+ 
+void TEngineBay::SetLockTxId(ui64 lockTxId) { 
+    LockTxId = lockTxId; 
+    if (ComputeCtx) { 
+        ComputeCtx->SetLockTxId(lockTxId); 
+    } 
+} 
+ 
 NKqp::TKqpTasksRunner& TEngineBay::GetKqpTasksRunner(const NKikimrTxDataShard::TKqpTransaction& tx) {
-    if (!KqpTasksRunner) {
+    if (!KqpTasksRunner) { 
         NYql::NDq::TDqTaskRunnerSettings settings;
 
         if (tx.HasRuntimeSettings() && tx.GetRuntimeSettings().HasStatsMode()) {
@@ -705,15 +705,15 @@ NKqp::TKqpTasksRunner& TEngineBay::GetKqpTasksRunner(const NKikimrTxDataShard::T
 
         KqpAlloc->SetLimit(10_MB);
         KqpTasksRunner = NKqp::CreateKqpTasksRunner(tx.GetTasks(), KqpExecCtx, settings, KqpLogFunc);
-    }
-
-    return *KqpTasksRunner;
-}
-
+    } 
+ 
+    return *KqpTasksRunner; 
+} 
+ 
 TKqpDatashardComputeContext& TEngineBay::GetKqpComputeCtx() {
-    Y_VERIFY(ComputeCtx);
-    return *ComputeCtx;
-}
-
+    Y_VERIFY(ComputeCtx); 
+    return *ComputeCtx; 
+} 
+ 
 } // NDataShard
 } // NKikimr
diff --git a/ydb/core/tx/datashard/datashard__engine_host.h b/ydb/core/tx/datashard/datashard__engine_host.h
index 8e3064c83d..9906eeb83b 100644
--- a/ydb/core/tx/datashard/datashard__engine_host.h
+++ b/ydb/core/tx/datashard/datashard__engine_host.h
@@ -34,7 +34,7 @@ public:
         ui64 ReadSize = 0;
         ui64 ReplySize = 0;
         THashMap<ui64, ui64> OutReadSetSize;
-        ui64 TotalKeysSize = 0;
+        ui64 TotalKeysSize = 0; 
     };
 
     TEngineBay(TDataShard * self, TTransactionContext& txc, const TActorContext& ctx,
@@ -43,9 +43,9 @@ public:
     virtual ~TEngineBay();
 
     const NMiniKQL::IEngineFlat * GetEngine() const { return Engine.Get(); }
-    NMiniKQL::IEngineFlat * GetEngine();
-    void SetLockTxId(ui64 lockTxId);
-    void SetUseLlvmRuntime(bool llvmRuntime) { EngineSettings->LlvmRuntime = llvmRuntime; }
+    NMiniKQL::IEngineFlat * GetEngine(); 
+    void SetLockTxId(ui64 lockTxId); 
+    void SetUseLlvmRuntime(bool llvmRuntime) { EngineSettings->LlvmRuntime = llvmRuntime; } 
 
     EResult Validate() {
         if (Info.Loaded)
@@ -71,7 +71,7 @@ public:
 
     /// @note it expects TValidationInfo keys are materialized outsize of engine's allocs
     void DestroyEngine() {
-        ComputeCtx->Clear();
+        ComputeCtx->Clear(); 
         if (KqpTasksRunner) {
             KqpTasksRunner.Reset();
             {
@@ -88,7 +88,7 @@ public:
     }
 
     const TValidationInfo& TxInfo() const { return Info; }
-    TEngineBay::TSizes CalcSizes(bool needsTotalKeysSize) const;
+    TEngineBay::TSizes CalcSizes(bool needsTotalKeysSize) const; 
 
     void SetWriteVersion(TRowVersion writeVersion);
     void SetReadVersion(TRowVersion readVersion);
@@ -101,19 +101,19 @@ public:
 
     NKqp::TKqpTasksRunner& GetKqpTasksRunner(const NKikimrTxDataShard::TKqpTransaction& tx);
     NMiniKQL::TKqpDatashardComputeContext& GetKqpComputeCtx();
-
+ 
 private:
-    std::pair<ui64, ui64> StepTxId;
+    std::pair<ui64, ui64> StepTxId; 
     THolder<NMiniKQL::IEngineFlatHost> EngineHost;
-    THolder<NMiniKQL::TEngineFlatSettings> EngineSettings;
+    THolder<NMiniKQL::TEngineFlatSettings> EngineSettings; 
     THolder<NMiniKQL::IEngineFlat> Engine;
     TValidationInfo Info;
     TEngineHostCounters EngineHostCounters;
     ui64 LockTxId;
     TString TraceMessage;
     NYql::NDq::TLogFunc KqpLogFunc;
-    THolder<NUdf::IApplyContext> KqpApplyCtx;
-    THolder<NMiniKQL::TKqpDatashardComputeContext> ComputeCtx;
+    THolder<NUdf::IApplyContext> KqpApplyCtx; 
+    THolder<NMiniKQL::TKqpDatashardComputeContext> ComputeCtx; 
     THolder<NMiniKQL::TScopedAlloc> KqpAlloc;
     THolder<NMiniKQL::TTypeEnvironment> KqpTypeEnv;
     NYql::NDq::TDqTaskRunnerContext KqpExecCtx;
diff --git a/ydb/core/tx/datashard/datashard__kqp_scan.cpp b/ydb/core/tx/datashard/datashard__kqp_scan.cpp
index b6b6b7e337..54da7e7f2e 100644
--- a/ydb/core/tx/datashard/datashard__kqp_scan.cpp
+++ b/ydb/core/tx/datashard/datashard__kqp_scan.cpp
@@ -601,8 +601,8 @@ void TDataShard::Handle(TEvDataShard::TEvKqpScan::TPtr& ev, const TActorContext&
         IssueToMessage(issue, ev->Record.MutableIssues()->Add());
         Send(scanComputeActor, ev.Release(), IEventHandle::FlagTrackDelivery);
         return;
-    }
-
+    } 
+ 
     auto& snapshot = request.GetSnapshot();
 
     auto snapshotKey = TSnapshotKey(PathOwnerId, request.GetLocalPathId(), snapshot.GetStep(), snapshot.GetTxId());
diff --git a/ydb/core/tx/datashard/datashard__progress_tx.cpp b/ydb/core/tx/datashard/datashard__progress_tx.cpp
index 3f1fab6b46..7503d8b6a1 100644
--- a/ydb/core/tx/datashard/datashard__progress_tx.cpp
+++ b/ydb/core/tx/datashard/datashard__progress_tx.cpp
@@ -1,5 +1,5 @@
 #include "datashard_txs.h"
-#include "datashard_failpoints.h"
+#include "datashard_failpoints.h" 
 
 namespace NKikimr {
 namespace NDataShard {
diff --git a/ydb/core/tx/datashard/datashard__propose_tx_base.cpp b/ydb/core/tx/datashard/datashard__propose_tx_base.cpp
index 7dfb1a294e..7320e2e24a 100644
--- a/ydb/core/tx/datashard/datashard__propose_tx_base.cpp
+++ b/ydb/core/tx/datashard/datashard__propose_tx_base.cpp
@@ -1,5 +1,5 @@
 #include "datashard_txs.h"
-#include "datashard_failpoints.h"
+#include "datashard_failpoints.h" 
 #include "operation.h"
 
 #include <ydb/core/util/pb.h>
@@ -145,8 +145,8 @@ bool TDataShard::TTxProposeTransactionBase::Execute(NTabletFlatExecutor::TTransa
     } catch (const TSchemeErrorTabletException &ex) {
         Y_UNUSED(ex);
         Y_FAIL();
-    } catch (const TMemoryLimitExceededException &ex) {
-        Y_FAIL("there must be no leaked exceptions: TMemoryLimitExceededException");
+    } catch (const TMemoryLimitExceededException &ex) { 
+        Y_FAIL("there must be no leaked exceptions: TMemoryLimitExceededException"); 
     } catch (const std::exception &e) {
         Y_FAIL("there must be no leaked exceptions: %s", e.what());
     } catch (...) {
diff --git a/ydb/core/tx/datashard/datashard_active_transaction.cpp b/ydb/core/tx/datashard/datashard_active_transaction.cpp
index 0226bd42e2..8aecc944e1 100644
--- a/ydb/core/tx/datashard/datashard_active_transaction.cpp
+++ b/ydb/core/tx/datashard/datashard_active_transaction.cpp
@@ -1,7 +1,7 @@
 #include "defs.h"
 
 #include "datashard_active_transaction.h"
-#include "datashard_kqp.h"
+#include "datashard_kqp.h" 
 #include "datashard_locks.h"
 #include "datashard_impl.h"
 #include "datashard_failpoints.h"
@@ -26,7 +26,7 @@ TValidatedDataTx::TValidatedDataTx(TDataShard *self,
     , TxSize(0)
     , TxCacheUsage(0)
     , IsReleased(false)
-    , IsReadOnly(true)
+    , IsReadOnly(true) 
     , AllowCancelROwithReadsets(self->AllowCancelROwithReadsets())
     , Cancelled(false)
     , ReceivedAt_(receivedAt)
@@ -41,7 +41,7 @@ TValidatedDataTx::TValidatedDataTx(TDataShard *self,
     ComputeTxSize();
     NActors::NMemory::TLabel<MemoryLabelValidatedDataTx>::Add(TxSize);
 
-    Y_VERIFY(Tx.HasMiniKQL() || Tx.HasReadTableTransaction() || Tx.HasKqpTransaction(),
+    Y_VERIFY(Tx.HasMiniKQL() || Tx.HasReadTableTransaction() || Tx.HasKqpTransaction(), 
              "One of the fields should be set: MiniKQL, ReadTableTransaction, KqpTransaction");
 
     if (Tx.GetLockTxId())
@@ -63,7 +63,7 @@ TValidatedDataTx::TValidatedDataTx(TDataShard *self,
             ErrCode = NKikimrTxDataShard::TError::SCHEME_ERROR;
             ErrStr = "Trying to read from table that doesn't exist";
         }
-    } else if (IsKqpTx()) {
+    } else if (IsKqpTx()) { 
         if (Y_UNLIKELY(!IsKqpDataTx())) {
             LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "Unexpected KQP transaction type, shard: " << TabletId()
                 << ", txid: " << StepTxId_.TxId << ", tx: " << Tx.DebugString());
@@ -90,15 +90,15 @@ TValidatedDataTx::TValidatedDataTx(TDataShard *self,
             for (auto& task : GetKqpTransaction().GetTasks()) {
                 NKikimrTxDataShard::TKqpTransaction::TDataTaskMeta meta;
                 if (!task.GetMeta().UnpackTo(&meta)) {
-                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP transaction validation failed"
-                        << ", datashard: " << TabletId()
+                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP transaction validation failed" 
+                        << ", datashard: " << TabletId() 
                         << ", txid: " << StepTxId_.TxId
                         << ", failed to load task meta: " << task.GetMeta().value());
-                    ErrCode = NKikimrTxDataShard::TError::PROGRAM_ERROR;
+                    ErrCode = NKikimrTxDataShard::TError::PROGRAM_ERROR; 
                     ErrStr = "Transaction validation failed: invalid task metadata.";
-                    return;
-                }
-
+                    return; 
+                } 
+ 
                 LOG_TRACE_S(ctx, NKikimrServices::TX_DATASHARD, "TxId: " << StepTxId_.TxId << ", shard " << TabletId()
                     << ", task: " << task.GetId() << ", meta: " << meta.ShortDebugString());
 
@@ -168,23 +168,23 @@ TValidatedDataTx::TValidatedDataTx(TDataShard *self,
         } catch (const yexception& e) {
             LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "Exception while validating KQP transaction, datashard: "
                 << TabletId() << ", txid: " << StepTxId_.TxId << ", error: " << e.what());
-            ErrCode = NKikimrTxDataShard::TError::PROGRAM_ERROR;
+            ErrCode = NKikimrTxDataShard::TError::PROGRAM_ERROR; 
             ErrStr = TStringBuilder() << "Transaction validation failed: " << e.what() << ".";
-            return;
-        }
+            return; 
+        } 
     } else {
         Y_VERIFY(Tx.HasMiniKQL());
-        if (Tx.GetLlvmRuntime()) {
+        if (Tx.GetLlvmRuntime()) { 
             LOG_DEBUG_S(ctx, NKikimrServices::TX_DATASHARD,
                         "Using LLVM runtime to execute transaction: " << StepTxId_.TxId);
-            EngineBay.SetUseLlvmRuntime(true);
-        }
-        if (Tx.HasPerShardKeysSizeLimitBytes()) {
-            PerShardKeysSizeLimitBytes_ = Tx.GetPerShardKeysSizeLimitBytes();
-        }
-
-        IsReadOnly = IsReadOnly && Tx.GetReadOnly();
-
+            EngineBay.SetUseLlvmRuntime(true); 
+        } 
+        if (Tx.HasPerShardKeysSizeLimitBytes()) { 
+            PerShardKeysSizeLimitBytes_ = Tx.GetPerShardKeysSizeLimitBytes(); 
+        } 
+
+        IsReadOnly = IsReadOnly && Tx.GetReadOnly(); 
+ 
         auto engine = EngineBay.GetEngine();
         auto result = engine->AddProgram(TabletId_, Tx.GetMiniKQL(), Tx.GetReadOnly());
 
@@ -200,10 +200,10 @@ TValidatedDataTx::~TValidatedDataTx() {
 }
 
 const google::protobuf::RepeatedPtrField<NYql::NDqProto::TDqTask>& TValidatedDataTx::GetKqpTasks() const {
-    Y_VERIFY(IsKqpTx());
+    Y_VERIFY(IsKqpTx()); 
     return Tx.GetKqpTransaction().GetTasks();
-}
-
+} 
+ 
 ui32 TValidatedDataTx::ExtractKeys(bool allowErrors)
 {
     using EResult = NMiniKQL::IEngineFlat::EResult;
@@ -267,7 +267,7 @@ ETxOrder TValidatedDataTx::CheckOrder(const TSysLocks& sysLocks, const TValidate
     return ETxOrder::Any;
 }
 
-bool TValidatedDataTx::CanCancel() {
+bool TValidatedDataTx::CanCancel() { 
     if (!IsTxReadOnly()) {
         return false;
     }
@@ -278,18 +278,18 @@ bool TValidatedDataTx::CanCancel() {
         }
     }
 
-    return true;
-}
-
-bool TValidatedDataTx::CheckCancelled() {
-    if (Cancelled) {
-        return true;
-    }
-
-    if (!CanCancel()) {
-        return false;
-    }
-
+    return true; 
+} 
+ 
+bool TValidatedDataTx::CheckCancelled() { 
+    if (Cancelled) { 
+        return true; 
+    } 
+ 
+    if (!CanCancel()) { 
+        return false; 
+    } 
+ 
     TInstant now = AppData()->TimeProvider->Now();
     Cancelled = (now >= Deadline());
 
diff --git a/ydb/core/tx/datashard/datashard_active_transaction.h b/ydb/core/tx/datashard/datashard_active_transaction.h
index 43abd525e1..7f5065a9a8 100644
--- a/ydb/core/tx/datashard/datashard_active_transaction.h
+++ b/ydb/core/tx/datashard/datashard_active_transaction.h
@@ -137,12 +137,12 @@ public:
     ui64 LockTxId() const { return Tx.GetLockTxId(); }
     ui64 ProgramSize() const { return Tx.GetMiniKQL().size(); }
     bool Immediate() const { return Tx.GetImmediate(); }
-    bool ReadOnly() const { return Tx.GetReadOnly(); }
+    bool ReadOnly() const { return Tx.GetReadOnly(); } 
     bool NeedDiagnostics() const { return Tx.GetNeedDiagnostics(); }
     bool CollectStats() const { return Tx.GetCollectStats(); }
     TInstant ReceivedAt() const { return ReceivedAt_; }
     TInstant Deadline() const { return Deadline_; }
-    TMaybe<ui64> PerShardKeysSizeLimitBytes() const { return PerShardKeysSizeLimitBytes_; }
+    TMaybe<ui64> PerShardKeysSizeLimitBytes() const { return PerShardKeysSizeLimitBytes_; } 
 
     bool Ready() const { return ErrCode == NKikimrTxDataShard::TError::OK; }
     bool RequirePrepare() const { return ErrCode == NKikimrTxDataShard::TError::SNAPSHOT_NOT_READY_YET; }
@@ -152,16 +152,16 @@ public:
     bool HasDynamicWrites() const { return TxInfo().DynKeysCount != 0; }
 
     // TODO: It's an expensive operation (Precharge() inside). We need avoid it.
-    TEngineBay::TSizes CalcReadSizes(bool needsTotalKeysSize) const { return EngineBay.CalcSizes(needsTotalKeysSize); }
+    TEngineBay::TSizes CalcReadSizes(bool needsTotalKeysSize) const { return EngineBay.CalcSizes(needsTotalKeysSize); } 
 
     ui64 GetMemoryAllocated() const {
-        if (!IsKqpDataTx()) {
-            const NMiniKQL::IEngineFlat * engine = EngineBay.GetEngine();
-            if (engine) {
-                return EngineBay.GetEngine()->GetMemoryAllocated();
-            }
-        }
-
+        if (!IsKqpDataTx()) { 
+            const NMiniKQL::IEngineFlat * engine = EngineBay.GetEngine(); 
+            if (engine) { 
+                return EngineBay.GetEngine()->GetMemoryAllocated(); 
+            } 
+        } 
+ 
         return 0;
     }
 
@@ -169,8 +169,8 @@ public:
     void DestroyEngine() { EngineBay.DestroyEngine(); }
     const NMiniKQL::TEngineHostCounters& GetCounters() { return EngineBay.GetCounters(); }
     void ResetCounters() { EngineBay.ResetCounters(); }
-
-    bool CanCancel();
+ 
+    bool CanCancel(); 
     bool CheckCancelled();
 
     void SetWriteVersion(TRowVersion writeVersion) { EngineBay.SetWriteVersion(writeVersion); }
@@ -185,21 +185,21 @@ public:
 
     bool IsTableRead() const { return Tx.HasReadTableTransaction(); }
 
-    bool IsKqpTx() const { return Tx.HasKqpTransaction(); }
-
-    bool IsKqpDataTx() const {
-        return IsKqpTx() && Tx.GetKqpTransaction().GetType() == NKikimrTxDataShard::KQP_TX_TYPE_DATA;
-    }
-
-    bool IsKqpScanTx() const {
-        return IsKqpTx() && Tx.GetKqpTransaction().GetType() == NKikimrTxDataShard::KQP_TX_TYPE_SCAN;
-    }
-
+    bool IsKqpTx() const { return Tx.HasKqpTransaction(); } 
+ 
+    bool IsKqpDataTx() const { 
+        return IsKqpTx() && Tx.GetKqpTransaction().GetType() == NKikimrTxDataShard::KQP_TX_TYPE_DATA; 
+    } 
+ 
+    bool IsKqpScanTx() const { 
+        return IsKqpTx() && Tx.GetKqpTransaction().GetType() == NKikimrTxDataShard::KQP_TX_TYPE_SCAN; 
+    } 
+ 
     const NKikimrTxDataShard::TKqpTransaction &GetKqpTransaction() const { return Tx.GetKqpTransaction(); }
     const google::protobuf::RepeatedPtrField<NYql::NDqProto::TDqTask>& GetKqpTasks() const;
     NKqp::TKqpTasksRunner& GetKqpTasksRunner() { Y_VERIFY(IsKqpDataTx()); return EngineBay.GetKqpTasksRunner(Tx.GetKqpTransaction()); }
     NMiniKQL::TKqpDatashardComputeContext& GetKqpComputeCtx() { Y_VERIFY(IsKqpDataTx()); return EngineBay.GetKqpComputeCtx(); }
-
+ 
     bool HasStreamResponse() const { return Tx.GetStreamResponse(); }
     TActorId GetSink() const { return ActorIdFromProto(Tx.GetSink()); }
     const NKikimrTxDataShard::TReadTableTransaction &GetReadTableTransaction() const { return Tx.GetReadTableTransaction(); }
@@ -219,8 +219,8 @@ public:
 
     bool IsTxInfoLoaded() const { return TxInfo().Loaded; }
 
-    bool IsTxReadOnly() const { return IsReadOnly; }
-
+    bool IsTxReadOnly() const { return IsReadOnly; } 
+ 
     bool HasOutReadsets() const { return TxInfo().HasOutReadsets; }
     bool HasInReadsets() const { return TxInfo().HasInReadsets; }
 
@@ -238,8 +238,8 @@ private:
     ui64 TxSize;
     ui64 TxCacheUsage;
     bool IsReleased;
-    TMaybe<ui64> PerShardKeysSizeLimitBytes_;
-    bool IsReadOnly;
+    TMaybe<ui64> PerShardKeysSizeLimitBytes_; 
+    bool IsReadOnly; 
     bool AllowCancelROwithReadsets;
     bool Cancelled;
     const TInstant ReceivedAt_; // For local timeout tracking
diff --git a/ydb/core/tx/datashard/datashard_failpoints.cpp b/ydb/core/tx/datashard/datashard_failpoints.cpp
index a8f785dab5..f2def8cd95 100644
--- a/ydb/core/tx/datashard/datashard_failpoints.cpp
+++ b/ydb/core/tx/datashard/datashard_failpoints.cpp
@@ -4,6 +4,6 @@ namespace NKikimr {
 namespace NDataShard {
 
 TCancelTxFailPoint gCancelTxFailPoint;
-TSkipRepliesFailPoint gSkipRepliesFailPoint;
+TSkipRepliesFailPoint gSkipRepliesFailPoint; 
 
 }}
diff --git a/ydb/core/tx/datashard/datashard_failpoints.h b/ydb/core/tx/datashard/datashard_failpoints.h
index f6b8cac58b..a716aabdde 100644
--- a/ydb/core/tx/datashard/datashard_failpoints.h
+++ b/ydb/core/tx/datashard/datashard_failpoints.h
@@ -66,60 +66,60 @@ struct TCancelTxFailPoint {
     }
 };
 
-// Allows to skip specified number of replies from datashard by TabletID and TxId
-struct TSkipRepliesFailPoint {
-    TAtomic Enabled;
-    TSpinLock Lock;
-    ui64 TabletId;
-    ui64 TxId;
-    ui64 RepliesToSkip;
-
-    TSkipRepliesFailPoint() {
-        Disable();
-    }
-
-    void Enable(ui64 tabletId, ui64 txId, ui64 count) {
-        Disable();
-
-        TGuard<TSpinLock> g(Lock);
-        TabletId = tabletId;
-        TxId = txId;
-        RepliesToSkip = count;
-
-        AtomicSet(Enabled, 1);
-    }
-
-    void Disable() {
-        TGuard<TSpinLock> g(Lock);
-
-        TabletId = 0;
-        TxId = 0;
-        RepliesToSkip = 0;
-
-        AtomicSet(Enabled, 0);
-    }
-
-    bool Check(ui64 tabletId, ui64 txId) {
-        if (!AtomicGet(Enabled)) {
-            return false;
-        }
-
-        TGuard<TSpinLock> g(Lock);
-
-        if ((tabletId != TabletId && TabletId != (ui64)-1) || (txId != TxId && TxId != (ui64)-1)) {
-            return false;
-        }
-
-        if (RepliesToSkip == 0) {
-            return false;
-        }
-
-        --RepliesToSkip;
-        return true;
-    }
-};
-
+// Allows to skip specified number of replies from datashard by TabletID and TxId 
+struct TSkipRepliesFailPoint { 
+    TAtomic Enabled; 
+    TSpinLock Lock; 
+    ui64 TabletId; 
+    ui64 TxId; 
+    ui64 RepliesToSkip; 
+ 
+    TSkipRepliesFailPoint() { 
+        Disable(); 
+    } 
+ 
+    void Enable(ui64 tabletId, ui64 txId, ui64 count) { 
+        Disable(); 
+ 
+        TGuard<TSpinLock> g(Lock); 
+        TabletId = tabletId; 
+        TxId = txId; 
+        RepliesToSkip = count; 
+ 
+        AtomicSet(Enabled, 1); 
+    } 
+ 
+    void Disable() { 
+        TGuard<TSpinLock> g(Lock); 
+ 
+        TabletId = 0; 
+        TxId = 0; 
+        RepliesToSkip = 0; 
+ 
+        AtomicSet(Enabled, 0); 
+    } 
+ 
+    bool Check(ui64 tabletId, ui64 txId) { 
+        if (!AtomicGet(Enabled)) { 
+            return false; 
+        } 
+ 
+        TGuard<TSpinLock> g(Lock); 
+ 
+        if ((tabletId != TabletId && TabletId != (ui64)-1) || (txId != TxId && TxId != (ui64)-1)) { 
+            return false; 
+        } 
+ 
+        if (RepliesToSkip == 0) { 
+            return false; 
+        } 
+ 
+        --RepliesToSkip; 
+        return true; 
+    } 
+}; 
+ 
 extern TCancelTxFailPoint gCancelTxFailPoint;
-extern TSkipRepliesFailPoint gSkipRepliesFailPoint;
+extern TSkipRepliesFailPoint gSkipRepliesFailPoint; 
 
 }}
diff --git a/ydb/core/tx/datashard/datashard_impl.h b/ydb/core/tx/datashard/datashard_impl.h
index 11313474f8..391549b769 100644
--- a/ydb/core/tx/datashard/datashard_impl.h
+++ b/ydb/core/tx/datashard/datashard_impl.h
@@ -227,7 +227,7 @@ class TDataShard
     friend class TScanTransactionProcessor;
     friend class TDataShardEngineHost;
     friend class TTxS3Listing;
-    friend class TExecuteKqpScanTxUnit;
+    friend class TExecuteKqpScanTxUnit; 
     friend class TTableScan;
     friend class TKqpScan;
 
@@ -1186,12 +1186,12 @@ public:
 
     const THashMap<ui64, TUserTable::TCPtr> &GetUserTables() const { return TableInfos; }
 
-    ui64 GetLocalTableId(const TTableId& tableId) const {
-        Y_VERIFY(!TSysTables::IsSystemTable(tableId));
+    ui64 GetLocalTableId(const TTableId& tableId) const { 
+        Y_VERIFY(!TSysTables::IsSystemTable(tableId)); 
         auto it = TableInfos.find(tableId.PathId.LocalPathId);
         return it == TableInfos.end() ? 0 : it->second->LocalTid;
-    }
-
+    } 
+ 
     ui64 GetShadowTableId(const TTableId& tableId) const {
         Y_VERIFY(!TSysTables::IsSystemTable(tableId));
         auto it = TableInfos.find(tableId.PathId.LocalPathId);
@@ -2423,8 +2423,8 @@ protected:
     void ResolveTablePath(const TActorContext &ctx);
 };
 
-NKikimrTxDataShard::TError::EKind ConvertErrCode(NMiniKQL::IEngineFlat::EResult code);
-
+NKikimrTxDataShard::TError::EKind ConvertErrCode(NMiniKQL::IEngineFlat::EResult code); 
+ 
 Ydb::StatusIds::StatusCode ConvertToYdbStatusCode(NKikimrTxDataShard::TError::EKind);
 
 template <class T>
diff --git a/ydb/core/tx/datashard/datashard_kqp.cpp b/ydb/core/tx/datashard/datashard_kqp.cpp
index a262c98de5..54ffbc9ec3 100644
--- a/ydb/core/tx/datashard/datashard_kqp.cpp
+++ b/ydb/core/tx/datashard/datashard_kqp.cpp
@@ -1,162 +1,162 @@
-#include "datashard_kqp.h"
+#include "datashard_kqp.h" 
 #include "datashard_impl.h"
-
+ 
 #include <ydb/core/kqp/kqp.h>
 #include <ydb/core/kqp/runtime/kqp_tasks_runner.h>
 #include <ydb/core/scheme/scheme_tablecell.h>
 #include <ydb/core/tx/datashard/datashard_locks.h>
 #include <ydb/core/tx/datashard/datashard_user_table.h>
 #include <ydb/core/tx/datashard/range_ops.h>
-
+ 
 #include <ydb/library/yql/dq/actors/compute/dq_compute_actor.h>
 #include <ydb/library/yql/dq/runtime/dq_transport.h>
 
 #include <util/generic/size_literals.h>
 
-namespace NKikimr {
+namespace NKikimr { 
 namespace NDataShard {
-
-namespace {
-
-const ui32 MaxDatashardReplySize = 48 * 1024 * 1024; // 48 MB
-
+ 
+namespace { 
+ 
+const ui32 MaxDatashardReplySize = 48 * 1024 * 1024; // 48 MB 
+ 
 using namespace NYql;
 
 bool KqpValidateTask(const NYql::NDqProto::TDqTask& task, bool isImmediate, ui64 txId, const TActorContext& ctx,
     bool& hasPersistentChannels)
-{
-    for (auto& input : task.GetInputs()) {
-        for (auto& channel : input.GetChannels()) {
-            if (channel.GetIsPersistent()) {
+{ 
+    for (auto& input : task.GetInputs()) { 
+        for (auto& channel : input.GetChannels()) { 
+            if (channel.GetIsPersistent()) { 
                 hasPersistentChannels = true;
-                if (isImmediate) {
-                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP validate, txId: " << txId
-                        << ", immediate KQP transaction cannot have persistent input channels"
-                        << ", task: " << task.GetId()
-                        << ", channelId: " << channel.GetId());
-                    return false;
-                }
-
-                if (!channel.GetSrcEndpoint().HasTabletId()) {
-                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP validate, txId: " << txId
+                if (isImmediate) { 
+                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP validate, txId: " << txId 
+                        << ", immediate KQP transaction cannot have persistent input channels" 
+                        << ", task: " << task.GetId() 
+                        << ", channelId: " << channel.GetId()); 
+                    return false; 
+                } 
+ 
+                if (!channel.GetSrcEndpoint().HasTabletId()) { 
+                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP validate, txId: " << txId 
                         << ", persistent input channel without src tablet id"
-                        << ", task: " << task.GetId()
-                        << ", channelId: " << channel.GetId());
-                    return false;
-                }
-            }
-        }
-    }
-
-    for (auto& output : task.GetOutputs()) {
-        for (auto& channel : output.GetChannels()) {
-            if (channel.GetIsPersistent()) {
+                        << ", task: " << task.GetId() 
+                        << ", channelId: " << channel.GetId()); 
+                    return false; 
+                } 
+            } 
+        } 
+    } 
+ 
+    for (auto& output : task.GetOutputs()) { 
+        for (auto& channel : output.GetChannels()) { 
+            if (channel.GetIsPersistent()) { 
                 hasPersistentChannels = true;
-                if (isImmediate) {
-                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP validate, txId: " << txId
-                        << ", immediate KQP transaction cannot have persistent output channels"
-                        << ", task: " << task.GetId()
-                        << ", channelId: " << channel.GetId());
-                    return false;
-                }
-
-                if (!channel.GetDstEndpoint().HasTabletId()) {
-                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP validate, txId: " << txId
+                if (isImmediate) { 
+                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP validate, txId: " << txId 
+                        << ", immediate KQP transaction cannot have persistent output channels" 
+                        << ", task: " << task.GetId() 
+                        << ", channelId: " << channel.GetId()); 
+                    return false; 
+                } 
+ 
+                if (!channel.GetDstEndpoint().HasTabletId()) { 
+                    LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "KQP validate, txId: " << txId 
                         << ", persistent output channel without dst tablet id"
-                        << ", task: " << task.GetId()
-                        << ", channelId: " << channel.GetId());
-                    return false;
-                }
-            }
-        }
-    }
-
-    return true;
-}
-
+                        << ", task: " << task.GetId() 
+                        << ", channelId: " << channel.GetId()); 
+                    return false; 
+                } 
+            } 
+        } 
+    } 
+ 
+    return true; 
+} 
+ 
 NUdf::EFetchStatus FetchAllOutput(NDq::IDqOutputChannel* channel, NDqProto::TData& buffer) {
     auto result = channel->PopAll(buffer);
     Y_UNUSED(result);
 
     if (channel->IsFinished()) {
         return NUdf::EFetchStatus::Finish;
-    }
-
+    } 
+ 
     return NUdf::EFetchStatus::Yield;
-}
-
+} 
+ 
 NDq::ERunStatus RunKqpTransactionInternal(const TActorContext& ctx, ui64 txId,
     const TInputOpData::TInReadSets* inReadSets, const google::protobuf::RepeatedPtrField<NDqProto::TDqTask>& tasks,
     NKqp::TKqpTasksRunner& tasksRunner, bool applyEffects)
 {
     THashMap<ui64, std::pair<ui64, ui32>> inputChannelsMap; // channelId -> (taskId, input index)
-    for (auto& task : tasks) {
-        for (ui32 i = 0; i < task.InputsSize(); ++i) {
-            auto& input = task.GetInputs(i);
-            for (auto& channel : input.GetChannels()) {
-                auto channelInfo = std::make_pair(task.GetId(), i);
+    for (auto& task : tasks) { 
+        for (ui32 i = 0; i < task.InputsSize(); ++i) { 
+            auto& input = task.GetInputs(i); 
+            for (auto& channel : input.GetChannels()) { 
+                auto channelInfo = std::make_pair(task.GetId(), i); 
                 auto result = inputChannelsMap.emplace(channel.GetId(), channelInfo);
-                MKQL_ENSURE_S(result.second);
-            }
-        }
-    }
-
-    if (inReadSets) {
+                MKQL_ENSURE_S(result.second); 
+            } 
+        } 
+    } 
+ 
+    if (inReadSets) { 
         YQL_ENSURE(applyEffects);
 
-        for (auto& readSet : *inReadSets) {
-            auto& key = readSet.first;
-            auto& dataList = readSet.second;
-
-            ui64 source = key.first;
-            ui64 target = key.second;
-
-            for (auto& data : dataList) {
-                NKikimrTxDataShard::TKqpReadset kqpReadset;
+        for (auto& readSet : *inReadSets) { 
+            auto& key = readSet.first; 
+            auto& dataList = readSet.second; 
+ 
+            ui64 source = key.first; 
+            ui64 target = key.second; 
+ 
+            for (auto& data : dataList) { 
+                NKikimrTxDataShard::TKqpReadset kqpReadset; 
                 Y_PROTOBUF_SUPPRESS_NODISCARD kqpReadset.ParseFromString(data.Body);
-
+ 
                 for (int outputId = 0; outputId < kqpReadset.GetOutputs().size(); ++outputId) {
                     auto* channelData = kqpReadset.MutableOutputs()->Mutable(outputId);
                     auto channelId = channelData->GetChannelId();
-                    auto inputInfo = inputChannelsMap.FindPtr(channelId);
-                    MKQL_ENSURE_S(inputInfo);
-
-                    auto taskId = inputInfo->first;
-
-                    LOG_DEBUG_S(ctx, NKikimrServices::TX_DATASHARD, "Added KQP readset"
+                    auto inputInfo = inputChannelsMap.FindPtr(channelId); 
+                    MKQL_ENSURE_S(inputInfo); 
+ 
+                    auto taskId = inputInfo->first; 
+ 
+                    LOG_DEBUG_S(ctx, NKikimrServices::TX_DATASHARD, "Added KQP readset" 
                         << ", source: " << source << ", target: " << target << ", origin: " << data.Origin
                         << ", TxId: " << txId << ", task: " << taskId << ", channelId: " << channelId);
-
+ 
                     auto channel = tasksRunner.GetInputChannel(taskId, channelId);
                     channel->Push(std::move(*(channelData->MutableData())));
-
+ 
                     MKQL_ENSURE_S(channelData->GetFinished());
                     channel->Finish();
-                }
-            }
-        }
-    }
-
+                } 
+            } 
+        } 
+    } 
+ 
     auto runStatus = NDq::ERunStatus::PendingInput;
-    bool hasInputChanges = true;
-
+    bool hasInputChanges = true; 
+ 
     while (runStatus == NDq::ERunStatus::PendingInput && hasInputChanges) {
-        runStatus = tasksRunner.Run(applyEffects);
+        runStatus = tasksRunner.Run(applyEffects); 
         if (runStatus == NDq::ERunStatus::Finished) {
-            break;
-        }
-
+            break; 
+        } 
+ 
         // we must set output buffers big enough to avoid PendingOutput state here
         MKQL_ENSURE_S(runStatus == NDq::ERunStatus::PendingInput);
-
-        hasInputChanges = false;
-        for (auto& task : tasks) {
-            for (ui32 i = 0; i < task.OutputsSize(); ++i) {
-                for (auto& channel : task.GetOutputs(i).GetChannels()) {
+ 
+        hasInputChanges = false; 
+        for (auto& task : tasks) { 
+            for (ui32 i = 0; i < task.OutputsSize(); ++i) { 
+                for (auto& channel : task.GetOutputs(i).GetChannels()) { 
                     if (auto* inputInfo = inputChannelsMap.FindPtr(channel.GetId())) {
                         auto transferState = tasksRunner.TransferData(task.GetId(), channel.GetId(),
                             inputInfo->first, channel.GetId());
-
+ 
                         if (transferState.first) {
                             hasInputChanges = true;
                             LOG_TRACE_S(ctx, NKikimrServices::TX_DATASHARD, "Forwarded KQP channel data"
@@ -164,23 +164,23 @@ NDq::ERunStatus RunKqpTransactionInternal(const TActorContext& ctx, ui64 txId,
                                 << ", srcTask: " << task.GetId() << ", dstTask: " << inputInfo->first
                                 << ", channelId: " << channel.GetId());
                         }
-
+ 
                         if (transferState.second) {
                             hasInputChanges = true;
                             LOG_TRACE_S(ctx, NKikimrServices::TX_DATASHARD, "Finished input channel"
                                 << ", TxId: " << txId
                                 << ", srcTask: " << task.GetId() << ", dstTask: " << inputInfo->first
                                 << ", channelId: " << channel.GetId());
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    return runStatus;
-}
-
+                        } 
+                    } 
+                } 
+            } 
+        } 
+    } 
+ 
+    return runStatus; 
+} 
+ 
 bool NeedValidateLocks(NKikimrTxDataShard::TKqpLocks_ELocksOp op) {
     switch (op) {
         case NKikimrTxDataShard::TKqpLocks::ValidateAndErase:
@@ -228,55 +228,55 @@ TVector<TCell> MakeLockKey(const NKikimrTxDataShard::TLock& lockProto) {
 // returns list of broken locks
 TVector<NKikimrTxDataShard::TLock> ValidateLocks(const NKikimrTxDataShard::TKqpLocks& txLocks, TSysLocks& sysLocks,
     ui64 tabletId)
-{
+{ 
     TVector<NKikimrTxDataShard::TLock> brokenLocks;
 
     if (!NeedValidateLocks(txLocks.GetOp())) {
         return {};
     }
 
-    for (auto& lockProto : txLocks.GetLocks()) {
-        if (lockProto.GetDataShard() != tabletId) {
-            continue;
-        }
-
+    for (auto& lockProto : txLocks.GetLocks()) { 
+        if (lockProto.GetDataShard() != tabletId) { 
+            continue; 
+        } 
+ 
         auto lockKey = MakeLockKey(lockProto);
-
-        auto lock = sysLocks.GetLock(lockKey);
-        if (lock.Generation != lockProto.GetGeneration() || lock.Counter != lockProto.GetCounter()) {
+ 
+        auto lock = sysLocks.GetLock(lockKey); 
+        if (lock.Generation != lockProto.GetGeneration() || lock.Counter != lockProto.GetCounter()) { 
             brokenLocks.push_back(lockProto);
-        }
-    }
-
+        } 
+    } 
+ 
     return brokenLocks;
-}
-
+} 
+ 
 bool SendLocks(const NKikimrTxDataShard::TKqpLocks& locks, ui64 shardId) {
     auto& sendingShards = locks.GetSendingShards();
-    auto it = std::find(sendingShards.begin(), sendingShards.end(), shardId);
-    return it != sendingShards.end();
-}
-
+    auto it = std::find(sendingShards.begin(), sendingShards.end(), shardId); 
+    return it != sendingShards.end(); 
+} 
+ 
 bool ReceiveLocks(const NKikimrTxDataShard::TKqpLocks& locks, ui64 shardId) {
     auto& receivingShards = locks.GetReceivingShards();
-    auto it = std::find(receivingShards.begin(), receivingShards.end(), shardId);
-    return it != receivingShards.end();
-}
-
-} // namespace
-
+    auto it = std::find(receivingShards.begin(), receivingShards.end(), shardId); 
+    return it != receivingShards.end(); 
+} 
+ 
+} // namespace 
+ 
 bool KqpValidateTransaction(const NKikimrTxDataShard::TKqpTransaction& tx, bool isImmediate, ui64 txId,
     const TActorContext& ctx, bool& hasPersistentChannels)
-{
+{ 
     for (const auto& task : tx.GetTasks()) {
         if (!KqpValidateTask(task, isImmediate, txId, ctx, hasPersistentChannels)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
+            return false; 
+        } 
+    } 
+ 
+    return true; 
+} 
+ 
 namespace {
 
 template <bool Read>
@@ -406,31 +406,31 @@ void KqpSetTxLocksKeys(const NKikimrTxDataShard::TKqpLocks& locks, const TSysLoc
 
 NYql::NDq::ERunStatus KqpRunTransaction(const TActorContext& ctx, ui64 txId,
     const google::protobuf::RepeatedPtrField<NYql::NDqProto::TDqTask>& tasks, NKqp::TKqpTasksRunner& tasksRunner)
-{
+{ 
     return RunKqpTransactionInternal(ctx, txId, /* inReadSets */ nullptr, tasks, tasksRunner, /* applyEffects */ false);
-}
-
-THolder<TEvDataShard::TEvProposeTransactionResult> KqpCompleteTransaction(const TActorContext& ctx,
-    ui64 origin, ui64 txId, const TInputOpData::TInReadSets* inReadSets,
+} 
+ 
+THolder<TEvDataShard::TEvProposeTransactionResult> KqpCompleteTransaction(const TActorContext& ctx, 
+    ui64 origin, ui64 txId, const TInputOpData::TInReadSets* inReadSets, 
     const google::protobuf::RepeatedPtrField<NDqProto::TDqTask>& tasks, NKqp::TKqpTasksRunner& tasksRunner,
     const NMiniKQL::TKqpDatashardComputeContext& computeCtx)
-{
+{ 
     auto runStatus = RunKqpTransactionInternal(ctx, txId, inReadSets, tasks, tasksRunner, /* applyEffects */ true);
-
+ 
     if (runStatus == NYql::NDq::ERunStatus::PendingInput && computeCtx.IsTabletNotReady()) {
         return nullptr;
     }
 
     MKQL_ENSURE_S(runStatus == NYql::NDq::ERunStatus::Finished);
-
-    auto result = MakeHolder<TEvDataShard::TEvProposeTransactionResult>(NKikimrTxDataShard::TX_KIND_DATA,
-        origin, txId, NKikimrTxDataShard::TEvProposeTransactionResult::COMPLETE);
-
-    for (auto& task : tasks) {
+ 
+    auto result = MakeHolder<TEvDataShard::TEvProposeTransactionResult>(NKikimrTxDataShard::TX_KIND_DATA, 
+        origin, txId, NKikimrTxDataShard::TEvProposeTransactionResult::COMPLETE); 
+ 
+    for (auto& task : tasks) { 
         auto& taskRunner = tasksRunner.GetTaskRunner(task.GetId());
-
-        for (ui32 i = 0; i < task.OutputsSize(); ++i) {
-            for (auto& channel : task.GetOutputs(i).GetChannels()) {
+ 
+        for (ui32 i = 0; i < task.OutputsSize(); ++i) { 
+            for (auto& channel : task.GetOutputs(i).GetChannels()) { 
                 auto computeActor = computeCtx.GetTaskOutputChannel(task.GetId(), channel.GetId());
                 if (computeActor) {
                     auto dataEv = MakeHolder<NYql::NDq::TEvDqCompute::TEvChannelData>();
@@ -439,84 +439,84 @@ THolder<TEvDataShard::TEvProposeTransactionResult> KqpCompleteTransaction(const
                     dataEv->Record.MutableChannelData()->SetFinished(true);
                     dataEv->Record.SetNoAck(true);
                     auto outputData = dataEv->Record.MutableChannelData()->MutableData();
-
+ 
                     auto fetchStatus = FetchAllOutput(taskRunner.GetOutputChannel(channel.GetId()).Get(), *outputData);
                     MKQL_ENSURE_S(fetchStatus == NUdf::EFetchStatus::Finish);
 
-                    if (outputData->GetRaw().size() > MaxDatashardReplySize) {
-                        auto message = TStringBuilder() << "Datashard " << origin
-                            << ": reply size limit exceeded (" << outputData->GetRaw().size() << " > "
-                            << MaxDatashardReplySize << ")";
-
-                        LOG_WARN_S(*TlsActivationContext, NKikimrServices::TX_DATASHARD, message);
-                        result->SetExecutionError(NKikimrTxDataShard::TError::REPLY_SIZE_EXECEEDED, message);
-                    } else {
-                        ctx.Send(computeActor, dataEv.Release());
-                    }
+                    if (outputData->GetRaw().size() > MaxDatashardReplySize) { 
+                        auto message = TStringBuilder() << "Datashard " << origin 
+                            << ": reply size limit exceeded (" << outputData->GetRaw().size() << " > " 
+                            << MaxDatashardReplySize << ")"; 
+ 
+                        LOG_WARN_S(*TlsActivationContext, NKikimrServices::TX_DATASHARD, message); 
+                        result->SetExecutionError(NKikimrTxDataShard::TError::REPLY_SIZE_EXECEEDED, message); 
+                    } else { 
+                        ctx.Send(computeActor, dataEv.Release()); 
+                    } 
                 } else {
                     NDqProto::TData outputData;
                     auto fetchStatus = FetchAllOutput(taskRunner.GetOutputChannel(channel.GetId()).Get(), outputData);
                     MKQL_ENSURE_S(fetchStatus == NUdf::EFetchStatus::Finish);
                     MKQL_ENSURE_S(outputData.GetRows() == 0);
                 }
-            }
-        }
-    }
-
-    TString replyStr;
+            } 
+        } 
+    } 
+ 
+    TString replyStr; 
     NKikimrTxDataShard::TKqpReply reply;
     Y_PROTOBUF_SUPPRESS_NODISCARD reply.SerializeToString(&replyStr);
-
-    result->SetTxResult(replyStr);
-    return result;
-}
-
+ 
+    result->SetTxResult(replyStr); 
+    return result; 
+} 
+ 
 void KqpFillOutReadSets(TOutputOpData::TOutReadSets& outReadSets, const NKikimrTxDataShard::TKqpTransaction& kqpTx,
     NKqp::TKqpTasksRunner& tasksRunner, TSysLocks& sysLocks, ui64 tabletId)
-{
-    TMap<std::pair<ui64, ui64>, NKikimrTxDataShard::TKqpReadset> readsetData;
-
-    for (auto& task : kqpTx.GetTasks()) {
+{ 
+    TMap<std::pair<ui64, ui64>, NKikimrTxDataShard::TKqpReadset> readsetData; 
+ 
+    for (auto& task : kqpTx.GetTasks()) { 
         auto& taskRunner = tasksRunner.GetTaskRunner(task.GetId());
-
-        for (ui32 i = 0; i < task.OutputsSize(); ++i) {
-            for (auto& channel : task.GetOutputs(i).GetChannels()) {
-                if (channel.GetIsPersistent()) {
+ 
+        for (ui32 i = 0; i < task.OutputsSize(); ++i) { 
+            for (auto& channel : task.GetOutputs(i).GetChannels()) { 
+                if (channel.GetIsPersistent()) { 
                     MKQL_ENSURE_S(channel.GetSrcEndpoint().HasTabletId());
                     MKQL_ENSURE_S(channel.GetDstEndpoint().HasTabletId());
-
+ 
                     NDqProto::TData outputData;
                     auto fetchStatus = FetchAllOutput(taskRunner.GetOutputChannel(channel.GetId()).Get(), outputData);
-                    MKQL_ENSURE_S(fetchStatus == NUdf::EFetchStatus::Finish);
-
-                    auto key = std::make_pair(channel.GetSrcEndpoint().GetTabletId(),
-                        channel.GetDstEndpoint().GetTabletId());
-                    auto& channelData = *readsetData[key].AddOutputs();
-
-                    channelData.SetChannelId(channel.GetId());
-                    channelData.SetFinished(true);
+                    MKQL_ENSURE_S(fetchStatus == NUdf::EFetchStatus::Finish); 
+ 
+                    auto key = std::make_pair(channel.GetSrcEndpoint().GetTabletId(), 
+                        channel.GetDstEndpoint().GetTabletId()); 
+                    auto& channelData = *readsetData[key].AddOutputs(); 
+ 
+                    channelData.SetChannelId(channel.GetId()); 
+                    channelData.SetFinished(true); 
                     channelData.MutableData()->Swap(&outputData);
-                }
-            }
-        }
-    }
-
+                } 
+            } 
+        } 
+    } 
+ 
     if (kqpTx.HasLocks() && NeedValidateLocks(kqpTx.GetLocks().GetOp())) {
         bool sendLocks = SendLocks(kqpTx.GetLocks(), tabletId);
         YQL_ENSURE(sendLocks == !kqpTx.GetLocks().GetLocks().empty());
-
+ 
         if (sendLocks && !kqpTx.GetLocks().GetReceivingShards().empty()) {
             auto brokenLocks = ValidateLocks(kqpTx.GetLocks(), sysLocks, tabletId);
-
-            NKikimrTxDataShard::TKqpValidateLocksResult validateLocksResult;
+ 
+            NKikimrTxDataShard::TKqpValidateLocksResult validateLocksResult; 
             validateLocksResult.SetSuccess(brokenLocks.empty());
 
             for (auto& lock : brokenLocks) {
                 LOG_TRACE_S(*TlsActivationContext, NKikimrServices::TX_DATASHARD,
                     "Found broken lock: " << lock.ShortDebugString());
                 validateLocksResult.AddBrokenLocks()->Swap(&lock);
-            }
-
+            } 
+ 
             for (auto& dstTabletId : kqpTx.GetLocks().GetReceivingShards()) {
                 if (tabletId == dstTabletId) {
                     continue;
@@ -526,19 +526,19 @@ void KqpFillOutReadSets(TOutputOpData::TOutReadSets& outReadSets, const NKikimrT
                     << tabletId << " to " << dstTabletId << ", locks: " << validateLocksResult.ShortDebugString());
 
                 auto key = std::make_pair(tabletId, dstTabletId);
-                readsetData[key].MutableValidateLocksResult()->CopyFrom(validateLocksResult);
-            }
-        }
-    }
-
+                readsetData[key].MutableValidateLocksResult()->CopyFrom(validateLocksResult); 
+            } 
+        } 
+    } 
+ 
     for (auto& [key, data] : readsetData) {
-        TString bodyStr;
+        TString bodyStr; 
         Y_PROTOBUF_SUPPRESS_NODISCARD data.SerializeToString(&bodyStr);
-
-        outReadSets[key] = bodyStr;
-    }
-}
-
+ 
+        outReadSets[key] = bodyStr; 
+    } 
+} 
+ 
 bool KqpValidateLocks(ui64 origin, TActiveTransaction* tx, TSysLocks& sysLocks) {
     auto& kqpTx = tx->GetDataTx()->GetKqpTransaction();
 
@@ -569,30 +569,30 @@ bool KqpValidateLocks(ui64 origin, TActiveTransaction* tx, TSysLocks& sysLocks)
     }
 
     for (auto& readSet : tx->InReadSets()) {
-        for (auto& data : readSet.second) {
-            NKikimrTxDataShard::TKqpReadset kqpReadset;
+        for (auto& data : readSet.second) { 
+            NKikimrTxDataShard::TKqpReadset kqpReadset; 
             Y_PROTOBUF_SUPPRESS_NODISCARD kqpReadset.ParseFromString(data.Body);
-
-            if (kqpReadset.HasValidateLocksResult()) {
-                auto& validateResult = kqpReadset.GetValidateLocksResult();
-                if (!validateResult.GetSuccess()) {
+ 
+            if (kqpReadset.HasValidateLocksResult()) { 
+                auto& validateResult = kqpReadset.GetValidateLocksResult(); 
+                if (!validateResult.GetSuccess()) { 
                     tx->Result() = MakeHolder<TEvDataShard::TEvProposeTransactionResult>(
-                        NKikimrTxDataShard::TX_KIND_DATA,
-                        origin,
+                        NKikimrTxDataShard::TX_KIND_DATA, 
+                        origin, 
                         tx->GetTxId(),
-                        NKikimrTxDataShard::TEvProposeTransactionResult::LOCKS_BROKEN);
-
+                        NKikimrTxDataShard::TEvProposeTransactionResult::LOCKS_BROKEN); 
+ 
                     tx->Result()->Record.MutableTxLocks()->CopyFrom(validateResult.GetBrokenLocks());
-
-                    return false;
-                }
-            }
-        }
-    }
-
-    return true;
-}
-
+ 
+                    return false; 
+                } 
+            } 
+        } 
+    } 
+ 
+    return true; 
+} 
+ 
 void KqpEraseLocks(ui64 origin, TActiveTransaction* tx, TSysLocks& sysLocks) {
     auto& kqpTx = tx->GetDataTx()->GetKqpTransaction();
 
@@ -613,24 +613,24 @@ void KqpEraseLocks(ui64 origin, TActiveTransaction* tx, TSysLocks& sysLocks) {
 }
 
 void KqpPrepareInReadsets(TInputOpData::TInReadSets& inReadSets,
-    const NKikimrTxDataShard::TKqpTransaction& kqpTx, ui64 tabletId)
-{
-    for (auto& task : kqpTx.GetTasks()) {
-        for (ui32 i = 0; i < task.InputsSize(); ++i) {
-            for (auto& channel : task.GetInputs(i).GetChannels()) {
-                if (channel.GetIsPersistent()) {
+    const NKikimrTxDataShard::TKqpTransaction& kqpTx, ui64 tabletId) 
+{ 
+    for (auto& task : kqpTx.GetTasks()) { 
+        for (ui32 i = 0; i < task.InputsSize(); ++i) { 
+            for (auto& channel : task.GetInputs(i).GetChannels()) { 
+                if (channel.GetIsPersistent()) { 
                     MKQL_ENSURE_S(channel.GetSrcEndpoint().HasTabletId());
                     MKQL_ENSURE_S(channel.GetDstEndpoint().HasTabletId());
-
-                    auto key = std::make_pair(channel.GetSrcEndpoint().GetTabletId(),
-                        channel.GetDstEndpoint().GetTabletId());
+ 
+                    auto key = std::make_pair(channel.GetSrcEndpoint().GetTabletId(), 
+                        channel.GetDstEndpoint().GetTabletId()); 
 
                     inReadSets.emplace(key, TVector<TRSData>());
-                }
-            }
-        }
-    }
-
+                } 
+            } 
+        } 
+    } 
+ 
     if (ReceiveLocks(kqpTx.GetLocks(), tabletId)) {
         for (ui64 shardId : kqpTx.GetLocks().GetSendingShards()) {
             if (shardId == tabletId) {
@@ -640,12 +640,12 @@ void KqpPrepareInReadsets(TInputOpData::TInReadSets& inReadSets,
             LOG_TRACE_S(*TlsActivationContext, NKikimrServices::TX_DATASHARD, "Prepare InReadsets from " << shardId
                 << " to " << tabletId);
 
-            auto key = std::make_pair(shardId, tabletId);
+            auto key = std::make_pair(shardId, tabletId); 
             inReadSets.emplace(key, TVector<TRSData>());
-        }
-    }
-}
-
+        } 
+    } 
+} 
+ 
 void KqpUpdateDataShardStatCounters(TDataShard& dataShard, const NMiniKQL::TEngineHostCounters& counters) {
     dataShard.IncCounter(COUNTER_ENGINE_HOST_SELECT_ROW, counters.NSelectRow);
     dataShard.IncCounter(COUNTER_ENGINE_HOST_SELECT_RANGE, counters.NSelectRange);
@@ -667,7 +667,7 @@ void KqpUpdateDataShardStatCounters(TDataShard& dataShard, const NMiniKQL::TEngi
 
 void KqpFillTxStats(TDataShard& dataShard, const NMiniKQL::TEngineHostCounters& counters,
     TEvDataShard::TEvProposeTransactionResult& result)
-{
+{ 
     auto& stats = *result.Record.MutableTxStats();
     auto& perTable = *stats.AddTableAccessStats();
     perTable.MutableTableInfo()->SetSchemeshardId(dataShard.GetPathOwnerId());
@@ -696,16 +696,16 @@ void KqpFillTxStats(TDataShard& dataShard, const NMiniKQL::TEngineHostCounters&
         perTable.MutableEraseRow()->SetBytes(counters.EraseRowBytes);
     }
 }
-
+ 
 void KqpFillStats(TDataShard& dataShard, const NKqp::TKqpTasksRunner& tasksRunner,
     NMiniKQL::TKqpDatashardComputeContext& computeCtx, const NYql::NDqProto::EDqStatsMode& statsMode,
     TEvDataShard::TEvProposeTransactionResult& result)
 {
     Y_VERIFY(dataShard.GetUserTables().size() == 1, "TODO: Fix handling of collocated tables");
     auto tableInfo = dataShard.GetUserTables().begin();
-
+ 
     bool withProfileStats = statsMode >= NYql::NDqProto::DQ_STATS_MODE_PROFILE;
-
+ 
     auto& computeActorStats = *result.Record.MutableComputeActorStats();
 
     ui64 minFirstRowTimeMs = std::numeric_limits<ui64>::max();
@@ -741,11 +741,11 @@ void KqpFillStats(TDataShard& dataShard, const NKqp::TKqpTasksRunner& tasksRunne
 
     if (maxFinishTimeMs >= minFirstRowTimeMs) {
         computeActorStats.SetDurationUs((maxFinishTimeMs - minFirstRowTimeMs) * 1'000);
-    }
-
+    } 
+ 
     // TODO: fill profile stats
-}
-
+} 
+ 
 NYql::NDq::TDqTaskRunnerMemoryLimits DefaultKqpDataReqMemoryLimits() {
     NYql::NDq::TDqTaskRunnerMemoryLimits memoryLimits;
     // Data queries require output channel to be drained only once, and it must contain complete result
@@ -781,4 +781,4 @@ THolder<NYql::NDq::IDqTaskRunnerExecutionContext> DefaultKqpExecutionContext() {
 }
 
 } // namespace NDataShard
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/tx/datashard/datashard_kqp.h b/ydb/core/tx/datashard/datashard_kqp.h
index 228f71fd37..43c535627b 100644
--- a/ydb/core/tx/datashard/datashard_kqp.h
+++ b/ydb/core/tx/datashard/datashard_kqp.h
@@ -1,19 +1,19 @@
-#pragma once
-
-#include "datashard.h"
-#include "datashard_active_transaction.h"
-
+#pragma once 
+ 
+#include "datashard.h" 
+#include "datashard_active_transaction.h" 
+ 
 #include <ydb/core/engine/minikql/minikql_engine_host.h>
 #include <ydb/core/kqp/runtime/kqp_tasks_runner.h>
-
-#include <util/generic/ptr.h>
-
-namespace NKikimr {
+ 
+#include <util/generic/ptr.h> 
+ 
+namespace NKikimr { 
 namespace NDataShard {
-
+ 
 bool KqpValidateTransaction(const NKikimrTxDataShard::TKqpTransaction& tx, bool isImmediate,
     ui64 txId, const TActorContext& ctx, bool& hasPersistentChannels);
-
+ 
 void KqpSetTxKeys(ui64 tabletId, ui64 taskId, const TUserTable* tableInfo,
     const NKikimrTxDataShard::TKqpTransaction_TDataTaskMeta& meta, const NScheme::TTypeRegistry& typeRegistry,
     const TActorContext& ctx, TEngineBay& engineBay);
@@ -22,24 +22,24 @@ void KqpSetTxLocksKeys(const NKikimrTxDataShard::TKqpLocks& locks, const TSysLoc
 
 NYql::NDq::ERunStatus KqpRunTransaction(const TActorContext& ctx, ui64 txId,
     const google::protobuf::RepeatedPtrField<NYql::NDqProto::TDqTask>& tasks, NKqp::TKqpTasksRunner& tasksRunner);
-
-THolder<TEvDataShard::TEvProposeTransactionResult> KqpCompleteTransaction(const TActorContext& ctx,
+ 
+THolder<TEvDataShard::TEvProposeTransactionResult> KqpCompleteTransaction(const TActorContext& ctx, 
     ui64 origin, ui64 txId, const TInputOpData::TInReadSets* inReadSets,
     const google::protobuf::RepeatedPtrField<NYql::NDqProto::TDqTask>& tasks, NKqp::TKqpTasksRunner& tasksRunner,
     const NMiniKQL::TKqpDatashardComputeContext& computeCtx);
-
+ 
 void KqpFillOutReadSets(TOutputOpData::TOutReadSets& outReadSets, const NKikimrTxDataShard::TKqpTransaction& kqpTx,
     NKqp::TKqpTasksRunner& tasksRunner, TSysLocks& sysLocks, ui64 tabletId);
-
+ 
 void KqpPrepareInReadsets(TInputOpData::TInReadSets& inReadSets,
     const NKikimrTxDataShard::TKqpTransaction& kqpTx, ui64 tabletId);
-
+ 
 bool KqpValidateLocks(ui64 origin, TActiveTransaction* tx, TSysLocks& sysLocks);
-
+ 
 void KqpEraseLocks(ui64 origin, TActiveTransaction* tx, TSysLocks& sysLocks);
 
 void KqpUpdateDataShardStatCounters(TDataShard& dataShard, const NMiniKQL::TEngineHostCounters& counters);
-
+ 
 void KqpFillTxStats(TDataShard& dataShard, const NMiniKQL::TEngineHostCounters& counters,
     TEvDataShard::TEvProposeTransactionResult& result);
 
@@ -51,4 +51,4 @@ NYql::NDq::TDqTaskRunnerMemoryLimits DefaultKqpDataReqMemoryLimits();
 THolder<NYql::NDq::IDqTaskRunnerExecutionContext> DefaultKqpExecutionContext();
 
 } // namespace NDataShard
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/tx/datashard/datashard_kqp_compute.cpp b/ydb/core/tx/datashard/datashard_kqp_compute.cpp
index edd6ca8e19..4ba377503f 100644
--- a/ydb/core/tx/datashard/datashard_kqp_compute.cpp
+++ b/ydb/core/tx/datashard/datashard_kqp_compute.cpp
@@ -1,106 +1,106 @@
-#include "datashard_kqp_compute.h"
+#include "datashard_kqp_compute.h" 
 #include "range_ops.h"
-
+ 
 #include <ydb/core/kqp/runtime/kqp_transport.h>
 #include <ydb/core/kqp/runtime/kqp_read_table.h>
 #include <ydb/core/kqp/runtime/kqp_scan_data.h>
 #include <ydb/core/tx/datashard/datashard_impl.h>
-
+ 
 #include <ydb/library/yql/minikql/mkql_node.h>
-
-namespace NKikimr {
-namespace NMiniKQL {
-
-using namespace NTable;
-using namespace NUdf;
-
-TSmallVec<TTag> ExtractTags(const TSmallVec<TKqpComputeContextBase::TColumn>& columns) {
-    TSmallVec<TTag> tags;
-    for (const auto& column : columns) {
-        tags.push_back(column.Tag);
-    }
-    return tags;
-}
-
-typedef IComputationNode* (*TCallableDatashardBuilderFunc)(TCallable& callable,
-    const TComputationNodeFactoryContext& ctx, TKqpDatashardComputeContext& computeCtx);
-
-struct TKqpDatashardComputationMap {
-    TKqpDatashardComputationMap() {
+ 
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
+using namespace NTable; 
+using namespace NUdf; 
+ 
+TSmallVec<TTag> ExtractTags(const TSmallVec<TKqpComputeContextBase::TColumn>& columns) { 
+    TSmallVec<TTag> tags; 
+    for (const auto& column : columns) { 
+        tags.push_back(column.Tag); 
+    } 
+    return tags; 
+} 
+ 
+typedef IComputationNode* (*TCallableDatashardBuilderFunc)(TCallable& callable, 
+    const TComputationNodeFactoryContext& ctx, TKqpDatashardComputeContext& computeCtx); 
+ 
+struct TKqpDatashardComputationMap { 
+    TKqpDatashardComputationMap() { 
         Map["KqpWideReadTable"] = &WrapKqpWideReadTable;
         Map["KqpWideReadTableRanges"] = &WrapKqpWideReadTableRanges;
-        Map["KqpLookupTable"] = &WrapKqpLookupTable;
-        Map["KqpUpsertRows"] = &WrapKqpUpsertRows;
+        Map["KqpLookupTable"] = &WrapKqpLookupTable; 
+        Map["KqpUpsertRows"] = &WrapKqpUpsertRows; 
         Map["KqpDeleteRows"] = &WrapKqpDeleteRows;
-        Map["KqpEffects"] = &WrapKqpEffects;
-    }
-
-    THashMap<TString, TCallableDatashardBuilderFunc> Map;
-};
-
-TComputationNodeFactory GetKqpDatashardComputeFactory(TKqpDatashardComputeContext* computeCtx) {
-    MKQL_ENSURE_S(computeCtx);
-    MKQL_ENSURE_S(computeCtx->Database);
-
-    auto computeFactory = GetKqpBaseComputeFactory(computeCtx);
-
-    return [computeFactory, computeCtx]
-        (TCallable& callable, const TComputationNodeFactoryContext& ctx) -> IComputationNode* {
-            if (auto compute = computeFactory(callable, ctx)) {
-                return compute;
-            }
-
-            const auto& datashardMap = Singleton<TKqpDatashardComputationMap>()->Map;
-            auto it = datashardMap.find(callable.GetType()->GetName());
-            if (it != datashardMap.end()) {
-                return it->second(callable, ctx, *computeCtx);
-            }
-
-            return nullptr;
-        };
-};
-
-typedef IComputationNode* (*TCallableScanBuilderFunc)(TCallable& callable,
+        Map["KqpEffects"] = &WrapKqpEffects; 
+    } 
+ 
+    THashMap<TString, TCallableDatashardBuilderFunc> Map; 
+}; 
+ 
+TComputationNodeFactory GetKqpDatashardComputeFactory(TKqpDatashardComputeContext* computeCtx) { 
+    MKQL_ENSURE_S(computeCtx); 
+    MKQL_ENSURE_S(computeCtx->Database); 
+ 
+    auto computeFactory = GetKqpBaseComputeFactory(computeCtx); 
+ 
+    return [computeFactory, computeCtx] 
+        (TCallable& callable, const TComputationNodeFactoryContext& ctx) -> IComputationNode* { 
+            if (auto compute = computeFactory(callable, ctx)) { 
+                return compute; 
+            } 
+ 
+            const auto& datashardMap = Singleton<TKqpDatashardComputationMap>()->Map; 
+            auto it = datashardMap.find(callable.GetType()->GetName()); 
+            if (it != datashardMap.end()) { 
+                return it->second(callable, ctx, *computeCtx); 
+            } 
+ 
+            return nullptr; 
+        }; 
+}; 
+ 
+typedef IComputationNode* (*TCallableScanBuilderFunc)(TCallable& callable, 
     const TComputationNodeFactoryContext& ctx, TKqpScanComputeContext& computeCtx);
-
-struct TKqpScanComputationMap {
-    TKqpScanComputationMap() {
+ 
+struct TKqpScanComputationMap { 
+    TKqpScanComputationMap() { 
         Map["KqpWideReadTable"] = &WrapKqpScanWideReadTable;
         Map["KqpWideReadTableRanges"] = &WrapKqpScanWideReadTableRanges;
-    }
-
-    THashMap<TString, TCallableScanBuilderFunc> Map;
-};
-
-TComputationNodeFactory GetKqpScanComputeFactory(TKqpScanComputeContext* computeCtx) {
-    MKQL_ENSURE_S(computeCtx);
-
-    auto computeFactory = GetKqpBaseComputeFactory(computeCtx);
-
-    return [computeFactory, computeCtx]
-        (TCallable& callable, const TComputationNodeFactoryContext& ctx) -> IComputationNode* {
-            if (auto compute = computeFactory(callable, ctx)) {
-                return compute;
-            }
-
-            const auto& datashardMap = Singleton<TKqpScanComputationMap>()->Map;
-            auto it = datashardMap.find(callable.GetType()->GetName());
-            if (it != datashardMap.end()) {
-                return it->second(callable, ctx, *computeCtx);
-            }
-
-            return nullptr;
-        };
-}
-
-ui64 TKqpDatashardComputeContext::GetLocalTableId(const TTableId &tableId) const {
-    MKQL_ENSURE_S(Shard);
-    return Shard->GetLocalTableId(tableId);
-}
-
-TVector<std::pair<NScheme::TTypeId, TString>> TKqpDatashardComputeContext::GetKeyColumnsInfo(
-        const TTableId &tableId) const
-{
+    } 
+ 
+    THashMap<TString, TCallableScanBuilderFunc> Map; 
+}; 
+ 
+TComputationNodeFactory GetKqpScanComputeFactory(TKqpScanComputeContext* computeCtx) { 
+    MKQL_ENSURE_S(computeCtx); 
+ 
+    auto computeFactory = GetKqpBaseComputeFactory(computeCtx); 
+ 
+    return [computeFactory, computeCtx] 
+        (TCallable& callable, const TComputationNodeFactoryContext& ctx) -> IComputationNode* { 
+            if (auto compute = computeFactory(callable, ctx)) { 
+                return compute; 
+            } 
+ 
+            const auto& datashardMap = Singleton<TKqpScanComputationMap>()->Map; 
+            auto it = datashardMap.find(callable.GetType()->GetName()); 
+            if (it != datashardMap.end()) { 
+                return it->second(callable, ctx, *computeCtx); 
+            } 
+ 
+            return nullptr; 
+        }; 
+} 
+ 
+ui64 TKqpDatashardComputeContext::GetLocalTableId(const TTableId &tableId) const { 
+    MKQL_ENSURE_S(Shard); 
+    return Shard->GetLocalTableId(tableId); 
+} 
+ 
+TVector<std::pair<NScheme::TTypeId, TString>> TKqpDatashardComputeContext::GetKeyColumnsInfo( 
+        const TTableId &tableId) const 
+{ 
     MKQL_ENSURE_S(Shard);
     const NDataShard::TUserTable::TCPtr* tablePtr = Shard->GetUserTables().FindPtr(tableId.PathId.LocalPathId);
     MKQL_ENSURE_S(tablePtr);
@@ -119,28 +119,28 @@ TVector<std::pair<NScheme::TTypeId, TString>> TKqpDatashardComputeContext::GetKe
     return res;
 }
 
-THashMap<TString, NScheme::TTypeId> TKqpDatashardComputeContext::GetKeyColumnsMap(const TTableId &tableId) const {
-    THashMap<TString, NScheme::TTypeId> columnsMap;
-
-    auto keyColumns = GetKeyColumnsInfo(tableId);
-    for (const auto& [type, name] : keyColumns) {
-        columnsMap[name] = type;
-    }
-
-    return columnsMap;
-}
-
-TString TKqpDatashardComputeContext::GetTablePath(const TTableId &tableId) const {
-    MKQL_ENSURE_S(Shard);
-
-    auto table = Shard->GetUserTables().FindPtr(tableId.PathId.LocalPathId);
-    if (!table) {
-        return TStringBuilder() << tableId;
-    }
-
-    return (*table)->Path;
-}
-
+THashMap<TString, NScheme::TTypeId> TKqpDatashardComputeContext::GetKeyColumnsMap(const TTableId &tableId) const { 
+    THashMap<TString, NScheme::TTypeId> columnsMap; 
+ 
+    auto keyColumns = GetKeyColumnsInfo(tableId); 
+    for (const auto& [type, name] : keyColumns) { 
+        columnsMap[name] = type; 
+    } 
+ 
+    return columnsMap; 
+} 
+ 
+TString TKqpDatashardComputeContext::GetTablePath(const TTableId &tableId) const { 
+    MKQL_ENSURE_S(Shard); 
+ 
+    auto table = Shard->GetUserTables().FindPtr(tableId.PathId.LocalPathId); 
+    if (!table) { 
+        return TStringBuilder() << tableId; 
+    } 
+ 
+    return (*table)->Path; 
+} 
+ 
 const NDataShard::TUserTable* TKqpDatashardComputeContext::GetTable(const TTableId& tableId) const {
     MKQL_ENSURE_S(Shard);
     auto ptr = Shard->GetUserTables().FindPtr(tableId.PathId.LocalPathId);
@@ -148,27 +148,27 @@ const NDataShard::TUserTable* TKqpDatashardComputeContext::GetTable(const TTable
     return ptr->Get();
 }
 
-void TKqpDatashardComputeContext::ReadTable(const TTableId& tableId, const TTableRange& range) const {
-    MKQL_ENSURE_S(Shard);
-    Shard->SysLocksTable().SetLock(tableId, range, LockTxId);
-    Shard->SetTableAccessTime(tableId, Now);
-}
-
-void TKqpDatashardComputeContext::ReadTable(const TTableId& tableId, const TArrayRef<const TCell>& key) const {
-    MKQL_ENSURE_S(Shard);
-    Shard->SysLocksTable().SetLock(tableId, key, LockTxId);
-    Shard->SetTableAccessTime(tableId, Now);
-}
-
+void TKqpDatashardComputeContext::ReadTable(const TTableId& tableId, const TTableRange& range) const { 
+    MKQL_ENSURE_S(Shard); 
+    Shard->SysLocksTable().SetLock(tableId, range, LockTxId); 
+    Shard->SetTableAccessTime(tableId, Now); 
+} 
+ 
+void TKqpDatashardComputeContext::ReadTable(const TTableId& tableId, const TArrayRef<const TCell>& key) const { 
+    MKQL_ENSURE_S(Shard); 
+    Shard->SysLocksTable().SetLock(tableId, key, LockTxId); 
+    Shard->SetTableAccessTime(tableId, Now); 
+} 
+ 
 void TKqpDatashardComputeContext::BreakSetLocks() const {
     MKQL_ENSURE_S(Shard);
     Shard->SysLocksTable().BreakSetLocks(LockTxId);
 }
 
-void TKqpDatashardComputeContext::SetLockTxId(ui64 lockTxId) {
-    LockTxId = lockTxId;
-}
-
+void TKqpDatashardComputeContext::SetLockTxId(ui64 lockTxId) { 
+    LockTxId = lockTxId; 
+} 
+ 
 ui64 TKqpDatashardComputeContext::GetShardId() const {
     return Shard->TabletID();
 }
@@ -195,11 +195,11 @@ TActorId TKqpDatashardComputeContext::GetTaskOutputChannel(ui64 taskId, ui64 cha
     return TActorId();
 }
 
-void TKqpDatashardComputeContext::Clear() {
-    Database = nullptr;
-    LockTxId = 0;
-}
-
+void TKqpDatashardComputeContext::Clear() { 
+    Database = nullptr; 
+    LockTxId = 0; 
+} 
+ 
 bool TKqpDatashardComputeContext::PinPages(const TVector<IEngineFlat::TValidatedKey>& keys, ui64 pageFaultCount) {
     ui64 limitMultiplier = 1;
     if (pageFaultCount >= 2) {
@@ -276,4 +276,4 @@ bool TKqpDatashardComputeContext::PinPages(const TVector<IEngineFlat::TValidated
 }
 
 } // namespace NMiniKQL
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/tx/datashard/datashard_kqp_compute.h b/ydb/core/tx/datashard/datashard_kqp_compute.h
index 4bbb8fa0de..b55f590bbf 100644
--- a/ydb/core/tx/datashard/datashard_kqp_compute.h
+++ b/ydb/core/tx/datashard/datashard_kqp_compute.h
@@ -1,44 +1,44 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/core/kqp/runtime/kqp_scan_data.h>
 #include <ydb/core/engine/mkql_engine_flat.h>
 #include <ydb/core/scheme/scheme_tabledefs.h>
 #include <ydb/core/tablet_flat/flat_database.h>
-
-namespace NKikimr {
+ 
+namespace NKikimr { 
     namespace NDataShard {
-        class TExecuteKqpScanTxUnit;
+        class TExecuteKqpScanTxUnit; 
         class TDataShard;
         struct TUserTable;
-    }
-}
-
-namespace NKikimr {
-namespace NMiniKQL {
-
-class IEngineFlatHost;
-
+    } 
+} 
+ 
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
+class IEngineFlatHost; 
+ 
 using TKqpTableStats = TEngineHostCounters;
-
-class TKqpDatashardComputeContext : public TKqpComputeContextBase {
-public:
+ 
+class TKqpDatashardComputeContext : public TKqpComputeContextBase { 
+public: 
     TKqpDatashardComputeContext(NDataShard::TDataShard* shard, TEngineHostCounters& counters, TInstant now)
-        : Shard(shard)
+        : Shard(shard) 
         , DatashardCounters(counters)
-        , Now(now) {}
-
-    ui64 GetLocalTableId(const TTableId& tableId) const;
-    TString GetTablePath(const TTableId& tableId) const;
+        , Now(now) {} 
+ 
+    ui64 GetLocalTableId(const TTableId& tableId) const; 
+    TString GetTablePath(const TTableId& tableId) const; 
     const NDataShard::TUserTable* GetTable(const TTableId& tableId) const;
-    void ReadTable(const TTableId& tableId, const TTableRange& range) const;
-    void ReadTable(const TTableId& tableId, const TArrayRef<const TCell>& key) const;
+    void ReadTable(const TTableId& tableId, const TTableRange& range) const; 
+    void ReadTable(const TTableId& tableId, const TArrayRef<const TCell>& key) const; 
     void BreakSetLocks() const;
-    void SetLockTxId(ui64 lockTxId);
+    void SetLockTxId(ui64 lockTxId); 
     ui64 GetShardId() const;
-
-    TVector<std::pair<NScheme::TTypeId, TString>> GetKeyColumnsInfo(const TTableId &tableId) const;
-    THashMap<TString, NScheme::TTypeId> GetKeyColumnsMap(const TTableId &tableId) const;
-
+ 
+    TVector<std::pair<NScheme::TTypeId, TString>> GetKeyColumnsInfo(const TTableId &tableId) const; 
+    THashMap<TString, NScheme::TTypeId> GetKeyColumnsMap(const TTableId &tableId) const; 
+ 
     void SetHasPersistentChannels(bool value) { PersistentChannels = value; }
     bool HasPersistentChannels() const { return PersistentChannels; }
 
@@ -47,66 +47,66 @@ public:
 
     bool PinPages(const TVector<IEngineFlat::TValidatedKey>& keys, ui64 pageFaultCount = 0);
 
-    void Clear();
-
+    void Clear(); 
+ 
     void SetReadVersion(TRowVersion readVersion);
     TRowVersion GetReadVersion() const;
 
     TEngineHostCounters& GetTaskCounters(ui64 taskId) { return TaskCounters[taskId]; }
     TEngineHostCounters& GetDatashardCounters() { return DatashardCounters; }
-
+ 
     void SetTabletNotReady() { Y_VERIFY_DEBUG(!TabletNotReady); TabletNotReady = true; };
     bool IsTabletNotReady() const { return TabletNotReady; }
 
-public:
-    NTable::TDatabase* Database = nullptr;
-
-private:
+public: 
+    NTable::TDatabase* Database = nullptr; 
+ 
+private: 
     NDataShard::TDataShard* Shard;
     std::unordered_map<ui64, TEngineHostCounters> TaskCounters;
     TEngineHostCounters& DatashardCounters;
-    TInstant Now;
-    ui64 LockTxId = 0;
+    TInstant Now; 
+    ui64 LockTxId = 0; 
     bool PersistentChannels = false;
     bool TabletNotReady = false;
     TRowVersion ReadVersion = TRowVersion::Min();
     THashMap<std::pair<ui64, ui64>, TActorId> OutputChannels;
-};
-
-class TKqpDatashardApplyContext : public NUdf::IApplyContext {
-public:
-    IEngineFlatHost* Host = nullptr;
-};
-
-TSmallVec<NTable::TTag> ExtractTags(const TSmallVec<TKqpComputeContextBase::TColumn>& columns);
-
-bool TryFetchRow(NTable::TTableIt& iterator, NYql::NUdf::TUnboxedValue& row, TComputationContext& ctx,
-    TKqpTableStats& tableStats, const TKqpDatashardComputeContext& computeCtx,
-    const TSmallVec<NTable::TTag>& systemColumnTags, const TSmallVec<bool>& skipNullKeys);
-
+}; 
+ 
+class TKqpDatashardApplyContext : public NUdf::IApplyContext { 
+public: 
+    IEngineFlatHost* Host = nullptr; 
+}; 
+ 
+TSmallVec<NTable::TTag> ExtractTags(const TSmallVec<TKqpComputeContextBase::TColumn>& columns); 
+ 
+bool TryFetchRow(NTable::TTableIt& iterator, NYql::NUdf::TUnboxedValue& row, TComputationContext& ctx, 
+    TKqpTableStats& tableStats, const TKqpDatashardComputeContext& computeCtx, 
+    const TSmallVec<NTable::TTag>& systemColumnTags, const TSmallVec<bool>& skipNullKeys); 
+ 
 bool TryFetchRow(NTable::TTableReverseIt& iterator, NYql::NUdf::TUnboxedValue& row, TComputationContext& ctx,
     TKqpTableStats& tableStats, const TKqpDatashardComputeContext& computeCtx,
     const TSmallVec<NTable::TTag>& systemColumnTags, const TSmallVec<bool>& skipNullKeys);
 
-void FetchRow(const TDbTupleRef& dbTuple, NYql::NUdf::TUnboxedValue& row, TComputationContext& ctx,
-    TKqpTableStats& tableStats, const TKqpDatashardComputeContext& computeCtx,
-    const TSmallVec<NTable::TTag>& systemColumnTags);
-
+void FetchRow(const TDbTupleRef& dbTuple, NYql::NUdf::TUnboxedValue& row, TComputationContext& ctx, 
+    TKqpTableStats& tableStats, const TKqpDatashardComputeContext& computeCtx, 
+    const TSmallVec<NTable::TTag>& systemColumnTags); 
+ 
 IComputationNode* WrapKqpWideReadTableRanges(TCallable& callable, const TComputationNodeFactoryContext& ctx,
     TKqpDatashardComputeContext& computeCtx);
-IComputationNode* WrapKqpLookupTable(TCallable& callable, const TComputationNodeFactoryContext& ctx,
-    TKqpDatashardComputeContext& computeCtx);
-IComputationNode* WrapKqpUpsertRows(TCallable& callable, const TComputationNodeFactoryContext& ctx,
-    TKqpDatashardComputeContext& computeCtx);
+IComputationNode* WrapKqpLookupTable(TCallable& callable, const TComputationNodeFactoryContext& ctx, 
+    TKqpDatashardComputeContext& computeCtx); 
+IComputationNode* WrapKqpUpsertRows(TCallable& callable, const TComputationNodeFactoryContext& ctx, 
+    TKqpDatashardComputeContext& computeCtx); 
 IComputationNode* WrapKqpDeleteRows(TCallable& callable, const TComputationNodeFactoryContext& ctx,
     TKqpDatashardComputeContext& computeCtx);
-IComputationNode* WrapKqpEffects(TCallable& callable, const TComputationNodeFactoryContext& ctx,
-    TKqpDatashardComputeContext& computeCtx);
+IComputationNode* WrapKqpEffects(TCallable& callable, const TComputationNodeFactoryContext& ctx, 
+    TKqpDatashardComputeContext& computeCtx); 
 IComputationNode* WrapKqpWideReadTable(TCallable& callable, const TComputationNodeFactoryContext& ctx,
     TKqpDatashardComputeContext& computeCtx);
-
-TComputationNodeFactory GetKqpDatashardComputeFactory(TKqpDatashardComputeContext* computeCtx);
-TComputationNodeFactory GetKqpScanComputeFactory(TKqpScanComputeContext* computeCtx);
-
+ 
+TComputationNodeFactory GetKqpDatashardComputeFactory(TKqpDatashardComputeContext* computeCtx); 
+TComputationNodeFactory GetKqpScanComputeFactory(TKqpScanComputeContext* computeCtx); 
+ 
 } // namespace NMiniKQL
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/tx/datashard/datashard_kqp_delete_rows.cpp b/ydb/core/tx/datashard/datashard_kqp_delete_rows.cpp
index 6a6c3d8231..3caed29d7f 100644
--- a/ydb/core/tx/datashard/datashard_kqp_delete_rows.cpp
+++ b/ydb/core/tx/datashard/datashard_kqp_delete_rows.cpp
@@ -132,36 +132,36 @@ IComputationNode* WrapKqpDeleteRows(TCallable& callable, const TComputationNodeF
     auto tableId = NKqp::ParseTableId(tableNode);
     auto localTableId = computeCtx.GetLocalTableId(tableId);
     MKQL_ENSURE_S(localTableId);
-    auto tableKeyTypes = computeCtx.GetKeyColumnsInfo(tableId);
+    auto tableKeyTypes = computeCtx.GetKeyColumnsInfo(tableId); 
 
     auto rowType = AS_TYPE(TStructType, AS_TYPE(TStreamType, rowsNode.GetStaticType())->GetItemType());
-    MKQL_ENSURE_S(tableKeyTypes.size() == rowType->GetMembersCount(), "Table key column count mismatch"
-        << ", expected: " << tableKeyTypes.size()
-        << ", actual: " << rowType->GetMembersCount());
+    MKQL_ENSURE_S(tableKeyTypes.size() == rowType->GetMembersCount(), "Table key column count mismatch" 
+        << ", expected: " << tableKeyTypes.size() 
+        << ", actual: " << rowType->GetMembersCount()); 
 
     THashMap<TString, ui32> inputIndex;
     TVector<NUdf::TDataTypeId> rowTypes(rowType->GetMembersCount());
     for (ui32 i = 0; i < rowType->GetMembersCount(); ++i) {
         const auto& name = rowType->GetMemberName(i);
         MKQL_ENSURE_S(inputIndex.emplace(TString(name), i).second);
-
-        auto memberType = rowType->GetMemberType(i);
-        auto typeId = memberType->IsOptional()
-            ? AS_TYPE(TDataType, AS_TYPE(TOptionalType, memberType)->GetItemType())->GetSchemeType()
-            : AS_TYPE(TDataType, memberType)->GetSchemeType();
-
-        rowTypes[i] = typeId;
+ 
+        auto memberType = rowType->GetMemberType(i); 
+        auto typeId = memberType->IsOptional() 
+            ? AS_TYPE(TDataType, AS_TYPE(TOptionalType, memberType)->GetItemType())->GetSchemeType() 
+            : AS_TYPE(TDataType, memberType)->GetSchemeType(); 
+ 
+        rowTypes[i] = typeId; 
     }
 
     TVector<ui32> keyIndices(tableKeyTypes.size());
     for (ui32 i = 0; i < tableKeyTypes.size(); i++) {
         auto it = inputIndex.find(tableKeyTypes[i].second);
-
-        MKQL_ENSURE_S(rowTypes[it->second] == tableKeyTypes[i].first, "Key type mismatch"
-            << ", column: " << tableKeyTypes[i].second
-            << ", expected: " << tableKeyTypes[i].first
-            << ", actual: " << rowTypes[it->second]);
-
+ 
+        MKQL_ENSURE_S(rowTypes[it->second] == tableKeyTypes[i].first, "Key type mismatch" 
+            << ", column: " << tableKeyTypes[i].second 
+            << ", expected: " << tableKeyTypes[i].first 
+            << ", actual: " << rowTypes[it->second]); 
+ 
         keyIndices[i] = it->second;
     }
 
diff --git a/ydb/core/tx/datashard/datashard_kqp_effects.cpp b/ydb/core/tx/datashard/datashard_kqp_effects.cpp
index c8c3f1c79b..d4cdf3a027 100644
--- a/ydb/core/tx/datashard/datashard_kqp_effects.cpp
+++ b/ydb/core/tx/datashard/datashard_kqp_effects.cpp
@@ -1,102 +1,102 @@
-#include "datashard_kqp_compute.h"
-
+#include "datashard_kqp_compute.h" 
+ 
 #include <ydb/core/engine/mkql_keys.h>
 #include <ydb/core/engine/mkql_engine_flat_host.h>
 #include <ydb/core/kqp/runtime/kqp_read_table.h>
-
+ 
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_holders.h>
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_impl.h>
 #include <ydb/library/yql/minikql/mkql_node.h>
 #include <ydb/library/yql/minikql/mkql_node_cast.h>
-
-#include <util/generic/cast.h>
-
-namespace NKikimr {
-namespace NMiniKQL {
-
-using namespace NTable;
-using namespace NUdf;
-
-namespace {
-
-class TKqpEffectsWrapper : public TMutableComputationNode<TKqpEffectsWrapper> {
-    using TBase = TMutableComputationNode<TKqpEffectsWrapper>;
-
-public:
-    class TEffectsValue : public TComputationValue<TEffectsValue> {
-    public:
-        using TBase = TComputationValue<TEffectsValue>;
-
-        TEffectsValue(TMemoryUsageInfo* memInfo, TUnboxedValueVector&& effects)
-            : TBase(memInfo)
-            , Effects(std::move(effects)) {}
-
-        EFetchStatus Fetch(TUnboxedValue& result) final {
-            if (Index >= Effects.size()) {
-                return EFetchStatus::Finish;
-            }
-
-            while (Index < Effects.size()) {
-                const auto status = Effects[Index].Fetch(result);
-                switch (status) {
-                    case EFetchStatus::Finish:
-                        ++Index;
-                        break;
-
-                    default:
-                        return status;
-                }
-            }
-
-            result = TUnboxedValue();
-            return EFetchStatus::Finish;
-        }
-
-    private:
-        const TUnboxedValueVector Effects;
-        ui32 Index = 0;
-    };
-
-    TUnboxedValuePod DoCalculate(TComputationContext& ctx) const {
-        TUnboxedValueVector values;
-        values.reserve(Effects.size());
-        std::transform(Effects.cbegin(), Effects.cend(), std::back_inserter(values),
-            std::bind(&IComputationNode::GetValue, std::placeholders::_1, std::ref(ctx))
-        );
-
-        return ctx.HolderFactory.Create<TEffectsValue>(std::move(values));
-    }
-
-public:
-    TKqpEffectsWrapper(TComputationMutables& mutables, TComputationNodePtrVector&& effects)
-        : TBase(mutables)
-        , Effects(std::move(effects)) {}
-
-private:
-    void RegisterDependencies() const final {
-        std::for_each(Effects.cbegin(), Effects.cend(),
-            std::bind(&TKqpEffectsWrapper::DependsOn, this, std::placeholders::_1));
-    }
-
-private:
-    const TComputationNodePtrVector Effects;
-};
-
-} // namespace
-
-IComputationNode* WrapKqpEffects(TCallable& callable, const TComputationNodeFactoryContext& ctx,
-    TKqpDatashardComputeContext& computeCtx)
-{
-    Y_UNUSED(computeCtx);
-
-    TComputationNodePtrVector effectNodes;
-    effectNodes.reserve(callable.GetInputsCount());
-    for (ui32 i = 0; i < callable.GetInputsCount(); ++i) {
-        effectNodes.emplace_back(LocateNode(ctx.NodeLocator, callable, i));
-    }
-
-    return new TKqpEffectsWrapper(ctx.Mutables, std::move(effectNodes));
-}
-
-} // namspace NMiniKQL
-} // namespace NKikimr
+ 
+#include <util/generic/cast.h> 
+ 
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
+using namespace NTable; 
+using namespace NUdf; 
+ 
+namespace { 
+ 
+class TKqpEffectsWrapper : public TMutableComputationNode<TKqpEffectsWrapper> { 
+    using TBase = TMutableComputationNode<TKqpEffectsWrapper>; 
+ 
+public: 
+    class TEffectsValue : public TComputationValue<TEffectsValue> { 
+    public: 
+        using TBase = TComputationValue<TEffectsValue>; 
+ 
+        TEffectsValue(TMemoryUsageInfo* memInfo, TUnboxedValueVector&& effects) 
+            : TBase(memInfo) 
+            , Effects(std::move(effects)) {} 
+ 
+        EFetchStatus Fetch(TUnboxedValue& result) final { 
+            if (Index >= Effects.size()) { 
+                return EFetchStatus::Finish; 
+            } 
+ 
+            while (Index < Effects.size()) { 
+                const auto status = Effects[Index].Fetch(result); 
+                switch (status) { 
+                    case EFetchStatus::Finish: 
+                        ++Index; 
+                        break; 
+ 
+                    default: 
+                        return status; 
+                } 
+            } 
+ 
+            result = TUnboxedValue(); 
+            return EFetchStatus::Finish; 
+        } 
+ 
+    private: 
+        const TUnboxedValueVector Effects; 
+        ui32 Index = 0; 
+    }; 
+ 
+    TUnboxedValuePod DoCalculate(TComputationContext& ctx) const { 
+        TUnboxedValueVector values; 
+        values.reserve(Effects.size()); 
+        std::transform(Effects.cbegin(), Effects.cend(), std::back_inserter(values), 
+            std::bind(&IComputationNode::GetValue, std::placeholders::_1, std::ref(ctx)) 
+        ); 
+ 
+        return ctx.HolderFactory.Create<TEffectsValue>(std::move(values)); 
+    } 
+ 
+public: 
+    TKqpEffectsWrapper(TComputationMutables& mutables, TComputationNodePtrVector&& effects) 
+        : TBase(mutables) 
+        , Effects(std::move(effects)) {} 
+ 
+private: 
+    void RegisterDependencies() const final { 
+        std::for_each(Effects.cbegin(), Effects.cend(), 
+            std::bind(&TKqpEffectsWrapper::DependsOn, this, std::placeholders::_1)); 
+    } 
+ 
+private: 
+    const TComputationNodePtrVector Effects; 
+}; 
+ 
+} // namespace 
+ 
+IComputationNode* WrapKqpEffects(TCallable& callable, const TComputationNodeFactoryContext& ctx, 
+    TKqpDatashardComputeContext& computeCtx) 
+{ 
+    Y_UNUSED(computeCtx); 
+ 
+    TComputationNodePtrVector effectNodes; 
+    effectNodes.reserve(callable.GetInputsCount()); 
+    for (ui32 i = 0; i < callable.GetInputsCount(); ++i) { 
+        effectNodes.emplace_back(LocateNode(ctx.NodeLocator, callable, i)); 
+    } 
+ 
+    return new TKqpEffectsWrapper(ctx.Mutables, std::move(effectNodes)); 
+} 
+ 
+} // namspace NMiniKQL 
+} // namespace NKikimr 
diff --git a/ydb/core/tx/datashard/datashard_kqp_lookup_table.cpp b/ydb/core/tx/datashard/datashard_kqp_lookup_table.cpp
index 24582c2664..bf5e745e10 100644
--- a/ydb/core/tx/datashard/datashard_kqp_lookup_table.cpp
+++ b/ydb/core/tx/datashard/datashard_kqp_lookup_table.cpp
@@ -1,68 +1,68 @@
-#include "datashard_kqp_compute.h"
-
+#include "datashard_kqp_compute.h" 
+ 
 #include <ydb/core/kqp/runtime/kqp_read_table.h>
 #include <ydb/core/kqp/runtime/kqp_runtime_impl.h>
 #include <ydb/core/engine/minikql/minikql_engine_host.h>
-
-namespace NKikimr {
-namespace NMiniKQL {
-
-using namespace NTable;
-using namespace NUdf;
-
-namespace {
-
-struct TParseLookupTableResult {
-    ui32 CallableId = 0;
-    TTableId TableId;
-    TRuntimeNode LookupKeys;
-    TVector<ui32> KeyIndices;
-    TVector<NUdf::TDataTypeId> KeyTypes;
-
-    TSmallVec<TKqpComputeContextBase::TColumn> Columns;
-    TSmallVec<TKqpComputeContextBase::TColumn> SystemColumns;
-    TSmallVec<bool> SkipNullKeys;
-};
-
-void ValidateLookupKeys(const TType* inputType, const THashMap<TString, NScheme::TTypeId>& keyColumns) {
-    MKQL_ENSURE_S(inputType);
-    auto rowType = AS_TYPE(TStructType, AS_TYPE(TStreamType, inputType)->GetItemType());
-
-    for (ui32 i = 0; i < rowType->GetMembersCount(); ++i) {
-        auto name = rowType->GetMemberName(i);
-        auto dataType = NKqp::UnwrapDataTypeFromStruct(*rowType, i);
-
-        auto columnType = keyColumns.FindPtr(name);
-        MKQL_ENSURE_S(columnType);
-        MKQL_ENSURE_S(dataType == *columnType, "Key column type mismatch, column: " << name);
-    }
-}
-
-TParseLookupTableResult ParseLookupTable(TCallable& callable) {
-    MKQL_ENSURE_S(callable.GetInputsCount() >= 4);
-
-    TParseLookupTableResult result;
-
-    result.CallableId = callable.GetUniqueId();
-    MKQL_ENSURE_S(result.CallableId);
-
-    auto tableNode = callable.GetInput(0);
-    auto keysNode = callable.GetInput(1);
-    auto keysIndicesNode = callable.GetInput(2);
-    auto tagsNode = callable.GetInput(3);
-
-    result.TableId = NKqp::ParseTableId(tableNode);
-    result.LookupKeys = keysNode;
-
-    auto keyIndices = AS_VALUE(TListLiteral, keysIndicesNode);
-    result.KeyIndices.resize(keyIndices->GetItemsCount());
-    for (ui32 i = 0; i < result.KeyIndices.size(); ++i) {
-        result.KeyIndices[i] = AS_VALUE(TDataLiteral, keyIndices->GetItems()[i])->AsValue().Get<ui32>();;
-    }
-
-    auto keyTypes = AS_TYPE(TStructType, AS_TYPE(TStreamType, keysNode.GetStaticType())->GetItemType());
-    result.KeyTypes.resize(keyTypes->GetMembersCount());
-    for (ui32 i = 0; i < result.KeyTypes.size(); ++i) {
+ 
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
+using namespace NTable; 
+using namespace NUdf; 
+ 
+namespace { 
+ 
+struct TParseLookupTableResult { 
+    ui32 CallableId = 0; 
+    TTableId TableId; 
+    TRuntimeNode LookupKeys; 
+    TVector<ui32> KeyIndices; 
+    TVector<NUdf::TDataTypeId> KeyTypes; 
+ 
+    TSmallVec<TKqpComputeContextBase::TColumn> Columns; 
+    TSmallVec<TKqpComputeContextBase::TColumn> SystemColumns; 
+    TSmallVec<bool> SkipNullKeys; 
+}; 
+ 
+void ValidateLookupKeys(const TType* inputType, const THashMap<TString, NScheme::TTypeId>& keyColumns) { 
+    MKQL_ENSURE_S(inputType); 
+    auto rowType = AS_TYPE(TStructType, AS_TYPE(TStreamType, inputType)->GetItemType()); 
+ 
+    for (ui32 i = 0; i < rowType->GetMembersCount(); ++i) { 
+        auto name = rowType->GetMemberName(i); 
+        auto dataType = NKqp::UnwrapDataTypeFromStruct(*rowType, i); 
+ 
+        auto columnType = keyColumns.FindPtr(name); 
+        MKQL_ENSURE_S(columnType); 
+        MKQL_ENSURE_S(dataType == *columnType, "Key column type mismatch, column: " << name); 
+    } 
+} 
+ 
+TParseLookupTableResult ParseLookupTable(TCallable& callable) { 
+    MKQL_ENSURE_S(callable.GetInputsCount() >= 4); 
+ 
+    TParseLookupTableResult result; 
+ 
+    result.CallableId = callable.GetUniqueId(); 
+    MKQL_ENSURE_S(result.CallableId); 
+ 
+    auto tableNode = callable.GetInput(0); 
+    auto keysNode = callable.GetInput(1); 
+    auto keysIndicesNode = callable.GetInput(2); 
+    auto tagsNode = callable.GetInput(3); 
+ 
+    result.TableId = NKqp::ParseTableId(tableNode); 
+    result.LookupKeys = keysNode; 
+ 
+    auto keyIndices = AS_VALUE(TListLiteral, keysIndicesNode); 
+    result.KeyIndices.resize(keyIndices->GetItemsCount()); 
+    for (ui32 i = 0; i < result.KeyIndices.size(); ++i) { 
+        result.KeyIndices[i] = AS_VALUE(TDataLiteral, keyIndices->GetItems()[i])->AsValue().Get<ui32>();; 
+    } 
+ 
+    auto keyTypes = AS_TYPE(TStructType, AS_TYPE(TStreamType, keysNode.GetStaticType())->GetItemType()); 
+    result.KeyTypes.resize(keyTypes->GetMembersCount()); 
+    for (ui32 i = 0; i < result.KeyTypes.size(); ++i) { 
         if (keyTypes->GetMemberType(i)->IsOptional()) {
             auto type = AS_TYPE(TDataType, AS_TYPE(TOptionalType, keyTypes->GetMemberType(i))->GetItemType());
             result.KeyTypes[i] = type->GetSchemeType();
@@ -70,88 +70,88 @@ TParseLookupTableResult ParseLookupTable(TCallable& callable) {
             auto type = AS_TYPE(TDataType, keyTypes->GetMemberType(i));
             result.KeyTypes[i] = type->GetSchemeType();
         }
-    }
-
+    } 
+ 
     ParseReadColumns(callable.GetType()->GetReturnType(), tagsNode, result.Columns, result.SystemColumns);
-
-    return result;
-}
-
+ 
+    return result; 
+} 
+ 
 class TKqpLookupRowsWrapper : public TStatelessFlowComputationNode<TKqpLookupRowsWrapper> {
     using TBase = TStatelessFlowComputationNode<TKqpLookupRowsWrapper>;
-
-public:
-    TKqpLookupRowsWrapper(TComputationMutables& mutables, TKqpDatashardComputeContext& computeCtx,
-        const TTypeEnvironment& typeEnv, const TParseLookupTableResult& parseResult, IComputationNode* lookupKeysNode)
+ 
+public: 
+    TKqpLookupRowsWrapper(TComputationMutables& mutables, TKqpDatashardComputeContext& computeCtx, 
+        const TTypeEnvironment& typeEnv, const TParseLookupTableResult& parseResult, IComputationNode* lookupKeysNode) 
         : TBase(mutables, this, EValueRepresentation::Boxed)
-        , ComputeCtx(computeCtx)
-        , TypeEnv(typeEnv)
-        , ParseResult(parseResult)
-        , LookupKeysNode(lookupKeysNode)
-        , LocalTid(ComputeCtx.GetLocalTableId(ParseResult.TableId))
-        , ColumnTags(ExtractTags(ParseResult.Columns))
-        , SystemColumnTags(ExtractTags(ParseResult.SystemColumns))
+        , ComputeCtx(computeCtx) 
+        , TypeEnv(typeEnv) 
+        , ParseResult(parseResult) 
+        , LookupKeysNode(lookupKeysNode) 
+        , LocalTid(ComputeCtx.GetLocalTableId(ParseResult.TableId)) 
+        , ColumnTags(ExtractTags(ParseResult.Columns)) 
+        , SystemColumnTags(ExtractTags(ParseResult.SystemColumns)) 
         , ShardTableStats(ComputeCtx.GetDatashardCounters())
         , TaskTableStats(ComputeCtx.GetTaskCounters(ComputeCtx.GetCurrentTaskId()))
-        , TableInfo(ComputeCtx.Database->GetScheme().GetTableInfo(LocalTid))
-    {
-        MKQL_ENSURE_S(TableInfo);
-
-        MKQL_ENSURE_S(TableInfo->KeyColumns.size() == ParseResult.KeyIndices.size(),
-            "Incomplete row key in LookupRows.");
-
-        CellTypes.reserve(ColumnTags.size());
-        for (size_t i = 0; i < ColumnTags.size(); ++i) {
-            CellTypes.emplace_back(TableInfo->Columns.at(ColumnTags[i]).PType);
-        }
-    }
-
-    TUnboxedValue DoCalculate(TComputationContext& ctx) const {
-        auto keysValues = LookupKeysNode->GetValue(ctx);
-
-        while (!Finished) {
-            NUdf::TUnboxedValue key;
-            auto status = keysValues.Fetch(key);
-            switch (status) {
-                case NUdf::EFetchStatus::Ok: {
-                    TVector<TCell> keyCells(TableInfo->KeyColumns.size());
-                    FillKeyTupleValue(key, ParseResult.KeyIndices, ParseResult.KeyTypes, keyCells, TypeEnv);
-
-                    TSmallVec<TRawTypeValue> keyValues;
-                    ConvertTableKeys(ComputeCtx.Database->GetScheme(), TableInfo, keyCells, keyValues, nullptr);
-
-                    if (keyValues.size() != TableInfo->KeyColumns.size()) {
-                        throw TSchemeErrorTabletException();
-                    }
-
-                    ComputeCtx.ReadTable(ParseResult.TableId, keyCells);
-
-                    NTable::TRowState dbRow;
+        , TableInfo(ComputeCtx.Database->GetScheme().GetTableInfo(LocalTid)) 
+    { 
+        MKQL_ENSURE_S(TableInfo); 
+ 
+        MKQL_ENSURE_S(TableInfo->KeyColumns.size() == ParseResult.KeyIndices.size(), 
+            "Incomplete row key in LookupRows."); 
+ 
+        CellTypes.reserve(ColumnTags.size()); 
+        for (size_t i = 0; i < ColumnTags.size(); ++i) { 
+            CellTypes.emplace_back(TableInfo->Columns.at(ColumnTags[i]).PType); 
+        } 
+    } 
+ 
+    TUnboxedValue DoCalculate(TComputationContext& ctx) const { 
+        auto keysValues = LookupKeysNode->GetValue(ctx); 
+ 
+        while (!Finished) { 
+            NUdf::TUnboxedValue key; 
+            auto status = keysValues.Fetch(key); 
+            switch (status) { 
+                case NUdf::EFetchStatus::Ok: { 
+                    TVector<TCell> keyCells(TableInfo->KeyColumns.size()); 
+                    FillKeyTupleValue(key, ParseResult.KeyIndices, ParseResult.KeyTypes, keyCells, TypeEnv); 
+ 
+                    TSmallVec<TRawTypeValue> keyValues; 
+                    ConvertTableKeys(ComputeCtx.Database->GetScheme(), TableInfo, keyCells, keyValues, nullptr); 
+ 
+                    if (keyValues.size() != TableInfo->KeyColumns.size()) { 
+                        throw TSchemeErrorTabletException(); 
+                    } 
+ 
+                    ComputeCtx.ReadTable(ParseResult.TableId, keyCells); 
+ 
+                    NTable::TRowState dbRow; 
                     NTable::TSelectStats stats;
-                    ui64 flags = 0; // TODO: Check DisableByKeyFilter
+                    ui64 flags = 0; // TODO: Check DisableByKeyFilter 
                     auto ready = ComputeCtx.Database->Select(LocalTid, keyValues, ColumnTags, dbRow, stats, flags, ComputeCtx.GetReadVersion());
                     if (stats.Invisible)
                         ComputeCtx.BreakSetLocks();
 
-                    switch (ready) {
-                        case EReady::Page:
+                    switch (ready) { 
+                        case EReady::Page: 
                             ComputeCtx.SetTabletNotReady();
                             return TUnboxedValue::MakeYield();
-                        case EReady::Gone:
-                            continue;
-                        case EReady::Data:
-                            break;
-                        default:
-                            MKQL_ENSURE_S(false, "Unexpected local db select status: " << (ui32)ready);
-                    };
-
-                    MKQL_ENSURE_S(CellTypes.size() == dbRow.Size(), "Invalid local db row size.");
-
-                    TDbTupleRef dbTuple(CellTypes.data(), (*dbRow).data(), dbRow.Size());
-                    TUnboxedValue result;
+                        case EReady::Gone: 
+                            continue; 
+                        case EReady::Data: 
+                            break; 
+                        default: 
+                            MKQL_ENSURE_S(false, "Unexpected local db select status: " << (ui32)ready); 
+                    }; 
+ 
+                    MKQL_ENSURE_S(CellTypes.size() == dbRow.Size(), "Invalid local db row size."); 
+ 
+                    TDbTupleRef dbTuple(CellTypes.data(), (*dbRow).data(), dbRow.Size()); 
+                    TUnboxedValue result; 
                     TKqpTableStats tableStats;
                     FetchRow(dbTuple, result, ctx, tableStats, ComputeCtx, SystemColumnTags);
-
+ 
                     ShardTableStats.NSelectRow++;
                     ShardTableStats.SelectRowRows++;
                     ShardTableStats.SelectRowBytes += tableStats.SelectRowBytes;
@@ -160,107 +160,107 @@ public:
                     TaskTableStats.SelectRowRows++;
                     TaskTableStats.SelectRowBytes += tableStats.SelectRowBytes;
 
-                    return result;
-                }
-
-                case NUdf::EFetchStatus::Finish:
-                    Finished = true;
-                    return TUnboxedValue::MakeFinish();
-
-                case NUdf::EFetchStatus::Yield:
-                    return TUnboxedValue::MakeYield();
-            }
-
-            MKQL_ENSURE_S(false, "Unexpected key fetch status: " << (ui32)status);
-        }
-
-        return TUnboxedValue::MakeFinish();
-    }
-
-private:
-    void RegisterDependencies() const final {
-        this->FlowDependsOn(LookupKeysNode);
-    }
-
-private:
-    TKqpDatashardComputeContext& ComputeCtx;
-    const TTypeEnvironment& TypeEnv;
-    TParseLookupTableResult ParseResult;
-    IComputationNode* LookupKeysNode;
-    ui64 LocalTid;
-    TSmallVec<TTag> ColumnTags;
-    TSmallVec<TTag> SystemColumnTags;
+                    return result; 
+                } 
+ 
+                case NUdf::EFetchStatus::Finish: 
+                    Finished = true; 
+                    return TUnboxedValue::MakeFinish(); 
+ 
+                case NUdf::EFetchStatus::Yield: 
+                    return TUnboxedValue::MakeYield(); 
+            } 
+ 
+            MKQL_ENSURE_S(false, "Unexpected key fetch status: " << (ui32)status); 
+        } 
+ 
+        return TUnboxedValue::MakeFinish(); 
+    } 
+ 
+private: 
+    void RegisterDependencies() const final { 
+        this->FlowDependsOn(LookupKeysNode); 
+    } 
+ 
+private: 
+    TKqpDatashardComputeContext& ComputeCtx; 
+    const TTypeEnvironment& TypeEnv; 
+    TParseLookupTableResult ParseResult; 
+    IComputationNode* LookupKeysNode; 
+    ui64 LocalTid; 
+    TSmallVec<TTag> ColumnTags; 
+    TSmallVec<TTag> SystemColumnTags; 
     TKqpTableStats& ShardTableStats;
     TKqpTableStats& TaskTableStats;
-    const NTable::TScheme::TTableInfo* TableInfo;
-    TSmallVec<NScheme::TTypeId> CellTypes;
-    mutable bool Finished = false;
-};
-
+    const NTable::TScheme::TTableInfo* TableInfo; 
+    TSmallVec<NScheme::TTypeId> CellTypes; 
+    mutable bool Finished = false; 
+}; 
+ 
 class TKqpLookupTableWrapper : public TStatelessFlowComputationNode<TKqpLookupTableWrapper> {
     using TBase = TStatelessFlowComputationNode<TKqpLookupTableWrapper>;
-
-public:
-    TKqpLookupTableWrapper(TComputationMutables& mutables, TKqpDatashardComputeContext& computeCtx,
-        const TTypeEnvironment& typeEnv, const TParseLookupTableResult& parseResult, IComputationNode* lookupKeysNode)
+ 
+public: 
+    TKqpLookupTableWrapper(TComputationMutables& mutables, TKqpDatashardComputeContext& computeCtx, 
+        const TTypeEnvironment& typeEnv, const TParseLookupTableResult& parseResult, IComputationNode* lookupKeysNode) 
         : TBase(mutables, this, EValueRepresentation::Boxed)
-        , ComputeCtx(computeCtx)
-        , TypeEnv(typeEnv)
-        , ParseResult(parseResult)
-        , LookupKeysNode(lookupKeysNode)
-        , LocalTid(ComputeCtx.GetLocalTableId(ParseResult.TableId))
-        , ColumnTags(ExtractTags(ParseResult.Columns))
-        , SystemColumnTags(ExtractTags(ParseResult.SystemColumns))
+        , ComputeCtx(computeCtx) 
+        , TypeEnv(typeEnv) 
+        , ParseResult(parseResult) 
+        , LookupKeysNode(lookupKeysNode) 
+        , LocalTid(ComputeCtx.GetLocalTableId(ParseResult.TableId)) 
+        , ColumnTags(ExtractTags(ParseResult.Columns)) 
+        , SystemColumnTags(ExtractTags(ParseResult.SystemColumns)) 
         , ShardTableStats(ComputeCtx.GetDatashardCounters())
         , TaskTableStats(ComputeCtx.GetTaskCounters(computeCtx.GetCurrentTaskId()))
-        , TableInfo(ComputeCtx.Database->GetScheme().GetTableInfo(LocalTid))
-    {
-        MKQL_ENSURE_S(TableInfo);
-    }
-
-    TUnboxedValue DoCalculate(TComputationContext& ctx) const {
-        while (!Finished) {
-            if (!Iterator) {
-                auto keysValues = LookupKeysNode->GetValue(ctx);
-
-                NUdf::TUnboxedValue key;
-                auto status = keysValues.Fetch(key);
-
-                switch (status) {
-                    case NUdf::EFetchStatus::Ok: {
-                        TVector<TCell> fromCells(TableInfo->KeyColumns.size());
-                        FillKeyTupleValue(key, ParseResult.KeyIndices, ParseResult.KeyTypes, fromCells, TypeEnv);
-
-                        TVector<TCell> toCells(ParseResult.KeyIndices.size());
-                        FillKeyTupleValue(key, ParseResult.KeyIndices, ParseResult.KeyTypes, toCells, TypeEnv);
-
-                        auto range = TTableRange(fromCells, true, toCells, true);
-
-                        TSmallVec<TRawTypeValue> from, to;
-                        ConvertTableKeys(ComputeCtx.Database->GetScheme(), TableInfo, range.From, from, nullptr);
-                        ConvertTableKeys(ComputeCtx.Database->GetScheme(), TableInfo, range.To, to, nullptr);
-
-                        NTable::TKeyRange keyRange;
-                        keyRange.MinKey = from;
-                        keyRange.MaxKey = to;
-                        keyRange.MinInclusive = range.InclusiveFrom;
-                        keyRange.MaxInclusive = range.InclusiveTo;
-
-                        ComputeCtx.ReadTable(ParseResult.TableId, range);
+        , TableInfo(ComputeCtx.Database->GetScheme().GetTableInfo(LocalTid)) 
+    { 
+        MKQL_ENSURE_S(TableInfo); 
+    } 
+ 
+    TUnboxedValue DoCalculate(TComputationContext& ctx) const { 
+        while (!Finished) { 
+            if (!Iterator) { 
+                auto keysValues = LookupKeysNode->GetValue(ctx); 
+ 
+                NUdf::TUnboxedValue key; 
+                auto status = keysValues.Fetch(key); 
+ 
+                switch (status) { 
+                    case NUdf::EFetchStatus::Ok: { 
+                        TVector<TCell> fromCells(TableInfo->KeyColumns.size()); 
+                        FillKeyTupleValue(key, ParseResult.KeyIndices, ParseResult.KeyTypes, fromCells, TypeEnv); 
+ 
+                        TVector<TCell> toCells(ParseResult.KeyIndices.size()); 
+                        FillKeyTupleValue(key, ParseResult.KeyIndices, ParseResult.KeyTypes, toCells, TypeEnv); 
+ 
+                        auto range = TTableRange(fromCells, true, toCells, true); 
+ 
+                        TSmallVec<TRawTypeValue> from, to; 
+                        ConvertTableKeys(ComputeCtx.Database->GetScheme(), TableInfo, range.From, from, nullptr); 
+                        ConvertTableKeys(ComputeCtx.Database->GetScheme(), TableInfo, range.To, to, nullptr); 
+ 
+                        NTable::TKeyRange keyRange; 
+                        keyRange.MinKey = from; 
+                        keyRange.MaxKey = to; 
+                        keyRange.MinInclusive = range.InclusiveFrom; 
+                        keyRange.MaxInclusive = range.InclusiveTo; 
+ 
+                        ComputeCtx.ReadTable(ParseResult.TableId, range); 
                         Iterator = ComputeCtx.Database->IterateRange(LocalTid, keyRange, ColumnTags, ComputeCtx.GetReadVersion());
-                        break;
-                    }
-
-                    case NUdf::EFetchStatus::Finish:
-                        Finished = true;
-                        return TUnboxedValue::MakeFinish();
-
-                    case NUdf::EFetchStatus::Yield:
-                        return TUnboxedValue::MakeYield();
-                }
-            }
-
-            TUnboxedValue result;
+                        break; 
+                    } 
+ 
+                    case NUdf::EFetchStatus::Finish: 
+                        Finished = true; 
+                        return TUnboxedValue::MakeFinish(); 
+ 
+                    case NUdf::EFetchStatus::Yield: 
+                        return TUnboxedValue::MakeYield(); 
+                } 
+            } 
+ 
+            TUnboxedValue result; 
             TKqpTableStats tableStats;
             auto fetched = TryFetchRow(*Iterator, result, ctx, tableStats, ComputeCtx, SystemColumnTags, ParseResult.SkipNullKeys);
 
@@ -281,67 +281,67 @@ public:
             TaskTableStats.InvisibleRowSkips += invisibleRowSkips;
 
             if (fetched) {
-                return result;
-            }
-
-            if (Iterator->Last() == NTable::EReady::Page) {
+                return result; 
+            } 
+ 
+            if (Iterator->Last() == NTable::EReady::Page) { 
                 ComputeCtx.SetTabletNotReady();
                 return TUnboxedValue::MakeYield();
-            }
-
-            Iterator = nullptr;
-        }
-
-        return TUnboxedValue::MakeFinish();
-    }
-
-private:
-    void RegisterDependencies() const final {
-        this->FlowDependsOn(LookupKeysNode);
-    }
-
-private:
-    TKqpDatashardComputeContext& ComputeCtx;
-    const TTypeEnvironment& TypeEnv;
-    TParseLookupTableResult ParseResult;
-    IComputationNode* LookupKeysNode;
-    ui64 LocalTid;
-    TSmallVec<TTag> ColumnTags;
-    TSmallVec<TTag> SystemColumnTags;
+            } 
+ 
+            Iterator = nullptr; 
+        } 
+ 
+        return TUnboxedValue::MakeFinish(); 
+    } 
+ 
+private: 
+    void RegisterDependencies() const final { 
+        this->FlowDependsOn(LookupKeysNode); 
+    } 
+ 
+private: 
+    TKqpDatashardComputeContext& ComputeCtx; 
+    const TTypeEnvironment& TypeEnv; 
+    TParseLookupTableResult ParseResult; 
+    IComputationNode* LookupKeysNode; 
+    ui64 LocalTid; 
+    TSmallVec<TTag> ColumnTags; 
+    TSmallVec<TTag> SystemColumnTags; 
     TKqpTableStats& ShardTableStats;
     TKqpTableStats& TaskTableStats;
-    const NTable::TScheme::TTableInfo* TableInfo;
-    mutable TAutoPtr<NTable::TTableIt> Iterator;
-    mutable bool Finished = false;
-};
-
-IComputationNode* WrapKqpLookupTableInternal(TCallable& callable, const TComputationNodeFactoryContext& ctx,
-    TKqpDatashardComputeContext& computeCtx)
-{
-    auto parseResult = ParseLookupTable(callable);
-    auto lookupKeysNode = LocateNode(ctx.NodeLocator, *parseResult.LookupKeys.GetNode());
-
-    auto keyColumns = computeCtx.GetKeyColumnsMap(parseResult.TableId);
-    ValidateLookupKeys(parseResult.LookupKeys.GetStaticType(), keyColumns);
-
-    auto localTid = computeCtx.GetLocalTableId(parseResult.TableId);
-    auto tableInfo = computeCtx.Database->GetScheme().GetTableInfo(localTid);
-    MKQL_ENSURE_S(tableInfo);
-
-    if (tableInfo->KeyColumns.size() == parseResult.KeyIndices.size()) {
+    const NTable::TScheme::TTableInfo* TableInfo; 
+    mutable TAutoPtr<NTable::TTableIt> Iterator; 
+    mutable bool Finished = false; 
+}; 
+ 
+IComputationNode* WrapKqpLookupTableInternal(TCallable& callable, const TComputationNodeFactoryContext& ctx, 
+    TKqpDatashardComputeContext& computeCtx) 
+{ 
+    auto parseResult = ParseLookupTable(callable); 
+    auto lookupKeysNode = LocateNode(ctx.NodeLocator, *parseResult.LookupKeys.GetNode()); 
+ 
+    auto keyColumns = computeCtx.GetKeyColumnsMap(parseResult.TableId); 
+    ValidateLookupKeys(parseResult.LookupKeys.GetStaticType(), keyColumns); 
+ 
+    auto localTid = computeCtx.GetLocalTableId(parseResult.TableId); 
+    auto tableInfo = computeCtx.Database->GetScheme().GetTableInfo(localTid); 
+    MKQL_ENSURE_S(tableInfo); 
+ 
+    if (tableInfo->KeyColumns.size() == parseResult.KeyIndices.size()) { 
         return new TKqpLookupRowsWrapper(ctx.Mutables, computeCtx, ctx.Env, parseResult, lookupKeysNode);
-    } else {
+    } else { 
         return new TKqpLookupTableWrapper(ctx.Mutables, computeCtx, ctx.Env, parseResult, lookupKeysNode);
-    }
-}
-
-} // namespace
-
-IComputationNode* WrapKqpLookupTable(TCallable& callable, const TComputationNodeFactoryContext& ctx,
-    TKqpDatashardComputeContext& computeCtx)
-{
+    } 
+} 
+ 
+} // namespace 
+ 
+IComputationNode* WrapKqpLookupTable(TCallable& callable, const TComputationNodeFactoryContext& ctx, 
+    TKqpDatashardComputeContext& computeCtx) 
+{ 
     return WrapKqpLookupTableInternal(callable, ctx, computeCtx);
-}
-
-} // namespace NMiniKQL
-} // namespace NKikimr
+} 
+ 
+} // namespace NMiniKQL 
+} // namespace NKikimr 
diff --git a/ydb/core/tx/datashard/datashard_kqp_read_table.cpp b/ydb/core/tx/datashard/datashard_kqp_read_table.cpp
index 9fbd8ef0ad..fd0a7184f2 100644
--- a/ydb/core/tx/datashard/datashard_kqp_read_table.cpp
+++ b/ydb/core/tx/datashard/datashard_kqp_read_table.cpp
@@ -1,79 +1,79 @@
-#include "datashard_kqp_compute.h"
-
+#include "datashard_kqp_compute.h" 
+ 
 #include <ydb/core/engine/minikql/minikql_engine_host.h>
 #include <ydb/core/kqp/runtime/kqp_read_table.h>
 #include <ydb/core/scheme/scheme_tabledefs.h>
 #include <ydb/core/tablet_flat/flat_database.h>
 #include <ydb/core/util/yverify_stream.h>
-
+ 
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_holders.h>
-
-namespace NKikimr {
-namespace NMiniKQL {
-
-using namespace NTable;
-using namespace NUdf;
-
+ 
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
+using namespace NTable; 
+using namespace NUdf; 
+ 
 namespace {
 
-void ValidateKeyType(const TType* keyType, const std::pair<NScheme::TTypeId, TString>& keyColumn) {
-    auto type = keyType;
-
-    if (type->IsOptional()) {
-        type = AS_TYPE(TOptionalType, type)->GetItemType();
-    }
-
-    auto dataType = AS_TYPE(TDataType, type)->GetSchemeType();
-
-    MKQL_ENSURE_S(dataType == keyColumn.first);
-}
-
-void ValidateKeyTuple(const TTupleType* tupleType, const TVector<std::pair<NScheme::TTypeId, TString>>& keyColumns) {
-    MKQL_ENSURE_S(tupleType);
-    MKQL_ENSURE_S(tupleType->GetElementsCount() <= keyColumns.size());
-
-    for (ui32 i = 0; i < tupleType->GetElementsCount(); ++i) {
-        ValidateKeyType(tupleType->GetElementType(i), keyColumns[i]);
-    }
-}
-
-void ValidateRangeBound(const TTupleType* tupleType, const TVector<std::pair<NScheme::TTypeId, TString>>& keyColumns) {
-    MKQL_ENSURE_S(tupleType);
-    MKQL_ENSURE_S(tupleType->GetElementsCount() == keyColumns.size() + 1);
-
-    for (ui32 i = 0; i < keyColumns.size(); ++i) {
-        auto elementType = tupleType->GetElementType(i);
-        ValidateKeyType(AS_TYPE(TOptionalType, elementType)->GetItemType(), keyColumns[i]);
-    }
-}
-
-struct TKeyRangesType {
-    TTupleType* From = nullptr;
-    TTupleType* To = nullptr;
-};
-
-TMaybe<TKeyRangesType> ParseKeyRangesType(const TTupleType* rangeTupleType) {
-    MKQL_ENSURE_S(rangeTupleType);
-    MKQL_ENSURE_S(rangeTupleType->GetElementsCount() == 1);
-
-    auto rangesType = rangeTupleType->GetElementType(0);
-    if (rangesType->GetKind() == TType::EKind::Void) {
-        return {};
-    }
-
-    auto listType = AS_TYPE(TListType, AS_TYPE(TTupleType, rangesType)->GetElementType(0));
-    auto tupleType = AS_TYPE(TTupleType, listType->GetItemType());
-    MKQL_ENSURE_S(tupleType->GetElementsCount() == 2);
-
-    auto fromType = AS_TYPE(TTupleType, tupleType->GetElementType(0));
-    auto toType = AS_TYPE(TTupleType, tupleType->GetElementType(1));
-
-    return TKeyRangesType {
-        .From = fromType,
-        .To = toType
-    };
-}
-
+void ValidateKeyType(const TType* keyType, const std::pair<NScheme::TTypeId, TString>& keyColumn) { 
+    auto type = keyType; 
+ 
+    if (type->IsOptional()) { 
+        type = AS_TYPE(TOptionalType, type)->GetItemType(); 
+    } 
+ 
+    auto dataType = AS_TYPE(TDataType, type)->GetSchemeType(); 
+ 
+    MKQL_ENSURE_S(dataType == keyColumn.first); 
+} 
+ 
+void ValidateKeyTuple(const TTupleType* tupleType, const TVector<std::pair<NScheme::TTypeId, TString>>& keyColumns) { 
+    MKQL_ENSURE_S(tupleType); 
+    MKQL_ENSURE_S(tupleType->GetElementsCount() <= keyColumns.size()); 
+ 
+    for (ui32 i = 0; i < tupleType->GetElementsCount(); ++i) { 
+        ValidateKeyType(tupleType->GetElementType(i), keyColumns[i]); 
+    } 
+} 
+ 
+void ValidateRangeBound(const TTupleType* tupleType, const TVector<std::pair<NScheme::TTypeId, TString>>& keyColumns) { 
+    MKQL_ENSURE_S(tupleType); 
+    MKQL_ENSURE_S(tupleType->GetElementsCount() == keyColumns.size() + 1); 
+ 
+    for (ui32 i = 0; i < keyColumns.size(); ++i) { 
+        auto elementType = tupleType->GetElementType(i); 
+        ValidateKeyType(AS_TYPE(TOptionalType, elementType)->GetItemType(), keyColumns[i]); 
+    } 
+} 
+ 
+struct TKeyRangesType { 
+    TTupleType* From = nullptr; 
+    TTupleType* To = nullptr; 
+}; 
+ 
+TMaybe<TKeyRangesType> ParseKeyRangesType(const TTupleType* rangeTupleType) { 
+    MKQL_ENSURE_S(rangeTupleType); 
+    MKQL_ENSURE_S(rangeTupleType->GetElementsCount() == 1); 
+ 
+    auto rangesType = rangeTupleType->GetElementType(0); 
+    if (rangesType->GetKind() == TType::EKind::Void) { 
+        return {}; 
+    } 
+ 
+    auto listType = AS_TYPE(TListType, AS_TYPE(TTupleType, rangesType)->GetElementType(0)); 
+    auto tupleType = AS_TYPE(TTupleType, listType->GetItemType()); 
+    MKQL_ENSURE_S(tupleType->GetElementsCount() == 2); 
+ 
+    auto fromType = AS_TYPE(TTupleType, tupleType->GetElementType(0)); 
+    auto toType = AS_TYPE(TTupleType, tupleType->GetElementType(1)); 
+ 
+    return TKeyRangesType { 
+        .From = fromType, 
+        .To = toType 
+    }; 
+} 
+ 
 TSerializedTableRange CreateTableRange(const TParseReadTableResult& parseResult, const IComputationNode* fromNode,
     const IComputationNode* toNode, const TTypeEnvironment& typeEnv, TComputationContext& ctx)
 {
@@ -159,8 +159,8 @@ template <bool IsReverse>
 TVector<TSerializedTableRange> CreateTableRanges(const TParseReadTableRangesResult& parseResult,
     const IComputationNode* rangesNode, const TTypeEnvironment& typeEnv, TComputationContext& ctx, ui32 keyColumnsSize)
 {
-    auto keyRangesType = ParseKeyRangesType(parseResult.Ranges->GetType());
-    if (!keyRangesType) {
+    auto keyRangesType = ParseKeyRangesType(parseResult.Ranges->GetType()); 
+    if (!keyRangesType) { 
         return {BuildFullRange(keyColumnsSize)};
     }
 
@@ -173,7 +173,7 @@ TVector<TSerializedTableRange> CreateTableRanges(const TParseReadTableRangesResu
         const auto& from = tuple.GetElement(0);
         const auto& to = tuple.GetElement(1);
 
-        ranges.emplace_back(BuildRange(keyRangesType->From, from, keyRangesType->To, to, typeEnv, keyColumnsSize));
+        ranges.emplace_back(BuildRange(keyRangesType->From, from, keyRangesType->To, to, typeEnv, keyColumnsSize)); 
     }
 
     if constexpr (IsReverse) {
@@ -474,67 +474,67 @@ private:
     mutable std::optional<ui32> RangeId;
 };
 
-void FetchRowImpl(const TDbTupleRef& dbTuple, TUnboxedValue& row, TComputationContext& ctx, TKqpTableStats& tableStats,
-    const TKqpDatashardComputeContext& computeCtx, const TSmallVec<TTag>& systemColumnTags)
-{
-    size_t columnsCount = dbTuple.ColumnCount + systemColumnTags.size();
-
-    TUnboxedValue* rowItems = nullptr;
-    row = ctx.HolderFactory.CreateDirectArrayHolder(columnsCount, rowItems);
-
-    ui64 rowSize = 0;
-    for (ui32 i = 0; i < dbTuple.ColumnCount; ++i) {
-        rowSize += dbTuple.Columns[i].IsNull() ? 1 : dbTuple.Columns[i].Size();
-        rowItems[i] = GetCellValue(dbTuple.Cells()[i], dbTuple.Types[i]);
-    }
-
-    // Some per-row overhead to deal with the case when no columns were requested
-    rowSize = std::max(rowSize, (ui64)8);
-
-    for (ui32 i = dbTuple.ColumnCount, j = 0; i < columnsCount; ++i, ++j) {
-        switch (systemColumnTags[j]) {
-            case TKeyDesc::EColumnIdDataShard:
-                rowItems[i] = TUnboxedValue(TUnboxedValuePod(computeCtx.GetShardId()));
-                break;
-            default:
-                throw TSchemeErrorTabletException();
-        }
-    }
-
+void FetchRowImpl(const TDbTupleRef& dbTuple, TUnboxedValue& row, TComputationContext& ctx, TKqpTableStats& tableStats, 
+    const TKqpDatashardComputeContext& computeCtx, const TSmallVec<TTag>& systemColumnTags) 
+{ 
+    size_t columnsCount = dbTuple.ColumnCount + systemColumnTags.size(); 
+
+    TUnboxedValue* rowItems = nullptr; 
+    row = ctx.HolderFactory.CreateDirectArrayHolder(columnsCount, rowItems); 
+ 
+    ui64 rowSize = 0; 
+    for (ui32 i = 0; i < dbTuple.ColumnCount; ++i) { 
+        rowSize += dbTuple.Columns[i].IsNull() ? 1 : dbTuple.Columns[i].Size(); 
+        rowItems[i] = GetCellValue(dbTuple.Cells()[i], dbTuple.Types[i]); 
+    } 
+ 
+    // Some per-row overhead to deal with the case when no columns were requested 
+    rowSize = std::max(rowSize, (ui64)8); 
+ 
+    for (ui32 i = dbTuple.ColumnCount, j = 0; i < columnsCount; ++i, ++j) { 
+        switch (systemColumnTags[j]) { 
+            case TKeyDesc::EColumnIdDataShard: 
+                rowItems[i] = TUnboxedValue(TUnboxedValuePod(computeCtx.GetShardId())); 
+                break; 
+            default: 
+                throw TSchemeErrorTabletException(); 
+        } 
+    } 
+ 
     tableStats.NSelectRow++;
     tableStats.SelectRowRows++;
     tableStats.SelectRowBytes += rowSize;
-}
-
+} 
+ 
 template <typename TTableIterator>
 bool TryFetchRowImpl(TTableIterator& iterator, TUnboxedValue& row, TComputationContext& ctx, TKqpTableStats& tableStats,
-    const TKqpDatashardComputeContext& computeCtx, const TSmallVec<TTag>& systemColumnTags,
-    const TSmallVec<bool>& skipNullKeys)
-{
-    while (iterator.Next(NTable::ENext::Data) == NTable::EReady::Data) {
-        TDbTupleRef rowKey = iterator.GetKey();
-
-        Y_VERIFY(skipNullKeys.size() <= rowKey.ColumnCount);
-        bool skipRow = false;
-        for (ui32 i = 0; i < skipNullKeys.size(); ++i) {
-            if (skipNullKeys[i] && rowKey.Columns[i].IsNull()) {
-                skipRow = true;
-                break;
-            }
-        }
-
-        if (skipRow) {
-            continue;
-        }
-
-        TDbTupleRef rowValues = iterator.GetValues();
-        FetchRowImpl(rowValues, row, ctx, tableStats, computeCtx, systemColumnTags);
-        return true;
-    }
-
-    return false;
-}
-
+    const TKqpDatashardComputeContext& computeCtx, const TSmallVec<TTag>& systemColumnTags, 
+    const TSmallVec<bool>& skipNullKeys) 
+{ 
+    while (iterator.Next(NTable::ENext::Data) == NTable::EReady::Data) { 
+        TDbTupleRef rowKey = iterator.GetKey(); 
+ 
+        Y_VERIFY(skipNullKeys.size() <= rowKey.ColumnCount); 
+        bool skipRow = false; 
+        for (ui32 i = 0; i < skipNullKeys.size(); ++i) { 
+            if (skipNullKeys[i] && rowKey.Columns[i].IsNull()) { 
+                skipRow = true; 
+                break; 
+            } 
+        } 
+ 
+        if (skipRow) { 
+            continue; 
+        } 
+ 
+        TDbTupleRef rowValues = iterator.GetValues(); 
+        FetchRowImpl(rowValues, row, ctx, tableStats, computeCtx, systemColumnTags); 
+        return true; 
+    } 
+ 
+    return false; 
+} 
+ 
 } // namespace
 
 bool TryFetchRow(TTableIt& iterator, TUnboxedValue& row, TComputationContext& ctx, TKqpTableStats& tableStats,
@@ -551,25 +551,25 @@ bool TryFetchRow(TTableReverseIt& iterator, TUnboxedValue& row, TComputationCont
     return TryFetchRowImpl(iterator, row, ctx, tableStats, computeCtx, systemColumnTags, skipNullKeys);
 }
 
-void FetchRow(const TDbTupleRef& dbTuple, TUnboxedValue& row, TComputationContext& ctx, TKqpTableStats& tableStats,
-    const TKqpDatashardComputeContext& computeCtx, const TSmallVec<TTag>& systemColumnTags)
-{
-    return FetchRowImpl(dbTuple, row, ctx, tableStats, computeCtx, systemColumnTags);
-}
-
+void FetchRow(const TDbTupleRef& dbTuple, TUnboxedValue& row, TComputationContext& ctx, TKqpTableStats& tableStats, 
+    const TKqpDatashardComputeContext& computeCtx, const TSmallVec<TTag>& systemColumnTags) 
+{ 
+    return FetchRowImpl(dbTuple, row, ctx, tableStats, computeCtx, systemColumnTags); 
+} 
+ 
 IComputationNode* WrapKqpWideReadTableRanges(TCallable& callable, const TComputationNodeFactoryContext& ctx,
     TKqpDatashardComputeContext& computeCtx)
 {
     auto parseResult = ParseWideReadTableRanges(callable);
     auto rangesNode = LocateNode(ctx.NodeLocator, *parseResult.Ranges);
 
-    auto keyColumns = computeCtx.GetKeyColumnsInfo(parseResult.TableId);
-    auto keyRangesType = ParseKeyRangesType(parseResult.Ranges->GetType());
-    if (keyRangesType) {
-        ValidateRangeBound(keyRangesType->From, keyColumns);
-        ValidateRangeBound(keyRangesType->To, keyColumns);
-    }
-
+    auto keyColumns = computeCtx.GetKeyColumnsInfo(parseResult.TableId); 
+    auto keyRangesType = ParseKeyRangesType(parseResult.Ranges->GetType()); 
+    if (keyRangesType) { 
+        ValidateRangeBound(keyRangesType->From, keyColumns); 
+        ValidateRangeBound(keyRangesType->To, keyColumns); 
+    } 
+ 
     IComputationNode* itemsLimit = nullptr;
     if (parseResult.ItemsLimit) {
         itemsLimit = LocateNode(ctx.NodeLocator, *parseResult.ItemsLimit);
@@ -589,10 +589,10 @@ IComputationNode* WrapKqpWideReadTable(TCallable& callable, const TComputationNo
     auto fromNode = LocateNode(ctx.NodeLocator, *parseResult.FromTuple);
     auto toNode = LocateNode(ctx.NodeLocator, *parseResult.ToTuple);
 
-    auto keyColumns = computeCtx.GetKeyColumnsInfo(parseResult.TableId);
-    ValidateKeyTuple(parseResult.FromTuple->GetType(), keyColumns);
-    ValidateKeyTuple(parseResult.ToTuple->GetType(), keyColumns);
-
+    auto keyColumns = computeCtx.GetKeyColumnsInfo(parseResult.TableId); 
+    ValidateKeyTuple(parseResult.FromTuple->GetType(), keyColumns); 
+    ValidateKeyTuple(parseResult.ToTuple->GetType(), keyColumns); 
+ 
     IComputationNode* itemsLimit = nullptr;
     if (parseResult.ItemsLimit) {
         itemsLimit = LocateNode(ctx.NodeLocator, *parseResult.ItemsLimit);
@@ -606,4 +606,4 @@ IComputationNode* WrapKqpWideReadTable(TCallable& callable, const TComputationNo
 }
 
 } // namespace NMiniKQL
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/tx/datashard/datashard_kqp_upsert_rows.cpp b/ydb/core/tx/datashard/datashard_kqp_upsert_rows.cpp
index a2dfa61bbf..a8c518a889 100644
--- a/ydb/core/tx/datashard/datashard_kqp_upsert_rows.cpp
+++ b/ydb/core/tx/datashard/datashard_kqp_upsert_rows.cpp
@@ -1,233 +1,233 @@
-#include "datashard_kqp_compute.h"
+#include "datashard_kqp_compute.h" 
 #include "datashard_user_table.h"
-
+ 
 #include <ydb/core/engine/mkql_keys.h>
 #include <ydb/core/engine/mkql_engine_flat_host.h>
 #include <ydb/core/kqp/runtime/kqp_runtime_impl.h>
-
+ 
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_holders.h>
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_impl.h>
 #include <ydb/library/yql/minikql/mkql_node.h>
 #include <ydb/library/yql/minikql/mkql_node_cast.h>
-
-#include <util/generic/cast.h>
-
-namespace NKikimr {
-namespace NMiniKQL {
-
-using namespace NTable;
-using namespace NUdf;
-
-namespace {
-
-struct TUpsertColumn {
-    ui32 ColumnId;
-    ui32 RowIndex;
-};
-
-class TKqpUpsertRowsWrapper : public TMutableComputationNode<TKqpUpsertRowsWrapper> {
-    using TBase = TMutableComputationNode<TKqpUpsertRowsWrapper>;
-
-public:
-    class TRowResult : public TComputationValue<TRowResult> {
-        using TBase = TComputationValue<TRowResult>;
-
-    public:
-        TRowResult(TMemoryUsageInfo* memInfo, const TKqpUpsertRowsWrapper& owner,
-            NUdf::TUnboxedValue&& row)
-            : TBase(memInfo)
-            , Owner(owner)
-            , Row(std::move(row)) {}
-
-    private:
-        void Apply(NUdf::IApplyContext& applyContext) const override {
-            auto& dsApplyCtx = *CheckedCast<TKqpDatashardApplyContext*>(&applyContext);
-
+ 
+#include <util/generic/cast.h> 
+ 
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
+using namespace NTable; 
+using namespace NUdf; 
+ 
+namespace { 
+ 
+struct TUpsertColumn { 
+    ui32 ColumnId; 
+    ui32 RowIndex; 
+}; 
+ 
+class TKqpUpsertRowsWrapper : public TMutableComputationNode<TKqpUpsertRowsWrapper> { 
+    using TBase = TMutableComputationNode<TKqpUpsertRowsWrapper>; 
+ 
+public: 
+    class TRowResult : public TComputationValue<TRowResult> { 
+        using TBase = TComputationValue<TRowResult>; 
+ 
+    public: 
+        TRowResult(TMemoryUsageInfo* memInfo, const TKqpUpsertRowsWrapper& owner, 
+            NUdf::TUnboxedValue&& row) 
+            : TBase(memInfo) 
+            , Owner(owner) 
+            , Row(std::move(row)) {} 
+ 
+    private: 
+        void Apply(NUdf::IApplyContext& applyContext) const override { 
+            auto& dsApplyCtx = *CheckedCast<TKqpDatashardApplyContext*>(&applyContext); 
+ 
             TVector<TCell> keyTuple(Owner.KeyIndices.size());
             FillKeyTupleValue(Row, Owner.KeyIndices, Owner.RowTypes, keyTuple, Owner.Env);
-
-            if (dsApplyCtx.Host->IsPathErased(Owner.TableId)) {
-                return;
-            }
-
-            if (!dsApplyCtx.Host->IsMyKey(Owner.TableId, keyTuple)) {
-                return;
-            }
-
-            TVector<IEngineFlatHost::TUpdateCommand> commands;
-            commands.reserve(Owner.UpsertColumns.size());
-
-            for (auto& upsertColumn : Owner.UpsertColumns) {
-                IEngineFlatHost::TUpdateCommand command;
-                command.Column = upsertColumn.ColumnId;
-                command.Operation = TKeyDesc::EColumnOperation::Set;
-                auto rowIndex = upsertColumn.RowIndex;
-
-                NUdf::TDataTypeId type = Owner.RowTypes[rowIndex];
-                NUdf::TUnboxedValue value = Row.GetElement(rowIndex);
-
-                if (value) {
-                    auto slot = NUdf::GetDataSlot(type);
-                    MKQL_ENSURE(IsValidValue(slot, value),
-                        "Malformed value for type: " << NUdf::GetDataTypeInfo(slot).Name << ", " << value);
-                }
-
-                // NOTE: We have to copy values here as some values inlined in TUnboxedValue
+ 
+            if (dsApplyCtx.Host->IsPathErased(Owner.TableId)) { 
+                return; 
+            } 
+ 
+            if (!dsApplyCtx.Host->IsMyKey(Owner.TableId, keyTuple)) { 
+                return; 
+            } 
+ 
+            TVector<IEngineFlatHost::TUpdateCommand> commands; 
+            commands.reserve(Owner.UpsertColumns.size()); 
+ 
+            for (auto& upsertColumn : Owner.UpsertColumns) { 
+                IEngineFlatHost::TUpdateCommand command; 
+                command.Column = upsertColumn.ColumnId; 
+                command.Operation = TKeyDesc::EColumnOperation::Set; 
+                auto rowIndex = upsertColumn.RowIndex; 
+ 
+                NUdf::TDataTypeId type = Owner.RowTypes[rowIndex]; 
+                NUdf::TUnboxedValue value = Row.GetElement(rowIndex); 
+ 
+                if (value) { 
+                    auto slot = NUdf::GetDataSlot(type); 
+                    MKQL_ENSURE(IsValidValue(slot, value), 
+                        "Malformed value for type: " << NUdf::GetDataTypeInfo(slot).Name << ", " << value); 
+                } 
+ 
+                // NOTE: We have to copy values here as some values inlined in TUnboxedValue 
                 // cannot be inlined in TCell.
-                command.Value = MakeCell(type, value, Owner.Env, true);
-
-                commands.emplace_back(std::move(command));
-            }
-
+                command.Value = MakeCell(type, value, Owner.Env, true); 
+ 
+                commands.emplace_back(std::move(command)); 
+            } 
+ 
             ui64 nUpdateRow = Owner.ShardTableStats.NUpdateRow;
             ui64 updateRowBytes = Owner.ShardTableStats.UpdateRowBytes;
 
-            dsApplyCtx.Host->UpdateRow(Owner.TableId, keyTuple, commands);
+            dsApplyCtx.Host->UpdateRow(Owner.TableId, keyTuple, commands); 
 
             if (i64 delta = Owner.ShardTableStats.NUpdateRow - nUpdateRow; delta > 0) {
                 Owner.TaskTableStats.NUpdateRow += delta;
                 Owner.TaskTableStats.UpdateRowBytes += Owner.ShardTableStats.UpdateRowBytes - updateRowBytes;
             }
-        };
-
-    private:
-        const TKqpUpsertRowsWrapper& Owner;
-        NUdf::TUnboxedValue Row;
-    };
-
-    class TRowsResult : public TComputationValue<TRowsResult> {
-        using TBase = TComputationValue<TRowsResult>;
-
-    public:
-        TRowsResult(TMemoryUsageInfo* memInfo, const TKqpUpsertRowsWrapper& owner,
-            NUdf::TUnboxedValue&& rows)
-            : TBase(memInfo)
-            , Owner(owner)
-            , Rows(std::move(rows)) {}
-
-        NUdf::EFetchStatus Fetch(NUdf::TUnboxedValue& result) final {
-            NUdf::TUnboxedValue row;
-            auto status = Rows.Fetch(row);
-
-            if (status == NUdf::EFetchStatus::Ok) {
-                result = NUdf::TUnboxedValuePod(new TRowResult(GetMemInfo(), Owner, std::move(row)));
-            }
-
-            return status;
-        }
-
-    private:
-        const TKqpUpsertRowsWrapper& Owner;
-        NUdf::TUnboxedValue Rows;
-    };
-
-    NUdf::TUnboxedValuePod DoCalculate(TComputationContext& ctx) const {
-        return ctx.HolderFactory.Create<TRowsResult>(*this, RowsNode->GetValue(ctx));
-    }
-
-public:
+        }; 
+ 
+    private: 
+        const TKqpUpsertRowsWrapper& Owner; 
+        NUdf::TUnboxedValue Row; 
+    }; 
+ 
+    class TRowsResult : public TComputationValue<TRowsResult> { 
+        using TBase = TComputationValue<TRowsResult>; 
+ 
+    public: 
+        TRowsResult(TMemoryUsageInfo* memInfo, const TKqpUpsertRowsWrapper& owner, 
+            NUdf::TUnboxedValue&& rows) 
+            : TBase(memInfo) 
+            , Owner(owner) 
+            , Rows(std::move(rows)) {} 
+ 
+        NUdf::EFetchStatus Fetch(NUdf::TUnboxedValue& result) final { 
+            NUdf::TUnboxedValue row; 
+            auto status = Rows.Fetch(row); 
+ 
+            if (status == NUdf::EFetchStatus::Ok) { 
+                result = NUdf::TUnboxedValuePod(new TRowResult(GetMemInfo(), Owner, std::move(row))); 
+            } 
+ 
+            return status; 
+        } 
+ 
+    private: 
+        const TKqpUpsertRowsWrapper& Owner; 
+        NUdf::TUnboxedValue Rows; 
+    }; 
+ 
+    NUdf::TUnboxedValuePod DoCalculate(TComputationContext& ctx) const { 
+        return ctx.HolderFactory.Create<TRowsResult>(*this, RowsNode->GetValue(ctx)); 
+    } 
+ 
+public: 
     TKqpUpsertRowsWrapper(TComputationMutables& mutables, TKqpDatashardComputeContext& computeCtx,
-        const TTableId& tableId, IComputationNode* rowsNode, TVector<NUdf::TDataTypeId>&& rowTypes,
-        TVector<ui32>&& keyIndices, TVector<TUpsertColumn>&& upsertColumns, const TTypeEnvironment& env)
-        : TBase(mutables)
-        , TableId(tableId)
-        , RowsNode(rowsNode)
-        , RowTypes(std::move(rowTypes))
-        , KeyIndices(std::move(keyIndices))
-        , UpsertColumns(std::move(upsertColumns))
+        const TTableId& tableId, IComputationNode* rowsNode, TVector<NUdf::TDataTypeId>&& rowTypes, 
+        TVector<ui32>&& keyIndices, TVector<TUpsertColumn>&& upsertColumns, const TTypeEnvironment& env) 
+        : TBase(mutables) 
+        , TableId(tableId) 
+        , RowsNode(rowsNode) 
+        , RowTypes(std::move(rowTypes)) 
+        , KeyIndices(std::move(keyIndices)) 
+        , UpsertColumns(std::move(upsertColumns)) 
         , Env(env)
         , ShardTableStats(computeCtx.GetDatashardCounters())
         , TaskTableStats(computeCtx.GetTaskCounters(computeCtx.GetCurrentTaskId())) {}
-
-private:
-    void RegisterDependencies() const final {
-        DependsOn(RowsNode);
-    }
-
-private:
-    TTableId TableId;
-    IComputationNode* RowsNode;
-    TVector<NUdf::TDataTypeId> RowTypes;
-    TVector<ui32> KeyIndices;
-    TVector<TUpsertColumn> UpsertColumns;
+ 
+private: 
+    void RegisterDependencies() const final { 
+        DependsOn(RowsNode); 
+    } 
+ 
+private: 
+    TTableId TableId; 
+    IComputationNode* RowsNode; 
+    TVector<NUdf::TDataTypeId> RowTypes; 
+    TVector<ui32> KeyIndices; 
+    TVector<TUpsertColumn> UpsertColumns; 
     const TTypeEnvironment& Env;
     TKqpTableStats& ShardTableStats;
     TKqpTableStats& TaskTableStats;
-};
-
-} // namespace
-
-IComputationNode* WrapKqpUpsertRows(TCallable& callable, const TComputationNodeFactoryContext& ctx,
-    TKqpDatashardComputeContext& computeCtx)
-{
+}; 
+ 
+} // namespace 
+ 
+IComputationNode* WrapKqpUpsertRows(TCallable& callable, const TComputationNodeFactoryContext& ctx, 
+    TKqpDatashardComputeContext& computeCtx) 
+{ 
     MKQL_ENSURE_S(callable.GetInputsCount() >= 3);
-
-    auto tableNode = callable.GetInput(0);
-    auto rowsNode = callable.GetInput(1);
+ 
+    auto tableNode = callable.GetInput(0); 
+    auto rowsNode = callable.GetInput(1); 
     auto upsertColumnsNode = callable.GetInput(2);
-
-    auto tableId = NKqp::ParseTableId(tableNode);
-    auto localTableId = computeCtx.GetLocalTableId(tableId);
-    MKQL_ENSURE_S(localTableId);
-    auto tableKeyTypes = computeCtx.GetKeyColumnsInfo(tableId);
-
+ 
+    auto tableId = NKqp::ParseTableId(tableNode); 
+    auto localTableId = computeCtx.GetLocalTableId(tableId); 
+    MKQL_ENSURE_S(localTableId); 
+    auto tableKeyTypes = computeCtx.GetKeyColumnsInfo(tableId); 
+ 
     auto tableInfo = computeCtx.GetTable(tableId);
     MKQL_ENSURE(tableInfo, "Table not found: " << tableId.PathId.ToString());
 
-    auto rowType = AS_TYPE(TStructType, AS_TYPE(TStreamType, rowsNode.GetStaticType())->GetItemType());
+    auto rowType = AS_TYPE(TStructType, AS_TYPE(TStreamType, rowsNode.GetStaticType())->GetItemType()); 
 
     MKQL_ENSURE_S(tableKeyTypes.size() <= rowType->GetMembersCount(), "not enough columns in the runtime node");
 
     THashMap<TString, ui32> inputIndex;
-    TVector<NUdf::TDataTypeId> rowTypes(rowType->GetMembersCount());
-    for (ui32 i = 0; i < rowTypes.size(); ++i) {
+    TVector<NUdf::TDataTypeId> rowTypes(rowType->GetMembersCount()); 
+    for (ui32 i = 0; i < rowTypes.size(); ++i) { 
         const auto& name = rowType->GetMemberName(i);
         MKQL_ENSURE_S(inputIndex.emplace(TString(name), i).second);
-        rowTypes[i] = NKqp::UnwrapDataTypeFromStruct(*rowType, i);
-    }
-
+        rowTypes[i] = NKqp::UnwrapDataTypeFromStruct(*rowType, i); 
+    } 
+ 
     TVector<ui32> keyIndices(tableKeyTypes.size());
     for (ui32 i = 0; i < tableKeyTypes.size(); i++) {
         auto it = inputIndex.find(tableKeyTypes[i].second);
         MKQL_ENSURE_S(it != inputIndex.end());
-        auto typeId = NKqp::UnwrapDataTypeFromStruct(*rowType, it->second);
+        auto typeId = NKqp::UnwrapDataTypeFromStruct(*rowType, it->second); 
         MKQL_ENSURE_S(typeId == tableKeyTypes[i].first, "row key type missmatch with table key type");
         keyIndices[i] = it->second;
-    }
-
-    for (const auto& [_, column] : tableInfo->Columns) {
-        if (column.NotNull) {
-            auto it = inputIndex.find(column.Name);
-            MKQL_ENSURE(it != inputIndex.end(),
-                "Not null column " << column.Name << " has to be specified in upsert");
-
-            auto columnType = rowType->GetMemberType(it->second);
-            MKQL_ENSURE(columnType->GetKind() != NMiniKQL::TType::EKind::Optional,
-                "Not null column " << column.Name << " can't be optional");
+    } 
+ 
+    for (const auto& [_, column] : tableInfo->Columns) { 
+        if (column.NotNull) { 
+            auto it = inputIndex.find(column.Name); 
+            MKQL_ENSURE(it != inputIndex.end(), 
+                "Not null column " << column.Name << " has to be specified in upsert"); 
+
+            auto columnType = rowType->GetMemberType(it->second); 
+            MKQL_ENSURE(columnType->GetKind() != NMiniKQL::TType::EKind::Optional, 
+                "Not null column " << column.Name << " can't be optional"); 
         }
     }
 
-    auto upsertColumnsDict = AS_VALUE(TDictLiteral, upsertColumnsNode);
-    TVector<TUpsertColumn> upsertColumns(upsertColumnsDict->GetItemsCount());
-    for (ui32 i = 0; i < upsertColumns.size(); ++i) {
-        auto item = upsertColumnsDict->GetItem(i);
-
-        auto& upsertColumn = upsertColumns[i];
-        upsertColumn.ColumnId = AS_VALUE(TDataLiteral, item.first)->AsValue().Get<ui32>();
-        upsertColumn.RowIndex = AS_VALUE(TDataLiteral, item.second)->AsValue().Get<ui32>();
-
-        auto tableColumn = tableInfo->Columns.FindPtr(upsertColumn.ColumnId);
-        MKQL_ENSURE_S(tableColumn);
-
-        MKQL_ENSURE_S(rowTypes[upsertColumn.RowIndex] == tableColumn->Type,
-            "upsert column type missmatch, column: " << tableColumn->Name);
-
-    }
-
-    return new TKqpUpsertRowsWrapper(ctx.Mutables, computeCtx, tableId,
-        LocateNode(ctx.NodeLocator, *rowsNode.GetNode()), std::move(rowTypes), std::move(keyIndices),
-        std::move(upsertColumns), ctx.Env);
-}
-
+    auto upsertColumnsDict = AS_VALUE(TDictLiteral, upsertColumnsNode); 
+    TVector<TUpsertColumn> upsertColumns(upsertColumnsDict->GetItemsCount()); 
+    for (ui32 i = 0; i < upsertColumns.size(); ++i) { 
+        auto item = upsertColumnsDict->GetItem(i); 
+ 
+        auto& upsertColumn = upsertColumns[i]; 
+        upsertColumn.ColumnId = AS_VALUE(TDataLiteral, item.first)->AsValue().Get<ui32>(); 
+        upsertColumn.RowIndex = AS_VALUE(TDataLiteral, item.second)->AsValue().Get<ui32>(); 
+ 
+        auto tableColumn = tableInfo->Columns.FindPtr(upsertColumn.ColumnId); 
+        MKQL_ENSURE_S(tableColumn); 
+ 
+        MKQL_ENSURE_S(rowTypes[upsertColumn.RowIndex] == tableColumn->Type, 
+            "upsert column type missmatch, column: " << tableColumn->Name); 
+ 
+    } 
+ 
+    return new TKqpUpsertRowsWrapper(ctx.Mutables, computeCtx, tableId, 
+        LocateNode(ctx.NodeLocator, *rowsNode.GetNode()), std::move(rowTypes), std::move(keyIndices), 
+        std::move(upsertColumns), ctx.Env); 
+} 
+ 
 } // namespace NMiniKQL
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/tx/datashard/datashard_locks.cpp b/ydb/core/tx/datashard/datashard_locks.cpp
index aa5fc3876b..9b30afffbe 100644
--- a/ydb/core/tx/datashard/datashard_locks.cpp
+++ b/ydb/core/tx/datashard/datashard_locks.cpp
@@ -14,7 +14,7 @@ TLockInfo::TLockInfo(TLockLocker * locker, ui64 lockId)
     : Locker(locker)
     , LockId(lockId)
     , Counter(locker->IncCounter())
-    , CreationTime(TAppData::TimeProvider->Now())
+    , CreationTime(TAppData::TimeProvider->Now()) 
 {}
 
 TLockInfo::~TLockInfo() {
@@ -240,13 +240,13 @@ void TLockLocker::RemoveOneLock(ui64 lockTxId) {
     auto it = Locks.find(lockTxId);
     if (it != Locks.end()) {
         TLockInfo::TPtr txLock = it->second;
-
-        TDuration lifetime = TAppData::TimeProvider->Now() - txLock->GetCreationTime();
-        if (Self->TabletCounters) {
+ 
+        TDuration lifetime = TAppData::TimeProvider->Now() - txLock->GetCreationTime(); 
+        if (Self->TabletCounters) { 
             Self->IncCounter(COUNTER_LOCKS_LIFETIME, lifetime);
             Self->IncCounter(COUNTER_LOCKS_REMOVED);
-        }
-
+        } 
+ 
         if (!txLock->IsShardLock()) {
             for (const TPathId& tableId : txLock->GetAffectedTables()) {
                 Tables[tableId]->RemoveLock(txLock);
@@ -318,11 +318,11 @@ void TLockLocker::ScheduleLockCleanup(ui64 lockId, const TRowVersion& at) {
         CleanupPending.push_back(lockId);
     }
 
-    if (Self->TabletCounters) {
+    if (Self->TabletCounters) { 
         Self->IncCounter(COUNTER_LOCKS_BROKEN);
-    }
-}
-
+    } 
+} 
+ 
 // TLockLocker.TLockLimiter
 
 TLockInfo::TPtr TLockLocker::TLockLimiter::TryAddLock(ui64 lockId) {
@@ -337,10 +337,10 @@ TLockInfo::TPtr TLockLocker::TLockLimiter::TryAddLock(ui64 lockId) {
         if (oldest.Value() >= forgetTime)
             return nullptr;
 
-        if (Parent->Self->TabletCounters) {
+        if (Parent->Self->TabletCounters) { 
             Parent->Self->IncCounter(COUNTER_LOCKS_EVICTED);
-        }
-
+        } 
+ 
         Parent->RemoveOneLock(oldest.Key()); // erase LocksQueue inside
     }
 
@@ -384,10 +384,10 @@ TVector<TSysLocks::TLock> TSysLocks::ApplyLocks() {
         }
     }
 
-    if (!Update->Erases.empty() && Self->TabletCounters) {
+    if (!Update->Erases.empty() && Self->TabletCounters) { 
         Self->IncCounter(COUNTER_LOCKS_ERASED, Update->Erases.size());
-    }
-
+    } 
+ 
     for (ui64 lockId : Update->Erases) {
         Y_VERIFY(!Update->HasLocks(), "Can't erase and set locks in one Tx");
         if (breakVersion)
@@ -440,24 +440,24 @@ TVector<TSysLocks::TLock> TSysLocks::ApplyLocks() {
         counter = TLock::ErrorTooMuch;
     }
 
-    if (Self->TabletCounters) {
+    if (Self->TabletCounters) { 
         Self->IncCounter(COUNTER_LOCKS_ACTIVE_PER_SHARD, LocksCount());
         Self->IncCounter(COUNTER_LOCKS_BROKEN_PER_SHARD, BrokenLocksCount());
         if (Update->ShardLock) {
             Self->IncCounter(COUNTER_LOCKS_WHOLE_SHARD);
         }
-
+ 
         if (TLock::IsError(counter)) {
             if (TLock::IsBroken(counter)) {
                 Self->IncCounter(COUNTER_LOCKS_REJECT_BROKEN);
             } else {
                 Self->IncCounter(COUNTER_LOCKS_REJECTED);
             }
-        } else {
+        } else { 
             Self->IncCounter(COUNTER_LOCKS_ACQUIRED);
-        }
-    }
-
+        } 
+    } 
+ 
     // We have to tell client that there were some locks (even if we don't set them)
     TVector<TLock> out;
     out.reserve(Update->AffectedTables.size());
diff --git a/ydb/core/tx/datashard/datashard_locks.h b/ydb/core/tx/datashard/datashard_locks.h
index 19c68c4d88..ad5264ba67 100644
--- a/ydb/core/tx/datashard/datashard_locks.h
+++ b/ydb/core/tx/datashard/datashard_locks.h
@@ -158,9 +158,9 @@ public:
 
     ui64 GetLockId() const { return LockId; }
 
-    TInstant GetCreationTime() const { return CreationTime; }
+    TInstant GetCreationTime() const { return CreationTime; } 
     const THashSet<TPathId>& GetAffectedTables() const { return AffectedTables; }
-
+ 
     const TVector<TPointKey>& GetPoints() const { return Points; }
     const TVector<TRangeKey>& GetRanges() const { return Ranges; }
 
diff --git a/ydb/core/tx/datashard/datashard_pipeline.cpp b/ydb/core/tx/datashard/datashard_pipeline.cpp
index 3498162c17..0e91f7035e 100644
--- a/ydb/core/tx/datashard/datashard_pipeline.cpp
+++ b/ydb/core/tx/datashard/datashard_pipeline.cpp
@@ -1239,9 +1239,9 @@ TOperation::TPtr TPipeline::BuildOperation(TEvDataShard::TEvProposeTransaction::
             tx->SetNeedDiagnosticsFlag();
         if (dataTx->IsKqpDataTx())
             tx->SetKqpDataTransactionFlag();
-        if (dataTx->IsKqpScanTx()) {
-            tx->SetKqpScanTransactionFlag();
-            // TODO: support for extracting keys in kqp scan transaction
+        if (dataTx->IsKqpScanTx()) { 
+            tx->SetKqpScanTransactionFlag(); 
+            // TODO: support for extracting keys in kqp scan transaction 
             tx->SetGlobalReaderFlag();
         }
 
diff --git a/ydb/core/tx/datashard/datashard_ut_common.cpp b/ydb/core/tx/datashard/datashard_ut_common.cpp
index d754f7ad0e..d0da7eafd4 100644
--- a/ydb/core/tx/datashard/datashard_ut_common.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_common.cpp
@@ -331,10 +331,10 @@ ui32 TFakeProxyTx::SetProgram(TTester& tester, const TString& programText) {
     for (auto& dbKey : dbKeys) {
         keyResolver(*dbKey);
         UNIT_ASSERT(dbKey->Status == TKeyDesc::EStatus::Ok);
-
-        for (auto& partition : dbKey->Partitions) {
-            resolvedShards.insert(partition.ShardId);
-        }
+ 
+        for (auto& partition : dbKey->Partitions) { 
+            resolvedShards.insert(partition.ShardId); 
+        } 
     }
 
     result = Engine->PrepareShardPrograms();
@@ -353,7 +353,7 @@ ui32 TFakeProxyTx::GetShardProgram(ui32 idx, TString& outTxBody) {
     NKikimrTxDataShard::TDataTransaction tx;
     tx.SetMiniKQL(shardData.Program);
     tx.SetImmediate(shardData.Immediate);
-    tx.SetReadOnly(Engine->IsReadOnlyProgram());
+    tx.SetReadOnly(Engine->IsReadOnlyProgram()); 
     outTxBody = tx.SerializeAsString();
     return shardData.ShardId;
 }
@@ -454,7 +454,7 @@ void TFakeScanTx::AddPlanStepShardResult(ui32 /*shardId*/,
                                          bool /*complete*/) {
     if (event->Record.GetStatus() == NKikimrTxDataShard::TEvProposeTransactionResult::RESPONSE_DATA) {
         auto &res = event->Record.GetTxResult();
-        YdbOld::ResultSet part;
+        YdbOld::ResultSet part; 
         UNIT_ASSERT(part.ParseFromArray(res.data(), res.size()));
 
         if (Result.column_metaSize())
@@ -469,7 +469,7 @@ void TFakeScanTx::AddPlanStepShardResult(ui32 /*shardId*/,
     }
 }
 
-YdbOld::ResultSet TFakeScanTx::GetScanResult() const {
+YdbOld::ResultSet TFakeScanTx::GetScanResult() const { 
     return Result;
 }
 
@@ -1719,7 +1719,7 @@ void SendSQL(Tests::TServer::TPtr server,
 {
     auto &runtime = *server->GetRuntime();
     auto request = MakeSQLRequest(sql, dml);
-    runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+    runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release())); 
 }
 
 void ExecSQL(Tests::TServer::TPtr server,
@@ -1732,7 +1732,7 @@ void ExecSQL(Tests::TServer::TPtr server,
     TAutoPtr<IEventHandle> handle;
 
     auto request = MakeSQLRequest(sql, dml);
-    runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+    runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release())); 
     auto ev = runtime.GrabEdgeEventRethrow<NKqp::TEvKqp::TEvQueryResponse>(sender);
     UNIT_ASSERT_VALUES_EQUAL(ev->Get()->Record.GetRef().GetYdbStatus(), code);
 }
diff --git a/ydb/core/tx/datashard/datashard_ut_common.h b/ydb/core/tx/datashard/datashard_ut_common.h
index 4b5d7fe4ea..4d0c06bc77 100644
--- a/ydb/core/tx/datashard/datashard_ut_common.h
+++ b/ydb/core/tx/datashard/datashard_ut_common.h
@@ -241,11 +241,11 @@ public:
     ui32 SetProgram(TTester& tester) override;
     ui32 GetShardProgram(ui32 idx, TString& outTxBody) override;
     void AddPlanStepShardResult(ui32 shardId, const TEvDataShard::TEvProposeTransactionResult * event, bool complete) override;
-    YdbOld::ResultSet GetScanResult() const;
+    YdbOld::ResultSet GetScanResult() const; 
     IEngineFlat::EStatus GetStatus(bool atPropose) override;
 
 private:
-    YdbOld::ResultSet Result;
+    YdbOld::ResultSet Result; 
     IEngineFlat::EStatus Status;
 };
 
diff --git a/ydb/core/tx/datashard/datashard_ut_common_kqp.h b/ydb/core/tx/datashard/datashard_ut_common_kqp.h
index b8a7873652..cac4126a20 100644
--- a/ydb/core/tx/datashard/datashard_ut_common_kqp.h
+++ b/ydb/core/tx/datashard/datashard_ut_common_kqp.h
@@ -131,7 +131,7 @@ namespace NKqpHelpers {
     {
         auto request = MakeHolder<NKqp::TEvKqp::TEvQueryRequest>();
         request->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
-        request->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_SCAN);
+        request->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_SCAN); 
         request->Record.MutableRequest()->SetKeepSession(false);
         request->Record.MutableRequest()->SetQuery(sql);
         request->Record.MutableRequest()->SetProfile(collectStats);
diff --git a/ydb/core/tx/datashard/datashard_ut_erase_rows.cpp b/ydb/core/tx/datashard/datashard_ut_erase_rows.cpp
index 87a51ef80a..0b71e813bf 100644
--- a/ydb/core/tx/datashard/datashard_ut_erase_rows.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_erase_rows.cpp
@@ -717,10 +717,10 @@ key = 4, value = (empty maybe)
 
             auto& response = ev->Get()->Record.GetRef();
             UNIT_ASSERT_VALUES_EQUAL(response.GetYdbStatus(), Ydb::StatusIds::ABORTED);
-
-            NYql::TIssues issues;
-            IssuesFromMessage(response.GetResponse().GetQueryIssues(), issues);
-            UNIT_ASSERT(NKqp::HasIssue(issues, NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED));
+ 
+            NYql::TIssues issues; 
+            IssuesFromMessage(response.GetResponse().GetQueryIssues(), issues); 
+            UNIT_ASSERT(NKqp::HasIssue(issues, NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED)); 
         }
     }
 
diff --git a/ydb/core/tx/datashard/datashard_ut_kqp_errors.cpp b/ydb/core/tx/datashard/datashard_ut_kqp_errors.cpp
index dcbae112e8..5cd8ba92a7 100644
--- a/ydb/core/tx/datashard/datashard_ut_kqp_errors.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_kqp_errors.cpp
@@ -119,7 +119,7 @@ Y_UNIT_TEST_NEW_ENGINE(ProposeError) {
 
     using TMod = std::function<void(NKikimrTxDataShard::TEvProposeTransactionResult&)>;
 
-    auto test = [&](auto proposeStatus, auto ydbStatus, auto issue, auto issueMessage, TMod mod = {}) {
+    auto test = [&](auto proposeStatus, auto ydbStatus, auto issue, auto issueMessage, TMod mod = {}) { 
         auto client = Runtime->AllocateEdgeActor();
 
         bool done = false;
diff --git a/ydb/core/tx/datashard/datashard_ut_locks.cpp b/ydb/core/tx/datashard/datashard_ut_locks.cpp
index 1d25c39f99..fef0da2bdd 100644
--- a/ydb/core/tx/datashard/datashard_ut_locks.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_locks.cpp
@@ -72,9 +72,9 @@ namespace NTest {
 
             NTable::TSchemeModifier(Schema).Apply(*delta.Flush());
         }
-
-    public:
-        TTabletCountersBase* TabletCounters = nullptr;
+ 
+    public: 
+        TTabletCountersBase* TabletCounters = nullptr; 
         THashMap<ui64, NDataShard::TUserTable> TableInfos;
     };
 }
@@ -640,13 +640,13 @@ void CheckLocksCacheUsage(bool waitForLocksStore) {
 
     {
         auto request = MakeSQLRequest("UPSERT INTO [/Root/table-1] (key, value) VALUES (1,0x80000002),(0x80000001,2)");
-        runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+        runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release())); 
         runtime.GrabEdgeEventRethrow<NKqp::TEvKqp::TEvQueryResponse>(handle);
     }
 
     {
         auto request = MakeSQLRequest("UPSERT INTO [/Root/table-1] (key, value) SELECT value as key, value FROM [/Root/table-1]");
-        runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+        runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release())); 
 
         // Get shard IDs.
         ui64 shards[2];
@@ -712,7 +712,7 @@ void CheckLocksCacheUsage(bool waitForLocksStore) {
 
     {
         auto request = MakeSQLRequest("SELECT * FROM [/Root/table-1]");
-        runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+        runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release())); 
         auto reply = runtime.GrabEdgeEventRethrow<NKqp::TEvKqp::TEvQueryResponse>(handle);
         auto &resp = reply->Record.GetRef().GetResponse();
         UNIT_ASSERT_VALUES_EQUAL(resp.ResultsSize(), 1);
diff --git a/ydb/core/tx/datashard/datashard_ut_minstep.cpp b/ydb/core/tx/datashard/datashard_ut_minstep.cpp
index 99d72b2e45..4d9d265c53 100644
--- a/ydb/core/tx/datashard/datashard_ut_minstep.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_minstep.cpp
@@ -66,7 +66,7 @@ TAutoPtr<IEventHandle> EjectDataPropose(TServer::TPtr server, ui64 dataShard)
 }
 
 Y_UNIT_TEST_SUITE(TDataShardMinStepTest) {
-    void TestDropTablePlanComesNotTooEarly(const TString& query, Ydb::StatusIds::StatusCode expectedStatus) {
+    void TestDropTablePlanComesNotTooEarly(const TString& query, Ydb::StatusIds::StatusCode expectedStatus) { 
         TPortManager pm;
         TServerSettings serverSettings(pm.GetPort(2134));
         serverSettings.SetDomainName("Root")
@@ -96,7 +96,7 @@ Y_UNIT_TEST_SUITE(TDataShardMinStepTest) {
 
         // propose data tx for datashards but not to coordinator
         // eject propose message to coordinator
-        SendSQL(server, sender, query);
+        SendSQL(server, sender, query); 
         auto proposeEvent = EjectDataPropose(server, shard2);
 
         // drop one table while proposes are active
@@ -115,17 +115,17 @@ Y_UNIT_TEST_SUITE(TDataShardMinStepTest) {
 
             TAutoPtr<IEventHandle> handle;
             auto reply = runtime.GrabEdgeEventRethrow<TEvTxProxy::TEvProposeTransactionStatus>(handle);
-            UNIT_ASSERT_VALUES_EQUAL((TEvTxProxy::TEvProposeTransactionStatus::EStatus)reply->Record.GetStatus(),
-                TEvTxProxy::TEvProposeTransactionStatus::EStatus::StatusOutdated);
+            UNIT_ASSERT_VALUES_EQUAL((TEvTxProxy::TEvProposeTransactionStatus::EStatus)reply->Record.GetStatus(), 
+                TEvTxProxy::TEvProposeTransactionStatus::EStatus::StatusOutdated); 
         }
 
         { // handle respond from unplanned data transaction because plan ejection
             TAutoPtr<IEventHandle> handle;
             auto reply = runtime.GrabEdgeEventRethrow<NKqp::TEvKqp::TEvQueryResponse>(handle);
-            NYql::TIssues issues;
-            NYql::IssuesFromMessage(reply->Record.GetRef().GetResponse().GetQueryIssues(), issues);
-            UNIT_ASSERT_VALUES_EQUAL_C(reply->Record.GetRef().GetYdbStatus(), expectedStatus,
-                issues.ToString());
+            NYql::TIssues issues; 
+            NYql::IssuesFromMessage(reply->Record.GetRef().GetResponse().GetQueryIssues(), issues); 
+            UNIT_ASSERT_VALUES_EQUAL_C(reply->Record.GetRef().GetYdbStatus(), expectedStatus, 
+                issues.ToString()); 
         }
 
         // make sure that second table is still operationable
@@ -133,20 +133,20 @@ Y_UNIT_TEST_SUITE(TDataShardMinStepTest) {
         ExecSQL(server, sender, "DROP TABLE [/Root/table-2]", false);
         WaitTabletBecomesOffline(server, shard2);
     }
-
-    Y_UNIT_TEST(TestDropTablePlanComesNotTooEarlyRO) {
-        TestDropTablePlanComesNotTooEarly(
-            "SELECT * FROM [/Root/table-1]; SELECT * FROM [/Root/table-2];",
-            Ydb::StatusIds::UNAVAILABLE
-        );
+ 
+    Y_UNIT_TEST(TestDropTablePlanComesNotTooEarlyRO) { 
+        TestDropTablePlanComesNotTooEarly( 
+            "SELECT * FROM [/Root/table-1]; SELECT * FROM [/Root/table-2];", 
+            Ydb::StatusIds::UNAVAILABLE 
+        ); 
     }
 
-    Y_UNIT_TEST(TestDropTablePlanComesNotTooEarlyRW) {
-        TestDropTablePlanComesNotTooEarly(
-            "UPSERT INTO [/Root/table-2] (key, value) SELECT key, value FROM [/Root/table-1];",
-            Ydb::StatusIds::UNDETERMINED
-        );
-    }
+    Y_UNIT_TEST(TestDropTablePlanComesNotTooEarlyRW) { 
+        TestDropTablePlanComesNotTooEarly( 
+            "UPSERT INTO [/Root/table-2] (key, value) SELECT key, value FROM [/Root/table-1];", 
+            Ydb::StatusIds::UNDETERMINED 
+        ); 
+    } 
 
     enum class ERebootOnPropose {
         DataShard,
@@ -483,6 +483,6 @@ Y_UNIT_TEST_SUITE(TDataShardMinStepTest) {
         );
     }
 
-}
-
+} 
+ 
 } // namespace NKikimr
diff --git a/ydb/core/tx/datashard/datashard_ut_order.cpp b/ydb/core/tx/datashard/datashard_ut_order.cpp
index 32472dce59..2c010ddbf3 100644
--- a/ydb/core/tx/datashard/datashard_ut_order.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_order.cpp
@@ -1167,7 +1167,7 @@ Y_UNIT_TEST_WITH_MVCC(ScanFollowedByUpdate) {
 
     auto checkScanResult = [](const TFakeProxyTx &tx, TSet<TString> ref) -> bool {
         const TFakeScanTx &scanTx = dynamic_cast<const TFakeScanTx &>(tx);
-        YdbOld::ResultSet res = scanTx.GetScanResult();
+        YdbOld::ResultSet res = scanTx.GetScanResult(); 
         //Cerr << res.DebugString() << Endl;
         for (auto &row : res.rows()) {
             auto &val = row.items(0).text_value();
@@ -1501,9 +1501,9 @@ Y_UNIT_TEST_QUAD(TestOutOfOrderLockLost, UseMvcc, UseNewEngine) {
         auto& response = ev->Get()->Record.GetRef();
         if (response.GetYdbStatus() == Ydb::StatusIds::ABORTED) {
             // Let's suppose somehow locks still managed to become invalidated
-            NYql::TIssues issues;
-            IssuesFromMessage(response.GetResponse().GetQueryIssues(), issues);
-            UNIT_ASSERT(NKqp::HasIssue(issues, NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED));
+            NYql::TIssues issues; 
+            IssuesFromMessage(response.GetResponse().GetQueryIssues(), issues); 
+            UNIT_ASSERT(NKqp::HasIssue(issues, NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED)); 
             committed = false;
         } else {
             UNIT_ASSERT_VALUES_EQUAL(response.GetYdbStatus(), Ydb::StatusIds::SUCCESS);
@@ -3271,15 +3271,15 @@ Y_UNIT_TEST_NEW_ENGINE(TestReadTableWriteConflict) {
         "UPSERT INTO [/Root/table-2] (key, value) VALUES (4, 2)")));
 
     // Wait until we captured all readsets
-    if (readSets.size() < 4) {
+    if (readSets.size() < 4) { 
         TDispatchOptions options;
         options.FinalEvents.emplace_back(
             [&](IEventHandle &) -> bool {
-                return readSets.size() >= 4;
+                return readSets.size() >= 4; 
             });
         runtime.DispatchEvents(options);
     }
-    UNIT_ASSERT_VALUES_EQUAL(readSets.size(), 4u);
+    UNIT_ASSERT_VALUES_EQUAL(readSets.size(), 4u); 
     captureReadSets = false;
 
     // Start reading table-1, wait for its plan step
diff --git a/ydb/core/tx/datashard/datashard_ut_rs.cpp b/ydb/core/tx/datashard/datashard_ut_rs.cpp
index edbe2968da..fb75dfbc23 100644
--- a/ydb/core/tx/datashard/datashard_ut_rs.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_rs.cpp
@@ -81,7 +81,7 @@ Y_UNIT_TEST_SUITE(TDataShardRSTest) {
         // Fill some data. Later we will copy data from shards 2 and 3 to shard 1.
         {
             auto request = MakeSQLRequest("UPSERT INTO [/Root/table-1] (key, value) VALUES (0x50000000,1),(0x80000001,1),(0x80000002,1),(0x80000003,1),(0x80000004,1),(0x80000005,1),(0x80000006,1),(0x80000007,1),(0x80000008,1),(0x80000009,1)");
-            runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+            runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release())); 
             runtime.GrabEdgeEventRethrow<NKqp::TEvKqp::TEvQueryResponse>(handle);
         }
 
@@ -119,7 +119,7 @@ Y_UNIT_TEST_SUITE(TDataShardRSTest) {
             runtime.SetObserverFunc(captureRS);
 
             auto request = MakeSQLRequest("UPSERT INTO [/Root/table-1] (key, value) SELECT value, key FROM [/Root/table-1] WHERE key = 0x50000000");
-            runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+            runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release())); 
             // Wait until both parts of tx are finished on the second shard.
             TDispatchOptions options;
             options.FinalEvents.emplace_back(IsTxResultComplete(), 2);
@@ -130,7 +130,7 @@ Y_UNIT_TEST_SUITE(TDataShardRSTest) {
         {
             for (auto i = 1; i < 10; ++i) {
                 auto request = MakeSQLRequest(Sprintf("UPSERT INTO [/Root/table-1] (key, value) SELECT value, key FROM [/Root/table-1] WHERE key = %" PRIu32, i + 0x80000000));
-                runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+                runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release())); 
             }
             TDispatchOptions options;
             options.FinalEvents.emplace_back(TEvTxProcessing::EvReadSetAck, 9);
diff --git a/ydb/core/tx/datashard/datashard_ut_upload_rows.cpp b/ydb/core/tx/datashard/datashard_ut_upload_rows.cpp
index ab1c586d30..472655e1ec 100644
--- a/ydb/core/tx/datashard/datashard_ut_upload_rows.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_upload_rows.cpp
@@ -253,10 +253,10 @@ Y_UNIT_TEST_SUITE(TTxDataShardUploadRows) {
                 "UPSERT INTO [/Root/table-1] (key, value) VALUES (6, 600);"));
             auto& response = ev->Get()->Record.GetRef();
             UNIT_ASSERT_VALUES_EQUAL(response.GetYdbStatus(), Ydb::StatusIds::ABORTED);
-
-            NYql::TIssues issues;
-            IssuesFromMessage(response.GetResponse().GetQueryIssues(), issues);
-            UNIT_ASSERT(NKqp::HasIssue(issues, NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED));
+ 
+            NYql::TIssues issues; 
+            IssuesFromMessage(response.GetResponse().GetQueryIssues(), issues); 
+            UNIT_ASSERT(NKqp::HasIssue(issues, NYql::TIssuesIds::KIKIMR_LOCKS_INVALIDATED)); 
         }
     }
 
diff --git a/ydb/core/tx/datashard/execute_data_tx_unit.cpp b/ydb/core/tx/datashard/execute_data_tx_unit.cpp
index b32f635cc0..a07b19acaa 100644
--- a/ydb/core/tx/datashard/execute_data_tx_unit.cpp
+++ b/ydb/core/tx/datashard/execute_data_tx_unit.cpp
@@ -113,8 +113,8 @@ EExecutionStatus TExecuteDataTxUnit::Execute(TOperation::TPtr op,
     else {
         ui64 consumed = tx->GetDataTx()->GetTxSize() + engine->GetMemoryAllocated();
         if (MaybeRequestMoreTxMemory(consumed, txc)) {
-            LOG_TRACE_S(ctx, NKikimrServices::TX_DATASHARD, "Operation " << *op << " at " << DataShard.TabletID()
-                << " requested " << txc.GetRequestedMemory() << " more memory");
+            LOG_TRACE_S(ctx, NKikimrServices::TX_DATASHARD, "Operation " << *op << " at " << DataShard.TabletID() 
+                << " requested " << txc.GetRequestedMemory() << " more memory"); 
 
             DataShard.IncCounter(COUNTER_TX_WAIT_RESOURCE);
             return EExecutionStatus::Restart;
@@ -133,10 +133,10 @@ EExecutionStatus TExecuteDataTxUnit::Execute(TOperation::TPtr op,
             throw;
         }
     } catch (const TMemoryLimitExceededException&) {
-        LOG_TRACE_S(ctx, NKikimrServices::TX_DATASHARD, "Operation " << *op << " at " << DataShard.TabletID()
-            << " exceeded memory limit " << txc.GetMemoryLimit()
-            << " and requests " << txc.GetMemoryLimit() * MEMORY_REQUEST_FACTOR
-            << " more for the next try");
+        LOG_TRACE_S(ctx, NKikimrServices::TX_DATASHARD, "Operation " << *op << " at " << DataShard.TabletID() 
+            << " exceeded memory limit " << txc.GetMemoryLimit() 
+            << " and requests " << txc.GetMemoryLimit() * MEMORY_REQUEST_FACTOR 
+            << " more for the next try"); 
 
         txc.NotEnoughMemory();
         DataShard.IncCounter(DataShard.NotEnoughMemoryCounter(txc.GetNotEnoughMemoryCount()));
@@ -149,7 +149,7 @@ EExecutionStatus TExecuteDataTxUnit::Execute(TOperation::TPtr op,
         return EExecutionStatus::Restart;
     } catch (const TNotReadyTabletException&) {
         LOG_TRACE_S(ctx, NKikimrServices::TX_DATASHARD, "Tablet " << DataShard.TabletID()
-            << " is not ready for " << *op << " execution");
+            << " is not ready for " << *op << " execution"); 
 
         DataShard.IncCounter(COUNTER_TX_TABLET_NOT_READY);
 
@@ -193,10 +193,10 @@ void TExecuteDataTxUnit::ExecuteDataTx(TOperation::TPtr op,
         }
     }
 
-    if (tx->GetDataTx()->CanCancel()) {
-        engine->SetDeadline(tx->GetDataTx()->Deadline());
-    }
-
+    if (tx->GetDataTx()->CanCancel()) { 
+        engine->SetDeadline(tx->GetDataTx()->Deadline()); 
+    } 
+ 
     IEngineFlat::EResult engineResult = engine->Execute();
     if (engineResult != IEngineFlat::EResult::Ok) {
         TString errorMessage = TStringBuilder() << "Datashard execution error for " << *op << " at "
@@ -208,7 +208,7 @@ void TExecuteDataTxUnit::ExecuteDataTx(TOperation::TPtr op,
                 break;
             case IEngineFlat::EResult::Cancelled:
                 LOG_NOTICE_S(ctx, NKikimrServices::TX_DATASHARD, errorMessage);
-                Y_VERIFY(tx->GetDataTx()->CanCancel());
+                Y_VERIFY(tx->GetDataTx()->CanCancel()); 
                 break;
             default:
                 if (op->IsReadOnly() || op->IsImmediate()) {
diff --git a/ydb/core/tx/datashard/execute_kqp_data_tx_unit.cpp b/ydb/core/tx/datashard/execute_kqp_data_tx_unit.cpp
index 70e7be3662..f178f283db 100644
--- a/ydb/core/tx/datashard/execute_kqp_data_tx_unit.cpp
+++ b/ydb/core/tx/datashard/execute_kqp_data_tx_unit.cpp
@@ -24,8 +24,8 @@ public:
     ~TExecuteKqpDataTxUnit() override;
 
     bool IsReadyToExecute(TOperation::TPtr op) const override;
-    EExecutionStatus Execute(TOperation::TPtr op, TTransactionContext& txc, const TActorContext& ctx) override;
-    void Complete(TOperation::TPtr op, const TActorContext& ctx) override;
+    EExecutionStatus Execute(TOperation::TPtr op, TTransactionContext& txc, const TActorContext& ctx) override; 
+    void Complete(TOperation::TPtr op, const TActorContext& ctx) override; 
 
 private:
     void AddLocksToResult(TOperation::TPtr op, const TActorContext& ctx);
@@ -34,9 +34,9 @@ private:
 };
 
 TExecuteKqpDataTxUnit::TExecuteKqpDataTxUnit(TDataShard& dataShard, TPipeline& pipeline)
-    : TExecutionUnit(EExecutionUnitKind::ExecuteKqpDataTx, true, dataShard, pipeline) {}
+    : TExecutionUnit(EExecutionUnitKind::ExecuteKqpDataTx, true, dataShard, pipeline) {} 
 
-TExecuteKqpDataTxUnit::~TExecuteKqpDataTxUnit() {}
+TExecuteKqpDataTxUnit::~TExecuteKqpDataTxUnit() {} 
 
 bool TExecuteKqpDataTxUnit::IsReadyToExecute(TOperation::TPtr op) const {
     if (op->Result() || op->HasResultSentFlag() || op->IsImmediate() && WillRejectDataTx(op)) {
@@ -51,9 +51,9 @@ bool TExecuteKqpDataTxUnit::IsReadyToExecute(TOperation::TPtr op) const {
     return !op->HasRuntimeConflicts();
 }
 
-EExecutionStatus TExecuteKqpDataTxUnit::Execute(TOperation::TPtr op, TTransactionContext& txc,
-    const TActorContext& ctx)
-{
+EExecutionStatus TExecuteKqpDataTxUnit::Execute(TOperation::TPtr op, TTransactionContext& txc, 
+    const TActorContext& ctx) 
+{ 
     if (op->Result() || op->HasResultSentFlag() || op->IsImmediate() && CheckRejectDataTx(op, ctx)) {
         return EExecutionStatus::Executed;
     }
@@ -61,7 +61,7 @@ EExecutionStatus TExecuteKqpDataTxUnit::Execute(TOperation::TPtr op, TTransactio
     // We remember current time now, but will only count it when transaction succeeds
     TDuration waitExecuteLatency = op->GetCurrentElapsed();
     TDuration waitTotalLatency = op->GetTotalElapsed();
-
+ 
     if (op->IsImmediate()) {
         // Every time we execute immediate transaction we may choose a new mvcc version
         op->MvccReadWriteVersion.reset();
@@ -82,7 +82,7 @@ EExecutionStatus TExecuteKqpDataTxUnit::Execute(TOperation::TPtr op, TTransactio
             case ERestoreDataStatus::Error:
                 Y_FAIL("Failed to restore tx data: %s", tx->GetDataTx()->GetErrors().c_str());
         }
-    }
+    } 
 
     ui64 tabletId = DataShard.TabletID();
     const TValidatedDataTx::TPtr& dataTx = tx->GetDataTx();
@@ -107,7 +107,7 @@ EExecutionStatus TExecuteKqpDataTxUnit::Execute(TOperation::TPtr op, TTransactio
         }
 
         auto& tasksRunner = dataTx->GetKqpTasksRunner();
-
+ 
         auto allocGuard = tasksRunner.BindAllocator(txc.GetMemoryLimit() - dataTx->GetTxSize());
 
         NKqp::NRm::TKqpResourcesRequest req;
@@ -167,13 +167,13 @@ EExecutionStatus TExecuteKqpDataTxUnit::Execute(TOperation::TPtr op, TTransactio
         if (statsMode >= NYql::NDqProto::DQ_STATS_MODE_BASIC) {
             KqpFillTxStats(DataShard, dataTx->GetCounters(), *op->Result());
             KqpFillStats(DataShard, tasksRunner, computeCtx, statsMode, *op->Result());
-        }
+        } 
     } catch (const TMemoryLimitExceededException&) {
         txc.NotEnoughMemory();
 
         LOG_T("Operation " << *op << " at " << tabletId
-            << " exceeded memory limit " << txc.GetMemoryLimit()
-            << " and requests " << txc.GetMemoryLimit() * MEMORY_REQUEST_FACTOR
+            << " exceeded memory limit " << txc.GetMemoryLimit() 
+            << " and requests " << txc.GetMemoryLimit() * MEMORY_REQUEST_FACTOR 
             << " more for the next try (" << txc.GetNotEnoughMemoryCount() << ")");
 
         DataShard.IncCounter(DataShard.NotEnoughMemoryCounter(txc.GetNotEnoughMemoryCount()));
@@ -210,12 +210,12 @@ void TExecuteKqpDataTxUnit::AddLocksToResult(TOperation::TPtr op, const TActorCo
     LOG_T("add locks to result: " << locks.size());
     for (const auto& lock : locks) {
         if (lock.IsError()) {
-            LOG_NOTICE_S(TActivationContext::AsActorContext(), NKikimrServices::TX_DATASHARD, "Lock is not set for "
-                << *op << " at " << DataShard.TabletID() << " lock " << lock);
+            LOG_NOTICE_S(TActivationContext::AsActorContext(), NKikimrServices::TX_DATASHARD, "Lock is not set for " 
+                << *op << " at " << DataShard.TabletID() << " lock " << lock); 
         }
-
-        op->Result()->AddTxLock(lock.LockId, lock.DataShard, lock.Generation, lock.Counter, lock.SchemeShard,
-            lock.PathId);
+ 
+        op->Result()->AddTxLock(lock.LockId, lock.DataShard, lock.Generation, lock.Counter, lock.SchemeShard, 
+            lock.PathId); 
 
         LOG_T("add lock to result: " << op->Result()->Record.GetTxLocks().rbegin()->ShortDebugString());
     }
@@ -235,7 +235,7 @@ EExecutionStatus TExecuteKqpDataTxUnit::OnTabletNotReady(TActiveTransaction& tx,
     return EExecutionStatus::Restart;
 }
 
-void TExecuteKqpDataTxUnit::Complete(TOperation::TPtr, const TActorContext&) {}
+void TExecuteKqpDataTxUnit::Complete(TOperation::TPtr, const TActorContext&) {} 
 
 THolder<TExecutionUnit> CreateExecuteKqpDataTxUnit(TDataShard& dataShard, TPipeline& pipeline) {
     return THolder(new TExecuteKqpDataTxUnit(dataShard, pipeline));
diff --git a/ydb/core/tx/datashard/execute_kqp_scan_tx_unit.cpp b/ydb/core/tx/datashard/execute_kqp_scan_tx_unit.cpp
index 1362a5149f..741de934e2 100644
--- a/ydb/core/tx/datashard/execute_kqp_scan_tx_unit.cpp
+++ b/ydb/core/tx/datashard/execute_kqp_scan_tx_unit.cpp
@@ -1,23 +1,23 @@
-#include "datashard_impl.h"
-#include "datashard_pipeline.h"
-#include "execution_unit_ctors.h"
-
-namespace NKikimr {
+#include "datashard_impl.h" 
+#include "datashard_pipeline.h" 
+#include "execution_unit_ctors.h" 
+ 
+namespace NKikimr { 
 namespace NDataShard {
-
-using namespace NKqp;
-using namespace NMiniKQL;
-
-class TExecuteKqpScanTxUnit : public TExecutionUnit {
-public:
+ 
+using namespace NKqp; 
+using namespace NMiniKQL; 
+ 
+class TExecuteKqpScanTxUnit : public TExecutionUnit { 
+public: 
     TExecuteKqpScanTxUnit(TDataShard& dataShard, TPipeline& pipeline)
-        : TExecutionUnit(EExecutionUnitKind::ExecuteKqpScanTx, false, dataShard, pipeline) {
+        : TExecutionUnit(EExecutionUnitKind::ExecuteKqpScanTx, false, dataShard, pipeline) { 
     }
-
-    ~TExecuteKqpScanTxUnit() override {
+ 
+    ~TExecuteKqpScanTxUnit() override { 
     }
-
-    bool IsReadyToExecute(TOperation::TPtr op) const override {
+ 
+    bool IsReadyToExecute(TOperation::TPtr op) const override { 
         if (op->Result() || op->HasResultSentFlag() || op->IsImmediate() && WillRejectDataTx(op)) {
             return true;
         }
@@ -28,8 +28,8 @@ public:
         }
 
         return !op->HasRuntimeConflicts();
-    }
-
+    } 
+ 
     EExecutionStatus Execute(TOperation::TPtr op, TTransactionContext&, const TActorContext& ctx) override {
         if (op->Result() || op->HasResultSentFlag() || op->IsImmediate() && CheckRejectDataTx(op, ctx)) {
             return EExecutionStatus::Executed;
@@ -40,17 +40,17 @@ public:
         op->Abort();
 
         LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD, "Unexpected KqpScanTx");
-
-        return EExecutionStatus::Executed;
-    }
-
+ 
+        return EExecutionStatus::Executed; 
+    } 
+ 
     void Complete(TOperation::TPtr, const TActorContext&) override {
-    }
-};
-
+    } 
+}; 
+ 
 THolder<TExecutionUnit> CreateExecuteKqpScanTxUnit(TDataShard& dataShard, TPipeline& pipeline) {
     return MakeHolder<TExecuteKqpScanTxUnit>(dataShard, pipeline);
-}
-
+} 
+ 
 } // namespace NDataShard
-} // namespace NKikimr
+} // namespace NKikimr 
diff --git a/ydb/core/tx/datashard/execution_unit.cpp b/ydb/core/tx/datashard/execution_unit.cpp
index 9f6e13fa5c..ede321d5b1 100644
--- a/ydb/core/tx/datashard/execution_unit.cpp
+++ b/ydb/core/tx/datashard/execution_unit.cpp
@@ -72,8 +72,8 @@ THolder<TExecutionUnit> CreateExecutionUnit(EExecutionUnitKind kind,
         return CreateExecuteCommitWritesTxUnit(dataShard, pipeline);
     case EExecutionUnitKind::CompleteOperation:
         return CreateCompleteOperationUnit(dataShard, pipeline);
-    case EExecutionUnitKind::ExecuteKqpScanTx:
-        return CreateExecuteKqpScanTxUnit(dataShard, pipeline);
+    case EExecutionUnitKind::ExecuteKqpScanTx: 
+        return CreateExecuteKqpScanTxUnit(dataShard, pipeline); 
     case EExecutionUnitKind::MakeScanSnapshot:
         return CreateMakeScanSnapshotUnit(dataShard, pipeline);
     case EExecutionUnitKind::WaitForStreamClearance:
diff --git a/ydb/core/tx/datashard/execution_unit_kind.h b/ydb/core/tx/datashard/execution_unit_kind.h
index 88e763887f..01efef7d80 100644
--- a/ydb/core/tx/datashard/execution_unit_kind.h
+++ b/ydb/core/tx/datashard/execution_unit_kind.h
@@ -36,7 +36,7 @@ enum class EExecutionUnitKind : ui32 {
     ExecuteDistributedEraseTx,
     ExecuteCommitWritesTx,
     CompleteOperation,
-    ExecuteKqpScanTx,
+    ExecuteKqpScanTx, 
     MakeScanSnapshot,
     WaitForStreamClearance,
     ReadTableScan,
diff --git a/ydb/core/tx/datashard/operation.h b/ydb/core/tx/datashard/operation.h
index 0f4b713e91..926d2ec72f 100644
--- a/ydb/core/tx/datashard/operation.h
+++ b/ydb/core/tx/datashard/operation.h
@@ -296,10 +296,10 @@ public:
     void SetLoadedInRSFlag(bool val = true) { SetFlag(TTxFlags::LoadedInRS, val); }
     void ResetLoadedInRSFlag() { ResetFlag(TTxFlags::LoadedInRS); }
 
-    bool HasKqpScanTransactionFlag() const { return HasFlag(TTxFlags::KqpScanTransaction); }
-    void SetKqpScanTransactionFlag(bool val = true) { SetFlag(TTxFlags::KqpScanTransaction, val); }
-    void ResetKqpScanTransactionFlag() { ResetFlag(TTxFlags::KqpScanTransaction); }
-    bool IsKqpScanTransaction() const { return HasKqpScanTransactionFlag(); }
+    bool HasKqpScanTransactionFlag() const { return HasFlag(TTxFlags::KqpScanTransaction); } 
+    void SetKqpScanTransactionFlag(bool val = true) { SetFlag(TTxFlags::KqpScanTransaction, val); } 
+    void ResetKqpScanTransactionFlag() { ResetFlag(TTxFlags::KqpScanTransaction); } 
+    bool IsKqpScanTransaction() const { return HasKqpScanTransactionFlag(); } 
 
     bool HasWaitingForStreamClearanceFlag() const { return HasFlag(TTxFlags::WaitingForStreamClearance); }
     void SetWaitingForStreamClearanceFlag(bool val = true) { SetFlag(TTxFlags::WaitingForStreamClearance, val); }
diff --git a/ydb/core/tx/datashard/prepare_kqp_data_tx_in_rs_unit.cpp b/ydb/core/tx/datashard/prepare_kqp_data_tx_in_rs_unit.cpp
index 05ab71fc36..35385cef2a 100644
--- a/ydb/core/tx/datashard/prepare_kqp_data_tx_in_rs_unit.cpp
+++ b/ydb/core/tx/datashard/prepare_kqp_data_tx_in_rs_unit.cpp
@@ -14,22 +14,22 @@ public:
     ~TPrepareKqpDataTxInRSUnit() override;
 
     bool IsReadyToExecute(TOperation::TPtr op) const override;
-    EExecutionStatus Execute(TOperation::TPtr op, TTransactionContext &txc, const TActorContext &ctx) override;
-    void Complete(TOperation::TPtr op, const TActorContext &ctx) override;
+    EExecutionStatus Execute(TOperation::TPtr op, TTransactionContext &txc, const TActorContext &ctx) override; 
+    void Complete(TOperation::TPtr op, const TActorContext &ctx) override; 
 };
 
 TPrepareKqpDataTxInRSUnit::TPrepareKqpDataTxInRSUnit(TDataShard &dataShard,
-    TPipeline &pipeline)
-    : TExecutionUnit(EExecutionUnitKind::PrepareKqpDataTxInRS, true, dataShard, pipeline) {}
+    TPipeline &pipeline) 
+    : TExecutionUnit(EExecutionUnitKind::PrepareKqpDataTxInRS, true, dataShard, pipeline) {} 
 
-TPrepareKqpDataTxInRSUnit::~TPrepareKqpDataTxInRSUnit() {}
+TPrepareKqpDataTxInRSUnit::~TPrepareKqpDataTxInRSUnit() {} 
 
-bool TPrepareKqpDataTxInRSUnit::IsReadyToExecute(TOperation::TPtr) const {
+bool TPrepareKqpDataTxInRSUnit::IsReadyToExecute(TOperation::TPtr) const { 
     return true;
 }
 
-EExecutionStatus TPrepareKqpDataTxInRSUnit::Execute(TOperation::TPtr op, TTransactionContext &txc,
-    const TActorContext &ctx)
+EExecutionStatus TPrepareKqpDataTxInRSUnit::Execute(TOperation::TPtr op, TTransactionContext &txc, 
+    const TActorContext &ctx) 
 {
     TActiveTransaction *tx = dynamic_cast<TActiveTransaction*>(op.Get());
     Y_VERIFY_S(tx, "cannot cast operation of kind " << op->GetKind());
@@ -43,7 +43,7 @@ EExecutionStatus TPrepareKqpDataTxInRSUnit::Execute(TOperation::TPtr op, TTransa
             case ERestoreDataStatus::Error:
                 Y_FAIL("Failed to restore tx data: %s", tx->GetDataTx()->GetErrors().c_str());
         }
-    }
+    } 
 
     if (tx->GetDataTx()->CheckCancelled()) {
         tx->ReleaseTxData(txc, ctx);
@@ -56,17 +56,17 @@ EExecutionStatus TPrepareKqpDataTxInRSUnit::Execute(TOperation::TPtr op, TTransa
     }
 
     try {
-        KqpPrepareInReadsets(op->InReadSets(), tx->GetDataTx()->GetKqpTransaction(), DataShard.TabletID());
-    } catch (const yexception& e) {
-        LOG_CRIT_S(ctx, NKikimrServices::TX_DATASHARD, "Exception while preparing in-readsets for KQP transaction "
-            << *op << " at " << DataShard.TabletID() << ": " << CurrentExceptionMessage());
-        Y_FAIL_S("Unexpected exception in KQP in-readsets prepare: " << CurrentExceptionMessage());
+        KqpPrepareInReadsets(op->InReadSets(), tx->GetDataTx()->GetKqpTransaction(), DataShard.TabletID()); 
+    } catch (const yexception& e) { 
+        LOG_CRIT_S(ctx, NKikimrServices::TX_DATASHARD, "Exception while preparing in-readsets for KQP transaction " 
+            << *op << " at " << DataShard.TabletID() << ": " << CurrentExceptionMessage()); 
+        Y_FAIL_S("Unexpected exception in KQP in-readsets prepare: " << CurrentExceptionMessage()); 
     }
 
     return EExecutionStatus::Executed;
 }
 
-void TPrepareKqpDataTxInRSUnit::Complete(TOperation::TPtr, const TActorContext &) {}
+void TPrepareKqpDataTxInRSUnit::Complete(TOperation::TPtr, const TActorContext &) {} 
 
 THolder<TExecutionUnit> CreatePrepareKqpDataTxInRSUnit(TDataShard &dataShard, TPipeline &pipeline) {
     return THolder(new TPrepareKqpDataTxInRSUnit(dataShard, pipeline));
diff --git a/ydb/core/tx/datashard/ya.make b/ydb/core/tx/datashard/ya.make
index 9c98e8e79b..dfc39c61df 100644
--- a/ydb/core/tx/datashard/ya.make
+++ b/ydb/core/tx/datashard/ya.make
@@ -105,15 +105,15 @@ SRCS(
     datashard_user_table.cpp
     datashard_user_table.h
     datashard_impl.h
-    datashard_kqp_compute.cpp
-    datashard_kqp_compute.h
-    datashard_kqp_effects.cpp
-    datashard_kqp_lookup_table.cpp
-    datashard_kqp_read_table.cpp
-    datashard_kqp_upsert_rows.cpp
+    datashard_kqp_compute.cpp 
+    datashard_kqp_compute.h 
+    datashard_kqp_effects.cpp 
+    datashard_kqp_lookup_table.cpp 
+    datashard_kqp_read_table.cpp 
+    datashard_kqp_upsert_rows.cpp 
     datashard_kqp_delete_rows.cpp
-    datashard_kqp.cpp
-    datashard_kqp.h
+    datashard_kqp.cpp 
+    datashard_kqp.h 
     datashard_repl_apply.cpp
     datashard_repl_offsets.cpp
     datashard_repl_offsets_client.cpp
@@ -134,7 +134,7 @@ SRCS(
     execute_data_tx_unit.cpp
     execute_distributed_erase_tx_unit.cpp
     execute_kqp_data_tx_unit.cpp
-    execute_kqp_scan_tx_unit.cpp
+    execute_kqp_scan_tx_unit.cpp 
     execution_unit.cpp
     execution_unit.h
     execution_unit_ctors.h
diff --git a/ydb/core/tx/schemeshard/ut_base.cpp b/ydb/core/tx/schemeshard/ut_base.cpp
index a76dcf9d5b..0681fa5227 100644
--- a/ydb/core/tx/schemeshard/ut_base.cpp
+++ b/ydb/core/tx/schemeshard/ut_base.cpp
@@ -2527,7 +2527,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
                             Columns { Name: "key1"       Type: "Uint32"}
                             Columns { Name: "key2"       Type: "Utf8"}
                             Columns { Name: "key3"       Type: "Uint64"}
-                            Columns { Name: "key4"       Type: "Int32"}
+                            Columns { Name: "key4"       Type: "Int32"} 
                             Columns { Name: "Value"      Type: "Utf8"}
                             KeyColumnNames: ["key1", "key2", "key3", "key4"]
                             SplitBoundary { KeyPrefix {
@@ -2537,7 +2537,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
                                 Tuple { Optional { Uint32 : 200 } }
                                 Tuple { }                  # NULL
                                 Tuple { Optional { Uint64 : 100500 } }
-                                Tuple { Optional { Int32 : -100500 } }
+                                Tuple { Optional { Int32 : -100500 } } 
                             }}
                             SplitBoundary { KeyPrefix {
                                 Tuple { Optional { Uint32 : 200 } }
diff --git a/ydb/core/tx/schemeshard/ut_index_build_reboots.cpp b/ydb/core/tx/schemeshard/ut_index_build_reboots.cpp
index d270fd87e6..3130af7a89 100644
--- a/ydb/core/tx/schemeshard/ut_index_build_reboots.cpp
+++ b/ydb/core/tx/schemeshard/ut_index_build_reboots.cpp
@@ -130,7 +130,7 @@ Y_UNIT_TEST_SUITE(IndexBuildTestReboots) {
                 UNIT_ASSERT_VALUES_EQUAL_C(status, NKikimrProto::OK, err);
                 UNIT_ASSERT_VALUES_EQUAL(err, "");
 
-                NKqp::CompareYson(R"([[[[[["100000"];["1000"]];[["100001"];["1001"]];[["100002"];["1002"]];[["100003"];["1003"]];[["100004"];["1004"]];[["100005"];["1005"]];[["100006"];["1006"]];[["100007"];["1007"]];[["100008"];["1008"]];[["100009"];["1009"]];[["101000"];["2000"]];[["101001"];["2001"]];[["101002"];["2002"]];[["101003"];["2003"]];[["101004"];["2004"]];[["101005"];["2005"]];[["101006"];["2006"]];[["101007"];["2007"]];[["101008"];["2008"]];[["101009"];["2009"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["100000"];["1000"]];[["100001"];["1001"]];[["100002"];["1002"]];[["100003"];["1003"]];[["100004"];["1004"]];[["100005"];["1005"]];[["100006"];["1006"]];[["100007"];["1007"]];[["100008"];["1008"]];[["100009"];["1009"]];[["101000"];["2000"]];[["101001"];["2001"]];[["101002"];["2002"]];[["101003"];["2003"]];[["101004"];["2004"]];[["101005"];["2005"]];[["101006"];["2006"]];[["101007"];["2007"]];[["101008"];["2008"]];[["101009"];["2009"]]];%false]]])", result); 
             }
         });
     }
@@ -200,7 +200,7 @@ Y_UNIT_TEST_SUITE(IndexBuildTestReboots) {
                 UNIT_ASSERT_VALUES_EQUAL_C(status, NKikimrProto::OK, err);
                 UNIT_ASSERT_VALUES_EQUAL(err, "");
 
-                NKqp::CompareYson(R"([[[[[["100000"];["1000"];["aaaa"]];[["100001"];["1001"];["aaaa"]];[["100002"];["1002"];["aaaa"]];[["100003"];["1003"];["aaaa"]];[["100004"];["1004"];["aaaa"]];[["100005"];["1005"];["aaaa"]];[["100006"];["1006"];["aaaa"]];[["100007"];["1007"];["aaaa"]];[["100008"];["1008"];["aaaa"]];[["100009"];["1009"];["aaaa"]];[["101000"];["2000"];["aaaa"]];[["101001"];["2001"];["aaaa"]];[["101002"];["2002"];["aaaa"]];[["101003"];["2003"];["aaaa"]];[["101004"];["2004"];["aaaa"]];[["101005"];["2005"];["aaaa"]];[["101006"];["2006"];["aaaa"]];[["101007"];["2007"];["aaaa"]];[["101008"];["2008"];["aaaa"]];[["101009"];["2009"];["aaaa"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["100000"];["1000"];["aaaa"]];[["100001"];["1001"];["aaaa"]];[["100002"];["1002"];["aaaa"]];[["100003"];["1003"];["aaaa"]];[["100004"];["1004"];["aaaa"]];[["100005"];["1005"];["aaaa"]];[["100006"];["1006"];["aaaa"]];[["100007"];["1007"];["aaaa"]];[["100008"];["1008"];["aaaa"]];[["100009"];["1009"];["aaaa"]];[["101000"];["2000"];["aaaa"]];[["101001"];["2001"];["aaaa"]];[["101002"];["2002"];["aaaa"]];[["101003"];["2003"];["aaaa"]];[["101004"];["2004"];["aaaa"]];[["101005"];["2005"];["aaaa"]];[["101006"];["2006"];["aaaa"]];[["101007"];["2007"];["aaaa"]];[["101008"];["2008"];["aaaa"]];[["101009"];["2009"];["aaaa"]]];%false]]])", result); 
             }
         });
     }
diff --git a/ydb/core/tx/schemeshard/ut_restore.cpp b/ydb/core/tx/schemeshard/ut_restore.cpp
index a8b33dcbdc..4cd714c833 100644
--- a/ydb/core/tx/schemeshard/ut_restore.cpp
+++ b/ydb/core/tx/schemeshard/ut_restore.cpp
@@ -277,7 +277,7 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
         )", {data});
 
         auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets);
-        NKqp::CompareYson(data.YsonStr, content);
+        NKqp::CompareYson(data.YsonStr, content); 
     }
 
     Y_UNIT_TEST(ShouldSucceedOnMultiShardTable) {
@@ -300,11 +300,11 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
 
         {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 0);
-            NKqp::CompareYson(a.YsonStr, content);
+            NKqp::CompareYson(a.YsonStr, content); 
         }
         {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 1);
-            NKqp::CompareYson(b.YsonStr, content);
+            NKqp::CompareYson(b.YsonStr, content); 
         }
     }
 
@@ -322,7 +322,7 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
         )", {data});
 
         auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets, "Table", {"key", "Uint32", "0"});
-        NKqp::CompareYson(data.YsonStr, content);
+        NKqp::CompareYson(data.YsonStr, content); 
     }
 
     Y_UNIT_TEST(ShouldSucceedOnSupportedDatatypes) {
@@ -419,7 +419,7 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
             "json_value",
             "jsondoc_value",
         });
-        NKqp::CompareYson(data.YsonStr, content);
+        NKqp::CompareYson(data.YsonStr, content); 
     }
 
     Y_UNIT_TEST(ShouldRestoreSpecialFpValues) {
@@ -549,7 +549,7 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
         )", {data});
 
         auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets);
-        NKqp::CompareYson(data.YsonStr, content);
+        NKqp::CompareYson(data.YsonStr, content); 
     }
 
     Y_UNIT_TEST(ShouldFailOnEmptyToken) {
@@ -565,7 +565,7 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
         )", {data});
 
         auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets);
-        NKqp::CompareYson(data.YsonStr, content);
+        NKqp::CompareYson(data.YsonStr, content); 
     }
 
     Y_UNIT_TEST(ShouldFailOnInvalidValue) {
@@ -581,7 +581,7 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
         )", {data});
 
         auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets, "Table", {"key", "Uint64", "0"});
-        NKqp::CompareYson(data.YsonStr, content);
+        NKqp::CompareYson(data.YsonStr, content); 
     }
 
     Y_UNIT_TEST(ShouldFailOnOutboundKey) {
@@ -604,15 +604,15 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
 
         {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 0);
-            NKqp::CompareYson(a.YsonStr, content);
+            NKqp::CompareYson(a.YsonStr, content); 
         }
         {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 1);
-            NKqp::CompareYson(b.YsonStr, content);
+            NKqp::CompareYson(b.YsonStr, content); 
         }
     }
 
-    void TestRestoreNegative(TTestActorRuntime& runtime, ui64 txId, const TString& parentPath, const TString& name,
+    void TestRestoreNegative(TTestActorRuntime& runtime, ui64 txId, const TString& parentPath, const TString& name, 
             const TVector<TEvSchemeShard::EStatus>& expectedResults) {
 
         TestRestore(runtime, ++txId, parentPath, Sprintf(R"(
@@ -711,7 +711,7 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
         env.TestWaitNotification(runtime, {restoreTxId, txId});
 
         auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets);
-        NKqp::CompareYson(data.YsonStr, content);
+        NKqp::CompareYson(data.YsonStr, content); 
     }
 
     Y_UNIT_TEST(CancelUponProposeShouldSucceed) {
@@ -777,7 +777,7 @@ Y_UNIT_TEST_SUITE(TRestoreTests) {
         env.TestWaitNotification(runtime, {restoreTxId, txId});
 
         auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets);
-        NKqp::CompareYson(data.YsonStr, content);
+        NKqp::CompareYson(data.YsonStr, content); 
     }
 }
 
@@ -839,7 +839,7 @@ Y_UNIT_TEST_SUITE(TRestoreWithRebootsTests) {
                 TInactiveZone inactive(activeZone);
 
                 auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets);
-                NKqp::CompareYson(data.YsonStr, content);
+                NKqp::CompareYson(data.YsonStr, content); 
             }
         });
     }
@@ -869,11 +869,11 @@ Y_UNIT_TEST_SUITE(TRestoreWithRebootsTests) {
                 TInactiveZone inactive(activeZone);
                 {
                     auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 0);
-                    NKqp::CompareYson(a.YsonStr, content);
+                    NKqp::CompareYson(a.YsonStr, content); 
                 }
                 {
                     auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 1);
-                    NKqp::CompareYson(b.YsonStr, content);
+                    NKqp::CompareYson(b.YsonStr, content); 
                 }
             }
         });
@@ -951,7 +951,7 @@ Y_UNIT_TEST_SUITE(TRestoreWithRebootsTests) {
                 TInactiveZone inactive(activeZone);
 
                 auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets, "Table", {"key", "Uint32", "0"});
-                NKqp::CompareYson(data.YsonStr, content);
+                NKqp::CompareYson(data.YsonStr, content); 
             }
         });
     }
@@ -975,7 +975,7 @@ Y_UNIT_TEST_SUITE(TRestoreWithRebootsTests) {
                 TInactiveZone inactive(activeZone);
 
                 auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets);
-                NKqp::CompareYson(data.YsonStr, content);
+                NKqp::CompareYson(data.YsonStr, content); 
             }
         });
     }
@@ -999,7 +999,7 @@ Y_UNIT_TEST_SUITE(TRestoreWithRebootsTests) {
                 TInactiveZone inactive(activeZone);
 
                 auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets);
-                NKqp::CompareYson(data.YsonStr, content);
+                NKqp::CompareYson(data.YsonStr, content); 
             }
         });
     }
@@ -1023,7 +1023,7 @@ Y_UNIT_TEST_SUITE(TRestoreWithRebootsTests) {
                 TInactiveZone inactive(activeZone);
 
                 auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets, "Table", {"key", "Uint64", "0"});
-                NKqp::CompareYson(data.YsonStr, content);
+                NKqp::CompareYson(data.YsonStr, content); 
             }
         });
     }
@@ -1053,11 +1053,11 @@ Y_UNIT_TEST_SUITE(TRestoreWithRebootsTests) {
                 TInactiveZone inactive(activeZone);
                 {
                     auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 0);
-                    NKqp::CompareYson(a.YsonStr, content);
+                    NKqp::CompareYson(a.YsonStr, content); 
                 }
                 {
                     auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 1);
-                    NKqp::CompareYson(b.YsonStr, content);
+                    NKqp::CompareYson(b.YsonStr, content); 
                 }
             }
         });
@@ -1243,7 +1243,7 @@ Y_UNIT_TEST_SUITE(TImportTests) {
         )");
 
         auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets);
-        NKqp::CompareYson(data.Data[0].YsonStr, content);
+        NKqp::CompareYson(data.Data[0].YsonStr, content); 
     }
 
     Y_UNIT_TEST(ShouldSucceedOnMultiShardTable) {
@@ -1280,11 +1280,11 @@ Y_UNIT_TEST_SUITE(TImportTests) {
 
         {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 0);
-            NKqp::CompareYson(data.Data[0].YsonStr, content);
+            NKqp::CompareYson(data.Data[0].YsonStr, content); 
         }
         {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 1);
-            NKqp::CompareYson(data.Data[1].YsonStr, content);
+            NKqp::CompareYson(data.Data[1].YsonStr, content); 
         }
     }
 
@@ -1328,13 +1328,13 @@ Y_UNIT_TEST_SUITE(TImportTests) {
 
         {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 0);
-            NKqp::CompareYson(data.Data[0].YsonStr, content);
+            NKqp::CompareYson(data.Data[0].YsonStr, content); 
         }
 
         for (ui32 i = 0; i < indexes; ++i) {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 1 + i,
                 "indexImplTable", {"value", "Utf8", "\"\""}, {"value", "key"});
-            NKqp::CompareYson(data.Data[0].YsonStr, content);
+            NKqp::CompareYson(data.Data[0].YsonStr, content); 
         }
     }
 
@@ -1394,11 +1394,11 @@ Y_UNIT_TEST_SUITE(TImportTests) {
 
         {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 0, "TableA");
-            NKqp::CompareYson(a.Data[0].YsonStr, content);
+            NKqp::CompareYson(a.Data[0].YsonStr, content); 
         }
         {
             auto content = ReadTable(runtime, TTestTxConfig::FakeHiveTablets + 1, "TableB");
-            NKqp::CompareYson(b.Data[0].YsonStr, content);
+            NKqp::CompareYson(b.Data[0].YsonStr, content); 
         }
     }
 
diff --git a/ydb/core/tx/schemeshard/ut_ttl.cpp b/ydb/core/tx/schemeshard/ut_ttl.cpp
index d512ad0033..f6e9631d19 100644
--- a/ydb/core/tx/schemeshard/ut_ttl.cpp
+++ b/ydb/core/tx/schemeshard/ut_ttl.cpp
@@ -498,14 +498,14 @@ Y_UNIT_TEST_SUITE(TSchemeShardTTLTests) {
             writeRow(tabletId, 1, now, "TTLEnabledTable1");
             {
                 auto result = readTable(tabletId, "TTLEnabledTable1");
-                NKqp::CompareYson(R"([[[[[["1"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["1"]]];%false]]])", result); 
             }
 
             runtime.AdvanceCurrentTime(TDuration::Minutes(1));
             WaitForCondErase(runtime);
             {
                 auto result = readTable(tabletId, "TTLEnabledTable1");
-                NKqp::CompareYson(R"([[[[];%false]]])", result);
+                NKqp::CompareYson(R"([[[[];%false]]])", result); 
             }
         }
 
@@ -529,21 +529,21 @@ Y_UNIT_TEST_SUITE(TSchemeShardTTLTests) {
             writeRow(tabletId, 2, now, "TTLEnabledTable2");
             {
                 auto result = readTable(tabletId, "TTLEnabledTable2");
-                NKqp::CompareYson(R"([[[[[["1"]];[["2"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["1"]];[["2"]]];%false]]])", result); 
             }
 
             runtime.AdvanceCurrentTime(TDuration::Minutes(1));
             WaitForCondErase(runtime);
             {
                 auto result = readTable(tabletId, "TTLEnabledTable2");
-                NKqp::CompareYson(R"([[[[[["2"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["2"]]];%false]]])", result); 
             }
 
             runtime.AdvanceCurrentTime(TDuration::Hours(1));
             WaitForCondErase(runtime);
             {
                 auto result = readTable(tabletId, "TTLEnabledTable2");
-                NKqp::CompareYson(R"([[[[];%false]]])", result);
+                NKqp::CompareYson(R"([[[[];%false]]])", result); 
             }
         }
 
@@ -567,21 +567,21 @@ Y_UNIT_TEST_SUITE(TSchemeShardTTLTests) {
             writeRow(tabletId, 1, now, "TTLEnabledTable3");
             {
                 auto result = readTable(tabletId, "TTLEnabledTable3");
-                NKqp::CompareYson(R"([[[[[["1"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["1"]]];%false]]])", result); 
             }
 
             runtime.AdvanceCurrentTime(TDuration::Minutes(1));
             waitForScheduleCondErase();
             {
                 auto result = readTable(tabletId, "TTLEnabledTable3");
-                NKqp::CompareYson(R"([[[[[["1"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["1"]]];%false]]])", result); 
             }
 
             runtime.AdvanceCurrentTime(TDuration::Hours(1));
             waitForScheduleCondErase();
             {
                 auto result = readTable(tabletId, "TTLEnabledTable3");
-                NKqp::CompareYson(R"([[[[[["1"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["1"]]];%false]]])", result); 
             }
         }
 
@@ -607,14 +607,14 @@ Y_UNIT_TEST_SUITE(TSchemeShardTTLTests) {
             writeRow(tabletId, 2, now + TDuration::Days(1), "TTLEnabledTable4", "Uint64");
             {
                 auto result = readTable(tabletId, "TTLEnabledTable4");
-                NKqp::CompareYson(R"([[[[[["1"]];[["2"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["1"]];[["2"]]];%false]]])", result); 
             }
 
             runtime.AdvanceCurrentTime(TDuration::Minutes(1));
             WaitForCondErase(runtime);
             {
                 auto result = readTable(tabletId, "TTLEnabledTable4");
-                NKqp::CompareYson(R"([[[[[["2"]]];%false]]])", result);
+                NKqp::CompareYson(R"([[[[[["2"]]];%false]]])", result); 
             }
         }
     }
diff --git a/ydb/core/tx/tx_proxy/datareq.cpp b/ydb/core/tx/tx_proxy/datareq.cpp
index af48b42d60..7ad3fb560f 100644
--- a/ydb/core/tx/tx_proxy/datareq.cpp
+++ b/ydb/core/tx/tx_proxy/datareq.cpp
@@ -37,9 +37,9 @@
 namespace NKikimr {
 namespace NTxProxy {
 
-const ui32 MaxDatashardProgramSize = 48 * 1024 * 1024; // 48 MB
-const ui32 ShardCancelDeadlineShiftSec = 60;
-
+const ui32 MaxDatashardProgramSize = 48 * 1024 * 1024; // 48 MB 
+const ui32 ShardCancelDeadlineShiftSec = 60; 
+ 
 namespace {
     static constexpr TDuration MinReattachDelay = TDuration::MilliSeconds(10);
     static constexpr TDuration MaxReattachDelay = TDuration::MilliSeconds(100);
@@ -50,11 +50,11 @@ struct TFlatMKQLRequest : public TThrRefBase {
     TAutoPtr<NMiniKQL::IEngineFlat> Engine;
     ui64 LockTxId;
     bool NeedDiagnostics;
-    bool LlvmRuntime;
+    bool LlvmRuntime; 
     bool CollectStats;
-    bool ReadOnlyProgram;
-    TMaybe<ui64> PerShardKeysSizeLimitBytes;
-    NKikimrTxUserProxy::TMiniKQLTransaction::TLimits Limits;
+    bool ReadOnlyProgram; 
+    TMaybe<ui64> PerShardKeysSizeLimitBytes; 
+    NKikimrTxUserProxy::TMiniKQLTransaction::TLimits Limits; 
     TRowVersion Snapshot = TRowVersion::Min();
 
     TMap<ui64, TAutoPtr<TBalanceCoverageBuilder>> BalanceCoverageBuilders;
@@ -67,10 +67,10 @@ struct TFlatMKQLRequest : public TThrRefBase {
     TFlatMKQLRequest()
         : LockTxId(0)
         , NeedDiagnostics(false)
-        , LlvmRuntime(false)
+        , LlvmRuntime(false) 
         , CollectStats(false)
-        , ReadOnlyProgram(false)
-        , EngineResultStatusCode(NMiniKQL::IEngineFlat::EResult::Unknown)
+        , ReadOnlyProgram(false) 
+        , EngineResultStatusCode(NMiniKQL::IEngineFlat::EResult::Unknown) 
         , EngineResponseStatus(NMiniKQL::IEngineFlat::EStatus::Unknown)
     {}
 
@@ -300,7 +300,7 @@ private:
 
     ui64 ProxyFlags;
     TDuration ExecTimeoutPeriod;
-    TDuration CancelAfter;
+    TDuration CancelAfter; 
     TSchedulerCookieHolder ExecTimeoutCookieHolder;
 
     TActorId RequestSource;
@@ -444,8 +444,8 @@ private:
                           EParseRangeKeyExp exp);
 
     bool CheckDomainLocality(NSchemeCache::TSchemeCacheRequest &cacheRequest);
-    void BuildTxStats(NKikimrQueryStats::TTxStats& stats);
-    bool IsReadOnlyRequest() const;
+    void BuildTxStats(NKikimrQueryStats::TTxStats& stats); 
+    bool IsReadOnlyRequest() const; 
 
 public:
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
@@ -523,7 +523,7 @@ public:
             HFuncTraced(TEvPipeCache::TEvDeliveryProblem, HandlePrepare);
             HFuncTraced(TEvPrivate::TEvReattachToShard, Handle);
             HFuncTraced(TEvents::TEvUndelivered, Handle);
-            CFunc(TEvents::TSystem::Wakeup, HandleExecTimeout);
+            CFunc(TEvents::TSystem::Wakeup, HandleExecTimeout); 
             CFunc(TEvPrivate::EvProxyDataReqOngoingTransactionsWatchdog, HandleWatchdog);
         }
     }
@@ -556,7 +556,7 @@ public:
             HFuncTraced(TEvPipeCache::TEvDeliveryProblem, HandlePlan);
             HFuncTraced(TEvPrivate::TEvReattachToShard, Handle);
             HFuncTraced(TEvents::TEvUndelivered, Handle);
-            CFunc(TEvents::TSystem::Wakeup, HandleExecTimeout);
+            CFunc(TEvents::TSystem::Wakeup, HandleExecTimeout); 
             CFunc(TEvPrivate::EvProxyDataReqOngoingTransactionsWatchdog, HandleWatchdog);
         }
     }
@@ -941,13 +941,13 @@ void TDataReq::ProcessFlatMKQLResolve(NSchemeCache::TSchemeCacheRequest *cacheRe
 
     auto beforeBuild = Now();
     NMiniKQL::IEngineFlat::TShardLimits shardLimits(RequestControls.MaxShardCount, RequestControls.MaxReadSetCount);
-    if (FlatMKQLRequest->Limits.GetAffectedShardsLimit()) {
-        shardLimits.ShardCount = std::min(shardLimits.ShardCount, FlatMKQLRequest->Limits.GetAffectedShardsLimit());
-    }
-    if (FlatMKQLRequest->Limits.GetReadsetCountLimit()) {
-        shardLimits.RSCount = std::min(shardLimits.RSCount, FlatMKQLRequest->Limits.GetReadsetCountLimit());
-    }
-    FlatMKQLRequest->EngineResultStatusCode = engine.PrepareShardPrograms(shardLimits);
+    if (FlatMKQLRequest->Limits.GetAffectedShardsLimit()) { 
+        shardLimits.ShardCount = std::min(shardLimits.ShardCount, FlatMKQLRequest->Limits.GetAffectedShardsLimit()); 
+    } 
+    if (FlatMKQLRequest->Limits.GetReadsetCountLimit()) { 
+        shardLimits.RSCount = std::min(shardLimits.RSCount, FlatMKQLRequest->Limits.GetReadsetCountLimit()); 
+    } 
+    FlatMKQLRequest->EngineResultStatusCode = engine.PrepareShardPrograms(shardLimits); 
     auto afterBuild = Now();
 
     if (FlatMKQLRequest->EngineResultStatusCode != NMiniKQL::IEngineFlat::EResult::Ok) {
@@ -959,21 +959,21 @@ void TDataReq::ProcessFlatMKQLResolve(NSchemeCache::TSchemeCacheRequest *cacheRe
         return Die(ctx);
     }
 
-    FlatMKQLRequest->ReadOnlyProgram = engine.IsReadOnlyProgram();
-
+    FlatMKQLRequest->ReadOnlyProgram = engine.IsReadOnlyProgram(); 
+ 
     TxProxyMon->TxPrepareBuildShardProgramsHgram->Collect((afterBuild - beforeBuild).MicroSeconds());
 
     if (engine.GetAffectedShardCount() > 1 || FlatMKQLRequest->Snapshot) // TODO KIKIMR-11912
         CanUseFollower = false;
 
-    TDuration shardCancelAfter = ExecTimeoutPeriod;
-    if (CancelAfter) {
-        shardCancelAfter = Min(shardCancelAfter, CancelAfter);
-    }
-
-    TInstant shardCancelDeadline = WallClockAccepted + shardCancelAfter
-        + TDuration::Seconds(ShardCancelDeadlineShiftSec);
-
+    TDuration shardCancelAfter = ExecTimeoutPeriod; 
+    if (CancelAfter) { 
+        shardCancelAfter = Min(shardCancelAfter, CancelAfter); 
+    } 
+ 
+    TInstant shardCancelDeadline = WallClockAccepted + shardCancelAfter 
+        + TDuration::Seconds(ShardCancelDeadlineShiftSec); 
+ 
     for (ui32 shx = 0, affectedShards = engine.GetAffectedShardCount(); shx != affectedShards; ++shx) {
         NMiniKQL::IEngineFlat::TShardData shardData;
         const auto shardDataRes = engine.GetAffectedShard(shx, shardData);
@@ -982,42 +982,42 @@ void TDataReq::ProcessFlatMKQLResolve(NSchemeCache::TSchemeCacheRequest *cacheRe
         NKikimrTxDataShard::TDataTransaction dataTransaction;
         dataTransaction.SetMiniKQL(shardData.Program);
         dataTransaction.SetImmediate(shardData.Immediate || FlatMKQLRequest->Snapshot && FlatMKQLRequest->ReadOnlyProgram);
-        dataTransaction.SetReadOnly(FlatMKQLRequest->ReadOnlyProgram);
-        dataTransaction.SetCancelAfterMs(shardCancelAfter.MilliSeconds());
-        dataTransaction.SetCancelDeadlineMs(shardCancelDeadline.MilliSeconds());
+        dataTransaction.SetReadOnly(FlatMKQLRequest->ReadOnlyProgram); 
+        dataTransaction.SetCancelAfterMs(shardCancelAfter.MilliSeconds()); 
+        dataTransaction.SetCancelDeadlineMs(shardCancelDeadline.MilliSeconds()); 
         dataTransaction.SetCollectStats(FlatMKQLRequest->CollectStats);
         if (FlatMKQLRequest->LockTxId)
             dataTransaction.SetLockTxId(FlatMKQLRequest->LockTxId);
         if (FlatMKQLRequest->NeedDiagnostics)
             dataTransaction.SetNeedDiagnostics(true);
-        if (FlatMKQLRequest->LlvmRuntime)
-            dataTransaction.SetLlvmRuntime(true);
-        if (FlatMKQLRequest->PerShardKeysSizeLimitBytes)
-            dataTransaction.SetPerShardKeysSizeLimitBytes(*FlatMKQLRequest->PerShardKeysSizeLimitBytes);
+        if (FlatMKQLRequest->LlvmRuntime) 
+            dataTransaction.SetLlvmRuntime(true); 
+        if (FlatMKQLRequest->PerShardKeysSizeLimitBytes) 
+            dataTransaction.SetPerShardKeysSizeLimitBytes(*FlatMKQLRequest->PerShardKeysSizeLimitBytes); 
         const TString transactionBuffer = dataTransaction.SerializeAsString();
 
-        if (transactionBuffer.size() > MaxDatashardProgramSize) {
-            TString error = TStringBuilder() << "Datashard program size limit exceeded ("
-                << transactionBuffer.size() << " > " << MaxDatashardProgramSize << ")";
-
-            LOG_ERROR_S(ctx, NKikimrServices::TX_PROXY, error
-                << ", actor: " << ctx.SelfID.ToString()
-                << ", txId: " << TxId
-                << ", shard: " << shardData.ShardId);
-
-            for (ui32 i = 0; i < shx; ++i) {
-                auto result = engine.GetAffectedShard(i, shardData);
-                if (result == NMiniKQL::IEngineFlat::EResult::Ok) {
-                    CancelProposal(shardData.ShardId);
-                }
-            }
-
-            IssueManager.RaiseIssue(MakeIssue(NKikimrIssues::TIssuesIds::SHARD_PROGRAM_SIZE_EXCEEDED, error));
-            ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecError,
-                NKikimrIssues::TStatusIds::QUERY_ERROR, true, ctx);
-            return Die(ctx);
-        }
-
+        if (transactionBuffer.size() > MaxDatashardProgramSize) { 
+            TString error = TStringBuilder() << "Datashard program size limit exceeded (" 
+                << transactionBuffer.size() << " > " << MaxDatashardProgramSize << ")"; 
+ 
+            LOG_ERROR_S(ctx, NKikimrServices::TX_PROXY, error 
+                << ", actor: " << ctx.SelfID.ToString() 
+                << ", txId: " << TxId 
+                << ", shard: " << shardData.ShardId); 
+ 
+            for (ui32 i = 0; i < shx; ++i) { 
+                auto result = engine.GetAffectedShard(i, shardData); 
+                if (result == NMiniKQL::IEngineFlat::EResult::Ok) { 
+                    CancelProposal(shardData.ShardId); 
+                } 
+            } 
+ 
+            IssueManager.RaiseIssue(MakeIssue(NKikimrIssues::TIssuesIds::SHARD_PROGRAM_SIZE_EXCEEDED, error)); 
+            ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecError, 
+                NKikimrIssues::TStatusIds::QUERY_ERROR, true, ctx); 
+            return Die(ctx); 
+        } 
+ 
         const auto affectedType = shardData.HasWrites ? TPerTablet::AffectedWrite : TPerTablet::AffectedRead;
 
         TPerTablet &perTablet = PerTablet[shardData.ShardId];
@@ -1031,9 +1031,9 @@ void TDataReq::ProcessFlatMKQLResolve(NSchemeCache::TSchemeCacheRequest *cacheRe
         // we would need shard -> table mapping for scheme cache invalidation on errors
         for (const auto& keyDescription : keyDescriptions) {
             for (auto& partition : keyDescription->Partitions) {
-                if (auto *x = PerTablet.FindPtr(partition.ShardId)) {
+                if (auto *x = PerTablet.FindPtr(partition.ShardId)) { 
                     x->TableId = keyDescription->TableId;
-                }
+                } 
             }
         }
 
@@ -1108,7 +1108,7 @@ void TDataReq::ProcessReadTableResolve(NSchemeCache::TSchemeCacheRequest *cacheR
 
         const TString transactionBuffer = dataTransaction.SerializeAsString();
 
-        TPerTablet &perTablet = PerTablet[partition.ShardId];
+        TPerTablet &perTablet = PerTablet[partition.ShardId]; 
         perTablet.TableId = ReadTableRequest->KeyDesc->TableId;
         perTablet.TabletStatus = TPerTablet::ETabletStatus::StatusWait;
         perTablet.AffectedFlags = TPerTablet::AffectedRead;
@@ -1118,7 +1118,7 @@ void TDataReq::ProcessReadTableResolve(NSchemeCache::TSchemeCacheRequest *cacheR
 
         LOG_DEBUG_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId,
             "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId
-            << " SEND TEvProposeTransaction to datashard " << partition.ShardId
+            << " SEND TEvProposeTransaction to datashard " << partition.ShardId 
             << " with read table request"
             << " affected shards " << ReadTableRequest->KeyDesc->Partitions.size()
             << " followers " << (CanUseFollower ? "allowed" : "disallowed") << " marker# P4b");
@@ -1129,7 +1129,7 @@ void TDataReq::ProcessReadTableResolve(NSchemeCache::TSchemeCacheRequest *cacheR
                 new TEvDataShard::TEvProposeTransaction(NKikimrTxDataShard::TX_KIND_SCAN,
                     ctx.SelfID, TxId, transactionBuffer,
                     TxFlags | (immediate ? NTxDataShard::TTxFlags::Immediate : 0)),
-                partition.ShardId, true));
+                partition.ShardId, true)); 
     }
 
     Become(&TThis::StateWaitPrepare);
@@ -1216,26 +1216,26 @@ void TDataReq::Handle(TEvTxProxyReq::TEvMakeRequest::TPtr &ev, const TActorConte
         ExecTimeoutPeriod = TDuration::Minutes(30);
     }
 
-    CancelAfter = TDuration::MilliSeconds(record.GetCancelAfterMs());
-    if (CancelAfter.Hours() > 8) {
-        LOG_WARN_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId,
-                            "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId
-                            << " huge CancelAfter duration " << CancelAfter.ToString()
-                            << ", disabling CancelAfter");
-        CancelAfter = {};
-    }
-
+    CancelAfter = TDuration::MilliSeconds(record.GetCancelAfterMs()); 
+    if (CancelAfter.Hours() > 8) { 
+        LOG_WARN_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId, 
+                            "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId 
+                            << " huge CancelAfter duration " << CancelAfter.ToString() 
+                            << ", disabling CancelAfter"); 
+        CancelAfter = {}; 
+    } 
+ 
     WallClockAccepted = Now();
     ctx.Schedule(TDuration::MilliSeconds(KIKIMR_DATAREQ_WATCHDOG_PERIOD), new TEvPrivate::TEvProxyDataReqOngoingTransactionWatchdog());
 
-    // Schedule execution timeout
-    {
+    // Schedule execution timeout 
+    { 
         TAutoPtr<IEventHandle> wakeupEv(new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
         ExecTimeoutCookieHolder.Reset(ISchedulerCookie::Make2Way());
-
-        CreateLongTimer(ctx, ExecTimeoutPeriod, wakeupEv, AppData(ctx)->SystemPoolId, ExecTimeoutCookieHolder.Get());
-    }
-
+ 
+        CreateLongTimer(ctx, ExecTimeoutPeriod, wakeupEv, AppData(ctx)->SystemPoolId, ExecTimeoutCookieHolder.Get()); 
+    } 
+ 
     const NKikimrTxUserProxy::TTransaction &txbody = record.GetTransaction();
     RequestSource = msg->Ev->Sender;
     TxFlags = txbody.GetFlags() & ~NTxDataShard::TTxFlags::Immediate; // Ignore external immediate flag
@@ -1281,14 +1281,14 @@ void TDataReq::Handle(TEvTxProxyReq::TEvMakeRequest::TPtr &ev, const TActorConte
 
         if (mkqlTxBody.GetFlatMKQL()) {
             FlatMKQLRequest = new TFlatMKQLRequest;
-            FlatMKQLRequest->LlvmRuntime = mkqlTxBody.GetLlvmRuntime();
+            FlatMKQLRequest->LlvmRuntime = mkqlTxBody.GetLlvmRuntime(); 
             FlatMKQLRequest->CollectStats = mkqlTxBody.GetCollectStats();
-            if (mkqlTxBody.HasPerShardKeysSizeLimitBytes()) {
-                FlatMKQLRequest->PerShardKeysSizeLimitBytes = mkqlTxBody.GetPerShardKeysSizeLimitBytes();
-            }
-            if (mkqlTxBody.HasLimits()) {
-                FlatMKQLRequest->Limits.CopyFrom(mkqlTxBody.GetLimits());
-            }
+            if (mkqlTxBody.HasPerShardKeysSizeLimitBytes()) { 
+                FlatMKQLRequest->PerShardKeysSizeLimitBytes = mkqlTxBody.GetPerShardKeysSizeLimitBytes(); 
+            } 
+            if (mkqlTxBody.HasLimits()) { 
+                FlatMKQLRequest->Limits.CopyFrom(mkqlTxBody.GetLimits()); 
+            } 
             if (mkqlTxBody.HasSnapshotStep() && mkqlTxBody.HasSnapshotTxId())
                 FlatMKQLRequest->Snapshot = TRowVersion(mkqlTxBody.GetSnapshotStep(), mkqlTxBody.GetSnapshotTxId());
             NMiniKQL::TEngineFlatSettings settings(NMiniKQL::IEngineFlat::EProtocol::V1, functionRegistry,
@@ -1296,11 +1296,11 @@ void TDataReq::Handle(TEvTxProxyReq::TEvMakeRequest::TPtr &ev, const TActorConte
                                                    nullptr, TxProxyMon->AllocPoolCounters);
             settings.EvaluateResultType = mkqlTxBody.GetEvaluateResultType();
             settings.EvaluateResultValue = mkqlTxBody.GetEvaluateResultValue();
-            if (FlatMKQLRequest->LlvmRuntime) {
-                LOG_DEBUG_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId,
-                    "Using LLVM runtime to execute transaction: " << TxId);
-                settings.LlvmRuntime = true;
-            }
+            if (FlatMKQLRequest->LlvmRuntime) { 
+                LOG_DEBUG_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId, 
+                    "Using LLVM runtime to execute transaction: " << TxId); 
+                settings.LlvmRuntime = true; 
+            } 
             if (ctx.LoggerSettings()->Satisfies(NLog::PRI_DEBUG, NKikimrServices::MINIKQL_ENGINE, TxId)) {
                 auto actorSystem = ctx.ExecutorThread.ActorSystem;
                 auto txId = TxId;
@@ -1309,10 +1309,10 @@ void TDataReq::Handle(TEvTxProxyReq::TEvMakeRequest::TPtr &ev, const TActorConte
                         "Proxy data request, txId: %" PRIu64 ", %s (%" PRIu32 ")\n%s",
                         txId, operation, line, backtrace ? backtrace->PrintToString().data() : "");
                 };
-                settings.LogErrorWriter = [txId, actorSystem](const TString& message) {
-                    LOG_ERROR_S(*actorSystem, NKikimrServices::MINIKQL_ENGINE, "Proxy data request, txId: "
-                        << txId << ", engine error: " << message);
-                };
+                settings.LogErrorWriter = [txId, actorSystem](const TString& message) { 
+                    LOG_ERROR_S(*actorSystem, NKikimrServices::MINIKQL_ENGINE, "Proxy data request, txId: " 
+                        << txId << ", engine error: " << message); 
+                }; 
             }
 
             if ((TxFlags & NTxDataShard::TTxFlags::ForceOnline) != 0) {
@@ -1325,7 +1325,7 @@ void TDataReq::Handle(TEvTxProxyReq::TEvMakeRequest::TPtr &ev, const TActorConte
             TString program = mkqlTxBody.GetProgram().GetBin();
             TString params = mkqlTxBody.GetParams().GetBin();
             resolveReq = PrepareFlatMKQLRequest(program, params, ctx);
-
+ 
             FlatMKQLRequest->RequestAdditionResults(TxId);
         }
     }
@@ -1702,10 +1702,10 @@ void TDataReq::HandlePrepare(TEvPipeCache::TEvDeliveryProblem::TPtr &ev, const T
             TStringStream explanation;
             explanation << "tx state unknown for shard " << msg->TabletId << " with txid# " << TxId;
             IssueManager.RaiseIssue(MakeIssue(NKikimrIssues::TIssuesIds::TX_STATE_UNKNOWN, explanation.Str()));
-            auto status = IsReadOnlyRequest()
-                ? TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardNotAvailable
-                : TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardUnknown;
-            ReportStatus(status, NKikimrIssues::TStatusIds::TIMEOUT, true, ctx);
+            auto status = IsReadOnlyRequest() 
+                ? TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardNotAvailable 
+                : TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardUnknown; 
+            ReportStatus(status, NKikimrIssues::TStatusIds::TIMEOUT, true, ctx); 
         }
 
         Become(&TThis::StatePrepareErrors, ctx, TDuration::MilliSeconds(500), new TEvents::TEvWakeup);
@@ -1913,21 +1913,21 @@ void TDataReq::HandlePrepare(TEvDataShard::TEvProposeTransactionResult::TPtr &ev
         ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardOverloaded, NKikimrIssues::TStatusIds::OVERLOADED, true, ctx);
         TxProxyMon->TxResultShardOverloaded->Inc();
         return Die(ctx);
-    case NKikimrTxDataShard::TEvProposeTransactionResult::EXEC_ERROR:
-        ExtractDatashardErrors(record);
-        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecError, NKikimrIssues::TStatusIds::ERROR, true, ctx);
-        TxProxyMon->TxResultExecError->Inc();
-        return Die(ctx);
-    case NKikimrTxDataShard::TEvProposeTransactionResult::RESULT_UNAVAILABLE:
-        ExtractDatashardErrors(record);
-        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable, NKikimrIssues::TStatusIds::ERROR, true, ctx);
-        TxProxyMon->TxResultResultUnavailable->Inc();
-        return Die(ctx);
-    case NKikimrTxDataShard::TEvProposeTransactionResult::CANCELLED:
-        ExtractDatashardErrors(record);
-        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecCancelled, NKikimrIssues::TStatusIds::ERROR, true, ctx);
-        TxProxyMon->TxResultCancelled->Inc();
-        return Die(ctx);
+    case NKikimrTxDataShard::TEvProposeTransactionResult::EXEC_ERROR: 
+        ExtractDatashardErrors(record); 
+        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecError, NKikimrIssues::TStatusIds::ERROR, true, ctx); 
+        TxProxyMon->TxResultExecError->Inc(); 
+        return Die(ctx); 
+    case NKikimrTxDataShard::TEvProposeTransactionResult::RESULT_UNAVAILABLE: 
+        ExtractDatashardErrors(record); 
+        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable, NKikimrIssues::TStatusIds::ERROR, true, ctx); 
+        TxProxyMon->TxResultResultUnavailable->Inc(); 
+        return Die(ctx); 
+    case NKikimrTxDataShard::TEvProposeTransactionResult::CANCELLED: 
+        ExtractDatashardErrors(record); 
+        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecCancelled, NKikimrIssues::TStatusIds::ERROR, true, ctx); 
+        TxProxyMon->TxResultCancelled->Inc(); 
+        return Die(ctx); 
     case NKikimrTxDataShard::TEvProposeTransactionResult::BAD_REQUEST:
         ExtractDatashardErrors(record);
         ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::WrongRequest, NKikimrIssues::TStatusIds::BAD_REQUEST, true, ctx);
@@ -2216,18 +2216,18 @@ void TDataReq::HandlePlan(TEvDataShard::TEvProposeTransactionResult::TPtr &ev, c
         ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecAborted, NKikimrIssues::TStatusIds::SUCCESS, true, ctx);
         TxProxyMon->PlanClientTxResultAborted->Inc();
         return Die(ctx);
-    case NKikimrTxDataShard::TEvProposeTransactionResult::RESULT_UNAVAILABLE:
-        ExtractDatashardErrors(record);
-        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable, NKikimrIssues::TStatusIds::ERROR, true, ctx);
-        TxProxyMon->PlanClientTxResultResultUnavailable->Inc();
-        return Die(ctx);
-    case NKikimrTxDataShard::TEvProposeTransactionResult::CANCELLED:
-        ExtractDatashardErrors(record);
-        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecCancelled, NKikimrIssues::TStatusIds::ERROR, true, ctx);
-        TxProxyMon->PlanClientTxResultCancelled->Inc();
-        return Die(ctx);
+    case NKikimrTxDataShard::TEvProposeTransactionResult::RESULT_UNAVAILABLE: 
+        ExtractDatashardErrors(record); 
+        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable, NKikimrIssues::TStatusIds::ERROR, true, ctx); 
+        TxProxyMon->PlanClientTxResultResultUnavailable->Inc(); 
+        return Die(ctx); 
+    case NKikimrTxDataShard::TEvProposeTransactionResult::CANCELLED: 
+        ExtractDatashardErrors(record); 
+        ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecCancelled, NKikimrIssues::TStatusIds::ERROR, true, ctx); 
+        TxProxyMon->PlanClientTxResultCancelled->Inc(); 
+        return Die(ctx); 
     default:
-        ExtractDatashardErrors(record);
+        ExtractDatashardErrors(record); 
         ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecError, NKikimrIssues::TStatusIds::ERROR, true, ctx);
         TxProxyMon->PlanClientTxResultExecError->Inc();
         return Die(ctx);
@@ -2265,11 +2265,11 @@ void TDataReq::HandlePlan(TEvPipeCache::TEvDeliveryProblem::TPtr &ev, const TAct
             explanation << "tx state unknown, lost pipe with selected tx coordinator with txid#" << TxId;
             IssueManager.RaiseIssue(MakeIssue(NKikimrIssues::TIssuesIds::TX_STATE_UNKNOWN, explanation.Str()));
 
-            auto status = IsReadOnlyRequest()
-                ? TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorDeclined
-                : TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorUnknown;
-
-            ReportStatus(status, NKikimrIssues::TStatusIds::TIMEOUT, true, ctx);
+            auto status = IsReadOnlyRequest() 
+                ? TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorDeclined 
+                : TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::CoordinatorUnknown; 
+ 
+            ReportStatus(status, NKikimrIssues::TStatusIds::TIMEOUT, true, ctx); 
             TxProxyMon->PlanClientDestroyed->Inc();
         }
 
@@ -2316,10 +2316,10 @@ void TDataReq::HandlePlan(TEvPipeCache::TEvDeliveryProblem::TPtr &ev, const TAct
         explanation << "tx state unknown for shard " << msg->TabletId << " with txid#" << TxId;
         IssueManager.RaiseIssue(MakeIssue(NKikimrIssues::TIssuesIds::TX_STATE_UNKNOWN, explanation.Str()));
 
-        auto status = IsReadOnlyRequest()
-            ? TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardNotAvailable
-            : TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardUnknown;
-        ReportStatus(status, NKikimrIssues::TStatusIds::TIMEOUT, true, ctx);
+        auto status = IsReadOnlyRequest() 
+            ? TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardNotAvailable 
+            : TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ProxyShardUnknown; 
+        ReportStatus(status, NKikimrIssues::TStatusIds::TIMEOUT, true, ctx); 
         TxProxyMon->ClientConnectedError->Inc();
 
         return Die(ctx);
@@ -2521,15 +2521,15 @@ void TDataReq::MergeResult(TEvDataShard::TEvProposeTransactionResult::TPtr &ev,
         return FinishShardStream(ev, ctx);
     }
 
-    Y_VERIFY(FlatMKQLRequest);
+    Y_VERIFY(FlatMKQLRequest); 
     NCpuTime::TCpuTimer timer;
-    NMiniKQL::IEngineFlat &engine = *FlatMKQLRequest->Engine;
-
+    NMiniKQL::IEngineFlat &engine = *FlatMKQLRequest->Engine; 
+ 
     for (const auto& lock : record.GetTxLocks()) {
-        engine.AddTxLock(NMiniKQL::IEngineFlat::TTxLock(
-            lock.GetLockId(),
-            lock.GetDataShard(),
-            lock.GetGeneration(),
+        engine.AddTxLock(NMiniKQL::IEngineFlat::TTxLock( 
+            lock.GetLockId(), 
+            lock.GetDataShard(), 
+            lock.GetGeneration(), 
             lock.GetCounter(),
             lock.GetSchemeShard(),
             lock.GetPathId()));
@@ -2559,7 +2559,7 @@ void TDataReq::MergeResult(TEvDataShard::TEvProposeTransactionResult::TPtr &ev,
     auto builderIt = FlatMKQLRequest->BalanceCoverageBuilders.find(originShard);
     if (builderIt != FlatMKQLRequest->BalanceCoverageBuilders.end()) {
         if (builderIt->second->AddResult(record.GetBalanceTrackList())) {
-            engine.AddShardReply(originShard, record.GetTxResult());
+            engine.AddShardReply(originShard, record.GetTxResult()); 
             if (builderIt->second->IsComplete()) {
                 engine.FinalizeOriginReplies(originShard);
                 FlatMKQLRequest->BalanceCoverageBuilders.erase(builderIt);
@@ -2577,12 +2577,12 @@ void TDataReq::MergeResult(TEvDataShard::TEvProposeTransactionResult::TPtr &ev,
 void TDataReq::MakeFlatMKQLResponse(const TActorContext &ctx, const NCpuTime::TCpuTimer& timer) {
     NMiniKQL::IEngineFlat &engine = *FlatMKQLRequest->Engine;
     engine.SetStepTxId({ PlanStep, TxId });
-
-    engine.SetDeadline(WallClockAccepted + ExecTimeoutPeriod);
-    if (FlatMKQLRequest->Limits.GetComputeNodeMemoryLimitBytes()) {
-        engine.SetMemoryLimit(FlatMKQLRequest->Limits.GetComputeNodeMemoryLimitBytes());
-    }
-
+ 
+    engine.SetDeadline(WallClockAccepted + ExecTimeoutPeriod); 
+    if (FlatMKQLRequest->Limits.GetComputeNodeMemoryLimitBytes()) { 
+        engine.SetMemoryLimit(FlatMKQLRequest->Limits.GetComputeNodeMemoryLimitBytes()); 
+    } 
+ 
     engine.BuildResult();
     FlatMKQLRequest->EngineResponseStatus = engine.GetStatus();
 
@@ -2597,50 +2597,50 @@ void TDataReq::MakeFlatMKQLResponse(const TActorContext &ctx, const NCpuTime::TC
         TxProxyMon->MergeResultMiniKQLExecError->Inc();
         return Die(ctx);
     case NMiniKQL::IEngineFlat::EStatus::Complete:
-    case NMiniKQL::IEngineFlat::EStatus::Aborted: {
+    case NMiniKQL::IEngineFlat::EStatus::Aborted: { 
         LOG_DEBUG_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId,
             "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId
             << " MergeResult ExecComplete TDataReq marker# P17");
-
-        auto fillResult = engine.FillResultValue(FlatMKQLRequest->EngineEvaluatedResponse);
-        switch (fillResult) {
-        case NMiniKQL::IEngineFlat::EResult::Ok:
+ 
+        auto fillResult = engine.FillResultValue(FlatMKQLRequest->EngineEvaluatedResponse); 
+        switch (fillResult) { 
+        case NMiniKQL::IEngineFlat::EResult::Ok: 
             CpuTime += timer.GetTime();
             ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecComplete, NKikimrIssues::TStatusIds::SUCCESS, true, ctx);
-            TxProxyMon->MergeResultMiniKQLExecComplete->Inc();
-            break;
-        case NMiniKQL::IEngineFlat::EResult::ResultTooBig:
-            LOG_ERROR_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId,
-                "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId
-                << " MergeResult Result too large TDataReq marker# P18");
-
-            FlatMKQLRequest->EngineResultStatusCode = fillResult;
+            TxProxyMon->MergeResultMiniKQLExecComplete->Inc(); 
+            break; 
+        case NMiniKQL::IEngineFlat::EResult::ResultTooBig: 
+            LOG_ERROR_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId, 
+                "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId 
+                << " MergeResult Result too large TDataReq marker# P18"); 
+ 
+            FlatMKQLRequest->EngineResultStatusCode = fillResult; 
             CpuTime += timer.GetTime();
-            ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable, NKikimrIssues::TStatusIds::ERROR, true, ctx);
-            TxProxyMon->MergeResultMiniKQLExecError->Inc();
-            break;
-        case NMiniKQL::IEngineFlat::EResult::Cancelled:
-            LOG_ERROR_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId,
-                "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId
-                << " MergeResult Execution was cancelled TDataReq marker# P20");
-
+            ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecResultUnavailable, NKikimrIssues::TStatusIds::ERROR, true, ctx); 
+            TxProxyMon->MergeResultMiniKQLExecError->Inc(); 
+            break; 
+        case NMiniKQL::IEngineFlat::EResult::Cancelled: 
+            LOG_ERROR_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId, 
+                "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId 
+                << " MergeResult Execution was cancelled TDataReq marker# P20"); 
+ 
             CpuTime += timer.GetTime();
-            ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecTimeout, NKikimrIssues::TStatusIds::TIMEOUT, true, ctx);
-            TxProxyMon->ExecTimeout->Inc();
-            break;
-        default:
-            LOG_ERROR_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId,
-                "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId
-                << " MergeResult Error: " << (ui32)fillResult << " TDataReq marker# P19");
-            FlatMKQLRequest->EngineResultStatusCode = fillResult;
+            ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecTimeout, NKikimrIssues::TStatusIds::TIMEOUT, true, ctx); 
+            TxProxyMon->ExecTimeout->Inc(); 
+            break; 
+        default: 
+            LOG_ERROR_S_SAMPLED_BY(ctx, NKikimrServices::TX_PROXY, TxId, 
+                "Actor# " << ctx.SelfID.ToString() << " txid# " << TxId 
+                << " MergeResult Error: " << (ui32)fillResult << " TDataReq marker# P19"); 
+            FlatMKQLRequest->EngineResultStatusCode = fillResult; 
             CpuTime += timer.GetTime();
-            ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecError, NKikimrIssues::TStatusIds::ERROR, true, ctx);
-            TxProxyMon->MergeResultMiniKQLExecError->Inc();
-            break;
-        }
-
+            ReportStatus(TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecError, NKikimrIssues::TStatusIds::ERROR, true, ctx); 
+            TxProxyMon->MergeResultMiniKQLExecError->Inc(); 
+            break; 
+        } 
+ 
         return Die(ctx);
-    }
+    } 
     default:
         Y_FAIL("unknown engine status# %" PRIu32 " txid# %" PRIu64, (ui32)FlatMKQLRequest->EngineResponseStatus, (ui64)TxId);
     }
@@ -2712,8 +2712,8 @@ ui64 GetFirstTablet(NSchemeCache::TSchemeCacheRequest &cacheRequest) {
 
     NSchemeCache::TSchemeCacheRequest::TEntry& firstEntry= *cacheRequest.ResultSet.begin();
     NKikimr::TKeyDesc& firstKey = *firstEntry.KeyDescription;
-    Y_VERIFY(!firstKey.Partitions.empty());
-    return firstKey.Partitions.begin()->ShardId;
+    Y_VERIFY(!firstKey.Partitions.empty()); 
+    return firstKey.Partitions.begin()->ShardId; 
 }
 
 const TDomainsInfo::TDomain& TDataReq::SelectDomain(NSchemeCache::TSchemeCacheRequest &cacheRequest, const TActorContext &ctx) {
@@ -2791,12 +2791,12 @@ void TDataReq::RegisterPlan(const TActorContext &ctx) {
 
     // Check reply size
     ui64 sizeLimit = RequestControls.PerRequestDataSizeLimit;
-    if (FlatMKQLRequest && FlatMKQLRequest->Limits.GetTotalReadSizeLimitBytes()) {
-        sizeLimit = sizeLimit
-            ? std::min(sizeLimit, FlatMKQLRequest->Limits.GetTotalReadSizeLimitBytes())
-            : FlatMKQLRequest->Limits.GetTotalReadSizeLimitBytes();
-    }
-
+    if (FlatMKQLRequest && FlatMKQLRequest->Limits.GetTotalReadSizeLimitBytes()) { 
+        sizeLimit = sizeLimit 
+            ? std::min(sizeLimit, FlatMKQLRequest->Limits.GetTotalReadSizeLimitBytes()) 
+            : FlatMKQLRequest->Limits.GetTotalReadSizeLimitBytes(); 
+    } 
+ 
     if (totalReadSize > sizeLimit) {
         FailProposedRequest(
                     TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecError,
@@ -2966,16 +2966,16 @@ bool TDataReq::ParseRangeKey(const NKikimrMiniKQL::TParams &proto,
     return true;
 }
 
-bool TDataReq::IsReadOnlyRequest() const {
-    if (FlatMKQLRequest) {
-        return FlatMKQLRequest->ReadOnlyProgram;
-    } else if (ReadTableRequest) {
-        return true;
-    }
-
-    Y_FAIL("No request");
-}
-
+bool TDataReq::IsReadOnlyRequest() const { 
+    if (FlatMKQLRequest) { 
+        return FlatMKQLRequest->ReadOnlyProgram; 
+    } else if (ReadTableRequest) { 
+        return true; 
+    } 
+ 
+    Y_FAIL("No request"); 
+} 
+ 
 IActor* CreateTxProxyDataReq(const TTxProxyServices &services, const ui64 txid, const TIntrusivePtr<NKikimr::NTxProxy::TTxProxyMon>& mon,
                              const TRequestControls& requestControls) {
     return new NTxProxy::TDataReq(services, txid, mon, requestControls);
diff --git a/ydb/core/tx/tx_proxy/mon.cpp b/ydb/core/tx/tx_proxy/mon.cpp
index 14f5d47064..b927497336 100644
--- a/ydb/core/tx/tx_proxy/mon.cpp
+++ b/ydb/core/tx/tx_proxy/mon.cpp
@@ -24,7 +24,7 @@ TTxProxyMon::TTxProxyMon(const TIntrusivePtr<NMonitoring::TDynamicCounters>& cou
     CommitWritesRequest = TxGroup->GetCounter("Propose/CommitWritesRequest", true);
     MakeRequestProxyNotReady = TxGroup->GetCounter("Propose/MakeRequestProxyNotReady", true);
     TxNotImplemented = TxGroup->GetCounter("Propose/TxNotImplemented", true);
-    KqpRequest = TxGroup->GetCounter("Propose/KqpRequest", true);
+    KqpRequest = TxGroup->GetCounter("Propose/KqpRequest", true); 
 
     DataReqInFly = TxGroup->GetCounter("InFly/DataTx", false);
     SchemeReqInFly = TxGroup->GetCounter("InFly/SchemeOp", false);
@@ -79,8 +79,8 @@ TTxProxyMon::TTxProxyMon(const TIntrusivePtr<NMonitoring::TDynamicCounters>& cou
 
     PlanClientTxResultComplete = DataReqGroup->GetCounter("Plan/TxResult/Complete", true);
     PlanClientTxResultAborted = DataReqGroup->GetCounter("Plan/TxResult/Aborted", true);
-    PlanClientTxResultResultUnavailable = DataReqGroup->GetCounter("Plan/TxResult/ResultUnavailable", true);
-    PlanClientTxResultCancelled = DataReqGroup->GetCounter("Plan/TxResult/Cancelled", true);
+    PlanClientTxResultResultUnavailable = DataReqGroup->GetCounter("Plan/TxResult/ResultUnavailable", true); 
+    PlanClientTxResultCancelled = DataReqGroup->GetCounter("Plan/TxResult/Cancelled", true); 
     PlanClientTxResultExecError = DataReqGroup->GetCounter("Plan/TxResult/ExecError", true);
 
     ClientTxStatusAccepted = DataReqGroup->GetCounter("ClientTx/Status/Accepted", true);
@@ -115,9 +115,9 @@ TTxProxyMon::TTxProxyMon(const TIntrusivePtr<NMonitoring::TDynamicCounters>& cou
     TxResultFatal = DataReqGroup->GetCounter("TxResult/Fatal", true);
     TxResultShardOverloaded = DataReqGroup->GetCounter("TxResult/Overloaded", true);
     TxResultShardTryLater = DataReqGroup->GetCounter("TxResult/TryLater", true);
-    TxResultExecError = DataReqGroup->GetCounter("TxResult/ExecError", true);
-    TxResultResultUnavailable = DataReqGroup->GetCounter("TxResult/ResultUnavailable", true);
-    TxResultCancelled = DataReqGroup->GetCounter("TxResult/Cancelled", true);
+    TxResultExecError = DataReqGroup->GetCounter("TxResult/ExecError", true); 
+    TxResultResultUnavailable = DataReqGroup->GetCounter("TxResult/ResultUnavailable", true); 
+    TxResultCancelled = DataReqGroup->GetCounter("TxResult/Cancelled", true); 
 
     MergeResultRequestExecError = DataReqGroup->GetCounter("MergeResult/RequestExecError", true);
     MergeResultRequestExecComplete = DataReqGroup->GetCounter("MergeResult/RequestExecComplete", true);
diff --git a/ydb/core/tx/tx_proxy/mon.h b/ydb/core/tx/tx_proxy/mon.h
index d747ab4f99..cd846bb7cb 100644
--- a/ydb/core/tx/tx_proxy/mon.h
+++ b/ydb/core/tx/tx_proxy/mon.h
@@ -32,7 +32,7 @@ namespace NTxProxy {
         NMonitoring::TDynamicCounters::TCounterPtr SchemeRequestProxyNotReady;
         NMonitoring::TDynamicCounters::TCounterPtr MakeRequestProxyNotReady;
         NMonitoring::TDynamicCounters::TCounterPtr TxNotImplemented;
-        NMonitoring::TDynamicCounters::TCounterPtr KqpRequest;
+        NMonitoring::TDynamicCounters::TCounterPtr KqpRequest; 
 
         NMonitoring::TDynamicCounters::TCounterPtr DataReqInFly;
         NMonitoring::TDynamicCounters::TCounterPtr SchemeReqInFly;
@@ -77,8 +77,8 @@ namespace NTxProxy {
 
         NMonitoring::TDynamicCounters::TCounterPtr PlanClientTxResultComplete;
         NMonitoring::TDynamicCounters::TCounterPtr PlanClientTxResultAborted;
-        NMonitoring::TDynamicCounters::TCounterPtr PlanClientTxResultResultUnavailable;
-        NMonitoring::TDynamicCounters::TCounterPtr PlanClientTxResultCancelled;
+        NMonitoring::TDynamicCounters::TCounterPtr PlanClientTxResultResultUnavailable; 
+        NMonitoring::TDynamicCounters::TCounterPtr PlanClientTxResultCancelled; 
         NMonitoring::TDynamicCounters::TCounterPtr PlanClientTxResultExecError;
 
         NMonitoring::TDynamicCounters::TCounterPtr ClientTxStatusAccepted;
@@ -113,9 +113,9 @@ namespace NTxProxy {
         NMonitoring::TDynamicCounters::TCounterPtr TxResultFatal;
         NMonitoring::TDynamicCounters::TCounterPtr TxResultShardOverloaded;
         NMonitoring::TDynamicCounters::TCounterPtr TxResultShardTryLater;
-        NMonitoring::TDynamicCounters::TCounterPtr TxResultExecError;
-        NMonitoring::TDynamicCounters::TCounterPtr TxResultResultUnavailable;
-        NMonitoring::TDynamicCounters::TCounterPtr TxResultCancelled;
+        NMonitoring::TDynamicCounters::TCounterPtr TxResultExecError; 
+        NMonitoring::TDynamicCounters::TCounterPtr TxResultResultUnavailable; 
+        NMonitoring::TDynamicCounters::TCounterPtr TxResultCancelled; 
 
         NMonitoring::TDynamicCounters::TCounterPtr MergeResultRequestExecError;
         NMonitoring::TDynamicCounters::TCounterPtr MergeResultRequestExecComplete;
diff --git a/ydb/core/tx/tx_proxy/proxy.h b/ydb/core/tx/tx_proxy/proxy.h
index 86d4f1ac79..4fbc5c8d0c 100644
--- a/ydb/core/tx/tx_proxy/proxy.h
+++ b/ydb/core/tx/tx_proxy/proxy.h
@@ -45,8 +45,8 @@ struct TEvTxUserProxy {
         EvCancelBackupRequestDeprecated,
         EvCancelBackupResultDeprecated,
 
-        EvProposeKqpTransaction,
-
+        EvProposeKqpTransaction, 
+ 
         EvAllocateTxId,
         EvAllocateTxIdResult,
 
@@ -171,12 +171,12 @@ struct TEvTxUserProxy {
 
     struct TEvInvalidateTableResult : public TEventSimple<TEvInvalidateTableResult, EvInvalidateTableResult> {};
 
-    struct TEvProposeKqpTransaction : public TEventLocal<TEvProposeKqpTransaction, EvProposeKqpTransaction> {
+    struct TEvProposeKqpTransaction : public TEventLocal<TEvProposeKqpTransaction, EvProposeKqpTransaction> { 
         TActorId ExecuterId;
-
+ 
         TEvProposeKqpTransaction(const TActorId& executerId)
-            : ExecuterId(executerId) {}
-    };
+            : ExecuterId(executerId) {} 
+    }; 
 
     struct TEvAllocateTxId : public TEventLocal<TEvAllocateTxId, EvAllocateTxId> {
         // empty
diff --git a/ydb/core/tx/tx_proxy/proxy_impl.cpp b/ydb/core/tx/tx_proxy/proxy_impl.cpp
index 20dc8cce17..ea91c6aec4 100644
--- a/ydb/core/tx/tx_proxy/proxy_impl.cpp
+++ b/ydb/core/tx/tx_proxy/proxy_impl.cpp
@@ -52,8 +52,8 @@ class TTxProxy : public TActorBootstrapped<TTxProxy> {
     static const TDuration TimeoutDelayedRequest;
     typedef TDelayedQueue<TEvTxUserProxy::TEvProposeTransaction> TDelayedProposal;
     TDelayedProposal DelayedProposal;
-    typedef TDelayedQueue<TEvTxUserProxy::TEvProposeKqpTransaction> TDelayedKqpProposal;
-    TDelayedKqpProposal DelayedKqpProposal;
+    typedef TDelayedQueue<TEvTxUserProxy::TEvProposeKqpTransaction> TDelayedKqpProposal; 
+    TDelayedKqpProposal DelayedKqpProposal; 
     typedef TDelayedQueue<TEvTxUserProxy::TEvAllocateTxId> TDelayedAllocateTxId;
     TDelayedAllocateTxId DelayedAllocateTxId;
 
@@ -133,11 +133,11 @@ class TTxProxy : public TActorBootstrapped<TTxProxy> {
 
     }
 
-    void DelayRequest(TEvTxUserProxy::TEvProposeKqpTransaction::TPtr &ev, const TActorContext &ctx) {
-        auto request = new TDelayedKqpProposal::TRequest(ev, ctx.Now() + TimeoutDelayedRequest);
-        DelayedKqpProposal.Queue->Push(request);
-    }
-
+    void DelayRequest(TEvTxUserProxy::TEvProposeKqpTransaction::TPtr &ev, const TActorContext &ctx) { 
+        auto request = new TDelayedKqpProposal::TRequest(ev, ctx.Now() + TimeoutDelayedRequest); 
+        DelayedKqpProposal.Queue->Push(request); 
+    } 
+ 
     void DelayRequest(TEvTxUserProxy::TEvAllocateTxId::TPtr &ev, const TActorContext &ctx) {
         auto request = new TDelayedAllocateTxId::TRequest(ev, ctx.Now() + TimeoutDelayedRequest);
         DelayedAllocateTxId.Queue->Push(request);
@@ -334,37 +334,37 @@ class TTxProxy : public TActorBootstrapped<TTxProxy> {
         return ProcessRequest(ev, ctx, 0);
     }
 
-    void ProcessRequest(TEvTxUserProxy::TEvProposeKqpTransaction::TPtr& ev, const TActorContext& ctx, ui64 txid) {
-        TxProxyMon->KqpRequest->Inc();
-        LOG_DEBUG_S(ctx, NKikimrServices::TX_PROXY,
-                    "actor# " << SelfId() <<
-                    " TxId# " << txid <<
-                    " ProcessProposeKqpTransaction");
-
-        auto executerEv = MakeHolder<NKqp::TEvKqpExecuter::TEvTxRequest>();
+    void ProcessRequest(TEvTxUserProxy::TEvProposeKqpTransaction::TPtr& ev, const TActorContext& ctx, ui64 txid) { 
+        TxProxyMon->KqpRequest->Inc(); 
+        LOG_DEBUG_S(ctx, NKikimrServices::TX_PROXY, 
+                    "actor# " << SelfId() << 
+                    " TxId# " << txid << 
+                    " ProcessProposeKqpTransaction"); 
+ 
+        auto executerEv = MakeHolder<NKqp::TEvKqpExecuter::TEvTxRequest>(); 
         ActorIdToProto(ev->Sender, executerEv->Record.MutableTarget());
-        executerEv->Record.MutableRequest()->SetTxId(txid);
-        ctx.Send(ev->Get()->ExecuterId, executerEv.Release());
-    }
-
-    void Handle(TEvTxUserProxy::TEvProposeKqpTransaction::TPtr &ev, const TActorContext &ctx) {
-        LOG_DEBUG_S(ctx, NKikimrServices::TX_PROXY,
-                   "actor# " << SelfId() <<
-                   " Handle TEvExecuteKqpTransaction");
-
+        executerEv->Record.MutableRequest()->SetTxId(txid); 
+        ctx.Send(ev->Get()->ExecuterId, executerEv.Release()); 
+    } 
+ 
+    void Handle(TEvTxUserProxy::TEvProposeKqpTransaction::TPtr &ev, const TActorContext &ctx) { 
+        LOG_DEBUG_S(ctx, NKikimrServices::TX_PROXY, 
+                   "actor# " << SelfId() << 
+                   " Handle TEvExecuteKqpTransaction"); 
+ 
         auto txIds = TxAllocatorClient.AllocateTxIds(1, ctx);
         if (!txIds) {
-            LOG_DEBUG_S(ctx, NKikimrServices::TX_PROXY,
-                       "actor# " << SelfId() <<
-                       " Cookie# " << (ui64)ev->Cookie <<
-                       " DELAY REQUEST, wait txids from allocator" <<
-                       " Type# Scheme");
-            return DelayRequest(ev, ctx);
-        }
-
+            LOG_DEBUG_S(ctx, NKikimrServices::TX_PROXY, 
+                       "actor# " << SelfId() << 
+                       " Cookie# " << (ui64)ev->Cookie << 
+                       " DELAY REQUEST, wait txids from allocator" << 
+                       " Type# Scheme"); 
+            return DelayRequest(ev, ctx); 
+        } 
+ 
         ProcessRequest(ev, ctx, txIds.front());
-    }
-
+    } 
+ 
     void ProcessRequest(TEvTxUserProxy::TEvAllocateTxId::TPtr &ev, const TActorContext &ctx, ui64 txId) {
         auto reply = MakeHolder<TEvTxUserProxy::TEvAllocateTxIdResult>(txId, Services, TxProxyMon);
         ctx.Send(ev->Sender, reply.Release(), 0, ev->Cookie);
@@ -469,9 +469,9 @@ public:
             HFunc(TEvTxUserProxy::TEvInvalidateTable, Handle);
             HFunc(TEvTxProxySchemeCache::TEvInvalidateTableResult, Handle);
 
-            HFunc(TEvTxUserProxy::TEvProposeKqpTransaction, Handle);
+            HFunc(TEvTxUserProxy::TEvProposeKqpTransaction, Handle); 
             HFunc(TEvTxUserProxy::TEvAllocateTxId, Handle);
-
+ 
             HFunc(TEvTxUserProxy::TEvGetProxyServicesRequest, Handle);
 
             HFunc(TEvents::TEvPoisonPill, Handle);
diff --git a/ydb/core/viewer/json_query.h b/ydb/core/viewer/json_query.h
index 600d8088e1..c71a873754 100644
--- a/ydb/core/viewer/json_query.h
+++ b/ydb/core/viewer/json_query.h
@@ -117,7 +117,7 @@ public:
             event->Record.SetUserToken(Event->Get()->UserToken);
         }
         ActorIdToProto(SelfId(), event->Record.MutableRequestActorId());
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), event.Release());
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), event.Release()); 
 
         Become(&TThis::StateWork, ctx, TDuration::MilliSeconds(Timeout), new TEvents::TEvWakeup());
     }
@@ -205,7 +205,7 @@ private:
     void HandleReply(NKqp::TEvKqp::TEvQueryResponse::TPtr& ev, const TActorContext& ctx) {
         TStringBuilder out;
         NKikimrKqp::TEvQueryResponse& record = ev->Get()->Record.GetRef();
-        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) {
+        if (record.GetYdbStatus() == Ydb::StatusIds::SUCCESS) { 
             const auto& response = record.GetResponse();
             out << Viewer->GetHTTPOKJSON();
             if (!Stats.empty()) {
@@ -270,19 +270,19 @@ private:
             }
         } else {
             out << "HTTP/1.1 400 Bad Request\r\nContent-Type: text/plain\r\nConnection: Close\r\n\r\n";
-
-            TStringBuilder err;
-            for (const auto& queryIssue : record.GetResponse().GetQueryIssues()) {
-                if (!err.empty()) {
-                    err << '\n';
-                }
-                if (queryIssue.has_position()) {
-                    err << queryIssue.position().row() << ':' << queryIssue.position().column() << ' ';
+ 
+            TStringBuilder err; 
+            for (const auto& queryIssue : record.GetResponse().GetQueryIssues()) { 
+                if (!err.empty()) { 
+                    err << '\n'; 
                 }
-                err << queryIssue.message();
+                if (queryIssue.has_position()) { 
+                    err << queryIssue.position().row() << ':' << queryIssue.position().column() << ' '; 
+                } 
+                err << queryIssue.message(); 
             }
-            out << err;
-
+            out << err; 
+ 
             out << "\r\n";
         }
 
diff --git a/ydb/core/ydb_convert/table_description.cpp b/ydb/core/ydb_convert/table_description.cpp
index 0d10bb8450..01303d253b 100644
--- a/ydb/core/ydb_convert/table_description.cpp
+++ b/ydb/core/ydb_convert/table_description.cpp
@@ -690,7 +690,7 @@ void FillReadReplicasSettings(Ydb::Table::DescribeTableResult& out,
         const NKikimrSchemeOp::TTableDescription& in) {
     FillReadReplicasSettingsImpl(out, in);
 }
-
+ 
 void FillReadReplicasSettings(Ydb::Table::CreateTableRequest& out,
         const NKikimrSchemeOp::TTableDescription& in) {
     FillReadReplicasSettingsImpl(out, in);
diff --git a/ydb/core/ydb_convert/ydb_convert.cpp b/ydb/core/ydb_convert/ydb_convert.cpp
index 11c804cff5..8bab701679 100644
--- a/ydb/core/ydb_convert/ydb_convert.cpp
+++ b/ydb/core/ydb_convert/ydb_convert.cpp
@@ -11,7 +11,7 @@
 #include <ydb/library/yql/minikql/dom/yson.h>
 #include <ydb/library/yql/public/udf/udf_types.h>
 #include <ydb/library/yql/utils/utf8.h>
-
+ 
 namespace NKikimr {
 
 template<typename TOut>
@@ -54,7 +54,7 @@ Y_FORCE_INLINE void ConvertYdbStructTypeToMiniKQLType(const Ydb::StructType& pro
     }
 }
 
-void ConvertMiniKQLTypeToYdbType(const NKikimrMiniKQL::TType& input, Ydb::Type& output) {
+void ConvertMiniKQLTypeToYdbType(const NKikimrMiniKQL::TType& input, Ydb::Type& output) { 
     switch (input.GetKind()) {
         case NKikimrMiniKQL::ETypeKind::Void: {
             output.set_void_type(::google::protobuf::NULL_VALUE);
@@ -129,50 +129,50 @@ void ConvertMiniKQLTypeToYdbType(const NKikimrMiniKQL::TType& input, Ydb::Type&
     }
 }
 
-void ConvertYdbTypeToMiniKQLType(const Ydb::Type& input, NKikimrMiniKQL::TType& output) {
-    switch (input.type_case()) {
-        case Ydb::Type::kVoidType:
+void ConvertYdbTypeToMiniKQLType(const Ydb::Type& input, NKikimrMiniKQL::TType& output) { 
+    switch (input.type_case()) { 
+        case Ydb::Type::kVoidType: 
             output.SetKind(NKikimrMiniKQL::ETypeKind::Void);
             break;
         case Ydb::Type::kNullType:
             output.SetKind(NKikimrMiniKQL::ETypeKind::Null);
             break;
-        case Ydb::Type::kTypeId:
+        case Ydb::Type::kTypeId: 
             output.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-            output.MutableData()->SetScheme(input.type_id());
+            output.MutableData()->SetScheme(input.type_id()); 
             break;
         case Ydb::Type::kDecimalType: {
-            // TODO: Decimal parameters
-            output.SetKind(NKikimrMiniKQL::ETypeKind::Data);
+            // TODO: Decimal parameters 
+            output.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
             auto data = output.MutableData();
             data->SetScheme(NYql::NProto::TypeIds::Decimal);
             data->MutableDecimalParams()->SetPrecision(input.decimal_type().precision());
             data->MutableDecimalParams()->SetScale(input.decimal_type().scale());
-            break;
+            break; 
         }
-        case Ydb::Type::kOptionalType:
+        case Ydb::Type::kOptionalType: 
             output.SetKind(NKikimrMiniKQL::ETypeKind::Optional);
             ConvertYdbTypeToMiniKQLType(input.optional_type().item(), *output.MutableOptional()->MutableItem());
             break;
-        case Ydb::Type::kListType:
+        case Ydb::Type::kListType: 
             output.SetKind(NKikimrMiniKQL::ETypeKind::List);
             ConvertYdbTypeToMiniKQLType(input.list_type().item(), *output.MutableList()->MutableItem());
             break;
-        case Ydb::Type::kTupleType: {
+        case Ydb::Type::kTupleType: { 
             output.SetKind(NKikimrMiniKQL::ETypeKind::Tuple);
-            const Ydb::TupleType& protoTupleType = input.tuple_type();
+            const Ydb::TupleType& protoTupleType = input.tuple_type(); 
             ConvertYdbTupleTypeToMiniKQLType(protoTupleType, *output.MutableTuple());
             break;
         }
-        case Ydb::Type::kStructType: {
+        case Ydb::Type::kStructType: { 
             output.SetKind(NKikimrMiniKQL::ETypeKind::Struct);
-            const Ydb::StructType& protoStructType = input.struct_type();
+            const Ydb::StructType& protoStructType = input.struct_type(); 
             ConvertYdbStructTypeToMiniKQLType(protoStructType, *output.MutableStruct());
             break;
         }
-        case Ydb::Type::kDictType: {
+        case Ydb::Type::kDictType: { 
             output.SetKind(NKikimrMiniKQL::ETypeKind::Dict);
-            const Ydb::DictType& protoDictType = input.dict_type();
+            const Ydb::DictType& protoDictType = input.dict_type(); 
             ConvertYdbTypeToMiniKQLType(protoDictType.key(), *output.MutableDict()->MutableKey());
             ConvertYdbTypeToMiniKQLType(protoDictType.payload(), *output.MutableDict()->MutablePayload());
             break;
@@ -206,7 +206,7 @@ void ConvertYdbTypeToMiniKQLType(const Ydb::Type& input, NKikimrMiniKQL::TType&
 
 }
 
-Y_FORCE_INLINE void ConvertData(NUdf::TDataTypeId typeId, const NKikimrMiniKQL::TValue& value, Ydb::Value& res) {
+Y_FORCE_INLINE void ConvertData(NUdf::TDataTypeId typeId, const NKikimrMiniKQL::TValue& value, Ydb::Value& res) { 
     switch (typeId) {
         case NUdf::TDataType<bool>::Id:
             res.set_bool_value(value.GetBool());
@@ -285,168 +285,168 @@ Y_FORCE_INLINE void ConvertData(NUdf::TDataTypeId typeId, const NKikimrMiniKQL::
     }
 }
 
-Y_FORCE_INLINE void CheckTypeId(i32 id, i32 expected, std::string_view typeName) {
-    if (id != expected) {
-        throw yexception() << "Invalid value representation for type: " << typeName;
-    }
-}
-
-Y_FORCE_INLINE void ConvertData(NUdf::TDataTypeId typeId, const Ydb::Value& value, NKikimrMiniKQL::TValue& res) {
+Y_FORCE_INLINE void CheckTypeId(i32 id, i32 expected, std::string_view typeName) { 
+    if (id != expected) { 
+        throw yexception() << "Invalid value representation for type: " << typeName; 
+    } 
+} 
+ 
+Y_FORCE_INLINE void ConvertData(NUdf::TDataTypeId typeId, const Ydb::Value& value, NKikimrMiniKQL::TValue& res) { 
     switch (typeId) {
         case NUdf::TDataType<bool>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kBoolValue, "Bool");
+            CheckTypeId(value.value_case(), Ydb::Value::kBoolValue, "Bool"); 
             res.SetBool(value.bool_value());
             break;
         case NUdf::TDataType<ui8>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Uint8");
+            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Uint8"); 
             res.SetUint32(value.uint32_value());
             break;
         case NUdf::TDataType<i8>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kInt32Value, "Int8");
+            CheckTypeId(value.value_case(), Ydb::Value::kInt32Value, "Int8"); 
             res.SetInt32(value.int32_value());
             break;
         case NUdf::TDataType<ui16>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Uint16");
+            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Uint16"); 
             res.SetUint32(value.uint32_value());
             break;
         case NUdf::TDataType<i16>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kInt32Value, "Int16");
+            CheckTypeId(value.value_case(), Ydb::Value::kInt32Value, "Int16"); 
             res.SetInt32(value.int32_value());
             break;
         case NUdf::TDataType<i32>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kInt32Value, "Int32");
+            CheckTypeId(value.value_case(), Ydb::Value::kInt32Value, "Int32"); 
             res.SetInt32(value.int32_value());
             break;
         case NUdf::TDataType<ui32>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Uint32");
+            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Uint32"); 
             res.SetUint32(value.uint32_value());
             break;
         case NUdf::TDataType<i64>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kInt64Value, "Int64");
+            CheckTypeId(value.value_case(), Ydb::Value::kInt64Value, "Int64"); 
             res.SetInt64(value.int64_value());
             break;
         case NUdf::TDataType<ui64>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kUint64Value, "Uint64");
+            CheckTypeId(value.value_case(), Ydb::Value::kUint64Value, "Uint64"); 
             res.SetUint64(value.uint64_value());
             break;
         case NUdf::TDataType<float>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kFloatValue, "Float");
+            CheckTypeId(value.value_case(), Ydb::Value::kFloatValue, "Float"); 
             res.SetFloat(value.float_value());
             break;
         case NUdf::TDataType<double>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kDoubleValue, "Double");
+            CheckTypeId(value.value_case(), Ydb::Value::kDoubleValue, "Double"); 
             res.SetDouble(value.double_value());
             break;
-        case NUdf::TDataType<NUdf::TTzDate>::Id: {
-            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "TzDate");
-            const auto& stringRef = value.text_value();
-            res.SetText(stringRef.data(), stringRef.size());
-            break;
-        }
-        case NUdf::TDataType<NUdf::TTzDatetime>::Id: {
-            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "TzDatetime");
-            const auto& stringRef = value.text_value();
-            res.SetText(stringRef.data(), stringRef.size());
-            break;
-        }
-        case NUdf::TDataType<NUdf::TTzTimestamp>::Id: {
-            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "TzTimestamp");
-            const auto& stringRef = value.text_value();
-            res.SetText(stringRef.data(), stringRef.size());
-            break;
-        }
-        case NUdf::TDataType<NUdf::TJson>::Id: {
-            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "Json");
-            const auto& stringRef = value.text_value();
-            if (!NYql::NDom::IsValidJson(stringRef)) {
-                throw yexception() << "Invalid Json value";
-            }
-            res.SetText(stringRef.data(), stringRef.size());
-            break;
-        }
+        case NUdf::TDataType<NUdf::TTzDate>::Id: { 
+            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "TzDate"); 
+            const auto& stringRef = value.text_value(); 
+            res.SetText(stringRef.data(), stringRef.size()); 
+            break; 
+        } 
+        case NUdf::TDataType<NUdf::TTzDatetime>::Id: { 
+            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "TzDatetime"); 
+            const auto& stringRef = value.text_value(); 
+            res.SetText(stringRef.data(), stringRef.size()); 
+            break; 
+        } 
+        case NUdf::TDataType<NUdf::TTzTimestamp>::Id: { 
+            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "TzTimestamp"); 
+            const auto& stringRef = value.text_value(); 
+            res.SetText(stringRef.data(), stringRef.size()); 
+            break; 
+        } 
+        case NUdf::TDataType<NUdf::TJson>::Id: { 
+            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "Json"); 
+            const auto& stringRef = value.text_value(); 
+            if (!NYql::NDom::IsValidJson(stringRef)) { 
+                throw yexception() << "Invalid Json value"; 
+            } 
+            res.SetText(stringRef.data(), stringRef.size()); 
+            break; 
+        } 
         case NUdf::TDataType<NUdf::TUtf8>::Id: {
-            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "Utf8");
+            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "Utf8"); 
             const auto& stringRef = value.text_value();
-            if (!NYql::IsUtf8(stringRef)) {
-                throw yexception() << "Invalid Utf8 value";
-            }
+            if (!NYql::IsUtf8(stringRef)) { 
+                throw yexception() << "Invalid Utf8 value"; 
+            } 
             res.SetText(stringRef.data(), stringRef.size());
             break;
-        }
-        case NUdf::TDataType<NUdf::TDate>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Date");
-            if (value.uint32_value() >= NUdf::MAX_DATE) {
-                throw yexception() << "Invalid Date value";
+        } 
+        case NUdf::TDataType<NUdf::TDate>::Id: 
+            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Date"); 
+            if (value.uint32_value() >= NUdf::MAX_DATE) { 
+                throw yexception() << "Invalid Date value"; 
             }
             res.SetUint32(value.uint32_value());
             break;
         case NUdf::TDataType<NUdf::TDatetime>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Datetime");
-            if (value.uint32_value() >= NUdf::MAX_DATETIME) {
-                throw yexception() << "Invalid Datetime value";
-            }
+            CheckTypeId(value.value_case(), Ydb::Value::kUint32Value, "Datetime"); 
+            if (value.uint32_value() >= NUdf::MAX_DATETIME) { 
+                throw yexception() << "Invalid Datetime value"; 
+            } 
             res.SetUint32(value.uint32_value());
             break;
         case NUdf::TDataType<NUdf::TTimestamp>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kUint64Value, "Timestamp");
-            if (value.uint64_value() >= NUdf::MAX_TIMESTAMP) {
-                throw yexception() << "Invalid Timestamp value";
-            }
+            CheckTypeId(value.value_case(), Ydb::Value::kUint64Value, "Timestamp"); 
+            if (value.uint64_value() >= NUdf::MAX_TIMESTAMP) { 
+                throw yexception() << "Invalid Timestamp value"; 
+            } 
             res.SetUint64(value.uint64_value());
             break;
         case NUdf::TDataType<NUdf::TInterval>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kInt64Value, "Interval");
-            if ((ui64)std::abs(value.int64_value()) >= NUdf::MAX_TIMESTAMP) {
-                throw yexception() << "Invalid Interval value";
-            }
+            CheckTypeId(value.value_case(), Ydb::Value::kInt64Value, "Interval"); 
+            if ((ui64)std::abs(value.int64_value()) >= NUdf::MAX_TIMESTAMP) { 
+                throw yexception() << "Invalid Interval value"; 
+            } 
             res.SetInt64(value.int64_value());
             break;
         case NUdf::TDataType<NUdf::TUuid>::Id:
-            CheckTypeId(value.value_case(), Ydb::Value::kLow128, "Uuid");
+            CheckTypeId(value.value_case(), Ydb::Value::kLow128, "Uuid"); 
             res.SetLow128(value.low_128());
             res.SetHi128(value.high_128());
             break;
         case NUdf::TDataType<NUdf::TJsonDocument>::Id: {
-            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "JsonDocument");
+            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "JsonDocument"); 
             const auto binaryJson = NBinaryJson::SerializeToBinaryJson(value.text_value());
-            if (!binaryJson.Defined()) {
-                throw yexception() << "Invalid JsonDocument value";
-            }
+            if (!binaryJson.Defined()) { 
+                throw yexception() << "Invalid JsonDocument value"; 
+            } 
             res.SetBytes(binaryJson->Data(), binaryJson->Size());
             break;
         }
         case NUdf::TDataType<NUdf::TDyNumber>::Id: {
-            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "DyNumber");
+            CheckTypeId(value.value_case(), Ydb::Value::kTextValue, "DyNumber"); 
             const auto dyNumber = NDyNumber::ParseDyNumberString(value.text_value());
-            if (!dyNumber.Defined()) {
-                throw yexception() << "Invalid DyNumber value";
-            }
+            if (!dyNumber.Defined()) { 
+                throw yexception() << "Invalid DyNumber value"; 
+            } 
             res.SetBytes(dyNumber->Data(), dyNumber->Size());
             break;
         }
-        case NUdf::TDataType<char*>::Id: {
-            CheckTypeId(value.value_case(), Ydb::Value::kBytesValue, "String");
+        case NUdf::TDataType<char*>::Id: { 
+            CheckTypeId(value.value_case(), Ydb::Value::kBytesValue, "String"); 
             const auto& stringRef = value.bytes_value();
             res.SetBytes(stringRef.data(), stringRef.size());
-            break;
-        }
-        case NUdf::TDataType<NUdf::TYson>::Id: {
-            CheckTypeId(value.value_case(), Ydb::Value::kBytesValue, "Yson");
-            const auto& stringRef = value.bytes_value();
-            if (!NYql::NDom::IsValidYson(stringRef)) {
-                throw yexception() << "Invalid Yson value";
-            }
-            res.SetBytes(stringRef.data(), stringRef.size());
-            break;
-        }
-        default:
-            throw yexception() << "Unsupported data type: " << typeId;
+            break; 
+        } 
+        case NUdf::TDataType<NUdf::TYson>::Id: { 
+            CheckTypeId(value.value_case(), Ydb::Value::kBytesValue, "Yson"); 
+            const auto& stringRef = value.bytes_value(); 
+            if (!NYql::NDom::IsValidYson(stringRef)) { 
+                throw yexception() << "Invalid Yson value"; 
+            } 
+            res.SetBytes(stringRef.data(), stringRef.size()); 
+            break; 
+        } 
+        default: 
+            throw yexception() << "Unsupported data type: " << typeId; 
     }
 }
 
 void ConvertMiniKQLValueToYdbValue(const NKikimrMiniKQL::TType& inputType,
                                    const NKikimrMiniKQL::TValue& inputValue,
-                                   Ydb::Value& output) {
+                                   Ydb::Value& output) { 
     switch (inputType.GetKind()) {
         case NKikimrMiniKQL::ETypeKind::Void: {
             break;
@@ -479,7 +479,7 @@ void ConvertMiniKQLValueToYdbValue(const NKikimrMiniKQL::TType& inputType,
                 } else {
                     // Next type is not optional and we have no optional value - Optional<Optional<T>>(Null) case.
                     // Write corresponding number of nested Value messages, and NullFlag to the last one
-                    Ydb::Value* resValue = &output;
+                    Ydb::Value* resValue = &output; 
                     while (optionalCounter--) {
                         resValue = resValue->mutable_nested_value();
                     }
@@ -566,29 +566,29 @@ void ConvertMiniKQLValueToYdbValue(const NKikimrMiniKQL::TType& inputType,
     }
 }
 
-void ConvertYdbValueToMiniKQLValue(const Ydb::Type& inputType,
-                                   const Ydb::Value& inputValue,
+void ConvertYdbValueToMiniKQLValue(const Ydb::Type& inputType, 
+                                   const Ydb::Value& inputValue, 
                                    NKikimrMiniKQL::TValue& output) {
 
-    switch (inputType.type_case()) {
-        case Ydb::Type::kVoidType:
+    switch (inputType.type_case()) { 
+        case Ydb::Type::kVoidType: 
             break;
-        case Ydb::Type::kTypeId:
-            ConvertData(inputType.type_id(), inputValue, output);
+        case Ydb::Type::kTypeId: 
+            ConvertData(inputType.type_id(), inputValue, output); 
             break;
-        case Ydb::Type::kDecimalType:
+        case Ydb::Type::kDecimalType: 
             Y_ENSURE(inputValue.value_case() == Ydb::Value::kLow128);
             output.SetLow128(inputValue.low_128());
             output.SetHi128(inputValue.high_128());
-            if (NYql::NDecimal::IsError(NYql::NDecimal::FromProto(output))) {
-                throw yexception() << "Invalid decimal value";
-            }
-            break;
-        case Ydb::Type::kOptionalType: {
-            switch (inputValue.value_case()) {
-                case Ydb::Value::kNullFlagValue:
+            if (NYql::NDecimal::IsError(NYql::NDecimal::FromProto(output))) { 
+                throw yexception() << "Invalid decimal value"; 
+            } 
+            break; 
+        case Ydb::Type::kOptionalType: { 
+            switch (inputValue.value_case()) { 
+                case Ydb::Value::kNullFlagValue: 
                     break;
-                case Ydb::Value::kNestedValue:
+                case Ydb::Value::kNestedValue: 
                     ConvertYdbValueToMiniKQLValue(inputType.optional_type().item(), inputValue.nested_value(), *output.MutableOptional());
                     break;
                 default:
@@ -596,28 +596,28 @@ void ConvertYdbValueToMiniKQLValue(const Ydb::Type& inputType,
             }
             break;
         }
-        case Ydb::Type::kListType: {
-            const Ydb::ListType& protoListType = inputType.list_type();
-            const Ydb::Type& protoItemType = protoListType.item();
+        case Ydb::Type::kListType: { 
+            const Ydb::ListType& protoListType = inputType.list_type(); 
+            const Ydb::Type& protoItemType = protoListType.item(); 
             for (const auto& x : inputValue.items()) {
                 ConvertYdbValueToMiniKQLValue(protoItemType, x, *output.MutableList()->Add());
             }
             break;
         }
-        case Ydb::Type::kStructType: {
-            const Ydb::StructType& protoStructType = inputType.struct_type();
+        case Ydb::Type::kStructType: { 
+            const Ydb::StructType& protoStructType = inputType.struct_type(); 
             ui32 membersCount = static_cast<ui32>(protoStructType.membersSize());
             if (membersCount != inputValue.itemsSize()) {
-                throw yexception() << "Number of struct fields and their types mismatched";
+                throw yexception() << "Number of struct fields and their types mismatched"; 
             }
             for (ui32 memberNum = 0; memberNum < membersCount; ++memberNum) {
-                const Ydb::StructMember& protoMember = protoStructType.members(memberNum);
+                const Ydb::StructMember& protoMember = protoStructType.members(memberNum); 
                 ConvertYdbValueToMiniKQLValue(protoMember.type(), inputValue.items(memberNum), *output.MutableStruct()->Add());
             }
             break;
         }
-        case Ydb::Type::kDictType: {
-            const Ydb::DictType& protoDictType = inputType.dict_type();
+        case Ydb::Type::kDictType: { 
+            const Ydb::DictType& protoDictType = inputType.dict_type(); 
             for (const auto& x : inputValue.pairs()) {
                 auto pair = output.MutableDict()->Add();
                 ConvertYdbValueToMiniKQLValue(protoDictType.key(), x.key(), *pair->MutableKey());
@@ -625,14 +625,14 @@ void ConvertYdbValueToMiniKQLValue(const Ydb::Type& inputType,
             }
             break;
         }
-        case Ydb::Type::kTupleType: {
-            const Ydb::TupleType& protoTupleType = inputType.tuple_type();
+        case Ydb::Type::kTupleType: { 
+            const Ydb::TupleType& protoTupleType = inputType.tuple_type(); 
             ui32 elementsCount = static_cast<ui32>(protoTupleType.elementsSize());
             if (elementsCount != inputValue.itemsSize()) {
-                throw yexception() << "Number of tuple elements and their types mismatched";
+                throw yexception() << "Number of tuple elements and their types mismatched"; 
             }
             for (ui32 elementNum = 0; elementNum < elementsCount; ++elementNum) {
-                const Ydb::Type& elementType = protoTupleType.elements(elementNum);
+                const Ydb::Type& elementType = protoTupleType.elements(elementNum); 
                 ConvertYdbValueToMiniKQLValue(elementType, inputValue.items(elementNum), *output.MutableTuple()->Add());
             }
             break;
@@ -645,7 +645,7 @@ void ConvertYdbValueToMiniKQLValue(const Ydb::Type& inputType,
                 case Ydb::VariantType::kTupleItems: {
                     Y_ENSURE(protoVariantType.tuple_items().elements_size() >= 0);
                     if (variantIndex >= (ui32)protoVariantType.tuple_items().elements_size()) {
-                        throw yexception() << "Variant index out of type range";
+                        throw yexception() << "Variant index out of type range"; 
                     }
                     const Ydb::Type& nextType = protoVariantType.tuple_items().elements(variantIndex);
                     ConvertYdbValueToMiniKQLValue(nextType, inputValue.nested_value(), *output.MutableOptional());
@@ -654,21 +654,21 @@ void ConvertYdbValueToMiniKQLValue(const Ydb::Type& inputType,
                 case Ydb::VariantType::kStructItems: {
                     Y_ENSURE(protoVariantType.struct_items().members_size() >= 0);
                     if (variantIndex >= (ui32)protoVariantType.struct_items().members_size()) {
-                        throw yexception() << "Variant index out of type range";
+                        throw yexception() << "Variant index out of type range"; 
                     }
                     const Ydb::Type& nextType = protoVariantType.struct_items().members(variantIndex).type();
                     ConvertYdbValueToMiniKQLValue(nextType, inputValue.nested_value(), *output.MutableOptional());
                     break;
                 }
                 default:
-                    throw yexception() << "Unknown variant type representation: "
+                    throw yexception() << "Unknown variant type representation: " 
                                         << protoVariantType.DebugString();
             }
             break;
         }
 
         default: {
-            throw yexception() << "Unknown protobuf type: "
+            throw yexception() << "Unknown protobuf type: " 
                                 << inputType.DebugString();
         }
     }
@@ -817,42 +817,42 @@ void ConvertDirectoryEntry(const NKikimrSchemeOp::TPathDescription& from, Ydb::S
     }
 }
 
-void ConvertYdbResultToKqpResult(const Ydb::ResultSet& input, NKikimrMiniKQL::TResult& output) {
-    auto& outputType = *output.MutableType();
-    outputType.SetKind(NKikimrMiniKQL::ETypeKind::Struct);
-    auto& dataMember = *outputType.MutableStruct()->AddMember();
-    dataMember.SetName("Data");
-    auto& truncatedMember = *outputType.MutableStruct()->AddMember();
-    truncatedMember.SetName("Truncated");
-    truncatedMember.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data);
-    truncatedMember.MutableType()->MutableData()->SetScheme(NKikimr::NUdf::TDataType<bool>::Id);
-
-    auto& dataType = *dataMember.MutableType();
-    dataType.SetKind(NKikimrMiniKQL::ETypeKind::List);
-    auto& itemType = *dataType.MutableList()->MutableItem();
-    itemType.SetKind(NKikimrMiniKQL::ETypeKind::Struct);
-    auto& structType = *itemType.MutableStruct();
-
-    auto& outputValue = *output.MutableValue();
-    auto& dataValue = *outputValue.AddStruct();
-    auto& truncatedValue = *outputValue.AddStruct();
-
-    for (auto& column : input.columns()) {
-        auto& columnMember = *structType.AddMember();
-        columnMember.SetName(column.name());
-        ConvertYdbTypeToMiniKQLType(column.type(), *columnMember.MutableType());
-    }
-
-    Ydb::Type ydbRowType;
-    ConvertMiniKQLTypeToYdbType(itemType, ydbRowType);
-
-    for (auto& row : input.rows()) {
-        ConvertYdbValueToMiniKQLValue(ydbRowType, row, *dataValue.AddList());
-    }
-
-    truncatedValue.SetBool(input.truncated());
-}
-
+void ConvertYdbResultToKqpResult(const Ydb::ResultSet& input, NKikimrMiniKQL::TResult& output) { 
+    auto& outputType = *output.MutableType(); 
+    outputType.SetKind(NKikimrMiniKQL::ETypeKind::Struct); 
+    auto& dataMember = *outputType.MutableStruct()->AddMember(); 
+    dataMember.SetName("Data"); 
+    auto& truncatedMember = *outputType.MutableStruct()->AddMember(); 
+    truncatedMember.SetName("Truncated"); 
+    truncatedMember.MutableType()->SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+    truncatedMember.MutableType()->MutableData()->SetScheme(NKikimr::NUdf::TDataType<bool>::Id); 
+ 
+    auto& dataType = *dataMember.MutableType(); 
+    dataType.SetKind(NKikimrMiniKQL::ETypeKind::List); 
+    auto& itemType = *dataType.MutableList()->MutableItem(); 
+    itemType.SetKind(NKikimrMiniKQL::ETypeKind::Struct); 
+    auto& structType = *itemType.MutableStruct(); 
+ 
+    auto& outputValue = *output.MutableValue(); 
+    auto& dataValue = *outputValue.AddStruct(); 
+    auto& truncatedValue = *outputValue.AddStruct(); 
+ 
+    for (auto& column : input.columns()) { 
+        auto& columnMember = *structType.AddMember(); 
+        columnMember.SetName(column.name()); 
+        ConvertYdbTypeToMiniKQLType(column.type(), *columnMember.MutableType()); 
+    } 
+ 
+    Ydb::Type ydbRowType; 
+    ConvertMiniKQLTypeToYdbType(itemType, ydbRowType); 
+ 
+    for (auto& row : input.rows()) { 
+        ConvertYdbValueToMiniKQLValue(ydbRowType, row, *dataValue.AddList()); 
+    } 
+ 
+    truncatedValue.SetBool(input.truncated()); 
+} 
+ 
 TACLAttrs::TACLAttrs(ui32 access, ui32 inheritance)
     : AccessMask(access)
     , InheritanceType(inheritance)
diff --git a/ydb/core/ydb_convert/ydb_convert.h b/ydb/core/ydb_convert/ydb_convert.h
index 2cf74135af..5e3f09b0c5 100644
--- a/ydb/core/ydb_convert/ydb_convert.h
+++ b/ydb/core/ydb_convert/ydb_convert.h
@@ -8,17 +8,17 @@
 
 namespace NKikimr {
 
-void ConvertMiniKQLTypeToYdbType(const NKikimrMiniKQL::TType& input, Ydb::Type& output);
+void ConvertMiniKQLTypeToYdbType(const NKikimrMiniKQL::TType& input, Ydb::Type& output); 
 void ConvertMiniKQLValueToYdbValue(const NKikimrMiniKQL::TType& inputType,
     const NKikimrMiniKQL::TValue& inputValue,
     Ydb::Value& output);
-void ConvertYdbTypeToMiniKQLType(const Ydb::Type& input, NKikimrMiniKQL::TType& output);
-void ConvertYdbValueToMiniKQLValue(const Ydb::Type& inputType,
+void ConvertYdbTypeToMiniKQLType(const Ydb::Type& input, NKikimrMiniKQL::TType& output); 
+void ConvertYdbValueToMiniKQLValue(const Ydb::Type& inputType, 
     const Ydb::Value& inputValue,
     NKikimrMiniKQL::TValue& output);
 
-void ConvertYdbResultToKqpResult(const Ydb::ResultSet& input, NKikimrMiniKQL::TResult& output);
-
+void ConvertYdbResultToKqpResult(const Ydb::ResultSet& input, NKikimrMiniKQL::TResult& output); 
+ 
 void ConvertYdbParamsToMiniKQLParams(const ::google::protobuf::Map<TString, Ydb::TypedValue>& input,
     NKikimrMiniKQL::TParams& output);
 
diff --git a/ydb/core/ydb_convert/ydb_convert_ut.cpp b/ydb/core/ydb_convert/ydb_convert_ut.cpp
index cb80206926..4c0a4a4faf 100644
--- a/ydb/core/ydb_convert/ydb_convert_ut.cpp
+++ b/ydb/core/ydb_convert/ydb_convert_ut.cpp
@@ -10,7 +10,7 @@ namespace NKikimr {
 static void TestConvertTypeToYdb(const TString& input, const TString& expected) {
     NKikimrMiniKQL::TType typeFrom;
     google::protobuf::TextFormat::ParseFromString(input, &typeFrom);
-    Ydb::Type typeTo;
+    Ydb::Type typeTo; 
     ConvertMiniKQLTypeToYdbType(typeFrom, typeTo);
     TString result;
     google::protobuf::TextFormat::PrintToString(typeTo, &result);
@@ -18,7 +18,7 @@ static void TestConvertTypeToYdb(const TString& input, const TString& expected)
 }
 
 static void TestConvertTypeFromYdb(const TString& input, const TString& expected) {
-    Ydb::Type typeFrom;
+    Ydb::Type typeFrom; 
     google::protobuf::TextFormat::ParseFromString(input, &typeFrom);
     NKikimrMiniKQL::TType typeTo;
     ConvertYdbTypeToMiniKQLType(typeFrom, typeTo);
@@ -32,7 +32,7 @@ static void TestConvertValueToYdb(const TString& inputType, const TString& input
     google::protobuf::TextFormat::ParseFromString(input, &valueFrom);
     NKikimrMiniKQL::TType typeFrom;
     google::protobuf::TextFormat::ParseFromString(inputType, &typeFrom);
-    Ydb::Value valueTo;
+    Ydb::Value valueTo; 
     ConvertMiniKQLValueToYdbValue(typeFrom, valueFrom, valueTo);
     TString result;
     google::protobuf::TextFormat::PrintToString(valueTo, &result);
@@ -40,9 +40,9 @@ static void TestConvertValueToYdb(const TString& inputType, const TString& input
 }
 
 static void TestConvertValueFromYdb(const TString& inputType, const TString& input, const TString& expected) {
-    Ydb::Value valueFrom;
+    Ydb::Value valueFrom; 
     google::protobuf::TextFormat::ParseFromString(input, &valueFrom);
-    Ydb::Type typeFrom;
+    Ydb::Type typeFrom; 
     google::protobuf::TextFormat::ParseFromString(inputType, &typeFrom);
     NKikimrMiniKQL::TValue valueTo;
     ConvertYdbValueToMiniKQLValue(typeFrom, valueFrom, valueTo);
diff --git a/ydb/core/yql_testlib/ya.make b/ydb/core/yql_testlib/ya.make
index a68cca63d3..b7dbbcf292 100644
--- a/ydb/core/yql_testlib/ya.make
+++ b/ydb/core/yql_testlib/ya.make
@@ -1,6 +1,6 @@
 LIBRARY()
 
-OWNER(spuchin)
+OWNER(spuchin) 
 
 SRCS(
     yql_testlib.cpp
diff --git a/ydb/core/yql_testlib/yql_testlib.cpp b/ydb/core/yql_testlib/yql_testlib.cpp
index 35838c40f6..0b19f50c6b 100644
--- a/ydb/core/yql_testlib/yql_testlib.cpp
+++ b/ydb/core/yql_testlib/yql_testlib.cpp
@@ -153,7 +153,7 @@ namespace Tests {
 
 void TYqlServer::Initialize() {
     ResumeYqlExecutionPromise = NThreading::NewPromise<void>();
-
+ 
     Runtime.Reset(new TTestActorRuntime(StaticNodes() + DynamicNodes(), true));
 
     Runtime->SetupMonitoring();
diff --git a/ydb/library/backup/backup.cpp b/ydb/library/backup/backup.cpp
index 676cc831ee..e717b040f3 100644
--- a/ydb/library/backup/backup.cpp
+++ b/ydb/library/backup/backup.cpp
@@ -266,7 +266,7 @@ TMaybe<TValue> TryReadTable(TDriver driver, const NTable::TTableDescription& des
         }
         VerifyStatus(resultSetStreamPart, TStringBuilder() << "TStreamPart<TResultSet> is not successfull"
                     " error msg: " << resultSetStreamPart.GetIssues().ToString());
-        TResultSet resultSetCurrent = resultSetStreamPart.ExtractPart();
+        TResultSet resultSetCurrent = resultSetStreamPart.ExtractPart(); 
 
         TFsPath tmpFileName = folderPath.Child(INCOMPLETE_DATA_FILE_NAME);
         TFile tmpFile = TFile(tmpFileName, CreateAlways | WrOnly);
@@ -276,7 +276,7 @@ TMaybe<TValue> TryReadTable(TDriver driver, const NTable::TTableDescription& des
         TMaybe<TValue> lastReadPK;
 
         while (true) {
-            NTable::TAsyncSimpleStreamPart<TResultSet> nextResult;
+            NTable::TAsyncSimpleStreamPart<TResultSet> nextResult; 
             if (resultSetCurrent.Truncated()) {
                 nextResult = iter->ReadNext();
             }
diff --git a/ydb/library/backup/ut/ut.cpp b/ydb/library/backup/ut/ut.cpp
index 5967e9dfa3..6bd98f5d0f 100644
--- a/ydb/library/backup/ut/ut.cpp
+++ b/ydb/library/backup/ut/ut.cpp
@@ -16,10 +16,10 @@ namespace NYdb {
 Y_UNIT_TEST_SUITE(BackupToolValuePrintParse) {
 
 void TestResultSetParsedOk(const TString& protoStr, const TString& expect) {
-    Ydb::ResultSet proto;
+    Ydb::ResultSet proto; 
     google::protobuf::TextFormat::ParseFromString(protoStr, &proto);
 
-    TResultSet result(proto);
+    TResultSet result(proto); 
 
     TStringStream got;
     got.Reserve(1 << 10);
@@ -170,7 +170,7 @@ Y_UNIT_TEST(ParseValuesFromFile) {
 
 Y_UNIT_TEST(ResultSetBoolPrintTest) {
     TString resultSetStr = R"_(
-        columns:{
+        columns:{ 
             name: "Col1"
             type: { type_id: BOOL }
         }
@@ -187,11 +187,11 @@ Y_UNIT_TEST(ResultSetBoolPrintTest) {
 
 Y_UNIT_TEST(ResultSetInt8PrintTest) {
     TString resultSetStr = R"_(
-        columns:{
+        columns:{ 
             name: "Col1"
             type: { type_id: INT8 }
         }
-        columns:{
+        columns:{ 
             name: "Col2"
             type: { type_id: UINT8 }
         }
@@ -214,11 +214,11 @@ Y_UNIT_TEST(ResultSetInt8PrintTest) {
 
 Y_UNIT_TEST(ResultSetInt16PrintTest) {
     TString resultSetStr = R"_(
-        columns:{
+        columns:{ 
             name: "Col1"
             type: { type_id: INT16 }
         }
-        columns:{
+        columns:{ 
             name: "Col2"
             type: { type_id: UINT16 }
         }
@@ -243,11 +243,11 @@ Y_UNIT_TEST(ResultSetInt16PrintTest) {
 
 Y_UNIT_TEST(ResultSetInt32PrintTest) {
     TString resultSetStr = R"_(
-        columns:{
+        columns:{ 
             name: "Col6"
             type: { type_id: INT32 }
         }
-        columns:{
+        columns:{ 
             name: "Col7"
             type: { type_id: UINT32 }
         }
@@ -270,11 +270,11 @@ Y_UNIT_TEST(ResultSetInt32PrintTest) {
 
 Y_UNIT_TEST(ResultSetInt64PrintTest) {
     TString resultSetStr = R"_(
-        columns:{
+        columns:{ 
             name: "Col8"
             type: { type_id: INT64 }
         }
-        columns:{
+        columns:{ 
             name: "Col9"
             type: { type_id: UINT64 }
         }
@@ -297,11 +297,11 @@ Y_UNIT_TEST(ResultSetInt64PrintTest) {
 
 Y_UNIT_TEST(ResultSetFloatPrintTest) {
     TString resultSetStr = R"_(
-        columns:{
+        columns:{ 
             name: "Col1"
             type: { type_id: FLOAT }
         }
-        columns:{
+        columns:{ 
             name: "Col2"
             type: { type_id: DOUBLE }
         }
@@ -335,7 +335,7 @@ Y_UNIT_TEST(ResultSetFloatPrintTest) {
 
 Y_UNIT_TEST(ResultSetIntarvalsPrintTest) {
     TString resultSetStr = R"_(
-        columns:{
+        columns:{ 
             name: "Col1"
             type: { type_id: DATE }
         }
@@ -372,11 +372,11 @@ Y_UNIT_TEST(ResultSetStringPrintTest) {
             name: "Col1"
             type: { type_id: STRING }
         }
-        columns:{
+        columns:{ 
             name: "Col2"
             type: { type_id: STRING }
         }
-        columns:{
+        columns:{ 
             name: "Col3"
             type: { type_id: STRING }
         }
@@ -405,11 +405,11 @@ Y_UNIT_TEST(ResultSetStringPrintTest) {
 
 Y_UNIT_TEST(ResultSetUtf8PrintTest) {
     TString resultSetStr = R"_(
-        columns:{
+        columns:{ 
             name: "Col1"
             type: { type_id: UTF8 }
         }
-        columns:{
+        columns:{ 
             name: "Col12"
             type: { type_id: UTF8 }
         }
@@ -433,11 +433,11 @@ Y_UNIT_TEST(ResultSetUtf8PrintTest) {
 
 Y_UNIT_TEST(ResultSetVoidPrintTest) {
     TString resultSetStr = R"_(
-        columns:{
+        columns:{ 
             name: "Col1"
             type:{ optional_type:{ item:{ type_id: INT32 } } }
         }
-        columns:{
+        columns:{ 
             name: "Col12"
             type:{ optional_type:{ item:{ type_id: STRING } } }
         }
diff --git a/ydb/library/yql/ast/yql_ast.cpp b/ydb/library/yql/ast/yql_ast.cpp
index 16e521d901..06ce8449ce 100644
--- a/ydb/library/yql/ast/yql_ast.cpp
+++ b/ydb/library/yql/ast/yql_ast.cpp
@@ -147,7 +147,7 @@ namespace {
 
     private:
         inline void AddError(const TString& message) {
-            Issues_.AddIssue(Ctx_.Position(), message);
+            Issues_.AddIssue(Ctx_.Position(), message); 
         }
 
         inline void SkipComment() {
@@ -569,19 +569,19 @@ namespace {
                     Indent(out, indent * 2);
                 }
 
-                if (localIndent == 0 && blockLevel > 0) {
-                    Indent(out, (blockLevel - 1) * 2);
-                }
-
+                if (localIndent == 0 && blockLevel > 0) { 
+                    Indent(out, (blockLevel - 1) * 2); 
+                } 
+ 
                 out << ')';
             }
         }
 
         if (!isQuote || !(flags & TAstPrintFlags::ShortQuote)) {
-            if (localIndent > 0 || blockLevel == 0) {
-                if (localIndent <= 1 || !(flags & TAstPrintFlags::PerLine)) {
-                    out << Endl;
-                }
+            if (localIndent > 0 || blockLevel == 0) { 
+                if (localIndent <= 1 || !(flags & TAstPrintFlags::PerLine)) { 
+                    out << Endl; 
+                } 
             }
         }
     }
diff --git a/ydb/library/yql/ast/yql_ast.h b/ydb/library/yql/ast/yql_ast.h
index 887b53dbc5..f4679c3501 100644
--- a/ydb/library/yql/ast/yql_ast.h
+++ b/ydb/library/yql/ast/yql_ast.h
@@ -14,7 +14,7 @@
 namespace NYql {
 
 struct TNodeFlags {
-    enum : ui16 {
+    enum : ui16 { 
         Default = 0,
         ArbitraryContent = 0x01,
         BinaryContent = 0x02,
diff --git a/ydb/library/yql/ast/yql_ast_escaping.cpp b/ydb/library/yql/ast/yql_ast_escaping.cpp
index 56aee8f596..40bd1eda38 100644
--- a/ydb/library/yql/ast/yql_ast_escaping.cpp
+++ b/ydb/library/yql/ast/yql_ast_escaping.cpp
@@ -107,10 +107,10 @@ static bool TryParseHex(const char*& p, const char* e, int maxlen, wchar32* valu
     return (maxlen == -1);
 }
 
-static bool IsValidUtf8Rune(wchar32 value) {
-    return value <= 0x10ffff && (value < 0xd800 || value > 0xdfff);
-}
-
+static bool IsValidUtf8Rune(wchar32 value) { 
+    return value <= 0x10ffff && (value < 0xd800 || value > 0xdfff); 
+} 
+ 
 TStringBuf UnescapeResultToString(EUnescapeResult result)
 {
     switch (result) {
@@ -139,11 +139,11 @@ void EscapeArbitraryAtom(TStringBuf atom, char quoteChar, IOutputStream* out)
               *e = reinterpret_cast<const ui8*>(atom.end());
     while (p != e) {
         wchar32 rune = 0;
-        size_t rune_len = 0;
-
-        if (SafeReadUTF8Char(rune, rune_len, p, e) == RECODE_RESULT::RECODE_OK && IsValidUtf8Rune(rune)) {
+        size_t rune_len = 0; 
+ 
+        if (SafeReadUTF8Char(rune, rune_len, p, e) == RECODE_RESULT::RECODE_OK && IsValidUtf8Rune(rune)) { 
             EscapedPrintUnicode(rune, out);
-            p += rune_len;
+            p += rune_len; 
         } else {
             EscapedPrintChar(*p++, out);
         }
@@ -198,7 +198,7 @@ EUnescapeResult UnescapeArbitraryAtom(
                 case 'U': {
                     wchar32 value = 0;
                     int len = (next == 'u' ? 4 : 8);
-                    if (!TryParseHex(p, e, len, &value) || !IsValidUtf8Rune(value)) {
+                    if (!TryParseHex(p, e, len, &value) || !IsValidUtf8Rune(value)) { 
                         *readBytes = p - atom.begin();
                         return EUnescapeResult::INVALID_UNICODE;
                     }
diff --git a/ydb/library/yql/ast/yql_expr.cpp b/ydb/library/yql/ast/yql_expr.cpp
index 82f6c5812a..9ae52fdd93 100644
--- a/ydb/library/yql/ast/yql_expr.cpp
+++ b/ydb/library/yql/ast/yql_expr.cpp
@@ -34,7 +34,7 @@ namespace {
 
     template <typename T, typename... Args>
     const T* AddType(TExprContext& ctx, Args&&... args) {
-        Y_VERIFY_DEBUG(!ctx.Frozen);
+        Y_VERIFY_DEBUG(!ctx.Frozen); 
         ctx.TypeNodes.emplace(new T(std::forward<Args>(args)...));
         const auto ins = ctx.TypeSet.emplace(ctx.TypeNodes.top().get());
         return static_cast<const T*>(*ins.first);
@@ -949,14 +949,14 @@ namespace {
         }
 
         if (ctx.ModuleResolver) {
-            auto exportsPtr = ctx.ModuleResolver->GetModule(import);
-            if (!exportsPtr) {
+            auto exportsPtr = ctx.ModuleResolver->GetModule(import); 
+            if (!exportsPtr) { 
                 ctx.AddError(*name, baseMsg << "'" << import << "' does not exist");
                 return nullptr;
             }
 
             const auto& exports = exportsPtr->Symbols();
-
+ 
             const auto ex = exports.find(aliasValue);
             if (exports.cend() == ex) {
                 ctx.AddError(*alias, baseMsg << " export '" << aliasValue << "' does not exist");
@@ -1040,48 +1040,48 @@ namespace {
         return true;
     }
 
-    bool CompileDeclare(const TAstNode& node, TContext& ctx) {
-        if (node.GetChildrenCount() != 3) {
-            ctx.AddError(node, "Expected list of size 3");
-            return false;
-        }
-
-        const auto name = node.GetChild(1);
-        if (!name->IsAtom()) {
-            ctx.AddError(*name, "Expected atom");
-            return false;
-        }
-
-        TString nameStr = TString(name->GetContent());
+    bool CompileDeclare(const TAstNode& node, TContext& ctx) { 
+        if (node.GetChildrenCount() != 3) { 
+            ctx.AddError(node, "Expected list of size 3"); 
+            return false; 
+        } 
+ 
+        const auto name = node.GetChild(1); 
+        if (!name->IsAtom()) { 
+            ctx.AddError(*name, "Expected atom"); 
+            return false; 
+        } 
+ 
+        TString nameStr = TString(name->GetContent()); 
         if (nameStr.size() < 2) {
-            ctx.AddError(*name, "Parameter name should be at least 2 characters long.");
-            return false;
-        }
-
-        if (nameStr[0] == '$' && std::isdigit(nameStr[1])) {
-            ctx.AddError(*name, "Parameter name cannot start with digit.");
-            return false;
-        }
-
+            ctx.AddError(*name, "Parameter name should be at least 2 characters long."); 
+            return false; 
+        } 
+ 
+        if (nameStr[0] == '$' && std::isdigit(nameStr[1])) { 
+            ctx.AddError(*name, "Parameter name cannot start with digit."); 
+            return false; 
+        } 
+ 
         auto typeExpr = Compile(*node.GetChild(2), ctx);
         if (typeExpr.size() != 1U)
-            return false;
-
-        auto parameterExpr = ctx.ProcessNode(node,
-            ctx.Expr.NewCallable(node.GetPosition(), "Parameter", {
-                ctx.Expr.NewAtom(node.GetPosition(), nameStr),
+            return false; 
+ 
+        auto parameterExpr = ctx.ProcessNode(node, 
+            ctx.Expr.NewCallable(node.GetPosition(), "Parameter", { 
+                ctx.Expr.NewAtom(node.GetPosition(), nameStr), 
                 std::move(typeExpr.front())
-            }));
-
+            })); 
+ 
         if (!ctx.Frames.back().Bindings.emplace(nameStr, TExprNode::TListType{std::move(parameterExpr)}).second) {
-            ctx.AddError(node, TStringBuilder() << "Declare statement hides previously defined name: "
-                << nameStr);
-            return false;
-        }
-
-        return true;
-    }
-
+            ctx.AddError(node, TStringBuilder() << "Declare statement hides previously defined name: " 
+                << nameStr); 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
     bool CompileLibraryDef(const TAstNode& node, TContext& ctx) {
         if (node.GetChildrenCount() != 2 && node.GetChildrenCount() != 3) {
             ctx.AddError(node, "Expected list of size 2 or 3");
@@ -1225,12 +1225,12 @@ namespace {
                 if (!CompileImport(*node, ctx))
                     return {};
             } else if (firstChild->GetContent() == TStringBuf("declare")) {
-                if (!topLevel) {
-                    ctx.AddError(*firstChild, "Declare statements are only allowed on top level block");
+                if (!topLevel) { 
+                    ctx.AddError(*firstChild, "Declare statements are only allowed on top level block"); 
                     return {};
-                }
-
-                if (!CompileDeclare(*node, ctx))
+                } 
+ 
+                if (!CompileDeclare(*node, ctx)) 
                     return {};
             } else if (firstChild->GetContent() == TStringBuf("library")) {
                 if (!topLevel) {
@@ -1404,7 +1404,7 @@ namespace {
         std::vector<TFrameContext> Frames;
         TFrameContext* CurrentFrame = nullptr;
         TNodeMap<size_t> LambdaFrames;
-        std::map<TStringBuf, std::pair<const TExprNode*, TAstNode*>> Parameters;
+        std::map<TStringBuf, std::pair<const TExprNode*, TAstNode*>> Parameters; 
 
         struct TCounters {
             size_t References = 0ULL, Neighbors = 0ULL, Order = 0ULL, Frame = 0ULL;
@@ -1513,10 +1513,10 @@ namespace {
 
     TAstNode* ConvertFunction(TPositionHandle position, const TRoots& roots, TVisitNodeContext& ctx, ui32 annotationFlags, TMemoryPool& pool);
 
-    TAstNode* BuildValueNode(const TExprNode& node, TVisitNodeContext& ctx, const TString& topLevelName, ui32 annotationFlags, TMemoryPool& pool, bool useBindings) {
+    TAstNode* BuildValueNode(const TExprNode& node, TVisitNodeContext& ctx, const TString& topLevelName, ui32 annotationFlags, TMemoryPool& pool, bool useBindings) { 
         TAstNode* res = nullptr;
         const auto& name = ctx.FindBinding(&node);
-        if (!name.empty() && name != topLevelName && useBindings) {
+        if (!name.empty() && name != topLevelName && useBindings) { 
             res = TAstNode::NewAtom(ctx.Expr.GetPosition(node.Pos()), name, pool);
         } else {
             switch (node.Type()) {
@@ -1537,7 +1537,7 @@ namespace {
                 {
                     TSmallVec<TAstNode*> values;
                     for (const auto& child : node.Children()) {
-                        values.push_back(BuildValueNode(*child, ctx, topLevelName, annotationFlags, pool, useBindings));
+                        values.push_back(BuildValueNode(*child, ctx, topLevelName, annotationFlags, pool, useBindings)); 
                     }
 
                     auto quote = AnnotateAstNode(&TAstNode::QuoteAtom, nullptr, annotationFlags, pool, ctx.RefAtoms);
@@ -1550,35 +1550,35 @@ namespace {
 
             case TExprNode::Callable:
                 {
-                    if (node.Content() == "Parameter") {
-                        const auto& nameNode = *node.Child(0);
-                        const auto& typeNode = *node.Child(1);
-                        Y_UNUSED(typeNode);
-
+                    if (node.Content() == "Parameter") { 
+                        const auto& nameNode = *node.Child(0); 
+                        const auto& typeNode = *node.Child(1); 
+                        Y_UNUSED(typeNode); 
+ 
                         res = TAstNode::NewAtom(ctx.Expr.GetPosition(node.Pos()), nameNode.Content(), pool);
-
-                        auto it = ctx.Parameters.find(nameNode.Content());
-                        if (it != ctx.Parameters.end()) {
-                            break;
-                        }
-
+ 
+                        auto it = ctx.Parameters.find(nameNode.Content()); 
+                        if (it != ctx.Parameters.end()) { 
+                            break; 
+                        } 
+ 
                         auto declareAtom = TAstNode::NewLiteralAtom(ctx.Expr.GetPosition(node.Pos()), TStringBuf("declare"), pool);
-                        auto nameAtom = ctx.RefAtoms
+                        auto nameAtom = ctx.RefAtoms 
                             ? TAstNode::NewLiteralAtom(ctx.Expr.GetPosition(nameNode.Pos()), nameNode.Content(), pool)
                             : TAstNode::NewAtom(ctx.Expr.GetPosition(nameNode.Pos()), nameNode.Content(), pool);
-
-                        TSmallVec<TAstNode*> children;
-                        children.push_back(AnnotateAstNode(declareAtom, nullptr, annotationFlags, pool, ctx.RefAtoms));
-                        children.push_back(AnnotateAstNode(nameAtom, nullptr, annotationFlags, pool, ctx.RefAtoms));
-                        children.push_back(BuildValueNode(typeNode, ctx, topLevelName, annotationFlags, pool, false));
+ 
+                        TSmallVec<TAstNode*> children; 
+                        children.push_back(AnnotateAstNode(declareAtom, nullptr, annotationFlags, pool, ctx.RefAtoms)); 
+                        children.push_back(AnnotateAstNode(nameAtom, nullptr, annotationFlags, pool, ctx.RefAtoms)); 
+                        children.push_back(BuildValueNode(typeNode, ctx, topLevelName, annotationFlags, pool, false)); 
                         auto declareNode = TAstNode::NewList(ctx.Expr.GetPosition(node.Pos()), children.data(), children.size(), pool);
-                        declareNode = AnnotateAstNode(declareNode, &node, annotationFlags, pool, ctx.RefAtoms);
-
-                        ctx.Parameters.insert(std::make_pair(nameNode.Content(),
-                            std::make_pair(&typeNode, declareNode)));
-                        break;
-                    }
-
+                        declareNode = AnnotateAstNode(declareNode, &node, annotationFlags, pool, ctx.RefAtoms); 
+ 
+                        ctx.Parameters.insert(std::make_pair(nameNode.Content(), 
+                            std::make_pair(&typeNode, declareNode))); 
+                        break; 
+                    } 
+ 
                     TSmallVec<TAstNode*> children;
                     children.push_back(AnnotateAstNode(
                         ctx.RefAtoms ?
@@ -1586,7 +1586,7 @@ namespace {
                             TAstNode::NewAtom(ctx.Expr.GetPosition(node.Pos()), node.Content(), pool),
                             nullptr, annotationFlags, pool, ctx.RefAtoms));
                     for (const auto& child : node.Children()) {
-                        children.push_back(BuildValueNode(*child, ctx, topLevelName, annotationFlags, pool, useBindings));
+                        children.push_back(BuildValueNode(*child, ctx, topLevelName, annotationFlags, pool, useBindings)); 
                     }
 
                     res = TAstNode::NewList(ctx.Expr.GetPosition(node.Pos()), children.data(), children.size(), pool);
@@ -1672,7 +1672,7 @@ namespace {
 
             const auto letAtom = TAstNode::NewLiteralAtom(ctx.Expr.GetPosition(node->Pos()), TStringBuf("let"), pool);
             const auto nameAtom = TAstNode::NewAtom(ctx.Expr.GetPosition(node->Pos()), name, pool);
-            const auto valueNode = BuildValueNode(*node, ctx, name, annotationFlags, pool, true);
+            const auto valueNode = BuildValueNode(*node, ctx, name, annotationFlags, pool, true); 
 
             const auto letNode = TAstNode::NewList(ctx.Expr.GetPosition(node->Pos()), pool,
                 AnnotateAstNode(letAtom, nullptr, annotationFlags, pool, ctx.RefAtoms),
@@ -1690,29 +1690,29 @@ namespace {
         }
         const auto returnList = TAstNode::NewList(ctx.Expr.GetPosition(position), returnChildren.data(), returnChildren.size(), pool);
         children.emplace_back(AnnotateAstNode(returnList, 1U == roots.size() ? roots.front() : nullptr, annotationFlags, pool, ctx.RefAtoms));
-
-        if (!ctx.CurrentFrame->Index && !ctx.Parameters.empty()) {
-            TSmallVec<TAstNode*> parameterNodes;
-            parameterNodes.reserve(ctx.Parameters.size());
-
-            for (auto& pair : ctx.Parameters) {
-                parameterNodes.push_back(pair.second.second);
-            }
-
-            children.insert(children.begin(), parameterNodes.begin(), parameterNodes.end());
-        }
-
+ 
+        if (!ctx.CurrentFrame->Index && !ctx.Parameters.empty()) { 
+            TSmallVec<TAstNode*> parameterNodes; 
+            parameterNodes.reserve(ctx.Parameters.size()); 
+ 
+            for (auto& pair : ctx.Parameters) { 
+                parameterNodes.push_back(pair.second.second); 
+            } 
+ 
+            children.insert(children.begin(), parameterNodes.begin(), parameterNodes.end()); 
+        } 
+ 
         const auto res = TAstNode::NewList(ctx.Expr.GetPosition(position), children.data(), children.size(), pool);
         return AnnotateAstNode(res, nullptr, annotationFlags, pool, ctx.RefAtoms);
     }
 
-    bool InlineNode(const TExprNode& node, size_t references, size_t neighbors, const TConvertToAstSettings& settings) {
-        if (settings.NoInlineFunc) {
-            if (settings.NoInlineFunc(node)) {
-                return false;
-            }
-        }
-
+    bool InlineNode(const TExprNode& node, size_t references, size_t neighbors, const TConvertToAstSettings& settings) { 
+        if (settings.NoInlineFunc) { 
+            if (settings.NoInlineFunc(node)) { 
+                return false; 
+            } 
+        } 
+ 
         switch (node.Type()) {
         case TExprNode::Argument:
             return false;
@@ -1976,7 +1976,7 @@ bool CompileExpr(TAstNode& astRoot, TExprNode::TPtr& exprRoot, TExprContext& ctx
     }
 
     compileCtx.Frames.back().Bindings[TStringBuf("world")] = {std::move(world)};
-    auto ret = CompileFunction(*cleanRoot, compileCtx, true);
+    auto ret = CompileFunction(*cleanRoot, compileCtx, true); 
     if (1U != ret.size())
         return false;
     exprRoot = std::move(ret.front());
@@ -1984,19 +1984,19 @@ bool CompileExpr(TAstNode& astRoot, TExprNode::TPtr& exprRoot, TExprContext& ctx
     return bool(exprRoot);
 }
 
-bool CompileExpr(TAstNode& astRoot, TExprNode::TPtr& exprRoot, TExprContext& ctx,
+bool CompileExpr(TAstNode& astRoot, TExprNode::TPtr& exprRoot, TExprContext& ctx, 
     IModuleResolver* resolver, ui32 annotationFlags, ui16 syntaxVersion)
-{
-    bool hasAnnotations = annotationFlags != TExprAnnotationFlags::None;
-    ui32 typeAnnotationIndex = Max<ui32>();
-    if (annotationFlags & TExprAnnotationFlags::Types) {
-        bool hasPostions = annotationFlags & TExprAnnotationFlags::Position;
-        typeAnnotationIndex = hasPostions ? 1 : 0;
-    }
-
+{ 
+    bool hasAnnotations = annotationFlags != TExprAnnotationFlags::None; 
+    ui32 typeAnnotationIndex = Max<ui32>(); 
+    if (annotationFlags & TExprAnnotationFlags::Types) { 
+        bool hasPostions = annotationFlags & TExprAnnotationFlags::Position; 
+        typeAnnotationIndex = hasPostions ? 1 : 0; 
+    } 
+ 
     return CompileExpr(astRoot, exprRoot, ctx, resolver, hasAnnotations, typeAnnotationIndex, syntaxVersion);
-}
-
+} 
+ 
 bool CompileExpr(TAstNode& astRoot, TLibraryCohesion& library, TExprContext& ctx, ui16 syntaxVersion) {
     const TAstNode* cleanRoot = &astRoot;
     TContext compileCtx(ctx);
@@ -2370,12 +2370,12 @@ void CheckArguments(const TExprNode& root) {
     }
 }
 
-TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& exprContext, const TConvertToAstSettings& settings) {
+TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& exprContext, const TConvertToAstSettings& settings) { 
 #ifdef _DEBUG
     CheckArguments(root);
 #endif
     TVisitNodeContext ctx(exprContext);
-    ctx.RefAtoms = settings.RefAtoms;
+    ctx.RefAtoms = settings.RefAtoms; 
     ctx.Pool = std::make_unique<TMemoryPool>(4096);
     ctx.Frames.push_back(TFrameContext());
     ctx.CurrentFrame = &ctx.Frames.front();
@@ -2389,7 +2389,7 @@ TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& exprContext, c
             const auto name = ctx.FindBinding(node.second);
             if (name.empty()) {
                 const auto& ref = ctx.References[node.second];
-                if (!InlineNode(*node.second, ref.References, ref.Neighbors, settings)) {
+                if (!InlineNode(*node.second, ref.References, ref.Neighbors, settings)) { 
                     if (settings.PrintArguments && node.second->IsArgument()) {
                         auto buffer = TStringBuilder() << "$" << ++uniqueNum
                             << "{" << node.second->Content() << ":"
@@ -2413,13 +2413,13 @@ TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& exprContext, c
     return result;
 }
 
-TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& exprContext, ui32 annotationFlags, bool refAtoms) {
-    TConvertToAstSettings settings;
-    settings.AnnotationFlags = annotationFlags;
-    settings.RefAtoms = refAtoms;
-    return ConvertToAst(root, exprContext, settings);
-}
-
+TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& exprContext, ui32 annotationFlags, bool refAtoms) { 
+    TConvertToAstSettings settings; 
+    settings.AnnotationFlags = annotationFlags; 
+    settings.RefAtoms = refAtoms; 
+    return ConvertToAst(root, exprContext, settings); 
+} 
+ 
 TString TExprNode::Dump() const {
     TNodeSet visited;
     TStringStream out;
@@ -2628,9 +2628,9 @@ TNodeException::TNodeException(const TExprNode* node)
 
 TNodeException::TNodeException(const TPositionHandle& pos)
     : Pos_(pos)
-{
-}
-
+{ 
+} 
+ 
 bool ValidateName(TPosition position, TStringBuf name, TStringBuf descr, TExprContext& ctx) {
     if (name.empty()) {
         ctx.AddError(TIssue(position,
@@ -2864,7 +2864,7 @@ bool TTaggedExprType::Validate(TPositionHandle position, TExprContext& ctx) cons
 TExprContext::TExprContext(ui64 nextUniqueId)
     : StringPool(4096)
     , NextUniqueId(nextUniqueId)
-    , Frozen(false)
+    , Frozen(false) 
     , PositionSet(
         16,
         [this](TPositionHandle p) { return GetHash(p); },
@@ -2900,36 +2900,36 @@ TPosition TExprContext::GetPosition(TPositionHandle handle) const {
     return Positions[handle.Handle];
 }
 
-TExprContext::~TExprContext() {
-    UnFreeze();
-}
-
-void TExprContext::Freeze() {
-    for (auto& node : ExprNodes) {
-        node->MarkFrozen();
-    }
-
-    Frozen = true;
-}
-
-void TExprContext::UnFreeze() {
-    if (Frozen) {
-        for (auto& node : ExprNodes) {
-            node->MarkFrozen(false);
-        }
-
-        Frozen = false;
-    }
-}
-
-void TExprContext::Reset() {
-    YQL_ENSURE(!Frozen);
-
-    IssueManager.Reset();
-    Step.Reset();
-    RepeatTransformCounter = 0;
-}
-
+TExprContext::~TExprContext() { 
+    UnFreeze(); 
+} 
+
+void TExprContext::Freeze() { 
+    for (auto& node : ExprNodes) { 
+        node->MarkFrozen(); 
+    } 
+ 
+    Frozen = true; 
+} 
+ 
+void TExprContext::UnFreeze() { 
+    if (Frozen) { 
+        for (auto& node : ExprNodes) { 
+            node->MarkFrozen(false); 
+        } 
+ 
+        Frozen = false; 
+    } 
+} 
+ 
+void TExprContext::Reset() { 
+    YQL_ENSURE(!Frozen); 
+ 
+    IssueManager.Reset(); 
+    Step.Reset(); 
+    RepeatTransformCounter = 0; 
+} 
+ 
 bool TExprContext::IsEqual(TPositionHandle a, TPositionHandle b) const {
     YQL_ENSURE(a.Handle < Positions.size());
     YQL_ENSURE(b.Handle < Positions.size());
diff --git a/ydb/library/yql/ast/yql_expr.h b/ydb/library/yql/ast/yql_expr.h
index d6eb544f9a..c455aafd9d 100644
--- a/ydb/library/yql/ast/yql_expr.h
+++ b/ydb/library/yql/ast/yql_expr.h
@@ -33,18 +33,18 @@
 #include <span>
 #include <stack>
 
-//#define YQL_CHECK_NODES_CONSISTENCY
-#ifdef YQL_CHECK_NODES_CONSISTENCY
-    #define ENSURE_NOT_DELETED \
+//#define YQL_CHECK_NODES_CONSISTENCY 
+#ifdef YQL_CHECK_NODES_CONSISTENCY 
+    #define ENSURE_NOT_DELETED \ 
         YQL_ENSURE(!Dead(), "Access to dead node # " << UniqueId_ << ": " << Type_ << " '" << ContentUnchecked() << "'");
-    #define ENSURE_NOT_FROZEN \
+    #define ENSURE_NOT_FROZEN \ 
         YQL_ENSURE(!Frozen(), "Change in frozen node # " << UniqueId_ << ": " << Type_ << " '" << ContentUnchecked() << "'");
-    #define ENSURE_NOT_FROZEN_CTX \
-        YQL_ENSURE(!Frozen, "Change in frozen expr context.");
+    #define ENSURE_NOT_FROZEN_CTX \ 
+        YQL_ENSURE(!Frozen, "Change in frozen expr context."); 
 #else
     #define ENSURE_NOT_DELETED Y_VERIFY_DEBUG(!Dead(), "Access to dead node # %lu: %d '%s'", UniqueId_, (int)Type_, TString(ContentUnchecked()).data());
-    #define ENSURE_NOT_FROZEN Y_VERIFY_DEBUG(!Frozen());
-    #define ENSURE_NOT_FROZEN_CTX Y_VERIFY_DEBUG(!Frozen);
+    #define ENSURE_NOT_FROZEN Y_VERIFY_DEBUG(!Frozen()); 
+    #define ENSURE_NOT_FROZEN_CTX Y_VERIFY_DEBUG(!Frozen); 
 #endif
 
 namespace NYql {
@@ -68,7 +68,7 @@ class TDictExprType;
 class TVoidExprType;
 class TNullExprType;
 class TGenericExprType;
-class TTaggedExprType;
+class TTaggedExprType; 
 class TErrorExprType;
 class TVariantExprType;
 class TStreamExprType;
@@ -101,7 +101,7 @@ struct TTypeAnnotationVisitor {
     virtual void Visit(const TVoidExprType& type) = 0;
     virtual void Visit(const TNullExprType& type) = 0;
     virtual void Visit(const TGenericExprType& type) = 0;
-    virtual void Visit(const TTaggedExprType& type) = 0;
+    virtual void Visit(const TTaggedExprType& type) = 0; 
     virtual void Visit(const TErrorExprType& type) = 0;
     virtual void Visit(const TVariantExprType& type) = 0;
     virtual void Visit(const TEmptyListExprType& type) = 0;
@@ -1059,16 +1059,16 @@ private:
     const TStringBuf Tag;
 };
 
-class TTaggedExprType : public TTypeAnnotationNode {
-public:
+class TTaggedExprType : public TTypeAnnotationNode { 
+public: 
     static constexpr ETypeAnnotationKind KindValue = ETypeAnnotationKind::Tagged;
 
     TTaggedExprType(ui64 hash, const TTypeAnnotationNode* baseType, const TStringBuf& tag)
         : TTypeAnnotationNode(KindValue, baseType->GetFlags(), hash)
-        , BaseType(baseType)
-        , Tag(tag)
-    {}
-
+        , BaseType(baseType) 
+        , Tag(tag) 
+    {} 
+ 
     static ui64 MakeHash(const TTypeAnnotationNode* baseType, const TStringBuf& tag) {
         ui64 hash = TypeHashMagic | (ui64)ETypeAnnotationKind::Tagged;
         hash = StreamHash(baseType->GetHash(), hash);
@@ -1077,25 +1077,25 @@ public:
     }
 
     const TStringBuf& GetTag() const {
-        return Tag;
-    }
-
-    const TTypeAnnotationNode* GetBaseType() const {
-        return BaseType;
-    }
-
-    bool operator==(const TTaggedExprType& other) const {
+        return Tag; 
+    } 
+ 
+    const TTypeAnnotationNode* GetBaseType() const { 
+        return BaseType; 
+    } 
+ 
+    bool operator==(const TTaggedExprType& other) const { 
         return Tag == other.Tag && GetBaseType() == other.GetBaseType();
-    }
-
+    } 
+ 
     bool Validate(TPosition position, TExprContext& ctx) const;
     bool Validate(TPositionHandle position, TExprContext& ctx) const;
 
-private:
+private: 
     const TTypeAnnotationNode* BaseType;
     const TStringBuf Tag;
-};
-
+}; 
+ 
 class TErrorExprType : public TTypeAnnotationNode {
 public:
     static constexpr ETypeAnnotationKind KindValue = ETypeAnnotationKind::Error;
@@ -1281,7 +1281,7 @@ inline void TTypeAnnotationNode::Accept(TTypeAnnotationVisitor& visitor) const {
         return visitor.Visit(static_cast<const TGenericExprType&>(*this));
     case ETypeAnnotationKind::Resource:
         return visitor.Visit(static_cast<const TResourceExprType&>(*this));
-    case ETypeAnnotationKind::Tagged:
+    case ETypeAnnotationKind::Tagged: 
         return visitor.Visit(static_cast<const TTaggedExprType&>(*this));
     case ETypeAnnotationKind::Error:
         return visitor.Visit(static_cast<const TErrorExprType&>(*this));
@@ -1303,20 +1303,20 @@ inline void TTypeAnnotationNode::Accept(TTypeAnnotationVisitor& visitor) const {
 }
 
 class TExprNode {
-    friend class TExprNodeBuilder;
-    friend class TExprNodeReplaceBuilder;
-    friend struct TExprContext;
-
-private:
-    struct TExprFlags {
-        enum : ui16 {
-            Default = 0,
-            Dead = 0x01,
-            Frozen = 0x02,
-        };
+    friend class TExprNodeBuilder; 
+    friend class TExprNodeReplaceBuilder; 
+    friend struct TExprContext; 
+
+private: 
+    struct TExprFlags { 
+        enum : ui16 { 
+            Default = 0, 
+            Dead = 0x01, 
+            Frozen = 0x02, 
+        }; 
         static constexpr ui32 FlagsMask = 0x03; // all flags should fit here
-    };
-
+    }; 
+ 
 public:
     typedef TIntrusivePtr<TExprNode> TPtr;
     typedef std::vector<TPtr> TListType;
@@ -1337,7 +1337,7 @@ public:
     xx(Arguments, 5) \
     xx(World, 7)
 
-    enum EType : ui8 {
+    enum EType : ui8 { 
         YQL_EXPR_NODE_TYPE_MAP(ENUM_VALUE_GEN)
     };
 
@@ -1378,7 +1378,7 @@ public:
 
     void SetResult(TPtr&& result) {
         ENSURE_NOT_DELETED
-        ENSURE_NOT_FROZEN
+        ENSURE_NOT_FROZEN 
         Result = std::move(result);
     }
 
@@ -1398,11 +1398,11 @@ public:
         return Type() == TExprNode::Callable && names.contains(Content());
     }
 
-    bool IsCallable() const {
+    bool IsCallable() const { 
         ENSURE_NOT_DELETED
         return Type() == TExprNode::Callable;
-    }
-
+    } 
+ 
     bool IsAtom() const {
         ENSURE_NOT_DELETED
         return Type() == TExprNode::Atom;
@@ -1490,30 +1490,30 @@ public:
     }
 
     void Ref() {
-        ENSURE_NOT_DELETED
-        ENSURE_NOT_FROZEN
+        ENSURE_NOT_DELETED 
+        ENSURE_NOT_FROZEN 
         Y_ENSURE(RefCount_ < Max<ui32>());
         ++RefCount_;
     }
 
     void UnRef() {
-        ENSURE_NOT_DELETED
-        ENSURE_NOT_FROZEN
+        ENSURE_NOT_DELETED 
+        ENSURE_NOT_FROZEN 
         if (!--RefCount_) {
             Result.Reset();
             Children_.clear();
             Constraints_.Clear();
-            MarkDead();
+            MarkDead(); 
         }
     }
 
     ui32 UseCount() const { return RefCount_; }
     bool Unique() const { return 1U == UseCount(); }
 
-    bool Dead() const {
-        return ExprFlags_ & TExprFlags::Dead;
-    }
-
+    bool Dead() const { 
+        return ExprFlags_ & TExprFlags::Dead; 
+    } 
+ 
     TPositionHandle Pos() const {
         ENSURE_NOT_DELETED
         return Position_;
@@ -1523,7 +1523,7 @@ public:
 
     EType Type() const {
         ENSURE_NOT_DELETED
-        return (EType)Type_;
+        return (EType)Type_; 
     }
 
     TListType::size_type ChildrenSize() const {
@@ -1545,7 +1545,7 @@ public:
 
     TPtr& ChildRef(ui32 index) {
         ENSURE_NOT_DELETED
-        ENSURE_NOT_FROZEN
+        ENSURE_NOT_FROZEN 
         Y_ENSURE(index < Children_.size(), "index out of range");
         return Children_[index];
     }
@@ -1632,8 +1632,8 @@ public:
     }
 
     void NormalizeAtomFlags(const TExprNode& otherAtom) {
-        ENSURE_NOT_DELETED
-        ENSURE_NOT_FROZEN
+        ENSURE_NOT_DELETED 
+        ENSURE_NOT_FROZEN 
         Y_ENSURE(Type_ == Atom && otherAtom.Type_ == Atom, "Expected atoms");
         Y_ENSURE((Flags_ & TNodeFlags::BinaryContent) ==
             (otherAtom.Flags_ & TNodeFlags::BinaryContent), "Mismatch binary atom flags");
@@ -1869,9 +1869,9 @@ public:
     }
 
     ~TExprNode() {
-        Y_VERIFY(Dead(), "Node (id: %lu, type: %s, content: '%s') not dead on destruction.",
+        Y_VERIFY(Dead(), "Node (id: %lu, type: %s, content: '%s') not dead on destruction.", 
             UniqueId_, ToString(Type_).data(),  TString(ContentUnchecked()).data());
-        Y_VERIFY(!UseCount(), "Node (id: %lu, type: %s, content: '%s') has non-zero use count on destruction.",
+        Y_VERIFY(!UseCount(), "Node (id: %lu, type: %s, content: '%s') has non-zero use count on destruction.", 
             UniqueId_, ToString(Type_).data(),  TString(ContentUnchecked()).data());
     }
 
@@ -1894,35 +1894,35 @@ private:
         , Position_(position)
         , ContentSize(contentSize)
         , Type_(type)
-        , Flags_(flags)
-        , ExprFlags_(TExprFlags::Default)
+        , Flags_(flags) 
+        , ExprFlags_(TExprFlags::Default) 
         , State(EState::Initial)
         , HasLambdaScope(0)
         , UsedInDependsOn(0)
         , UnordChildren(0)
         , ShallBeDisclosed(0)
     {}
-
+ 
     TExprNode(const TExprNode&) = delete;
     TExprNode(TExprNode&&) = delete;
     TExprNode& operator=(const TExprNode&) = delete;
     TExprNode& operator=(TExprNode&&) = delete;
 
-    bool Frozen() const {
-        return ExprFlags_ & TExprFlags::Frozen;
-    }
-
-    void MarkFrozen(bool frozen = true) {
-        if (frozen) {
-            ExprFlags_ |= TExprFlags::Frozen;
-        } else {
-            ExprFlags_ &= ~TExprFlags::Frozen;
-        }
-    }
-
-    void MarkDead() {
-        ExprFlags_ |= TExprFlags::Dead;
-    }
+    bool Frozen() const { 
+        return ExprFlags_ & TExprFlags::Frozen; 
+    } 
+ 
+    void MarkFrozen(bool frozen = true) { 
+        if (frozen) { 
+            ExprFlags_ |= TExprFlags::Frozen; 
+        } else { 
+            ExprFlags_ &= ~TExprFlags::Frozen; 
+        } 
+    } 
+ 
+    void MarkDead() { 
+        ExprFlags_ |= TExprFlags::Dead; 
+    } 
 
     TStringBuf ContentUnchecked() const {
         return TStringBuf(Content_, ContentSize);
@@ -2214,25 +2214,25 @@ using TSingletonTypeCache = std::tuple<
 >;
 
 struct TExprContext : private TNonCopyable {
-    class TFreezeGuard {
-    public:
-        TFreezeGuard(const TFreezeGuard&) = delete;
-        TFreezeGuard& operator=(const TFreezeGuard&) = delete;
-
-        TFreezeGuard(TExprContext& ctx)
-            : Ctx(ctx)
-        {
-            Ctx.Freeze();
-        }
-
-        ~TFreezeGuard() {
-            Ctx.UnFreeze();
-        }
-
-    private:
-        TExprContext& Ctx;
-    };
-
+    class TFreezeGuard { 
+    public: 
+        TFreezeGuard(const TFreezeGuard&) = delete; 
+        TFreezeGuard& operator=(const TFreezeGuard&) = delete; 
+ 
+        TFreezeGuard(TExprContext& ctx) 
+            : Ctx(ctx) 
+        { 
+            Ctx.Freeze(); 
+        } 
+ 
+        ~TFreezeGuard() { 
+            Ctx.UnFreeze(); 
+        } 
+ 
+    private: 
+        TExprContext& Ctx; 
+    }; 
+ 
     TIssueManager IssueManager;
     TNodeMap<TIssues> AssociativeIssues;
 
@@ -2262,19 +2262,19 @@ struct TExprContext : private TNonCopyable {
 
     TExprStep Step;
 
-    bool Frozen;
-
+    bool Frozen; 
+ 
     explicit TExprContext(ui64 nextUniqueId = 0ULL);
     ~TExprContext();
 
     ui64 AllocateNextUniqueId() {
-        ENSURE_NOT_FROZEN_CTX
+        ENSURE_NOT_FROZEN_CTX 
         const auto ret = ++NextUniqueId;
         return ret;
     }
 
     TStringBuf AppendString(const TStringBuf& buf) {
-        ENSURE_NOT_FROZEN_CTX
+        ENSURE_NOT_FROZEN_CTX 
         if (buf.size() == 0) {
             return ZeroString;
         }
@@ -2436,19 +2436,19 @@ struct TExprContext : private TNonCopyable {
     const T* MakeConstraint(Args&&... args);
 
     void AddError(const TIssue& error) {
-        ENSURE_NOT_FROZEN_CTX
+        ENSURE_NOT_FROZEN_CTX 
         IssueManager.RaiseIssue(error);
     }
-
+ 
     bool AddWarning(const TIssue& warning) {
         ENSURE_NOT_FROZEN_CTX
         return IssueManager.RaiseWarning(warning);
     }
 
-    void Freeze();
-    void UnFreeze();
-
-    void Reset();
+    void Freeze(); 
+    void UnFreeze(); 
+ 
+    void Reset(); 
 
     template <class TConstraint>
     bool IsConstraintEnabled() const {
@@ -2484,10 +2484,10 @@ inline const T* TExprContext::MakeConstraint(Args&&... args) {
     return static_cast<const T*>(*ins.first);
 }
 
-#undef ENSURE_NOT_DELETED
-#undef ENSURE_NOT_FROZEN
-#undef ENSURE_NOT_FROZEN_CTX
-
+#undef ENSURE_NOT_DELETED 
+#undef ENSURE_NOT_FROZEN 
+#undef ENSURE_NOT_FROZEN_CTX 
+ 
 inline bool IsSameAnnotation(const TTypeAnnotationNode& left, const TTypeAnnotationNode& right) {
     return &left == &right;
 }
@@ -2526,9 +2526,9 @@ private:
 bool CompileExpr(TAstNode& astRoot, TExprNode::TPtr& exprRoot, TExprContext& ctx,
     IModuleResolver* resolver, bool hasAnnotations = false, ui32 typeAnnotationIndex = Max<ui32>(), ui16 syntaxVersion = 0);
 
-bool CompileExpr(TAstNode& astRoot, TExprNode::TPtr& exprRoot, TExprContext& ctx,
+bool CompileExpr(TAstNode& astRoot, TExprNode::TPtr& exprRoot, TExprContext& ctx, 
     IModuleResolver* resolver, ui32 annotationFlags, ui16 syntaxVersion = 0);
-
+ 
 struct TLibraryCohesion {
     TExportTable Exports;
     TNodeMap<std::pair<TString, TString>> Imports;
@@ -2551,18 +2551,18 @@ bool CompareExprTreeParts(const TExprNode& one, const TExprNode& two, const TNod
 void GatherParents(const TExprNode& node, TParentsMap& parentsMap, bool withLeaves = false);
 void GatherParentsMulti(const TExprNode& node, TParentsMultiMap& parentsMap, bool withLeaves = false);
 
-struct TConvertToAstSettings {
-    ui32 AnnotationFlags = 0;
-    bool RefAtoms = false;
-    std::function<bool(const TExprNode&)> NoInlineFunc;
+struct TConvertToAstSettings { 
+    ui32 AnnotationFlags = 0; 
+    bool RefAtoms = false; 
+    std::function<bool(const TExprNode&)> NoInlineFunc; 
     bool PrintArguments = false;
-};
-
-TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& ctx, const TConvertToAstSettings& settings);
-
-// refAtoms allows omit copying of atom bodies - they will be referenced from expr graph
-TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& ctx, ui32 annotationFlags, bool refAtoms);
-
+}; 
+ 
+TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& ctx, const TConvertToAstSettings& settings); 
+ 
+// refAtoms allows omit copying of atom bodies - they will be referenced from expr graph 
+TAstParseResult ConvertToAst(const TExprNode& root, TExprContext& ctx, ui32 annotationFlags, bool refAtoms); 
+ 
 TExprNode::TListType GetLambdaBody(const TExprNode& lambda);
 
 } // namespace NYql
diff --git a/ydb/library/yql/ast/yql_expr_builder.cpp b/ydb/library/yql/ast/yql_expr_builder.cpp
index 4b22308b99..22c1324e28 100644
--- a/ydb/library/yql/ast/yql_expr_builder.cpp
+++ b/ydb/library/yql/ast/yql_expr_builder.cpp
@@ -6,22 +6,22 @@ namespace NYql {
 TExprNodeBuilder::TExprNodeBuilder(TPositionHandle pos, TExprContext& ctx)
     : Ctx(ctx)
     , Parent(nullptr)
-    , ParentReplacer(nullptr)
+    , ParentReplacer(nullptr) 
     , Container(nullptr)
     , Pos(pos)
     , CurrentNode(nullptr)
 {}
 
 TExprNodeBuilder::TExprNodeBuilder(TPositionHandle pos, TExprContext& ctx, ExtArgsFuncType extArgsFunc)
-    : Ctx(ctx)
-    , Parent(nullptr)
-    , ParentReplacer(nullptr)
-    , Container(nullptr)
-    , Pos(pos)
-    , CurrentNode(nullptr)
-    , ExtArgsFunc(extArgsFunc)
-{}
-
+    : Ctx(ctx) 
+    , Parent(nullptr) 
+    , ParentReplacer(nullptr) 
+    , Container(nullptr) 
+    , Pos(pos) 
+    , CurrentNode(nullptr) 
+    , ExtArgsFunc(extArgsFunc) 
+{} 
+ 
 TExprNodeBuilder::TExprNodeBuilder(TPositionHandle pos, TExprNodeBuilder* parent, const TExprNode::TPtr& container)
     : Ctx(parent->Ctx)
     , Parent(parent)
@@ -332,12 +332,12 @@ TExprNode::TPtr TExprNodeBuilder::FindArgument(const TStringBuf& name) {
         }
     }
 
-    if (ExtArgsFunc) {
+    if (ExtArgsFunc) { 
         if (const auto arg = ExtArgsFunc(name)) {
-            return arg;
-        }
-    }
-
+            return arg; 
+        } 
+    } 
+ 
     ythrow yexception() << "Parameter not found: " << name;
 }
 
@@ -367,10 +367,10 @@ TExprNodeReplaceBuilder TExprNodeBuilder::ApplyPartial(ui32 index, TExprNode::TP
     Y_ENSURE(Container, "Container expected");
     Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
         "Container position mismatch, expected: " << Container->ChildrenSize() <<
-        ", actual: " << index);
+        ", actual: " << index); 
     return TExprNodeReplaceBuilder(this, Container, std::move(args), std::move(body));
-}
-
+} 
+ 
 TExprNodeReplaceBuilder TExprNodeBuilder::ApplyPartial(ui32 index, TExprNode::TPtr args, TExprNode::TListType body) {
     Y_ENSURE(Container, "Container expected");
     Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
@@ -383,8 +383,8 @@ TExprNodeReplaceBuilder TExprNodeBuilder::ApplyPartial(TExprNode::TPtr args, TEx
     Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
     Y_ENSURE(!CurrentNode, "Node is already build");
     return TExprNodeReplaceBuilder(this, Container, std::move(args), std::move(body));
-}
-
+} 
+ 
 TExprNodeReplaceBuilder TExprNodeBuilder::ApplyPartial(TExprNode::TPtr args, TExprNode::TListType body) {
     Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
     Y_ENSURE(!CurrentNode, "Node is already build");
@@ -416,10 +416,10 @@ TExprNodeReplaceBuilder::TExprNodeReplaceBuilder(TExprNodeBuilder* owner, TExprN
 TExprNodeReplaceBuilder::TExprNodeReplaceBuilder(TExprNodeBuilder* owner, TExprNode::TPtr container,
     const TExprNode& lambda)
     : TExprNodeReplaceBuilder(owner, std::move(container), lambda.HeadPtr(), lambda.TailPtr())
-{
+{ 
     Y_ENSURE(lambda.Type() == TExprNode::Lambda, "Expected lambda");
-}
-
+} 
+ 
 TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::With(
     ui32 argIndex, const TStringBuf& toName) {
     Y_ENSURE(Args, "No arguments");
@@ -458,13 +458,13 @@ TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::With(ui32 argIndex, const TStr
 
 TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::WithNode(const TExprNode& fromNode, TExprNode::TPtr&& toNode) {
     Body = Owner->Ctx.ReplaceNodes(std::move(Body), {{&fromNode, std::move(toNode)}});
-    return *this;
-}
-
+    return *this; 
+} 
+ 
 TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::WithNode(const TExprNode& fromNode, const TStringBuf& toName) {
     return WithNode(fromNode, Owner->FindArgument(toName));
-}
-
+} 
+ 
 TExprNodeBuilder TExprNodeReplaceBuilder::With(ui32 argIndex) {
     CurrentIndex = argIndex;
     return TExprNodeBuilder(Owner->Pos, this);
diff --git a/ydb/library/yql/ast/yql_expr_builder.h b/ydb/library/yql/ast/yql_expr_builder.h
index 18c63f2eea..2d512e7dc5 100644
--- a/ydb/library/yql/ast/yql_expr_builder.h
+++ b/ydb/library/yql/ast/yql_expr_builder.h
@@ -4,8 +4,8 @@
 #include "yql_errors.h"
 #include "yql_pos_handle.h"
 
-#include <functional>
-
+#include <functional> 
+ 
 namespace NYql {
 
 struct TExprContext;
@@ -13,13 +13,13 @@ class TExprNode;
 typedef TIntrusivePtr<TExprNode> TExprNodePtr;
 typedef std::vector<TExprNodePtr> TExprNodeList;
 
-class TExprNodeReplaceBuilder;
+class TExprNodeReplaceBuilder; 
 
 class TExprNodeBuilder {
 friend class TExprNodeReplaceBuilder;
 public:
     typedef std::function<TExprNodePtr(const TStringBuf&)> ExtArgsFuncType;
-public:
+public: 
     TExprNodeBuilder(TPositionHandle pos, TExprContext& ctx);
     TExprNodeBuilder(TPositionHandle pos, TExprContext& ctx, ExtArgsFuncType extArgsFunc);
     TExprNodePtr Build();
@@ -99,31 +99,31 @@ private:
     TExprNodePtr Container;
     TPositionHandle Pos;
     TExprNodePtr CurrentNode;
-    ExtArgsFuncType ExtArgsFunc;
+    ExtArgsFuncType ExtArgsFunc; 
 };
 
-namespace NNodes {
-    template<typename TParent, typename TNode>
-    class TNodeBuilder;
-}
-
-class TExprNodeReplaceBuilder {
-friend class TExprNodeBuilder;
-private:
-    struct TBuildAdapter {
-        typedef TExprNodeReplaceBuilder& ResultType;
-
-        TBuildAdapter(TExprNodeReplaceBuilder& builder)
-            : Builder(builder) {}
-
-        ResultType Value() {
-            return Builder;
-        }
-
-        TExprNodeReplaceBuilder& Builder;
-    };
-
-public:
+namespace NNodes { 
+    template<typename TParent, typename TNode> 
+    class TNodeBuilder; 
+} 
+ 
+class TExprNodeReplaceBuilder { 
+friend class TExprNodeBuilder; 
+private: 
+    struct TBuildAdapter { 
+        typedef TExprNodeReplaceBuilder& ResultType; 
+ 
+        TBuildAdapter(TExprNodeReplaceBuilder& builder) 
+            : Builder(builder) {} 
+ 
+        ResultType Value() { 
+            return Builder; 
+        } 
+ 
+        TExprNodeReplaceBuilder& Builder; 
+    }; 
+ 
+public: 
     TExprNodeReplaceBuilder(TExprNodeBuilder* owner, TExprNodePtr container, const TExprNode& lambda);
     TExprNodeReplaceBuilder(TExprNodeBuilder* owner, TExprNodePtr container, TExprNodePtr&& args, TExprNodePtr&& body);
     TExprNodeReplaceBuilder(TExprNodeBuilder* owner, TExprNodePtr container, TExprNodePtr&& args, TExprNodeList&& body);
@@ -134,40 +134,40 @@ public:
     TExprNodeReplaceBuilder& With(const TStringBuf& toName, ui32 toIndex);
     TExprNodeReplaceBuilder& WithNode(const TExprNode& fromNode, TExprNodePtr&& toNode);
     TExprNodeReplaceBuilder& WithNode(const TExprNode& fromNode, const TStringBuf& toName);
-    TExprNodeBuilder With(ui32 argIndex);
+    TExprNodeBuilder With(ui32 argIndex); 
     TExprNodeBuilder WithNode(TExprNodePtr&& fromNode);
-
-    template<typename TNode>
-    NNodes::TNodeBuilder<TBuildAdapter, TNode> With(ui32 argIndex) {
-        TBuildAdapter adapter(*this);
-
-        NNodes::TNodeBuilder<TBuildAdapter, TNode> builder(Owner->Ctx, Owner->Pos,
-            [adapter, argIndex](const TNode& node) mutable -> TBuildAdapter& {
-                adapter.Builder = adapter.Builder.With(argIndex, node.Get());
-                return adapter;
-            },
-            [adapter] (const TStringBuf& argName) {
+ 
+    template<typename TNode> 
+    NNodes::TNodeBuilder<TBuildAdapter, TNode> With(ui32 argIndex) { 
+        TBuildAdapter adapter(*this); 
+ 
+        NNodes::TNodeBuilder<TBuildAdapter, TNode> builder(Owner->Ctx, Owner->Pos, 
+            [adapter, argIndex](const TNode& node) mutable -> TBuildAdapter& { 
+                adapter.Builder = adapter.Builder.With(argIndex, node.Get()); 
+                return adapter; 
+            }, 
+            [adapter] (const TStringBuf& argName) { 
                 return adapter.Builder.Owner->FindArgument(argName);
-            });
-
-        return builder;
-    }
-
-    TExprNodeBuilder& Seal();
-
+            }); 
+ 
+        return builder; 
+    } 
+ 
+    TExprNodeBuilder& Seal(); 
+ 
     template <typename TFunc>
     TExprNodeReplaceBuilder& Do(const TFunc& func) {
         return func(*this);
     }
 
-private:
-    TExprNodeBuilder* Owner;
+private: 
+    TExprNodeBuilder* Owner; 
     TExprNodePtr Container;
     TExprNodePtr Args;
     TExprNodeList Body;
-    ui32 CurrentIndex;
+    ui32 CurrentIndex; 
     TExprNodePtr CurrentNode;
-};
-
+}; 
+ 
 } // namespace NYql
 
diff --git a/ydb/library/yql/ast/yql_expr_builder_ut.cpp b/ydb/library/yql/ast/yql_expr_builder_ut.cpp
index eb0f2a0bf1..28a2571ffb 100644
--- a/ydb/library/yql/ast/yql_expr_builder_ut.cpp
+++ b/ydb/library/yql/ast/yql_expr_builder_ut.cpp
@@ -568,28 +568,28 @@ Y_UNIT_TEST_SUITE(TExprBuilder) {
         UNIT_ASSERT_VALUES_EQUAL(res->Child(1)->ChildrenSize(), 1);
         UNIT_ASSERT_EQUAL(res->Child(1)->Child(0), res->Head().Child(0));
     }
-
+ 
     Y_UNIT_TEST(TestApplyPartialLambdaArgAsRoot) {
-        TExprContext ctx;
+        TExprContext ctx; 
         auto lambda = ctx.Builder(TPositionHandle())
-            .Lambda()
-                .Param("x")
-                .Callable("Func1")
-                    .Callable(0, "Func2")
-                        .Atom(0, "ABC")
-                        .Arg(1, "x")
-                    .Seal()
-                .Seal()
-            .Seal()
-            .Build();
-
+            .Lambda() 
+                .Param("x") 
+                .Callable("Func1") 
+                    .Callable(0, "Func2") 
+                        .Atom(0, "ABC") 
+                        .Arg(1, "x") 
+                    .Seal() 
+                .Seal() 
+            .Seal() 
+            .Build(); 
+ 
         auto res = ctx.Builder(TPositionHandle())
-            .Lambda()
-                .Param("y")
+            .Lambda() 
+                .Param("y") 
                 .ApplyPartial(lambda->HeadPtr(), lambda->Child(1)->HeadPtr()).With(0, "y").Seal()
-            .Seal()
-            .Build();
-
+            .Seal() 
+            .Build(); 
+ 
         UNIT_ASSERT_VALUES_EQUAL(res->Type(), TExprNode::Lambda);
         UNIT_ASSERT_VALUES_EQUAL(res->ChildrenSize(), 2);
         UNIT_ASSERT_VALUES_EQUAL(res->Head().Type(), TExprNode::Arguments);
@@ -597,31 +597,31 @@ Y_UNIT_TEST_SUITE(TExprBuilder) {
         UNIT_ASSERT_VALUES_EQUAL(res->Head().Head().Type(), TExprNode::Argument);
         UNIT_ASSERT_VALUES_EQUAL(res->Head().Head().Content(), "y");
         UNIT_ASSERT_EQUAL(res->Child(1)->Child(1), res->Head().Child(0));
-    }
-
+    } 
+ 
     Y_UNIT_TEST(TestApplyPartialLambdaArgInContainer) {
-        TExprContext ctx;
+        TExprContext ctx; 
         auto lambda = ctx.Builder(TPositionHandle())
-            .Lambda()
-                .Param("x")
-                .Callable("Func1")
-                    .Callable(0, "Func2")
-                        .Atom(0, "ABC")
-                        .Arg(1, "x")
-                    .Seal()
-                .Seal()
-            .Seal()
-            .Build();
-
+            .Lambda() 
+                .Param("x") 
+                .Callable("Func1") 
+                    .Callable(0, "Func2") 
+                        .Atom(0, "ABC") 
+                        .Arg(1, "x") 
+                    .Seal() 
+                .Seal() 
+            .Seal() 
+            .Build(); 
+ 
         auto res = ctx.Builder(TPositionHandle())
-            .Lambda()
-                .Param("y")
-                .Callable("Func3")
+            .Lambda() 
+                .Param("y") 
+                .Callable("Func3") 
                     .ApplyPartial(0, lambda->HeadPtr(), lambda->Child(1)->HeadPtr()).With(0, "y").Seal()
-                .Seal()
-            .Seal()
-            .Build();
-
+                .Seal() 
+            .Seal() 
+            .Build(); 
+ 
         UNIT_ASSERT_VALUES_EQUAL(res->Type(), TExprNode::Lambda);
         UNIT_ASSERT_VALUES_EQUAL(res->ChildrenSize(), 2);
         UNIT_ASSERT_VALUES_EQUAL(res->Head().Type(), TExprNode::Arguments);
@@ -629,35 +629,35 @@ Y_UNIT_TEST_SUITE(TExprBuilder) {
         UNIT_ASSERT_VALUES_EQUAL(res->Head().Head().Type(), TExprNode::Argument);
         UNIT_ASSERT_VALUES_EQUAL(res->Head().Head().Content(), "y");
         UNIT_ASSERT_EQUAL(res->Child(1)->Head().Child(1), res->Head().Child(0));
-    }
-
+    } 
+ 
     Y_UNIT_TEST(TestApplyOuterArg) {
-        TExprContext ctx;
+        TExprContext ctx; 
         auto ast = ctx.Builder(TPositionHandle())
-            .Lambda()
-                .Param("x")
-                .Callable("Func1")
-                    .Atom(0, "p1")
-                    .Lambda(1)
-                        .Callable("Func2")
-                            .Atom(0, "ABC")
-                            .Arg(1, "x")
-                        .Seal()
-                    .Seal()
-                .Seal()
-            .Seal()
-            .Build();
-
+            .Lambda() 
+                .Param("x") 
+                .Callable("Func1") 
+                    .Atom(0, "p1") 
+                    .Lambda(1) 
+                        .Callable("Func2") 
+                            .Atom(0, "ABC") 
+                            .Arg(1, "x") 
+                        .Seal() 
+                    .Seal() 
+                .Seal() 
+            .Seal() 
+            .Build(); 
+ 
         auto res1 = ctx.Builder(TPositionHandle())
-            .Lambda()
-                .Param("y")
-                .Callable("Func3")
+            .Lambda() 
+                .Param("y") 
+                .Callable("Func3") 
                     .ApplyPartial(0, nullptr, ast->Child(1)->Child(1)->ChildPtr(1))
                     .WithNode(*ast->Head().Child(0), "y").Seal()
-                .Seal()
-            .Seal()
-            .Build();
-
+                .Seal() 
+            .Seal() 
+            .Build(); 
+ 
         UNIT_ASSERT_VALUES_EQUAL(res1->Type(), TExprNode::Lambda);
         UNIT_ASSERT_VALUES_EQUAL(res1->ChildrenSize(), 2);
         UNIT_ASSERT_VALUES_EQUAL(res1->Head().Type(), TExprNode::Arguments);
@@ -665,26 +665,26 @@ Y_UNIT_TEST_SUITE(TExprBuilder) {
         UNIT_ASSERT_VALUES_EQUAL(res1->Head().Head().Type(), TExprNode::Argument);
         UNIT_ASSERT_VALUES_EQUAL(res1->Head().Head().Content(), "y");
         UNIT_ASSERT_EQUAL(res1->Child(1)->Head().Child(1), res1->Head().Child(0));
-
+ 
         auto atom = ctx.Builder(TPositionHandle())
-            .Atom("const")
-            .Build();
-
+            .Atom("const") 
+            .Build(); 
+ 
         auto res2 = ctx.Builder(TPositionHandle())
-            .Lambda()
-                .Callable("Func3")
+            .Lambda() 
+                .Callable("Func3") 
                     .ApplyPartial(0, nullptr, ast->Child(1)->Child(1)->ChildPtr(1))
                     .WithNode(ast->Head().Head(), TExprNode::TPtr(atom)).Seal()
-                .Seal()
-            .Seal()
-            .Build();
-
+                .Seal() 
+            .Seal() 
+            .Build(); 
+ 
         UNIT_ASSERT_VALUES_EQUAL(res2->Type(), TExprNode::Lambda);
         UNIT_ASSERT_VALUES_EQUAL(res2->ChildrenSize(), 2);
         UNIT_ASSERT_VALUES_EQUAL(res2->Head().Type(), TExprNode::Arguments);
         UNIT_ASSERT_VALUES_EQUAL(res2->Head().ChildrenSize(), 0);
         UNIT_ASSERT_EQUAL(res2->Child(1)->Head().ChildPtr(1), atom);
-    }
+    } 
 }
 
 } // namespace NYql
diff --git a/ydb/library/yql/ast/yql_expr_ut.cpp b/ydb/library/yql/ast/yql_expr_ut.cpp
index 06550f2507..2827f61634 100644
--- a/ydb/library/yql/ast/yql_expr_ut.cpp
+++ b/ydb/library/yql/ast/yql_expr_ut.cpp
@@ -35,7 +35,7 @@ Y_UNIT_TEST_SUITE(TCompileYqlExpr) {
         TExprNode::TPtr exprRoot;
         bool result = CompileExpr(*astRes.Root, exprRoot, exprCtx, nullptr);
         exprCtx.IssueManager.GetIssues().PrintTo(Cout);
-        return result;
+        return result; 
     }
 
     Y_UNIT_TEST(TestNoReturn1) {
@@ -229,80 +229,80 @@ Y_UNIT_TEST_SUITE(TCompileYqlExpr) {
             ")\n";
         UNIT_ASSERT(false == ParseAndCompile(s));
     }
-
+ 
     Y_UNIT_TEST(TestDeclareNonTop) {
-        const auto s = R"(
-            (
-            (let $1 (block '(
-                (declare $param (DataType 'Uint32))
-                (return $param)
-            )))
-            (return $1)
-            )
-        )";
-        UNIT_ASSERT(false == ParseAndCompile(s));
-    }
-
+        const auto s = R"( 
+            ( 
+            (let $1 (block '( 
+                (declare $param (DataType 'Uint32)) 
+                (return $param) 
+            ))) 
+            (return $1) 
+            ) 
+        )"; 
+        UNIT_ASSERT(false == ParseAndCompile(s)); 
+    } 
+ 
     Y_UNIT_TEST(TestDeclareHideLet) {
-        const auto s = R"(
-            (
-            (let $name (Uint32 '10))
-            (declare $name (DataType 'Uint32))
-            (return $name)
-            )
-        )";
-        UNIT_ASSERT(false == ParseAndCompile(s));
-    }
-
+        const auto s = R"( 
+            ( 
+            (let $name (Uint32 '10)) 
+            (declare $name (DataType 'Uint32)) 
+            (return $name) 
+            ) 
+        )"; 
+        UNIT_ASSERT(false == ParseAndCompile(s)); 
+    } 
+ 
     Y_UNIT_TEST(TestDeclareBadName) {
-        const auto s = R"(
-            (
-            (declare $15 (DataType 'Uint32))
-            (return $15)
-            )
-        )";
-        UNIT_ASSERT(false == ParseAndCompile(s));
-    }
-
+        const auto s = R"( 
+            ( 
+            (declare $15 (DataType 'Uint32)) 
+            (return $15) 
+            ) 
+        )"; 
+        UNIT_ASSERT(false == ParseAndCompile(s)); 
+    } 
+ 
     Y_UNIT_TEST(TestLetHideDeclare) {
-        const auto s = R"(
-            (
-            (declare $name (DataType 'Uint32))
-            (let $name (Uint32 '10))
-            (return $name)
-            )
-        )";
-
-        TAstParseResult astRes = ParseAstWithCheck(s);
-        TExprContext exprCtx;
-        TExprNode::TPtr exprRoot;
-        CompileExprWithCheck(*astRes.Root, exprRoot, exprCtx);
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Type(), TExprNode::Callable);
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Content(), "Uint32");
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->ChildrenSize(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(0)->Type(), TExprNode::Atom);
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(0)->Content(), "10");
-    }
-
+        const auto s = R"( 
+            ( 
+            (declare $name (DataType 'Uint32)) 
+            (let $name (Uint32 '10)) 
+            (return $name) 
+            ) 
+        )"; 
+ 
+        TAstParseResult astRes = ParseAstWithCheck(s); 
+        TExprContext exprCtx; 
+        TExprNode::TPtr exprRoot; 
+        CompileExprWithCheck(*astRes.Root, exprRoot, exprCtx); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Type(), TExprNode::Callable); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Content(), "Uint32"); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->ChildrenSize(), 1); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(0)->Type(), TExprNode::Atom); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(0)->Content(), "10"); 
+    } 
+ 
     Y_UNIT_TEST(TestDeclare) {
-        const auto s = R"(
-            (
-            (declare $param (DataType 'Uint32))
-            (return $param)
-            )
-        )";
-
-        TAstParseResult astRes = ParseAstWithCheck(s);
-        TExprContext exprCtx;
-        TExprNode::TPtr exprRoot;
-        CompileExprWithCheck(*astRes.Root, exprRoot, exprCtx);
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Type(), TExprNode::Callable);
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->ChildrenSize(), 2);
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(0)->Type(), TExprNode::Atom);
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(0)->Content(), "$param");
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(1)->Type(), TExprNode::Callable);
-        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(1)->Content(), "DataType");
-    }
+        const auto s = R"( 
+            ( 
+            (declare $param (DataType 'Uint32)) 
+            (return $param) 
+            ) 
+        )"; 
+ 
+        TAstParseResult astRes = ParseAstWithCheck(s); 
+        TExprContext exprCtx; 
+        TExprNode::TPtr exprRoot; 
+        CompileExprWithCheck(*astRes.Root, exprRoot, exprCtx); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Type(), TExprNode::Callable); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->ChildrenSize(), 2); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(0)->Type(), TExprNode::Atom); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(0)->Content(), "$param"); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(1)->Type(), TExprNode::Callable); 
+        UNIT_ASSERT_VALUES_EQUAL(exprRoot->Child(1)->Content(), "DataType"); 
+    } 
 }
 
 Y_UNIT_TEST_SUITE(TCompareExprTrees) {
@@ -888,7 +888,7 @@ Y_UNIT_TEST_SUITE(TCompareExprTrees) {
 }
 
 Y_UNIT_TEST_SUITE(TConvertToAst) {
-    static TString CompileAndDisassemble(const TString& program, bool expectEqualExprs = true) {
+    static TString CompileAndDisassemble(const TString& program, bool expectEqualExprs = true) { 
         const auto astRes = ParseAst(program);
         UNIT_ASSERT(astRes.IsOk());
         TExprContext exprCtx;
@@ -903,12 +903,12 @@ Y_UNIT_TEST_SUITE(TConvertToAst) {
         TExprNode::TPtr exprRoot2;
         auto compileOk = CompileExpr(*convRes.Root, exprRoot2, exprCtx2, nullptr);
         exprCtx2.IssueManager.GetIssues().PrintTo(Cout);
-        UNIT_ASSERT(compileOk);
+        UNIT_ASSERT(compileOk); 
         UNIT_ASSERT(exprRoot2);
         const TExprNode* node = exprRoot.Get();
         const TExprNode* node2 = exprRoot2.Get();
-        bool equal = CompareExprTrees(node, node2);
-        UNIT_ASSERT(equal == expectEqualExprs);
+        bool equal = CompareExprTrees(node, node2); 
+        UNIT_ASSERT(equal == expectEqualExprs); 
 
         return convRes.Root->ToString(TAstPrintFlags::PerLine | TAstPrintFlags::ShortQuote);
     }
@@ -1158,61 +1158,61 @@ Y_UNIT_TEST_SUITE(TConvertToAst) {
     }
 
     Y_UNIT_TEST(Parameters) {
-        const auto program = R"(
-        (
-        (let $nameType (OptionalType (DataType 'String)))
-        (let $1 (Read! world (DataSource '"kikimr" '"local_ut") (Key '('table (String '"tmp/table"))) (Void) '()))
-        (let $2 (DataSink 'result))
-        (let $5 (Write! (Left! $1) $2 (Key) (FlatMap (Filter (Right! $1)
-            (lambda '($9) (Coalesce (And
-                (== (Member $9 '"Group") (Parameter '"$Group" (DataType 'Uint32)))
-                (== (Member $9 '"Name") (Parameter '"$Name" $nameType))) (Bool 'false))))
-            (lambda '($10) (AsList $10))) '('('type) '('autoref))))
-        (let $6 (Read! (Commit! $5 $2) (DataSource '"kikimr" '"local_ut")
-            (Key '('table (String '"tmp/table"))) (Void) '()))
-        (let $7 (DataSink 'result))
-        (let $8 (Write! (Left! $6) $7 (Key) (FlatMap (Filter (Right! $6)
-            (lambda '($11) (Coalesce (And
-                (== (Member $11 '"Group") (+ (Parameter '"$Group" (DataType 'Uint32)) (Int32 '"1")))
-                (== (Member $11 '"Name") (Coalesce (Parameter '"$Name" $nameType)
-                    (String '"Empty")))) (Bool 'false))))
-            (lambda '($12) (AsList $12))) '('('type) '('autoref))))
-        (return (Commit! $8 $7))
-        )
-        )";
-
-        const auto disassembled = CompileAndDisassemble(program);
-        UNIT_ASSERT(TString::npos != disassembled.find("(declare $Group (DataType 'Uint32))"));
-        UNIT_ASSERT(TString::npos != disassembled.find("(declare $Name (OptionalType (DataType 'String)))"));
-    }
-
+        const auto program = R"( 
+        ( 
+        (let $nameType (OptionalType (DataType 'String))) 
+        (let $1 (Read! world (DataSource '"kikimr" '"local_ut") (Key '('table (String '"tmp/table"))) (Void) '())) 
+        (let $2 (DataSink 'result)) 
+        (let $5 (Write! (Left! $1) $2 (Key) (FlatMap (Filter (Right! $1) 
+            (lambda '($9) (Coalesce (And 
+                (== (Member $9 '"Group") (Parameter '"$Group" (DataType 'Uint32))) 
+                (== (Member $9 '"Name") (Parameter '"$Name" $nameType))) (Bool 'false)))) 
+            (lambda '($10) (AsList $10))) '('('type) '('autoref)))) 
+        (let $6 (Read! (Commit! $5 $2) (DataSource '"kikimr" '"local_ut") 
+            (Key '('table (String '"tmp/table"))) (Void) '())) 
+        (let $7 (DataSink 'result)) 
+        (let $8 (Write! (Left! $6) $7 (Key) (FlatMap (Filter (Right! $6) 
+            (lambda '($11) (Coalesce (And 
+                (== (Member $11 '"Group") (+ (Parameter '"$Group" (DataType 'Uint32)) (Int32 '"1"))) 
+                (== (Member $11 '"Name") (Coalesce (Parameter '"$Name" $nameType) 
+                    (String '"Empty")))) (Bool 'false)))) 
+            (lambda '($12) (AsList $12))) '('('type) '('autoref)))) 
+        (return (Commit! $8 $7)) 
+        ) 
+        )"; 
+ 
+        const auto disassembled = CompileAndDisassemble(program); 
+        UNIT_ASSERT(TString::npos != disassembled.find("(declare $Group (DataType 'Uint32))")); 
+        UNIT_ASSERT(TString::npos != disassembled.find("(declare $Name (OptionalType (DataType 'String)))")); 
+    } 
+ 
     Y_UNIT_TEST(ParametersDifferentTypes) {
-        const auto program = R"(
-        (
-        (let $1 (Read! world (DataSource '"kikimr" '"local_ut") (Key '('table (String '"tmp/table"))) (Void) '()))
-        (let $2 (DataSink 'result))
-        (let $5 (Write! (Left! $1) $2 (Key) (FlatMap (Filter (Right! $1)
-            (lambda '($9) (Coalesce (And
-                (== (Member $9 '"Group") (Parameter '"$Group" (DataType 'Uint32)))
-                (== (Member $9 '"Name") (Parameter '"$Name" (OptionalType (DataType 'String))))) (Bool 'false))))
-            (lambda '($10) (AsList $10))) '('('type) '('autoref))))
-        (let $6 (Read! (Commit! $5 $2) (DataSource '"kikimr" '"local_ut")
-            (Key '('table (String '"tmp/table"))) (Void) '()))
-        (let $7 (DataSink 'result))
-        (let $8 (Write! (Left! $6) $7 (Key) (FlatMap (Filter (Right! $6)
-            (lambda '($11) (Coalesce (And
-                (== (Member $11 '"Group") (+ (Parameter '"$Group" (DataType 'Uint32)) (Int32 '"1")))
-                (== (Member $11 '"Name") (Coalesce (Parameter '"$Name" (OptionalType (DataType 'Int32)))
-                    (String '"Empty")))) (Bool 'false))))
-            (lambda '($12) (AsList $12))) '('('type) '('autoref))))
-        (return (Commit! $8 $7))
-        )
-        )";
-
-        const auto disassembled = CompileAndDisassemble(program, false);
-        UNIT_ASSERT(TString::npos != disassembled.find("(declare $Group (DataType 'Uint32))"));
-        UNIT_ASSERT(TString::npos != disassembled.find("(declare $Name (OptionalType (DataType 'String)))"));
-    }
+        const auto program = R"( 
+        ( 
+        (let $1 (Read! world (DataSource '"kikimr" '"local_ut") (Key '('table (String '"tmp/table"))) (Void) '())) 
+        (let $2 (DataSink 'result)) 
+        (let $5 (Write! (Left! $1) $2 (Key) (FlatMap (Filter (Right! $1) 
+            (lambda '($9) (Coalesce (And 
+                (== (Member $9 '"Group") (Parameter '"$Group" (DataType 'Uint32))) 
+                (== (Member $9 '"Name") (Parameter '"$Name" (OptionalType (DataType 'String))))) (Bool 'false)))) 
+            (lambda '($10) (AsList $10))) '('('type) '('autoref)))) 
+        (let $6 (Read! (Commit! $5 $2) (DataSource '"kikimr" '"local_ut") 
+            (Key '('table (String '"tmp/table"))) (Void) '())) 
+        (let $7 (DataSink 'result)) 
+        (let $8 (Write! (Left! $6) $7 (Key) (FlatMap (Filter (Right! $6) 
+            (lambda '($11) (Coalesce (And 
+                (== (Member $11 '"Group") (+ (Parameter '"$Group" (DataType 'Uint32)) (Int32 '"1"))) 
+                (== (Member $11 '"Name") (Coalesce (Parameter '"$Name" (OptionalType (DataType 'Int32))) 
+                    (String '"Empty")))) (Bool 'false)))) 
+            (lambda '($12) (AsList $12))) '('('type) '('autoref)))) 
+        (return (Commit! $8 $7)) 
+        ) 
+        )"; 
+ 
+        const auto disassembled = CompileAndDisassemble(program, false); 
+        UNIT_ASSERT(TString::npos != disassembled.find("(declare $Group (DataType 'Uint32))")); 
+        UNIT_ASSERT(TString::npos != disassembled.find("(declare $Name (OptionalType (DataType 'String)))")); 
+    } 
 }
 
 } // namespace NYql
diff --git a/ydb/library/yql/ast/yql_type_string.cpp b/ydb/library/yql/ast/yql_type_string.cpp
index af9af93259..99ba89845d 100644
--- a/ydb/library/yql/ast/yql_type_string.cpp
+++ b/ydb/library/yql/ast/yql_type_string.cpp
@@ -333,13 +333,13 @@ private:
         // skip spaces
         while (!AtEnd() && isspace(Get())) {
             Move();
-        }
+        } 
 
         TokenBegin = Position;
         if (AtEnd()) {
             return TOKEN_EOF;
-        }
-
+        } 
+ 
         // clear last readed indentifier
         Identifier = {};
 
@@ -385,8 +385,8 @@ private:
             // otherwise, just return the last character as its ascii value
             return lastChar;
         }
-    }
-
+    } 
+ 
     TAstNode* ParseCallableType() {
         EXPECT_AND_SKIP_TOKEN('(', nullptr);
 
@@ -921,29 +921,29 @@ private:
         return MakeResourceType(tag);
     }
 
-    TAstNode* ParseTaggedType() {
+    TAstNode* ParseTaggedType() { 
         GetNextToken(); // eat keyword
         EXPECT_AND_SKIP_TOKEN('<', nullptr);
-
-        auto baseType = ParseType();
-        if (!baseType) return nullptr;
-
+ 
+        auto baseType = ParseType(); 
+        if (!baseType) return nullptr; 
+ 
         EXPECT_AND_SKIP_TOKEN(',', nullptr);
 
         if (Token != TOKEN_IDENTIFIER && Token != TOKEN_ESCAPED_IDENTIFIER) {
             return AddError("Expected tag of type");
         }
-
+ 
         TStringBuf tag = Identifier;
         if (tag.empty()) {
             return AddError("Expected non empty tag of type");
-        }
-
+        } 
+ 
         GetNextToken(); // eat tag
         EXPECT_AND_SKIP_TOKEN('>', nullptr);
         return MakeTaggedType(baseType, tag);
-    }
-
+    } 
+ 
     TAstNode* MakeResourceType(TStringBuf tag) {
         TAstNode* items[] = {
             MakeLiteralAtom(TStringBuf("ResourceType")),
@@ -995,15 +995,15 @@ private:
     }
 
     TAstNode* MakeTaggedType(TAstNode* baseType, TStringBuf tag) {
-        TAstNode* items[] = {
+        TAstNode* items[] = { 
             MakeLiteralAtom(TStringBuf("TaggedType")),
-            baseType,
-            MakeQuotedAtom(tag)
-        };
-
-        return MakeList(items, Y_ARRAY_SIZE(items));
-    }
-
+            baseType, 
+            MakeQuotedAtom(tag) 
+        }; 
+ 
+        return MakeList(items, Y_ARRAY_SIZE(items)); 
+    } 
+ 
     TAstNode* MakeDataType(TStringBuf type) {
         TAstNode* items[] = {
             MakeLiteralAtom(TStringBuf("DataType")),
@@ -1079,7 +1079,7 @@ private:
     }
 
     TAstNode* AddError(const TString& message) {
-        Issues.AddIssue(TIssue(TokenBegin, message));
+        Issues.AddIssue(TIssue(TokenBegin, message)); 
         return nullptr;
     }
 
@@ -1289,12 +1289,12 @@ private:
 
     void Visit(const TTaggedExprType& type) final {
         Out_ << TStringBuf("Tagged<");
-        type.GetBaseType()->Accept(*this);
+        type.GetBaseType()->Accept(*this); 
         Out_ << ',';
         EscapeArbitraryAtom(type.GetTag(), '\'', &Out_);
         Out_ << '>';
-    }
-
+    } 
+ 
     void Visit(const TErrorExprType& type) final {
         Out_ << TStringBuf("Error<");
         auto pos = type.GetError().Position;
diff --git a/ydb/library/yql/ast/yql_type_string_ut.cpp b/ydb/library/yql/ast/yql_type_string_ut.cpp
index 2f22c42258..6fe3144d9c 100644
--- a/ydb/library/yql/ast/yql_type_string_ut.cpp
+++ b/ydb/library/yql/ast/yql_type_string_ut.cpp
@@ -498,9 +498,9 @@ Y_UNIT_TEST_SUITE(TTypeString)
     }
 
     Y_UNIT_TEST(ParseTagged) {
-        TestOk("Tagged<Uint32, IdTag>", "(TaggedType (DataType 'Uint32) 'IdTag)");
-    }
-
+        TestOk("Tagged<Uint32, IdTag>", "(TaggedType (DataType 'Uint32) 'IdTag)"); 
+    } 
+ 
     Y_UNIT_TEST(ParseEmptyTuple) {
         TestOk("Tuple<>", "(TupleType)");
     }
diff --git a/ydb/library/yql/core/common_opt/yql_co.h b/ydb/library/yql/core/common_opt/yql_co.h
index b8f2719037..ea0c0bc470 100644
--- a/ydb/library/yql/core/common_opt/yql_co.h
+++ b/ydb/library/yql/core/common_opt/yql_co.h
@@ -12,10 +12,10 @@ struct TOptimizeContext {
     TParentsMap* ParentsMap = nullptr;
 
     const TExprNode* GetParentIfSingle(const TExprNode& node) const {
-        YQL_ENSURE(ParentsMap);
+        YQL_ENSURE(ParentsMap); 
 
         const auto it = ParentsMap->find(&node);
-        YQL_ENSURE(it != ParentsMap->cend());
+        YQL_ENSURE(it != ParentsMap->cend()); 
 
         auto& parents = it->second;
         YQL_ENSURE(!parents.empty());
@@ -40,8 +40,8 @@ struct TOptimizeContext {
 
     bool IsSingleUsage(const NNodes::TExprBase& node) const {
         return IsSingleUsage(node.Ref());
-    }
-
+    } 
+ 
     bool HasParent(const TExprNode& node) const {
         YQL_ENSURE(ParentsMap);
         return ParentsMap->contains(&node);
@@ -64,10 +64,10 @@ struct TOptimizeContext {
 
         return false;
     }
-
-    bool IsPersistentNode(const NNodes::TExprBase& node) const {
-        return IsPersistentNode(node.Ref());
-    }
+ 
+    bool IsPersistentNode(const NNodes::TExprBase& node) const { 
+        return IsPersistentNode(node.Ref()); 
+    } 
 };
 
 using TCallableOptimizerExt = std::function<TExprNode::TPtr (const TExprNode::TPtr&, TExprContext&, TOptimizeContext&)>;
diff --git a/ydb/library/yql/core/common_opt/yql_co_flow1.cpp b/ydb/library/yql/core/common_opt/yql_co_flow1.cpp
index 728838dc8e..f235f1c6b4 100644
--- a/ydb/library/yql/core/common_opt/yql_co_flow1.cpp
+++ b/ydb/library/yql/core/common_opt/yql_co_flow1.cpp
@@ -418,30 +418,30 @@ TExprNode::TPtr FuseFlatmaps(TCoFlatMapBase outerMap, TExprContext& ctx, TTypeAn
 TExprNode::TPtr FuseCombineByKeyOverFlatmap(TCoCombineByKey combine, TExprContext& ctx) {
     auto flatmap = combine.Input().Cast<TCoFlatMapBase>();
 
-    auto inputType = flatmap.Input().Ref().GetTypeAnn();
-    if (inputType->GetKind() == ETypeAnnotationKind::Optional) {
-        // Optional not supported as CombineByKey input.
-        return combine.Ptr();
-    }
-
-    auto flatmapBody = flatmap.Lambda().Body();
-    if (!IsJustOrSingleAsList(flatmapBody.Ref())) {
-        // Only push maps to PreMapLambda.
-        return combine.Ptr();
-    }
-
-    auto value = flatmapBody.Maybe<TCoJust>()
-        ? flatmapBody.Cast<TCoJust>().Input()
-        : flatmapBody.Cast<TCoAsList>().Arg(0);
-
+    auto inputType = flatmap.Input().Ref().GetTypeAnn(); 
+    if (inputType->GetKind() == ETypeAnnotationKind::Optional) { 
+        // Optional not supported as CombineByKey input. 
+        return combine.Ptr(); 
+    } 
+ 
+    auto flatmapBody = flatmap.Lambda().Body(); 
+    if (!IsJustOrSingleAsList(flatmapBody.Ref())) { 
+        // Only push maps to PreMapLambda. 
+        return combine.Ptr(); 
+    } 
+ 
+    auto value = flatmapBody.Maybe<TCoJust>() 
+        ? flatmapBody.Cast<TCoJust>().Input() 
+        : flatmapBody.Cast<TCoAsList>().Arg(0); 
+ 
     auto ret = Build<TCoCombineByKey>(ctx, combine.Pos())
         .Input(flatmap.Input())
         .PreMapLambda()
             .Args({"item"})
-            .Body<TExprApplier>()
-                .Apply(combine.PreMapLambda().Body())
-                .With(combine.PreMapLambda().Args().Arg(0), value)
-                .With(flatmap.Lambda().Args().Arg(0), "item")
+            .Body<TExprApplier>() 
+                .Apply(combine.PreMapLambda().Body()) 
+                .With(combine.PreMapLambda().Args().Arg(0), value) 
+                .With(flatmap.Lambda().Args().Arg(0), "item") 
                 .Build()
             .Build()
         .KeySelectorLambda(combine.KeySelectorLambda())
@@ -2251,11 +2251,11 @@ void RegisterCoFlowCallables1(TCallableOptimizerMap& map) {
             auto flatmap = maybeFlatmap.Cast();
 
             TMaybe<THashSet<TStringBuf>> passthroughFields;
-            if (IsPassthroughFlatMap(flatmap, &passthroughFields)
-                && !IsTablePropsDependent(flatmap.Lambda().Body().Ref())
-                // SkipNullMembers doesn't support optional items
-                && flatmap.Lambda().Args().Arg(0).Ref().GetTypeAnn()->GetKind() != ETypeAnnotationKind::Optional)
-            {
+            if (IsPassthroughFlatMap(flatmap, &passthroughFields) 
+                && !IsTablePropsDependent(flatmap.Lambda().Body().Ref()) 
+                // SkipNullMembers doesn't support optional items 
+                && flatmap.Lambda().Args().Arg(0).Ref().GetTypeAnn()->GetKind() != ETypeAnnotationKind::Optional) 
+            { 
                 bool hasAllMembers = true;
                 if (passthroughFields) {
                     for (const auto& member : skipNullMembers.Members().Cast()) {
diff --git a/ydb/library/yql/core/common_opt/yql_co_flow2.cpp b/ydb/library/yql/core/common_opt/yql_co_flow2.cpp
index 88f9140031..1e4e3aaa64 100644
--- a/ydb/library/yql/core/common_opt/yql_co_flow2.cpp
+++ b/ydb/library/yql/core/common_opt/yql_co_flow2.cpp
@@ -17,10 +17,10 @@ using namespace NNodes;
 
 TExprNode::TPtr AggregateSubsetFieldsAnalyzer(const TCoAggregate& node, TExprContext& ctx, const TParentsMap& parentsMap) {
     auto inputType = node.Input().Ref().GetTypeAnn();
-    auto structType = inputType->GetKind() == ETypeAnnotationKind::List
-        ? inputType->Cast<TListExprType>()->GetItemType()->Cast<TStructExprType>()
-        : inputType->Cast<TStreamExprType>()->GetItemType()->Cast<TStructExprType>();
-
+    auto structType = inputType->GetKind() == ETypeAnnotationKind::List 
+        ? inputType->Cast<TListExprType>()->GetItemType()->Cast<TStructExprType>() 
+        : inputType->Cast<TStreamExprType>()->GetItemType()->Cast<TStructExprType>(); 
+ 
     if (structType->GetSize() == 0) {
         return node.Ptr();
     }
@@ -604,56 +604,56 @@ TExprNode::TPtr FlatMapOverEquiJoin(const TCoFlatMapBase& node, TExprContext& ct
 }
 
 TExprNode::TPtr FlatMapSubsetFields(const TCoFlatMapBase& node, TExprContext& ctx, const TParentsMap& parentsMap) {
-    auto it = parentsMap.find(node.Input().Raw());
-    YQL_ENSURE(it != parentsMap.cend());
-    auto inputParentsCount = it->second.size();
-
-    if (inputParentsCount > 1) {
-        return node.Ptr();
-    }
-
-    auto itemArg = node.Lambda().Args().Arg(0);
+    auto it = parentsMap.find(node.Input().Raw()); 
+    YQL_ENSURE(it != parentsMap.cend()); 
+    auto inputParentsCount = it->second.size(); 
+ 
+    if (inputParentsCount > 1) { 
+        return node.Ptr(); 
+    } 
+ 
+    auto itemArg = node.Lambda().Args().Arg(0); 
     auto itemType = itemArg.Ref().GetTypeAnn();
-    if (itemType->GetKind() != ETypeAnnotationKind::Struct) {
-        return node.Ptr();
-    }
-
-    auto itemStructType = itemType->Cast<TStructExprType>();
-    if (itemStructType->GetSize() == 0) {
-        return node.Ptr();
-    }
-
-    TSet<TStringBuf> usedFields;
-    if (!HaveFieldsSubset(node.Lambda().Body().Ptr(), itemArg.Ref(), usedFields, parentsMap)) {
-        return node.Ptr();
-    }
-
-    TExprNode::TListType fieldNodes;
-    for (auto& item : itemStructType->GetItems()) {
+    if (itemType->GetKind() != ETypeAnnotationKind::Struct) { 
+        return node.Ptr(); 
+    } 
+ 
+    auto itemStructType = itemType->Cast<TStructExprType>(); 
+    if (itemStructType->GetSize() == 0) { 
+        return node.Ptr(); 
+    } 
+ 
+    TSet<TStringBuf> usedFields; 
+    if (!HaveFieldsSubset(node.Lambda().Body().Ptr(), itemArg.Ref(), usedFields, parentsMap)) { 
+        return node.Ptr(); 
+    } 
+ 
+    TExprNode::TListType fieldNodes; 
+    for (auto& item : itemStructType->GetItems()) { 
         if (usedFields.contains(item->GetName())) {
-            fieldNodes.push_back(ctx.NewAtom(node.Pos(), item->GetName()));
-        }
-    }
-
+            fieldNodes.push_back(ctx.NewAtom(node.Pos(), item->GetName())); 
+        } 
+    } 
+ 
     return Build<TCoFlatMapBase>(ctx, node.Pos())
         .CallableName(node.Ref().Content())
         .Input<TCoExtractMembers>()
             .Input(node.Input())
             .Members()
                 .Add(fieldNodes)
-                .Build()
+                .Build() 
             .Build()
         .Lambda()
             .Args({"item"})
             .Body<TExprApplier>()
                 .Apply(node.Lambda())
                 .With(0, "item")
-                .Build()
+                .Build() 
             .Build()
         .Done()
         .Ptr();
-}
-
+} 
+ 
 TExprNode::TPtr RenameJoinTable(TPositionHandle pos, TExprNode::TPtr table,
     const THashMap<TString, TString>& upstreamTablesRename, TExprContext& ctx)
 {
@@ -1500,7 +1500,7 @@ TExprNode::TPtr PullUpFlatMapOverEquiJoin(const TExprNode::TPtr& node, TExprCont
     return ctx.NewCallable(node->Pos(), "FlatMap", { newEquiJoin, newLambda });
 }
 
-TExprNode::TPtr OptimizeFromFlow(const TExprNode::TPtr& node, TExprContext& ctx, TOptimizeContext& optCtx) {
+TExprNode::TPtr OptimizeFromFlow(const TExprNode::TPtr& node, TExprContext& ctx, TOptimizeContext& optCtx) { 
     if (!optCtx.IsSingleUsage(node->Head())) {
         return node;
     }
@@ -1511,16 +1511,16 @@ TExprNode::TPtr OptimizeFromFlow(const TExprNode::TPtr& node, TExprContext& ctx,
         return node->Head().HeadPtr();
     }
 
-    if (node->Head().IsCallable("ToFlow") &&
-        node->Head().Head().GetTypeAnn()->GetKind() == ETypeAnnotationKind::List) {
-        YQL_CLOG(DEBUG, Core) << "Replace  " << node->Content() << " with Iterator";
-
-        return Build<TCoIterator>(ctx, node->Pos())
-            .List(node->HeadPtr()->HeadPtr())
-            .Done()
-            .Ptr();
-    }
-
+    if (node->Head().IsCallable("ToFlow") && 
+        node->Head().Head().GetTypeAnn()->GetKind() == ETypeAnnotationKind::List) { 
+        YQL_CLOG(DEBUG, Core) << "Replace  " << node->Content() << " with Iterator"; 
+ 
+        return Build<TCoIterator>(ctx, node->Pos()) 
+            .List(node->HeadPtr()->HeadPtr()) 
+            .Done() 
+            .Ptr(); 
+    } 
+ 
     return node;
 }
 
@@ -1543,7 +1543,7 @@ TExprNode::TPtr OptimizeCollect(const TExprNode::TPtr& node, TExprContext& ctx,
 void RegisterCoFlowCallables2(TCallableOptimizerMap& map) {
     using namespace std::placeholders;
 
-    map["FromFlow"] = std::bind(&OptimizeFromFlow, _1, _2, _3);
+    map["FromFlow"] = std::bind(&OptimizeFromFlow, _1, _2, _3); 
     map["Collect"] = std::bind(&OptimizeCollect, _1, _2, _3);
 
     map["FlatMap"] = map["OrderedFlatMap"] = [](const TExprNode::TPtr& node, TExprContext& ctx, TOptimizeContext& optCtx) {
@@ -1675,12 +1675,12 @@ void RegisterCoFlowCallables2(TCallableOptimizerMap& map) {
             }
         }
 
-        auto ret = FlatMapSubsetFields(self, ctx, *optCtx.ParentsMap);
-        if (ret != node) {
+        auto ret = FlatMapSubsetFields(self, ctx, *optCtx.ParentsMap); 
+        if (ret != node) { 
             YQL_CLOG(DEBUG, Core) << node->Content() << "SubsetFields";
-            return ret;
-        }
-
+            return ret; 
+        } 
+ 
         return node;
     };
 
@@ -1820,7 +1820,7 @@ void RegisterCoFlowCallables2(TCallableOptimizerMap& map) {
     };
 
     map["ExtractMembers"] = [](const TExprNode::TPtr& node, TExprContext& ctx, TOptimizeContext& optCtx) {
-        TCoExtractMembers self(node);
+        TCoExtractMembers self(node); 
         if (!optCtx.IsSingleUsage(self.Input())) {
             return node;
         }
@@ -2200,7 +2200,7 @@ void RegisterCoFlowCallables2(TCallableOptimizerMap& map) {
     };
 
     map["Aggregate"] = [](const TExprNode::TPtr& node, TExprContext& ctx, TOptimizeContext& optCtx) {
-        TCoAggregate self(node);
+        TCoAggregate self(node); 
         if (!optCtx.IsSingleUsage(self.Input()) && !optCtx.IsPersistentNode(self.Input())) {
             return node;
         }
diff --git a/ydb/library/yql/core/common_opt/yql_co_transformer.cpp b/ydb/library/yql/core/common_opt/yql_co_transformer.cpp
index 8a98716eac..48ee45128d 100644
--- a/ydb/library/yql/core/common_opt/yql_co_transformer.cpp
+++ b/ydb/library/yql/core/common_opt/yql_co_transformer.cpp
@@ -17,15 +17,15 @@
 namespace NYql {
 namespace {
 
-class TCommonOptTransformer final : public TSyncTransformerBase {
+class TCommonOptTransformer final : public TSyncTransformerBase { 
 public:
     TCommonOptTransformer(TTypeAnnotationContext* typeCtx, bool final)
         : TypeCtx(typeCtx)
         , Final(final)
     {}
 
-    IGraphTransformer::TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final;
-    void Rewind() final;
+    IGraphTransformer::TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final; 
+    void Rewind() final; 
 private:
     IGraphTransformer::TStatus DoTransform(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx,
         const TCallableOptimizerMap& callables, TProcessedNodesSet& processedNodes,
@@ -38,13 +38,13 @@ private:
     TProcessedNodesSet SimpleProcessedNodes[TCoCallableRules::SIMPLE_STEPS];
     TProcessedNodesSet FlowProcessedNodes[TCoCallableRules::FLOW_STEPS];
     TProcessedNodesSet FinalProcessedNodes;
-    TTypeAnnotationContext* TypeCtx;
+    TTypeAnnotationContext* TypeCtx; 
     const bool Final;
 };
 
 }
 
-TAutoPtr<IGraphTransformer> CreateCommonOptTransformer(TTypeAnnotationContext* typeCtx) {
+TAutoPtr<IGraphTransformer> CreateCommonOptTransformer(TTypeAnnotationContext* typeCtx) { 
     return new TCommonOptTransformer(typeCtx, false);
 }
 
@@ -82,24 +82,24 @@ IGraphTransformer::TStatus TCommonOptTransformer::DoTransform(TExprNode::TPtr in
     return status;
 }
 
-void TCommonOptTransformer::Rewind() {
-    FinalProcessedNodes.clear();
-
-    for (auto& set : FlowProcessedNodes) {
-        set.clear();
-    }
-
-    for (auto& set : SimpleProcessedNodes) {
-        set.clear();
-    }
-}
-
+void TCommonOptTransformer::Rewind() { 
+    FinalProcessedNodes.clear(); 
+ 
+    for (auto& set : FlowProcessedNodes) { 
+        set.clear(); 
+    } 
+ 
+    for (auto& set : SimpleProcessedNodes) { 
+        set.clear(); 
+    } 
+} 
+ 
 IGraphTransformer::TStatus TCommonOptTransformer::DoTransform(
     const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx,
     const TCallableOptimizerMap& callables,
     TProcessedNodesSet& processedNodes, bool withParents)
 {
-    TOptimizeExprSettings settings(TypeCtx);
+    TOptimizeExprSettings settings(TypeCtx); 
     settings.ProcessedNodes = &processedNodes;
     settings.CustomInstantTypeTransformer = TypeCtx->CustomInstantTypeTransformer.Get();
     TParentsMap parentsMap;
@@ -157,7 +157,7 @@ IGraphTransformer::TStatus TCommonOptTransformer::DoTransform(const TExprNode::T
     );
 
     if (!toOptimize.empty()) {
-        TOptimizeExprSettings settings(TypeCtx);
+        TOptimizeExprSettings settings(TypeCtx); 
         settings.VisitTuples = true;
         settings.CustomInstantTypeTransformer = TypeCtx->CustomInstantTypeTransformer.Get();
         return RemapExpr(input, output, toOptimize, ctx, settings);
diff --git a/ydb/library/yql/core/common_opt/yql_co_transformer.h b/ydb/library/yql/core/common_opt/yql_co_transformer.h
index a2e8449e1e..5a33d41921 100644
--- a/ydb/library/yql/core/common_opt/yql_co_transformer.h
+++ b/ydb/library/yql/core/common_opt/yql_co_transformer.h
@@ -8,7 +8,7 @@
 
 namespace NYql {
 
-TAutoPtr<IGraphTransformer> CreateCommonOptTransformer(TTypeAnnotationContext* typeCtx);
+TAutoPtr<IGraphTransformer> CreateCommonOptTransformer(TTypeAnnotationContext* typeCtx); 
 TAutoPtr<IGraphTransformer> CreateCommonOptFinalTransformer(TTypeAnnotationContext* typeCtx);
 
 }
diff --git a/ydb/library/yql/core/expr_nodes/ya.make b/ydb/library/yql/core/expr_nodes/ya.make
index 5f919fa0e4..96186f5d2f 100644
--- a/ydb/library/yql/core/expr_nodes/ya.make
+++ b/ydb/library/yql/core/expr_nodes/ya.make
@@ -1,39 +1,39 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(
     spuchin
     g:yql
     g:yql_ydb_core
 )
-
-SRCS(
-    yql_expr_nodes.h
-    yql_expr_nodes.cpp
-)
-
-PEERDIR(
+ 
+SRCS( 
+    yql_expr_nodes.h 
+    yql_expr_nodes.cpp 
+) 
+ 
+PEERDIR( 
     ydb/library/yql/core/expr_nodes_gen
     ydb/library/yql/public/udf
     ydb/library/yql/core/issue
-)
-
+) 
+ 
 SRCDIR(ydb/library/yql/core/expr_nodes_gen)
-
-RUN_PROGRAM(
+ 
+RUN_PROGRAM( 
     ydb/library/yql/core/expr_nodes_gen/gen
-        yql_expr_nodes_gen.jnj
-        yql_expr_nodes.json
-        yql_expr_nodes.gen.h
-        yql_expr_nodes.decl.inl.h
-        yql_expr_nodes.defs.inl.h
-    IN yql_expr_nodes_gen.jnj
-    IN yql_expr_nodes.json
-    OUT yql_expr_nodes.gen.h
-    OUT yql_expr_nodes.decl.inl.h
-    OUT yql_expr_nodes.defs.inl.h
+        yql_expr_nodes_gen.jnj 
+        yql_expr_nodes.json 
+        yql_expr_nodes.gen.h 
+        yql_expr_nodes.decl.inl.h 
+        yql_expr_nodes.defs.inl.h 
+    IN yql_expr_nodes_gen.jnj 
+    IN yql_expr_nodes.json 
+    OUT yql_expr_nodes.gen.h 
+    OUT yql_expr_nodes.decl.inl.h 
+    OUT yql_expr_nodes.defs.inl.h 
     OUTPUT_INCLUDES
     ${ARCADIA_ROOT}/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.h
     ${ARCADIA_ROOT}/util/generic/hash_set.h
-)
-
-END()
+) 
+ 
+END() 
diff --git a/ydb/library/yql/core/expr_nodes/yql_expr_nodes.cpp b/ydb/library/yql/core/expr_nodes/yql_expr_nodes.cpp
index 4d61ced421..81f926308b 100644
--- a/ydb/library/yql/core/expr_nodes/yql_expr_nodes.cpp
+++ b/ydb/library/yql/core/expr_nodes/yql_expr_nodes.cpp
@@ -1 +1 @@
-#include "yql_expr_nodes.h"
+#include "yql_expr_nodes.h" 
diff --git a/ydb/library/yql/core/expr_nodes/yql_expr_nodes.h b/ydb/library/yql/core/expr_nodes/yql_expr_nodes.h
index 01cc777118..08dbbe4d6c 100644
--- a/ydb/library/yql/core/expr_nodes/yql_expr_nodes.h
+++ b/ydb/library/yql/core/expr_nodes/yql_expr_nodes.h
@@ -1,184 +1,184 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/core/issue/yql_issue.h>
 #include <ydb/library/yql/core/expr_nodes/yql_expr_nodes.gen.h>
-
-#include <util/generic/map.h>
-#include <util/string/cast.h>
-
-namespace NYql {
-namespace NNodes {
-
+ 
+#include <util/generic/map.h> 
+#include <util/string/cast.h> 
+ 
+namespace NYql { 
+namespace NNodes { 
+ 
 #include <ydb/library/yql/core/expr_nodes/yql_expr_nodes.decl.inl.h>
-
+ 
 class TCoAtom : public NGenerated::TCoAtomStub<TExprBase> {
-public:
+public: 
     explicit TCoAtom(const TExprNode* node)
         : TCoAtomStub(node) {}
 
     explicit TCoAtom(const TExprNode::TPtr& node)
         : TCoAtomStub(node) {}
-
+ 
     operator TStringBuf() const {
-        return Value();
-    }
-
-    TString StringValue() const {
-        return TString(Value());
-    }
-};
-
+        return Value(); 
+    } 
+ 
+    TString StringValue() const { 
+        return TString(Value()); 
+    } 
+}; 
+ 
 inline bool operator==(const TCoAtom& lhs, const TStringBuf& rhs) {
-    return lhs.Value() == rhs;
-}
-
+    return lhs.Value() == rhs; 
+} 
+ 
 class TCoArguments : public NGenerated::TCoArgumentsStub<TExprBase> {
-public:
+public: 
     explicit TCoArguments(const TExprNode* node)
         : TCoArgumentsStub(node) {}
 
     explicit TCoArguments(const TExprNode::TPtr& node)
         : TCoArgumentsStub(node) {}
-
+ 
     TCoArgument Arg(size_t index) const { return TCoArgument(Ref().ChildPtr(index)); }
     size_t Size() const { return Ref().ChildrenSize(); }
-
-    TChildIterator<TCoArgument> begin() const { return TChildIterator<TCoArgument>(*this); }
-    TChildIterator<TCoArgument> end() const { return TChildIterator<TCoArgument>(); }
-};
-
+ 
+    TChildIterator<TCoArgument> begin() const { return TChildIterator<TCoArgument>(*this); } 
+    TChildIterator<TCoArgument> end() const { return TChildIterator<TCoArgument>(); } 
+}; 
+ 
 #include <ydb/library/yql/core/expr_nodes/yql_expr_nodes.defs.inl.h>
-
-template<typename TParent>
+ 
+template<typename TParent> 
 class TNodeBuilder<TParent, TCoWorld> : public NGenerated::TCoWorldBuilder<TParent>
-{
-public:
+{ 
+public: 
     TNodeBuilder(TExprContext& ctx, TPositionHandle pos,
         typename NGenerated::TCoWorldBuilder<TParent>::BuildFuncType buildFunc,
         typename NGenerated::TCoWorldBuilder<TParent>::GetArgFuncType getArgFunc)
         : NGenerated::TCoWorldBuilder<TParent>(ctx, pos, buildFunc, getArgFunc) {}
-
+ 
     TCoWorld DoBuild() {
         auto node = this->Ctx.NewWorld(this->Pos);
         return TCoWorld(node);
-    }
-};
-
-template<typename TParent>
+    } 
+}; 
+ 
+template<typename TParent> 
 class TNodeBuilder<TParent, TCoArgument> : public NGenerated::TCoArgumentBuilder<TParent>
-{
-public:
+{ 
+public: 
     TNodeBuilder(TExprContext& ctx, TPositionHandle pos,
         typename NGenerated::TCoArgumentBuilder<TParent>::BuildFuncType buildFunc,
         typename NGenerated::TCoArgumentBuilder<TParent>::GetArgFuncType getArgFunc)
         : NGenerated::TCoArgumentBuilder<TParent>(ctx, pos, buildFunc, getArgFunc) {}
-
+ 
     TNodeBuilder<TParent, TCoArgument>& Name(const TStringBuf& value) {
-        this->NameHolder = this->Ctx.AppendString(value);
-        return *this;
-    }
-
+        this->NameHolder = this->Ctx.AppendString(value); 
+        return *this; 
+    } 
+ 
     TCoArgument DoBuild() {
         YQL_ENSURE(!NameHolder.empty());
         auto node = this->Ctx.NewArgument(this->Pos, NameHolder);
         return TCoArgument(node);
-    }
-
-private:
-    TStringBuf NameHolder;
-};
-
-template<typename TParent>
+    } 
+ 
+private: 
+    TStringBuf NameHolder; 
+}; 
+ 
+template<typename TParent> 
 class TNodeBuilder<TParent, TCoAtom> : public NGenerated::TCoAtomBuilder<TParent>
-{
-public:
+{ 
+public: 
     TNodeBuilder(TExprContext& ctx, TPositionHandle pos,
         typename NGenerated::TCoAtomBuilder<TParent>::BuildFuncType buildFunc,
         typename NGenerated::TCoAtomBuilder<TParent>::GetArgFuncType getArgFunc)
         : NGenerated::TCoAtomBuilder<TParent>(ctx, pos, buildFunc, getArgFunc) {}
-
+ 
     TNodeBuilder<TParent, TCoAtom>& Value(const TStringBuf& value, ui32 flags = TNodeFlags::ArbitraryContent) {
-        this->ValueHolder = this->Ctx.AppendString(value);
+        this->ValueHolder = this->Ctx.AppendString(value); 
         this->Flags = flags;
-        return *this;
-    }
-
+        return *this; 
+    } 
+ 
     TCoAtom DoBuild() {
         auto node = this->Ctx.NewAtom(this->Pos, ValueHolder, this->Flags);
         return TCoAtom(node);
-    }
-
+    } 
+ 
     TParent& Build() {
         return this->NGenerated::TCoAtomBuilder<TParent>::Build();
     }
 
     TParent& Build(const TStringBuf& value, ui32 flags = TNodeFlags::ArbitraryContent) {
-        this->ValueHolder = this->Ctx.AppendString(value);
+        this->ValueHolder = this->Ctx.AppendString(value); 
         this->Flags = flags;
-        return this->Build();
-    }
-
-    TParent& Build(i64 value) {
+        return this->Build(); 
+    } 
+ 
+    TParent& Build(i64 value) { 
         return Build(ToString(value), TNodeFlags::Default);
-    }
-
-private:
-    TStringBuf ValueHolder;
+    } 
+ 
+private: 
+    TStringBuf ValueHolder; 
     ui32 Flags = TNodeFlags::ArbitraryContent;
-};
-
-template<typename TParent>
+}; 
+ 
+template<typename TParent> 
 class TNodeBuilder<TParent, TCoLambda> : public NGenerated::TCoLambdaBuilder<TParent>
-{
-public:
+{ 
+public: 
     TNodeBuilder(TExprContext& ctx, TPositionHandle pos,
         typename NGenerated::TCoLambdaBuilder<TParent>::BuildFuncType buildFunc,
         typename NGenerated::TCoLambdaBuilder<TParent>::GetArgFuncType getArgFunc,
         std::shared_ptr<TMap<TStringBuf, TExprBase>> argsStore = std::make_shared<TMap<TStringBuf, TExprBase>>())
         : NGenerated::TCoLambdaBuilder<TParent>(ctx, pos, buildFunc, [argsStore, getArgFunc] (const TStringBuf& argName) {
             if (auto res = argsStore->FindPtr(argName)) {
-                return *res;
-            }
-
-            return getArgFunc(argName);
+                return *res; 
+            } 
+ 
+            return getArgFunc(argName); 
         })
         , ArgsMap(argsStore)
         {}
-
+ 
     TNodeBuilder<TParent, TCoLambda>& Args(const TCoArgument& node) {
-        Y_VERIFY_DEBUG(!this->ArgsHolder.IsValid());
-
+        Y_VERIFY_DEBUG(!this->ArgsHolder.IsValid()); 
+ 
         auto argsNode = this->Ctx.NewArguments(this->Pos, { node.Ptr() });
         this->ArgsHolder = TCoArguments(argsNode);
-
-        return *this;
-    }
-
+ 
+        return *this; 
+    } 
+ 
     TNodeBuilder<TParent, TCoLambda>& Args(const TCoArguments& node) {
         Y_VERIFY_DEBUG(!this->ArgsHolder.IsValid());
-
-        this->ArgsHolder = node;
-        return *this;
-    }
-
+ 
+        this->ArgsHolder = node; 
+        return *this; 
+    } 
+ 
     TNodeBuilder<TParent, TCoLambda>& Args(std::initializer_list<TStringBuf> list)
-    {
+    { 
         Y_VERIFY_DEBUG(!this->ArgsHolder.IsValid());
-
+ 
         TExprNode::TListType argNodes;
-        for (auto name : list) {
-            auto argName = this->Ctx.AppendString(name);
-            auto argNode = this->Ctx.NewArgument(this->Pos, argName);
+        for (auto name : list) { 
+            auto argName = this->Ctx.AppendString(name); 
+            auto argNode = this->Ctx.NewArgument(this->Pos, argName); 
             argNodes.push_back(argNode);
-
+ 
             ArgsMap->emplace(argName, TExprBase(argNode));
-        }
-
+        } 
+ 
         auto argsNode = this->Ctx.NewArguments(this->Pos, std::move(argNodes));
         this->ArgsHolder = TCoArguments(argsNode);
-        return *this;
-    }
-
+        return *this; 
+    } 
+ 
     TNodeBuilder<TParent, TCoLambda>& Args(const std::vector<TCoArgument>& list)
     {
         Y_VERIFY_DEBUG(!this->ArgsHolder.IsValid());
@@ -204,61 +204,61 @@ public:
 
     TCoLambda DoBuild() {
         auto node = this->Ctx.NewLambda(this->Pos, this->ArgsHolder.Cast().Ptr(), this->BodyHolder.Cast().Ptr());
-
+ 
         return TCoLambda(node);
-    }
-
-private:
+    } 
+ 
+private: 
     std::shared_ptr<TMap<TStringBuf, TExprBase>> ArgsMap;
-};
-
-class TExprApplier : public TExprBase {
-    friend class TMaybeNode<TExprApplier>;
-
-    template<typename TParent, typename TNode>
-    friend class TNodeBuilder;
-
+}; 
+ 
+class TExprApplier : public TExprBase { 
+    friend class TMaybeNode<TExprApplier>; 
+ 
+    template<typename TParent, typename TNode> 
+    friend class TNodeBuilder; 
+ 
     TExprApplier(const TExprNode::TPtr& node)
-        : TExprBase(node) {}
-
-    TExprApplier(const TExprBase node)
-        : TExprBase(node) {}
-};
-
-template<>
-class TMaybeNode<TExprApplier> : public TMaybeNode<TExprBase> {
-public:
-    TMaybeNode()
-        : TMaybeNode<TExprBase>() {}
-
-    TMaybeNode(const TExprNode* node)
-        : TMaybeNode<TExprBase>(node) {}
-
-    TMaybeNode(const TExprNode::TPtr& node)
-        : TMaybeNode<TExprBase>(node) {}
-
-    TExprApplier Cast() const {
-        return TExprApplier(TMaybeNode<TExprBase>::Cast());
-    }
-};
-
-template<typename TParent>
-class TNodeBuilder<TParent, TExprApplier> : TNodeBuilderBase
-{
-public:
-    typedef std::function<TParent& (const TExprApplier&)> BuildFuncType;
-    typedef std::function<TExprBase (const TStringBuf& arg)> GetArgFuncType;
-    typedef TExprApplier ResultType;
-
+        : TExprBase(node) {} 
+ 
+    TExprApplier(const TExprBase node) 
+        : TExprBase(node) {} 
+}; 
+ 
+template<> 
+class TMaybeNode<TExprApplier> : public TMaybeNode<TExprBase> { 
+public: 
+    TMaybeNode() 
+        : TMaybeNode<TExprBase>() {} 
+ 
+    TMaybeNode(const TExprNode* node) 
+        : TMaybeNode<TExprBase>(node) {} 
+ 
+    TMaybeNode(const TExprNode::TPtr& node) 
+        : TMaybeNode<TExprBase>(node) {} 
+ 
+    TExprApplier Cast() const { 
+        return TExprApplier(TMaybeNode<TExprBase>::Cast()); 
+    } 
+}; 
+ 
+template<typename TParent> 
+class TNodeBuilder<TParent, TExprApplier> : TNodeBuilderBase 
+{ 
+public: 
+    typedef std::function<TParent& (const TExprApplier&)> BuildFuncType; 
+    typedef std::function<TExprBase (const TStringBuf& arg)> GetArgFuncType; 
+    typedef TExprApplier ResultType; 
+ 
     TNodeBuilder(TExprContext& ctx, TPositionHandle pos, BuildFuncType buildFunc, GetArgFuncType getArgFunc)
-        : TNodeBuilderBase(ctx, pos, getArgFunc)
-        , BuildFunc(buildFunc) {}
-
-    TParent& Build() {
+        : TNodeBuilderBase(ctx, pos, getArgFunc) 
+        , BuildFunc(buildFunc) {} 
+ 
+    TParent& Build() { 
         YQL_ENSURE(Body);
         return BuildFunc(TExprApplier(Body.Cast().Ptr()));
-    }
-
+    } 
+ 
     typename TParent::ResultType Done() {
         TParent& parent = Build();
         return parent.Value();
@@ -266,68 +266,68 @@ public:
 
     TNodeBuilder<TParent, TExprApplier>& Apply(TCoLambda lambda) {
         YQL_ENSURE(!Body);
-
-        Body = lambda.Body();
-        Args = lambda.Args();
-
-        return *this;
-    }
-
-    TNodeBuilder<TParent, TExprApplier>& Apply(TExprBase node) {
+ 
+        Body = lambda.Body(); 
+        Args = lambda.Args(); 
+ 
+        return *this; 
+    } 
+ 
+    TNodeBuilder<TParent, TExprApplier>& Apply(TExprBase node) { 
         YQL_ENSURE(!Body);
-
-        Body = node;
-
-        return *this;
-    }
-
-    TNodeBuilder<TParent, TExprApplier>& With(TExprBase from, TExprBase to) {
+ 
+        Body = node; 
+ 
+        return *this; 
+    } 
+ 
+    TNodeBuilder<TParent, TExprApplier>& With(TExprBase from, TExprBase to) { 
         YQL_ENSURE(Body);
-
-        DoApply(from, to);
-
-        return *this;
-    }
-
-    TNodeBuilder<TParent, TExprApplier>& With(ui32 argIndex, TExprBase to) {
-        YQL_ENSURE(Body);
-        YQL_ENSURE(Args);
-
-        DoApply(Args.Cast().Arg(argIndex), to);
-        return *this;
-    }
-
-    TNodeBuilder<TParent, TExprApplier>& With(ui32 argIndex, const TStringBuf& argName) {
+ 
+        DoApply(from, to); 
+ 
+        return *this; 
+    } 
+ 
+    TNodeBuilder<TParent, TExprApplier>& With(ui32 argIndex, TExprBase to) { 
+        YQL_ENSURE(Body); 
+        YQL_ENSURE(Args); 
+ 
+        DoApply(Args.Cast().Arg(argIndex), to); 
+        return *this; 
+    } 
+ 
+    TNodeBuilder<TParent, TExprApplier>& With(ui32 argIndex, const TStringBuf& argName) { 
         YQL_ENSURE(Body);
         YQL_ENSURE(Args);
-
-        DoApply(Args.Cast().Arg(argIndex), GetArgFunc(argName));
-
-        return *this;
-    }
-
-    TNodeBuilder<TParent, TExprApplier>& With(TExprBase from, const TStringBuf& argName) {
-        YQL_ENSURE(Body);
-
-        DoApply(from, GetArgFunc(argName));
-
-        return *this;
-    }
-
-    template<typename TNode>
-    TNodeBuilder<TNodeBuilder<TParent, TExprApplier>, TNode> With(ui32 argIndex) {
+ 
+        DoApply(Args.Cast().Arg(argIndex), GetArgFunc(argName)); 
+ 
+        return *this; 
+    } 
+ 
+    TNodeBuilder<TParent, TExprApplier>& With(TExprBase from, const TStringBuf& argName) { 
+        YQL_ENSURE(Body); 
+ 
+        DoApply(from, GetArgFunc(argName)); 
+ 
+        return *this; 
+    } 
+ 
+    template<typename TNode> 
+    TNodeBuilder<TNodeBuilder<TParent, TExprApplier>, TNode> With(ui32 argIndex) { 
         YQL_ENSURE(Body);
         YQL_ENSURE(Args);
-
-        auto buildFunc = [argIndex, this] (const TNode& node) mutable -> TNodeBuilder<TParent, TExprApplier>& {
-            DoApply(Args.Cast().Arg(argIndex), node);
-            return *this;
-        };
-
-        return TNodeBuilder<TNodeBuilder<TParent, TExprApplier>, TNode>(this->Ctx, this->Pos,
-            buildFunc, GetArgFunc);
-    }
-
+ 
+        auto buildFunc = [argIndex, this] (const TNode& node) mutable -> TNodeBuilder<TParent, TExprApplier>& { 
+            DoApply(Args.Cast().Arg(argIndex), node); 
+            return *this; 
+        }; 
+ 
+        return TNodeBuilder<TNodeBuilder<TParent, TExprApplier>, TNode>(this->Ctx, this->Pos, 
+            buildFunc, GetArgFunc); 
+    } 
+ 
     template<typename TNode>
     TNodeBuilder<TNodeBuilder<TParent, TExprApplier>, TNode> With(TExprBase from) {
         YQL_ENSURE(Body);
@@ -341,26 +341,26 @@ public:
             buildFunc, GetArgFunc);
     }
 
-private:
-    void DoApply(TExprBase applyFrom, TExprBase applyTo) {
-        TExprNodeBuilder builder(this->Pos, this->Ctx, [this] (const TStringBuf& argName) {
+private: 
+    void DoApply(TExprBase applyFrom, TExprBase applyTo) { 
+        TExprNodeBuilder builder(this->Pos, this->Ctx, [this] (const TStringBuf& argName) { 
             return GetArgFunc(argName).Ptr();
-        });
-
+        }); 
+ 
         auto args = Args.IsValid() ? Args.Cast().Ptr() : nullptr;
-
-        Body = builder
+ 
+        Body = builder 
             .ApplyPartial(std::move(args), Body.Cast().Ptr())
             .WithNode(applyFrom.Ref(), applyTo.Ptr())
-            .Seal().Build();
-    }
-
-private:
-    BuildFuncType BuildFunc;
-
-    TMaybeNode<TExprBase> Body;
+            .Seal().Build(); 
+    } 
+ 
+private: 
+    BuildFuncType BuildFunc; 
+ 
+    TMaybeNode<TExprBase> Body; 
     TMaybeNode<TCoArguments> Args;
-};
-
-} // namespace NNodes
-} // namespace NYql
+}; 
+ 
+} // namespace NNodes 
+} // namespace NYql 
diff --git a/ydb/library/yql/core/expr_nodes/yql_expr_nodes.json b/ydb/library/yql/core/expr_nodes/yql_expr_nodes.json
index edfcaa1530..bcc6214334 100644
--- a/ydb/library/yql/core/expr_nodes/yql_expr_nodes.json
+++ b/ydb/library/yql/core/expr_nodes/yql_expr_nodes.json
@@ -1,36 +1,36 @@
-{
-    "NodeRootType": "TExprBase",
-    "NodeBuilderBase": "TNodeBuilderBase",
-    "ListBuilderBase": "TListBuilderBase",
-    "FreeArgCallableBase": "TFreeArgCallable",
-    "FreeArgBuilderBase": "TFreeArgCallableBuilderBase",
-    "Nodes": [
-        {
-            "Name": "TExprList",
-            "ListBase": "TExprBase"
-        },
-        {
+{ 
+    "NodeRootType": "TExprBase", 
+    "NodeBuilderBase": "TNodeBuilderBase", 
+    "ListBuilderBase": "TListBuilderBase", 
+    "FreeArgCallableBase": "TFreeArgCallable", 
+    "FreeArgBuilderBase": "TFreeArgCallableBuilderBase", 
+    "Nodes": [ 
+        { 
+            "Name": "TExprList", 
+            "ListBase": "TExprBase" 
+        }, 
+        { 
             "Name": "TCoAtom",
-            "Base": "TExprBase",
-            "Definition": "Custom",
-            "Match": {"Type": "NodeType", "TypeName": "Atom"},
+            "Base": "TExprBase", 
+            "Definition": "Custom", 
+            "Match": {"Type": "NodeType", "TypeName": "Atom"}, 
             "Content": {"Name": "Value", "Type": "TStringBuf"},
-            "Builder": {"Generate": "Custom"}
-        },
-        {
+            "Builder": {"Generate": "Custom"} 
+        }, 
+        { 
             "Name": "TCoAtomList",
             "ListBase": "TCoAtom"
-        },
-        {
+        }, 
+        { 
             "Name": "TCoNameValueTuple",
-            "Base": "TExprBase",
-            "Match": {"Type": "Tuple"},
-            "Children": [
+            "Base": "TExprBase", 
+            "Match": {"Type": "Tuple"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Name", "Type": "TCoAtom"},
                 {"Index": 1, "Name": "Value", "Type": "TExprBase", "Optional": true}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoIndex",
             "Base": "TExprBase",
             "Match": {"Type": "Tuple"},
@@ -48,8 +48,8 @@
         {
             "Name": "TCoNameValueTupleList",
             "ListBase": "TCoNameValueTuple"
-        },
-        {
+        }, 
+        { 
             "Name": "TCoChangefeed",
             "Base": "TExprBase",
             "Match": {"Type": "Tuple"},
@@ -65,35 +65,35 @@
         },
         {
             "Name": "TCoWorld",
-            "Base": "TExprBase",
-            "Match": {"Type": "NodeType", "TypeName": "World"},
-            "Builder": {"Generate": "Custom"}
-        },
-        {
+            "Base": "TExprBase", 
+            "Match": {"Type": "NodeType", "TypeName": "World"}, 
+            "Builder": {"Generate": "Custom"} 
+        }, 
+        { 
             "Name": "TCoArgument",
-            "Base": "TExprBase",
-            "Match": {"Type": "NodeType", "TypeName": "Argument"},
+            "Base": "TExprBase", 
+            "Match": {"Type": "NodeType", "TypeName": "Argument"}, 
             "Content": {"Name": "Name", "Type": "TStringBuf"},
-            "Builder": {"Generate": "Custom"}
-        },
-        {
+            "Builder": {"Generate": "Custom"} 
+        }, 
+        { 
             "Name": "TCoArguments",
-            "Base": "TExprBase",
-            "Definition": "Custom",
-            "Match": {"Type": "NodeType", "TypeName": "Arguments"},
-            "Builder": {"Generate": "None"}
-        },
-        {
+            "Base": "TExprBase", 
+            "Definition": "Custom", 
+            "Match": {"Type": "NodeType", "TypeName": "Arguments"}, 
+            "Builder": {"Generate": "None"} 
+        }, 
+        { 
             "Name": "TCoLambda",
-            "Base": "TExprBase",
-            "Match": {"Type": "NodeType", "TypeName": "Lambda"},
-            "Builder": {"Generate": "Custom"},
-            "Children": [
+            "Base": "TExprBase", 
+            "Match": {"Type": "NodeType", "TypeName": "Lambda"}, 
+            "Builder": {"Generate": "Custom"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Args", "Type": "TCoArguments"},
-                {"Index": 1, "Name": "Body", "Type": "TExprBase"}
-            ]
-        },
-        {
+                {"Index": 1, "Name": "Body", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoInputBase",
             "Base": "TCallable",
             "Match": {"Type": "CallableBase"},
@@ -104,23 +104,23 @@
         },
         {
             "Name": "TCoApply",
-            "Base": "TFreeArgCallable",
-            "Match": {"Type": "Callable", "Name": "Apply"},
-            "Children": [
-                {"Index": 0, "Name": "Callable", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TFreeArgCallable", 
+            "Match": {"Type": "Callable", "Name": "Apply"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Callable", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoRight",
             "Base": "TCoInputBase",
             "Match": {"Type": "Callable", "Name": "Right!"}
-        },
-        {
+        }, 
+        { 
             "Name": "TCoLeft",
             "Base": "TCoInputBase",
             "Match": {"Type": "Callable", "Name": "Left!"}
-        },
-        {
+        }, 
+        { 
             "Name": "TCoCons",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "Cons!"},
@@ -131,13 +131,13 @@
         },
         {
             "Name": "TCoTypeOf",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "TypeOf"},
-            "Children": [
-                {"Index": 0, "Name": "Value", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "TypeOf"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Value", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoImplicitEquals",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "ImplicitEquals"},
@@ -148,18 +148,18 @@
         },
         {
             "Name": "TCoNothing",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Nothing"},
-            "Children": [
-                {"Index": 0, "Name": "OptionalType", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Nothing"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "OptionalType", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoVoid",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Void"}
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Void"} 
+        }, 
+        { 
             "Name": "TCoNull",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "Null"}
@@ -168,11 +168,11 @@
             "Name": "TCoMapBase",
             "Base": "TCoInputBase",
             "Match": {"Type": "CallableBase"},
-            "Children": [
+            "Children": [ 
                 {"Index": 1, "Name": "Lambda", "Type": "TCoLambda"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoMap",
             "Base": "TCoMapBase",
             "Match": {"Type": "Callable", "Name": "Map"}
@@ -221,12 +221,12 @@
             "Name": "TCoFilterBase",
             "Base": "TCoInputBase",
             "Match": {"Type": "CallableBase"},
-            "Children": [
+            "Children": [ 
                 {"Index": 1, "Name": "Lambda", "Type": "TCoLambda"},
                 {"Index": 2, "Name": "Limit", "Type": "TExprBase", "Optional": true}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoFilter",
             "Base": "TCoFilterBase",
             "Match": {"Type": "Callable", "Name": "Filter"}
@@ -246,11 +246,11 @@
             "Base": "TCoInputBase",
             "Match": {"Type": "CallableBase"},
             "Builder": {"Generate": "None"},
-            "Children": [
+            "Children": [ 
                 {"Index": 1, "Name": "Members", "Type": "TCoAtomList", "Optional": true}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoFilterNullMembers",
             "Base": "TCoFilterNullMembersBase",
             "Match": {"Type": "Callable", "Name": "FilterNullMembers"}
@@ -305,11 +305,11 @@
             "Name": "TCoFlatMapBase",
             "Base": "TCoInputBase",
             "Match": {"Type": "CallableBase"},
-            "Children": [
+            "Children": [ 
                 {"Index": 1, "Name": "Lambda", "Type": "TCoLambda"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoFlatMap",
             "Base": "TCoFlatMapBase",
             "Match": {"Type": "Callable", "Name": "FlatMap"}
@@ -369,56 +369,56 @@
         },
         {
             "Name": "TCoConditionalValueBase",
-            "Base": "TCallable",
-            "Match": {"Type": "CallableBase"},
-            "Children": [
-                {"Index": 0, "Name": "Predicate", "Type": "TExprBase"},
-                {"Index": 1, "Name": "Value", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "CallableBase"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Predicate", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "Value", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoOptionalIf",
             "Base": "TCoConditionalValueBase",
-            "Match": {"Type": "Callable", "Name": "OptionalIf"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "OptionalIf"} 
+        }, 
+        { 
             "Name": "TCoFlatOptionalIf",
             "Base": "TCoConditionalValueBase",
-            "Match": {"Type": "Callable", "Name": "FlatOptionalIf"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "FlatOptionalIf"} 
+        }, 
+        { 
             "Name": "TCoListIf",
             "Base": "TCoConditionalValueBase",
-            "Match": {"Type": "Callable", "Name": "ListIf"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "ListIf"} 
+        }, 
+        { 
             "Name": "TCoFlatListIf",
             "Base": "TCoConditionalValueBase",
-            "Match": {"Type": "Callable", "Name": "FlatListIf"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "FlatListIf"} 
+        }, 
+        { 
             "Name": "TCoJust",
             "Base": "TCoInputBase",
             "Match": {"Type": "Callable", "Name": "Just"}
-        },
-        {
+        }, 
+        { 
             "Name": "TCoCombineByKey",
             "Base": "TCoInputBase",
             "Match": {"Type": "Callable", "Name": "CombineByKey"},
-            "Children": [
+            "Children": [ 
                 {"Index": 1, "Name": "PreMapLambda",        "Type": "TCoLambda"},
                 {"Index": 2, "Name": "KeySelectorLambda",   "Type": "TCoLambda"},
                 {"Index": 3, "Name": "InitHandlerLambda",   "Type": "TCoLambda"},
                 {"Index": 4, "Name": "UpdateHandlerLambda", "Type": "TCoLambda"},
                 {"Index": 5, "Name": "FinishHandlerLambda", "Type": "TCoLambda"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoMin",
             "VarArgBase": "TExprBase",
-            "Match": {"Type": "Callable", "Name": "Min"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Min"} 
+        }, 
+        { 
             "Name": "TCoMax",
             "VarArgBase": "TExprBase",
             "Match": {"Type": "Callable", "Name": "Max"}
@@ -428,11 +428,11 @@
             "Base": "TCoInputBase",
             "Match": {"Type": "CallableBase"},
             "Builder": {"Generate": "None"},
-            "Children": [
-                {"Index": 1, "Name": "Count", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Children": [ 
+                {"Index": 1, "Name": "Count", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoTake",
             "Base": "TCoCountBase",
             "Match": {"Type": "Callable", "Name": "Take"}
@@ -446,17 +446,17 @@
             "Name": "TCoSkip",
             "Base": "TCoCountBase",
             "Match": {"Type": "Callable", "Name": "Skip"}
-        },
-        {
+        }, 
+        { 
             "Name": "TCoAppend",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Append"},
-            "Children": [
-                {"Index": 0, "Name": "List", "Type": "TExprBase"},
-                {"Index": 1, "Name": "Item", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Append"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "List", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "Item", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoExtendBase",
             "VarArgBase": "TExprBase",
             "Match": {"Type": "CallableBase"}
@@ -464,9 +464,9 @@
         {
             "Name": "TCoExtend",
             "Base": "TCoExtendBase",
-            "Match": {"Type": "Callable", "Name": "Extend"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Extend"} 
+        }, 
+        { 
             "Name": "TCoOrderedExtend",
             "Base": "TCoExtendBase",
             "Match": {"Type": "Callable", "Name": "OrderedExtend"}
@@ -493,13 +493,13 @@
         },
         {
             "Name": "TCoHasItems",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "HasItems"},
-            "Children": [
-                {"Index": 0, "Name": "List", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "HasItems"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "List", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoLength",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "Length"},
@@ -574,10 +574,10 @@
         },
         {
             "Name": "TCoAggregationTraits",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "AggregationTraits"},
-            "Children": [
-                {"Index": 0, "Name": "ItemType",      "Type": "TExprBase"},
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "AggregationTraits"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "ItemType",      "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "InitHandler",   "Type": "TCoLambda"},
                 {"Index": 2, "Name": "UpdateHandler", "Type": "TCoLambda"},
                 {"Index": 3, "Name": "SaveHandler",   "Type": "TCoLambda"},
@@ -585,23 +585,23 @@
                 {"Index": 5, "Name": "MergeHandler",  "Type": "TCoLambda"},
                 {"Index": 6, "Name": "FinishHandler", "Type": "TCoLambda"},
                 {"Index": 7, "Name": "DefVal",        "Type": "TExprBase"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoAggregateTuple",
-            "Base": "TExprBase",
-            "Match": {"Type": "Tuple"},
-            "Children": [
-                {"Index": 0, "Name": "ColumnName",   "Type": "TExprBase"},
+            "Base": "TExprBase", 
+            "Match": {"Type": "Tuple"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "ColumnName",   "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "Trait",        "Type": "TCoAggregationTraits"},
                 {"Index": 2, "Name": "DistinctName", "Type": "TCoAtom", "Optional": true}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoAggregateTupleList",
             "ListBase": "TCoAggregateTuple"
-        },
-        {
+        }, 
+        { 
             "Name": "TCoAggregate",
             "Base": "TCoInputBase",
             "Match": {"Type": "Callable", "Name": "Aggregate"},
@@ -610,17 +610,17 @@
                 {"Index": 2, "Name": "Handlers",  "Type": "TCoAggregateTupleList"},
                 {"Index": 3, "Name": "Settings",  "Type": "TCoNameValueTupleList"}
             ]
-        },
-        {
+        }, 
+        { 
             "Name": "TCoFold1",
             "Base": "TCoInputBase",
-            "Match": {"Type": "Callable", "Name": "Fold1"},
-            "Children": [
+            "Match": {"Type": "Callable", "Name": "Fold1"}, 
+            "Children": [ 
                 {"Index": 1, "Name": "InitHandler",   "Type": "TCoLambda"},
                 {"Index": 2, "Name": "UpdateHandler", "Type": "TCoLambda"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoChain1Map",
             "Base": "TCoInputBase",
             "Match": {"Type": "Callable", "Name": "Chain1Map"},
@@ -632,9 +632,9 @@
         {
             "Name": "TCoZip",
             "VarArgBase": "TExprBase",
-            "Match": {"Type": "Callable", "Name": "Zip"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Zip"} 
+        }, 
+        { 
             "Name": "TCoZipAll",
             "VarArgBase": "TExprBase",
             "Match": {"Type": "Callable", "Name": "ZipAll"}
@@ -642,56 +642,56 @@
         {
             "Name": "TCoSync",
             "VarArgBase": "TExprBase",
-            "Match": {"Type": "Callable", "Name": "Sync!"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Sync!"} 
+        }, 
+        { 
             "Name": "TCoDataSource",
-            "Base": "TFreeArgCallable",
-            "Match": {"Type": "Callable", "Name": "DataSource"},
-            "Children": [
+            "Base": "TFreeArgCallable", 
+            "Match": {"Type": "Callable", "Name": "DataSource"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Category", "Type": "TCoAtom"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoDataSink",
-            "Base": "TFreeArgCallable",
-            "Match": {"Type": "Callable", "Name": "DataSink"},
-            "Children": [
+            "Base": "TFreeArgCallable", 
+            "Match": {"Type": "Callable", "Name": "DataSink"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Category", "Type": "TCoAtom"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoCommit",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Commit!"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
-                {"Index": 1, "Name": "DataSink", "Type": "TExprBase"},
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Commit!"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "DataSink", "Type": "TExprBase"}, 
                 {"Index": 2, "Name": "Settings", "Type": "TCoNameValueTupleList", "Optional": true}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoWrite",
-            "Base": "TFreeArgCallable",
-            "Match": {"Type": "Callable", "Name": "Write!"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
+            "Base": "TFreeArgCallable", 
+            "Match": {"Type": "Callable", "Name": "Write!"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "DataSink", "Type": "TCoDataSink"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoKey",
             "VarArgBase": "TExprBase",
-            "Match": {"Type": "Callable", "Name": "Key"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Key"} 
+        }, 
+        { 
             "Name": "TCoRead",
-            "Base": "TFreeArgCallable",
-            "Match": {"Type": "Callable", "Name": "Read!"},
-            "Children": [
-                {"Index": 0, "Name": "World", "Type": "TExprBase"},
+            "Base": "TFreeArgCallable", 
+            "Match": {"Type": "Callable", "Name": "Read!"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "World", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "DataSource", "Type": "TCoDataSource"}
-            ]
+            ] 
         },
         {
             "Name": "TCoConfigure",
@@ -704,50 +704,50 @@
         },
         {
             "Name": "TCoDataType",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "DataType"},
-            "Children": [
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "DataType"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Type", "Type": "TCoAtom"},
                 {"Index": 1, "Name": "ParamOne", "Type": "TCoAtom", "Optional": true},
                 {"Index": 2, "Name": "ParamTwo",  "Type": "TCoAtom", "Optional": true}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoTaggedType",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "TaggedType"},
-            "Children": [
-                {"Index": 0, "Name": "Type", "Type": "TExprBase"},
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "TaggedType"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Type", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "Tag", "Type": "TCoAtom"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoListType",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "ListType"},
-            "Children": [
-                {"Index": 0, "Name": "ItemType", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "ListType"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "ItemType", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoStructType",
             "VarArgBase": "TExprBase",
             "Match": {"Type": "Callable", "Name": "StructType"}
         },
         {
             "Name": "TCoOptionalType",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "OptionalType"},
-            "Children": [
-                {"Index": 0, "Name": "ItemType", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "OptionalType"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "ItemType", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoVoidType",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "VoidType"}
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "VoidType"} 
+        }, 
+        { 
             "Name": "TCoTupleType",
             "VarArgBase": "TExprBase",
             "Match": {"Type": "Callable", "Name": "TupleType"}
@@ -762,25 +762,25 @@
         },
         {
             "Name": "TCoDataCtor",
-            "Base": "TCallable",
-            "Match": {"Type": "CallableBase"},
-            "Builder": {"Generate": "None"},
-            "Children": [
+            "Base": "TCallable", 
+            "Match": {"Type": "CallableBase"}, 
+            "Builder": {"Generate": "None"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Literal", "Type": "TCoAtom"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoIntegralCtor",
             "Base": "TCoDataCtor",
-            "Match": {"Type": "CallableBase"},
-            "Builder": {"Generate": "None"}
-        },
-        {
+            "Match": {"Type": "CallableBase"}, 
+            "Builder": {"Generate": "None"} 
+        }, 
+        { 
             "Name": "TCoUint8",
             "Base": "TCoIntegralCtor",
             "Match": {"Type": "Callable", "Name": "Uint8"}
-        },
-        {
+        }, 
+        { 
             "Name": "TCoInt8",
             "Base": "TCoIntegralCtor",
             "Match": {"Type": "Callable", "Name": "Int8"}
@@ -798,24 +798,24 @@
         {
             "Name": "TCoInt32",
             "Base": "TCoIntegralCtor",
-            "Match": {"Type": "Callable", "Name": "Int32"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Int32"} 
+        }, 
+        { 
             "Name": "TCoUint32",
             "Base": "TCoIntegralCtor",
-            "Match": {"Type": "Callable", "Name": "Uint32"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Uint32"} 
+        }, 
+        { 
             "Name": "TCoInt64",
             "Base": "TCoIntegralCtor",
-            "Match": {"Type": "Callable", "Name": "Int64"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Int64"} 
+        }, 
+        { 
             "Name": "TCoUint64",
             "Base": "TCoIntegralCtor",
-            "Match": {"Type": "Callable", "Name": "Uint64"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Uint64"} 
+        }, 
+        { 
             "Name": "TCoFloat",
             "Base": "TCoDataCtor",
             "Match": {"Type": "Callable", "Name": "Float"}
@@ -828,14 +828,14 @@
         {
             "Name": "TCoString",
             "Base": "TCoDataCtor",
-            "Match": {"Type": "Callable", "Name": "String"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "String"} 
+        }, 
+        { 
             "Name": "TCoUtf8",
             "Base": "TCoDataCtor",
-            "Match": {"Type": "Callable", "Name": "Utf8"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Utf8"} 
+        }, 
+        { 
             "Name": "TCoYson",
             "Base": "TCoDataCtor",
             "Match": {"Type": "Callable", "Name": "Yson"}
@@ -848,9 +848,9 @@
         {
             "Name": "TCoBool",
             "Base": "TCoDataCtor",
-            "Match": {"Type": "Callable", "Name": "Bool"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Bool"} 
+        }, 
+        { 
             "Name": "TCoDateBase",
             "Base": "TCoDataCtor",
             "Match": {"Type": "CallableBase"},
@@ -914,54 +914,54 @@
         {
             "Name": "TCoAsList",
             "VarArgBase": "TExprBase",
-            "Match": {"Type": "Callable", "Name": "AsList"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "AsList"} 
+        }, 
+        { 
             "Name": "TCoToList",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "ToList"},
-            "Children": [
-                {"Index": 0, "Name": "Optional", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "ToList"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Optional", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoToOptional",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "ToOptional"},
-            "Children": [
-                {"Index": 0, "Name": "List", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "ToOptional"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "List", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoList",
             "Base": "TFreeArgCallable",
-            "Match": {"Type": "Callable", "Name": "List"},
-            "Children": [
-                {"Index": 0, "Name": "ListType", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "List"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "ListType", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoAsStruct",
             "VarArgBase": "TExprList",
-            "Match": {"Type": "Callable", "Name": "AsStruct"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "AsStruct"} 
+        }, 
+        { 
             "Name": "TCoAsDict",
             "Base": "TFreeArgCallable",
             "Match": {"Type": "Callable", "Name": "AsDict"}
         },
         {
             "Name": "TCoToDict",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "ToDict"},
-            "Children": [
-                {"Index": 0, "Name": "List", "Type": "TExprBase"},
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "ToDict"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "List", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "KeySelector", "Type": "TCoLambda"},
                 {"Index": 2, "Name": "PayloadSelector", "Type": "TCoLambda"},
                 {"Index": 3, "Name": "Settings", "Type": "TCoAtomList"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoDictFromKeys",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "DictFromKeys"},
@@ -969,8 +969,8 @@
                 {"Index": 0, "Name": "Type", "Type": "TExprBase"},
                 {"Index": 1, "Name": "Keys", "Type": "TExprList"}
             ]
-        },
-        {
+        }, 
+        { 
             "Name": "TCoSqueezeToDict",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "SqueezeToDict"},
@@ -1007,24 +1007,24 @@
             ]
         },
         {
-            "Name": "TCoDictItems",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "DictItems"},
-            "Children": [
-                {"Index": 0, "Name": "Dict", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Name": "TCoDictItems", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "DictItems"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Dict", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoLookupBase",
-            "Base": "TCallable",
+            "Base": "TCallable", 
             "Match": {"Type": "CallableBase"},
             "Builder": {"Generate": "None"},
-            "Children": [
+            "Children": [ 
                 {"Index": 0, "Name": "Collection", "Type": "TExprBase"},
-                {"Index": 1, "Name": "Lookup", "Type": "TExprBase"}
-            ]
-        },
-        {
+                {"Index": 1, "Name": "Lookup", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoContains",
             "Base": "TCoLookupBase",
             "Match": {"Type": "Callable", "Name": "Contains"}
@@ -1041,66 +1041,66 @@
             "Name": "TCoLookup",
             "Base": "TCoLookupBase",
             "Match": {"Type": "Callable", "Name": "Lookup"}
-        },
-        {
+        }, 
+        { 
             "Name": "TCoMember",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Member"},
-            "Children": [
-                {"Index": 0, "Name": "Struct", "Type": "TExprBase"},
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Member"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Struct", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "Name", "Type": "TCoAtom"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoNth",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Nth"},
-            "Children": [
-                {"Index": 0, "Name": "Tuple", "Type": "TExprBase"},
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Nth"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Tuple", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "Index", "Type": "TCoAtom"}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoCompare",
-            "Base": "TCallable",
-            "Match": {"Type": "CallableBase"},
-            "Builder": {"Generate": "None"},
-            "Children": [
-                {"Index": 0, "Name": "Left", "Type": "TExprBase"},
-                {"Index": 1, "Name": "Right", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "CallableBase"}, 
+            "Builder": {"Generate": "None"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Left", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "Right", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoCmpLess",
             "Base": "TCoCompare",
-            "Match": {"Type": "Callable", "Name": "<"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "<"} 
+        }, 
+        { 
             "Name": "TCoCmpLessOrEqual",
             "Base": "TCoCompare",
-            "Match": {"Type": "Callable", "Name": "<="}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "<="} 
+        }, 
+        { 
             "Name": "TCoCmpGreater",
             "Base": "TCoCompare",
-            "Match": {"Type": "Callable", "Name": ">"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": ">"} 
+        }, 
+        { 
             "Name": "TCoCmpGreaterOrEqual",
             "Base": "TCoCompare",
-            "Match": {"Type": "Callable", "Name": ">="}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": ">="} 
+        }, 
+        { 
             "Name": "TCoCmpEqual",
             "Base": "TCoCompare",
-            "Match": {"Type": "Callable", "Name": "=="}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "=="} 
+        }, 
+        { 
             "Name": "TCoCmpNotEqual",
             "Base": "TCoCompare",
-            "Match": {"Type": "Callable", "Name": "!="}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "!="} 
+        }, 
+        { 
             "Name": "TCoAggrEqual",
             "Base": "TCoCompare",
             "Match": {"Type": "Callable", "Name": "AggrEquals"}
@@ -1138,23 +1138,23 @@
         },
         {
             "Name": "TCoNot",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Not"},
-            "Children": [
-                {"Index": 0, "Name": "Value", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Not"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Value", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoAnd",
             "VarArgBase": "TExprBase",
-            "Match": {"Type": "Callable", "Name": "And"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "And"} 
+        }, 
+        { 
             "Name": "TCoOr",
             "VarArgBase": "TExprBase",
-            "Match": {"Type": "Callable", "Name": "Or"}
-        },
-        {
+            "Match": {"Type": "Callable", "Name": "Or"} 
+        }, 
+        { 
             "Name": "TCoXor",
             "VarArgBase": "TExprBase",
             "Match": {"Type": "Callable", "Name": "Xor"}
@@ -1185,50 +1185,50 @@
             "Match": {"Type": "Callable", "Name": "+"}
         },
         {
-            "Name": "TCoMul",
-            "Base": "TCoBinaryArithmetic",
-            "Match": {"Type": "Callable", "Name": "*"}
-        },
-        {
-            "Name": "TCoDiv",
-            "Base": "TCoBinaryArithmetic",
-            "Match": {"Type": "Callable", "Name": "/"}
-        },
-        {
-            "Name": "TCoMod",
-            "Base": "TCoBinaryArithmetic",
-            "Match": {"Type": "Callable", "Name": "%"}
-        },
-        {
+            "Name": "TCoMul", 
+            "Base": "TCoBinaryArithmetic", 
+            "Match": {"Type": "Callable", "Name": "*"} 
+        }, 
+        { 
+            "Name": "TCoDiv", 
+            "Base": "TCoBinaryArithmetic", 
+            "Match": {"Type": "Callable", "Name": "/"} 
+        }, 
+        { 
+            "Name": "TCoMod", 
+            "Base": "TCoBinaryArithmetic", 
+            "Match": {"Type": "Callable", "Name": "%"} 
+        }, 
+        { 
             "Name": "TCoCoalesce",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Coalesce"},
-            "Children": [
-                {"Index": 0, "Name": "Predicate", "Type": "TExprBase"},
-                {"Index": 1, "Name": "Value", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Coalesce"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Predicate", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "Value", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoUnwrap",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Unwrap"},
-            "Children": [
-                {"Index": 0, "Name": "Optional", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Unwrap"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Optional", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoScriptUdf",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "ScriptUdf"},
-            "Children": [
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "ScriptUdf"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "ScriptType", "Type": "TCoAtom"},
                 {"Index": 1, "Name": "FunctionName", "Type": "TCoAtom"},
-                {"Index": 2, "Name": "FunctionType", "Type": "TExprBase"},
+                {"Index": 2, "Name": "FunctionType", "Type": "TExprBase"}, 
                 {"Index": 3, "Name": "Script", "Type": "TExprBase"},
                 {"Index": 4, "Name": "Options", "Type": "TCoNameValueTupleList", "Optional": true}
-            ]
-        },
-        {
+            ] 
+        }, 
+        { 
             "Name": "TCoUdf",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "Udf"},
@@ -1244,23 +1244,23 @@
         },
         {
             "Name": "TCoExists",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Exists"},
-            "Children": [
-                {"Index": 0, "Name": "Optional", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Exists"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Optional", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoIf",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "If"},
-            "Children": [
-                {"Index": 0, "Name": "Predicate", "Type": "TExprBase"},
-                {"Index": 1, "Name": "ThenValue", "Type": "TExprBase"},
-                {"Index": 2, "Name": "ElseValue", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "If"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Predicate", "Type": "TExprBase"}, 
+                {"Index": 1, "Name": "ThenValue", "Type": "TExprBase"}, 
+                {"Index": 2, "Name": "ElseValue", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoIfStrict",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "IfStrict"},
@@ -1272,21 +1272,21 @@
         },
         {
             "Name": "TCoIfPresent",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "IfPresent"},
-            "Children": [
-                {"Index": 0, "Name": "Optional", "Type": "TExprBase"},
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "IfPresent"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Optional", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "PresentHandler", "Type": "TCoLambda"},
-                {"Index": 2, "Name": "MissingValue", "Type": "TExprBase"}
-            ]
-        },
-        {
+                {"Index": 2, "Name": "MissingValue", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoDefault",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Default"},
-            "Children": [
-                {"Index": 0, "Name": "Type", "Type": "TExprBase"}
-            ]
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Default"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Type", "Type": "TExprBase"} 
+            ] 
         },
         {
             "Name": "TCoCalcOverWindowBase",
@@ -1298,8 +1298,8 @@
                 {"Index": 2, "Name": "SortSpec",  "Type": "TExprBase"},
                 {"Index": 3, "Name": "Frames",    "Type": "TExprList"}
             ]
-        },
-        {
+        }, 
+        { 
             "Name": "TCoCalcOverWindow",
             "Base": "TCoCalcOverWindowBase",
             "Match": {"Type": "Callable", "Name": "CalcOverWindow"}
@@ -1339,30 +1339,30 @@
         },
         {
             "Name": "TCoEquiJoinTuple",
-            "Base": "TExprBase",
-            "Match": {"Type": "Tuple"},
-            "Children": [
+            "Base": "TExprBase", 
+            "Match": {"Type": "Tuple"}, 
+            "Children": [ 
                {"Index": 0, "Name": "Type", "Type": "TCoAtom"},
-               {"Index": 1, "Name": "LeftScope", "Type": "TExprBase"},
-               {"Index": 2, "Name": "RightScope", "Type": "TExprBase"},
+               {"Index": 1, "Name": "LeftScope", "Type": "TExprBase"}, 
+               {"Index": 2, "Name": "RightScope", "Type": "TExprBase"}, 
                {"Index": 3, "Name": "LeftKeys", "Type": "TCoAtomList"},
                {"Index": 4, "Name": "RightKeys", "Type": "TCoAtomList"},
-               {"Index": 5, "Name": "Options", "Type": "TExprList"}
-            ]
-        },
-        {
+               {"Index": 5, "Name": "Options", "Type": "TExprList"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoEquiJoinInput",
-            "Base": "TExprBase",
-            "Match": {"Type": "Tuple"},
-            "Children": [
-               {"Index": 0, "Name": "List", "Type": "TExprBase"},
-               {"Index": 1, "Name": "Scope", "Type": "TExprBase"}
-            ]
-        },
-        {
+            "Base": "TExprBase", 
+            "Match": {"Type": "Tuple"}, 
+            "Children": [ 
+               {"Index": 0, "Name": "List", "Type": "TExprBase"}, 
+               {"Index": 1, "Name": "Scope", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoEquiJoin",
             "VarArgBase": "TExprBase",
-            "Match": {"Type": "Callable", "Name": "EquiJoin"}
+            "Match": {"Type": "Callable", "Name": "EquiJoin"} 
         },
         {
             "Name": "TCoMapJoinCore",
@@ -1462,15 +1462,15 @@
         },
         {
             "Name": "TCoReplaceMember",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "ReplaceMember"},
-            "Children": [
-                {"Index": 0, "Name": "Struct", "Type": "TExprBase"},
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "ReplaceMember"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Struct", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "Name", "Type": "TCoAtom"},
-                {"Index": 2, "Name": "Item", "Type": "TExprBase"}
-            ]
-        },
-        {
+                {"Index": 2, "Name": "Item", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoRemoveMember",
             "Base": "TCallable",
             "Match": {"Type": "Callable", "Name": "RemoveMember"},
@@ -1538,47 +1538,47 @@
             "Children": [
                 {"Index": 0, "Name": "ListType", "Type": "TExprBase"}
             ]
-        },
-        {
-            "Name": "TCoStreamItemType",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "StreamItemType"},
-            "Children": [
-                {"Index": 0, "Name": "StreamType", "Type": "TExprBase"}
-            ]
-        },
-        {
-            "Name": "TCoDictKeyType",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "DictKeyType"},
-            "Children": [
-                {"Index": 0, "Name": "DictType", "Type": "TExprBase"}
-            ]
-        },
-        {
+        }, 
+        { 
+            "Name": "TCoStreamItemType", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "StreamItemType"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "StreamType", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
+            "Name": "TCoDictKeyType", 
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "DictKeyType"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "DictType", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoDependsOn",
             "Base": "TCoInputBase",
             "Match": {"Type": "Callable", "Name": "DependsOn"}
         },
         {
             "Name": "TCoParameter",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "Parameter"},
-            "Children": [
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "Parameter"}, 
+            "Children": [ 
                 {"Index": 0, "Name": "Name", "Type": "TCoAtom"},
-                {"Index": 1, "Name": "Type", "Type": "TExprBase"}
-            ]
-        },
-        {
+                {"Index": 1, "Name": "Type", "Type": "TExprBase"} 
+            ] 
+        }, 
+        { 
             "Name": "TCoMatchType",
-            "Base": "TCallable",
-            "Match": {"Type": "Callable", "Name": "MatchType"},
-            "Children": [
-                {"Index": 0, "Name": "Expression", "Type": "TExprBase"},
+            "Base": "TCallable", 
+            "Match": {"Type": "Callable", "Name": "MatchType"}, 
+            "Children": [ 
+                {"Index": 0, "Name": "Expression", "Type": "TExprBase"}, 
                 {"Index": 1, "Name": "TypeKind", "Type": "TCoAtom"},
                 {"Index": 2, "Name": "MatchLambda", "Type": "TCoLambda"},
                 {"Index": 3, "Name": "NotMatchLambda", "Type": "TCoLambda"}
-            ]
+            ] 
         },
         {
             "Name": "TCoIterator",
@@ -1612,8 +1612,8 @@
                 {"Index": 9,  "Name": "MergeHandler",   "Type": "TCoLambda"},
                 {"Index": 10, "Name": "FinishHandler",  "Type": "TCoLambda"}
             ]
-        },
-        {
+        }, 
+        { 
             "Name": "TCoMultiHoppingCore",
             "Base": "TCoInputBase",
             "Match": {"Type": "Callable", "Name": "MultiHoppingCore"},
@@ -1669,10 +1669,10 @@
         {
             "Name": "TCoConvert",
             "Base": "TCoInputBase",
-            "Match": {"Type": "Callable", "Name": "Convert"},
-            "Children": [
+            "Match": {"Type": "Callable", "Name": "Convert"}, 
+            "Children": [ 
                 {"Index": 1, "Name": "Type", "Type": "TCoAtom"}
-            ]
+            ] 
         },
         {
             "Name": "TCoCondense",
@@ -2062,6 +2062,6 @@
             "Name": "TCoCurrentTzTimestamp",
             "Base": "TCoTzTimeBase",
             "Match": {"Type": "Callable", "Name": "CurrentTzTimestamp"}
-        }
-    ]
-}
+        } 
+    ] 
+} 
diff --git a/ydb/library/yql/core/expr_nodes_gen/gen/__main__.py b/ydb/library/yql/core/expr_nodes_gen/gen/__main__.py
index 2bc809f4e7..0d19f207fe 100644
--- a/ydb/library/yql/core/expr_nodes_gen/gen/__main__.py
+++ b/ydb/library/yql/core/expr_nodes_gen/gen/__main__.py
@@ -1,205 +1,205 @@
-import os
-import sys
-import getopt
-import json
-import re
-
-from jinja2 import Environment, FileSystemLoader
-
-templateFile = sys.argv[1]
-(templateDir, templateFilename) = os.path.split(templateFile)
-
-jsonFile = sys.argv[2]
-headerOutFile = sys.argv[3]
-declOutFile = sys.argv[4]
-defsOutFile = sys.argv[5]
-
-env = Environment(loader=FileSystemLoader(templateDir))
-template = env.get_template(templateFilename)
-
-json_data=open(jsonFile)
-model = json.load(json_data)
-json_data.close()
-
-# Fill properties
-for node in model["Nodes"]:
-    aux = node["aux"] = {}
-
-    aux["stubName"] = node["Name"] + "Stub"
-    aux["stubMaybeName"] = node["Name"] + "MaybeStub"
-    aux["stubBuilderName"] = node["Name"] + "BuilderStub"
-    aux["stubBuilderAliasName"] = node["Name"] + "Builder"
-
-    if "Builder" not in node:
-        node["Builder"] = {}
-
-    if "ListBase" in node:
-        node["Base"] = "TListBase<{0}>".format(node["ListBase"])
-        node["Builder"]["Kind"] = "List"
-        node["Builder"]["ListItemType"] = node["ListBase"]
-
+import os 
+import sys 
+import getopt 
+import json 
+import re 
+ 
+from jinja2 import Environment, FileSystemLoader 
+ 
+templateFile = sys.argv[1] 
+(templateDir, templateFilename) = os.path.split(templateFile) 
+ 
+jsonFile = sys.argv[2] 
+headerOutFile = sys.argv[3] 
+declOutFile = sys.argv[4] 
+defsOutFile = sys.argv[5] 
+ 
+env = Environment(loader=FileSystemLoader(templateDir)) 
+template = env.get_template(templateFilename) 
+ 
+json_data=open(jsonFile) 
+model = json.load(json_data) 
+json_data.close() 
+ 
+# Fill properties 
+for node in model["Nodes"]: 
+    aux = node["aux"] = {} 
+ 
+    aux["stubName"] = node["Name"] + "Stub" 
+    aux["stubMaybeName"] = node["Name"] + "MaybeStub" 
+    aux["stubBuilderName"] = node["Name"] + "BuilderStub" 
+    aux["stubBuilderAliasName"] = node["Name"] + "Builder" 
+ 
+    if "Builder" not in node: 
+        node["Builder"] = {} 
+ 
+    if "ListBase" in node: 
+        node["Base"] = "TListBase<{0}>".format(node["ListBase"]) 
+        node["Builder"]["Kind"] = "List" 
+        node["Builder"]["ListItemType"] = node["ListBase"] 
+ 
     if "VarArgBase" in node:
         node["Base"] = "TVarArgCallable<{0}>".format(node["VarArgBase"])
         node["Builder"]["Kind"] = "List"
         node["Builder"]["ListItemType"] = node["VarArgBase"]
 
-    if "Children" in node:
-        for child in node["Children"]:
-            childAux = child["aux"] = {}
-            childAux["holderName"] = child["Name"] + "Holder"
-            if "Optional" not in child:
-                child["Optional"] = False
-
-    if node["Base"] == model["FreeArgCallableBase"]:
-        aux["isFinal"] = True;
-
-# Traverse tree
-nodesMap = {}
-for node in model["Nodes"]:
-    nodesMap[node["Name"]] = node
-
-    aux = node["aux"]
-    descendants = aux["descendants"] = set()
-    acscendants = aux["acscendants"] = set()
-
-for node in model["Nodes"]:
-    curNode = node
-    while curNode["Base"] in nodesMap:
-        parent = nodesMap[curNode["Base"]]
-
-        if "isFinal" in parent["aux"] and parent["aux"]["isFinal"]:
-            raise Exception("Node " + node["Name"] + " inherits final node " + parent["Name"])
-
-        parent["aux"]["descendants"].add(node["Name"])
-        node["aux"]["acscendants"].add(parent["Name"])
-        curNode = parent
-
-# Fill global properties
-for node in model["Nodes"]:
-    aux = node["aux"]
-
-    # Determine builders kind
-    if "Generate" not in node["Builder"]:
-        node["Builder"]["Generate"] = "Auto"
-
-    def hasBuilderKind(node):
-        return "Builder" in node and "Kind" in node["Builder"]
-
-    def isListBuilder(node):
-        return hasBuilderKind(node) and node["Builder"]["Kind"] == "List"
-
-    hasAscList = False
+    if "Children" in node: 
+        for child in node["Children"]: 
+            childAux = child["aux"] = {} 
+            childAux["holderName"] = child["Name"] + "Holder" 
+            if "Optional" not in child: 
+                child["Optional"] = False 
+ 
+    if node["Base"] == model["FreeArgCallableBase"]: 
+        aux["isFinal"] = True; 
+ 
+# Traverse tree 
+nodesMap = {} 
+for node in model["Nodes"]: 
+    nodesMap[node["Name"]] = node 
+ 
+    aux = node["aux"] 
+    descendants = aux["descendants"] = set() 
+    acscendants = aux["acscendants"] = set() 
+ 
+for node in model["Nodes"]: 
+    curNode = node 
+    while curNode["Base"] in nodesMap: 
+        parent = nodesMap[curNode["Base"]] 
+ 
+        if "isFinal" in parent["aux"] and parent["aux"]["isFinal"]: 
+            raise Exception("Node " + node["Name"] + " inherits final node " + parent["Name"]) 
+ 
+        parent["aux"]["descendants"].add(node["Name"]) 
+        node["aux"]["acscendants"].add(parent["Name"]) 
+        curNode = parent 
+ 
+# Fill global properties 
+for node in model["Nodes"]: 
+    aux = node["aux"] 
+ 
+    # Determine builders kind 
+    if "Generate" not in node["Builder"]: 
+        node["Builder"]["Generate"] = "Auto" 
+ 
+    def hasBuilderKind(node): 
+        return "Builder" in node and "Kind" in node["Builder"] 
+ 
+    def isListBuilder(node): 
+        return hasBuilderKind(node) and node["Builder"]["Kind"] == "List" 
+ 
+    hasAscList = False 
     for ascName in sorted(aux["acscendants"]):
-        asc = nodesMap[ascName]
-        if isListBuilder(asc):
-            hasAscList = True
-            ascListItemType = asc["Builder"]["ListItemType"]
-            break
-
-    if hasBuilderKind(node):
-        if hasAscList and not isListBuilder(node):
-            raise Exception("Invalid builder kind in " + node["Name"])
-        if hasAscList and ascListItemType != node["Builder"]["ListItemType"]:
-            raise Exception("Invalid builder list item type in " + node["Name"])
-    else:
-        if hasAscList:
-            node["Builder"]["Kind"] = "List"
-            node["Builder"]["ListItemType"] = ascListItemType
-        else:
-            node["Builder"]["Kind"] = "FreeArg" if node["Base"] == model["FreeArgCallableBase"] else "Node"
-
-    aux["generateBuilderStub"] = node["Builder"]["Generate"] != "None" and node["Builder"]["Kind"] != "List"
-    aux["generateBuilder"] = node["Builder"]["Generate"] == "Auto"
-
-    # Get all children
-    allChildren = []
-
-    if "Children" in node:
-        allChildren.extend(node["Children"])
-
+        asc = nodesMap[ascName] 
+        if isListBuilder(asc): 
+            hasAscList = True 
+            ascListItemType = asc["Builder"]["ListItemType"] 
+            break 
+ 
+    if hasBuilderKind(node): 
+        if hasAscList and not isListBuilder(node): 
+            raise Exception("Invalid builder kind in " + node["Name"]) 
+        if hasAscList and ascListItemType != node["Builder"]["ListItemType"]: 
+            raise Exception("Invalid builder list item type in " + node["Name"]) 
+    else: 
+        if hasAscList: 
+            node["Builder"]["Kind"] = "List" 
+            node["Builder"]["ListItemType"] = ascListItemType 
+        else: 
+            node["Builder"]["Kind"] = "FreeArg" if node["Base"] == model["FreeArgCallableBase"] else "Node" 
+ 
+    aux["generateBuilderStub"] = node["Builder"]["Generate"] != "None" and node["Builder"]["Kind"] != "List" 
+    aux["generateBuilder"] = node["Builder"]["Generate"] == "Auto" 
+ 
+    # Get all children 
+    allChildren = [] 
+ 
+    if "Children" in node: 
+        allChildren.extend(node["Children"]) 
+ 
     for ascName in sorted(aux["acscendants"]):
-        if "Children" in nodesMap[ascName]:
-            allChildren.extend(nodesMap[ascName]["Children"])
-
-    allChildren = sorted(allChildren, key=lambda c: c["Index"])
-    aux["allChildren"] = allChildren
-
-    # Make sure indices are OK
-    optionalArgs = False
-    aux["allChildrenCount"] = len(allChildren)
-    aux["fixedChildrenCount"] = 0
-    for index, child in enumerate(allChildren):
-        if child["Index"] != index:
-            raise Exception("Missing child #" + str(index) + " in " + node["Name"])
-        if not child["Optional"] and optionalArgs:
-            raise Exception("Child #" + str(index) + " should be optional in " + node["Name"])
-        optionalArgs = child["Optional"]
-        if not child["Optional"]:
-            aux["fixedChildrenCount"] += 1;
-
-    if "Match" in node and node["Match"]["Type"] == "CallableBase":
-        namesToMatch = aux["namesToMatch"] = []
+        if "Children" in nodesMap[ascName]: 
+            allChildren.extend(nodesMap[ascName]["Children"]) 
+ 
+    allChildren = sorted(allChildren, key=lambda c: c["Index"]) 
+    aux["allChildren"] = allChildren 
+ 
+    # Make sure indices are OK 
+    optionalArgs = False 
+    aux["allChildrenCount"] = len(allChildren) 
+    aux["fixedChildrenCount"] = 0 
+    for index, child in enumerate(allChildren): 
+        if child["Index"] != index: 
+            raise Exception("Missing child #" + str(index) + " in " + node["Name"]) 
+        if not child["Optional"] and optionalArgs: 
+            raise Exception("Child #" + str(index) + " should be optional in " + node["Name"]) 
+        optionalArgs = child["Optional"] 
+        if not child["Optional"]: 
+            aux["fixedChildrenCount"] += 1; 
+ 
+    if "Match" in node and node["Match"]["Type"] == "CallableBase": 
+        namesToMatch = aux["namesToMatch"] = [] 
         for descName in sorted(aux["descendants"]):
-            desc = nodesMap[descName]
-            if desc["Match"]["Type"] == "Callable":
-                namesToMatch.append(desc["Match"]["Name"])
-
-    def parseTypename(typename):
-        usages = []
-        match = re.match("(.*)(<([^,]*)>)+", typename)
-        if match:
-            usages.append((match.group(1), "template<typename> class {0}".format(match.group(1))))
-            usages.append((match.group(3), "typename {0}".format(match.group(3))))
-        elif typename == model["FreeArgCallableBase"]:
-            usages.append((typename, "template<const size_t> class {0}".format(typename)))
-        else:
-            usages.append((typename, "typename {0}".format(typename)))
-
-        return usages
-
-    usages = []
-    usagesSet = set()
-    declarations = []
-
-    def addUsages(typename):
-        typeUsages = parseTypename(typename)
-        for usage in typeUsages:
-            if usage[0] not in usagesSet:
-                usagesSet.add(usage[0])
-                usages.append(usage[0])
-                declarations.append(usage[1])
-
-    addUsages(model["NodeRootType"])
-    addUsages(node["Base"])
-    if ("Children" in node):
-        for child in node["Children"]:
-            addUsages(child["Type"])
-    aux["usages"] = usages
-    aux["typenames"] = declarations
-
-    usages = []
-    usagesSet = set()
-    declarations = []
-    addUsages(model["NodeRootType"])
-    addUsages(node["Base"])
-    for child in aux["allChildren"]:
-        addUsages(child["Type"])
-    aux["builderUsages"] = usages
-    aux["builderTypenames"] = declarations
-
-    if node["Base"] == model["FreeArgCallableBase"]:
-        node["Base"] = "{0}<{1}>".format(node["Base"], len(aux["allChildren"]))
-
-
-headerOutput = template.render(generator=__file__, genType="Header", model=model, nodes=model["Nodes"])
-with open(headerOutFile, "w") as fh:
-    fh.write(headerOutput)
-
-declOutput = template.render(generator=__file__, genType="Declarations", model=model, nodes=model["Nodes"])
-with open(declOutFile, "w") as fh:
-    fh.write(declOutput)
-
-defsOutput = template.render(generator=__file__, genType="Definitions", model=model, nodes=model["Nodes"])
-with open(defsOutFile, "w") as fh:
-    fh.write(defsOutput)
-
+            desc = nodesMap[descName] 
+            if desc["Match"]["Type"] == "Callable": 
+                namesToMatch.append(desc["Match"]["Name"]) 
+ 
+    def parseTypename(typename): 
+        usages = [] 
+        match = re.match("(.*)(<([^,]*)>)+", typename) 
+        if match: 
+            usages.append((match.group(1), "template<typename> class {0}".format(match.group(1)))) 
+            usages.append((match.group(3), "typename {0}".format(match.group(3)))) 
+        elif typename == model["FreeArgCallableBase"]: 
+            usages.append((typename, "template<const size_t> class {0}".format(typename))) 
+        else: 
+            usages.append((typename, "typename {0}".format(typename))) 
+ 
+        return usages 
+ 
+    usages = [] 
+    usagesSet = set() 
+    declarations = [] 
+ 
+    def addUsages(typename): 
+        typeUsages = parseTypename(typename) 
+        for usage in typeUsages: 
+            if usage[0] not in usagesSet: 
+                usagesSet.add(usage[0]) 
+                usages.append(usage[0]) 
+                declarations.append(usage[1]) 
+ 
+    addUsages(model["NodeRootType"]) 
+    addUsages(node["Base"]) 
+    if ("Children" in node): 
+        for child in node["Children"]: 
+            addUsages(child["Type"]) 
+    aux["usages"] = usages 
+    aux["typenames"] = declarations 
+ 
+    usages = [] 
+    usagesSet = set() 
+    declarations = [] 
+    addUsages(model["NodeRootType"]) 
+    addUsages(node["Base"]) 
+    for child in aux["allChildren"]: 
+        addUsages(child["Type"]) 
+    aux["builderUsages"] = usages 
+    aux["builderTypenames"] = declarations 
+ 
+    if node["Base"] == model["FreeArgCallableBase"]: 
+        node["Base"] = "{0}<{1}>".format(node["Base"], len(aux["allChildren"])) 
+ 
+ 
+headerOutput = template.render(generator=__file__, genType="Header", model=model, nodes=model["Nodes"]) 
+with open(headerOutFile, "w") as fh: 
+    fh.write(headerOutput) 
+ 
+declOutput = template.render(generator=__file__, genType="Declarations", model=model, nodes=model["Nodes"]) 
+with open(declOutFile, "w") as fh: 
+    fh.write(declOutput) 
+ 
+defsOutput = template.render(generator=__file__, genType="Definitions", model=model, nodes=model["Nodes"]) 
+with open(defsOutFile, "w") as fh: 
+    fh.write(defsOutput) 
+ 
diff --git a/ydb/library/yql/core/expr_nodes_gen/gen/ya.make b/ydb/library/yql/core/expr_nodes_gen/gen/ya.make
index 751fb55dee..8beddb8a45 100644
--- a/ydb/library/yql/core/expr_nodes_gen/gen/ya.make
+++ b/ydb/library/yql/core/expr_nodes_gen/gen/ya.make
@@ -1,15 +1,15 @@
 PY3_PROGRAM()
-
+ 
 OWNER(
     spuchin
     g:yql_ydb_core
 )
-
-PY_SRCS(__main__.py)
-
-PEERDIR(
-    contrib/python/MarkupSafe
-    contrib/python/Jinja2
-)
-
-END()
+ 
+PY_SRCS(__main__.py) 
+ 
+PEERDIR( 
+    contrib/python/MarkupSafe 
+    contrib/python/Jinja2 
+) 
+ 
+END() 
diff --git a/ydb/library/yql/core/expr_nodes_gen/ya.make b/ydb/library/yql/core/expr_nodes_gen/ya.make
index b2ce04a289..47c9073d2c 100644
--- a/ydb/library/yql/core/expr_nodes_gen/ya.make
+++ b/ydb/library/yql/core/expr_nodes_gen/ya.make
@@ -1,19 +1,19 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(
     spuchin
     g:yql
     g:yql_ydb_core
 )
-
-SRCS(
-    yql_expr_nodes_gen.h
-    yql_expr_nodes_gen.cpp
-)
-
-PEERDIR(
+ 
+SRCS( 
+    yql_expr_nodes_gen.h 
+    yql_expr_nodes_gen.cpp 
+) 
+ 
+PEERDIR( 
     ydb/library/yql/ast
     ydb/library/yql/public/udf
-)
-
-END()
+) 
+ 
+END() 
diff --git a/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.cpp b/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.cpp
index 4546f75db7..64bf507db3 100644
--- a/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.cpp
+++ b/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.cpp
@@ -1 +1 @@
-#include "yql_expr_nodes_gen.h"
+#include "yql_expr_nodes_gen.h" 
diff --git a/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.h b/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.h
index 0974e8d2d3..5c03d8460a 100644
--- a/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.h
+++ b/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.h
@@ -1,29 +1,29 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/utils/yql_panic.h>
 
 #include <ydb/library/yql/ast/yql_expr.h>
-
+ 
 #include <util/generic/vector.h>
 #include <util/generic/strbuf.h>
 #include <util/system/yassert.h>
 #include <util/string/cast.h>
 
-#include <functional>
+#include <functional> 
 #include <iterator>
-
-namespace NYql {
-namespace NNodes {
-
-template<typename TNode>
-class TMaybeNode {};
-
-class TExprBase {
-public:
+ 
+namespace NYql { 
+namespace NNodes { 
+ 
+template<typename TNode> 
+class TMaybeNode {}; 
+ 
+class TExprBase { 
+public: 
     explicit TExprBase(const TExprNode* node)
         : Raw_(node)
     {
-        YQL_ENSURE(node);
+        YQL_ENSURE(node); 
     }
 
     explicit TExprBase(TExprNode::TPtr&& node)
@@ -34,253 +34,253 @@ public:
 
     explicit TExprBase(const TExprNode::TPtr& node)
         : Raw_(node.Get()), Node(node)
-    {
-        YQL_ENSURE(node);
-    }
-
+    { 
+        YQL_ENSURE(node); 
+    } 
+ 
     const TExprNode* Raw() const {
         return Raw_;
     }
-
+ 
     TExprNode::TPtr Ptr() const {
         YQL_ENSURE(Node);
         return Node;
-    }
-
+    } 
+ 
     const TExprNode& Ref() const {
         return *Raw_;
     }
 
-    TExprBase NonOwning() const {
-        return TExprBase(Raw_);
-    }
-
+    TExprBase NonOwning() const { 
+        return TExprBase(Raw_); 
+    } 
+ 
     TPositionHandle Pos() const {
         return Raw_->Pos();
-    }
-
-    template<typename TNode>
-    TMaybeNode<TNode> Maybe() const {
+    } 
+ 
+    template<typename TNode> 
+    TMaybeNode<TNode> Maybe() const { 
         return Cast<TMaybeNode<TNode>>();
-    }
-
-    template<typename TNode>
-    TNode Cast() const {
+    } 
+ 
+    template<typename TNode> 
+    TNode Cast() const { 
         return Node ? TNode(Node) : TNode(Raw_);
-    }
-
-private:
+    } 
+ 
+private: 
     const TExprNode* Raw_;
     TExprNode::TPtr Node;
-};
-
-template<>
-class TMaybeNode<TExprBase> {
-public:
+}; 
+ 
+template<> 
+class TMaybeNode<TExprBase> { 
+public: 
     TMaybeNode(const TExprNode* node = nullptr)
         : Raw_(node) {}
-
+ 
     TMaybeNode(const TExprNode::TPtr& node)
         : Raw_(node.Get()), Node(node) {}
 
-    TMaybeNode(const TExprBase& node)
+    TMaybeNode(const TExprBase& node) 
         : Raw_(node.Raw()), Node(node.Ptr()) {}
-
+ 
     const TExprNode& Ref() const {
-        YQL_ENSURE(IsValid());
+        YQL_ENSURE(IsValid()); 
         return *Raw_;
-    }
-
+    } 
+ 
     const TExprNode* Raw() const {
         return Raw_;
     }
 
-    bool IsValid() const {
+    bool IsValid() const { 
         return Raw_ != nullptr;
-    }
-
+    } 
+ 
     explicit operator bool() const {
-        return IsValid();
-    }
-
-    template<typename TNode>
-    TMaybeNode<TNode> Maybe() const {
+        return IsValid(); 
+    } 
+ 
+    template<typename TNode> 
+    TMaybeNode<TNode> Maybe() const { 
         return Node ? TMaybeNode<TNode>(Node) : TMaybeNode<TNode>(Raw_);
-    }
-
-    template<typename TNode>
-    TNode Cast() const {
-        YQL_ENSURE(IsValid());
+    } 
+ 
+    template<typename TNode> 
+    TNode Cast() const { 
+        YQL_ENSURE(IsValid()); 
         return Node ? TNode(Node) : TNode(Raw_);
-    }
-
-    TExprBase Cast() const {
-        YQL_ENSURE(IsValid());
+    } 
+ 
+    TExprBase Cast() const { 
+        YQL_ENSURE(IsValid()); 
         return Node ? TExprBase(Node) : TExprBase(Raw_);
-    }
-
-private:
+    } 
+ 
+private: 
     const TExprNode* Raw_;
     TExprNode::TPtr Node;
-};
-
-template<typename TNode>
-class TChildIterator : public std::iterator<std::forward_iterator_tag, TNode> {
-public:
+}; 
+ 
+template<typename TNode> 
+class TChildIterator : public std::iterator<std::forward_iterator_tag, TNode> { 
+public: 
     TChildIterator()
     {
         CurIt = EndIt = {};
     }
-
-    TChildIterator(const TExprBase &node, size_t startIndex = 0)
+ 
+    TChildIterator(const TExprBase &node, size_t startIndex = 0) 
         : CurIt(node.Ref().Children().begin() + startIndex)
         , EndIt(node.Ref().Children().end())
-    {
-        if (CurIt != EndIt) {
-            CurNode = *CurIt;
-        }
-    }
-
-    TChildIterator& operator++ () // Pre-increment
-    {
-        YQL_ENSURE(CurNode);
-        Move();
-        return *this;
-    }
-
-    TChildIterator operator++ (int) // Post-increment
-    {
-        YQL_ENSURE(CurNode);
-        TChildIterator<TNode> tmp(*this);
-        Move();
-        return tmp;
-    }
-
-    bool operator ==(const TChildIterator<TNode>& rhs) const
-    {
-        return CurNode == rhs.CurNode;
-    }
-
-    bool operator !=(const TChildIterator<TNode>& rhs) const
-    {
-        return CurNode != rhs.CurNode;
-    }
-
-    TNode operator*() const
-    {
-        YQL_ENSURE(CurNode);
-        return TNode(CurNode);
-    }
-
-private:
-    void Move() {
-        ++CurIt;
-        CurNode = CurIt == EndIt ? nullptr : *CurIt;
-    }
-
+    { 
+        if (CurIt != EndIt) { 
+            CurNode = *CurIt; 
+        } 
+    } 
+ 
+    TChildIterator& operator++ () // Pre-increment 
+    { 
+        YQL_ENSURE(CurNode); 
+        Move(); 
+        return *this; 
+    } 
+ 
+    TChildIterator operator++ (int) // Post-increment 
+    { 
+        YQL_ENSURE(CurNode); 
+        TChildIterator<TNode> tmp(*this); 
+        Move(); 
+        return tmp; 
+    } 
+ 
+    bool operator ==(const TChildIterator<TNode>& rhs) const 
+    { 
+        return CurNode == rhs.CurNode; 
+    } 
+ 
+    bool operator !=(const TChildIterator<TNode>& rhs) const 
+    { 
+        return CurNode != rhs.CurNode; 
+    } 
+ 
+    TNode operator*() const 
+    { 
+        YQL_ENSURE(CurNode); 
+        return TNode(CurNode); 
+    } 
+ 
+private: 
+    void Move() { 
+        ++CurIt; 
+        CurNode = CurIt == EndIt ? nullptr : *CurIt; 
+    } 
+ 
     TExprNode::TPtr CurNode;
     TExprNode::TListType::const_iterator CurIt;
     TExprNode::TListType::const_iterator EndIt;
-};
-
-template<typename TItem>
-class TListBase : public TExprBase {
-public:
+}; 
+ 
+template<typename TItem> 
+class TListBase : public TExprBase { 
+public: 
     TListBase(const TExprNode* node)
-        : TExprBase(node)
-    {
-        YQL_ENSURE(Match(node));
-    }
-
+        : TExprBase(node) 
+    { 
+        YQL_ENSURE(Match(node)); 
+    } 
+ 
     TListBase(const TExprNode::TPtr& node)
         : TExprBase(node)
     {
-        YQL_ENSURE(Match(node.Get()));
+        YQL_ENSURE(Match(node.Get())); 
     }
-
+ 
     TItem Item(size_t index) const { return TItem(Ref().ChildPtr(index)); }
     size_t Size() const { return Ref().ChildrenSize(); }
-    bool Empty() const { return Size() == 0; }
-
-    TChildIterator<TItem> begin() const { return TChildIterator<TItem>(*this); }
-    TChildIterator<TItem> end() const { return TChildIterator<TItem>(); }
-
-public:
+    bool Empty() const { return Size() == 0; } 
+ 
+    TChildIterator<TItem> begin() const { return TChildIterator<TItem>(*this); } 
+    TChildIterator<TItem> end() const { return TChildIterator<TItem>(); } 
+ 
+public: 
     static bool Match(const TExprNode* node) {
         return node && node->IsList();
-    }
-};
-
-template<typename TItem>
-class TMaybeNode<TListBase<TItem>> : public TMaybeNode<TExprBase> {
-public:
+    } 
+}; 
+ 
+template<typename TItem> 
+class TMaybeNode<TListBase<TItem>> : public TMaybeNode<TExprBase> { 
+public: 
     TMaybeNode(const TExprNode* node)
         : TMaybeNode<TExprBase>(node && TListBase<TItem>::Match(node) ? node : nullptr) {}
 
     TMaybeNode(const TExprNode::TPtr& node)
         : TMaybeNode<TExprBase>(node && TListBase<TItem>::Match(node.Get()) ? node : TExprNode::TPtr()) {}
-
+ 
     TListBase<TItem> Cast() const {
-        YQL_ENSURE(IsValid());
+        YQL_ENSURE(IsValid()); 
         return TMaybeNode<TExprBase>::Cast().template Cast<TListBase<TItem>>();
     }
 
-    TMaybeNode<TItem> Item(size_t index) const {
-        if (!IsValid()) {
-            return TMaybeNode<TItem>();
-        }
-
+    TMaybeNode<TItem> Item(size_t index) const { 
+        if (!IsValid()) { 
+            return TMaybeNode<TItem>(); 
+        } 
+ 
         auto list = Cast();
-        if (index >= list.Size()) {
-            return TMaybeNode<TItem>();
-        }
-
+        if (index >= list.Size()) { 
+            return TMaybeNode<TItem>(); 
+        } 
+ 
         return TMaybeNode<TItem>(Ref().ChildPtr(index));
-    }
-};
-
-class TCallable : public TExprBase {
-public:
+    } 
+}; 
+ 
+class TCallable : public TExprBase { 
+public: 
     explicit TCallable(const TExprNode* node)
-        : TExprBase(node)
-    {
-        YQL_ENSURE(Match(node));
-    }
-
+        : TExprBase(node) 
+    { 
+        YQL_ENSURE(Match(node)); 
+    } 
+ 
     explicit TCallable(const TExprNode::TPtr& node)
         : TExprBase(node)
     {
-        YQL_ENSURE(Match(node.Get()));
+        YQL_ENSURE(Match(node.Get())); 
     }
 
-    TStringBuf CallableName() const {
+    TStringBuf CallableName() const { 
         return Ref().Content();
-    }
-
-public:
+    } 
+ 
+public: 
     static bool Match(const TExprNode* node) {
         return node && node->IsCallable();
-    }
-};
-
-template<>
-class TMaybeNode<TCallable> : public TMaybeNode<TExprBase> {
-public:
-    TMaybeNode(const TExprNode* node = nullptr)
+    } 
+}; 
+ 
+template<> 
+class TMaybeNode<TCallable> : public TMaybeNode<TExprBase> { 
+public: 
+    TMaybeNode(const TExprNode* node = nullptr) 
         : TMaybeNode<TExprBase>(node && TCallable::Match(node) ? node : nullptr) {}
 
-    TMaybeNode(const TExprNode::TPtr& node)
+    TMaybeNode(const TExprNode::TPtr& node) 
         : TMaybeNode<TExprBase>(node && TCallable::Match(node.Get()) ? node : TExprNode::TPtr()) {}
-
-    TMaybeNode(const TCallable& node)
-        : TMaybeNode(node.Ptr()) {}
-
-    TCallable Cast() const {
-        YQL_ENSURE(IsValid());
+ 
+    TMaybeNode(const TCallable& node) 
+        : TMaybeNode(node.Ptr()) {} 
+ 
+    TCallable Cast() const { 
+        YQL_ENSURE(IsValid()); 
         return TMaybeNode<TExprBase>::Cast().Cast<TCallable>();
-    }
-};
-
+    } 
+}; 
+ 
 template<typename TItem>
 class TVarArgCallable : public TCallable {
 public:
@@ -322,7 +322,7 @@ public:
         : TMaybeNode<TExprBase>(node && TVarArgCallable<TItem>::Match(node.Get()) ? node : TExprNode::TPtr()) {}
 
     TVarArgCallable<TItem> Cast() const {
-        YQL_ENSURE(IsValid());
+        YQL_ENSURE(IsValid()); 
         return TMaybeNode<TExprBase>::Cast().template Cast<TVarArgCallable<TItem>>();
     }
 
@@ -340,236 +340,236 @@ public:
     }
 };
 
-class TArgs
-{
-public:
+class TArgs 
+{ 
+public: 
     TArgs(const TExprBase& node, size_t startIndex)
-        : Node(node)
-        , StartIndex(startIndex) {}
-
+        : Node(node) 
+        , StartIndex(startIndex) {} 
+ 
     TExprBase Get(size_t index) const { return TExprBase(Node.Ref().ChildPtr(index)); }
     size_t Count() const { return Node.Ref().ChildrenSize(); }
-    TChildIterator<TExprBase> begin() const { return TChildIterator<TExprBase>(Node, StartIndex); }
-    TChildIterator<TExprBase> end() const { return TChildIterator<TExprBase>(); }
-
-private:
-    TExprBase Node;
-    size_t StartIndex;
-};
-
-template<const size_t FixedArgsCount>
-class TFreeArgCallable : public TCallable {
-public:
+    TChildIterator<TExprBase> begin() const { return TChildIterator<TExprBase>(Node, StartIndex); } 
+    TChildIterator<TExprBase> end() const { return TChildIterator<TExprBase>(); } 
+ 
+private: 
+    TExprBase Node; 
+    size_t StartIndex; 
+}; 
+ 
+template<const size_t FixedArgsCount> 
+class TFreeArgCallable : public TCallable { 
+public: 
     explicit TFreeArgCallable(const TExprNode* node)
-        : TCallable(node)
-    {
-        YQL_ENSURE(Match(node));
-    }
-
+        : TCallable(node) 
+    { 
+        YQL_ENSURE(Match(node)); 
+    } 
+ 
     explicit TFreeArgCallable(const TExprNode::TPtr& node)
         : TCallable(node)
     {
-        YQL_ENSURE(Match(node.Get()));
+        YQL_ENSURE(Match(node.Get())); 
     }
 
-    TArgs Args() const { return TArgs(*this, 0); }
-    TArgs FreeArgs() const { return TArgs(*this, FixedArgsCount); }
-
-    TExprBase Arg(size_t index) const { return TArgs(*this, 0).Get(index); }
-
+    TArgs Args() const { return TArgs(*this, 0); } 
+    TArgs FreeArgs() const { return TArgs(*this, FixedArgsCount); } 
+ 
+    TExprBase Arg(size_t index) const { return TArgs(*this, 0).Get(index); } 
+ 
     static bool Match(const TExprNode* node) {
         return node && node->IsCallable() && node->ChildrenSize() >= FixedArgsCount;
-    }
-};
-
-template<const size_t FixedArgsCount>
-class TMaybeNode<TFreeArgCallable<FixedArgsCount>> : public TMaybeNode<TExprBase> {
-public:
+    } 
+}; 
+ 
+template<const size_t FixedArgsCount> 
+class TMaybeNode<TFreeArgCallable<FixedArgsCount>> : public TMaybeNode<TExprBase> { 
+public: 
     TMaybeNode(const TExprNode* node)
         : TMaybeNode<TExprBase>(node && TFreeArgCallable<FixedArgsCount>::Match(node) ? node : nullptr) {}
 
-    TMaybeNode(const TExprNode::TPtr& node)
+    TMaybeNode(const TExprNode::TPtr& node) 
         : TMaybeNode<TExprBase>(node && TFreeArgCallable<FixedArgsCount>::Match(node.Get()) ? node : TExprNode::TPtr()) {}
-
-    TMaybeNode(const TExprBase& node)
+ 
+    TMaybeNode(const TExprBase& node) 
         : TMaybeNode(node) {}
-
-    TFreeArgCallable<FixedArgsCount> Cast() const {
-        YQL_ENSURE(IsValid());
+ 
+    TFreeArgCallable<FixedArgsCount> Cast() const { 
+        YQL_ENSURE(IsValid()); 
         return TMaybeNode<TExprBase>::Cast().template Cast<TFreeArgCallable<FixedArgsCount>>();
-    }
-};
-
-template<typename TParent, typename TNode>
-class TNodeBuilder {};
-
-class TNodeBuilderBase {
-protected:
-    typedef std::function<TExprBase (const TStringBuf& arg)> GetArgFuncType;
-
+    } 
+}; 
+ 
+template<typename TParent, typename TNode> 
+class TNodeBuilder {}; 
+ 
+class TNodeBuilderBase { 
+protected: 
+    typedef std::function<TExprBase (const TStringBuf& arg)> GetArgFuncType; 
+ 
     TNodeBuilderBase(TExprContext& ctx, TPositionHandle pos, GetArgFuncType getArgFunc)
-        : Ctx(ctx)
-        , Pos(pos)
-        , GetArgFunc(getArgFunc) {}
-
-protected:
-    TExprContext& Ctx;
+        : Ctx(ctx) 
+        , Pos(pos) 
+        , GetArgFunc(getArgFunc) {} 
+ 
+protected: 
+    TExprContext& Ctx; 
     TPositionHandle Pos;
-    GetArgFuncType GetArgFunc;
-};
-
-template <typename TParent, typename TDerived, typename TItem>
-class TListBuilderBase : public TNodeBuilderBase {
-protected:
-    typedef std::function<TParent& (const TDerived&)> BuildFuncType;
-
+    GetArgFuncType GetArgFunc; 
+}; 
+ 
+template <typename TParent, typename TDerived, typename TItem> 
+class TListBuilderBase : public TNodeBuilderBase { 
+protected: 
+    typedef std::function<TParent& (const TDerived&)> BuildFuncType; 
+ 
     TListBuilderBase(TExprContext& ctx, TPositionHandle pos, BuildFuncType buildFunc, GetArgFuncType getArgFunc)
-        : TNodeBuilderBase(ctx, pos, getArgFunc)
-        , BuildFunc(buildFunc) {}
-
+        : TNodeBuilderBase(ctx, pos, getArgFunc) 
+        , BuildFunc(buildFunc) {} 
+ 
     TVector<TExprBase> Items;
-    BuildFuncType BuildFunc;
-
-public:
-    typedef TDerived ResultType;
-
-    TParent& Build() {
-        TDerived node = static_cast<TNodeBuilder<TParent, TDerived>*>(this)->DoBuild();
-        return BuildFunc(node);
-    }
-
-    typename TParent::ResultType Done() {
-        TParent& parent = Build();
-        return parent.Value();
-    }
-
+    BuildFuncType BuildFunc; 
+ 
+public: 
+    typedef TDerived ResultType; 
+ 
+    TParent& Build() { 
+        TDerived node = static_cast<TNodeBuilder<TParent, TDerived>*>(this)->DoBuild(); 
+        return BuildFunc(node); 
+    } 
+ 
+    typename TParent::ResultType Done() { 
+        TParent& parent = Build(); 
+        return parent.Value(); 
+    } 
+ 
     TNodeBuilder<TParent, TDerived>& InitFrom(const ResultType& item) {
         Items.assign(item.begin(), item.end());
         return *static_cast<TNodeBuilder<TParent, TDerived>*>(this);
     }
 
-    TNodeBuilder<TParent, TDerived>& Add(const TExprBase& node) {
-        Items.push_back(node);
-        return *static_cast<TNodeBuilder<TParent, TDerived>*>(this);
-    }
-
+    TNodeBuilder<TParent, TDerived>& Add(const TExprBase& node) { 
+        Items.push_back(node); 
+        return *static_cast<TNodeBuilder<TParent, TDerived>*>(this); 
+    } 
+ 
     TNodeBuilder<TParent, TDerived>& Add(const TExprNode::TPtr& node) {
         Items.push_back(TExprBase(node));
         return *static_cast<TNodeBuilder<TParent, TDerived>*>(this);
     }
 
-    TNodeBuilder<TNodeBuilder<TParent, TDerived>, TItem> Add() {
-        return TNodeBuilder<TNodeBuilder<TParent, TDerived>, TItem>(this->Ctx, this->Pos,
-            [this] (const TExprBase& node) mutable -> TNodeBuilder<TParent, TDerived>& {
-                return Add(node);
-            }, GetArgFunc);
-    }
-
-    template<typename TNode>
-    TNodeBuilder<TNodeBuilder<TParent, TDerived>, TNode> Add() {
-        return TNodeBuilder<TNodeBuilder<TParent, TDerived>, TNode>(this->Ctx, this->Pos,
-            [this] (const TNode& node) mutable -> TNodeBuilder<TParent, TDerived>&{
-                return Add(node);
-            }, GetArgFunc);
-    }
-
-    TNodeBuilder<TParent, TDerived>& Add(const TStringBuf& argName) {
+    TNodeBuilder<TNodeBuilder<TParent, TDerived>, TItem> Add() { 
+        return TNodeBuilder<TNodeBuilder<TParent, TDerived>, TItem>(this->Ctx, this->Pos, 
+            [this] (const TExprBase& node) mutable -> TNodeBuilder<TParent, TDerived>& { 
+                return Add(node); 
+            }, GetArgFunc); 
+    } 
+ 
+    template<typename TNode> 
+    TNodeBuilder<TNodeBuilder<TParent, TDerived>, TNode> Add() { 
+        return TNodeBuilder<TNodeBuilder<TParent, TDerived>, TNode>(this->Ctx, this->Pos, 
+            [this] (const TNode& node) mutable -> TNodeBuilder<TParent, TDerived>&{ 
+                return Add(node); 
+            }, GetArgFunc); 
+    } 
+ 
+    TNodeBuilder<TParent, TDerived>& Add(const TStringBuf& argName) { 
         return Add(TExprBase(this->GetArgFunc(argName)));
-    }
-
-    template <typename T, typename = std::enable_if_t<!std::is_same<T, TExprBase>::value
-        && std::is_same<T, TItem>::value>>
+    } 
+ 
+    template <typename T, typename = std::enable_if_t<!std::is_same<T, TExprBase>::value 
+        && std::is_same<T, TItem>::value>> 
     TNodeBuilder<TParent, TDerived>& Add(const TVector<T>& list) {
-        for (auto item : list) {
-            Items.push_back(item);
-        }
-        return *static_cast<TNodeBuilder<TParent, TDerived>*>(this);
-    }
-
+        for (auto item : list) { 
+            Items.push_back(item); 
+        } 
+        return *static_cast<TNodeBuilder<TParent, TDerived>*>(this); 
+    } 
+ 
     TNodeBuilder<TParent, TDerived>& Add(const TVector<TExprBase>& list) {
-        for (auto item : list) {
-            Items.push_back(item);
-        }
-        return *static_cast<TNodeBuilder<TParent, TDerived>*>(this);
-    }
-
+        for (auto item : list) { 
+            Items.push_back(item); 
+        } 
+        return *static_cast<TNodeBuilder<TParent, TDerived>*>(this); 
+    } 
+ 
     TNodeBuilder<TParent, TDerived>& Add(const TExprNode::TListType& list) {
-        for (auto item : list) {
-            Items.push_back(TExprBase(item));
-        }
-        return *static_cast<TNodeBuilder<TParent, TDerived>*>(this);
-    }
-
-    TNodeBuilder<TParent, TDerived>& Add(std::initializer_list<TExprBase> list) {
+        for (auto item : list) { 
+            Items.push_back(TExprBase(item)); 
+        } 
+        return *static_cast<TNodeBuilder<TParent, TDerived>*>(this); 
+    } 
+ 
+    TNodeBuilder<TParent, TDerived>& Add(std::initializer_list<TExprBase> list) { 
         return Add(TVector<TExprBase>(list));
-    }
-};
-
-template<typename TParent>
+    } 
+}; 
+ 
+template<typename TParent> 
 class TNodeBuilder<TParent, TVector<TExprBase>> : public TListBuilderBase<TParent, TVector<TExprBase>, TExprBase> {
-public:
+public: 
     typedef std::function<TParent& (const TVector<TExprBase>&)> BuildFuncType;
-
+ 
     TNodeBuilder<TParent, TVector<TExprBase>>(TExprContext& ctx, TPositionHandle pos, BuildFuncType buildFunc,
-        TNodeBuilderBase::GetArgFuncType getArgFunc)
+        TNodeBuilderBase::GetArgFuncType getArgFunc) 
         : TListBuilderBase<TParent, TVector<TExprBase>, TExprBase>(ctx, pos, buildFunc, getArgFunc) {}
-
+ 
     TVector<TExprBase> DoBuild() {
-        return this->Items;
-    }
-};
-
-template <typename TParent, typename TDerived>
-class TFreeArgCallableBuilderBase : public TNodeBuilderBase {
-protected:
+        return this->Items; 
+    } 
+}; 
+ 
+template <typename TParent, typename TDerived> 
+class TFreeArgCallableBuilderBase : public TNodeBuilderBase { 
+protected: 
     TFreeArgCallableBuilderBase(TExprContext& ctx, TPositionHandle pos, GetArgFuncType getArgFunc)
-        : TNodeBuilderBase(ctx, pos, getArgFunc) {}
-
+        : TNodeBuilderBase(ctx, pos, getArgFunc) {} 
+ 
     TVector<TExprBase> FreeArgsHolder;
-
-public:
+ 
+public: 
     TNodeBuilder<TNodeBuilder<TParent, TDerived>, TVector<TExprBase>> FreeArgs() {
         return TNodeBuilder<TNodeBuilder<TParent, TDerived>, TVector<TExprBase>>(this->Ctx, this->Pos,
             [this] (const TVector<TExprBase>& freeArgs) mutable -> TNodeBuilder<TParent, TDerived>& {
-                FreeArgsHolder = freeArgs;
-                return *static_cast<TNodeBuilder<TParent, TDerived>*>(this);
-            }, GetArgFunc);
-    }
-};
-
-template<typename TNode>
-class TBuildValueHolder {
-public:
-    typedef TNode ResultType;
-
-    void SetValue(const TNode& node) {
+                FreeArgsHolder = freeArgs; 
+                return *static_cast<TNodeBuilder<TParent, TDerived>*>(this); 
+            }, GetArgFunc); 
+    } 
+}; 
+ 
+template<typename TNode> 
+class TBuildValueHolder { 
+public: 
+    typedef TNode ResultType; 
+ 
+    void SetValue(const TNode& node) { 
         Node = node.template Maybe<TNode>();
-    }
-
-    TNode Value() const {
-        YQL_ENSURE(Node);
-
-        return Node.Cast();
-    }
-
-private:
-    TMaybeNode<TNode> Node;
-};
-
-template<typename TNode>
+    } 
+ 
+    TNode Value() const { 
+        YQL_ENSURE(Node); 
+ 
+        return Node.Cast(); 
+    } 
+ 
+private: 
+    TMaybeNode<TNode> Node; 
+}; 
+ 
+template<typename TNode> 
 TNodeBuilder<TBuildValueHolder<TNode>, TNode> Build(TExprContext& ctx, TPositionHandle pos) {
-    TBuildValueHolder<TNode> holder;
-    TNodeBuilder<TBuildValueHolder<TNode>, TNode> builder(ctx, pos,
-        [holder](const TNode& node) mutable -> TBuildValueHolder<TNode>& {
-            holder.SetValue(node);
-            return holder;
-        },
-        [] (const TStringBuf& argName) -> TExprBase {
+    TBuildValueHolder<TNode> holder; 
+    TNodeBuilder<TBuildValueHolder<TNode>, TNode> builder(ctx, pos, 
+        [holder](const TNode& node) mutable -> TBuildValueHolder<TNode>& { 
+            holder.SetValue(node); 
+            return holder; 
+        }, 
+        [] (const TStringBuf& argName) -> TExprBase { 
             YQL_ENSURE(false, "Argument not found: " << ToString(argName));
-        });
-
-    return builder;
-}
-
-} //namespace NNodes
-} // namespace NYql
+        }); 
+ 
+    return builder; 
+} 
+ 
+} //namespace NNodes 
+} // namespace NYql 
diff --git a/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.jnj b/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.jnj
index 4b5733693f..7be576e8aa 100644
--- a/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.jnj
+++ b/ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.jnj
@@ -1,123 +1,123 @@
-// Auto-generated by {{ generator }}, do not modify.
-
-{% if genType == "Header" %}
-#pragma once
-
+// Auto-generated by {{ generator }}, do not modify. 
+ 
+{% if genType == "Header" %} 
+#pragma once 
+ 
 #include <ydb/library/yql/core/expr_nodes_gen/yql_expr_nodes_gen.h>
 #include <util/generic/hash_set.h>
-
-namespace NYql {
-namespace NNodes {
-namespace NGenerated {
-
-{% for node in nodes -%}
-template<{{ node.aux.typenames | join(", ") }}>
-class {{ node.aux.stubName }} :
-{%- if node.Base == model.FreeArgCallableBase %}
-    public {{ node.Base }}<{{ node.aux.allChildren | length}}> {
-{% else %}
-    public {{ node.Base }} {
-{%- endif %}
-public:
+ 
+namespace NYql { 
+namespace NNodes { 
+namespace NGenerated { 
+ 
+{% for node in nodes -%} 
+template<{{ node.aux.typenames | join(", ") }}> 
+class {{ node.aux.stubName }} : 
+{%- if node.Base == model.FreeArgCallableBase %} 
+    public {{ node.Base }}<{{ node.aux.allChildren | length}}> { 
+{% else %} 
+    public {{ node.Base }} { 
+{%- endif %} 
+public: 
     explicit {{ node.aux.stubName }}(const TExprNode* node)
         : {{ node.Base }}(node)
     {
     {%- if node.Match %}
-        YQL_ENSURE(Match(node));
+        YQL_ENSURE(Match(node)); 
     {%- endif %}
     }
 
     explicit {{ node.aux.stubName }}(const TExprNode::TPtr& node)
-        : {{ node.Base }}(node)
-    {
-    {%- if node.Match %}
-        YQL_ENSURE(Match(node.Get()));
-    {%- endif %}
-    }
-
-    {%- if node.Content %}
+        : {{ node.Base }}(node) 
+    { 
+    {%- if node.Match %} 
+        YQL_ENSURE(Match(node.Get())); 
+    {%- endif %} 
+    } 
+ 
+    {%- if node.Content %} 
         {% if node.Content.Type == "TStringBuf" %}
     TStringBuf {{ node.Content.Name }}() const {
         return this->Ref().Content();
-    }
-        {% else %}
-    static_assert(false, "Node {{node.Name}}: {{node.Content.Type}} is not supported as content type.");
-        {% endif %}
-    {% endif %}
-    {% for child in node.Children %}
-    static const size_t idx_{{child.Name}} = {{child.Index}};
-        {% if child.Optional %}
-    TMaybeNode<{{child.Type}}> {{child.Name}}() const {
-        return idx_{{child.Name}} < this->Ref().ChildrenSize()
-            ? {{child.Type}}(this->Ref().ChildPtr(idx_{{child.Name}}))
-            : TMaybeNode<{{child.Type}}>();
-    }
-        {% else %}
-    {{child.Type}} {{child.Name}}() const {
-        return {{child.Type}}(this->Ref().ChildPtr(idx_{{child.Name}}));
-    }
+    } 
+        {% else %} 
+    static_assert(false, "Node {{node.Name}}: {{node.Content.Type}} is not supported as content type."); 
+        {% endif %} 
+    {% endif %} 
+    {% for child in node.Children %} 
+    static const size_t idx_{{child.Name}} = {{child.Index}}; 
+        {% if child.Optional %} 
+    TMaybeNode<{{child.Type}}> {{child.Name}}() const { 
+        return idx_{{child.Name}} < this->Ref().ChildrenSize() 
+            ? {{child.Type}}(this->Ref().ChildPtr(idx_{{child.Name}})) 
+            : TMaybeNode<{{child.Type}}>(); 
+    } 
+        {% else %} 
+    {{child.Type}} {{child.Name}}() const { 
+        return {{child.Type}}(this->Ref().ChildPtr(idx_{{child.Name}})); 
+    } 
         {% endif -%}
-    {%- endfor %}
-
-    {%- if node.Match %}
-
-    static bool Match(const TExprNode* node) {
-        {%- if node.Match.Type == "Callable" %}
+    {%- endfor %} 
+ 
+    {%- if node.Match %} 
+ 
+    static bool Match(const TExprNode* node) { 
+        {%- if node.Match.Type == "Callable" %} 
         return node->IsCallable(TStringBuf("{{ node.Match.Name }}"));
-        {% elif node.Match.Type == "NodeType" %}
+        {% elif node.Match.Type == "NodeType" %} 
         return node->Type() == TExprNode::{{ node.Match.TypeName }};
-        {% elif node.Match.Type == "CallableBase" %}
+        {% elif node.Match.Type == "CallableBase" %} 
         static THashSet<TStringBuf> namesToMatch = {
-            {%- for name in node.aux.namesToMatch %}
+            {%- for name in node.aux.namesToMatch %} 
             TStringBuf("{{ name }}"),
             {%- endfor %}
         };
         return node->IsCallable(namesToMatch);
-        {% elif node.Match.Type == "Tuple" %}
-        return node->IsList()
-            && node->ChildrenSize() >= {{ node.aux.fixedChildrenCount }}
-            && node->ChildrenSize() <= {{ node.aux.allChildrenCount }};
-        {% else %}
-        static_assert(false, "Don't know how to match {{ node.Name }}.");
-        {% endif %}
-    }
-        {%- if node.Match.Type == "Callable" %}
-    static const TStringBuf CallableName() {
+        {% elif node.Match.Type == "Tuple" %} 
+        return node->IsList() 
+            && node->ChildrenSize() >= {{ node.aux.fixedChildrenCount }} 
+            && node->ChildrenSize() <= {{ node.aux.allChildrenCount }}; 
+        {% else %} 
+        static_assert(false, "Don't know how to match {{ node.Name }}."); 
+        {% endif %} 
+    } 
+        {%- if node.Match.Type == "Callable" %} 
+    static const TStringBuf CallableName() { 
         return "{{ node.Match.Name }}"sv;
-    }
-        {%- endif %}
-    {%- endif %}
-};
-
-template<template<typename> class TMaybe, typename TDerived, {{ node.aux.typenames | join(", ") }}>
-class {{ node.aux.stubMaybeName }} : public TMaybe<{{node.Base}}> {
-protected:
+    } 
+        {%- endif %} 
+    {%- endif %} 
+}; 
+ 
+template<template<typename> class TMaybe, typename TDerived, {{ node.aux.typenames | join(", ") }}> 
+class {{ node.aux.stubMaybeName }} : public TMaybe<{{node.Base}}> { 
+protected: 
     {{ node.aux.stubMaybeName }}(const TExprNode* node)
         : TMaybe<{{ node.Base }}>(node && TDerived::Match(node) ? node : nullptr) {}
     {{ node.aux.stubMaybeName }}(const TExprNode::TPtr& node)
         : TMaybe<{{ node.Base }}>(node && TDerived::Match(node.Get()) ? node : TExprNode::TPtr()) {}
-public:
-    {% for child in node.Children %}
-    TMaybe<{{child.Type}}> {{child.Name}}() const {
+public: 
+    {% for child in node.Children %} 
+    TMaybe<{{child.Type}}> {{child.Name}}() const { 
         return TMaybe<{{child.Type}}>(this->IsValid() {% if child.Optional %}&& {{child.Index}} < this->Ref().ChildrenSize() {% endif %}? this->Ref().ChildPtr({{child.Index}}) : TExprNode::TPtr());
-    }
-    {% endfor %}
-    TDerived Cast() const {
+    } 
+    {% endfor %} 
+    TDerived Cast() const { 
         return TMaybe<{{node.Base}}>::Cast().template Cast<TDerived>();
-    }
-};
-
-    {% if node.aux.generateBuilderStub %}
-template<typename TBase, typename TParent, template<typename, typename> class TBuilder, typename TDerived, template<typename> class TMaybe, {{ node.aux.builderTypenames | join(", ") }}>
-class {{ node.aux.stubBuilderName }} : public TBase {
-protected:
-    typedef std::function<TParent& (const TDerived&)> BuildFuncType;
-
+    } 
+}; 
+ 
+    {% if node.aux.generateBuilderStub %} 
+template<typename TBase, typename TParent, template<typename, typename> class TBuilder, typename TDerived, template<typename> class TMaybe, {{ node.aux.builderTypenames | join(", ") }}> 
+class {{ node.aux.stubBuilderName }} : public TBase { 
+protected: 
+    typedef std::function<TParent& (const TDerived&)> BuildFuncType; 
+ 
     {{ node.aux.stubBuilderName }}(TExprContext& ctx, TPositionHandle pos, BuildFuncType buildFunc, typename TBase::GetArgFuncType getArgFunc)
-        : TBase(ctx, pos, getArgFunc)
-        , BuildFunc(buildFunc) {}
-
-    void Check() {
+        : TBase(ctx, pos, getArgFunc) 
+        , BuildFunc(buildFunc) {} 
+ 
+    void Check() { 
         {% if node.Match and node.Match.Type == "CallableBase" %}
         if (CallableNameHolder.empty()) {
             ythrow yexception() << "{{node.Name}} builder: CallableName not defined.";
@@ -132,48 +132,48 @@ protected:
             ythrow yexception() << "{{node.Name}} builder: Invalid CallableName: " << CallableNameHolder;
         }
         {% endif %}
-        {% if node.aux.allChildren | count > 0 %}
-        bool argsValid = true;
-        bool argValid;
-            {%- for child in node.aux.allChildren %}
-        argValid = {{child.aux.holderName}}.IsValid();
-                {% if child.Optional %}
-        if (!argsValid && argValid) {
-            ythrow yexception() << "{{node.Name}} builder: optional args mismatch: {{child.Name}}.";
-        }
-                {% else %}
-        if (!argValid || !argsValid) {
-            ythrow yexception() << "{{node.Name}} builder: {{child.Name}} not defined.";
-        }
-                {% endif %}
-        argsValid = argValid;
-            {%- endfor %}
-        {% endif %}
-    }
-
+        {% if node.aux.allChildren | count > 0 %} 
+        bool argsValid = true; 
+        bool argValid; 
+            {%- for child in node.aux.allChildren %} 
+        argValid = {{child.aux.holderName}}.IsValid(); 
+                {% if child.Optional %} 
+        if (!argsValid && argValid) { 
+            ythrow yexception() << "{{node.Name}} builder: optional args mismatch: {{child.Name}}."; 
+        } 
+                {% else %} 
+        if (!argValid || !argsValid) { 
+            ythrow yexception() << "{{node.Name}} builder: {{child.Name}} not defined."; 
+        } 
+                {% endif %} 
+        argsValid = argValid; 
+            {%- endfor %} 
+        {% endif %} 
+    } 
+ 
     {% if node.Match and node.Match.Type == "CallableBase" %}
     TString CallableNameHolder;
     {% endif %}
-    {% for child in node.aux.allChildren %}
-    TMaybe<{{child.Type}}> {{child.aux.holderName}};
-    {%- endfor %}
-
-    BuildFuncType BuildFunc;
-
-public:
-    typedef TDerived ResultType;
-
-    TParent& Build() {
-        Check();
-        TDerived node = static_cast<TBuilder<TParent, TDerived>*>(this)->DoBuild();
-        return BuildFunc(node);
-    }
-
-    typename TParent::ResultType Done() {
-        TParent& parent = Build();
-        return parent.Value();
-    }
-
+    {% for child in node.aux.allChildren %} 
+    TMaybe<{{child.Type}}> {{child.aux.holderName}}; 
+    {%- endfor %} 
+ 
+    BuildFuncType BuildFunc; 
+ 
+public: 
+    typedef TDerived ResultType; 
+ 
+    TParent& Build() { 
+        Check(); 
+        TDerived node = static_cast<TBuilder<TParent, TDerived>*>(this)->DoBuild(); 
+        return BuildFunc(node); 
+    } 
+ 
+    typename TParent::ResultType Done() { 
+        TParent& parent = Build(); 
+        return parent.Value(); 
+    } 
+ 
     {% if node.aux.allChildren | count > 0 %}
     TNodeBuilder<TParent, TDerived>& InitFrom(const ResultType& item) {
         {% if node.Match.Type == "CallableBase" %}
@@ -201,176 +201,176 @@ public:
     TBuilder<TParent, TDerived>& CallableName(TStringBuf name) { CallableNameHolder = name; return *static_cast<TBuilder<TParent, TDerived>*>(this); }
     {% endif %}
 
-    {%- for child in node.aux.allChildren %}
+    {%- for child in node.aux.allChildren %} 
     TBuilder<TParent, TDerived>& {{child.Name}}(const TStringBuf& argName) { {{child.aux.holderName}} = {{child.Type}}(this->GetArgFunc(argName)); return *static_cast<TBuilder<TParent, TDerived>*>(this); }
         {% if child.Optional %}
     TBuilder<TParent, TDerived>& {{child.Name}}(const TMaybe<{{child.Type}}>& node) { {{child.aux.holderName}} = node; return *static_cast<TBuilder<TParent, TDerived>*>(this); }
         {% endif %}
-    TBuilder<TParent, TDerived>& {{child.Name}}(const {{child.Type}}& node) { {{child.aux.holderName}} = node; return *static_cast<TBuilder<TParent, TDerived>*>(this); }
-
+    TBuilder<TParent, TDerived>& {{child.Name}}(const {{child.Type}}& node) { {{child.aux.holderName}} = node; return *static_cast<TBuilder<TParent, TDerived>*>(this); } 
+ 
     TBuilder<TParent, TDerived>& {{child.Name}}(const TExprNode::TPtr& node) { {{child.aux.holderName}} = {{child.Type}}(node); return *static_cast<TBuilder<TParent, TDerived>*>(this); }
-
+ 
     TBuilder<TParent, TDerived>& {{child.Name}}(std::function<void(TExprNodeBuilder&)> fluentFunc) {
-        TExprNodeBuilder fluentBuilder(this->Pos, this->Ctx, [this] (const TStringBuf& argName) {
+        TExprNodeBuilder fluentBuilder(this->Pos, this->Ctx, [this] (const TStringBuf& argName) { 
             return this->GetArgFunc(argName).Ptr();
-        });
-
+        }); 
+ 
         fluentFunc(fluentBuilder);
         {{child.aux.holderName}} = fluentBuilder.Build();
         return *static_cast<TBuilder<TParent, TDerived>*>(this);
-    }
-
-    TBuilder<TBuilder<TParent, TDerived>, {{child.Type}}> {{child.Name}}() {
-        return TBuilder<TBuilder<TParent, TDerived>, {{child.Type}}>(this->Ctx, this->Pos,
-            [this] (const {{child.Type}}& node) mutable -> TBuilder<TParent, TDerived>& {
+    } 
+ 
+    TBuilder<TBuilder<TParent, TDerived>, {{child.Type}}> {{child.Name}}() { 
+        return TBuilder<TBuilder<TParent, TDerived>, {{child.Type}}>(this->Ctx, this->Pos, 
+            [this] (const {{child.Type}}& node) mutable -> TBuilder<TParent, TDerived>& { 
                 {{child.aux.holderName}} = node;
                 return *static_cast<TBuilder<TParent, TDerived>*>(this);
-            }, this->GetArgFunc);
-    }
-
-    template<typename TNode>
-    TBuilder<TBuilder<TParent, TDerived>, TNode> {{child.Name}}() {
-        return TBuilder<TBuilder<TParent, TDerived>, TNode>(this->Ctx, this->Pos,
+            }, this->GetArgFunc); 
+    } 
+ 
+    template<typename TNode> 
+    TBuilder<TBuilder<TParent, TDerived>, TNode> {{child.Name}}() { 
+        return TBuilder<TBuilder<TParent, TDerived>, TNode>(this->Ctx, this->Pos, 
             [this] (const TNode& node) mutable -> TBuilder<TParent, TDerived>&{
                 {{child.aux.holderName}} = node;
                 return *static_cast<TBuilder<TParent, TDerived>*>(this);
-            }, this->GetArgFunc);
-    }
-    {%- endfor %}
-};
-    {% endif %}
-
-{% endfor %}
-
-} // namespace NGenerated
-} // namespace NNodes
-} // namespace NYql
-{% elif genType == "Declarations" -%}
-
-{% for node in nodes %}
-    {%- if node.Definition == "Custom" %}
-class {{ node.Name }};
-    {% else %}
-using {{ node.Name }} = NGenerated::{{ node.aux.stubName }}<{{ node.aux.usages | join(", ") }}>;
-    {% endif %}
-{%- endfor %}
-
-{% elif genType == "Definitions" -%}
-
-{% for node in nodes %}
+            }, this->GetArgFunc); 
+    } 
+    {%- endfor %} 
+}; 
+    {% endif %} 
+ 
+{% endfor %} 
+ 
+} // namespace NGenerated 
+} // namespace NNodes 
+} // namespace NYql 
+{% elif genType == "Declarations" -%} 
+ 
+{% for node in nodes %} 
+    {%- if node.Definition == "Custom" %} 
+class {{ node.Name }}; 
+    {% else %} 
+using {{ node.Name }} = NGenerated::{{ node.aux.stubName }}<{{ node.aux.usages | join(", ") }}>; 
+    {% endif %} 
+{%- endfor %} 
+ 
+{% elif genType == "Definitions" -%} 
+ 
+{% for node in nodes %} 
 static_assert(std::is_constructible<{{ node.Name }}, const TExprNode*>::value,
     "{{ node.Name }} isn't defined correctly.");
 static_assert(std::is_constructible<{{ node.Name }}, const TExprNode::TPtr&>::value,
-    "{{ node.Name }} isn't defined correctly.");
-{% endfor %}
-
-{% for node in nodes %}
-template<>
-class TMaybeNode<{{ node.Name }}> : public NGenerated::
-    {{ node.aux.stubMaybeName }}<TMaybeNode, {{ node.Name }}, {{ node.aux.usages | join(", ") }}>
-{
-public:
+    "{{ node.Name }} isn't defined correctly."); 
+{% endfor %} 
+ 
+{% for node in nodes %} 
+template<> 
+class TMaybeNode<{{ node.Name }}> : public NGenerated:: 
+    {{ node.aux.stubMaybeName }}<TMaybeNode, {{ node.Name }}, {{ node.aux.usages | join(", ") }}> 
+{ 
+public: 
     TMaybeNode(const TExprNode* node = nullptr) : {{ node.aux.stubMaybeName }}(node) {}
     TMaybeNode(const TExprNode::TPtr& node) : {{ node.aux.stubMaybeName }}(node) {}
     TMaybeNode(const {{ node.Name }}& node) : {{ node.aux.stubMaybeName }}(node.template Maybe<{{ node.Name }}>()) {}
-};
-{% endfor %}
-
-namespace NGenerated {
-{% for node in nodes %}
-    {%- if node.aux.generateBuilderStub %}
+}; 
+{% endfor %} 
+ 
+namespace NGenerated { 
+{% for node in nodes %} 
+    {%- if node.aux.generateBuilderStub %} 
         {%- if node.Builder.Kind == "Node" %}
 template<typename TParent>
-using {{ node.aux.stubBuilderAliasName }} =
-    NGenerated::{{ node.aux.stubBuilderName }}<{{ model.NodeBuilderBase }}, TParent, TNodeBuilder, {{ node.Name }},
-        TMaybeNode, {{ node.aux.builderUsages | join(", ") }}>;
-        {% elif node.Builder.Kind == "FreeArg" %}
-template<typename TParent>
-using {{ node.aux.stubBuilderAliasName }} =
-    NGenerated::{{ node.aux.stubBuilderName }}<{{ model.FreeArgBuilderBase }}<TParent, {{ node.Name }}>, TParent, TNodeBuilder, {{ node.Name }},
-        TMaybeNode, {{ node.aux.builderUsages | join(", ") }}>;
-        {% endif %}
-    {% endif %}
-{%- endfor %}
-} // namespace NGenerated
-
-{% for node in nodes %}
-    {%- if node.aux.generateBuilder %}
-        {% if node.Builder.Kind == "Node" or node.Builder.Kind == "FreeArg" %}
-template<typename TParent>
-class TNodeBuilder<TParent, {{ node.Name }}> : public NGenerated::{{ node.aux.stubBuilderAliasName }}<TParent>
-{
-private:
-    typedef typename NGenerated::{{ node.aux.stubBuilderAliasName }}<TParent>::BuildFuncType BuildFuncType;
-    typedef typename NGenerated::{{ node.aux.stubBuilderAliasName }}<TParent>::GetArgFuncType GetArgFuncType;
-public:
+using {{ node.aux.stubBuilderAliasName }} = 
+    NGenerated::{{ node.aux.stubBuilderName }}<{{ model.NodeBuilderBase }}, TParent, TNodeBuilder, {{ node.Name }}, 
+        TMaybeNode, {{ node.aux.builderUsages | join(", ") }}>; 
+        {% elif node.Builder.Kind == "FreeArg" %} 
+template<typename TParent> 
+using {{ node.aux.stubBuilderAliasName }} = 
+    NGenerated::{{ node.aux.stubBuilderName }}<{{ model.FreeArgBuilderBase }}<TParent, {{ node.Name }}>, TParent, TNodeBuilder, {{ node.Name }}, 
+        TMaybeNode, {{ node.aux.builderUsages | join(", ") }}>; 
+        {% endif %} 
+    {% endif %} 
+{%- endfor %} 
+} // namespace NGenerated 
+ 
+{% for node in nodes %} 
+    {%- if node.aux.generateBuilder %} 
+        {% if node.Builder.Kind == "Node" or node.Builder.Kind == "FreeArg" %} 
+template<typename TParent> 
+class TNodeBuilder<TParent, {{ node.Name }}> : public NGenerated::{{ node.aux.stubBuilderAliasName }}<TParent> 
+{ 
+private: 
+    typedef typename NGenerated::{{ node.aux.stubBuilderAliasName }}<TParent>::BuildFuncType BuildFuncType; 
+    typedef typename NGenerated::{{ node.aux.stubBuilderAliasName }}<TParent>::GetArgFuncType GetArgFuncType; 
+public: 
     TNodeBuilder(TExprContext& ctx, TPositionHandle pos, BuildFuncType buildFunc, GetArgFuncType getArgFunc)
-        : NGenerated::{{ node.aux.stubBuilderAliasName }}<TParent>(ctx, pos, buildFunc, getArgFunc) {}
-        {% elif node.Builder.Kind == "List" %}
-template<typename TParent>
-class TNodeBuilder<TParent, {{ node.Name }}> : public TListBuilderBase<TParent, {{ node.Name }}, {{ node.Builder.ListItemType }}>
-{
-private:
-    typedef typename TListBuilderBase<TParent, {{ node.Name }}, {{ node.Builder.ListItemType }}>::BuildFuncType BuildFuncType;
-    typedef typename TListBuilderBase<TParent, {{ node.Name }}, {{ node.Builder.ListItemType }}>::GetArgFuncType GetArgFuncType;
-public:
+        : NGenerated::{{ node.aux.stubBuilderAliasName }}<TParent>(ctx, pos, buildFunc, getArgFunc) {} 
+        {% elif node.Builder.Kind == "List" %} 
+template<typename TParent> 
+class TNodeBuilder<TParent, {{ node.Name }}> : public TListBuilderBase<TParent, {{ node.Name }}, {{ node.Builder.ListItemType }}> 
+{ 
+private: 
+    typedef typename TListBuilderBase<TParent, {{ node.Name }}, {{ node.Builder.ListItemType }}>::BuildFuncType BuildFuncType; 
+    typedef typename TListBuilderBase<TParent, {{ node.Name }}, {{ node.Builder.ListItemType }}>::GetArgFuncType GetArgFuncType; 
+public: 
     TNodeBuilder(TExprContext& ctx, TPositionHandle pos, BuildFuncType buildFunc, GetArgFuncType getArgFunc)
-        : TListBuilderBase<TParent, {{ node.Name }}, {{ node.Builder.ListItemType }}>(ctx, pos, buildFunc, getArgFunc) {}
-        {% else %}
-class UnknownBuilder {
-    static_assert(false, "Unknown builder kind: {{ node.Builder.Kind }}.");
-        {% endif %}
-    {{ node.Name }} DoBuild() {
+        : TListBuilderBase<TParent, {{ node.Name }}, {{ node.Builder.ListItemType }}>(ctx, pos, buildFunc, getArgFunc) {} 
+        {% else %} 
+class UnknownBuilder { 
+    static_assert(false, "Unknown builder kind: {{ node.Builder.Kind }}."); 
+        {% endif %} 
+    {{ node.Name }} DoBuild() { 
         {%- if node.Match and (node.Match.Type == "Callable" or node.Match.Type == "CallableBase") %}
         TExprNode::TListType argsList;
-            {%- if node.Builder.Kind == "List" %}
-        for (auto child : this->Items) {
-            argsList.push_back(child.Ptr());
-        }
-            {%- else %}
-                {%- for child in node.aux.allChildren %}
+            {%- if node.Builder.Kind == "List" %} 
+        for (auto child : this->Items) { 
+            argsList.push_back(child.Ptr()); 
+        } 
+            {%- else %} 
+                {%- for child in node.aux.allChildren %} 
         if (this->{{ child.aux.holderName }}) {
-            YQL_ENSURE(argsList.size() == {{ child.Index }});
-            argsList.push_back(this->{{ child.aux.holderName }}.Cast().Ptr());
-        }
-                {%- endfor %}
-                {% if node.Builder.Kind == "FreeArg" %}
-        size_t fixedChildCount = {{ node.aux.allChildren | length }};
-        YQL_ENSURE(argsList.size() == fixedChildCount);
-        for (size_t i = 0; i < this->FreeArgsHolder.size(); ++i) {
-            argsList.push_back(this->FreeArgsHolder[i].Ptr());
-        }
-                {% endif %}
-            {%- endif %}
+            YQL_ENSURE(argsList.size() == {{ child.Index }}); 
+            argsList.push_back(this->{{ child.aux.holderName }}.Cast().Ptr()); 
+        } 
+                {%- endfor %} 
+                {% if node.Builder.Kind == "FreeArg" %} 
+        size_t fixedChildCount = {{ node.aux.allChildren | length }}; 
+        YQL_ENSURE(argsList.size() == fixedChildCount); 
+        for (size_t i = 0; i < this->FreeArgsHolder.size(); ++i) { 
+            argsList.push_back(this->FreeArgsHolder[i].Ptr()); 
+        } 
+                {% endif %} 
+            {%- endif %} 
             {%- if node.Match.Type == "CallableBase" %}
         auto node = this->Ctx.NewCallable(this->Pos, this->CallableNameHolder, std::move(argsList));
             {%- else %}
-        auto node = this->Ctx.NewCallable(this->Pos, "{{ node.Match.Name }}", std::move(argsList));
+        auto node = this->Ctx.NewCallable(this->Pos, "{{ node.Match.Name }}", std::move(argsList)); 
             {%- endif %}
-        return {{ node.Name }}(node);
-        {%- elif node.Match and node.Match.Type == "Tuple"%}
+        return {{ node.Name }}(node); 
+        {%- elif node.Match and node.Match.Type == "Tuple"%} 
         TExprNode::TListType tupleItems;
-            {%- for child in node.aux.allChildren %}
-        if (this->{{ child.aux.holderName }}) {
-            YQL_ENSURE(tupleItems.size() == {{ child.Index }});
-            tupleItems.push_back(this->{{ child.aux.holderName }}.Cast().Ptr());
-        }
-            {%- endfor %}
-        auto node = this->Ctx.NewList(this->Pos, std::move(tupleItems));
-        return {{ node.Name }}(node);
-        {%- elif node.ListBase and node.Builder.Kind == "List"%}
+            {%- for child in node.aux.allChildren %} 
+        if (this->{{ child.aux.holderName }}) { 
+            YQL_ENSURE(tupleItems.size() == {{ child.Index }}); 
+            tupleItems.push_back(this->{{ child.aux.holderName }}.Cast().Ptr()); 
+        } 
+            {%- endfor %} 
+        auto node = this->Ctx.NewList(this->Pos, std::move(tupleItems)); 
+        return {{ node.Name }}(node); 
+        {%- elif node.ListBase and node.Builder.Kind == "List"%} 
         TExprNode::TListType nodeChildren;
-        for (auto child : this->Items) {
+        for (auto child : this->Items) { 
             nodeChildren.push_back(child.Ptr());
-        }
+        } 
         auto node = this->Ctx.NewList(this->Pos, std::move(nodeChildren));
-        return {{ node.Name }}(node);
-        {%- else %}
-        static_assert(false, "Don't know how to build {{ node.Name }}.");
-        {% endif %}
-    }
-};
-    {%- endif %}
-{%- endfor %}
-
+        return {{ node.Name }}(node); 
+        {%- else %} 
+        static_assert(false, "Don't know how to build {{ node.Name }}."); 
+        {% endif %} 
+    } 
+}; 
+    {%- endif %} 
+{%- endfor %} 
+ 
 {% endif %}
diff --git a/ydb/library/yql/core/facade/yql_facade.cpp b/ydb/library/yql/core/facade/yql_facade.cpp
index b74abc1c34..a56ee2345d 100644
--- a/ydb/library/yql/core/facade/yql_facade.cpp
+++ b/ydb/library/yql/core/facade/yql_facade.cpp
@@ -30,7 +30,7 @@
 
 #include <util/stream/file.h>
 #include <util/stream/null.h>
-#include <util/string/split.h>
+#include <util/string/split.h> 
 #include <util/generic/guid.h>
 #include <util/system/rusage.h>
 #include <util/generic/yexception.h>
@@ -42,9 +42,9 @@ namespace NYql {
 
 namespace {
 
-const size_t DEFAULT_AST_BUF_SIZE = 1024;
-const size_t DEFAULT_PLAN_BUF_SIZE = 1024;
-
+const size_t DEFAULT_AST_BUF_SIZE = 1024; 
+const size_t DEFAULT_PLAN_BUF_SIZE = 1024; 
+ 
 class TUrlLoader : public IUrlLoader {
 public:
     TUrlLoader(TFileStoragePtr storage)
@@ -79,10 +79,10 @@ TProgram::TStatus SyncExecution(
         status = continueFuture.GetValue();
     }
 
-    if (status == TProgram::TStatus::Error) {
-        program->Print(program->ExprStream(), program->PlanStream());
-    }
-
+    if (status == TProgram::TStatus::Error) { 
+        program->Print(program->ExprStream(), program->PlanStream()); 
+    } 
+ 
     return status;
 }
 
@@ -147,10 +147,10 @@ void TProgramFactory::AddCredentialsTable(TCredentialTablePtr credentialTable) {
     CredentialTables_.push_back(credentialTable);
 }
 
-void TProgramFactory::SetUserCredentials(const TUserCredentials& userCredentials) {
-    UserCredentials_ = userCredentials;
-}
-
+void TProgramFactory::SetUserCredentials(const TUserCredentials& userCredentials) { 
+    UserCredentials_ = userCredentials; 
+} 
+ 
 void TProgramFactory::SetGatewaysConfig(const TGatewaysConfig* gatewaysConfig) {
     GatewaysConfig_ = gatewaysConfig;
 }
@@ -196,7 +196,7 @@ TProgramPtr TProgramFactory::Create(
     auto udfResolver = udfIndex ? NCommon::CreateUdfResolverWithIndex(udfIndex, UdfResolver_, FileStorage_) : UdfResolver_;
 
     // make UserDataTable_ copy here
-    return new TProgram(FunctionRegistry_, randomProvider, timeProvider, NextUniqueId_, DataProvidersInit_,
+    return new TProgram(FunctionRegistry_, randomProvider, timeProvider, NextUniqueId_, DataProvidersInit_, 
         UserDataTable_, CredentialTables_, UserCredentials_, moduleResolver, udfResolver, udfIndex, udfIndexPackageSet, FileStorage_,
         GatewaysConfig_, filename, sourceCode, sessionId, Runner_, EnableRangeComputeFor_);
 }
@@ -212,7 +212,7 @@ TProgram::TProgram(
         const TVector<TDataProviderInitializer>& dataProvidersInit,
         const TUserDataTable& userDataTable,
         const TVector<TCredentialTablePtr>& credentialTables,
-        const TUserCredentials& userCredentials,
+        const TUserCredentials& userCredentials, 
         const IModuleResolver::TPtr& modules,
         const IUdfResolver::TPtr& udfResolver,
         const TUdfIndex::TPtr& udfIndex,
@@ -231,7 +231,7 @@ TProgram::TProgram(
     , NextUniqueId_(nextUniqueId)
     , DataProvidersInit_(dataProvidersInit)
     , CredentialTables_(credentialTables)
-    , UserCredentials_(userCredentials)
+    , UserCredentials_(userCredentials) 
     , UdfResolver_(udfResolver)
     , UdfIndex_(udfIndex)
     , UdfIndexPackageSet_(udfIndexPackageSet)
@@ -240,7 +240,7 @@ TProgram::TProgram(
     , GatewaysConfig_(gatewaysConfig)
     , Filename_(filename)
     , SourceCode_(sourceCode)
-    , SourceSyntax_(ESourceSyntax::Unknown)
+    , SourceSyntax_(ESourceSyntax::Unknown) 
     , SyntaxVersion_(0)
     , AstRoot_(nullptr)
     , Modules_(modules)
@@ -387,14 +387,14 @@ TString TProgram::TakeSessionId() {
     }
 }
 
-bool TProgram::ParseYql() {
-    YQL_PROFILE_FUNC(TRACE);
-    YQL_ENSURE(SourceSyntax_ == ESourceSyntax::Unknown);
-    SourceSyntax_ = ESourceSyntax::Yql;
+bool TProgram::ParseYql() { 
+    YQL_PROFILE_FUNC(TRACE); 
+    YQL_ENSURE(SourceSyntax_ == ESourceSyntax::Unknown); 
+    SourceSyntax_ = ESourceSyntax::Yql; 
     SyntaxVersion_ = 1;
     return FillParseResult(ParseAst(SourceCode_));
-}
-
+} 
+ 
 bool TProgram::ParseSql() {
     YQL_PROFILE_FUNC(TRACE);
 
@@ -410,8 +410,8 @@ bool TProgram::ParseSql() {
 bool TProgram::ParseSql(const NSQLTranslation::TTranslationSettings& settings)
 {
     YQL_PROFILE_FUNC(TRACE);
-    YQL_ENSURE(SourceSyntax_ == ESourceSyntax::Unknown);
-    SourceSyntax_ = ESourceSyntax::Sql;
+    YQL_ENSURE(SourceSyntax_ == ESourceSyntax::Unknown); 
+    SourceSyntax_ = ESourceSyntax::Sql; 
     SyntaxVersion_ = settings.SyntaxVersion;
     NYql::TWarningRules warningRules;
     return FillParseResult(SqlToYql(SourceCode_, settings, &warningRules), &warningRules);
@@ -419,7 +419,7 @@ bool TProgram::ParseSql(const NSQLTranslation::TTranslationSettings& settings)
 
 bool TProgram::Compile(const TString& username) {
     YQL_PROFILE_FUNC(TRACE);
-
+ 
     Y_ENSURE(AstRoot_, "Program not parsed yet");
     if (!ExprCtx_) {
         ExprCtx_.Reset(new TExprContext(NextUniqueId_));
@@ -439,71 +439,71 @@ bool TProgram::Compile(const TString& username) {
     }
 
     if (!CompileExpr(*AstRoot_, ExprRoot_, *ExprCtx_, Modules_.get(), 0, SyntaxVersion_)) {
-        return false;
-    }
-
-    return true;
+        return false; 
+    } 
+ 
+    return true; 
 }
 
-bool TProgram::CollectUsedClusters() {
-    using namespace NNodes;
-
-    if (!UsedClusters_) {
-        UsedClusters_.ConstructInPlace();
-        UsedProviders_.ConstructInPlace();
-
-        auto& typesCtx = *GetAnnotationContext();
-        auto& ctx = *ExprCtx_;
-        auto& usedClusters = *UsedClusters_;
-        auto& usedProviders = *UsedProviders_;
-        bool hasErrors = false;
-
-        VisitExpr(ExprRoot_, [&typesCtx, &ctx, &usedClusters, &usedProviders, &hasErrors](const TExprNode::TPtr& node) {
+bool TProgram::CollectUsedClusters() { 
+    using namespace NNodes; 
+ 
+    if (!UsedClusters_) { 
+        UsedClusters_.ConstructInPlace(); 
+        UsedProviders_.ConstructInPlace(); 
+ 
+        auto& typesCtx = *GetAnnotationContext(); 
+        auto& ctx = *ExprCtx_; 
+        auto& usedClusters = *UsedClusters_; 
+        auto& usedProviders = *UsedProviders_; 
+        bool hasErrors = false; 
+ 
+        VisitExpr(ExprRoot_, [&typesCtx, &ctx, &usedClusters, &usedProviders, &hasErrors](const TExprNode::TPtr& node) { 
             if (auto dsNode = TMaybeNode<TCoDataSource>(node)) {
                 auto datasource = typesCtx.DataSourceMap.FindPtr(dsNode.Cast().Category());
                 YQL_ENSURE(datasource, "Unknown DataSource: " << dsNode.Cast().Category().Value());
-
-                TMaybe<TString> cluster;
-                if (!(*datasource)->ValidateParameters(*node, ctx, cluster)) {
-                    hasErrors = true;
-                    return false;
-                }
-
-                usedProviders.insert(TString(dsNode.Cast().Category().Value()));
-                if (cluster && *cluster != NCommon::ALL_CLUSTERS) {
-                    usedClusters.insert(*cluster);
-                }
-            }
-
+ 
+                TMaybe<TString> cluster; 
+                if (!(*datasource)->ValidateParameters(*node, ctx, cluster)) { 
+                    hasErrors = true; 
+                    return false; 
+                } 
+ 
+                usedProviders.insert(TString(dsNode.Cast().Category().Value())); 
+                if (cluster && *cluster != NCommon::ALL_CLUSTERS) { 
+                    usedClusters.insert(*cluster); 
+                } 
+            } 
+ 
             if (auto dsNode = TMaybeNode<TCoDataSink>(node)) {
                 auto datasink = typesCtx.DataSinkMap.FindPtr(dsNode.Cast().Category());
                 YQL_ENSURE(datasink, "Unknown DataSink: " << dsNode.Cast().Category().Value());
-
-                TMaybe<TString> cluster;
-                if (!(*datasink)->ValidateParameters(*node, ctx, cluster)) {
-                    hasErrors = true;
-                    return false;
-                }
-
-                usedProviders.insert(TString(dsNode.Cast().Category().Value()));
-                if (cluster) {
-                    usedClusters.insert(*cluster);
-                }
-            }
-
-            return true;
-        });
-
-        if (hasErrors) {
-            UsedClusters_ = Nothing();
-            UsedProviders_ = Nothing();
-            return false;
-        }
-    }
-
-    return true;
-}
-
+ 
+                TMaybe<TString> cluster; 
+                if (!(*datasink)->ValidateParameters(*node, ctx, cluster)) { 
+                    hasErrors = true; 
+                    return false; 
+                } 
+ 
+                usedProviders.insert(TString(dsNode.Cast().Category().Value())); 
+                if (cluster) { 
+                    usedClusters.insert(*cluster); 
+                } 
+            } 
+ 
+            return true; 
+        }); 
+ 
+        if (hasErrors) { 
+            UsedClusters_ = Nothing(); 
+            UsedProviders_ = Nothing(); 
+            return false; 
+        } 
+    } 
+ 
+    return true; 
+} 
+ 
 TProgram::TStatus TProgram::Discover(const TString& username) {
     YQL_PROFILE_FUNC(TRACE);
     auto m = &TProgram::DiscoverAsync;
@@ -554,7 +554,7 @@ TProgram::TFutureStatus TProgram::ValidateAsync(const TString& username, IOutput
     if (!ProvideAnnotationContext(username)->Initialize(*ExprCtx_) || !CollectUsedClusters()) {
         return NThreading::MakeFuture<TStatus>(IGraphTransformer::TStatus::Error);
     }
-    TypeCtx_->IsReadOnly = true;
+    TypeCtx_->IsReadOnly = true; 
 
     for (const auto& dp : DataProviders_) {
         if (!dp.RemoteClusterProvider || !dp.RemoteValidate) {
@@ -564,10 +564,10 @@ TProgram::TFutureStatus TProgram::ValidateAsync(const TString& username, IOutput
         if (auto cluster = dp.RemoteClusterProvider(UsedClusters_, UsedProviders_, SourceSyntax_)) {
             return dp.RemoteValidate(*cluster, SourceSyntax_, SourceCode_, *ExprCtx_);
         }
-    }
-
-    Y_ENSURE(ExprRoot_, "Program not compiled yet");
-
+    } 
+ 
+    Y_ENSURE(ExprRoot_, "Program not compiled yet"); 
+ 
     ExprStream_ = exprOut;
     Transformer_ = TTransformationPipeline(TypeCtx_)
             .AddServiceTransformers()
@@ -619,7 +619,7 @@ TProgram::TFutureStatus TProgram::OptimizeAsync(
     if (!ProvideAnnotationContext(username)->Initialize(*ExprCtx_) || !CollectUsedClusters()) {
         return NThreading::MakeFuture<TStatus>(IGraphTransformer::TStatus::Error);
     }
-    TypeCtx_->IsReadOnly = true;
+    TypeCtx_->IsReadOnly = true; 
 
     for (const auto& dp : DataProviders_) {
         if (!dp.RemoteClusterProvider || !dp.RemoteOptimize) {
@@ -631,10 +631,10 @@ TProgram::TFutureStatus TProgram::OptimizeAsync(
                 SourceSyntax_, SourceCode_, nullptr,
                 TypeCtx_, ExprRoot_, *ExprCtx_, ExternalQueryAst_, ExternalQueryPlan_);
         }
-    }
-
-    Y_ENSURE(ExprRoot_, "Program not compiled yet");
-
+    } 
+ 
+    Y_ENSURE(ExprRoot_, "Program not compiled yet"); 
+ 
     ExprStream_ = exprOut;
     PlanStream_ = tracePlan;
     Transformer_ = TTransformationPipeline(TypeCtx_)
@@ -647,7 +647,7 @@ TProgram::TFutureStatus TProgram::OptimizeAsync(
         .AddPostTypeAnnotation()
         .Add(TExprOutputTransformer::Sync(ExprRoot_, traceOut), "ExprOutput")
         .AddOptimization()
-        .Add(CreatePlanInfoTransformer(*TypeCtx_), "PlanInfo")
+        .Add(CreatePlanInfoTransformer(*TypeCtx_), "PlanInfo") 
         .Add(TExprOutputTransformer::Sync(ExprRoot_, exprOut, withTypes), "AstOutput")
         .Add(TPlanOutputTransformer::Sync(tracePlan, GetPlanBuilder(), OutputFormat_), "PlanOutput")
         .Build();
@@ -683,7 +683,7 @@ TProgram::TFutureStatus TProgram::OptimizeAsyncWithConfig(
     if (!ProvideAnnotationContext(username)->Initialize(*ExprCtx_) || !CollectUsedClusters()) {
         return NThreading::MakeFuture<TStatus>(IGraphTransformer::TStatus::Error);
     }
-    TypeCtx_->IsReadOnly = true;
+    TypeCtx_->IsReadOnly = true; 
 
     for (const auto& dp : DataProviders_) {
         if (!dp.RemoteClusterProvider || !dp.RemoteOptimize) {
@@ -695,10 +695,10 @@ TProgram::TFutureStatus TProgram::OptimizeAsyncWithConfig(
                 SourceSyntax_, SourceCode_, &pipelineConf,
                 TypeCtx_, ExprRoot_, *ExprCtx_, ExternalQueryAst_, ExternalQueryPlan_);
         }
-    }
-
-    Y_ENSURE(ExprRoot_, "Program not compiled yet");
-
+    } 
+ 
+    Y_ENSURE(ExprRoot_, "Program not compiled yet"); 
+ 
     TTransformationPipeline pipeline(TypeCtx_);
     pipelineConf.AfterCreate(&pipeline);
     pipeline.AddServiceTransformers();
@@ -716,7 +716,7 @@ TProgram::TFutureStatus TProgram::OptimizeAsyncWithConfig(
                      "ExpandRangeComputeFor", TIssuesIds::CORE_EXEC);
     }
 
-    pipeline.Add(CreatePlanInfoTransformer(*TypeCtx_), "PlanInfo");
+    pipeline.Add(CreatePlanInfoTransformer(*TypeCtx_), "PlanInfo"); 
     pipelineConf.AfterOptimize(&pipeline);
 
     Transformer_ = pipeline.Build();
@@ -760,7 +760,7 @@ TProgram::TFutureStatus TProgram::RunAsync(
     if (!ProvideAnnotationContext(username)->Initialize(*ExprCtx_) || !CollectUsedClusters()) {
         return NThreading::MakeFuture<TStatus>(IGraphTransformer::TStatus::Error);
     }
-    TypeCtx_->IsReadOnly = false;
+    TypeCtx_->IsReadOnly = false; 
 
     for (const auto& dp : DataProviders_) {
         if (!dp.RemoteClusterProvider || !dp.RemoteRun) {
@@ -773,10 +773,10 @@ TProgram::TFutureStatus TProgram::RunAsync(
                 TypeCtx_, ExprRoot_, *ExprCtx_, ExternalQueryAst_, ExternalQueryPlan_, ExternalDiagnostics_,
                 ResultProviderConfig_);
         }
-    }
-
-    Y_ENSURE(ExprRoot_, "Program not compiled yet");
-
+    } 
+ 
+    Y_ENSURE(ExprRoot_, "Program not compiled yet"); 
+ 
     ExprStream_ = exprOut;
     PlanStream_ = tracePlan;
 
@@ -834,7 +834,7 @@ TProgram::TFutureStatus TProgram::RunAsyncWithConfig(
     if (!ProvideAnnotationContext(username)->Initialize(*ExprCtx_) || !CollectUsedClusters()) {
         return NThreading::MakeFuture<TStatus>(IGraphTransformer::TStatus::Error);
     }
-    TypeCtx_->IsReadOnly = false;
+    TypeCtx_->IsReadOnly = false; 
 
     for (const auto& dp : DataProviders_) {
         if (!dp.RemoteClusterProvider || !dp.RemoteRun) {
@@ -847,10 +847,10 @@ TProgram::TFutureStatus TProgram::RunAsyncWithConfig(
                 TypeCtx_, ExprRoot_, *ExprCtx_, ExternalQueryAst_, ExternalQueryPlan_, ExternalDiagnostics_,
                 ResultProviderConfig_);
         }
-    }
-
-    Y_ENSURE(ExprRoot_, "Program not compiled yet");
-
+    } 
+ 
+    Y_ENSURE(ExprRoot_, "Program not compiled yet"); 
+ 
     TTransformationPipeline pipeline(TypeCtx_);
     pipelineConf.AfterCreate(&pipeline);
     pipeline.AddServiceTransformers();
@@ -997,90 +997,90 @@ TFuture<IGraphTransformer::TStatus> TProgram::AsyncTransformWithFallback(bool ap
     });
 }
 
-TMaybe<TString> TProgram::GetQueryAst() {
-    if (ExternalQueryAst_) {
-        return ExternalQueryAst_;
-    }
-
-    TStringStream astStream;
-    astStream.Reserve(DEFAULT_AST_BUF_SIZE);
-
-    if (ExprRoot_) {
+TMaybe<TString> TProgram::GetQueryAst() { 
+    if (ExternalQueryAst_) { 
+        return ExternalQueryAst_; 
+    } 
+ 
+    TStringStream astStream; 
+    astStream.Reserve(DEFAULT_AST_BUF_SIZE); 
+ 
+    if (ExprRoot_) { 
         auto ast = ConvertToAst(*ExprRoot_, *ExprCtx_, TExprAnnotationFlags::None, true);
-        ast.Root->PrettyPrintTo(astStream, TAstPrintFlags::ShortQuote | TAstPrintFlags::PerLine);
-        return astStream.Str();
-    } else if (AstRoot_) {
-        AstRoot_->PrettyPrintTo(astStream, TAstPrintFlags::ShortQuote | TAstPrintFlags::PerLine);
-        return astStream.Str();
-    }
-
-    return Nothing();
-}
-
-TMaybe<TString> TProgram::GetQueryPlan() {
-    if (ExternalQueryPlan_) {
-        return ExternalQueryPlan_;
-    }
-
-    if (ExprRoot_) {
-        TStringStream planStream;
-        planStream.Reserve(DEFAULT_PLAN_BUF_SIZE);
-
+        ast.Root->PrettyPrintTo(astStream, TAstPrintFlags::ShortQuote | TAstPrintFlags::PerLine); 
+        return astStream.Str(); 
+    } else if (AstRoot_) { 
+        AstRoot_->PrettyPrintTo(astStream, TAstPrintFlags::ShortQuote | TAstPrintFlags::PerLine); 
+        return astStream.Str(); 
+    } 
+ 
+    return Nothing(); 
+} 
+ 
+TMaybe<TString> TProgram::GetQueryPlan() { 
+    if (ExternalQueryPlan_) { 
+        return ExternalQueryPlan_; 
+    } 
+ 
+    if (ExprRoot_) { 
+        TStringStream planStream; 
+        planStream.Reserve(DEFAULT_PLAN_BUF_SIZE); 
+ 
         NYson::TYsonWriter writer(&planStream, OutputFormat_);
-        PlanBuilder_->WritePlan(writer, ExprRoot_);
-
-        return planStream.Str();
-    }
-
-    return Nothing();
-}
-
-TMaybe<TString> TProgram::GetDiagnostics() {
-    if (ExternalDiagnostics_) {
-        return ExternalDiagnostics_;
-    }
-
-    if (!TypeCtx_ || !TypeCtx_->Diagnostics) {
-        return Nothing();
-    }
-
-    if (!Transformer_) {
-        return Nothing();
-    }
-
-    TStringStream out;
+        PlanBuilder_->WritePlan(writer, ExprRoot_); 
+ 
+        return planStream.Str(); 
+    } 
+ 
+    return Nothing(); 
+} 
+ 
+TMaybe<TString> TProgram::GetDiagnostics() { 
+    if (ExternalDiagnostics_) { 
+        return ExternalDiagnostics_; 
+    } 
+ 
+    if (!TypeCtx_ || !TypeCtx_->Diagnostics) { 
+        return Nothing(); 
+    } 
+ 
+    if (!Transformer_) { 
+        return Nothing(); 
+    } 
+ 
+    TStringStream out; 
     NYson::TYsonWriter writer(&out, DiagnosticFormat_.GetOrElse(ResultFormat_));
-
-    writer.OnBeginMap();
-    writer.OnKeyedItem("Write");
-    writer.OnBeginList();
-    writer.OnListItem();
-    writer.OnBeginMap();
-    writer.OnKeyedItem("Data");
-    writer.OnBeginMap();
-    writer.OnKeyedItem("Diagnostics");
-    writer.OnBeginMap();
-    writer.OnKeyedItem("TransformStats");
-
-    auto transformStats = Transformer_->GetStatistics();
-    NCommon::TransformerStatsToYson("", transformStats, writer);
-
-    for (auto& datasink : TypeCtx_->DataSinks) {
+ 
+    writer.OnBeginMap(); 
+    writer.OnKeyedItem("Write"); 
+    writer.OnBeginList(); 
+    writer.OnListItem(); 
+    writer.OnBeginMap(); 
+    writer.OnKeyedItem("Data"); 
+    writer.OnBeginMap(); 
+    writer.OnKeyedItem("Diagnostics"); 
+    writer.OnBeginMap(); 
+    writer.OnKeyedItem("TransformStats"); 
+ 
+    auto transformStats = Transformer_->GetStatistics(); 
+    NCommon::TransformerStatsToYson("", transformStats, writer); 
+ 
+    for (auto& datasink : TypeCtx_->DataSinks) { 
         writer.OnKeyedItem(datasink->GetName());
         if (!datasink->CollectDiagnostics(writer)) {
-            writer.OnEntity();
-        }
-    }
-
-    writer.OnEndMap();
-    writer.OnEndMap();
-    writer.OnEndMap();
-    writer.OnEndList();
-    writer.OnEndMap();
-
-    return out.Str();
-}
-
+            writer.OnEntity(); 
+        } 
+    } 
+ 
+    writer.OnEndMap(); 
+    writer.OnEndMap(); 
+    writer.OnEndMap(); 
+    writer.OnEndList(); 
+    writer.OnEndMap(); 
+ 
+    return out.Str(); 
+} 
+ 
 IGraphTransformer::TStatistics TProgram::GetRawDiagnostics() {
     return Transformer_ ? Transformer_->GetStatistics() : IGraphTransformer::TStatistics::NotPresent();
 }
@@ -1249,7 +1249,7 @@ TTypeAnnotationContextPtr TProgram::BuildTypeAnnotationContext(const TString& us
 
     typeAnnotationContext->UserDataStorage = UserDataStorage_;
     typeAnnotationContext->Credentials = CredentialTables_;
-    typeAnnotationContext->UserCredentials = UserCredentials_;
+    typeAnnotationContext->UserCredentials = UserCredentials_; 
     typeAnnotationContext->Modules = Modules_;
     typeAnnotationContext->UdfResolver = UdfResolver_;
     typeAnnotationContext->UdfIndex = UdfIndex_;
@@ -1324,8 +1324,8 @@ TTypeAnnotationContextPtr TProgram::BuildTypeAnnotationContext(const TString& us
 
     if (!resultProviderDataSources.empty())
     {
-        auto resultFormat = ResultFormat_;
-        auto writerFactory = [resultFormat] () { return CreateYsonResultWriter(resultFormat); };
+        auto resultFormat = ResultFormat_; 
+        auto writerFactory = [resultFormat] () { return CreateYsonResultWriter(resultFormat); }; 
         ResultProviderConfig_ = MakeIntrusive<TResultProviderConfig>(*typeAnnotationContext,
             *FunctionRegistry_, IDataProvider::EResultFormat::Yson, ToString((ui32)resultFormat), writerFactory);
         ResultProviderConfig_->SupportsResultPosition = SupportsResultPosition_;
@@ -1364,26 +1364,26 @@ TFuture<void> TProgram::OpenSession(const TString& username)
 void TProgram::Print(IOutputStream* exprOut, IOutputStream* planOut, bool cleanPlan) {
     TVector<TTransformStage> printTransformers;
     const auto issueCode = TIssuesIds::DEFAULT_ERROR;
-    if (exprOut) {
-        printTransformers.push_back(TTransformStage(
+    if (exprOut) { 
+        printTransformers.push_back(TTransformStage( 
             TExprOutputTransformer::Sync(ExprRoot_, exprOut),
-            "ExprOutput",
+            "ExprOutput", 
             issueCode));
-    }
-    if (planOut) {
+    } 
+    if (planOut) { 
         if (cleanPlan) {
             GetPlanBuilder().Clear();
         }
-        printTransformers.push_back(TTransformStage(
+        printTransformers.push_back(TTransformStage( 
             TPlanOutputTransformer::Sync(planOut, GetPlanBuilder(), OutputFormat_),
-            "PlanOutput",
+            "PlanOutput", 
             issueCode));
-    }
-
+    } 
+ 
     auto compositeTransformer = CreateCompositeGraphTransformer(printTransformers, false);
-    InstantTransform(*compositeTransformer, ExprRoot_, *ExprCtx_);
-}
-
+    InstantTransform(*compositeTransformer, ExprRoot_, *ExprCtx_); 
+} 
+ 
 bool TProgram::HasActiveProcesses() {
     for (const auto& dp : DataProviders_) {
         if (dp.HasActiveProcesses && dp.HasActiveProcesses()) {
diff --git a/ydb/library/yql/core/facade/yql_facade.h b/ydb/library/yql/core/facade/yql_facade.h
index 1f8f47681d..0b01367c88 100644
--- a/ydb/library/yql/core/facade/yql_facade.h
+++ b/ydb/library/yql/core/facade/yql_facade.h
@@ -46,7 +46,7 @@ public:
 
     void AddUserDataTable(const TUserDataTable& userDataTable);
     void AddCredentialsTable(TCredentialTablePtr credentialTable);
-    void SetUserCredentials(const TUserCredentials& userCredentials);
+    void SetUserCredentials(const TUserCredentials& userCredentials); 
     void SetGatewaysConfig(const TGatewaysConfig* gatewaysConfig);
     void SetModules(IModuleResolver::TPtr modules);
     void SetUdfResolver(IUdfResolver::TPtr udfResolver);
@@ -72,7 +72,7 @@ private:
     TVector<TDataProviderInitializer> DataProvidersInit_;
     TUserDataTable UserDataTable_;
     TVector<TCredentialTablePtr> CredentialTables_;
-    TUserCredentials UserCredentials_;
+    TUserCredentials UserCredentials_; 
     const TGatewaysConfig* GatewaysConfig_;
     IModuleResolver::TPtr Modules_;
     IUdfResolver::TPtr UdfResolver_;
@@ -98,7 +98,7 @@ public:
 
     bool ParseYql();
     bool ParseSql();
-    bool ParseSql(const NSQLTranslation::TTranslationSettings& settings);
+    bool ParseSql(const NSQLTranslation::TTranslationSettings& settings); 
 
     bool Compile(const TString& username);
 
@@ -177,7 +177,7 @@ public:
     }
 
     void Print(IOutputStream* exprOut, IOutputStream* planOut, bool cleanPlan = false);
-
+ 
     inline void PrintErrorsTo(IOutputStream& out) const {
         if (ExprCtx_) {
             ExprCtx_->IssueManager.GetIssues().PrintWithProgramTo(out, Filename_, SourceCode_);
@@ -205,16 +205,16 @@ public:
         return ResultProviderConfig_->CommittedResults;
     }
 
-    TMaybe<TString> GetQueryAst();
-    TMaybe<TString> GetQueryPlan();
-
+    TMaybe<TString> GetQueryAst(); 
+    TMaybe<TString> GetQueryPlan(); 
+ 
     void SetDiagnosticFormat(NYson::EYsonFormat format) {
         DiagnosticFormat_ = format;
     }
 
-    TMaybe<TString> GetDiagnostics();
+    TMaybe<TString> GetDiagnostics(); 
     IGraphTransformer::TStatistics GetRawDiagnostics();
-
+ 
     TMaybe<TString> GetTasksInfo();
 
     TMaybe<TString> GetStatistics(bool totalOnly = false);
@@ -226,7 +226,7 @@ public:
 
     inline IOutputStream* ExprStream() const { return ExprStream_; }
     inline IOutputStream* PlanStream() const { return PlanStream_; }
-
+ 
     NYson::EYsonFormat GetResultFormat() const { return ResultFormat_; }
     NYson::EYsonFormat GetOutputFormat() const { return OutputFormat_; }
 
@@ -301,7 +301,7 @@ private:
         const TVector<TDataProviderInitializer>& dataProvidersInit,
         const TUserDataTable& userDataTable,
         const TVector<TCredentialTablePtr>& credentialTables,
-        const TUserCredentials& userCredentials,
+        const TUserCredentials& userCredentials, 
         const IModuleResolver::TPtr& modules,
         const IUdfResolver::TPtr& udfResolver,
         const TUdfIndex::TPtr& udfIndex,
@@ -317,17 +317,17 @@ private:
     TTypeAnnotationContextPtr BuildTypeAnnotationContext(const TString& username);
     TTypeAnnotationContextPtr GetAnnotationContext() const;
     TTypeAnnotationContextPtr ProvideAnnotationContext(const TString& username);
-    bool CollectUsedClusters();
-
+    bool CollectUsedClusters(); 
+ 
     NThreading::TFuture<void> OpenSession(const TString& username);
 
     void CleanupLastSession();
     void CloseLastSession();
 
-    TFutureStatus RemoteKikimrValidate(const TString& cluster);
-    TFutureStatus RemoteKikimrOptimize(const TString& cluster, const IPipelineConfigurator* pipelineConf);
-    TFutureStatus RemoteKikimrRun(const TString& cluster, const IPipelineConfigurator* pipelineConf);
-
+    TFutureStatus RemoteKikimrValidate(const TString& cluster); 
+    TFutureStatus RemoteKikimrOptimize(const TString& cluster, const IPipelineConfigurator* pipelineConf); 
+    TFutureStatus RemoteKikimrRun(const TString& cluster, const IPipelineConfigurator* pipelineConf); 
+ 
     bool FillParseResult(NYql::TAstParseResult&& astRes, NYql::TWarningRules* warningRules = nullptr);
     TString GetSessionId() const;
     TString TakeSessionId();
@@ -343,7 +343,7 @@ private:
     TVector<TDataProviderInfo> DataProviders_;
     TYqlOperationOptions OperationOptions_;
     TVector<TCredentialTablePtr> CredentialTables_;
-    TUserCredentials UserCredentials_;
+    TUserCredentials UserCredentials_; 
     const IUdfResolver::TPtr UdfResolver_;
     const TUdfIndex::TPtr UdfIndex_;
     const TUdfIndexPackageSet::TPtr UdfIndexPackageSet_;
@@ -352,7 +352,7 @@ private:
     const TGatewaysConfig* GatewaysConfig_;
     TString Filename_;
     TString SourceCode_;
-    ESourceSyntax SourceSyntax_;
+    ESourceSyntax SourceSyntax_; 
     ui16 SyntaxVersion_;
 
     TAstNode* AstRoot_;
@@ -376,9 +376,9 @@ private:
     bool UseTableMetaFromGraph_ = false;
     TMaybe<TSet<TString>> UsedClusters_;
     TMaybe<TSet<TString>> UsedProviders_;
-    TMaybe<TString> ExternalQueryAst_;
-    TMaybe<TString> ExternalQueryPlan_;
-    TMaybe<TString> ExternalDiagnostics_;
+    TMaybe<TString> ExternalQueryAst_; 
+    TMaybe<TString> ExternalQueryPlan_; 
+    TMaybe<TString> ExternalDiagnostics_; 
 
     IOutputStream* ExprStream_ = nullptr;
     IOutputStream* PlanStream_ = nullptr;
diff --git a/ydb/library/yql/core/issue/protos/issue_id.proto b/ydb/library/yql/core/issue/protos/issue_id.proto
index a2ed91d640..f8e4f8214a 100644
--- a/ydb/library/yql/core/issue/protos/issue_id.proto
+++ b/ydb/library/yql/core/issue/protos/issue_id.proto
@@ -10,7 +10,7 @@ message TIssuesIds {
         UNEXPECTED = 1;
         INFO = 2;
         WARNING = 3;
-        SUCCESS = 4;
+        SUCCESS = 4; 
 // core codes
         CORE = 1000;
         CORE_GC = 1010;
@@ -38,49 +38,49 @@ message TIssuesIds {
         CORE_LEGACY_REGEX_ENGINE = 1110;
         CORE_ALIAS_SHADOWS_COLUMN = 1111;
 
-// core errors
-        CORE_GC_NODES_LIMIT_EXCEEDED = 1500;
-        CORE_GC_STRINGS_LIMIT_EXCEEDED = 1501;
-
+// core errors 
+        CORE_GC_NODES_LIMIT_EXCEEDED = 1500; 
+        CORE_GC_STRINGS_LIMIT_EXCEEDED = 1501; 
+ 
 // kikimr
         KIKIMR_LOCKS_INVALIDATED = 2001;
-        KIKIMR_LOCKS_ACQUIRE_FAILURE = 2002;
-        KIKIMR_SCHEME_ERROR = 2003;
-        KIKIMR_COMPILE_ERROR = 2004;
-        KIKIMR_TEMPORARILY_UNAVAILABLE = 2005;
-        KIKIMR_OVERLOADED = 2006;
-        KIKIMR_BAD_OPERATION = 2008;
-        KIKIMR_MIXED_SCHEME_DATA_TX = 2009;
-        KIKIMR_MULTIPLE_SCHEME_MODIFICATIONS = 2010;
-        KIKIMR_OPERATION_ABORTED = 2011;
-        KIKIMR_CONSTRAINT_VIOLATION = 2012;
-        KIKIMR_RESULT_UNAVAILABLE = 2013;
-        KIKIMR_TOO_MANY_TRANSACTIONS = 2014;
-        KIKIMR_TRANSACTION_NOT_FOUND = 2015;
-        KIKIMR_PRAGMA_NOT_SUPPORTED = 2016;
-        KIKIMR_BAD_REQUEST = 2017;
-        KIKIMR_ACCESS_DENIED = 2018;
-        KIKIMR_QUERY_INVALIDATED = 2019;
-        KIKIMR_TIMEOUT = 2020;
-        KIKIMR_OPERATION_CANCELLED = 2021;
-        KIKIMR_UNAUTHENTICATED = 2022;
-        KIKIMR_UNIMPLEMENTED = 2023;
+        KIKIMR_LOCKS_ACQUIRE_FAILURE = 2002; 
+        KIKIMR_SCHEME_ERROR = 2003; 
+        KIKIMR_COMPILE_ERROR = 2004; 
+        KIKIMR_TEMPORARILY_UNAVAILABLE = 2005; 
+        KIKIMR_OVERLOADED = 2006; 
+        KIKIMR_BAD_OPERATION = 2008; 
+        KIKIMR_MIXED_SCHEME_DATA_TX = 2009; 
+        KIKIMR_MULTIPLE_SCHEME_MODIFICATIONS = 2010; 
+        KIKIMR_OPERATION_ABORTED = 2011; 
+        KIKIMR_CONSTRAINT_VIOLATION = 2012; 
+        KIKIMR_RESULT_UNAVAILABLE = 2013; 
+        KIKIMR_TOO_MANY_TRANSACTIONS = 2014; 
+        KIKIMR_TRANSACTION_NOT_FOUND = 2015; 
+        KIKIMR_PRAGMA_NOT_SUPPORTED = 2016; 
+        KIKIMR_BAD_REQUEST = 2017; 
+        KIKIMR_ACCESS_DENIED = 2018; 
+        KIKIMR_QUERY_INVALIDATED = 2019; 
+        KIKIMR_TIMEOUT = 2020; 
+        KIKIMR_OPERATION_CANCELLED = 2021; 
+        KIKIMR_UNAUTHENTICATED = 2022; 
+        KIKIMR_UNIMPLEMENTED = 2023; 
         KIKIMR_INDEX_METADATA_LOAD_FAILED = 2024;
         KIKIMR_GRPC_CONTEXT_ERROR = 2025;
-        KIKIMR_OPERATION_STATE_UNKNOWN = 2026;
+        KIKIMR_OPERATION_STATE_UNKNOWN = 2026; 
         KIKIMR_INDEX_IS_NOT_READY = 2027;
-        KIKIMR_SCHEME_MISMATCH = 2028;
+        KIKIMR_SCHEME_MISMATCH = 2028; 
         KIKIMR_PRECONDITION_FAILED = 2029;
         KIKIMR_UNSUPPORTED = 2030;
         KIKIMR_BAD_COLUMN_TYPE = 2031;
         KIKIMR_NO_COLUMN_DEFAULT_VALUE = 2032;
 
-// kikimr warnings
-        KIKIMR_READ_MODIFIED_TABLE = 2500;
-        KIKIMR_OPERATION_REVERTED = 2501;
-        KIKIMR_UPDATE_TABLE_WITH_DELETES = 2502;
+// kikimr warnings 
+        KIKIMR_READ_MODIFIED_TABLE = 2500; 
+        KIKIMR_OPERATION_REVERTED = 2501; 
+        KIKIMR_UPDATE_TABLE_WITH_DELETES = 2502; 
         KIKIMR_WRONG_INDEX_USAGE = 2503;
-
+ 
 // yt
         YT_TABLE_PATH_RECORD_FOR_TMP = 3001;
         YT_INFER_SCHEMA = 3002;
diff --git a/ydb/library/yql/core/issue/yql_issue.h b/ydb/library/yql/core/issue/yql_issue.h
index 9ec7ab14bb..8399984c00 100644
--- a/ydb/library/yql/core/issue/yql_issue.h
+++ b/ydb/library/yql/core/issue/yql_issue.h
@@ -31,15 +31,15 @@ inline TString IssueCodeToString(EYqlIssueCode id) {
     }
 }
 
-inline TIssue YqlIssue(const TPosition& position, EYqlIssueCode id, const TString& message) {
-    TIssue issue(position, message);
-    SetIssueCode(id, issue);
-
-    return issue;
-}
-
-inline TIssue YqlIssue(const TPosition& position, EYqlIssueCode id) {
-    return YqlIssue(position, id, IssueCodeToString(id));
-}
-
+inline TIssue YqlIssue(const TPosition& position, EYqlIssueCode id, const TString& message) { 
+    TIssue issue(position, message); 
+    SetIssueCode(id, issue); 
+ 
+    return issue; 
 }
+ 
+inline TIssue YqlIssue(const TPosition& position, EYqlIssueCode id) { 
+    return YqlIssue(position, id, IssueCodeToString(id)); 
+} 
+ 
+} 
diff --git a/ydb/library/yql/core/issue/yql_issue.txt b/ydb/library/yql/core/issue/yql_issue.txt
index 897d5d6f9a..8ab79ae2b7 100644
--- a/ydb/library/yql/core/issue/yql_issue.txt
+++ b/ydb/library/yql/core/issue/yql_issue.txt
@@ -11,10 +11,10 @@ ids {
   severity: S_INFO
 }
 ids {
-  code: SUCCESS
-  severity: S_INFO
-}
-ids {
+  code: SUCCESS 
+  severity: S_INFO 
+} 
+ids { 
   code: WARNING
   severity: S_WARNING
 }
@@ -120,136 +120,136 @@ ids {
   severity: S_WARNING
 }
 ids {
-  code: CORE_GC_NODES_LIMIT_EXCEEDED
-  severity: S_ERROR
-}
-ids {
-  code: CORE_GC_STRINGS_LIMIT_EXCEEDED
-  severity: S_ERROR
-}
-ids {
+  code: CORE_GC_NODES_LIMIT_EXCEEDED 
+  severity: S_ERROR 
+} 
+ids { 
+  code: CORE_GC_STRINGS_LIMIT_EXCEEDED 
+  severity: S_ERROR 
+} 
+ids { 
   code: KIKIMR_LOCKS_INVALIDATED
   severity: S_ERROR
-  format: "Transaction locks invalidated."
-}
-ids {
-  code: KIKIMR_LOCKS_ACQUIRE_FAILURE
-  severity: S_ERROR
-  format: "Failed to acquire transaction locks."
-}
-ids {
-  code: KIKIMR_SCHEME_ERROR
-  severity: S_ERROR
-  format: "Incorrect scheme found while performing Kikimr operation."
-}
-ids {
-  code: KIKIMR_COMPILE_ERROR
-  severity: S_ERROR
-  format: "Error while compiling Kikimr program."
-}
-ids {
-  code: KIKIMR_TEMPORARILY_UNAVAILABLE
-  severity: S_ERROR
-  format: "Kikimr cluster or one of its subsystems was unavailable."
-}
-ids {
-  code: KIKIMR_OVERLOADED
-  severity: S_ERROR
-  format: "Kikimr cluster or one of its subsystems is overloaded."
-}
-ids {
-  code: KIKIMR_BAD_OPERATION
-  severity: S_ERROR
-  format: "Bad operation."
-}
-ids {
-  code: KIKIMR_MIXED_SCHEME_DATA_TX
-  severity: S_ERROR
-  format: "Can't mix scheme and data operations in single Kikimr transaction. Use COMMIT statement to indicate end of transaction between scheme and data operations."
-}
-ids {
-  code: KIKIMR_MULTIPLE_SCHEME_MODIFICATIONS
-  severity: S_ERROR
-  format: "Multiple simultaneous modifications of Kikimr scheme element."
-}
-ids {
-  code: KIKIMR_OPERATION_ABORTED
-  severity: S_ERROR
-  format: "Operation aborted."
-}
-ids {
-  code: KIKIMR_CONSTRAINT_VIOLATION
-  severity: S_ERROR
-  format: "Constraint violation in Kikimr operation."
-}
-ids {
-  code: KIKIMR_RESULT_UNAVAILABLE
-  severity: S_ERROR
-  format: "Result of Kikimr query didn't meet requirements and isn't available"
-}
-ids {
-  code: KIKIMR_TOO_MANY_TRANSACTIONS
-  severity: S_ERROR
-  format: "Exceeded maximum allowed number of active transactions"
-}
-ids {
-  code: KIKIMR_TRANSACTION_NOT_FOUND
-  severity: S_ERROR
-  format: "Transaction not found"
-}
-ids {
-  code: KIKIMR_PRAGMA_NOT_SUPPORTED
-  severity: S_ERROR
-  format: "Pragma not supported in current context."
-}
-ids {
-  code: KIKIMR_BAD_REQUEST
-  severity: S_ERROR
-  format: "Bad request."
-}
-ids {
-  code: KIKIMR_ACCESS_DENIED
-  severity: S_ERROR
-  format: "Access denied."
-}
-ids {
-  code: KIKIMR_QUERY_INVALIDATED
-  severity: S_ERROR
-  format: "Query invalidated."
-}
-ids {
-  code: KIKIMR_TIMEOUT
-  severity: S_ERROR
-  format: "Operation timeout."
-}
-ids {
-  code: KIKIMR_OPERATION_CANCELLED
-  severity: S_ERROR
-  format: "Operation cancelled."
-}
-ids {
-  code: KIKIMR_UNAUTHENTICATED
-  severity: S_ERROR
-  format: "The request does not have valid authentication credentials."
-}
-ids {
-  code: KIKIMR_UNIMPLEMENTED
-  severity: S_ERROR
-  format: "Operation is not implemented or not supported."
-}
-ids {
-  code: KIKIMR_READ_MODIFIED_TABLE
-  severity: S_WARNING
-}
-ids {
-  code: KIKIMR_OPERATION_REVERTED
-  severity: S_WARNING
-}
-ids {
-  code: KIKIMR_UPDATE_TABLE_WITH_DELETES
-  severity: S_WARNING
-}
-ids {
+  format: "Transaction locks invalidated." 
+}
+ids {
+  code: KIKIMR_LOCKS_ACQUIRE_FAILURE 
+  severity: S_ERROR 
+  format: "Failed to acquire transaction locks." 
+} 
+ids { 
+  code: KIKIMR_SCHEME_ERROR 
+  severity: S_ERROR 
+  format: "Incorrect scheme found while performing Kikimr operation." 
+} 
+ids { 
+  code: KIKIMR_COMPILE_ERROR 
+  severity: S_ERROR 
+  format: "Error while compiling Kikimr program." 
+} 
+ids { 
+  code: KIKIMR_TEMPORARILY_UNAVAILABLE 
+  severity: S_ERROR 
+  format: "Kikimr cluster or one of its subsystems was unavailable." 
+} 
+ids { 
+  code: KIKIMR_OVERLOADED 
+  severity: S_ERROR 
+  format: "Kikimr cluster or one of its subsystems is overloaded." 
+} 
+ids { 
+  code: KIKIMR_BAD_OPERATION 
+  severity: S_ERROR 
+  format: "Bad operation." 
+} 
+ids { 
+  code: KIKIMR_MIXED_SCHEME_DATA_TX 
+  severity: S_ERROR 
+  format: "Can't mix scheme and data operations in single Kikimr transaction. Use COMMIT statement to indicate end of transaction between scheme and data operations." 
+} 
+ids { 
+  code: KIKIMR_MULTIPLE_SCHEME_MODIFICATIONS 
+  severity: S_ERROR 
+  format: "Multiple simultaneous modifications of Kikimr scheme element." 
+} 
+ids { 
+  code: KIKIMR_OPERATION_ABORTED 
+  severity: S_ERROR 
+  format: "Operation aborted." 
+} 
+ids { 
+  code: KIKIMR_CONSTRAINT_VIOLATION 
+  severity: S_ERROR 
+  format: "Constraint violation in Kikimr operation." 
+} 
+ids { 
+  code: KIKIMR_RESULT_UNAVAILABLE 
+  severity: S_ERROR 
+  format: "Result of Kikimr query didn't meet requirements and isn't available" 
+} 
+ids { 
+  code: KIKIMR_TOO_MANY_TRANSACTIONS 
+  severity: S_ERROR 
+  format: "Exceeded maximum allowed number of active transactions" 
+} 
+ids { 
+  code: KIKIMR_TRANSACTION_NOT_FOUND 
+  severity: S_ERROR 
+  format: "Transaction not found" 
+} 
+ids { 
+  code: KIKIMR_PRAGMA_NOT_SUPPORTED 
+  severity: S_ERROR 
+  format: "Pragma not supported in current context." 
+} 
+ids { 
+  code: KIKIMR_BAD_REQUEST 
+  severity: S_ERROR 
+  format: "Bad request." 
+} 
+ids { 
+  code: KIKIMR_ACCESS_DENIED 
+  severity: S_ERROR 
+  format: "Access denied." 
+} 
+ids { 
+  code: KIKIMR_QUERY_INVALIDATED 
+  severity: S_ERROR 
+  format: "Query invalidated." 
+} 
+ids { 
+  code: KIKIMR_TIMEOUT 
+  severity: S_ERROR 
+  format: "Operation timeout." 
+} 
+ids { 
+  code: KIKIMR_OPERATION_CANCELLED 
+  severity: S_ERROR 
+  format: "Operation cancelled." 
+} 
+ids { 
+  code: KIKIMR_UNAUTHENTICATED 
+  severity: S_ERROR 
+  format: "The request does not have valid authentication credentials." 
+} 
+ids { 
+  code: KIKIMR_UNIMPLEMENTED 
+  severity: S_ERROR 
+  format: "Operation is not implemented or not supported." 
+} 
+ids { 
+  code: KIKIMR_READ_MODIFIED_TABLE 
+  severity: S_WARNING 
+} 
+ids { 
+  code: KIKIMR_OPERATION_REVERTED 
+  severity: S_WARNING 
+} 
+ids { 
+  code: KIKIMR_UPDATE_TABLE_WITH_DELETES 
+  severity: S_WARNING 
+} 
+ids { 
   code: KIKIMR_WRONG_INDEX_USAGE
   severity: S_WARNING
 }
@@ -259,11 +259,11 @@ ids {
   format: "Operation with grpc context failed"
 }
 ids {
-  code: KIKIMR_OPERATION_STATE_UNKNOWN
-  severity: S_ERROR
-  format: "State of operation is unknown."
-}
-ids {
+  code: KIKIMR_OPERATION_STATE_UNKNOWN 
+  severity: S_ERROR 
+  format: "State of operation is unknown." 
+} 
+ids { 
   code: KIKIMR_INDEX_IS_NOT_READY
   severity: S_ERROR
 }
@@ -272,11 +272,11 @@ ids {
   severity: S_ERROR
 }
 ids {
-  code: KIKIMR_SCHEME_MISMATCH
-  severity: S_ERROR
-  format: "Scheme mismatch found while executing query."
-}
-ids {
+  code: KIKIMR_SCHEME_MISMATCH 
+  severity: S_ERROR 
+  format: "Scheme mismatch found while executing query." 
+} 
+ids { 
   code: KIKIMR_PRECONDITION_FAILED
   severity: S_ERROR
 }
diff --git a/ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.cpp b/ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.cpp
index ce22b12571..f9cc7feb42 100644
--- a/ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.cpp
+++ b/ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.cpp
@@ -574,20 +574,20 @@ TExprNode::TPtr PeepHoleDictFromKeysToDict(const TExprNode::TPtr& node, TExprCon
 
     return Build<TCoToDict>(ctx, callable.Pos())
         .List(list)
-        .KeySelector()
-            .Args({"item"})
-            .Body("item")
-            .Build()
-        .PayloadSelector()
-            .Args({"item"})
+        .KeySelector() 
+            .Args({"item"}) 
+            .Body("item") 
+            .Build() 
+        .PayloadSelector() 
+            .Args({"item"}) 
             .Body<TCoVoid>().Build()
-            .Build()
-        .Settings()
-            .Add().Build("One")
-            .Add().Build("Hashed")
-            .Build()
-        .Done()
-        .Ptr();
+            .Build() 
+        .Settings() 
+            .Add().Build("One") 
+            .Add().Build("Hashed") 
+            .Build() 
+        .Done() 
+        .Ptr(); 
 }
 
 TExprNode::TPtr ExpandEquiJoin(const TExprNode::TPtr& input, TExprContext& ctx) {
@@ -1928,7 +1928,7 @@ IGraphTransformer::TStatus PeepHoleCommonStage(const TExprNode::TPtr& input, TEx
 IGraphTransformer::TStatus PeepHoleFinalStage(const TExprNode::TPtr& input, TExprNode::TPtr& output,
     TExprContext& ctx, TTypeAnnotationContext& types, bool* hasNonDeterministicFunctions,
     const TPeepHoleOptimizerMap& optimizers, const TNonDeterministicOptimizerMap& nonDetOptimizers)
-{
+{ 
     TOptimizeExprSettings settings(&types);
     settings.CustomInstantTypeTransformer = types.CustomInstantTypeTransformer.Get();
 
diff --git a/ydb/library/yql/core/services/mounts/ya.make b/ydb/library/yql/core/services/mounts/ya.make
index 0959854ba5..60ce69c871 100644
--- a/ydb/library/yql/core/services/mounts/ya.make
+++ b/ydb/library/yql/core/services/mounts/ya.make
@@ -1,30 +1,30 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(
     spuchin
     g:yql
     g:yql_ydb_core
 )
-
-SRCS(
-    yql_mounts.h
-    yql_mounts.cpp
-)
-
-PEERDIR(
+ 
+SRCS( 
+    yql_mounts.h 
+    yql_mounts.cpp 
+) 
+ 
+PEERDIR( 
     library/cpp/resource
     ydb/library/yql/core/user_data
     ydb/library/yql/core
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-RESOURCE(
+RESOURCE( 
     ydb/library/yql/mount/lib/yql/aggregate.yql /lib/yql/aggregate.yql
     ydb/library/yql/mount/lib/yql/window.yql /lib/yql/window.yql
     ydb/library/yql/mount/lib/yql/id.yql /lib/yql/id.yql
     ydb/library/yql/mount/lib/yql/sqr.yql /lib/yql/sqr.yql
     ydb/library/yql/mount/lib/yql/core.yql /lib/yql/core.yql
-)
-
-END()
+) 
+ 
+END() 
diff --git a/ydb/library/yql/core/services/mounts/yql_mounts.cpp b/ydb/library/yql/core/services/mounts/yql_mounts.cpp
index 7d0e221799..583a5eb36b 100644
--- a/ydb/library/yql/core/services/mounts/yql_mounts.cpp
+++ b/ydb/library/yql/core/services/mounts/yql_mounts.cpp
@@ -1,30 +1,30 @@
-#include "yql_mounts.h"
-
+#include "yql_mounts.h" 
+ 
 #include <ydb/library/yql/core/yql_library_compiler.h>
-
+ 
 #include <library/cpp/resource/resource.h>
-
+ 
 #include <util/folder/path.h>
 #include <util/stream/file.h>
 
-namespace NYql {
+namespace NYql { 
     namespace {
         using namespace NUserData;
-
+ 
         void AddLibraryFromResource(TUserDataTable& userDataTable, const TString& resourceName) {
             auto& block = userDataTable[TUserDataKey::File(resourceName)];
             block.Data = NResource::Find(resourceName);
             block.Type = EUserDataType::RAW_INLINE_DATA;
             block.Usage.Set(EUserDataBlockUsage::Library, true);
         }
-
+ 
         TUserDataKey CreateKey(const NUserData::TUserData& item) {
             TString name = (item.Disposition_ == EDisposition::RESOURCE) ? item.Content_ : item.Name_;
 
             if (!name.StartsWith('/')) {
                 name = GetDefaultFilePrefix() + name;
             }
-
+ 
             if (item.Type_ == EType::UDF) {
                 return TUserDataKey::Udf(name);
             } else {
@@ -106,10 +106,10 @@ namespace NYql {
         AddLibraryFromResource(userData, "/lib/yql/id.yql");
         AddLibraryFromResource(userData, "/lib/yql/sqr.yql");
         AddLibraryFromResource(userData, "/lib/yql/core.yql");
-
+ 
         return userData;
     }
-
+ 
     TUserDataTable GetYqlModuleResolverImpl(
         TExprContext* rawCtx,
         IModuleResolver::TPtr& moduleResolver,
@@ -135,8 +135,8 @@ namespace NYql {
         moduleResolver = std::make_shared<TModuleResolver>(std::move(modulesTable), ctx->NextUniqueId,
             clusterMapping, sqlFlags, optimizeLibraries, std::move(ownedCtx));
         return mounts;
-    }
-
+    } 
+ 
     TUserDataTable GetYqlModuleResolver(
         TExprContext& ctx,
         IModuleResolver::TPtr& moduleResolver,
diff --git a/ydb/library/yql/core/services/mounts/yql_mounts.h b/ydb/library/yql/core/services/mounts/yql_mounts.h
index 27b30c4ccd..cb5178a28a 100644
--- a/ydb/library/yql/core/services/mounts/yql_mounts.h
+++ b/ydb/library/yql/core/services/mounts/yql_mounts.h
@@ -1,10 +1,10 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/core/user_data/yql_user_data.h>
 #include <ydb/library/yql/core/yql_type_annotation.h>
-
-namespace NYql {
-
+ 
+namespace NYql { 
+ 
 TUserDataTable GetYqlDefaultMounts();
 
 bool GetYqlDefaultModuleResolver(
@@ -25,5 +25,5 @@ TUserDataTable GetYqlModuleResolver(
         const THashMap<TString, TString>& clusterMapping,
         const THashSet<TString>& sqlFlags,
         bool optimizeLibraries = true);
-
-} // namespace NYql
+ 
+} // namespace NYql 
diff --git a/ydb/library/yql/core/services/ya.make b/ydb/library/yql/core/services/ya.make
index 5cebdea948..a652630540 100644
--- a/ydb/library/yql/core/services/ya.make
+++ b/ydb/library/yql/core/services/ya.make
@@ -1,12 +1,12 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(
     spuchin
     g:yql
     g:yql_ydb_core
 )
-
-SRCS(
+ 
+SRCS( 
     yql_eval_expr.cpp
     yql_eval_expr.h
     yql_eval_params.cpp
@@ -15,11 +15,11 @@ SRCS(
     yql_out_transformers.h
     yql_plan.cpp
     yql_plan.h
-    yql_transform_pipeline.cpp
+    yql_transform_pipeline.cpp 
     yql_transform_pipeline.h
-)
-
-PEERDIR(
+) 
+ 
+PEERDIR( 
     library/cpp/string_utils/base64
     library/cpp/yson
     ydb/library/yql/ast/serialize
@@ -35,8 +35,8 @@ PEERDIR(
     ydb/library/yql/providers/common/provider
     ydb/library/yql/providers/common/schema/expr
     ydb/library/yql/providers/result/expr_nodes
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-END()
+END() 
diff --git a/ydb/library/yql/core/services/yql_transform_pipeline.cpp b/ydb/library/yql/core/services/yql_transform_pipeline.cpp
index ae425f34c8..c76d63c081 100644
--- a/ydb/library/yql/core/services/yql_transform_pipeline.cpp
+++ b/ydb/library/yql/core/services/yql_transform_pipeline.cpp
@@ -1,7 +1,7 @@
-#include "yql_transform_pipeline.h"
+#include "yql_transform_pipeline.h" 
 #include "yql_eval_expr.h"
 #include "yql_eval_params.h"
-
+ 
 #include <ydb/library/yql/core/type_ann/type_ann_core.h>
 #include <ydb/library/yql/core/type_ann/type_ann_expr.h>
 #include <ydb/library/yql/core/yql_execution.h>
@@ -13,24 +13,24 @@
 #include <ydb/library/yql/core/common_opt/yql_co_transformer.h>
 #include <ydb/library/yql/core/yql_opt_proposed_by_data.h>
 #include <ydb/library/yql/core/yql_opt_rewrite_io.h>
-
+ 
 #include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
 
-namespace NYql {
-
+namespace NYql { 
+ 
 TTransformationPipeline::TTransformationPipeline(TIntrusivePtr<TTypeAnnotationContext> ctx)
-    : TypeAnnotationContext_(ctx)
+    : TypeAnnotationContext_(ctx) 
 {}
-
-TTransformationPipeline& TTransformationPipeline::Add(TAutoPtr<IGraphTransformer> transformer, const TString& stageName,
+ 
+TTransformationPipeline& TTransformationPipeline::Add(TAutoPtr<IGraphTransformer> transformer, const TString& stageName, 
     EYqlIssueCode issueCode, const TString& issueMessage)
-{
-    if (transformer) {
+{ 
+    if (transformer) { 
         Transformers_.push_back(TTransformStage(transformer, stageName, issueCode, issueMessage));
-    }
-    return *this;
-}
-
+    } 
+    return *this; 
+} 
+ 
 TTransformationPipeline& TTransformationPipeline::Add(IGraphTransformer& transformer, const TString& stageName,
     EYqlIssueCode issueCode, const TString& issueMessage)
 {
@@ -39,10 +39,10 @@ TTransformationPipeline& TTransformationPipeline::Add(IGraphTransformer& transfo
 }
 
 TTransformationPipeline& TTransformationPipeline::AddServiceTransformers(EYqlIssueCode issueCode) {
-    Transformers_.push_back(TTransformStage(CreateGcNodeTransformer(), "GC", issueCode));
-    return *this;
-}
-
+    Transformers_.push_back(TTransformStage(CreateGcNodeTransformer(), "GC", issueCode)); 
+    return *this; 
+} 
+ 
 TTransformationPipeline& TTransformationPipeline::AddParametersEvaluation(const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry, EYqlIssueCode issueCode) {
     auto& typeCtx = *TypeAnnotationContext_;
     Transformers_.push_back(TTransformStage(CreateFunctorTransformer(
@@ -67,50 +67,50 @@ TTransformationPipeline& TTransformationPipeline::AddExpressionEvaluation(const
 
 TTransformationPipeline& TTransformationPipeline::AddPreTypeAnnotation(EYqlIssueCode issueCode) {
     auto& typeCtx = *TypeAnnotationContext_;
-    Transformers_.push_back(TTransformStage(CreateFunctorTransformer(&ExpandApply), "ExpandApply",
+    Transformers_.push_back(TTransformStage(CreateFunctorTransformer(&ExpandApply), "ExpandApply", 
         issueCode));
-    Transformers_.push_back(TTransformStage(CreateFunctorTransformer(
+    Transformers_.push_back(TTransformStage(CreateFunctorTransformer( 
         [&](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
             return ValidateProviders(input, output, ctx, typeCtx);
-        }), "ValidateProviders", issueCode));
-
-    Transformers_.push_back(TTransformStage(
-        CreateConfigureTransformer(*TypeAnnotationContext_), "Configure", issueCode));
+        }), "ValidateProviders", issueCode)); 
+ 
+    Transformers_.push_back(TTransformStage( 
+        CreateConfigureTransformer(*TypeAnnotationContext_), "Configure", issueCode)); 
 
     return *this;
 }
 
 TTransformationPipeline& TTransformationPipeline::AddPreIOAnnotation(EYqlIssueCode issueCode) {
-    Transformers_.push_back(TTransformStage(
-        CreateIODiscoveryTransformer(*TypeAnnotationContext_), "IODiscovery", issueCode));
+    Transformers_.push_back(TTransformStage( 
+        CreateIODiscoveryTransformer(*TypeAnnotationContext_), "IODiscovery", issueCode)); 
     Transformers_.push_back(TTransformStage(
         CreateEpochsTransformer(*TypeAnnotationContext_), "Epochs", issueCode));
-    AddIntentDeterminationTransformer();
+    AddIntentDeterminationTransformer(); 
 
     return *this;
 }
 
 TTransformationPipeline& TTransformationPipeline::AddIOAnnotation(EYqlIssueCode issueCode) {
     AddPreIOAnnotation(issueCode);
-    AddTableMetadataLoaderTransformer();
-
+    AddTableMetadataLoaderTransformer(); 
+ 
     auto& typeCtx = *TypeAnnotationContext_;
-    Transformers_.push_back(TTransformStage(CreateFunctorTransformer(
+    Transformers_.push_back(TTransformStage(CreateFunctorTransformer( 
         [&](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
-            return RewriteIO(input, output, typeCtx, ctx);
-        }), "RewriteIO", issueCode));
-
+            return RewriteIO(input, output, typeCtx, ctx); 
+        }), "RewriteIO", issueCode)); 
+ 
     return *this;
 }
 
 TTransformationPipeline& TTransformationPipeline::AddTypeAnnotation(EYqlIssueCode issueCode) {
-    AddTypeAnnotationTransformer();
-    Transformers_.push_back(TTransformStage(
-        CreateFunctorTransformer(&CheckWholeProgramType),
-        "CheckWholeProgramType", issueCode));
-    return *this;
-}
-
+    AddTypeAnnotationTransformer(); 
+    Transformers_.push_back(TTransformStage( 
+        CreateFunctorTransformer(&CheckWholeProgramType), 
+        "CheckWholeProgramType", issueCode)); 
+    return *this; 
+} 
+ 
 TTransformationPipeline& TTransformationPipeline::AddPostTypeAnnotation(bool forSubGraph, EYqlIssueCode issueCode) {
     Transformers_.push_back(TTransformStage(
         CreateConstraintTransformer(*TypeAnnotationContext_, false, forSubGraph), "Constraints", issueCode));
@@ -135,13 +135,13 @@ TTransformationPipeline& TTransformationPipeline::AddPostTypeAnnotation(bool for
 }
 
 TTransformationPipeline& TTransformationPipeline::AddCommonOptimization(EYqlIssueCode issueCode) {
-    // auto instantCallableTransformer =
+    // auto instantCallableTransformer = 
     //    CreateExtCallableTypeAnnotationTransformer(*TypeAnnotationContext_, true);
     // TypeAnnotationContext_->CustomInstantTypeTransformer =
     //     CreateTypeAnnotationTransformer(instantCallableTransformer, *TypeAnnotationContext_);
-    Transformers_.push_back(TTransformStage(
-        CreateCommonOptTransformer(TypeAnnotationContext_.Get()),
-        "CommonOptimization",
+    Transformers_.push_back(TTransformStage( 
+        CreateCommonOptTransformer(TypeAnnotationContext_.Get()), 
+        "CommonOptimization", 
         issueCode));
     return *this;
 }
@@ -156,21 +156,21 @@ TTransformationPipeline& TTransformationPipeline::AddFinalCommonOptimization(EYq
 
 TTransformationPipeline& TTransformationPipeline::AddOptimization(bool checkWorld, bool withFinalOptimization, EYqlIssueCode issueCode) {
     AddCommonOptimization(issueCode);
-    Transformers_.push_back(TTransformStage(
+    Transformers_.push_back(TTransformStage( 
         CreateRecaptureDataProposalsInspector(*TypeAnnotationContext_, TString{DqProviderName}),
         "RecaptureDataProposals",
         issueCode));
     Transformers_.push_back(TTransformStage(
         CreateLogicalDataProposalsInspector(*TypeAnnotationContext_),
-        "LogicalDataProposals",
+        "LogicalDataProposals", 
         issueCode));
-    Transformers_.push_back(TTransformStage(
+    Transformers_.push_back(TTransformStage( 
         CreatePhysicalDataProposalsInspector(*TypeAnnotationContext_),
-        "PhysicalDataProposals",
+        "PhysicalDataProposals", 
         issueCode));
-    Transformers_.push_back(TTransformStage(
+    Transformers_.push_back(TTransformStage( 
         CreatePhysicalFinalizers(*TypeAnnotationContext_),
-        "PhysicalFinalizers",
+        "PhysicalFinalizers", 
         issueCode));
     if (withFinalOptimization) {
         AddFinalCommonOptimization(issueCode);
@@ -180,57 +180,57 @@ TTransformationPipeline& TTransformationPipeline::AddOptimization(bool checkWorl
 }
 
 TTransformationPipeline& TTransformationPipeline::AddCheckExecution(bool checkWorld, EYqlIssueCode issueCode) {
-    Transformers_.push_back(TTransformStage(
+    Transformers_.push_back(TTransformStage( 
         CreateCheckExecutionTransformer(*TypeAnnotationContext_, checkWorld),
-        "CheckExecution",
+        "CheckExecution", 
         issueCode));
-    return *this;
-}
-
+    return *this; 
+} 
+ 
 TTransformationPipeline& TTransformationPipeline::AddRun(TOperationProgressWriter writer, EYqlIssueCode issueCode) {
-    Transformers_.push_back(TTransformStage(
+    Transformers_.push_back(TTransformStage( 
         CreateExecutionTransformer(*TypeAnnotationContext_, writer),
-        "Execution",
+        "Execution", 
         issueCode));
-    return *this;
-}
-
+    return *this; 
+} 
+ 
 TTransformationPipeline& TTransformationPipeline::AddIntentDeterminationTransformer(EYqlIssueCode issueCode) {
-    Transformers_.push_back(TTransformStage(
+    Transformers_.push_back(TTransformStage( 
         CreateIntentDeterminationTransformer(*TypeAnnotationContext_),
-        "IntentDetermination",
+        "IntentDetermination", 
         issueCode));
-    return *this;
-}
-
+    return *this; 
+} 
+ 
 TTransformationPipeline& TTransformationPipeline::AddTableMetadataLoaderTransformer(EYqlIssueCode issueCode) {
-    Transformers_.push_back(TTransformStage(
+    Transformers_.push_back(TTransformStage( 
         CreateTableMetadataLoader(*TypeAnnotationContext_),
-        "TableMetadataLoader",
+        "TableMetadataLoader", 
         issueCode));
-    return *this;
-}
-
-TTransformationPipeline& TTransformationPipeline::AddTypeAnnotationTransformer(
+    return *this; 
+} 
+ 
+TTransformationPipeline& TTransformationPipeline::AddTypeAnnotationTransformer( 
     TAutoPtr<IGraphTransformer> callableTransformer, EYqlIssueCode issueCode)
-{
-    Transformers_.push_back(TTransformStage(
+{ 
+    Transformers_.push_back(TTransformStage( 
         CreateTypeAnnotationTransformer(callableTransformer, *TypeAnnotationContext_),
-        "TypeAnnotation",
+        "TypeAnnotation", 
         issueCode));
-    return *this;
-}
-
+    return *this; 
+} 
+ 
 TTransformationPipeline& TTransformationPipeline::AddTypeAnnotationTransformer(EYqlIssueCode issueCode)
-{
+{ 
     auto callableTransformer = CreateExtCallableTypeAnnotationTransformer(*TypeAnnotationContext_);
     return AddTypeAnnotationTransformer(callableTransformer, issueCode);
-}
-
+} 
+ 
 TAutoPtr<IGraphTransformer> TTransformationPipeline::Build(bool useIssueScopes) {
     return CreateCompositeGraphTransformer(Transformers_, useIssueScopes);
-}
-
+} 
+ 
 TAutoPtr<IGraphTransformer> TTransformationPipeline::BuildWithNoArgChecks(bool useIssueScopes) {
     return CreateCompositeGraphTransformerWithNoArgChecks(Transformers_, useIssueScopes);
 }
@@ -240,4 +240,4 @@ TIntrusivePtr<TTypeAnnotationContext> TTransformationPipeline::GetTypeAnnotation
 }
 
 
-} // namespace NYql
+} // namespace NYql 
diff --git a/ydb/library/yql/core/services/yql_transform_pipeline.h b/ydb/library/yql/core/services/yql_transform_pipeline.h
index 7e2f5c911e..ffe773efc8 100644
--- a/ydb/library/yql/core/services/yql_transform_pipeline.h
+++ b/ydb/library/yql/core/services/yql_transform_pipeline.h
@@ -1,12 +1,12 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/core/yql_graph_transformer.h>
 #include <ydb/library/yql/core/yql_type_annotation.h>
 #include <ydb/library/yql/core/yql_execution.h>
 #include <ydb/library/yql/core/issue/yql_issue.h>
-
-#include <util/generic/ptr.h>
-
+ 
+#include <util/generic/ptr.h> 
+ 
 namespace NKikimr {
 namespace NMiniKQL {
 
@@ -15,13 +15,13 @@ class IFunctionRegistry;
 }
 }
 
-namespace NYql {
-
-class TTransformationPipeline
-{
-public:
+namespace NYql { 
+ 
+class TTransformationPipeline 
+{ 
+public: 
     TTransformationPipeline(TIntrusivePtr<TTypeAnnotationContext> ctx);
-
+ 
     TTransformationPipeline& AddServiceTransformers(EYqlIssueCode issueCode = TIssuesIds::CORE_GC);
     TTransformationPipeline& AddParametersEvaluation(const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry, EYqlIssueCode issueCode = TIssuesIds::CORE_PARAM_EVALUATION);
     TTransformationPipeline& AddPreTypeAnnotation(EYqlIssueCode issueCode = TIssuesIds::CORE_PRE_TYPE_ANN);
@@ -36,27 +36,27 @@ public:
     TTransformationPipeline& AddOptimization(bool checkWorld = true, bool withFinalOptimization = true, EYqlIssueCode issueCode = TIssuesIds::CORE_OPTIMIZATION);
     TTransformationPipeline& AddCheckExecution(bool checkWorld = true, EYqlIssueCode issueCode = TIssuesIds::CORE_OPTIMIZATION);
     TTransformationPipeline& AddRun(TOperationProgressWriter writer, EYqlIssueCode issueCode = TIssuesIds::CORE_EXEC);
-
+ 
     TTransformationPipeline& AddIntentDeterminationTransformer(EYqlIssueCode issueCode = TIssuesIds::CORE_INTENT);
     TTransformationPipeline& AddTableMetadataLoaderTransformer(EYqlIssueCode issueCode = TIssuesIds::CORE_TABLE_METADATA_LOADER);
     TTransformationPipeline& AddTypeAnnotationTransformer(TAutoPtr<IGraphTransformer> callableTransformer, EYqlIssueCode issueCode = TIssuesIds::CORE_TYPE_ANN);
     TTransformationPipeline& AddTypeAnnotationTransformer(EYqlIssueCode issueCode = TIssuesIds::CORE_TYPE_ANN);
-
-    TTransformationPipeline& Add(TAutoPtr<IGraphTransformer> transformer, const TString& stageName,
+ 
+    TTransformationPipeline& Add(TAutoPtr<IGraphTransformer> transformer, const TString& stageName, 
         EYqlIssueCode issueCode = TIssuesIds::DEFAULT_ERROR, const TString& issueMessage = {});
     TTransformationPipeline& Add(IGraphTransformer& transformer, const TString& stageName,
         EYqlIssueCode issueCode = TIssuesIds::DEFAULT_ERROR, const TString& issueMessage = {});
-
+ 
     TAutoPtr<IGraphTransformer> Build(bool useIssueScopes = true);
     TAutoPtr<IGraphTransformer> BuildWithNoArgChecks(bool useIssueScopes = true);
-
+ 
     TIntrusivePtr<TTypeAnnotationContext> GetTypeAnnotationContext() const;
 
-private:
-    TIntrusivePtr<TTypeAnnotationContext> TypeAnnotationContext_;
+private: 
+    TIntrusivePtr<TTypeAnnotationContext> TypeAnnotationContext_; 
     TVector<TTransformStage> Transformers_;
-};
-
+}; 
+ 
 struct IPipelineConfigurator
 {
     virtual ~IPipelineConfigurator() = default;
@@ -66,4 +66,4 @@ struct IPipelineConfigurator
     virtual void AfterOptimize(TTransformationPipeline* pipeline) const = 0;
 };
 
-} // namspace NYql
+} // namspace NYql 
diff --git a/ydb/library/yql/core/type_ann/type_ann_core.cpp b/ydb/library/yql/core/type_ann/type_ann_core.cpp
index 5846e6cb10..03ae98acb3 100644
--- a/ydb/library/yql/core/type_ann/type_ann_core.cpp
+++ b/ydb/library/yql/core/type_ann/type_ann_core.cpp
@@ -426,8 +426,8 @@ namespace NTypeAnnImpl {
 
     TExtContext::TExtContext(TExprContext& expr, TTypeAnnotationContext& types)
         : TContext(expr)
-        , Types(types) {}
-
+        , Types(types) {} 
+ 
     bool TExtContext::LoadUdfMetadata(const TVector<IUdfResolver::TFunction*>& functions) {
         TVector<IUdfResolver::TImport*> imports;
         imports.reserve(Types.UdfImports.size());
@@ -512,8 +512,8 @@ namespace NTypeAnnImpl {
     }
 
     typedef std::function<IGraphTransformer::TStatus(const TExprNode::TPtr&, TExprNode::TPtr&, TContext& ctx)>
-        TAnnotationFunc;
-
+        TAnnotationFunc; 
+ 
     typedef std::function<IGraphTransformer::TStatus(const TExprNode::TPtr&, TExprNode::TPtr&, TExtContext& ctx)>
         TExtendedAnnotationFunc;
 
@@ -5414,16 +5414,16 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
     }
 
     IGraphTransformer::TStatus DictFromKeysWrapper(const TExprNode::TPtr& input, TExprNode::TPtr& output, TContext& ctx) {
-        Y_UNUSED(output);
+        Y_UNUSED(output); 
         if (!EnsureArgsCount(*input, 2, ctx.Expr)) {
-            return IGraphTransformer::TStatus::Error;
-        }
+            return IGraphTransformer::TStatus::Error; 
+        } 
         auto typeNode = input->Child(0);
         auto keysListNode = input->Child(1);
 
         if (auto status = EnsureTypeRewrite(input->HeadRef(), ctx.Expr); status != IGraphTransformer::TStatus::Ok) {
             return status;
-        }
+        } 
         const auto keyType = typeNode->GetTypeAnn()->Cast<TTypeExprType>()->GetType();
         if (!EnsureComputableType(typeNode->Pos(), *keyType, ctx.Expr)) {
             return IGraphTransformer::TStatus::Error;
@@ -5443,22 +5443,22 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
             if (status.Level == IGraphTransformer::TStatus::Error) {
                 return status;
             }
-        }
+        } 
 
         if (totalStatus.Level != IGraphTransformer::TStatus::Ok) {
             input->ChildRef(1) = ctx.Expr.ChangeChildren(*keysListNode, std::move(newChildren));
             return totalStatus;
         }
-
-        const TDictExprType* dictType = ctx.Expr.MakeType<TDictExprType>(keyType, ctx.Expr.MakeType<TVoidExprType>());
-        if (!dictType->Validate(input->Pos(), ctx.Expr)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+ 
+        const TDictExprType* dictType = ctx.Expr.MakeType<TDictExprType>(keyType, ctx.Expr.MakeType<TVoidExprType>()); 
+        if (!dictType->Validate(input->Pos(), ctx.Expr)) { 
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         input->SetTypeAnn(dictType);
-        return IGraphTransformer::TStatus::Ok;
-    }
-
+        return IGraphTransformer::TStatus::Ok; 
+    } 
+ 
     template <bool IsStrict>
     IGraphTransformer::TStatus IfWrapper(const TExprNode::TPtr& input, TExprNode::TPtr& output, TContext& ctx) {
         if (!EnsureArgsCount(*input, 3, ctx.Expr)) {
@@ -6687,7 +6687,7 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
         if (!EnsureMaxArgsCount(*input, 7, ctx.Expr)) {
             return IGraphTransformer::TStatus::Error;
         }
-
+ 
         // (0) function name
         if (!EnsureAtom(input->Head(), ctx.Expr)) {
             return IGraphTransformer::TStatus::Error;
@@ -6703,10 +6703,10 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
         // (1) run config value
         if (input->ChildrenSize() > 1) {
             if (!EnsureComputable(*input->Child(1), ctx.Expr)) {
-                return IGraphTransformer::TStatus::Error;
-            }
-        }
-
+                return IGraphTransformer::TStatus::Error; 
+            } 
+        } 
+ 
         // (2) user type
         const TTypeAnnotationNode* userType = nullptr;
         if (input->ChildrenSize() > 2) {
@@ -11099,24 +11099,24 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
         return IGraphTransformer::TStatus::Repeat;
     }
 
-    IGraphTransformer::TStatus ParameterWrapper(const TExprNode::TPtr& input, TExprNode::TPtr& output, TContext& ctx) {
-        Y_UNUSED(output);
-        if (!EnsureArgsCount(*input, 2, ctx.Expr)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+    IGraphTransformer::TStatus ParameterWrapper(const TExprNode::TPtr& input, TExprNode::TPtr& output, TContext& ctx) { 
+        Y_UNUSED(output); 
+        if (!EnsureArgsCount(*input, 2, ctx.Expr)) { 
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         if (!EnsureAtom(input->Head(), ctx.Expr)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         if (auto status = EnsureTypeRewrite(input->ChildRef(1), ctx.Expr); status != IGraphTransformer::TStatus::Ok) {
             return status;
-        }
-
+        } 
+ 
         input->SetTypeAnn(input->Child(1)->GetTypeAnn()->Cast<TTypeExprType>()->GetType());
-        return IGraphTransformer::TStatus::Ok;
-    }
-
+        return IGraphTransformer::TStatus::Ok; 
+    } 
+ 
     TMaybe<EDataSlot> ExtractDataType(const TExprNode& node, TExprContext& ctx) {
         if (node.IsAtom()) {
             auto dataType = node.Content();
@@ -12926,7 +12926,7 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
         Functions["MultiType"] = &TypeWrapper<ETypeAnnotationKind::Multi>;
         Functions["StructType"] = &TypeWrapper<ETypeAnnotationKind::Struct>;
         Functions["OptionalType"] = &TypeWrapper<ETypeAnnotationKind::Optional>;
-        Functions["TaggedType"] = &TypeWrapper<ETypeAnnotationKind::Tagged>;
+        Functions["TaggedType"] = &TypeWrapper<ETypeAnnotationKind::Tagged>; 
         Functions["VariantType"] = &TypeWrapper<ETypeAnnotationKind::Variant>;
         Functions["StreamType"] = &TypeWrapper<ETypeAnnotationKind::Stream>;
         Functions["FlowType"] = &TypeWrapper<ETypeAnnotationKind::Flow>;
@@ -13083,7 +13083,7 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
         Functions["QueuePop"] = &QueuePopWrapper;
         Functions["DependsOn"] = &DependsOnWrapper;
         Functions["Seq"] = &SeqWrapper;
-        Functions["Parameter"] = &ParameterWrapper;
+        Functions["Parameter"] = &ParameterWrapper; 
         Functions["WeakField"] = &WeakFieldWrapper;
         Functions["TryWeakMemberFromDict"] = &TryWeakMemberFromDictWrapper;
         Functions["ByteString"] = &ByteStringWrapper;
@@ -13221,12 +13221,12 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
         ExtFunctions["QueuePeek"] = &QueuePeekWrapper; ///< Ext for ParseTypeWrapper compatibility
         ExtFunctions["QueueRange"] = &QueueRangeWrapper; ///< Ext for ParseTypeWrapper compatibility
         ExtFunctions["PreserveStream"] = &PreserveStreamWrapper;
-        ExtFunctions["FilePath"] = &FilePathWrapper;
-        ExtFunctions["FileContent"] = &FileContentWrapper;
+        ExtFunctions["FilePath"] = &FilePathWrapper; 
+        ExtFunctions["FileContent"] = &FileContentWrapper; 
         ExtFunctions["FolderPath"] = &FolderPathWrapper;
         ExtFunctions["Files"] = &FilesWrapper;
         ExtFunctions["AuthTokens"] = &AuthTokensWrapper;
-        ExtFunctions["Udf"] = &UdfWrapper;
+        ExtFunctions["Udf"] = &UdfWrapper; 
         ExtFunctions["ScriptUdf"] = &ScriptUdfWrapper;
         ExtFunctions["ParseType"] = &ParseTypeWrapper;
         ExtFunctions["CurrentOperationId"] = &CurrentOperationIdWrapper;
@@ -13241,7 +13241,7 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
         ExtFunctions["AssumeColumnOrder"] = &AssumeColumnOrderWrapper;
         ExtFunctions["AssumeColumnOrderPartial"] = &AssumeColumnOrderWrapper;
         ExtFunctions["UnionAllPositional"] = &UnionAllPositionalWrapper;
-
+ 
         ColumnOrderFunctions["PgSetItem"] = &OrderForPgSetItem;
         ColumnOrderFunctions["AssumeColumnOrder"] = &OrderForAssumeColumnOrder;
 
@@ -13284,13 +13284,13 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
         AllNames.insert("Apply");
     }
 
-    class TIntentDeterminationTransformer : public TSyncTransformerBase {
+    class TIntentDeterminationTransformer : public TSyncTransformerBase { 
     public:
         TIntentDeterminationTransformer(const TTypeAnnotationContext& types)
             : Types(types)
         {}
 
-        IGraphTransformer::TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+        IGraphTransformer::TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
             output = input;
             if (ctx.Step.IsDone(TExprStep::Intents)) {
                 return TStatus::Ok;
@@ -13353,7 +13353,7 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
 
         TMaybe<IGraphTransformer::TStatus> ProcessCore(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
             auto& functions = TSyncFunctionsMap::Instance().Functions;
-            auto& extFunctions = TSyncFunctionsMap::Instance().ExtFunctions;
+            auto& extFunctions = TSyncFunctionsMap::Instance().ExtFunctions; 
             auto& columnOrderFunctions = TSyncFunctionsMap::Instance().ColumnOrderFunctions;
             auto name = input->Content();
             IGraphTransformer::TStatus status = IGraphTransformer::TStatus::Ok;
@@ -13391,10 +13391,10 @@ template <NKikimr::NUdf::EDataSlot DataSlot>
             if (!input->GetTypeAnn() || input->GetTypeAnn()->GetKind() != ETypeAnnotationKind::World) {
                 ctx.AddError(TIssue(ctx.GetPosition(input->Pos()), "Bad datasink commit result"));
                 return TStatus::Error;
-            }
+            } 
             return TStatus::Ok;
-        }
-
+        } 
+ 
         IGraphTransformer::TStatus ValidateProviderReadResult(const TExprNode::TPtr& input, TExprContext& ctx) {
             if (!input->GetTypeAnn() ||
                 input->GetTypeAnn()->GetKind() != ETypeAnnotationKind::Tuple ||
@@ -13456,8 +13456,8 @@ IGraphTransformer::TStatus ValidateDataSource(const TExprNode::TPtr& input, TExp
         return IGraphTransformer::TStatus::Error;
     }
 
-    TMaybe<TString> cluster;
-    if (!(*datasource)->ValidateParameters(*input, ctx, cluster)) {
+    TMaybe<TString> cluster; 
+    if (!(*datasource)->ValidateParameters(*input, ctx, cluster)) { 
         return IGraphTransformer::TStatus::Error;
     }
 
@@ -13484,8 +13484,8 @@ IGraphTransformer::TStatus ValidateDataSink(const TExprNode::TPtr& input, TExprC
         return IGraphTransformer::TStatus::Error;
     }
 
-    TMaybe<TString> cluster;
-    if (!(*datasink)->ValidateParameters(*input, ctx, cluster)) {
+    TMaybe<TString> cluster; 
+    if (!(*datasink)->ValidateParameters(*input, ctx, cluster)) { 
         return IGraphTransformer::TStatus::Error;
     }
 
diff --git a/ydb/library/yql/core/type_ann/type_ann_expr.cpp b/ydb/library/yql/core/type_ann/type_ann_expr.cpp
index f67d3b4120..2b348c764a 100644
--- a/ydb/library/yql/core/type_ann/type_ann_expr.cpp
+++ b/ydb/library/yql/core/type_ann/type_ann_expr.cpp
@@ -15,7 +15,7 @@ namespace {
 
 constexpr bool PrintCallableTimes = false;
 
-class TTypeAnnotationTransformer : public TGraphTransformerBase {
+class TTypeAnnotationTransformer : public TGraphTransformerBase { 
 public:
     TTypeAnnotationTransformer(TAutoPtr<IGraphTransformer> callableTransformer, TTypeAnnotationContext& types)
         : CallableTransformer(callableTransformer)
@@ -40,7 +40,7 @@ public:
         }
     }
 
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         YQL_PROFILE_SCOPE(DEBUG, "TypeAnnotationTransformer::DoTransform");
         output = input;
         auto status = TransformNode(input, output, ctx);
@@ -63,7 +63,7 @@ public:
         return status;
     }
 
-    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
+    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
         YQL_PROFILE_SCOPE(DEBUG, "TypeAnnotationTransformer::DoGetAsyncFuture");
         Y_UNUSED(input);
         TVector<NThreading::TFuture<void>> futures;
@@ -74,7 +74,7 @@ public:
         return WaitExceptionOrAll(futures);
     }
 
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         YQL_PROFILE_SCOPE(DEBUG, "TypeAnnotationTransformer::DoApplyAsyncChanges");
         output = input;
         TStatus combinedStatus = TStatus::Ok;
@@ -576,59 +576,59 @@ TAutoPtr<IGraphTransformer> CreateFullTypeAnnotationTransformer(
 {
     TVector<TTransformStage> transformers;
     auto issueCode = TIssuesIds::CORE_PRE_TYPE_ANN;
-    transformers.push_back(TTransformStage(
-        CreateFunctorTransformer(&ExpandApply),
-        "ExpandApply",
+    transformers.push_back(TTransformStage( 
+        CreateFunctorTransformer(&ExpandApply), 
+        "ExpandApply", 
         issueCode));
-    transformers.push_back(TTransformStage(
-        CreateFunctorTransformer(
+    transformers.push_back(TTransformStage( 
+        CreateFunctorTransformer( 
             [&](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
             return ValidateProviders(input, output, ctx, typeAnnotationContext);
         }),
-        "ValidateProviders",
+        "ValidateProviders", 
         issueCode));
 
-    transformers.push_back(TTransformStage(
+    transformers.push_back(TTransformStage( 
         CreateConfigureTransformer(typeAnnotationContext),
-        "Configure",
+        "Configure", 
         issueCode));
-    transformers.push_back(TTransformStage(
+    transformers.push_back(TTransformStage( 
         CreateIODiscoveryTransformer(typeAnnotationContext),
-        "IODiscovery",
+        "IODiscovery", 
         issueCode));
     transformers.push_back(TTransformStage(
         CreateEpochsTransformer(typeAnnotationContext),
         "Epochs",
         issueCode));
 
-    transformers.push_back(TTransformStage(
+    transformers.push_back(TTransformStage( 
         CreateIntentDeterminationTransformer(typeAnnotationContext),
-        "IntentDetermination",
+        "IntentDetermination", 
         issueCode));
-    transformers.push_back(TTransformStage(
+    transformers.push_back(TTransformStage( 
         CreateTableMetadataLoader(typeAnnotationContext),
-        "TableMetadataLoader",
+        "TableMetadataLoader", 
         issueCode));
     auto& typeCtx = typeAnnotationContext;
-    transformers.push_back(TTransformStage(
-        CreateFunctorTransformer(
+    transformers.push_back(TTransformStage( 
+        CreateFunctorTransformer( 
             [&](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
             return RewriteIO(input, output, typeCtx, ctx);
         }),
-        "RewriteIO",
+        "RewriteIO", 
         issueCode));
 
     issueCode = TIssuesIds::CORE_TYPE_ANN;
     auto callableTransformer = CreateExtCallableTypeAnnotationTransformer(typeAnnotationContext);
     auto typeTransformer = CreateTypeAnnotationTransformer(callableTransformer, typeAnnotationContext);
-    transformers.push_back(TTransformStage(
+    transformers.push_back(TTransformStage( 
         typeTransformer,
-        "TypeAnnotation",
+        "TypeAnnotation", 
         issueCode));
     if (wholeProgram) {
-        transformers.push_back(TTransformStage(
-            CreateFunctorTransformer(&CheckWholeProgramType),
-            "CheckWholeProgramType",
+        transformers.push_back(TTransformStage( 
+            CreateFunctorTransformer(&CheckWholeProgramType), 
+            "CheckWholeProgramType", 
             issueCode));
     }
 
diff --git a/ydb/library/yql/core/type_ann/type_ann_impl.h b/ydb/library/yql/core/type_ann/type_ann_impl.h
index 3d940ebd73..a71ddb0d23 100644
--- a/ydb/library/yql/core/type_ann/type_ann_impl.h
+++ b/ydb/library/yql/core/type_ann/type_ann_impl.h
@@ -16,14 +16,14 @@ namespace NTypeAnnImpl {
         TContext(TExprContext& expr);
     };
 
-    struct TExtContext : public TContext {
+    struct TExtContext : public TContext { 
         TTypeAnnotationContext& Types;
-
+ 
         TExtContext(TExprContext& expr, TTypeAnnotationContext& types);
         bool LoadUdfMetadata(const TVector<IUdfResolver::TFunction*>& functions);
         void RegisterResolvedImport(const IUdfResolver::TImport& import);
-    };
-
+    }; 
+ 
     // Implemented in type_ann_join.cpp
     IGraphTransformer::TStatus JoinWrapper(const TExprNode::TPtr& input, TExprNode::TPtr& output, TContext& ctx);
     IGraphTransformer::TStatus JoinDictWrapper(const TExprNode::TPtr& input, TExprNode::TPtr& output, TContext& ctx);
diff --git a/ydb/library/yql/core/type_ann/type_ann_list.cpp b/ydb/library/yql/core/type_ann/type_ann_list.cpp
index b145cde389..f73218de95 100644
--- a/ydb/library/yql/core/type_ann/type_ann_list.cpp
+++ b/ydb/library/yql/core/type_ann/type_ann_list.cpp
@@ -2587,7 +2587,7 @@ namespace {
         return true;
     }
 
-    IGraphTransformer::TStatus ValidateSortTraits(const TTypeAnnotationNode* itemType, const TExprNode::TPtr& direction, TExprNode::TPtr& lambda, TExprContext& ctx) {
+    IGraphTransformer::TStatus ValidateSortTraits(const TTypeAnnotationNode* itemType, const TExprNode::TPtr& direction, TExprNode::TPtr& lambda, TExprContext& ctx) { 
         bool isTuple = false;
         if (!ValidateSortDirections(*direction, ctx, isTuple)) {
             return IGraphTransformer::TStatus::Error;
@@ -3042,7 +3042,7 @@ namespace {
 
         bool hasSort = !input->Child(2)->IsCallable("Void");
         if (hasSort) {
-            auto status = ValidateSortTraits(itemType, input->Child(2), input->ChildRef(3), ctx.Expr);
+            auto status = ValidateSortTraits(itemType, input->Child(2), input->ChildRef(3), ctx.Expr); 
             if (status.Level != IGraphTransformer::TStatus::Ok) {
                 return status;
             }
@@ -3089,14 +3089,14 @@ namespace {
         }
 
         const auto retKind = lambdaListHandler->GetTypeAnn()->GetKind();
-        if (retKind != ETypeAnnotationKind::List && retKind != ETypeAnnotationKind::Optional &&
-            retKind != ETypeAnnotationKind::Stream)
-        {
+        if (retKind != ETypeAnnotationKind::List && retKind != ETypeAnnotationKind::Optional && 
+            retKind != ETypeAnnotationKind::Stream) 
+        { 
             ctx.Expr.AddError(TIssue(ctx.Expr.GetPosition(lambdaListHandler->Pos()), TStringBuilder() <<
                 "Expected either list, stream or optional, but got: " << *lambdaListHandler->GetTypeAnn()));
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
 
         const auto retItemType = GetSeqItemType(lambdaListHandler->GetTypeAnn());
         input->SetTypeAnn(MakeSequenceType(input->Head().GetTypeAnn()->GetKind(), *retItemType, ctx.Expr));
@@ -4319,20 +4319,20 @@ namespace {
             return IGraphTransformer::TStatus::Repeat;
         }
 
-        bool isStream;
+        bool isStream; 
         if (!EnsureSeqType(input->Head(), ctx.Expr, &isStream)) {
             return IGraphTransformer::TStatus::Error;
         }
 
-        auto inputItemType = isStream
+        auto inputItemType = isStream 
             ? input->Head().GetTypeAnn()->Cast<TStreamExprType>()->GetItemType()
             : input->Head().GetTypeAnn()->Cast<TListExprType>()->GetItemType();
-
+ 
         if (!EnsureStructType(input->Head().Pos(), *inputItemType, ctx.Expr)) {
             return IGraphTransformer::TStatus::Error;
         }
 
-        auto inputStructType = inputItemType->Cast<TStructExprType>();
+        auto inputStructType = inputItemType->Cast<TStructExprType>(); 
         if (input->Child(1)->IsCallable("Void")) {
             TExprNodeList names;
             names.reserve(inputStructType->GetSize());
@@ -4572,7 +4572,7 @@ namespace {
         }
 
         input->SetTypeAnn(isStream
-            ? (const TTypeAnnotationNode*)ctx.Expr.MakeType<TStreamExprType>(rowType)
+            ? (const TTypeAnnotationNode*)ctx.Expr.MakeType<TStreamExprType>(rowType) 
             : (const TTypeAnnotationNode*)ctx.Expr.MakeType<TListExprType>(rowType));
         return IGraphTransformer::TStatus::Ok;
     }
@@ -4635,8 +4635,8 @@ namespace {
         columnTypes.reserve(originalStructType->GetSize());
         for (const auto& x : originalStructType->GetItems()) {
             columnTypes.emplace(x->GetName(), x->GetItemType());
-        }
-
+        } 
+ 
         if (input->ChildrenSize() < 2U) {
             bool hasOptional = false;
             for (auto& column : columnTypes) {
@@ -4684,8 +4684,8 @@ namespace {
         }
 
         TVector<const TItemExprType*> items;
-        for (auto& pair : columnTypes) {
-            items.push_back(ctx.Expr.MakeType<TItemExprType>(pair.first, pair.second));
+        for (auto& pair : columnTypes) { 
+            items.push_back(ctx.Expr.MakeType<TItemExprType>(pair.first, pair.second)); 
         }
 
         const auto newStructType = ctx.Expr.MakeType<TStructExprType>(items);
@@ -5918,7 +5918,7 @@ namespace {
         auto& groupSwitch = input->ChildRef(TCoGroupingCore::idx_GroupSwitch);
         auto& keyExtractor = input->ChildRef(TCoGroupingCore::idx_KeyExtractor);
 
-        auto status = ConvertToLambda(groupSwitch, ctx.Expr, 2);
+        auto status = ConvertToLambda(groupSwitch, ctx.Expr, 2); 
         status = status.Combine(ConvertToLambda(keyExtractor, ctx.Expr, 1));
         if (hasHandler) {
             auto& handler = input->ChildRef(TCoGroupingCore::idx_ConvertHandler);
@@ -5942,18 +5942,18 @@ namespace {
             return IGraphTransformer::TStatus::Error;
         }
 
-        // groupSwitch
+        // groupSwitch 
         auto keyType = keyExtractor->GetTypeAnn();
-        if (!UpdateLambdaAllArgumentsTypes(groupSwitch, {keyType, itemType}, ctx.Expr)) {
-            return IGraphTransformer::TStatus::Error;
-        }
+        if (!UpdateLambdaAllArgumentsTypes(groupSwitch, {keyType, itemType}, ctx.Expr)) { 
+            return IGraphTransformer::TStatus::Error; 
+        } 
         if (!groupSwitch->GetTypeAnn()) {
-            return IGraphTransformer::TStatus::Repeat;
-        }
+            return IGraphTransformer::TStatus::Repeat; 
+        } 
         if (!EnsureSpecificDataType(*groupSwitch, EDataSlot::Bool, ctx.Expr)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         // handler
         if (hasHandler) {
             auto& handler = input->ChildRef(TCoGroupingCore::idx_ConvertHandler);
diff --git a/ydb/library/yql/core/type_ann/type_ann_types.cpp b/ydb/library/yql/core/type_ann/type_ann_types.cpp
index c27c0c433f..61f7c91af3 100644
--- a/ydb/library/yql/core/type_ann/type_ann_types.cpp
+++ b/ydb/library/yql/core/type_ann/type_ann_types.cpp
@@ -114,33 +114,33 @@ namespace NTypeAnnImpl {
     IGraphTransformer::TStatus TypeWrapper<ETypeAnnotationKind::Tagged>(const TExprNode::TPtr& input, TExprNode::TPtr& output, TContext& ctx) {
         Y_UNUSED(output);
         if (!EnsureArgsCount(*input, 2, ctx.Expr)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         if (auto status = EnsureTypeRewrite(input->HeadRef(), ctx.Expr); status != IGraphTransformer::TStatus::Ok) {
             return status;
-        }
-
+        } 
+ 
         if (!EnsureAtom(*input->Child(1), ctx.Expr)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         auto underlyingType = input->Child(0)->GetTypeAnn()->Cast<TTypeExprType>()->GetType();
         if (!EnsureInspectableType(input->Child(0)->Pos(), *underlyingType, ctx.Expr)) {
-            return IGraphTransformer::TStatus::Error;
-        }
-
+            return IGraphTransformer::TStatus::Error; 
+        } 
+ 
         auto tag = input->Child(1)->Content();
-
+ 
         auto taggedType = ctx.Expr.MakeType<TTaggedExprType>(underlyingType, tag);
         if (!taggedType->Validate(input->Pos(), ctx.Expr)) {
             return IGraphTransformer::TStatus::Error;
         }
         input->SetTypeAnn(ctx.Expr.MakeType<TTypeExprType>(taggedType));
-        return IGraphTransformer::TStatus::Ok;
-    }
-
-    template <>
+        return IGraphTransformer::TStatus::Ok; 
+    } 
+ 
+    template <> 
     IGraphTransformer::TStatus TypeWrapper<ETypeAnnotationKind::Error>(const TExprNode::TPtr& input, TExprNode::TPtr& output, TContext& ctx) {
         Y_UNUSED(output);
         if (!EnsureArgsCount(*input, 4, ctx.Expr)) {
@@ -898,10 +898,10 @@ namespace NTypeAnnImpl {
             return IGraphTransformer::TStatus::Error;
         }
 
-        // TODO: Collect type annotation directly from AST.
+        // TODO: Collect type annotation directly from AST. 
         auto callableTransformer = CreateExtCallableTypeAnnotationTransformer(ctx.Types);
         auto typeTransformer = CreateTypeAnnotationTransformer(callableTransformer, ctx.Types);
-        if (InstantTransform(*typeTransformer, exprRoot, ctx.Expr) != IGraphTransformer::TStatus::Ok) {
+        if (InstantTransform(*typeTransformer, exprRoot, ctx.Expr) != IGraphTransformer::TStatus::Ok) { 
             return IGraphTransformer::TStatus::Error;
         }
 
diff --git a/ydb/library/yql/core/yql_data_provider.h b/ydb/library/yql/core/yql_data_provider.h
index 3ffbdc041d..2031125315 100644
--- a/ydb/library/yql/core/yql_data_provider.h
+++ b/ydb/library/yql/core/yql_data_provider.h
@@ -76,24 +76,24 @@ public:
 
 class IDqIntegration;
 
-class IOptimizationContext;
-
+class IOptimizationContext; 
+ 
 class IDataProvider : public TThrRefBase {
 public:
     virtual ~IDataProvider() {}
 
     virtual TStringBuf GetName() const = 0;
 
-    enum class EResultFormat {
-        Yson,
-        Custom
-    };
-
+    enum class EResultFormat { 
+        Yson, 
+        Custom 
+    }; 
+ 
     // settings for result data provider
     struct TFillSettings {
         TMaybe<ui64> AllResultsBytesLimit = 100000;
         TMaybe<ui64> RowsLimitPerWrite = 1000; // only if list is written
-        EResultFormat Format;
+        EResultFormat Format; 
         TString FormatDetails;
         bool Discard = false;
     };
@@ -145,7 +145,7 @@ public:
     virtual void UndoEvaluationChanges() = 0;
     virtual TExprNode::TPtr CleanupWorld(const TExprNode::TPtr& node, TExprContext& ctx) = 0;
     virtual TExprNode::TPtr OptimizePull(const TExprNode::TPtr& source, const TFillSettings& fillSettings, TExprContext& ctx,
-        IOptimizationContext& optCtx) = 0;
+        IOptimizationContext& optCtx) = 0; 
 
     //-- execution
     virtual bool CanExecute(const TExprNode& node) = 0;
@@ -160,7 +160,7 @@ public:
     virtual bool CollectDiscoveredData(NYson::TYsonWriter& writer) = 0;
 
     //-- plan
-    virtual IGraphTransformer& GetPlanInfoTransformer() = 0;
+    virtual IGraphTransformer& GetPlanInfoTransformer() = 0; 
     virtual IPlanFormatter& GetPlanFormatter() = 0;
 
     //-- garbage collection
@@ -180,12 +180,12 @@ class TGatewaysConfig;
 
 using TOperationProgressWriter = std::function<void(const TOperationProgress&)>;
 
-enum class ESourceSyntax {
-    Unknown,
-    Sql,
-    Yql
-};
-
+enum class ESourceSyntax { 
+    Unknown, 
+    Sql, 
+    Yql 
+}; 
+ 
 struct TDataProviderInfo {
     using TFutureStatus = NThreading::TFuture<IGraphTransformer::TStatus>;
 
diff --git a/ydb/library/yql/core/yql_execution.cpp b/ydb/library/yql/core/yql_execution.cpp
index eb138b1b4f..e7d1c3c888 100644
--- a/ydb/library/yql/core/yql_execution.cpp
+++ b/ydb/library/yql/core/yql_execution.cpp
@@ -16,7 +16,7 @@ namespace {
 
 const bool RewriteSanityCheck = false;
 
-class TExecutionTransformer : public TGraphTransformerBase {
+class TExecutionTransformer : public TGraphTransformerBase { 
 public:
     struct TState : public TThrRefBase {
         TAdaptiveLock Lock;
@@ -41,10 +41,10 @@ public:
         , Writer(writer)
         , WithFinalize(withFinalize)
     {
-        Rewind();
+        Rewind(); 
     }
 
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         if (FinalizingTransformer) {
             YQL_CLOG(INFO, CoreExecution) << "FinalizingTransformer, root #" << input->UniqueId();
             auto status = FinalizingTransformer->Transform(input, output, ctx);
@@ -89,13 +89,13 @@ public:
         return FinalizingTransformer->Transform(input, output, ctx);
     }
 
-    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
+    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
         return FinalizingTransformer ?
             FinalizingTransformer->GetAsyncFuture(input) :
             State->Promise.GetFuture();
     }
 
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         if (FinalizingTransformer) {
             return FinalizingTransformer->ApplyAsyncChanges(input, output, ctx);
         }
@@ -200,18 +200,18 @@ public:
         return true;
     }
 
-    void Rewind() override {
-        State = MakeIntrusive<TState>();
-        State->Promise = NThreading::NewPromise();
-        State->HasResult = false;
-        NewNodes.clear();
-        FinalizingTransformer.Reset();
+    void Rewind() override { 
+        State = MakeIntrusive<TState>(); 
+        State->Promise = NThreading::NewPromise(); 
+        State->HasResult = false; 
+        NewNodes.clear(); 
+        FinalizingTransformer.Reset(); 
 
         TrackableNodes.clear();
         CollectingNodes.clear();
         ProvidersCache.clear();
-    }
-
+    } 
+ 
     TStatus ExecuteNode(const TExprNode::TPtr& node, TExprNode::TPtr& output, TExprContext& ctx, ui32 depth) {
         output = node;
         bool changed = false;
diff --git a/ydb/library/yql/core/yql_expr_csee.cpp b/ydb/library/yql/core/yql_expr_csee.cpp
index b0e7525521..3152399a94 100644
--- a/ydb/library/yql/core/yql_expr_csee.cpp
+++ b/ydb/library/yql/core/yql_expr_csee.cpp
@@ -235,9 +235,9 @@ namespace {
     bool EqualNodes(const TExprNode& left, TLambdaFrame& currLeftFrame, const TExprNode& right, TLambdaFrame& currRightFrame,
         TNodeSet& visited, const TColumnOrderStorage& coStore)
     {
-        if (&left == &right) {
-            return true;
-        }
+        if (&left == &right) { 
+            return true; 
+        } 
 
         if (!visited.emplace(&left).second) {
             return true;
@@ -248,8 +248,8 @@ namespace {
         }
 
         if (left.GetTypeAnn() != right.GetTypeAnn()) {
-            return false;
-        }
+            return false; 
+        } 
 
         if (left.GetAllConstraints() != right.GetAllConstraints()) {
             return false;
@@ -259,7 +259,7 @@ namespace {
             return false;
         }
 
-        switch (left.Type()) {
+        switch (left.Type()) { 
         case TExprNode::Atom:
             // compare pointers due to intern
             return left.Content().data() == right.Content().data() && left.GetFlagsToCompare() == right.GetFlagsToCompare();
@@ -267,12 +267,12 @@ namespace {
         case TExprNode::Callable:
             // compare pointers due to intern
             if (left.Content().data() != right.Content().data()) {
-                return false;
+                return false; 
             }
             [[fallthrough]];
         case TExprNode::List:
-            if (left.ChildrenSize() != right.ChildrenSize()) {
-                return false;
+            if (left.ChildrenSize() != right.ChildrenSize()) { 
+                return false; 
             }
 
             if (left.UnorderedChildren() && right.UnorderedChildren()) {
@@ -305,12 +305,12 @@ namespace {
                         return false;
                     }
                 }
-            }
+            } 
 
-            return true;
+            return true; 
         case TExprNode::Lambda: {
             if (left.IsComplete() != right.IsComplete()) {
-                return false;
+                return false; 
             }
 
             if (left.ChildrenSize() != right.ChildrenSize()) {
@@ -320,8 +320,8 @@ namespace {
             const auto& leftArgs = left.Head();
             const auto& rightArgs = right.Head();
             if (leftArgs.ChildrenSize() != rightArgs.ChildrenSize()) {
-                return false;
-            }
+                return false; 
+            } 
 
             for (ui32 i = 0; i < leftArgs.ChildrenSize(); ++i) {
                 const auto& leftArg = *leftArgs.Child(i);
@@ -332,7 +332,7 @@ namespace {
                 if (leftArg.GetAllConstraints() != rightArg.GetAllConstraints()) {
                     return false;
                 }
-            }
+            } 
 
             TLambdaFrame newLeftFrame(&left, &currLeftFrame);
             TLambdaFrame newRightFrame(&right, &currRightFrame);
@@ -350,17 +350,17 @@ namespace {
                 return leftRelativeLevel == rightRelativeLevel && left.GetArgIndex() == right.GetArgIndex();
             } else {
                 return &left == &right;
-            }
-        }
+            } 
+        } 
         case TExprNode::Arguments:
             break;
-        case TExprNode::World:
-            return true;
-        }
-
+        case TExprNode::World: 
+            return true; 
+        } 
+ 
         YQL_ENSURE(false, "Unexpected");
         return false;
-    }
+    } 
 
     int CompareNodes(const TExprNode& left, const TExprNode& right, TNodeSet& visited) {
         if (&left == &right) {
@@ -550,7 +550,7 @@ namespace {
                     iter = nodesSet.erase(iter);
                     continue;
                 }
-
+ 
                 if (!EqualNodes(node, *iter->second, coStore)) {
 #ifndef NDEBUG
                     if (!GetEnv("YQL_ALLOW_CSEE_HASH_COLLISION")) {
@@ -578,7 +578,7 @@ namespace {
         return nullptr;
     }
 }
-
+ 
 IGraphTransformer::TStatus UpdateCompletness(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext&) {
     YQL_PROFILE_SCOPE(DEBUG, "UpdateCompletness");
     output = input;
diff --git a/ydb/library/yql/core/yql_expr_optimize.cpp b/ydb/library/yql/core/yql_expr_optimize.cpp
index 677ca7fa53..f6d50a4186 100644
--- a/ydb/library/yql/core/yql_expr_optimize.cpp
+++ b/ydb/library/yql/core/yql_expr_optimize.cpp
@@ -6,72 +6,72 @@
 namespace NYql {
 
 namespace {
-    template<typename TOptimizer>
-    struct TOptimizationContext : IOptimizationContext {
-        TOptimizer Optimizer;
+    template<typename TOptimizer> 
+    struct TOptimizationContext : IOptimizationContext { 
+        TOptimizer Optimizer; 
         TExprContext& Expr;
         const TOptimizeExprSettings& Settings;
         TNodeOnNodeOwnedMap Memoization;
         const TNodeOnNodeOwnedMap* Replaces;
-        ui64 LastNodeId;
-        bool HasRemaps;
+        ui64 LastNodeId; 
+        bool HasRemaps; 
 
         TOptimizationContext(TOptimizer optimizer, const TNodeOnNodeOwnedMap* replaces, TExprContext& expr, const TOptimizeExprSettings& settings)
             : Optimizer(optimizer)
             , Expr(expr)
             , Settings(settings)
             , Replaces(replaces)
-            , LastNodeId(expr.NextUniqueId)
+            , LastNodeId(expr.NextUniqueId) 
             , HasRemaps(false)
         {
         }
-
+ 
         void RemapNode(const TExprNode& fromNode, const TExprNode::TPtr& toNode) final {
             YQL_ENSURE(fromNode.UniqueId() <= LastNodeId);
-            YQL_ENSURE(toNode->UniqueId() > LastNodeId);
+            YQL_ENSURE(toNode->UniqueId() > LastNodeId); 
             Memoization[&fromNode] = toNode;
-            HasRemaps = true;
+            HasRemaps = true; 
             if (Settings.ProcessedNodes) {
                 Settings.ProcessedNodes->erase(fromNode.UniqueId());
             }
-        }
+        } 
     };
 
     TExprNode::TPtr RunOptimizer(TOptimizationContext<TCallableOptimizer>& ctx, const TExprNode::TPtr& node) {
         return (!ctx.Settings.VisitChanges && ctx.HasRemaps) ? node : ctx.Optimizer(node, ctx.Expr);
-    }
-
+    } 
+ 
     TExprNode::TPtr RunOptimizer(TOptimizationContext<TCallableOptimizerEx>& ctx, const TExprNode::TPtr& node) {
         return (!ctx.Settings.VisitChanges && ctx.HasRemaps) ? node : ctx.Optimizer(node, ctx.Expr, ctx);
-    }
-
+    } 
+ 
     TExprNode::TPtr RunOptimizer(TOptimizationContext<TCallableOptimizerFast>& ctx, bool& changed, const TExprNode::TPtr& node) {
         return (!ctx.Settings.VisitChanges && ctx.HasRemaps) ? node : ctx.Optimizer(node, changed, ctx.Expr);
     }
 
-    template<typename TContext>
+    template<typename TContext> 
     TExprNode::TPtr ApplyRemaps(const TExprNode::TPtr& node, TContext& ctx) {
         const auto memoization = ctx.Memoization.find(node.Get());
         if (ctx.Memoization.cend() != memoization && memoization->second && memoization->second != node) {
             return memoization->second;
-        }
-
+        } 
+ 
         TExprNode::TListType newChildren;
-        bool hasRemaps = false;
+        bool hasRemaps = false; 
         for (const auto& child : node->Children()) {
             auto newChild = ApplyRemaps(child, ctx);
-            YQL_ENSURE(newChild);
-
-            if (newChild != child) {
-                hasRemaps = true;
-            }
-
+            YQL_ENSURE(newChild); 
+ 
+            if (newChild != child) { 
+                hasRemaps = true; 
+            } 
+ 
             newChildren.emplace_back(std::move(newChild));
-        }
-
+        } 
+ 
         return hasRemaps ? ctx.Expr.ChangeChildren(*node, std::move(newChildren)) : node;
-    }
-
+    } 
+ 
     void AddExpected(const TExprNode& src, const TExprNode& dst, const TOptimizeExprSettings& settings) {
         if (!src.GetTypeAnn() || dst.GetTypeAnn() || !settings.Types) {
             return;
@@ -89,7 +89,7 @@ namespace {
         }
     }
 
-    template<typename TContext>
+    template<typename TContext> 
     TExprNode::TPtr OptimizeNode(const TExprNode::TPtr& node, TContext& ctx, size_t level) {
         if (node->Type() == TExprNode::Atom || node->Type() == TExprNode::Argument ||
             node->Type() == TExprNode::Arguments || node->Type() == TExprNode::World) {
@@ -124,8 +124,8 @@ namespace {
         TExprNode::TPtr ret;
         if (current->Type() == TExprNode::Lambda) {
             ret = current;
-
-            if (ctx.Settings.VisitLambdas) {
+ 
+            if (ctx.Settings.VisitLambdas) { 
                 TExprNode::TListType newBody;
                 newBody.reserve(node->ChildrenSize() - 1U);
                 bool bodyChanged = false;
@@ -145,7 +145,7 @@ namespace {
                 if (bodyChanged) {
                     ret = ctx.Expr.DeepCopyLambda(*current, std::move(newBody));
                     AddExpected(*node, *ret, ctx.Settings);
-                }
+                } 
             }
         } else {
             TExprNode::TListType newChildren;
@@ -219,7 +219,7 @@ namespace {
         }
         return ret;
     }
-
+ 
     TExprNode::TPtr OptimizeNode(const TExprNode::TPtr& node, bool& changed, TOptimizationContext<TCallableOptimizerFast>& ctx, size_t level) {
         if (node->Type() == TExprNode::Atom || node->Type() == TExprNode::Argument ||
             node->Type() == TExprNode::Arguments || node->Type() == TExprNode::World) {
@@ -236,12 +236,12 @@ namespace {
 
         TExprNode::TPtr ret;
         if (node->Type() == TExprNode::Lambda) {
-            ret = node;
+            ret = node; 
 
-            if (ctx.Settings.VisitLambdas) {
+            if (ctx.Settings.VisitLambdas) { 
                 TExprNode::TListType newBody;
                 newBody.reserve(node->ChildrenSize() - 1U);
-                bool bodyChanged = false;
+                bool bodyChanged = false; 
                 for (ui32 i = 1U; i < node->ChildrenSize(); ++i) {
                     auto newNode = OptimizeNode(node->ChildPtr(i), bodyChanged, ctx, level + 1);
                     if (!newNode)
@@ -253,11 +253,11 @@ namespace {
                         newBody.emplace_back(std::move(newNode));
                     }
                 }
-
-                if (bodyChanged) {
+ 
+                if (bodyChanged) { 
                     ret = ctx.Expr.DeepCopyLambda(*node, std::move(newBody));
-                    changed = true;
-                }
+                    changed = true; 
+                } 
             }
         } else {
             TExprNode::TListType newChildren;
@@ -303,40 +303,40 @@ namespace {
         return ret;
     }
 
-    void VisitExprInternal(const TExprNode::TPtr& node, const TExprVisitPtrFunc& preFunc,
-        const TExprVisitPtrFunc& postFunc, TNodeSet& visitedNodes)
-    {
+    void VisitExprInternal(const TExprNode::TPtr& node, const TExprVisitPtrFunc& preFunc, 
+        const TExprVisitPtrFunc& postFunc, TNodeSet& visitedNodes) 
+    { 
         if (!visitedNodes.emplace(node.Get()).second) {
-            return;
-        }
-
-        if (!preFunc || preFunc(node)) {
-            for (const auto& child : node->Children()) {
-                VisitExprInternal(child, preFunc, postFunc, visitedNodes);
-            }
-        }
-
-        if (postFunc) {
-            postFunc(node);
-        }
-    }
-
-    void VisitExprInternal(const TExprNode& node, const TExprVisitRefFunc& preFunc,
-        const TExprVisitRefFunc& postFunc, TNodeSet& visitedNodes)
+            return; 
+        } 
+ 
+        if (!preFunc || preFunc(node)) { 
+            for (const auto& child : node->Children()) { 
+                VisitExprInternal(child, preFunc, postFunc, visitedNodes); 
+            } 
+        } 
+ 
+        if (postFunc) { 
+            postFunc(node); 
+        } 
+    } 
+
+    void VisitExprInternal(const TExprNode& node, const TExprVisitRefFunc& preFunc, 
+        const TExprVisitRefFunc& postFunc, TNodeSet& visitedNodes) 
     {
         if (!visitedNodes.emplace(&node).second) {
             return;
         }
 
-        if (!preFunc || preFunc(node)) {
+        if (!preFunc || preFunc(node)) { 
             node.ForEachChild([&](const TExprNode& child) {
                 VisitExprInternal(child, preFunc, postFunc, visitedNodes);
             });
         }
-
-        if (postFunc) {
-            postFunc(node);
-        }
+ 
+        if (postFunc) { 
+            postFunc(node); 
+        } 
     }
 
     void VisitExprByFirstInternal(const TExprNode::TPtr& node, const TExprVisitPtrFunc& preFunc,
@@ -346,7 +346,7 @@ namespace {
             return;
         }
 
-        if (!preFunc || preFunc(node)) {
+        if (!preFunc || preFunc(node)) { 
             if (node->ChildrenSize() > 0) {
                 if (node->Content() == SyncName) {
                     for (const auto& child : node->Children()) {
@@ -371,7 +371,7 @@ namespace {
             return;
         }
 
-        if (!preFunc || preFunc(node)) {
+        if (!preFunc || preFunc(node)) { 
             if (node.ChildrenSize() > 0) {
                 if (node.Content() == SyncName) {
                     for (const auto& child : node.Children()) {
@@ -411,28 +411,28 @@ namespace {
             VisitExprByPrimaryBranch(node->ChildPtr(i), predicate, primary, visitedNodes);
     }
 
-    template<typename TOptimizer>
+    template<typename TOptimizer> 
     IGraphTransformer::TStatus OptimizeExprInternal(TExprNode::TPtr input, TExprNode::TPtr& output, TOptimizer optimizer,
         const TNodeOnNodeOwnedMap* replaces, TExprContext& ctx, const TOptimizeExprSettings& settings) try
-    {
+    { 
         YQL_ENSURE(&input != &output);
         TOptimizationContext<TOptimizer> optCtx(optimizer, replaces, ctx, settings);
         output = OptimizeNode(input, optCtx, 0U);
-
+ 
         if (!output)
             return IGraphTransformer::TStatus::Error;
-
+ 
         if (optCtx.HasRemaps) {
             output = ApplyRemaps(output, optCtx);
             if (settings.ProcessedNodes) {
                 settings.ProcessedNodes->clear();
             }
         }
-
+ 
         if (!settings.VisitChanges && (output != input)) {
             return IGraphTransformer::TStatus(IGraphTransformer::TStatus::Repeat, true);
         }
-
+ 
         return IGraphTransformer::TStatus::Ok;
     } catch (const std::exception& e) {
         ctx.AddError(ExceptionToIssue(e, ctx.GetPosition(input->Pos())));
@@ -461,17 +461,17 @@ namespace {
 }
 
 IGraphTransformer::TStatus OptimizeExpr(const TExprNode::TPtr& input, TExprNode::TPtr& output, TCallableOptimizer optimizer,
-    TExprContext& ctx, const TOptimizeExprSettings& settings)
-{
+    TExprContext& ctx, const TOptimizeExprSettings& settings) 
+{ 
     return OptimizeExprInternal(input, output, optimizer, nullptr, ctx, settings);
-}
-
+} 
+ 
 IGraphTransformer::TStatus OptimizeExprEx(const TExprNode::TPtr& input, TExprNode::TPtr& output, TCallableOptimizerEx optimizer,
-    TExprContext& ctx, const TOptimizeExprSettings& settings)
-{
+    TExprContext& ctx, const TOptimizeExprSettings& settings) 
+{ 
     return OptimizeExprInternal(input, output, optimizer, nullptr, ctx, settings);
-}
-
+} 
+ 
 IGraphTransformer::TStatus OptimizeExpr(const TExprNode::TPtr& input, TExprNode::TPtr& output, const TCallableOptimizerFast& optimizer,
     TExprContext& ctx, const TOptimizeExprSettings& settings)
 {
@@ -843,23 +843,23 @@ TExprNode::TPtr ApplySyncListToWorld(const TExprNode::TPtr& main, const TSyncMap
 
 void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func) {
     TNodeSet visitedNodes;
-    VisitExprInternal(root, func, {}, visitedNodes);
+    VisitExprInternal(root, func, {}, visitedNodes); 
 }
-
-void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& preFunc, const TExprVisitPtrFunc& postFunc) {
-    TNodeSet visitedNodes;
-    VisitExprInternal(root, preFunc, postFunc, visitedNodes);
-}
-
+ 
+void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& preFunc, const TExprVisitPtrFunc& postFunc) { 
+    TNodeSet visitedNodes; 
+    VisitExprInternal(root, preFunc, postFunc, visitedNodes); 
+} 
+ 
 void VisitExpr(const TExprNode& root, const TExprVisitRefFunc& func) {
     TNodeSet visitedNodes;
-    VisitExprInternal(root, func, {}, visitedNodes);
-}
-
-void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func, TNodeSet& visitedNodes) {
-    VisitExprInternal(root, func, {}, visitedNodes);
-}
-
+    VisitExprInternal(root, func, {}, visitedNodes); 
+} 
+ 
+void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func, TNodeSet& visitedNodes) { 
+    VisitExprInternal(root, func, {}, visitedNodes); 
+} 
+ 
 void VisitExprByFirst(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func) {
     TNodeSet visitedNodes;
     VisitExprByFirstInternal(root, func, {}, visitedNodes);
@@ -882,20 +882,20 @@ void VisitExprByFirst(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func
 TExprNode::TPtr FindNode(const TExprNode::TPtr& root, const TExprVisitPtrFunc& predicate) {
     TExprNode::TPtr result;
     VisitExpr(root, [&result, &predicate] (const TExprNode::TPtr& node) {
-        if (result)
-            return false;
-
-        if (predicate(node)) {
+        if (result) 
+            return false; 
+ 
+        if (predicate(node)) { 
             result = node;
-            return false;
-        }
-
-        return true;
-    });
-
-    return result;
-}
-
+            return false; 
+        } 
+ 
+        return true; 
+    }); 
+ 
+    return result; 
+} 
+ 
 TExprNode::TPtr FindNode(const TExprNode::TPtr& root, const TExprVisitPtrFunc& filter, const TExprVisitPtrFunc& predicate) {
     TExprNode::TPtr result;
     VisitExpr(root, filter, [&result, &predicate] (const TExprNode::TPtr& node) {
@@ -940,16 +940,16 @@ TExprNode::TListType FindNodes(const TExprNode::TPtr& root, const TExprVisitPtrF
 }
 
 std::pair<TExprNode::TPtr, bool> FindSharedNode(const TExprNode::TPtr& firstRoot, const TExprNode::TPtr& secondRoot, const TExprVisitPtrFunc& predicate)
-{
+{ 
     TNodeSet nodes, visited;
-    VisitExpr(firstRoot, [&nodes, &predicate] (const TExprNode::TPtr& node) {
-        if (predicate(node)) {
-            nodes.insert(node.Get());
-        }
-
-        return true;
-    });
-
+    VisitExpr(firstRoot, [&nodes, &predicate] (const TExprNode::TPtr& node) { 
+        if (predicate(node)) { 
+            nodes.insert(node.Get()); 
+        } 
+ 
+        return true; 
+    }); 
+ 
     TExprNode::TPtr result;
     bool primary = true;
     VisitExprByPrimaryBranch(secondRoot, [&nodes, &result] (const TExprNode::TPtr& node) {
@@ -966,12 +966,12 @@ std::pair<TExprNode::TPtr, bool> FindSharedNode(const TExprNode::TPtr& firstRoot
 
     return std::make_pair(std::move(result), primary);
 }
-
+ 
 bool HaveSharedNodes(const TExprNode::TPtr& firstRoot, const TExprNode::TPtr& secondRoot, const TExprVisitPtrFunc& predicate)
 {
     return bool(FindSharedNode(firstRoot, secondRoot, predicate).first);
-}
-
+} 
+ 
 TExprNode::TPtr CloneCompleteFlow(TExprNode::TPtr&& node, TExprContext& ctx) {
     const TExprNode* original = nullptr;
     TExprNode::TPtr copy;
@@ -984,6 +984,6 @@ TExprNode::TPtr CloneCompleteFlow(TExprNode::TPtr&& node, TExprContext& ctx) {
         return false;
     });
     return original ? ctx.ReplaceNode(std::move(node), *original, std::move(copy)) : std::move(node);
-}
+} 
 
 }
diff --git a/ydb/library/yql/core/yql_expr_optimize.h b/ydb/library/yql/core/yql_expr_optimize.h
index ae5f0dea38..58dfdc312e 100644
--- a/ydb/library/yql/core/yql_expr_optimize.h
+++ b/ydb/library/yql/core/yql_expr_optimize.h
@@ -21,7 +21,7 @@ struct TOptimizeExprSettings {
     TProcessedNodesSet* ProcessedNodes = nullptr;
     bool VisitStarted = false;
     IGraphTransformer* CustomInstantTypeTransformer = nullptr;
-    bool VisitLambdas = true;
+    bool VisitLambdas = true; 
     TTypeAnnotationContext* Types;
     bool VisitTuples = false;
 };
@@ -36,28 +36,28 @@ IGraphTransformer::TStatus RemapExpr(const TExprNode::TPtr& input, TExprNode::TP
     TExprContext& ctx, const TOptimizeExprSettings& settings);
 
 
-class IOptimizationContext {
-public:
+class IOptimizationContext { 
+public: 
     virtual ~IOptimizationContext() = default;
     virtual void RemapNode(const TExprNode& fromNode, const TExprNode::TPtr& toNode) = 0;
-};
-
+}; 
+ 
 typedef std::function<TExprNode::TPtr (const TExprNode::TPtr&, TExprContext&, IOptimizationContext&)> TCallableOptimizerEx;
-
+ 
 IGraphTransformer::TStatus OptimizeExprEx(const TExprNode::TPtr& input, TExprNode::TPtr& output, TCallableOptimizerEx optimizer,
     TExprContext& ctx, const TOptimizeExprSettings& settings);
-
+ 
 IGraphTransformer::TStatus ExpandApply(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx);
 TExprNode::TPtr ApplySyncListToWorld(const TExprNode::TPtr& main, const TSyncMap& syncList, TExprContext& ctx);
 
 typedef std::function<bool (const TExprNode::TPtr&)> TExprVisitPtrFunc;
 typedef std::function<bool (const TExprNode&)> TExprVisitRefFunc;
-
+ 
 void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func);
-void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& preFunc, const TExprVisitPtrFunc& postFunc);
-void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func, TNodeSet& visitedNodes);
+void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& preFunc, const TExprVisitPtrFunc& postFunc); 
+void VisitExpr(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func, TNodeSet& visitedNodes); 
 void VisitExpr(const TExprNode& root, const TExprVisitRefFunc& func);
-
+ 
 void VisitExprByFirst(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func);
 void VisitExprByFirst(const TExprNode::TPtr& root, const TExprVisitPtrFunc& preFunc, const TExprVisitPtrFunc& postFunc);
 void VisitExprByFirst(const TExprNode::TPtr& root, const TExprVisitPtrFunc& func, TNodeSet& visitedNodes);
@@ -68,7 +68,7 @@ TExprNode::TPtr FindNode(const TExprNode::TPtr& root, const TExprVisitPtrFunc& f
 
 TExprNode::TListType FindNodes(const TExprNode::TPtr& root, const TExprVisitPtrFunc& predicate);
 TExprNode::TListType FindNodes(const TExprNode::TPtr& root, const TExprVisitPtrFunc& filter, const TExprVisitPtrFunc& predicate);
-
+ 
 std::pair<TExprNode::TPtr, bool> FindSharedNode(const TExprNode::TPtr& firstRoot, const TExprNode::TPtr& secondRoot, const TExprVisitPtrFunc& predicate);
 bool HaveSharedNodes(const TExprNode::TPtr& firstRoot, const TExprNode::TPtr& secondRoot, const TExprVisitPtrFunc& predicate);
 
diff --git a/ydb/library/yql/core/yql_expr_type_annotation.cpp b/ydb/library/yql/core/yql_expr_type_annotation.cpp
index f2b793af8d..1ec53d612f 100644
--- a/ydb/library/yql/core/yql_expr_type_annotation.cpp
+++ b/ydb/library/yql/core/yql_expr_type_annotation.cpp
@@ -22,9 +22,9 @@
 
 namespace NYql {
 
-using namespace NNodes;
+using namespace NNodes; 
 using namespace NKikimr;
-
+ 
 namespace {
 
 constexpr TStringBuf TypeResourceTag = "_Type";
@@ -2438,32 +2438,32 @@ bool EnsureListOrEmptyType(TPositionHandle position, const TTypeAnnotationNode&
     return true;
 }
 
-bool EnsureListOfVoidType(const TExprNode& node, TExprContext& ctx) {
+bool EnsureListOfVoidType(const TExprNode& node, TExprContext& ctx) { 
     if (HasError(node.GetTypeAnn(), ctx) || !node.GetTypeAnn()) {
-        YQL_ENSURE(node.Type() == TExprNode::Lambda);
+        YQL_ENSURE(node.Type() == TExprNode::Lambda); 
         ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder() << "Expected list of void type, but got lambda"));
-        return false;
-    }
-
+        return false; 
+    } 
+ 
     return EnsureListOfVoidType(node.Pos(), *node.GetTypeAnn(), ctx);
-}
-
+} 
+ 
 bool EnsureListOfVoidType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx) {
-    if (!EnsureListType(position, type, ctx)) {
-        return false;
-    }
-
-    auto listType = type.Cast<TListExprType>();
-    YQL_ENSURE(listType);
-
-    if (listType->GetItemType()->GetKind() != ETypeAnnotationKind::Void) {
+    if (!EnsureListType(position, type, ctx)) { 
+        return false; 
+    } 
+ 
+    auto listType = type.Cast<TListExprType>(); 
+    YQL_ENSURE(listType); 
+ 
+    if (listType->GetItemType()->GetKind() != ETypeAnnotationKind::Void) { 
         ctx.AddError(TIssue(ctx.GetPosition(position), TStringBuilder() << "Expected list of void type, but got: " << type));
-        return false;
-    }
-
-    return true;
-}
-
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
 bool EnsureStreamType(const TExprNode& node, TExprContext& ctx) {
     if (HasError(node.GetTypeAnn(), ctx) || !node.GetTypeAnn()) {
         YQL_ENSURE(node.Type() == TExprNode::Lambda);
@@ -2888,9 +2888,9 @@ bool UpdateLambdaAllArgumentsTypes(TExprNode::TPtr& lambda, const std::vector<co
         }
     }
     if (!updateArgs && args.GetTypeAnn()) {
-        return true;
-    }
-
+        return true; 
+    } 
+ 
     TNodeOnNodeOwnedMap replaces;
     replaces.reserve(argumentsAnnotations.size());
 
@@ -3082,7 +3082,7 @@ bool EnsureListOrOptionalListType(const TExprNode& node, TExprContext& ctx) {
     return true;
 }
 
-bool EnsureSeqType(const TExprNode& node, TExprContext& ctx, bool* isStream) {
+bool EnsureSeqType(const TExprNode& node, TExprContext& ctx, bool* isStream) { 
     if (HasError(node.GetTypeAnn(), ctx)) {
         return false;
     }
@@ -3101,18 +3101,18 @@ bool EnsureSeqType(TPositionHandle position, const TTypeAnnotationNode& type, TE
         return false;
     }
 
-    switch (type.GetKind()) {
-        case ETypeAnnotationKind::List:
-        case ETypeAnnotationKind::Stream:
-            if (isStream) {
-                *isStream = (type.GetKind() == ETypeAnnotationKind::Stream);
-            }
-            return true;
-
-        default:
+    switch (type.GetKind()) { 
+        case ETypeAnnotationKind::List: 
+        case ETypeAnnotationKind::Stream: 
+            if (isStream) { 
+                *isStream = (type.GetKind() == ETypeAnnotationKind::Stream); 
+            } 
+            return true; 
+ 
+        default: 
             ctx.AddError(TIssue(ctx.GetPosition(position), TStringBuilder() << "Expected list or stream, but got: " << type));
-            return false;
-
+            return false; 
+ 
     }
 }
 
@@ -4191,26 +4191,26 @@ bool IsPureIsolatedLambda(const TExprNode& lambdaBody) {
 }
 
 TString GetIntegralAtomValue(ui64 value, bool hasSign) {
-    return (hasSign) ? "-" + ToString(value) : ToString(value);
-}
-
+    return (hasSign) ? "-" + ToString(value) : ToString(value); 
+} 
+ 
 bool AllowIntegralConversion(TCoIntegralCtor node, bool negate, EDataSlot toType, TString* atomValue) {
-    bool hasSign;
-    bool isSigned;
-    ui64 value;
+    bool hasSign; 
+    bool isSigned; 
+    ui64 value; 
     ExtractIntegralValue(node.Ref(), negate, hasSign, isSigned, value);
-
-    bool allow = false;
-
+ 
+    bool allow = false; 
+ 
     if (toType == EDataSlot::Uint8) {
-        allow = !hasSign && value <= Max<ui8>();
-    }
+        allow = !hasSign && value <= Max<ui8>(); 
+    } 
     else if (toType == EDataSlot::Uint16) {
         allow = !hasSign && value <= Max<ui16>();
     }
     else if (toType == EDataSlot::Uint32) {
-        allow = !hasSign && value <= Max<ui32>();
-    }
+        allow = !hasSign && value <= Max<ui32>(); 
+    } 
     else if (toType == EDataSlot::Int8) {
         allow = !hasSign && value <= (ui64)Max<i8>() || hasSign && value <= (ui64)Max<i8>() + 1;
     }
@@ -4218,25 +4218,25 @@ bool AllowIntegralConversion(TCoIntegralCtor node, bool negate, EDataSlot toType
         allow = !hasSign && value <= (ui64)Max<i16>() || hasSign && value <= (ui64)Max<i16>() + 1;
     }
     else if (toType == EDataSlot::Int32) {
-        allow = !hasSign && value <= (ui64)Max<i32>() || hasSign && value <= (ui64)Max<i32>() + 1;
-    }
+        allow = !hasSign && value <= (ui64)Max<i32>() || hasSign && value <= (ui64)Max<i32>() + 1; 
+    } 
     else if (toType == EDataSlot::Uint64) {
-        allow = !hasSign;
-    }
+        allow = !hasSign; 
+    } 
     else if (toType == EDataSlot::Int64) {
-        allow = !hasSign && value <= (ui64)Max<i64>() || hasSign && value <= (ui64)Max<i64>() + 1;
-    }
+        allow = !hasSign && value <= (ui64)Max<i64>() || hasSign && value <= (ui64)Max<i64>() + 1; 
+    } 
     else if (toType == EDataSlot::Float) {
-        allow = value <= Max<ui32>();
-    }
-
-    if (atomValue) {
-        *atomValue = GetIntegralAtomValue(value, hasSign && isSigned);
-    }
-
-    return allow;
-}
-
+        allow = value <= Max<ui32>(); 
+    }
+ 
+    if (atomValue) { 
+        *atomValue = GetIntegralAtomValue(value, hasSign && isSigned); 
+    } 
+ 
+    return allow; 
+} 
+ 
 void ExtractIntegralValue(const TExprNode& constructor, bool negate, bool& hasSign, bool& isSigned, ui64& value) {
     hasSign = false;
     isSigned = false;
@@ -4288,8 +4288,8 @@ void ExtractIntegralValue(const TExprNode& constructor, bool negate, bool& hasSi
             auto strValue = hasSign
                 ? atom.Content().Tail(1)
                 : atom.Content();
-
-            value = ::FromString<ui64>(strValue);
+ 
+            value = ::FromString<ui64>(strValue); 
         }
     }
     else {
@@ -4586,7 +4586,7 @@ static TString GetStructDiff(const TStructExprType& left, const TStructExprType&
         return res.pop_back(); // remove trailing comma
     }
     return "no diff";
-}
+} 
 
 TString GetTypeDiff(const TTypeAnnotationNode& left, const TTypeAnnotationNode& right) {
     if (&left == &right) {
diff --git a/ydb/library/yql/core/yql_expr_type_annotation.h b/ydb/library/yql/core/yql_expr_type_annotation.h
index a865aa27cd..2140d4cd29 100644
--- a/ydb/library/yql/core/yql_expr_type_annotation.h
+++ b/ydb/library/yql/core/yql_expr_type_annotation.h
@@ -101,7 +101,7 @@ bool EnsureListType(const TExprNode& node, TExprContext& ctx);
 bool EnsureListType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx);
 bool EnsureListOrEmptyType(const TExprNode& node, TExprContext& ctx);
 bool EnsureListOrEmptyType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx);
-bool EnsureListOfVoidType(const TExprNode& node, TExprContext& ctx);
+bool EnsureListOfVoidType(const TExprNode& node, TExprContext& ctx); 
 bool EnsureListOfVoidType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx);
 bool EnsureStreamType(const TExprNode& node, TExprContext& ctx);
 bool EnsureStreamType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx);
@@ -145,7 +145,7 @@ bool EnsureListOrOptionalType(const TExprNode& node, TExprContext& ctx);
 bool EnsureListOrOptionalListType(const TExprNode& node, TExprContext& ctx);
 bool EnsureStructOrOptionalStructType(const TExprNode& node, TExprContext& ctx);
 bool EnsureStructOrOptionalStructType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx);
-bool EnsureSeqType(const TExprNode& node, TExprContext& ctx, bool* isStream = nullptr);
+bool EnsureSeqType(const TExprNode& node, TExprContext& ctx, bool* isStream = nullptr); 
 bool EnsureSeqType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx, bool* isStream = nullptr);
 bool EnsureSeqOrOptionalType(const TExprNode& node, TExprContext& ctx);
 bool EnsureSeqOrOptionalType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx);
diff --git a/ydb/library/yql/core/yql_gc_transformer.cpp b/ydb/library/yql/core/yql_gc_transformer.cpp
index d74099da4d..048e2c91ce 100644
--- a/ydb/library/yql/core/yql_gc_transformer.cpp
+++ b/ydb/library/yql/core/yql_gc_transformer.cpp
@@ -5,12 +5,12 @@ namespace NYql {
 
 namespace {
 
-class TGcNodeTransformer : public TSyncTransformerBase {
+class TGcNodeTransformer : public TSyncTransformerBase { 
 public:
     TGcNodeTransformer()
     {}
 
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) override {
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) override { 
         output = input;
 
         if (!CurrentThreshold)
@@ -51,17 +51,17 @@ public:
         CurrentThreshold = Max(ctx.GcConfig.Settings.NodeCountThreshold, liveSize);
 
         if (liveSize > ctx.NodesAllocationLimit) {
-            ctx.AddError(YqlIssue(TPosition(), TIssuesIds::CORE_GC_NODES_LIMIT_EXCEEDED, TStringBuilder()
-                << "Too many allocated nodes, allowed: " << ctx.NodesAllocationLimit
-                << ", current: " << liveSize));
+            ctx.AddError(YqlIssue(TPosition(), TIssuesIds::CORE_GC_NODES_LIMIT_EXCEEDED, TStringBuilder() 
+                << "Too many allocated nodes, allowed: " << ctx.NodesAllocationLimit 
+                << ", current: " << liveSize)); 
             return TStatus::Error;
         }
 
         const auto poolSize = ctx.StringPool.MemoryAllocated() + ctx.StringPool.MemoryWaste();
         if (poolSize > ctx.StringsAllocationLimit) {
-            ctx.AddError(YqlIssue(TPosition(), TIssuesIds::CORE_GC_STRINGS_LIMIT_EXCEEDED, TStringBuilder()
-                << "Too large string pool, allowed: " << ctx.StringsAllocationLimit
-                << ", current: " << poolSize));
+            ctx.AddError(YqlIssue(TPosition(), TIssuesIds::CORE_GC_STRINGS_LIMIT_EXCEEDED, TStringBuilder() 
+                << "Too large string pool, allowed: " << ctx.StringsAllocationLimit 
+                << ", current: " << poolSize)); 
             return TStatus::Error;
         }
         return TStatus::Ok;
diff --git a/ydb/library/yql/core/yql_graph_transformer.cpp b/ydb/library/yql/core/yql_graph_transformer.cpp
index 26193c4c40..2ef08bb910 100644
--- a/ydb/library/yql/core/yql_graph_transformer.cpp
+++ b/ydb/library/yql/core/yql_graph_transformer.cpp
@@ -7,7 +7,7 @@ namespace NYql {
 
 namespace {
 
-class TCompositeGraphTransformer : public TGraphTransformerBase {
+class TCompositeGraphTransformer : public TGraphTransformerBase { 
 public:
     TCompositeGraphTransformer(const TVector<TTransformStage>& stages, bool useIssueScopes, bool doCheckArguments)
         : Stages(stages)
@@ -22,16 +22,16 @@ public:
     }
 
     void Rewind() override {
-        for (auto& stage : Stages) {
+        for (auto& stage : Stages) { 
             stage.GetTransformer().Rewind();
-        }
-
+        } 
+ 
         Index = 0;
-        LastIssueScope = Nothing();
+        LastIssueScope = Nothing(); 
         CheckArgumentsCount = 0;
     }
 
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) override {
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) override { 
 //#define TRACE_NODES
 #ifdef TRACE_NODES
         static ui64 TransformsCount = 0;
@@ -41,7 +41,7 @@ public:
         }
 #endif
 
-        if (Index >= Stages.size()) {
+        if (Index >= Stages.size()) { 
             if (LastIssueScope) {
                 ctx.IssueManager.LeaveScope();
                 LastIssueScope.Clear();
@@ -72,32 +72,32 @@ public:
         return status;
     }
 
-    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) override {
-        YQL_ENSURE(Index < Stages.size());
+    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) override { 
+        YQL_ENSURE(Index < Stages.size()); 
         return Stages[Index].GetTransformer().GetAsyncFuture(input);
     }
 
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) override {
-        YQL_ENSURE(Index < Stages.size());
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) override { 
+        YQL_ENSURE(Index < Stages.size()); 
         const auto status = Stages[Index].GetTransformer().ApplyAsyncChanges(input, output, ctx);
         return HandleStatus(status);
     }
 
     TStatistics GetStatistics() const final {
-        if (Statistics.Stages.empty()) {
-            Statistics.Stages.resize(Stages.size());
-        }
-
-        YQL_ENSURE(Stages.size() == Statistics.Stages.size());
-        for (size_t i = 0; i < Stages.size(); ++i) {
-            auto& stagePair = Statistics.Stages[i];
-            stagePair.first = Stages[i].Name;
+        if (Statistics.Stages.empty()) { 
+            Statistics.Stages.resize(Stages.size()); 
+        } 
+ 
+        YQL_ENSURE(Stages.size() == Statistics.Stages.size()); 
+        for (size_t i = 0; i < Stages.size(); ++i) { 
+            auto& stagePair = Statistics.Stages[i]; 
+            stagePair.first = Stages[i].Name; 
             stagePair.second =  Stages[i].GetTransformer().GetStatistics();
-        }
-
-        return Statistics;
-    }
-
+        } 
+ 
+        return Statistics; 
+    } 
+ 
 private:
     virtual TStatus HandleStatus(TStatus status) {
         if (status.Level == IGraphTransformer::TStatus::Error) {
@@ -117,8 +117,8 @@ private:
     }
 
     void UpdateIssueScope(TIssueManager& issueManager) {
-        YQL_ENSURE(Index < Stages.size());
-        const auto scopeIssueCode = Stages[Index].IssueCode;
+        YQL_ENSURE(Index < Stages.size()); 
+        const auto scopeIssueCode = Stages[Index].IssueCode; 
         const auto scopeIssueMessage = Stages[Index].IssueMessage;
         if (LastIssueScope != scopeIssueCode) {
             if (!LastIssueScope.Empty()) {
diff --git a/ydb/library/yql/core/yql_graph_transformer.h b/ydb/library/yql/core/yql_graph_transformer.h
index 60d87727dd..8ccbc7e4f4 100644
--- a/ydb/library/yql/core/yql_graph_transformer.h
+++ b/ydb/library/yql/core/yql_graph_transformer.h
@@ -34,14 +34,14 @@ public:
             };
         };
 
-        bool operator== (const TStatus& other) const {
-            return Raw == other.Raw;
-        }
-
-        bool operator!= (const TStatus& other) const {
-            return Raw != other.Raw;
-        }
-
+        bool operator== (const TStatus& other) const { 
+            return Raw == other.Raw; 
+        } 
+
+        bool operator!= (const TStatus& other) const { 
+            return Raw != other.Raw; 
+        } 
+ 
         bool operator== (ELevel other) const {
             return Level == other;
         }
@@ -70,129 +70,129 @@ public:
         }
     };
 
-    struct TStatistics {
-        TDuration TransformDuration;
-        TDuration WaitDuration;
-        i32 NewExprNodes;
-        i32 NewTypeNodes;
+    struct TStatistics { 
+        TDuration TransformDuration; 
+        TDuration WaitDuration; 
+        i32 NewExprNodes; 
+        i32 NewTypeNodes; 
         i32 NewConstraintNodes;
-        ui32 Repeats;
-        ui32 Restarts;
-
+        ui32 Repeats; 
+        ui32 Restarts; 
+ 
         TVector<std::pair<TString, TStatistics>> Stages;
-
-        TStatistics()
-            : TransformDuration(TDuration::Zero())
-            , WaitDuration(TDuration::Zero())
-            , NewExprNodes(0)
-            , NewTypeNodes(0)
+ 
+        TStatistics() 
+            : TransformDuration(TDuration::Zero()) 
+            , WaitDuration(TDuration::Zero()) 
+            , NewExprNodes(0) 
+            , NewTypeNodes(0) 
             , NewConstraintNodes(0)
-            , Repeats(0)
-            , Restarts(0)
-            , Stages() {}
-
-        static TStatistics NotPresent() { return TStatistics(); }
-        static TStatistics Zero() { return TStatistics(); }
-    };
-
+            , Repeats(0) 
+            , Restarts(0) 
+            , Stages() {} 
+ 
+        static TStatistics NotPresent() { return TStatistics(); } 
+        static TStatistics Zero() { return TStatistics(); } 
+    }; 
+ 
     virtual ~IGraphTransformer() {}
 
     virtual TStatus Transform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) = 0;
     virtual NThreading::TFuture<void> GetAsyncFuture(const TExprNode& input) = 0;
     virtual TStatus ApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) = 0;
     virtual void Rewind() {}
-
-    virtual TStatistics GetStatistics() const { return TStatistics::NotPresent(); }
+ 
+    virtual TStatistics GetStatistics() const { return TStatistics::NotPresent(); } 
 };
 
-class TGraphTransformerBase : public IGraphTransformer {
-private:
-    class TTransformScope {
-    public:
-        TTransformScope(TStatistics& statistics, const TExprContext* exprCtx)
-            : Statistics(statistics)
-            , ExprCtx(exprCtx)
-            , TransformStart(TInstant::Now())
-            , ExprNodesSize(exprCtx ? exprCtx->ExprNodes.size() : 0)
+class TGraphTransformerBase : public IGraphTransformer { 
+private: 
+    class TTransformScope { 
+    public: 
+        TTransformScope(TStatistics& statistics, const TExprContext* exprCtx) 
+            : Statistics(statistics) 
+            , ExprCtx(exprCtx) 
+            , TransformStart(TInstant::Now()) 
+            , ExprNodesSize(exprCtx ? exprCtx->ExprNodes.size() : 0) 
             , TypeNodesSize(exprCtx ? exprCtx->TypeNodes.size() : 0)
             , ConstraintNodesSize(exprCtx ? exprCtx->ConstraintNodes.size() : 0)
         {
         }
-
-        ~TTransformScope() {
-            Statistics.TransformDuration += TInstant::Now() - TransformStart;
-            if (ExprCtx) {
-                Statistics.NewExprNodes += ExprCtx->ExprNodes.size() - ExprNodesSize;
-                Statistics.NewTypeNodes += ExprCtx->TypeNodes.size() - TypeNodesSize;
+ 
+        ~TTransformScope() { 
+            Statistics.TransformDuration += TInstant::Now() - TransformStart; 
+            if (ExprCtx) { 
+                Statistics.NewExprNodes += ExprCtx->ExprNodes.size() - ExprNodesSize; 
+                Statistics.NewTypeNodes += ExprCtx->TypeNodes.size() - TypeNodesSize; 
                 Statistics.NewConstraintNodes += ExprCtx->ConstraintNodes.size() - ConstraintNodesSize;
-            }
-        }
-
-        TStatus HandleStatus(const TStatus& status) {
-            if (status == TStatus::Repeat) {
-                Statistics.Repeats++;
-            }
-
-            if (status.HasRestart) {
-                Statistics.Restarts++;
-            }
-
-            return status;
-        }
-
-    private:
-        TStatistics& Statistics;
-        const TExprContext* ExprCtx;
-        TInstant TransformStart;
-        i64 ExprNodesSize;
-        i64 TypeNodesSize;
+            } 
+        } 
+ 
+        TStatus HandleStatus(const TStatus& status) { 
+            if (status == TStatus::Repeat) { 
+                Statistics.Repeats++; 
+            } 
+ 
+            if (status.HasRestart) { 
+                Statistics.Restarts++; 
+            } 
+ 
+            return status; 
+        } 
+ 
+    private: 
+        TStatistics& Statistics; 
+        const TExprContext* ExprCtx; 
+        TInstant TransformStart; 
+        i64 ExprNodesSize; 
+        i64 TypeNodesSize; 
         i64 ConstraintNodesSize;
-    };
-
-public:
-    TGraphTransformerBase()
-        : Statistics(TStatistics::Zero())
-        , AsyncStart() {}
-
-    TStatus Transform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        TTransformScope scope(Statistics, &ctx);
-
-        return scope.HandleStatus(DoTransform(input, output, ctx));
-    }
-
-    NThreading::TFuture<void> GetAsyncFuture(const TExprNode& input) final {
-        TTransformScope scope(Statistics, nullptr);
-        AsyncStart = TInstant::Now();
-
-        return DoGetAsyncFuture(input);
-    }
-
-    TStatus ApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        TTransformScope scope(Statistics, &ctx);
-        Statistics.WaitDuration += TInstant::Now() - AsyncStart;
-
-        return scope.HandleStatus(DoApplyAsyncChanges(input, output, ctx));
-    }
-
-    virtual TStatistics GetStatistics() const override { return Statistics; }
-
-public:
-    virtual TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) = 0;
-    virtual NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) = 0;
-    virtual TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) = 0;
-
-protected:
-    mutable TStatistics Statistics;
-
-private:
-    TInstant AsyncStart;
-};
-
-struct TTransformStage {
-    TString Name;
-    EYqlIssueCode IssueCode;
+    }; 
+ 
+public: 
+    TGraphTransformerBase() 
+        : Statistics(TStatistics::Zero()) 
+        , AsyncStart() {} 
+ 
+    TStatus Transform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        TTransformScope scope(Statistics, &ctx); 
+ 
+        return scope.HandleStatus(DoTransform(input, output, ctx)); 
+    } 
+ 
+    NThreading::TFuture<void> GetAsyncFuture(const TExprNode& input) final { 
+        TTransformScope scope(Statistics, nullptr); 
+        AsyncStart = TInstant::Now(); 
+ 
+        return DoGetAsyncFuture(input); 
+    } 
+ 
+    TStatus ApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        TTransformScope scope(Statistics, &ctx); 
+        Statistics.WaitDuration += TInstant::Now() - AsyncStart; 
+ 
+        return scope.HandleStatus(DoApplyAsyncChanges(input, output, ctx)); 
+    } 
+ 
+    virtual TStatistics GetStatistics() const override { return Statistics; } 
+ 
+public: 
+    virtual TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) = 0; 
+    virtual NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) = 0; 
+    virtual TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) = 0; 
+ 
+protected: 
+    mutable TStatistics Statistics; 
+ 
+private: 
+    TInstant AsyncStart; 
+}; 
+ 
+struct TTransformStage { 
+    TString Name; 
+    EYqlIssueCode IssueCode; 
     TString IssueMessage;
-
+ 
     TTransformStage(const TAutoPtr<IGraphTransformer>& transformer, const TString& name, EYqlIssueCode issueCode, const TString& issueMessage = {})
         : Name(name)
         , IssueCode(issueCode)
@@ -215,8 +215,8 @@ struct TTransformStage {
 private:
     IGraphTransformer* const RawTransformer;
     const TAutoPtr<IGraphTransformer> Transformer;
-};
-
+}; 
+ 
 TAutoPtr<IGraphTransformer> CreateCompositeGraphTransformer(const TVector<TTransformStage>& stages, bool useIssueScopes);
 TAutoPtr<IGraphTransformer> CreateCompositeGraphTransformerWithNoArgChecks(const TVector<TTransformStage>& stages, bool useIssueScopes);
 
@@ -233,14 +233,14 @@ NThreading::TFuture<IGraphTransformer::TStatus> AsyncTransform(IGraphTransformer
 void AsyncTransform(IGraphTransformer& transformer, TExprNode::TPtr& root, TExprContext& ctx, bool applyAsyncChanges,
                     std::function<void(const IGraphTransformer::TStatus&)> asyncCallback);
 
-class TSyncTransformerBase : public TGraphTransformerBase {
+class TSyncTransformerBase : public TGraphTransformerBase { 
 public:
-    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
+    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
         Y_UNUSED(input);
         YQL_ENSURE(false, "Not supported");
     }
 
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         Y_UNUSED(input);
         Y_UNUSED(output);
         Y_UNUSED(ctx);
@@ -248,26 +248,26 @@ public:
     }
 };
 
-class TNullTransformer : public TSyncTransformerBase {
+class TNullTransformer : public TSyncTransformerBase { 
 public:
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        output = input;
-        Y_UNUSED(ctx);
-
-        return IGraphTransformer::TStatus::Ok;
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        output = input; 
+        Y_UNUSED(ctx); 
+ 
+        return IGraphTransformer::TStatus::Ok; 
     }
-};
-
-template <typename TFunctor>
-class TFunctorTransformer : public TSyncTransformerBase {
-public:
-    TFunctorTransformer(TFunctor functor)
-        : Functor(std::move(functor)) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+}; 
+
+template <typename TFunctor> 
+class TFunctorTransformer : public TSyncTransformerBase { 
+public: 
+    TFunctorTransformer(TFunctor functor) 
+        : Functor(std::move(functor)) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         TStatus status = Functor(input, output, ctx);
         YQL_ENSURE(status.Level != IGraphTransformer::TStatus::Async);
-
+ 
         return status;
     }
 
@@ -283,87 +283,87 @@ THolder<IGraphTransformer> CreateFunctorTransformer(TFunctor functor) {
 typedef std::function<IGraphTransformer::TStatus(const TExprNode::TPtr&, TExprNode::TPtr&, TExprContext&)> TAsyncTransformCallback;
 typedef NThreading::TFuture<TAsyncTransformCallback> TAsyncTransformCallbackFuture;
 
-template <typename TDerived>
-class TAsyncCallbackTransformer : public TGraphTransformerBase {
-public:
-    // CallbackTransform should return std::pair<TStatus, TAsyncTransformCallbackFuture>
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        auto pair = static_cast<TDerived*>(this)->CallbackTransform(input, output, ctx);
-        if (pair.first == TStatus::Async) {
-            YQL_ENSURE(Callbacks.emplace(input.Get(), pair.second).second);
-        }
-
-        return pair.first;
-    }
-
-    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
-        const auto it = Callbacks.find(&input);
-        YQL_ENSURE(it != Callbacks.cend());
-        return it->second.IgnoreResult();
-    }
-
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        const auto it = Callbacks.find(input.Get());
-        YQL_ENSURE(it != Callbacks.cend());
-        auto& future = it->second;
-        YQL_ENSURE(future.HasValue());
-        const auto status = future.GetValue()(input, output, ctx);
-        Callbacks.erase(it);
-        return status;
-    }
-
+template <typename TDerived> 
+class TAsyncCallbackTransformer : public TGraphTransformerBase { 
+public: 
+    // CallbackTransform should return std::pair<TStatus, TAsyncTransformCallbackFuture> 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        auto pair = static_cast<TDerived*>(this)->CallbackTransform(input, output, ctx); 
+        if (pair.first == TStatus::Async) { 
+            YQL_ENSURE(Callbacks.emplace(input.Get(), pair.second).second); 
+        } 
+ 
+        return pair.first; 
+    } 
+ 
+    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
+        const auto it = Callbacks.find(&input); 
+        YQL_ENSURE(it != Callbacks.cend()); 
+        return it->second.IgnoreResult(); 
+    } 
+ 
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        const auto it = Callbacks.find(input.Get()); 
+        YQL_ENSURE(it != Callbacks.cend()); 
+        auto& future = it->second; 
+        YQL_ENSURE(future.HasValue()); 
+        const auto status = future.GetValue()(input, output, ctx); 
+        Callbacks.erase(it); 
+        return status; 
+    } 
+ 
     void Rewind() override {
         Callbacks.clear();
     }
 
-private:
-    TNodeMap<TAsyncTransformCallbackFuture> Callbacks;
-};
-
+private: 
+    TNodeMap<TAsyncTransformCallbackFuture> Callbacks; 
+}; 
+ 
 template <typename TFuture, typename TCallback>
 std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture>
-WrapFutureCallback(const TFuture& future, const TCallback& callback, const TString& message = "") {
+WrapFutureCallback(const TFuture& future, const TCallback& callback, const TString& message = "") { 
     return std::make_pair(IGraphTransformer::TStatus::Async, future.Apply(
-        [callback, message](const TFuture& completedFuture) {
-            return TAsyncTransformCallback([completedFuture, callback, message](const TExprNode::TPtr& input,
-                TExprNode::TPtr& output, TExprContext& ctx)
-                {
-                    output = input;
-                    const auto& res = completedFuture.GetValue();
-
-                    TIssueScopeGuard issueScope(ctx.IssueManager, [&]() {
-                        return MakeIntrusive<TIssue>(
+        [callback, message](const TFuture& completedFuture) { 
+            return TAsyncTransformCallback([completedFuture, callback, message](const TExprNode::TPtr& input, 
+                TExprNode::TPtr& output, TExprContext& ctx) 
+                { 
+                    output = input; 
+                    const auto& res = completedFuture.GetValue(); 
+ 
+                    TIssueScopeGuard issueScope(ctx.IssueManager, [&]() { 
+                        return MakeIntrusive<TIssue>( 
                             ctx.GetPosition(input->Pos()),
-                            message.empty()
-                                ? TStringBuilder() << "Execution of node: " << input->Content()
-                                : message);
-                    });
-                    res.ReportIssues(ctx.IssueManager);
-
-                    if (!res.Success()) {
+                            message.empty() 
+                                ? TStringBuilder() << "Execution of node: " << input->Content() 
+                                : message); 
+                    }); 
+                    res.ReportIssues(ctx.IssueManager); 
+ 
+                    if (!res.Success()) { 
                         input->SetState(TExprNode::EState::Error);
-                        return IGraphTransformer::TStatus(IGraphTransformer::TStatus::Error);
-                    }
-                    else {
-                        return callback(res, input, output, ctx);
-                    }
+                        return IGraphTransformer::TStatus(IGraphTransformer::TStatus::Error); 
+                    } 
+                    else { 
+                        return callback(res, input, output, ctx); 
+                    } 
                 });
-        }));
+        })); 
 }
 
 template <typename TFuture, typename TResultExtractor>
 std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture>
-WrapFuture(const TFuture& future, const TResultExtractor& extractor, const TString& message = "") {
+WrapFuture(const TFuture& future, const TResultExtractor& extractor, const TString& message = "") { 
     return WrapFutureCallback(future, [extractor](const NThreading::TFutureType<TFuture>& res, const TExprNode::TPtr& input, TExprNode::TPtr& /*output*/, TExprContext& ctx) {
         input->SetState(TExprNode::EState::ExecutionComplete);
         input->SetResult(extractor(res, input, ctx));
         return IGraphTransformer::TStatus(IGraphTransformer::TStatus::Ok);
-    }, message);
+    }, message); 
 }
 
 template <typename TFuture, typename TResultExtractor>
 std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture>
-WrapModifyFuture(const TFuture& future, const TResultExtractor& extractor, const TString& message = "") {
+WrapModifyFuture(const TFuture& future, const TResultExtractor& extractor, const TString& message = "") { 
     return WrapFutureCallback(future, [extractor](const NThreading::TFutureType<TFuture>& res, const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
         TExprNode::TPtr resultNode = extractor(res, input, output, ctx);
         input->SetState(TExprNode::EState::ExecutionComplete);
@@ -372,7 +372,7 @@ WrapModifyFuture(const TFuture& future, const TResultExtractor& extractor, const
             return IGraphTransformer::TStatus(IGraphTransformer::TStatus::Repeat, true);
         }
         return IGraphTransformer::TStatus(IGraphTransformer::TStatus::Ok);
-    }, message);
+    }, message); 
 }
 
 inline std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture> SyncStatus(IGraphTransformer::TStatus status) {
diff --git a/ydb/library/yql/core/yql_library_compiler.cpp b/ydb/library/yql/core/yql_library_compiler.cpp
index 79296792e6..249833681c 100644
--- a/ydb/library/yql/core/yql_library_compiler.cpp
+++ b/ydb/library/yql/core/yql_library_compiler.cpp
@@ -192,21 +192,21 @@ bool CompileLibraries(const TUserDataTable& userData, TExprContext& ctx, TModule
 {
     THashMap<TString, TLibraryCohesion> libs;
     for (const auto& data : userData) {
-        if (data.first.IsFile() && data.second.Usage.Test(EUserDataBlockUsage::Library)) {
+        if (data.first.IsFile() && data.second.Usage.Test(EUserDataBlockUsage::Library)) { 
             TString libraryData;
             const TString& alias = data.first.Alias();
-            if (data.second.Type == EUserDataType::PATH) {
-                libraryData = Load(data.second.Data);
-            } else if (data.second.Type == EUserDataType::RAW_INLINE_DATA) {
-                libraryData = data.second.Data;
-            }
-
-            if (!libraryData.empty()) {
+            if (data.second.Type == EUserDataType::PATH) { 
+                libraryData = Load(data.second.Data); 
+            } else if (data.second.Type == EUserDataType::RAW_INLINE_DATA) { 
+                libraryData = data.second.Data; 
+            } 
+ 
+            if (!libraryData.empty()) { 
                 if (CompileLibrary(alias, libraryData, ctx, libs[alias], optimize))
                     modules[TModuleResolver::NormalizeModuleName(alias)] = libs[alias].Exports;
-                else
-                    return false;
-            }
+                else 
+                    return false; 
+            } 
         }
     }
 
diff --git a/ydb/library/yql/core/yql_opt_proposed_by_data.cpp b/ydb/library/yql/core/yql_opt_proposed_by_data.cpp
index 23a912303f..f528726a27 100644
--- a/ydb/library/yql/core/yql_opt_proposed_by_data.cpp
+++ b/ydb/library/yql/core/yql_opt_proposed_by_data.cpp
@@ -11,7 +11,7 @@ enum class ESource {
 };
 
 template <ESource Source, typename TGetTransformer, typename TFinish>
-class TDataProposalsInspector : public TGraphTransformerBase {
+class TDataProposalsInspector : public TGraphTransformerBase { 
 public:
     TDataProposalsInspector(const TTypeAnnotationContext& types, TGetTransformer getTransformer,
         TFinish finish)
@@ -21,7 +21,7 @@ public:
     {}
 
 private:
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         HasRepeats = false;
         if (Source == ESource::DataSource || Source == ESource::All) {
             for (auto& x : Types.DataSources) {
@@ -53,9 +53,9 @@ private:
 
         if (NewRoots.empty()) {
             if (HasRepeats) {
-                return TStatus::Repeat;
-            }
-
+                return TStatus::Repeat; 
+            } 
+ 
             Finish(ctx);
             return TStatus::Ok;
         }
@@ -64,20 +64,20 @@ private:
         return TStatus(TStatus::Repeat, true);
     }
 
-    void Rewind() final {
-        if (Source == ESource::DataSource || Source == ESource::All) {
-            for (auto& x : Types.DataSources) {
-                GetTransformer(x.Get()).Rewind();
-            }
-        }
-
-        if (Source == ESource::DataSink || Source == ESource::All) {
-            for (auto& x : Types.DataSinks) {
-                GetTransformer(x.Get()).Rewind();
-            }
-        }
-    }
-
+    void Rewind() final { 
+        if (Source == ESource::DataSource || Source == ESource::All) { 
+            for (auto& x : Types.DataSources) { 
+                GetTransformer(x.Get()).Rewind(); 
+            } 
+        } 
+ 
+        if (Source == ESource::DataSink || Source == ESource::All) { 
+            for (auto& x : Types.DataSinks) { 
+                GetTransformer(x.Get()).Rewind(); 
+            } 
+        } 
+    } 
+ 
     TStatus HandleProvider(IDataProvider* provider, const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
         TExprNode::TPtr newRoot;
         TStatus status = GetTransformer(provider).Transform(input, newRoot, ctx);
@@ -97,7 +97,7 @@ private:
         return status;
     }
 
-    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
+    NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
         TVector<NThreading::TFuture<void>> futures;
         for (auto& x : PendingProviders) {
             futures.push_back(GetTransformer(x).GetAsyncFuture(input));
@@ -106,7 +106,7 @@ private:
         return WaitExceptionOrAll(futures);
     }
 
-    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+    TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
         for (auto& x : PendingProviders) {
             TExprNode::TPtr newRoot;
             TStatus status = GetTransformer(x).ApplyAsyncChanges(input, newRoot, ctx);
@@ -124,9 +124,9 @@ private:
         bool hasRepeats = HasRepeats;
         HasRepeats = false;
         if (NewRoots.empty()) {
-            return hasRepeats
-                ? TStatus::Repeat
-                : TStatus::Ok;
+            return hasRepeats 
+                ? TStatus::Repeat 
+                : TStatus::Ok; 
         }
 
         ChooseRoot(std::move(input), output);
@@ -360,9 +360,9 @@ TAutoPtr<IGraphTransformer> CreateTableMetadataLoader(const TTypeAnnotationConte
         types,
         [](IDataProvider* provider) -> IGraphTransformer& {
             return provider->GetLoadTableMetadataTransformer();
-        },
-        [](TExprContext& ctx) {
-            ctx.Step.Done(TExprStep::LoadTablesMetadata);
+        }, 
+        [](TExprContext& ctx) { 
+            ctx.Step.Done(TExprStep::LoadTablesMetadata); 
         }
     );
 }
@@ -376,15 +376,15 @@ TAutoPtr<IGraphTransformer> CreateCompositeFinalizingTransformer(const TTypeAnno
     );
 }
 
-TAutoPtr<IGraphTransformer> CreatePlanInfoTransformer(const TTypeAnnotationContext& types) {
-    return CreateDataProposalsInspector<ESource::DataSink>(
-        types,
-        [](IDataProvider* provider) -> IGraphTransformer& {
-            return provider->GetPlanInfoTransformer();
-        }
-    );
-}
-
+TAutoPtr<IGraphTransformer> CreatePlanInfoTransformer(const TTypeAnnotationContext& types) { 
+    return CreateDataProposalsInspector<ESource::DataSink>( 
+        types, 
+        [](IDataProvider* provider) -> IGraphTransformer& { 
+            return provider->GetPlanInfoTransformer(); 
+        } 
+    ); 
+} 
+ 
 TAutoPtr<IGraphTransformer> CreateRecaptureDataProposalsInspector(const TTypeAnnotationContext& types, const TString& provider) {
     return CreateSpecificDataProposalsInspector<ESource::DataSink>(
         types,
diff --git a/ydb/library/yql/core/yql_opt_proposed_by_data.h b/ydb/library/yql/core/yql_opt_proposed_by_data.h
index 0ec0bcab43..647d9eabb7 100644
--- a/ydb/library/yql/core/yql_opt_proposed_by_data.h
+++ b/ydb/library/yql/core/yql_opt_proposed_by_data.h
@@ -19,6 +19,6 @@ TAutoPtr<IGraphTransformer> CreatePhysicalDataProposalsInspector(const TTypeAnno
 TAutoPtr<IGraphTransformer> CreatePhysicalFinalizers(const TTypeAnnotationContext& types);
 TAutoPtr<IGraphTransformer> CreateTableMetadataLoader(const TTypeAnnotationContext& types);
 TAutoPtr<IGraphTransformer> CreateCompositeFinalizingTransformer(const TTypeAnnotationContext& types);
-TAutoPtr<IGraphTransformer> CreatePlanInfoTransformer(const TTypeAnnotationContext& types);
+TAutoPtr<IGraphTransformer> CreatePlanInfoTransformer(const TTypeAnnotationContext& types); 
 
 }
diff --git a/ydb/library/yql/core/yql_type_annotation.h b/ydb/library/yql/core/yql_type_annotation.h
index 1a1f1fb476..8a529cb1ba 100644
--- a/ydb/library/yql/core/yql_type_annotation.h
+++ b/ydb/library/yql/core/yql_type_annotation.h
@@ -127,11 +127,11 @@ struct TCredential {
 using TCredentialTable = THashMap<TString, TCredential>;
 using TCredentialTablePtr = std::shared_ptr<TCredentialTable>;
 
-struct TUserCredentials {
-    TString OauthToken;
-    TString BlackboxSessionIdCookie;
-};
-
+struct TUserCredentials { 
+    TString OauthToken; 
+    TString BlackboxSessionIdCookie; 
+}; 
+ 
 bool SplitUdfName(TStringBuf name, TStringBuf& moduleName, TStringBuf& funcName);
 
 using TUdfModulesTable = THashMap<TString, TString>; // external module name -> alias of file
@@ -191,14 +191,14 @@ struct TTypeAnnotationContext: public TThrRefBase {
     TUserDataTable UserDataStorageCrutches;
     TYqlOperationOptions OperationOptions;
     TVector<TCredentialTablePtr> Credentials;
-    TUserCredentials UserCredentials;
+    TUserCredentials UserCredentials; 
     IModuleResolver::TPtr Modules;
     NUdf::EValidateMode ValidateMode = NUdf::EValidateMode::None;
     bool DisableNativeUdfSupport = false;
     TMaybe<TString> OptLLVM;
     bool IsReadOnly = false;
     TAutoPtr<IGraphTransformer> CustomInstantTypeTransformer;
-    bool Diagnostics = false;
+    bool Diagnostics = false; 
     THashMap<ui64, ui32> NodeToOperationId; // UniqueId->PublicId translation
     bool EvaluationInProgress = false;
     THashMap<ui64, const TTypeAnnotationNode*> ExpectedTypes;
diff --git a/ydb/library/yql/dq/README.md b/ydb/library/yql/dq/README.md
index 694f62e3f1..545cdd4d06 100644
--- a/ydb/library/yql/dq/README.md
+++ b/ydb/library/yql/dq/README.md
@@ -1,15 +1,15 @@
-# YQL Distributed Queries (DQ) library
-
-YQL DQ - библиотека базовых компонент для поддержки распределенного выполнения YQL запросов. Библиотека предоставляет набор примитивов, не привязанных к конкретной среде выполнения, позволяющих построить пайплайн распределенного выполнения YQL запросов для конкретной системы.
-
-Основные покрываемые области:
-- Представление и построение физического плана (stages & connections)
-- Представление и построение плана выполнения (tasks & channels)
+# YQL Distributed Queries (DQ) library 
+ 
+YQL DQ - библиотека базовых компонент для поддержки распределенного выполнения YQL запросов. Библиотека предоставляет набор примитивов, не привязанных к конкретной среде выполнения, позволяющих построить пайплайн распределенного выполнения YQL запросов для конкретной системы. 
+ 
+Основные покрываемые области: 
+- Представление и построение физического плана (stages & connections) 
+- Представление и построение плана выполнения (tasks & channels) 
 - Представление и выполнение runtime программы для одного task'а
-- Транспорт данных в каналах
-- Правила оптимизации запроса, не специфичные для конкретной системы
-- Хелперы для управления распределенным выполнением
-
-## Основные потребители
-* YDB (OLTP, ScanQuery)
-* YQL 2.0 (Interactive queries)
+- Транспорт данных в каналах 
+- Правила оптимизации запроса, не специфичные для конкретной системы 
+- Хелперы для управления распределенным выполнением 
+ 
+## Основные потребители 
+* YDB (OLTP, ScanQuery) 
+* YQL 2.0 (Interactive queries) 
diff --git a/ydb/library/yql/dq/actors/compute/dq_compute_actor.cpp b/ydb/library/yql/dq/actors/compute/dq_compute_actor.cpp
index c2f6c45e2b..7d9f09e9d0 100644
--- a/ydb/library/yql/dq/actors/compute/dq_compute_actor.cpp
+++ b/ydb/library/yql/dq/actors/compute/dq_compute_actor.cpp
@@ -1,13 +1,13 @@
 #include "dq_compute_actor_impl.h"
 #include "dq_compute_actor.h"
-
+ 
 #include <ydb/library/yql/dq/common/dq_common.h>
 
 namespace NYql {
 namespace NDq {
-
+ 
 using namespace NActors;
-
+ 
 namespace {
 TDqExecutionSettings ExecutionSettings;
 
@@ -28,10 +28,10 @@ TDqExecutionSettings& GetDqExecutionSettingsForTests() {
 
 class TDqComputeActor : public TDqComputeActorBase<TDqComputeActor> {
     using TBase = TDqComputeActorBase<TDqComputeActor>;
-
-public:
+ 
+public: 
     static constexpr char ActorName[] = "DQ_COMPUTE_ACTOR";
-
+ 
     TDqComputeActor(const TActorId& executerId, const TTxId& txId, NDqProto::TDqTask&& task,
         IDqSourceActorFactory::TPtr sourceActorFactory, IDqSinkActorFactory::TPtr sinkActorFactory,
         const TComputeRuntimeSettings& settings, const TComputeMemoryLimits& memoryLimits,
@@ -39,10 +39,10 @@ public:
         : TBase(executerId, txId, std::move(task), std::move(sourceActorFactory), std::move(sinkActorFactory), settings, memoryLimits)
         , TaskRunnerFactory(taskRunnerFactory)
     {}
-
-    void DoBootstrap() {
+ 
+    void DoBootstrap() { 
         const TActorSystem* actorSystem = TlsActivationContext->ActorSystem();
-
+ 
         TLogFunc logger;
         if (IsDebugLogEnabled(actorSystem)) {
             logger = [actorSystem, txId = this->GetTxId(), taskId = GetTask().GetId()] (const TString& message) {
@@ -56,15 +56,15 @@ public:
         PrepareTaskRunner();
 
         ContinueExecute();
-    }
+    } 
 
     void FillExtraStats(NDqProto::TDqComputeActorStats* /* dst */, bool /* last */) {
     }
 
 private:
     const TTaskRunnerFactory TaskRunnerFactory;
-};
-
+}; 
+ 
 
 IActor* CreateDqComputeActor(const TActorId& executerId, const TTxId& txId, NYql::NDqProto::TDqTask&& task,
     IDqSourceActorFactory::TPtr sourceActorFactory, IDqSinkActorFactory::TPtr sinkActorFactory,
diff --git a/ydb/library/yql/dq/actors/compute/dq_compute_actor.h b/ydb/library/yql/dq/actors/compute/dq_compute_actor.h
index 84eeda2edb..24eb261f9d 100644
--- a/ydb/library/yql/dq/actors/compute/dq_compute_actor.h
+++ b/ydb/library/yql/dq/actors/compute/dq_compute_actor.h
@@ -1,5 +1,5 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/dq/actors/compute/dq_compute_actor_sources.h>
 #include <ydb/library/yql/dq/actors/compute/dq_compute_actor_sinks.h>
 #include <ydb/library/yql/dq/actors/dq_events_ids.h>
@@ -12,19 +12,19 @@
 #include <library/cpp/actors/core/actor_bootstrapped.h>
 #include <library/cpp/actors/core/hfunc.h>
 #include <library/cpp/actors/core/log.h>
-
+ 
 namespace NYql {
 namespace NDq {
-
+ 
 struct TEvDqCompute {
     struct TEvState : public NActors::TEventPB<TEvState, NDqProto::TEvComputeActorState, TDqComputeEvents::EvState> {};
     struct TEvStateRequest : public NActors::TEventPB<TEvState, NDqProto::TEvComputeStateRequest, TDqComputeEvents::EvStateRequest> {};
-
+ 
     struct TEvResumeExecution : public NActors::TEventLocal<TEvResumeExecution, TDqComputeEvents::EvResumeExecution> {};
-
+ 
     struct TEvChannelsInfo : public NActors::TEventPB<TEvChannelsInfo, NDqProto::TEvChannelsInfo,
         TDqComputeEvents::EvChannelsInfo> {};
-
+ 
     struct TEvChannelData : public NActors::TEventPB<TEvChannelData, NDqProto::TEvComputeChannelData,
         TDqComputeEvents::EvChannelData> {};
 
@@ -186,8 +186,8 @@ struct TEvDqCompute {
         const TIssues Issues;
         const ui64 Generation;
     };
-};
-
+}; 
+ 
 struct TDqExecutionSettings {
     struct TFlowControl {
         ui64 MaxOutputChunkSize = 2_MB;
@@ -232,7 +232,7 @@ struct TComputeRuntimeSettings {
     std::function<void(bool success, const TString& reason)> TerminateHandler;
     TMaybe<NDqProto::TRlPath> RlPath;
 };
-
+ 
 using TAllocateMemoryCallback = std::function<bool(const TTxId& txId, ui64 taskId, ui64 memory)>;
 using TFreeMemoryCallback = std::function<void(const TTxId& txId, ui64 taskId, ui64 memory)>;
 
diff --git a/ydb/library/yql/dq/actors/compute/dq_compute_actor_impl.h b/ydb/library/yql/dq/actors/compute/dq_compute_actor_impl.h
index deaadefb42..ff02d11f21 100644
--- a/ydb/library/yql/dq/actors/compute/dq_compute_actor_impl.h
+++ b/ydb/library/yql/dq/actors/compute/dq_compute_actor_impl.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once 
 
 #include "dq_compute_actor.h"
 #include "dq_compute_actor_channels.h"
@@ -6,7 +6,7 @@
 #include "dq_compute_actor_sinks.h"
 #include "dq_compute_actor_sources.h"
 #include "dq_compute_issues_buffer.h"
-
+ 
 #include <ydb/core/scheme/scheme_tabledefs.h> // TODO: TTableId
 #include <ydb/core/base/kikimr_issue.h>
 #include <ydb/core/tablet_flat/util_basics.h> // TODO: IDestructable
@@ -48,7 +48,7 @@
 
 namespace NYql {
 namespace NDq {
-
+ 
 enum : ui64 {
     ComputeActorNonProtobufStateVersion = 1,
     ComputeActorCurrentStateVersion = 2,
@@ -71,20 +71,20 @@ protected:
         RlNoResourceTag = 102,
     };
 
-public:
-    void Bootstrap() {
-        try {
-            CA_LOG_D("Start compute actor " << this->SelfId() << ", task: " << Task.GetId());
-
+public: 
+    void Bootstrap() { 
+        try { 
+            CA_LOG_D("Start compute actor " << this->SelfId() << ", task: " << Task.GetId()); 
+ 
             Channels = new TDqComputeActorChannels(this->SelfId(), TxId, Task, !RuntimeSettings.FailOnUndelivery,
                 RuntimeSettings.StatsMode, MemoryLimits.ChannelBufferSize, this, this->GetActivityType());
-            this->RegisterWithSameMailbox(Channels);
-
-            if (RuntimeSettings.Timeout) {
-                CA_LOG_D("Set execution timeout " << *RuntimeSettings.Timeout);
+            this->RegisterWithSameMailbox(Channels); 
+ 
+            if (RuntimeSettings.Timeout) { 
+                CA_LOG_D("Set execution timeout " << *RuntimeSettings.Timeout); 
                 this->Schedule(*RuntimeSettings.Timeout, new NActors::TEvents::TEvWakeup(EEvWakeupTag::TimeoutTag));
-            }
-
+            } 
+ 
             if (auto reportStatsSettings = RuntimeSettings.ReportStatsSettings) {
                 if (reportStatsSettings->MaxInterval) {
                     CA_LOG_D("Set periodic stats " << reportStatsSettings->MaxInterval);
@@ -93,29 +93,29 @@ public:
             }
 
             if (SayHelloOnBootstrap()) {
-                // say "Hello" to executer
+                // say "Hello" to executer 
                 auto ev = MakeHolder<TEvDqCompute::TEvState>();
                 ev->Record.SetState(NDqProto::COMPUTE_STATE_EXECUTING);
-                ev->Record.SetTaskId(Task.GetId());
-
+                ev->Record.SetTaskId(Task.GetId()); 
+ 
                 this->Send(ExecuterId, ev.Release(), NActors::IEventHandle::FlagTrackDelivery);
                 this->Become(&TDqComputeActorBase::StateFuncBase);
-            }
-
-            static_cast<TDerived*>(this)->DoBootstrap();
+            } 
+ 
+            static_cast<TDerived*>(this)->DoBootstrap(); 
         } catch (const NKikimr::TMemoryLimitExceededException& e) {
             InternalError(TIssuesIds::KIKIMR_PRECONDITION_FAILED, TStringBuilder()
-                << "Mkql memory limit exceeded, limit: " << MkqlMemoryLimit
-                << ", host: " << HostName()
-                << ", canAllocateExtraMemory: " << CanAllocateExtraMemory);
-        } catch (const yexception& e) {
+                << "Mkql memory limit exceeded, limit: " << MkqlMemoryLimit 
+                << ", host: " << HostName() 
+                << ", canAllocateExtraMemory: " << CanAllocateExtraMemory); 
+        } catch (const yexception& e) { 
             InternalError(TIssuesIds::DEFAULT_ERROR, e.what());
-        }
+        } 
 
         ReportEventElapsedTime();
-    }
-
-protected:
+    } 
+ 
+protected: 
     TDqComputeActorBase(const NActors::TActorId& executerId, const TTxId& txId, NDqProto::TDqTask&& task,
         IDqSourceActorFactory::TPtr sourceActorFactory, IDqSinkActorFactory::TPtr sinkActorFactory,
         const TComputeRuntimeSettings& settings, const TComputeMemoryLimits& memoryLimits)
@@ -139,7 +139,7 @@ protected:
         }
         InitializeTask();
     }
-
+ 
     TDqComputeActorBase(const NActors::TActorId& executerId, const TTxId& txId, const NDqProto::TDqTask& task,
         IDqSourceActorFactory::TPtr sourceActorFactory, IDqSinkActorFactory::TPtr sinkActorFactory,
         const TComputeRuntimeSettings& settings, const TComputeMemoryLimits& memoryLimits)
@@ -207,9 +207,9 @@ protected:
             }
         } catch (const NKikimr::TMemoryLimitExceededException& e) {
             InternalError(TIssuesIds::KIKIMR_PRECONDITION_FAILED, TStringBuilder()
-                << "Mkql memory limit exceeded, limit: " << MkqlMemoryLimit
-                << ", host: " << HostName()
-                << ", canAllocateExtraMemory: " << CanAllocateExtraMemory);
+                << "Mkql memory limit exceeded, limit: " << MkqlMemoryLimit 
+                << ", host: " << HostName() 
+                << ", canAllocateExtraMemory: " << CanAllocateExtraMemory); 
         } catch (const yexception& e) {
             InternalError(TIssuesIds::DEFAULT_ERROR, e.what());
         }
@@ -222,7 +222,7 @@ protected:
 protected:
     void DoExecute() {
         auto guard = BindAllocator();
-        auto* alloc = guard.GetMutex();
+        auto* alloc = guard.GetMutex(); 
 
         if (State == NDqProto::COMPUTE_STATE_FINISHED) {
             DoHandleChannelsAfterFinishImpl();
@@ -231,7 +231,7 @@ protected:
         }
 
         if (alloc->GetAllocated() - alloc->GetUsed() > MemoryLimits.MinMemFreeSize) {
-            alloc->ReleaseFreePages();
+            alloc->ReleaseFreePages(); 
             if (MemoryLimits.FreeMemoryFn) {
                 auto newLimit = std::max(alloc->GetAllocated(), CalcMkqlMemoryLimit());
                 if (MkqlMemoryLimit > newLimit) {
@@ -242,11 +242,11 @@ protected:
                     CA_LOG_I("[Mem] memory shrinked, new limit: " << MkqlMemoryLimit);
                 }
             }
-        }
+        } 
 
         auto now = TInstant::Now();
 
-        if (Y_UNLIKELY(ProfileStats)) {
+        if (Y_UNLIKELY(ProfileStats)) { 
             ProfileStats->MkqlMaxUsedMemory = std::max(ProfileStats->MkqlMaxUsedMemory, alloc->GetPeakAllocated());
             CA_LOG_D("Peak memory usage: " << ProfileStats->MkqlMaxUsedMemory);
         }
@@ -259,9 +259,9 @@ protected:
 
         PollSourceActors();
         ERunStatus status = TaskRunner->Run();
-
+ 
         CA_LOG_D("Resume execution, run status: " << status);
-
+ 
         if (status != ERunStatus::Finished) {
             PollSources(std::move(sourcesState));
         }
@@ -306,7 +306,7 @@ protected:
                 }
                 continue;
             }
-
+ 
             if (!outputChannel.Finished || Checkpoints) {
                 if (Channels->CanSendChannelData(channelId)) {
                     auto peerState = Channels->GetOutputChannelInFlightState(channelId);
@@ -364,9 +364,9 @@ protected:
                 // we have sent some data, so we have space in output channel(s)
                 ContinueExecute();
             }
-            return;
-        }
-
+            return; 
+        } 
+ 
         // Handle finishing of our task.
         if (status == ERunStatus::Finished && State != NDqProto::COMPUTE_STATE_FINISHED) {
             if (ProcessOutputsState.HasDataToSend || !ProcessOutputsState.ChannelsReady) {
@@ -383,9 +383,9 @@ protected:
                     ReportStateAndMaybeDie(TIssue("success"));
                 }
             }
-        }
-    }
-
+        } 
+    } 
+ 
 protected:
     void Terminate(bool success, const TString& message) {
 
@@ -485,8 +485,8 @@ protected:
 
         TerminateSources(NDqProto::EComputeState_Name(State), State == NDqProto::COMPUTE_STATE_FINISHED);
         Terminate(State == NDqProto::COMPUTE_STATE_FINISHED, NDqProto::EComputeState_Name(State));
-    }
-
+    } 
+ 
     void InternalError(TIssuesIds::EIssueCode issueCode, const TString& message) {
         CA_LOG_E(TIssuesIds::EIssueCode_Name(issueCode) << ": " << message << ".");
         TIssue issue(message);
@@ -494,15 +494,15 @@ protected:
         std::optional<TGuard<NKikimr::NMiniKQL::TScopedAlloc>> guard = MaybeBindAllocator();
         State = NDqProto::COMPUTE_STATE_FAILURE;
         ReportStateAndMaybeDie(std::move(issue));
-    }
-
+    } 
+ 
     void ContinueExecute() {
         if (!ResumeEventScheduled && Running) {
             ResumeEventScheduled = true;
             this->Send(this->SelfId(), new TEvDqCompute::TEvResumeExecution());
         }
-    }
-
+    } 
+ 
 public:
     i64 GetInputChannelFreeSpace(ui64 channelId) const override {
         const TInputChannelInfo* inputChannel = InputChannelsMap.FindPtr(channelId);
@@ -788,14 +788,14 @@ protected:
         if (Running) {
             DoExecute();
         }
-    }
-
+    } 
+ 
     void HandleExecuteBase(TEvDqCompute::TEvChannelsInfo::TPtr& ev) {
-        auto& record = ev->Get()->Record;
-
+        auto& record = ev->Get()->Record; 
+ 
         CA_LOG_D("Received channels info: " << record.ShortDebugString());
-
-        for (auto& channelUpdate : record.GetUpdate()) {
+ 
+        for (auto& channelUpdate : record.GetUpdate()) { 
             TInputChannelInfo* inputChannel = InputChannelsMap.FindPtr(channelUpdate.GetId());
             if (inputChannel && !inputChannel->HasPeer && channelUpdate.GetSrcEndpoint().HasActorId()) {
                 auto peer = NActors::ActorIdFromProto(channelUpdate.GetSrcEndpoint().GetActorId());
@@ -821,11 +821,11 @@ protected:
             }
 
             YQL_ENSURE(inputChannel || outputChannel, "Unknown channelId: " << channelUpdate.GetId() << ", task: " << Task.GetId());
-        }
-
+        } 
+ 
         DoExecute();
-    }
-
+    } 
+ 
     void HandleExecuteBase(NActors::TEvents::TEvWakeup::TPtr& ev) {
         auto tag = (EEvWakeupTag) ev->Get()->Tag;
         switch (tag) {
@@ -1109,10 +1109,10 @@ protected:
 
     const NDqProto::TDqTask& GetTask() const {
         return Task;
-    }
-
+    } 
+ 
     NDqProto::EDqStatsMode GetStatsMode() const {
-        return RuntimeSettings.StatsMode;
+        return RuntimeSettings.StatsMode; 
     }
 
     bool GetUseLLVM() const {
@@ -1132,14 +1132,14 @@ protected:
         YQL_ENSURE(TaskRunner);
 
         auto guard = TaskRunner->BindAllocator(MkqlMemoryLimit);
-        auto* alloc = guard.GetMutex();
-
-        if (CanAllocateExtraMemory) {
-            alloc->Ref().SetIncreaseMemoryLimitCallback([this, alloc](ui64 limit, ui64 required) {
-                RequestExtraMemory(required - limit, alloc);
-            });
-        }
-
+        auto* alloc = guard.GetMutex(); 
+ 
+        if (CanAllocateExtraMemory) { 
+            alloc->Ref().SetIncreaseMemoryLimitCallback([this, alloc](ui64 limit, ui64 required) { 
+                RequestExtraMemory(required - limit, alloc); 
+            }); 
+        } 
+ 
         TDqTaskRunnerMemoryLimits limits;
         limits.ChannelBufferSize = MemoryLimits.ChannelBufferSize;
         limits.OutputChunkMaxSize = GetDqExecutionSettings().FlowControl.MaxOutputChunkSize;
@@ -1207,7 +1207,7 @@ protected:
             this->RegisterWithSameMailbox(sink.Actor);
         }
     }
-
+ 
     void PollSourceActors() { // TODO: rename to PollSources()
         // Don't produce any input from sources if we're about to save checkpoint.
         if (!Running || (Checkpoints && Checkpoints->HasPendingCheckpoint() && !Checkpoints->ComputeActorStateSaved())) {
@@ -1284,9 +1284,9 @@ private:
                     auto result = InputChannelsMap.emplace(channel.GetId(), TInputChannelInfo(channel.GetId(), channel.GetCheckpointingMode()));
                     YQL_ENSURE(result.second);
                 }
-            }
+            } 
         }
-
+ 
         for (ui32 i = 0; i < Task.OutputsSize(); ++i) {
             const auto& outputDesc = Task.GetOutputs(i);
             Y_VERIFY(!outputDesc.HasSink() || outputDesc.ChannelsSize() == 0); // HasSink => no channels
@@ -1306,12 +1306,12 @@ private:
                     auto result = OutputChannelsMap.emplace(channel.GetId(), std::move(outputChannel));
                     YQL_ENSURE(result.second);
                 }
-            }
-        }
+            } 
+        } 
 
         MkqlMemoryLimit = CalcMkqlMemoryLimit();
-    }
-
+    } 
+ 
     static ui64 AlignMemorySizeToMbBoundary(ui64 memory) {
         // allocate memory in 1_MB (2^20B) chunks, so requested value is rounded up to MB boundary
         constexpr ui64 alignMask = 1_MB - 1;
@@ -1346,8 +1346,8 @@ private:
 
         if (last) {
             ReportEventElapsedTime();
-        }
-
+        } 
+ 
         dst->SetCpuTimeUs(BasicStats->CpuTime.MicroSeconds());
 
         if (ProfileStats) {
@@ -1461,7 +1461,7 @@ protected:
     const NDqProto::TDqTask Task;
     const TComputeRuntimeSettings RuntimeSettings;
     const TComputeMemoryLimits MemoryLimits;
-    const bool CanAllocateExtraMemory = false;
+    const bool CanAllocateExtraMemory = false; 
     const IDqSourceActorFactory::TPtr SourceActorFactory;
     const IDqSinkActorFactory::TPtr SinkActorFactory;
     const NDqProto::ECheckpointingMode CheckpointingMode;
@@ -1500,7 +1500,7 @@ protected:
 private:
     bool Running = true;
     TInstant LastSendStatsTime;
-};
-
+}; 
+ 
 } // namespace NYql
 } // namespace NNq
diff --git a/ydb/library/yql/dq/actors/dq_events_ids.h b/ydb/library/yql/dq/actors/dq_events_ids.h
index 698377a393..aff8f7263e 100644
--- a/ydb/library/yql/dq/actors/dq_events_ids.h
+++ b/ydb/library/yql/dq/actors/dq_events_ids.h
@@ -1,21 +1,21 @@
-#pragma once
-
+#pragma once 
+ 
 #include <library/cpp/actors/core/events.h>
-
+ 
 namespace NYql {
 namespace NDq {
-
+ 
 struct TDqEvents {
     enum EEventSpaceDq {
         ES_DQ_COMPUTE_KQP_COMPATIBLE = 4145, // TKikimrEvents::ES_KQP
         ES_DQ_COMPUTE = 4212 //TKikimrEvents::ES_DQ
-    };
+    }; 
 
     enum EDqEvents {
         EvAbortExecution = EventSpaceBegin(ES_DQ_COMPUTE_KQP_COMPATIBLE) + 15
     };
-};
-
+}; 
+ 
 struct TDqComputeEvents {
     enum EDqComputeEvents {
         Unused0 = EventSpaceBegin(TDqEvents::ES_DQ_COMPUTE_KQP_COMPATIBLE) + 200,
@@ -52,10 +52,10 @@ struct TDqComputeEvents {
         // place all new events here
 
         EvEnd
-    };
+    }; 
 
     static_assert(EvEnd < EventSpaceBegin((TDqEvents::ES_DQ_COMPUTE + 1)));
-};
-
+}; 
+ 
 } // namespace NDq
 } // namespace NYql
diff --git a/ydb/library/yql/dq/actors/protos/dq_events.proto b/ydb/library/yql/dq/actors/protos/dq_events.proto
index 0e38ab3bbc..226d28c9dc 100644
--- a/ydb/library/yql/dq/actors/protos/dq_events.proto
+++ b/ydb/library/yql/dq/actors/protos/dq_events.proto
@@ -1,6 +1,6 @@
 package NYql.NDqProto;
 option cc_enable_arenas = true;
-
+ 
 import "library/cpp/actors/protos/actors.proto";
 import "ydb/library/yql/dq/actors/protos/dq_stats.proto";
 import "ydb/library/yql/dq/proto/dq_state_load_plan.proto";
@@ -8,7 +8,7 @@ import "ydb/library/yql/dq/proto/dq_tasks.proto";
 import "ydb/library/yql/dq/proto/dq_transport.proto";
 import "ydb/public/api/protos/ydb_status_codes.proto";
 import "ydb/public/api/protos/ydb_issue_message.proto";
-
+ 
 message TCheckpoint {
     optional uint64 Id = 1;
     optional uint64 Generation = 2;
@@ -20,28 +20,28 @@ message TCheckpoint {
     2) Checkpoint
     3) Finished
 */
-message TChannelData {
-    optional uint64 ChannelId = 1;
+message TChannelData { 
+    optional uint64 ChannelId = 1; 
     optional NYql.NDqProto.TData Data = 2;
-    optional bool Finished = 3;
+    optional bool Finished = 3; 
     optional TCheckpoint Checkpoint = 4;
-};
-
+}; 
+ 
 message TEvRun {
     optional TMessageTransportMeta TransportMeta = 100;
 }
 
-message TEvChannelsInfo {
-    repeated NYql.NDqProto.TChannel Update = 1;
-};
-
-enum EComputeState {
-    COMPUTE_STATE_UNKNOWN = 0;
-    COMPUTE_STATE_FAILURE = 1;
-    COMPUTE_STATE_EXECUTING = 2;
-    COMPUTE_STATE_FINISHED = 3;
-};
-
+message TEvChannelsInfo { 
+    repeated NYql.NDqProto.TChannel Update = 1; 
+}; 
+ 
+enum EComputeState { 
+    COMPUTE_STATE_UNKNOWN = 0; 
+    COMPUTE_STATE_FAILURE = 1; 
+    COMPUTE_STATE_EXECUTING = 2; 
+    COMPUTE_STATE_FINISHED = 3; 
+}; 
+ 
 message TComputeActorStats {
     optional NActorsProto.TActorId ActorId = 1;
     reserved 2; //optional NKqpProto.TKqpStatsRun LegacyStats = 2;
@@ -54,17 +54,17 @@ message TEvComputeActorState {
     repeated Ydb.Issue.IssueMessage Issues = 4;
     optional uint64 TaskId = 5;
     optional TDqComputeActorStats Stats = 6;
-};
-
+}; 
+ 
 message TEvComputeStateRequest {
 }
 
-message TEvComputeChannelData {
-    optional TChannelData ChannelData = 1;
+message TEvComputeChannelData { 
+    optional TChannelData ChannelData = 1; 
     optional uint64 SendTime = 2;
     optional uint64 SeqNo = 3;
     optional bool NoAck = 4;
-};
+}; 
 
 message TEvComputeChannelDataAck {
     optional uint64 ChannelId = 1;
@@ -90,7 +90,7 @@ message TComputeRuntimeSettings {
 
     enum EExecType {
         UNSPECIFIED = 0;
-        SCAN = 1;
+        SCAN = 1; 
         DATA = 2;
     }
     optional EExecType ExecType = 2;
diff --git a/ydb/library/yql/dq/expr_nodes/dq_expr_nodes.h b/ydb/library/yql/dq/expr_nodes/dq_expr_nodes.h
index 48cfcfeb79..6158b1bb0a 100644
--- a/ydb/library/yql/dq/expr_nodes/dq_expr_nodes.h
+++ b/ydb/library/yql/dq/expr_nodes/dq_expr_nodes.h
@@ -13,31 +13,31 @@ struct TTopSortSettings {
     static inline const TString DescendingSort = "Desc";
 };
 
-class TDqConnection : public NGenerated::TDqConnectionStub<TExprBase, TCallable, TDqOutput> {
-public:
-    explicit TDqConnection(const TExprNode* node)
-        : TDqConnectionStub(node) {}
-
-    explicit TDqConnection(const TExprNode::TPtr& node)
-        : TDqConnectionStub(node) {}
-
-    static bool Match(const TExprNode* node) {
-        if (!node) {
-            return false;
-        }
-
-        if (!node->IsCallable()) {
-            return false;
-        }
-
-        if (node->ChildrenSize() < 1) {
-            return false;
-        }
-
-        return TDqOutput::Match(node->Child(0));
-    }
-};
-
+class TDqConnection : public NGenerated::TDqConnectionStub<TExprBase, TCallable, TDqOutput> { 
+public: 
+    explicit TDqConnection(const TExprNode* node) 
+        : TDqConnectionStub(node) {} 
+ 
+    explicit TDqConnection(const TExprNode::TPtr& node) 
+        : TDqConnectionStub(node) {} 
+ 
+    static bool Match(const TExprNode* node) { 
+        if (!node) { 
+            return false; 
+        } 
+ 
+        if (!node->IsCallable()) { 
+            return false; 
+        } 
+ 
+        if (node->ChildrenSize() < 1) { 
+            return false; 
+        } 
+ 
+        return TDqOutput::Match(node->Child(0)); 
+    } 
+}; 
+ 
 #include <ydb/library/yql/dq/expr_nodes/dq_expr_nodes.defs.inl.h>
 
-} // namespace NYql::NDq
+} // namespace NYql::NDq 
diff --git a/ydb/library/yql/dq/expr_nodes/dq_expr_nodes.json b/ydb/library/yql/dq/expr_nodes/dq_expr_nodes.json
index 67627b1b8b..2d3d597b38 100644
--- a/ydb/library/yql/dq/expr_nodes/dq_expr_nodes.json
+++ b/ydb/library/yql/dq/expr_nodes/dq_expr_nodes.json
@@ -1,57 +1,57 @@
 {
-    "NodeRootType": "TExprBase",
-    "NodeBuilderBase": "TNodeBuilderBase",
-    "ListBuilderBase": "TListBuilderBase",
-    "FreeArgCallableBase": "TFreeArgCallable",
-    "FreeArgBuilderBase": "TFreeArgCallableBuilderBase",
-    "Nodes": [
-    {
-        "Name": "TDqJoinKeyTuple",
-        "Base": "TExprBase",
-        "Match": {"Type": "Tuple"},
-        "Children": [
-            {"Index": 0, "Name": "LeftLabel", "Type": "TCoAtom"},
-            {"Index": 1, "Name": "LeftColumn", "Type": "TCoAtom"},
-            {"Index": 2, "Name": "RightLabel", "Type": "TCoAtom"},
-            {"Index": 3, "Name": "RightColumn", "Type": "TCoAtom"}
-        ]
-    },
-    {
-        "Name": "TDqJoinKeyTupleList",
-        "ListBase": "TDqJoinKeyTuple"
-    },
-    {
-        "Name": "TDqJoinBase",
-        "Base": "TCallable",
-        "Match": {"Type": "CallableBase"},
-        "Builder": {"Generate": "None"},
-        "Children": [
-            {"Index": 0, "Name": "LeftInput", "Type": "TExprBase"},
-            {"Index": 2, "Name": "LeftLabel", "Type": "TExprBase",
-                "NB": "Atom - if left is real table, Void - otherwise"},
-            {"Index": 1, "Name": "RightInput", "Type": "TExprBase"},
-            {"Index": 3, "Name": "RightLabel", "Type": "TExprBase",
-                "NB": "Atom - if right is real table, Void - otherwise"},
-            {"Index": 4, "Name": "JoinType", "Type": "TCoAtom"},
-            {"Index": 5, "Name": "JoinKeys", "Type": "TDqJoinKeyTupleList"}
-        ]
-    },
-    {
-        "Name": "TDqJoin",
-        "Base": "TDqJoinBase",
-        "Match": {"Type": "Callable", "Name": "DqJoin"}
-    },
-    {
-        "Name": "TDqPhyMapJoin",
-        "Base": "TDqJoinBase",
-        "Match": {"Type": "Callable", "Name": "DqPhyMapJoin"}
-    },
-    {
-        "Name": "TDqPhyCrossJoin",
-        "Base": "TDqJoinBase",
-        "Match": {"Type": "Callable", "Name": "DqPhyCrossJoin"}
-    },
-    {
+    "NodeRootType": "TExprBase", 
+    "NodeBuilderBase": "TNodeBuilderBase", 
+    "ListBuilderBase": "TListBuilderBase", 
+    "FreeArgCallableBase": "TFreeArgCallable", 
+    "FreeArgBuilderBase": "TFreeArgCallableBuilderBase", 
+    "Nodes": [ 
+    {
+        "Name": "TDqJoinKeyTuple", 
+        "Base": "TExprBase", 
+        "Match": {"Type": "Tuple"}, 
+        "Children": [ 
+            {"Index": 0, "Name": "LeftLabel", "Type": "TCoAtom"}, 
+            {"Index": 1, "Name": "LeftColumn", "Type": "TCoAtom"}, 
+            {"Index": 2, "Name": "RightLabel", "Type": "TCoAtom"}, 
+            {"Index": 3, "Name": "RightColumn", "Type": "TCoAtom"} 
+        ] 
+    }, 
+    { 
+        "Name": "TDqJoinKeyTupleList", 
+        "ListBase": "TDqJoinKeyTuple" 
+    }, 
+    { 
+        "Name": "TDqJoinBase", 
+        "Base": "TCallable", 
+        "Match": {"Type": "CallableBase"}, 
+        "Builder": {"Generate": "None"}, 
+        "Children": [ 
+            {"Index": 0, "Name": "LeftInput", "Type": "TExprBase"}, 
+            {"Index": 2, "Name": "LeftLabel", "Type": "TExprBase", 
+                "NB": "Atom - if left is real table, Void - otherwise"}, 
+            {"Index": 1, "Name": "RightInput", "Type": "TExprBase"}, 
+            {"Index": 3, "Name": "RightLabel", "Type": "TExprBase", 
+                "NB": "Atom - if right is real table, Void - otherwise"}, 
+            {"Index": 4, "Name": "JoinType", "Type": "TCoAtom"}, 
+            {"Index": 5, "Name": "JoinKeys", "Type": "TDqJoinKeyTupleList"} 
+        ] 
+    }, 
+    { 
+        "Name": "TDqJoin", 
+        "Base": "TDqJoinBase", 
+        "Match": {"Type": "Callable", "Name": "DqJoin"} 
+    }, 
+    { 
+        "Name": "TDqPhyMapJoin", 
+        "Base": "TDqJoinBase", 
+        "Match": {"Type": "Callable", "Name": "DqPhyMapJoin"} 
+    }, 
+    { 
+        "Name": "TDqPhyCrossJoin", 
+        "Base": "TDqJoinBase", 
+        "Match": {"Type": "Callable", "Name": "DqPhyCrossJoin"} 
+    }, 
+    { 
         "Name": "TDqPhyJoinDict",
         "Base": "TDqJoinBase",
         "Match": {"Type": "Callable", "Name": "DqPhyJoinDict"}
@@ -81,15 +81,15 @@
     },
     {
         "Name": "TDqStageBase",
-        "Base": "TCallable",
+        "Base": "TCallable", 
         "Match": {"Type": "CallableBase"},
         "Builder": {"Generate": "None"},
-        "Children": [
-            {"Index": 0, "Name": "Inputs", "Type": "TExprList"},
+        "Children": [ 
+            {"Index": 0, "Name": "Inputs", "Type": "TExprList"}, 
             {"Index": 1, "Name": "Program", "Type": "TCoLambda"},
             {"Index": 2, "Name": "Settings", "Type": "TCoNameValueTupleList"},
             {"Index": 3, "Name": "Sinks", "Type": "TDqSinksList", "Optional": true}
-        ]
+        ] 
     },
     {
         "Name": "TDqStage",
@@ -102,7 +102,7 @@
         "Match": {"Type": "Callable", "Name": "DqPhyStage"}
     },
     {
-        "Name": "TDqStageList",
+        "Name": "TDqStageList", 
         "ListBase": "TDqStageBase"
     },
     {
@@ -110,60 +110,60 @@
         "ListBase": "TDqPhyStage"
     },
     {
-        "Name": "TDqOutput",
-        "Base": "TCallable",
-        "Match": {"Type": "Callable", "Name": "TDqOutput"},
-        "Children": [
+        "Name": "TDqOutput", 
+        "Base": "TCallable", 
+        "Match": {"Type": "Callable", "Name": "TDqOutput"}, 
+        "Children": [ 
             {"Index": 0, "Name": "Stage", "Type": "TDqStageBase"},
-            {"Index": 1, "Name": "Index", "Type": "TCoAtom"}
-        ]
+            {"Index": 1, "Name": "Index", "Type": "TCoAtom"} 
+        ] 
     },
     {
-        "Name": "TDqConnection",
-        "Base": "TCallable",
-        "Definition": "Custom",
-        "Builder": {"Generate": "None"},
-        "Children": [
-            {"Index": 0, "Name": "Output", "Type": "TDqOutput"}
-        ]
+        "Name": "TDqConnection", 
+        "Base": "TCallable", 
+        "Definition": "Custom", 
+        "Builder": {"Generate": "None"}, 
+        "Children": [ 
+            {"Index": 0, "Name": "Output", "Type": "TDqOutput"} 
+        ] 
     },
     {
         "Name": "TDqCnHashShuffle",
-        "Base": "TDqConnection",
+        "Base": "TDqConnection", 
         "Match": {"Type": "Callable", "Name": "DqCnHashShuffle"},
-        "Children": [
-            {"Index": 1, "Name": "KeyColumns", "Type": "TCoAtomList"}
-        ]
+        "Children": [ 
+            {"Index": 1, "Name": "KeyColumns", "Type": "TCoAtomList"} 
+        ] 
     },
     {
-        "Name": "TDqCnBroadcast",
-        "Base": "TDqConnection",
-        "Match": {"Type": "Callable", "Name": "DqCnBroadcast"}
+        "Name": "TDqCnBroadcast", 
+        "Base": "TDqConnection", 
+        "Match": {"Type": "Callable", "Name": "DqCnBroadcast"} 
     },
     {
-        "Name": "TDqCnUnionAll",
-        "Base": "TDqConnection",
-        "Match": {"Type": "Callable", "Name": "DqCnUnionAll"}
+        "Name": "TDqCnUnionAll", 
+        "Base": "TDqConnection", 
+        "Match": {"Type": "Callable", "Name": "DqCnUnionAll"} 
     },
     {
-        "Name": "TDqCnMap",
-        "Base": "TDqConnection",
-        "Match": {"Type": "Callable", "Name": "DqCnMap"}
+        "Name": "TDqCnMap", 
+        "Base": "TDqConnection", 
+        "Match": {"Type": "Callable", "Name": "DqCnMap"} 
     },
     {
-        "Name": "TDqCnResult",
-        "Base": "TDqConnection",
+        "Name": "TDqCnResult", 
+        "Base": "TDqConnection", 
         "Match": {"Type": "Callable", "Name": "DqCnResult"},
         "Children": [
             {"Index": 1, "Name": "ColumnHints", "Type": "TCoAtomList"}
         ]
     },
     {
-        "Name": "TDqCnValue",
-        "Base": "TDqConnection",
-        "Match": {"Type": "Callable", "Name": "DqCnValue"}
-    },
-    {
+        "Name": "TDqCnValue", 
+        "Base": "TDqConnection", 
+        "Match": {"Type": "Callable", "Name": "DqCnValue"} 
+    }, 
+    { 
         "Name": "TDqSortColumn",
         "Base": "TExprBase",
         "Match": {"Type": "Tuple"},
@@ -228,4 +228,4 @@
         ]
     }
     ]
-}
+} 
diff --git a/ydb/library/yql/dq/expr_nodes/ya.make b/ydb/library/yql/dq/expr_nodes/ya.make
index 96cfd43f86..2ab8a1a541 100644
--- a/ydb/library/yql/dq/expr_nodes/ya.make
+++ b/ydb/library/yql/dq/expr_nodes/ya.make
@@ -33,4 +33,4 @@ RUN_PROGRAM(
     ${ARCADIA_ROOT}/util/generic/hash_set.h
 )
 
-END()
+END() 
diff --git a/ydb/library/yql/dq/opt/dq_opt.cpp b/ydb/library/yql/dq/opt/dq_opt.cpp
index f60f29dd46..8595870dbe 100644
--- a/ydb/library/yql/dq/opt/dq_opt.cpp
+++ b/ydb/library/yql/dq/opt/dq_opt.cpp
@@ -147,7 +147,7 @@ bool IsSingleConsumerConnection(const TDqConnection& node, const TParentsMap& pa
 ui32 GetStageOutputsCount(const TDqStageBase& stage, bool includingSinks) {
     auto stageType = stage.Ref().GetTypeAnn();
     YQL_ENSURE(stageType);
-    auto resultsTypeTuple = stageType->Cast<TTupleExprType>();
+    auto resultsTypeTuple = stageType->Cast<TTupleExprType>(); 
     ui32 result = resultsTypeTuple->GetSize();
     if (!includingSinks && stage.Sinks()) {
         result -= stage.Sinks().Cast().Size();
@@ -155,29 +155,29 @@ ui32 GetStageOutputsCount(const TDqStageBase& stage, bool includingSinks) {
     return result;
 }
 
-TVector<TDqConnection> FindDqConnections(const TExprBase& node) {
-    TVector<TDqConnection> connections;
-
-    VisitExpr(node.Ptr(), [&connections](const TExprNode::TPtr& exprNode) {
-        TExprBase node(exprNode);
-
+TVector<TDqConnection> FindDqConnections(const TExprBase& node) { 
+    TVector<TDqConnection> connections; 
+ 
+    VisitExpr(node.Ptr(), [&connections](const TExprNode::TPtr& exprNode) { 
+        TExprBase node(exprNode); 
+ 
         if (node.Maybe<TDqPhyPrecompute>()) {
             return false;
         }
 
-        if (auto maybeConnection = node.Maybe<TDqConnection>()) {
+        if (auto maybeConnection = node.Maybe<TDqConnection>()) { 
             YQL_ENSURE(!maybeConnection.Maybe<TDqCnValue>());
             connections.emplace_back(maybeConnection.Cast());
-            return false;
-        }
-
-        return true;
-    });
-
-    return connections;
-}
-
-bool IsDqPureExpr(const TExprBase& node, bool isPrecomputePure) {
+            return false; 
+        } 
+ 
+        return true; 
+    }); 
+ 
+    return connections; 
+} 
+ 
+bool IsDqPureExpr(const TExprBase& node, bool isPrecomputePure) { 
     auto filter = [](const TExprNode::TPtr& node) {
         return !TMaybeNode<TDqPhyPrecompute>(node).IsValid();
     };
@@ -187,25 +187,25 @@ bool IsDqPureExpr(const TExprBase& node, bool isPrecomputePure) {
                TMaybeNode<TDqConnection>(node).IsValid();
     };
 
-    if (isPrecomputePure) {
+    if (isPrecomputePure) { 
         return !FindNode(node.Ptr(), filter, predicate);
     }
 
     return !FindNode(node.Ptr(), predicate);
 }
 
-bool IsDqDependsOnStage(const TExprBase& node, const TDqStageBase& stage) {
+bool IsDqDependsOnStage(const TExprBase& node, const TDqStageBase& stage) { 
     return !!FindNode(node.Ptr(), [ptr = stage.Raw()](const TExprNode::TPtr& exprNode) {
         return exprNode.Get() == ptr;
-    });
-}
-
-bool CanPushDqExpr(const TExprBase& expr, const TDqStageBase& stage) {
-    return IsDqPureExpr(expr, true) && !IsDqDependsOnStage(expr, stage);
-}
-
-bool CanPushDqExpr(const TExprBase& expr, const TDqConnection& connection) {
-    return CanPushDqExpr(expr, connection.Output().Stage());
-}
-
+    }); 
+} 
+ 
+bool CanPushDqExpr(const TExprBase& expr, const TDqStageBase& stage) { 
+    return IsDqPureExpr(expr, true) && !IsDqDependsOnStage(expr, stage); 
+} 
+ 
+bool CanPushDqExpr(const TExprBase& expr, const TDqConnection& connection) { 
+    return CanPushDqExpr(expr, connection.Output().Stage()); 
+} 
+ 
 } // namespace NYql::NDq
diff --git a/ydb/library/yql/dq/opt/dq_opt.h b/ydb/library/yql/dq/opt/dq_opt.h
index 5b3146d0f4..9f8024d439 100644
--- a/ydb/library/yql/dq/opt/dq_opt.h
+++ b/ydb/library/yql/dq/opt/dq_opt.h
@@ -46,21 +46,21 @@ NNodes::TCoLambda BuildIdentityLambda(TPositionHandle pos, TExprContext& ctx);
 
 bool EnsureDqUnion(const NNodes::TExprBase& node, TExprContext& ctx);
 
-const TNodeSet& GetConsumers(const NNodes::TExprBase& node, const TParentsMap& parentsMap);
+const TNodeSet& GetConsumers(const NNodes::TExprBase& node, const TParentsMap& parentsMap); 
 const TNodeMultiSet& GetConsumers(const NNodes::TExprBase& node, const TParentsMultiMap& parentsMap);
 
-ui32 GetConsumersCount(const NNodes::TExprBase& node, const TParentsMap& parentsMap);
+ui32 GetConsumersCount(const NNodes::TExprBase& node, const TParentsMap& parentsMap); 
 bool IsSingleConsumer(const NNodes::TExprBase& node, const TParentsMap& parentsMap);
 
 bool IsSingleConsumerConnection(const NNodes::TDqConnection& node, const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
 
 ui32 GetStageOutputsCount(const NNodes::TDqStageBase& stage, bool includingSinks);
 
-TVector<NNodes::TDqConnection> FindDqConnections(const NNodes::TExprBase& node);
-bool IsDqPureExpr(const NNodes::TExprBase& node, bool isPrecomputePure = true);
-bool IsDqDependsOnStage(const NNodes::TExprBase& node, const NNodes::TDqStageBase& stage);
-
-bool CanPushDqExpr(const NNodes::TExprBase& expr, const NNodes::TDqStageBase& stage);
-bool CanPushDqExpr(const NNodes::TExprBase& expr, const NNodes::TDqConnection& connection);
+TVector<NNodes::TDqConnection> FindDqConnections(const NNodes::TExprBase& node); 
+bool IsDqPureExpr(const NNodes::TExprBase& node, bool isPrecomputePure = true); 
+bool IsDqDependsOnStage(const NNodes::TExprBase& node, const NNodes::TDqStageBase& stage); 
 
+bool CanPushDqExpr(const NNodes::TExprBase& expr, const NNodes::TDqStageBase& stage); 
+bool CanPushDqExpr(const NNodes::TExprBase& expr, const NNodes::TDqConnection& connection); 
+ 
 } // namespace NYql::NDq
diff --git a/ydb/library/yql/dq/opt/dq_opt_build.cpp b/ydb/library/yql/dq/opt/dq_opt_build.cpp
index e57b85a911..e670292aca 100644
--- a/ydb/library/yql/dq/opt/dq_opt_build.cpp
+++ b/ydb/library/yql/dq/opt/dq_opt_build.cpp
@@ -1,6 +1,6 @@
 #include "dq_opt_build.h"
 #include "dq_opt.h"
-#include "dq_opt_phy_finalizing.h"
+#include "dq_opt_phy_finalizing.h" 
 
 #include <ydb/library/yql/ast/yql_expr.h>
 #include <ydb/library/yql/core/yql_expr_optimize.h>
@@ -12,21 +12,21 @@ namespace NYql::NDq {
 
 using namespace NNodes;
 
-namespace {
-
-TExprBase RewriteProgramResultToStream(const TExprBase& result, TExprContext& ctx) {
-    if (result.Ref().GetTypeAnn()->GetKind() != ETypeAnnotationKind::Flow) {
-        return result;
+namespace { 
+ 
+TExprBase RewriteProgramResultToStream(const TExprBase& result, TExprContext& ctx) { 
+    if (result.Ref().GetTypeAnn()->GetKind() != ETypeAnnotationKind::Flow) { 
+        return result; 
     }
 
-    if (auto maybeToFlow = result.Maybe<TCoToFlow>()) {
+    if (auto maybeToFlow = result.Maybe<TCoToFlow>()) { 
         auto toFlow = maybeToFlow.Cast();
         if (toFlow.Input().Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Flow) {
-            return toFlow.Input();
+            return toFlow.Input(); 
         }
-
-        return Build<TCoToStream>(ctx, result.Pos())
-            .Input(toFlow.Input())
+ 
+        return Build<TCoToStream>(ctx, result.Pos()) 
+            .Input(toFlow.Input()) 
             .Done();
     }
 
@@ -73,220 +73,220 @@ TExprBase RewriteProgramResultToStream(const TExprBase& result, TExprContext& ct
         }
     }
 
-    return Build<TCoFromFlow>(ctx, result.Pos()) // TODO: TDqOutputReader?
-        .Input(result)
+    return Build<TCoFromFlow>(ctx, result.Pos()) // TODO: TDqOutputReader? 
+        .Input(result) 
         .Done();
 }
 
-void CollectArgsReplaces(const TDqStage& dqStage, TVector<TCoArgument>& newArgs, TNodeOnNodeOwnedMap& argsMap,
-    TExprContext& ctx)
-{
-    newArgs.reserve(dqStage.Program().Args().Size());
-
-    for (const auto& arg : dqStage.Program().Args()) {
-        auto newArg = TCoArgument(ctx.NewArgument(arg.Pos(), arg.Name()));
-        newArgs.emplace_back(newArg);
-        if (arg.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Flow) {
-            auto argReplace = Build<TCoToFlow>(ctx, arg.Pos()) // TODO: TDqInputReader
-                .Input(newArg)
-                .Done();
-            argsMap.emplace(arg.Raw(), argReplace.Ptr());
+void CollectArgsReplaces(const TDqStage& dqStage, TVector<TCoArgument>& newArgs, TNodeOnNodeOwnedMap& argsMap, 
+    TExprContext& ctx) 
+{ 
+    newArgs.reserve(dqStage.Program().Args().Size()); 
+
+    for (const auto& arg : dqStage.Program().Args()) { 
+        auto newArg = TCoArgument(ctx.NewArgument(arg.Pos(), arg.Name())); 
+        newArgs.emplace_back(newArg); 
+        if (arg.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Flow) { 
+            auto argReplace = Build<TCoToFlow>(ctx, arg.Pos()) // TODO: TDqInputReader 
+                .Input(newArg) 
+                .Done(); 
+            argsMap.emplace(arg.Raw(), argReplace.Ptr()); 
         } else {
-            argsMap.emplace(arg.Raw(), newArg.Ptr());
+            argsMap.emplace(arg.Raw(), newArg.Ptr()); 
         }
     }
-}
-
-struct TStageConsumersInfo {
-    ui32 ConsumersCount = 0;
-    std::vector<TMaybeNode<TDqOutput>> Consumers;
-    bool HasDependantConsumers = false;
-};
-
-void MakeConsumerReplaces(
-    const TDqStage& dqStage,
-    const std::vector<TDqOutput>& consumers,
-    TNodeOnNodeOwnedMap& replaces,
-    TExprContext& ctx)
-{
-    auto replicate = dqStage.Program().Body().Cast<TDqReplicate>();
-
-    TVector<TExprBase> stageResults;
-    for (const auto& output : consumers) {
-        auto index = FromString<ui32>(output.Index().Value());
-        stageResults.push_back(replicate.Args().Get(index + 1));
-    }
-
-    YQL_ENSURE(!stageResults.empty());
-    TMaybeNode<TExprBase> stageResult;
-    if (stageResults.size() == 1) {
-        stageResult = Build<TExprApplier>(ctx, dqStage.Pos())
-            .Apply(stageResults[0].Cast<TCoLambda>())
-            .With(0, replicate.Input())
-            .Done();
-    } else {
-        stageResult = Build<TDqReplicate>(ctx, dqStage.Pos())
-            .Input(replicate.Input())
-            .FreeArgs()
-                .Add(stageResults)
-                .Build()
-            .Done();
-    }
-
-    TVector<TCoArgument> newArgs;
-    newArgs.reserve(dqStage.Inputs().Size());
-    TNodeOnNodeOwnedMap argsMap;
-    CollectArgsReplaces(dqStage, newArgs, argsMap, ctx);
-
-    auto newStage = Build<TDqStage>(ctx, dqStage.Pos())
-        .Inputs(dqStage.Inputs())
-        .Program<TCoLambda>()
-            .Args(newArgs)
-            .Body(ctx.ReplaceNodes(stageResult.Cast().Ptr(), argsMap))
-            .Build()
-        .Settings(TDqStageSettings::New(dqStage).BuildNode(ctx, dqStage.Pos()))
-        .Sinks(dqStage.Sinks())
-        .Done();
-
-    for (ui32 i = 0; i < consumers.size(); ++i) {
-        auto newOutput = Build<TDqOutput>(ctx, dqStage.Pos())
-            .Stage(newStage)
-            .Index().Build(ToString(i))
-            .Done();
-
-        replaces.emplace(consumers[i].Raw(), newOutput.Ptr());
-    }
-}
-
-void MakeConsumerReplaces(
-    const TDqStage& dqStage,
-    const TStageConsumersInfo& info,
-    bool allowDependantConsumers,
-    TNodeOnNodeOwnedMap& replaces,
-    TExprContext& ctx)
-{
-    if (info.Consumers.size() <= 1) {
-        YQL_ENSURE(info.ConsumersCount == info.Consumers.size());
-        return;
+} 
+
+struct TStageConsumersInfo { 
+    ui32 ConsumersCount = 0; 
+    std::vector<TMaybeNode<TDqOutput>> Consumers; 
+    bool HasDependantConsumers = false; 
+}; 
+
+void MakeConsumerReplaces( 
+    const TDqStage& dqStage, 
+    const std::vector<TDqOutput>& consumers, 
+    TNodeOnNodeOwnedMap& replaces, 
+    TExprContext& ctx) 
+{ 
+    auto replicate = dqStage.Program().Body().Cast<TDqReplicate>(); 
+
+    TVector<TExprBase> stageResults; 
+    for (const auto& output : consumers) { 
+        auto index = FromString<ui32>(output.Index().Value()); 
+        stageResults.push_back(replicate.Args().Get(index + 1)); 
+    } 
+
+    YQL_ENSURE(!stageResults.empty()); 
+    TMaybeNode<TExprBase> stageResult; 
+    if (stageResults.size() == 1) { 
+        stageResult = Build<TExprApplier>(ctx, dqStage.Pos()) 
+            .Apply(stageResults[0].Cast<TCoLambda>()) 
+            .With(0, replicate.Input()) 
+            .Done(); 
+    } else { 
+        stageResult = Build<TDqReplicate>(ctx, dqStage.Pos()) 
+            .Input(replicate.Input()) 
+            .FreeArgs() 
+                .Add(stageResults) 
+                .Build() 
+            .Done(); 
+    } 
+
+    TVector<TCoArgument> newArgs; 
+    newArgs.reserve(dqStage.Inputs().Size()); 
+    TNodeOnNodeOwnedMap argsMap; 
+    CollectArgsReplaces(dqStage, newArgs, argsMap, ctx); 
+
+    auto newStage = Build<TDqStage>(ctx, dqStage.Pos()) 
+        .Inputs(dqStage.Inputs()) 
+        .Program<TCoLambda>() 
+            .Args(newArgs) 
+            .Body(ctx.ReplaceNodes(stageResult.Cast().Ptr(), argsMap)) 
+            .Build() 
+        .Settings(TDqStageSettings::New(dqStage).BuildNode(ctx, dqStage.Pos())) 
+        .Sinks(dqStage.Sinks()) 
+        .Done(); 
+
+    for (ui32 i = 0; i < consumers.size(); ++i) { 
+        auto newOutput = Build<TDqOutput>(ctx, dqStage.Pos()) 
+            .Stage(newStage) 
+            .Index().Build(ToString(i)) 
+            .Done(); 
+
+        replaces.emplace(consumers[i].Raw(), newOutput.Ptr()); 
+    } 
+} 
+
+void MakeConsumerReplaces( 
+    const TDqStage& dqStage, 
+    const TStageConsumersInfo& info, 
+    bool allowDependantConsumers, 
+    TNodeOnNodeOwnedMap& replaces, 
+    TExprContext& ctx) 
+{ 
+    if (info.Consumers.size() <= 1) { 
+        YQL_ENSURE(info.ConsumersCount == info.Consumers.size()); 
+        return; 
     }
-
-    if (info.HasDependantConsumers && !allowDependantConsumers) {
-        for (ui32 i = 0; i < info.Consumers.size(); ++i) {
-            if (info.Consumers[i]) {
-                MakeConsumerReplaces(dqStage, {info.Consumers[i].Cast()}, replaces, ctx);
-            }
+ 
+    if (info.HasDependantConsumers && !allowDependantConsumers) { 
+        for (ui32 i = 0; i < info.Consumers.size(); ++i) { 
+            if (info.Consumers[i]) { 
+                MakeConsumerReplaces(dqStage, {info.Consumers[i].Cast()}, replaces, ctx); 
+            } 
         }
 
-        return;
+        return; 
     }
 
-    if (info.ConsumersCount == info.Consumers.size()) {
-        return;
-    }
-
-    std::vector<TDqOutput> consumers;
-    for (ui32 i = 0; i < info.Consumers.size(); ++i) {
-        if (info.Consumers[i]) {
-            consumers.push_back(info.Consumers[i].Cast());
-        }
-    }
-    MakeConsumerReplaces(dqStage, consumers, replaces, ctx);
-}
-
-class TDqReplaceStageConsumersTransformer : public TSyncTransformerBase {
-public:
-    explicit TDqReplaceStageConsumersTransformer(bool allowDependantConsumers)
-        : AllowDependantConsumers(allowDependantConsumers) {}
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        YQL_CLOG(TRACE, CoreDq) << "[DQ/Build/TransformConsumers] " << NCommon::ExprToPrettyString(ctx, *input);
-        output = input;
-
-        // All physical query roots are considered independent, so we only
-        // clone stages with multiple consumers from single query result.
-        TVector<TExprBase> queryRoots;
-        TDeque<TExprBase> queryNodes;
-        queryNodes.emplace_back(input);
-        while (!queryNodes.empty()) {
-            auto head = queryNodes.front();
-            queryNodes.pop_front();
-
-            if (auto maybeList = head.Maybe<TExprList>()) {
-                for (const auto& item : maybeList.Cast()) {
-                    queryNodes.push_back(item);
-                }
+    if (info.ConsumersCount == info.Consumers.size()) { 
+        return; 
+    } 
+ 
+    std::vector<TDqOutput> consumers; 
+    for (ui32 i = 0; i < info.Consumers.size(); ++i) { 
+        if (info.Consumers[i]) { 
+            consumers.push_back(info.Consumers[i].Cast()); 
+        } 
+    } 
+    MakeConsumerReplaces(dqStage, consumers, replaces, ctx); 
+} 
+ 
+class TDqReplaceStageConsumersTransformer : public TSyncTransformerBase { 
+public: 
+    explicit TDqReplaceStageConsumersTransformer(bool allowDependantConsumers) 
+        : AllowDependantConsumers(allowDependantConsumers) {} 
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        YQL_CLOG(TRACE, CoreDq) << "[DQ/Build/TransformConsumers] " << NCommon::ExprToPrettyString(ctx, *input); 
+        output = input; 
+ 
+        // All physical query roots are considered independent, so we only 
+        // clone stages with multiple consumers from single query result. 
+        TVector<TExprBase> queryRoots; 
+        TDeque<TExprBase> queryNodes; 
+        queryNodes.emplace_back(input); 
+        while (!queryNodes.empty()) { 
+            auto head = queryNodes.front(); 
+            queryNodes.pop_front(); 
+ 
+            if (auto maybeList = head.Maybe<TExprList>()) { 
+                for (const auto& item : maybeList.Cast()) { 
+                    queryNodes.push_back(item); 
+                } 
             } else {
-                queryRoots.push_back(head);
+                queryRoots.push_back(head); 
             }
         }
-
-        auto filter = [](const TExprNode::TPtr& exprNode) {
-            return !exprNode->IsLambda();
-        };
-
-        TNodeMap<TStageConsumersInfo> consumersMap;
-        for (const auto& root : queryRoots) {
-            TNodeMap<ui32> stageUsages;
-
-            VisitExpr(root.Ptr(), filter, [&consumersMap, &stageUsages](const TExprNode::TPtr& node) {
-                if (auto maybeOutput = TMaybeNode<TDqOutput>(node)) {
-                    auto output = maybeOutput.Cast();
-                    auto index = FromString<ui32>(output.Index().Value());
-
-                    if (output.Stage().Maybe<TDqStage>()) {
-                        auto& info = consumersMap[output.Stage().Raw()];
-                        if (info.Consumers.empty()) {
-                            info.Consumers.resize(GetStageOutputsCount(output.Stage(), false));
-                        }
-
-                        YQL_ENSURE(index <= info.Consumers.size());
-
-                        if (info.Consumers[index]) {
-                            YQL_ENSURE(info.Consumers[index].Cast().Raw() == output.Raw());
-                        } else {
-                            info.Consumers[index] = output;
-                            info.ConsumersCount++;
-                        }
-
-                        stageUsages[output.Stage().Raw()]++;
-                    }
-                }
-
-                return true;
-            });
-
-            for (const auto& [stage, usages] : stageUsages) {
-                if (usages > 1) {
-                    consumersMap[stage].HasDependantConsumers = true;
-                }
-            }
-        }
-
-        TNodeOnNodeOwnedMap replaces;
-        for (const auto& [stage, info] : consumersMap) {
-            MakeConsumerReplaces(TDqStage(stage), info, AllowDependantConsumers, replaces, ctx);
-        }
-
-        if (replaces.empty()) {
-            return TStatus::Ok;
+ 
+        auto filter = [](const TExprNode::TPtr& exprNode) { 
+            return !exprNode->IsLambda(); 
+        }; 
+ 
+        TNodeMap<TStageConsumersInfo> consumersMap; 
+        for (const auto& root : queryRoots) { 
+            TNodeMap<ui32> stageUsages; 
+ 
+            VisitExpr(root.Ptr(), filter, [&consumersMap, &stageUsages](const TExprNode::TPtr& node) { 
+                if (auto maybeOutput = TMaybeNode<TDqOutput>(node)) { 
+                    auto output = maybeOutput.Cast(); 
+                    auto index = FromString<ui32>(output.Index().Value()); 
+ 
+                    if (output.Stage().Maybe<TDqStage>()) { 
+                        auto& info = consumersMap[output.Stage().Raw()]; 
+                        if (info.Consumers.empty()) { 
+                            info.Consumers.resize(GetStageOutputsCount(output.Stage(), false)); 
+                        } 
+ 
+                        YQL_ENSURE(index <= info.Consumers.size()); 
+ 
+                        if (info.Consumers[index]) { 
+                            YQL_ENSURE(info.Consumers[index].Cast().Raw() == output.Raw()); 
+                        } else { 
+                            info.Consumers[index] = output; 
+                            info.ConsumersCount++; 
+                        } 
+ 
+                        stageUsages[output.Stage().Raw()]++; 
+                    } 
+                } 
+ 
+                return true; 
+            }); 
+ 
+            for (const auto& [stage, usages] : stageUsages) { 
+                if (usages > 1) { 
+                    consumersMap[stage].HasDependantConsumers = true; 
+                } 
+            } 
         }
 
+        TNodeOnNodeOwnedMap replaces; 
+        for (const auto& [stage, info] : consumersMap) { 
+            MakeConsumerReplaces(TDqStage(stage), info, AllowDependantConsumers, replaces, ctx); 
+        } 
+ 
+        if (replaces.empty()) { 
+            return TStatus::Ok; 
+        } 
+ 
         TOptimizeExprSettings settings{nullptr};
         settings.VisitLambdas = false;
-        return RemapExpr(input, output, replaces, ctx, settings);
-    }
+        return RemapExpr(input, output, replaces, ctx, settings); 
+    } 
 
-private:
-    const bool AllowDependantConsumers;
-};
+private: 
+    const bool AllowDependantConsumers; 
+}; 
 
-class TDqBuildPhysicalStagesTransformer : public TSyncTransformerBase {
-public:
-    explicit TDqBuildPhysicalStagesTransformer() {}
+class TDqBuildPhysicalStagesTransformer : public TSyncTransformerBase { 
+public: 
+    explicit TDqBuildPhysicalStagesTransformer() {} 
 
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-        YQL_CLOG(TRACE, CoreDq) << "[DQ/Build/TransformPhysical] " << NCommon::ExprToPrettyString(ctx, *input);
-        output = input;
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+        YQL_CLOG(TRACE, CoreDq) << "[DQ/Build/TransformPhysical] " << NCommon::ExprToPrettyString(ctx, *input); 
+        output = input; 
 
         TNodeOnNodeOwnedMap replaces;
         VisitExpr(input, [&ctx, &replaces](const TExprNode::TPtr& node) {
@@ -322,54 +322,54 @@ public:
                     .Done();
 
                 replaces.emplace(stage.Raw(), newStage.Ptr());
-
-                YQL_CLOG(TRACE, CoreDq) << " [DQ/Build/TransformPhysical] replace stage #"
-                    << stage.Ref().UniqueId() << " -> #" << newStage.Ref().UniqueId();
+ 
+                YQL_CLOG(TRACE, CoreDq) << " [DQ/Build/TransformPhysical] replace stage #" 
+                    << stage.Ref().UniqueId() << " -> #" << newStage.Ref().UniqueId(); 
             }
 
             return true;
         });
 
-        if (replaces.empty()) {
-            return TStatus::Ok;
-        }
+        if (replaces.empty()) { 
+            return TStatus::Ok; 
+        } 
 
-        TOptimizeExprSettings settings{nullptr};
-        settings.VisitLambdas = false;
-        auto status = RemapExpr(input, output, replaces, ctx, settings);
+        TOptimizeExprSettings settings{nullptr}; 
+        settings.VisitLambdas = false; 
+        auto status = RemapExpr(input, output, replaces, ctx, settings); 
 #if 0
-        VisitExpr(output, [](const TExprNode::TPtr& node) {
-            YQL_ENSURE(!TDqStage::Match(node.Get()), "DqStage #" << node->UniqueId());
-            return true;
-        });
+        VisitExpr(output, [](const TExprNode::TPtr& node) { 
+            YQL_ENSURE(!TDqStage::Match(node.Get()), "DqStage #" << node->UniqueId()); 
+            return true; 
+        }); 
 #endif
-        return status;
+        return status; 
     }
-};
+}; 
 
-} // namespace
+} // namespace 
 
-TAutoPtr<IGraphTransformer> CreateDqBuildPhyStagesTransformer(bool allowDependantConsumers) {
-    TVector<TTransformStage> transformers;
+TAutoPtr<IGraphTransformer> CreateDqBuildPhyStagesTransformer(bool allowDependantConsumers) { 
+    TVector<TTransformStage> transformers; 
 
-    transformers.push_back(TTransformStage(CreateFunctorTransformer(
-        [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
-            return DqReplicateStageMultiOutput(input, output, ctx);
-        }),
-        "ReplicateStageMultiOutput",
-        TIssuesIds::DEFAULT_ERROR));
+    transformers.push_back(TTransformStage(CreateFunctorTransformer( 
+        [](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) { 
+            return DqReplicateStageMultiOutput(input, output, ctx); 
+        }), 
+        "ReplicateStageMultiOutput", 
+        TIssuesIds::DEFAULT_ERROR)); 
 
-    transformers.push_back(TTransformStage(
-        new TDqReplaceStageConsumersTransformer(allowDependantConsumers),
-        "ReplaceStageConsumers",
-        TIssuesIds::DEFAULT_ERROR));
+    transformers.push_back(TTransformStage( 
+        new TDqReplaceStageConsumersTransformer(allowDependantConsumers), 
+        "ReplaceStageConsumers", 
+        TIssuesIds::DEFAULT_ERROR)); 
 
-    transformers.push_back(TTransformStage(
-        new TDqBuildPhysicalStagesTransformer(),
-        "BuildPhysicalStages",
-        TIssuesIds::DEFAULT_ERROR));
+    transformers.push_back(TTransformStage( 
+        new TDqBuildPhysicalStagesTransformer(), 
+        "BuildPhysicalStages", 
+        TIssuesIds::DEFAULT_ERROR)); 
 
-    return CreateCompositeGraphTransformer(transformers, false);
+    return CreateCompositeGraphTransformer(transformers, false); 
 }
 
 } // namespace NYql::NDq
diff --git a/ydb/library/yql/dq/opt/dq_opt_build.h b/ydb/library/yql/dq/opt/dq_opt_build.h
index 456b1f0c81..b6fcd5ff49 100644
--- a/ydb/library/yql/dq/opt/dq_opt_build.h
+++ b/ydb/library/yql/dq/opt/dq_opt_build.h
@@ -5,6 +5,6 @@
 
 namespace NYql::NDq {
 
-TAutoPtr<IGraphTransformer> CreateDqBuildPhyStagesTransformer(bool allowDependantConsumers);
+TAutoPtr<IGraphTransformer> CreateDqBuildPhyStagesTransformer(bool allowDependantConsumers); 
 
 } // namespace NYql::NDq
diff --git a/ydb/library/yql/dq/opt/dq_opt_join.cpp b/ydb/library/yql/dq/opt/dq_opt_join.cpp
index 4097b49e24..c45107a42b 100644
--- a/ydb/library/yql/dq/opt/dq_opt_join.cpp
+++ b/ydb/library/yql/dq/opt/dq_opt_join.cpp
@@ -1,50 +1,50 @@
-#include "dq_opt_phy.h"
-
+#include "dq_opt_phy.h" 
+ 
 #include <ydb/library/yql/core/yql_join.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/dq/type_ann/dq_type_ann.h>
 #include <ydb/library/yql/utils/log/log.h>
 #include <ydb/library/yql/providers/common/provider/yql_provider.h>
-
-namespace NYql::NDq {
-
-using namespace NYql::NNodes;
-
-namespace {
-
-struct TJoinInputDesc {
-    TJoinInputDesc(TMaybe<TStringBuf> label, const TExprBase& input,
-        TSet<std::pair<TStringBuf, TStringBuf>>&& keys)
-        : Label(label)
-        , Input(input)
-        , Keys(std::move(keys)) {}
-
-    bool IsRealTable() const {
-        return Label.Defined();
-    }
-
-    TMaybe<TStringBuf> Label; // defined for real table input only, empty otherwise
-    TExprBase Input;
-    TSet<std::pair<TStringBuf, TStringBuf>> Keys; // set of (label, column_name) pairs in this input
-};
-
-void CollectJoinColumns(const TExprBase& joinSettings, THashMap<TStringBuf, TVector<TStringBuf>>* columnsToRename,
-    THashSet<TStringBuf>* columnsToDrop)
-{
-    for (const auto& option : joinSettings.Ref().Children()) {
+ 
+namespace NYql::NDq { 
+ 
+using namespace NYql::NNodes; 
+ 
+namespace { 
+ 
+struct TJoinInputDesc { 
+    TJoinInputDesc(TMaybe<TStringBuf> label, const TExprBase& input, 
+        TSet<std::pair<TStringBuf, TStringBuf>>&& keys) 
+        : Label(label) 
+        , Input(input) 
+        , Keys(std::move(keys)) {} 
+ 
+    bool IsRealTable() const { 
+        return Label.Defined(); 
+    } 
+ 
+    TMaybe<TStringBuf> Label; // defined for real table input only, empty otherwise 
+    TExprBase Input; 
+    TSet<std::pair<TStringBuf, TStringBuf>> Keys; // set of (label, column_name) pairs in this input 
+}; 
+ 
+void CollectJoinColumns(const TExprBase& joinSettings, THashMap<TStringBuf, TVector<TStringBuf>>* columnsToRename, 
+    THashSet<TStringBuf>* columnsToDrop) 
+{ 
+    for (const auto& option : joinSettings.Ref().Children()) { 
         if (option->Head().IsAtom("rename")) {
             TCoAtom fromName{option->Child(1)};
             YQL_ENSURE(!fromName.Value().Empty());
             TCoAtom toName{option->Child(2)};
             if (!toName.Value().Empty()) {
-                (*columnsToRename)[fromName.Value()].emplace_back(toName.Value());
+                (*columnsToRename)[fromName.Value()].emplace_back(toName.Value()); 
             } else {
                 columnsToDrop->emplace(fromName.Value());
             }
-        }
-    }
-}
-
+        } 
+    } 
+} 
+ 
 TExprBase BuildSkipNullKeys(TExprContext& ctx, TPositionHandle pos,
     const TExprBase& input, const TVector<TCoAtom>& keys)
 {
@@ -56,120 +56,120 @@ TExprBase BuildSkipNullKeys(TExprContext& ctx, TPositionHandle pos,
         .Done();
 };
 
-TMaybe<TJoinInputDesc> BuildDqJoin(const TCoEquiJoinTuple& joinTuple,
-    const THashMap<TStringBuf, TJoinInputDesc>& inputs, TExprContext& ctx)
-{
+TMaybe<TJoinInputDesc> BuildDqJoin(const TCoEquiJoinTuple& joinTuple, 
+    const THashMap<TStringBuf, TJoinInputDesc>& inputs, TExprContext& ctx) 
+{ 
     auto options = joinTuple.Options();
     auto linkSettings = GetEquiJoinLinkSettings(options.Ref());
     if (linkSettings.LeftHints.contains("any") || linkSettings.RightHints.contains("any")) {
         return {};
     }
 
-    TMaybe<TJoinInputDesc> left;
-    if (joinTuple.LeftScope().Maybe<TCoAtom>()) {
-        left = inputs.at(joinTuple.LeftScope().Cast<TCoAtom>().Value());
-        YQL_ENSURE(left, "unknown scope " << joinTuple.LeftScope().Cast<TCoAtom>().Value());
-    } else {
-        left = BuildDqJoin(joinTuple.LeftScope().Cast<TCoEquiJoinTuple>(), inputs, ctx);
-        if (!left) {
-            return {};
-        }
-    }
-
-    TMaybe<TJoinInputDesc> right;
-    if (joinTuple.RightScope().Maybe<TCoAtom>()) {
-        right = inputs.at(joinTuple.RightScope().Cast<TCoAtom>().Value());
-        YQL_ENSURE(right, "unknown scope " << joinTuple.RightScope().Cast<TCoAtom>().Value());
-    } else {
-        right = BuildDqJoin(joinTuple.RightScope().Cast<TCoEquiJoinTuple>(), inputs, ctx);
-        if (!right) {
-            return {};
-        }
-    }
-
+    TMaybe<TJoinInputDesc> left; 
+    if (joinTuple.LeftScope().Maybe<TCoAtom>()) { 
+        left = inputs.at(joinTuple.LeftScope().Cast<TCoAtom>().Value()); 
+        YQL_ENSURE(left, "unknown scope " << joinTuple.LeftScope().Cast<TCoAtom>().Value()); 
+    } else { 
+        left = BuildDqJoin(joinTuple.LeftScope().Cast<TCoEquiJoinTuple>(), inputs, ctx); 
+        if (!left) { 
+            return {}; 
+        } 
+    } 
+ 
+    TMaybe<TJoinInputDesc> right; 
+    if (joinTuple.RightScope().Maybe<TCoAtom>()) { 
+        right = inputs.at(joinTuple.RightScope().Cast<TCoAtom>().Value()); 
+        YQL_ENSURE(right, "unknown scope " << joinTuple.RightScope().Cast<TCoAtom>().Value()); 
+    } else { 
+        right = BuildDqJoin(joinTuple.RightScope().Cast<TCoEquiJoinTuple>(), inputs, ctx); 
+        if (!right) { 
+            return {}; 
+        } 
+    } 
+ 
     TStringBuf joinType = joinTuple.Type().Value();
     TSet<std::pair<TStringBuf, TStringBuf>> resultKeys;
     if (joinType != TStringBuf("RightOnly") && joinType != TStringBuf("RightSemi")) {
         resultKeys.insert(left->Keys.begin(), left->Keys.end());
     }
     if (joinType != TStringBuf("LeftOnly") && joinType != TStringBuf("LeftSemi")) {
-        resultKeys.insert(right->Keys.begin(), right->Keys.end());
-    }
-
-    auto leftTableLabel = left->IsRealTable()
-        ? BuildAtom(*left->Label, left->Input.Pos(), ctx).Ptr()
-        : Build<TCoVoid>(ctx, left->Input.Pos()).Done().Ptr();
-    auto rightTableLabel = right->IsRealTable()
-        ? BuildAtom(*right->Label, right->Input.Pos(), ctx).Ptr()
-        : Build<TCoVoid>(ctx, right->Input.Pos()).Done().Ptr();
-
-    size_t joinKeysCount = joinTuple.LeftKeys().Size() / 2;
-    TVector<TCoAtom> leftJoinKeys;
-    leftJoinKeys.reserve(joinKeysCount);
-    TVector<TCoAtom> rightJoinKeys;
-    rightJoinKeys.reserve(joinKeysCount);
-    auto joinKeysBuilder = Build<TDqJoinKeyTupleList>(ctx, left->Input.Pos());
-
-    for (size_t i = 0; i < joinKeysCount; ++i) {
-        size_t keyIndex = i * 2;
-
-        auto leftScopeAtom = joinTuple.LeftKeys().Item(keyIndex);
-        auto leftColumnAtom = joinTuple.LeftKeys().Item(keyIndex + 1);
-        auto rightScopeAtom = joinTuple.RightKeys().Item(keyIndex);
-        auto rightColumnAtom = joinTuple.RightKeys().Item(keyIndex + 1);
-
-        auto leftKey = Build<TCoAtom>(ctx, left->Input.Pos())
-            .Value(left->IsRealTable()
-                ? ToString(leftColumnAtom.Value())
-                : FullColumnName(leftScopeAtom.Value(), leftColumnAtom.Value()))
-            .Done();
-        auto rightKey = Build<TCoAtom>(ctx, right->Input.Pos())
-            .Value(right->IsRealTable()
-                ? ToString(rightColumnAtom.Value())
-                : FullColumnName(rightScopeAtom.Value(), rightColumnAtom.Value()))
-            .Done();
-
-        joinKeysBuilder.Add<TDqJoinKeyTuple>()
-            .LeftLabel(leftScopeAtom)
-            .LeftColumn(leftColumnAtom)
-            .RightLabel(rightScopeAtom)
-            .RightColumn(rightColumnAtom)
-            .Build();
-
-        leftJoinKeys.emplace_back(leftKey);
-        rightJoinKeys.emplace_back(rightKey);
-    }
-
-    auto dqJoin = Build<TDqJoin>(ctx, joinTuple.Pos())
-        .LeftInput(left->Input)
-        .LeftLabel(leftTableLabel)
-        .RightInput(right->Input)
-        .RightLabel(rightTableLabel)
-        .JoinType(joinTuple.Type())
-        .JoinKeys(joinKeysBuilder.Done())
-        .Done();
-
-    return TJoinInputDesc(Nothing(), dqJoin, std::move(resultKeys));
-}
-
-TMaybe<TJoinInputDesc> PrepareJoinInput(const TCoEquiJoinInput& input) {
-    if (!input.Scope().Maybe<TCoAtom>()) {
+        resultKeys.insert(right->Keys.begin(), right->Keys.end()); 
+    } 
+ 
+    auto leftTableLabel = left->IsRealTable() 
+        ? BuildAtom(*left->Label, left->Input.Pos(), ctx).Ptr() 
+        : Build<TCoVoid>(ctx, left->Input.Pos()).Done().Ptr(); 
+    auto rightTableLabel = right->IsRealTable() 
+        ? BuildAtom(*right->Label, right->Input.Pos(), ctx).Ptr() 
+        : Build<TCoVoid>(ctx, right->Input.Pos()).Done().Ptr(); 
+ 
+    size_t joinKeysCount = joinTuple.LeftKeys().Size() / 2; 
+    TVector<TCoAtom> leftJoinKeys; 
+    leftJoinKeys.reserve(joinKeysCount); 
+    TVector<TCoAtom> rightJoinKeys; 
+    rightJoinKeys.reserve(joinKeysCount); 
+    auto joinKeysBuilder = Build<TDqJoinKeyTupleList>(ctx, left->Input.Pos()); 
+ 
+    for (size_t i = 0; i < joinKeysCount; ++i) { 
+        size_t keyIndex = i * 2; 
+ 
+        auto leftScopeAtom = joinTuple.LeftKeys().Item(keyIndex); 
+        auto leftColumnAtom = joinTuple.LeftKeys().Item(keyIndex + 1); 
+        auto rightScopeAtom = joinTuple.RightKeys().Item(keyIndex); 
+        auto rightColumnAtom = joinTuple.RightKeys().Item(keyIndex + 1); 
+ 
+        auto leftKey = Build<TCoAtom>(ctx, left->Input.Pos()) 
+            .Value(left->IsRealTable() 
+                ? ToString(leftColumnAtom.Value()) 
+                : FullColumnName(leftScopeAtom.Value(), leftColumnAtom.Value())) 
+            .Done(); 
+        auto rightKey = Build<TCoAtom>(ctx, right->Input.Pos()) 
+            .Value(right->IsRealTable() 
+                ? ToString(rightColumnAtom.Value()) 
+                : FullColumnName(rightScopeAtom.Value(), rightColumnAtom.Value())) 
+            .Done(); 
+ 
+        joinKeysBuilder.Add<TDqJoinKeyTuple>() 
+            .LeftLabel(leftScopeAtom) 
+            .LeftColumn(leftColumnAtom) 
+            .RightLabel(rightScopeAtom) 
+            .RightColumn(rightColumnAtom) 
+            .Build(); 
+ 
+        leftJoinKeys.emplace_back(leftKey); 
+        rightJoinKeys.emplace_back(rightKey); 
+    } 
+ 
+    auto dqJoin = Build<TDqJoin>(ctx, joinTuple.Pos()) 
+        .LeftInput(left->Input) 
+        .LeftLabel(leftTableLabel) 
+        .RightInput(right->Input) 
+        .RightLabel(rightTableLabel) 
+        .JoinType(joinTuple.Type()) 
+        .JoinKeys(joinKeysBuilder.Done()) 
+        .Done(); 
+ 
+    return TJoinInputDesc(Nothing(), dqJoin, std::move(resultKeys)); 
+} 
+ 
+TMaybe<TJoinInputDesc> PrepareJoinInput(const TCoEquiJoinInput& input) { 
+    if (!input.Scope().Maybe<TCoAtom>()) { 
         YQL_CLOG(TRACE, CoreDq) << "EquiJoin input scope is not an Atom: " << input.Scope().Ref().Content();
-        return {};
-    }
-    auto scope = input.Scope().Cast<TCoAtom>().Value();
-
-    auto listType = input.List().Ref().GetTypeAnn()->Cast<TListExprType>();
-    auto resultStructType = listType->GetItemType()->Cast<TStructExprType>();
-
-    TSet<std::pair<TStringBuf, TStringBuf>> keys;
-    for (auto member : resultStructType->GetItems()) {
-        keys.emplace(scope, member->GetName());
-    }
-
-    return TJoinInputDesc(scope, input.List(), std::move(keys));
-}
-
+        return {}; 
+    } 
+    auto scope = input.Scope().Cast<TCoAtom>().Value(); 
+ 
+    auto listType = input.List().Ref().GetTypeAnn()->Cast<TListExprType>(); 
+    auto resultStructType = listType->GetItemType()->Cast<TStructExprType>(); 
+ 
+    TSet<std::pair<TStringBuf, TStringBuf>> keys; 
+    for (auto member : resultStructType->GetItems()) { 
+        keys.emplace(scope, member->GetName()); 
+    } 
+ 
+    return TJoinInputDesc(scope, input.List(), std::move(keys)); 
+} 
+ 
 TStringBuf RotateRightJoinType(TStringBuf joinType) {
     if (joinType == "Right") {
         return "Left";
@@ -184,33 +184,33 @@ TStringBuf RotateRightJoinType(TStringBuf joinType) {
 }
 
 std::pair<TVector<TCoAtom>, TVector<TCoAtom>> GetJoinKeys(const TDqJoin& join, TExprContext& ctx) {
-    TVector<TCoAtom> leftJoinKeys;
-    TVector<TCoAtom> rightJoinKeys;
+    TVector<TCoAtom> leftJoinKeys; 
+    TVector<TCoAtom> rightJoinKeys; 
 
     auto size = join.JoinKeys().Size();
     leftJoinKeys.reserve(size);
     rightJoinKeys.reserve(size);
 
-    for (const auto& keyTuple : join.JoinKeys()) {
-        auto leftLabel = keyTuple.LeftLabel().Value();
-        auto rightLabel = keyTuple.RightLabel().Value();
-
-        auto leftKey = Build<TCoAtom>(ctx, join.Pos())
-            .Value(join.LeftLabel().Maybe<TCoAtom>()
+    for (const auto& keyTuple : join.JoinKeys()) { 
+        auto leftLabel = keyTuple.LeftLabel().Value(); 
+        auto rightLabel = keyTuple.RightLabel().Value(); 
+ 
+        auto leftKey = Build<TCoAtom>(ctx, join.Pos()) 
+            .Value(join.LeftLabel().Maybe<TCoAtom>() 
                 ? keyTuple.LeftColumn().StringValue()
-                : FullColumnName(leftLabel, keyTuple.LeftColumn().Value()))
-            .Done();
-
-        auto rightKey = Build<TCoAtom>(ctx, join.Pos())
-            .Value(join.RightLabel().Maybe<TCoAtom>()
+                : FullColumnName(leftLabel, keyTuple.LeftColumn().Value())) 
+            .Done(); 
+ 
+        auto rightKey = Build<TCoAtom>(ctx, join.Pos()) 
+            .Value(join.RightLabel().Maybe<TCoAtom>() 
                 ? keyTuple.RightColumn().StringValue()
-                : FullColumnName(rightLabel, keyTuple.RightColumn().Value()))
-            .Done();
-
+                : FullColumnName(rightLabel, keyTuple.RightColumn().Value())) 
+            .Done(); 
+ 
         leftJoinKeys.emplace_back(std::move(leftKey));
         rightJoinKeys.emplace_back(std::move(rightKey));
-    }
-
+    } 
+ 
     return std::make_pair(std::move(leftJoinKeys), std::move(rightJoinKeys));
 }
 
@@ -224,39 +224,39 @@ TDqPhyMapJoin DqMakePhyMapJoin(const TDqJoin& join, const TExprBase& leftInput,
 
     auto [leftJoinKeys, rightJoinKeys] = GetJoinKeys(join, ctx);
 
-    TVector<TCoAtom> leftFilterKeys;
-    TVector<TCoAtom> rightFilterKeys;
-
+    TVector<TCoAtom> leftFilterKeys; 
+    TVector<TCoAtom> rightFilterKeys; 
+ 
     if (joinType == "Inner"sv || joinType == "LeftSemi"sv) {
         for (const auto& key : leftJoinKeys) {
-            leftFilterKeys.push_back(key);
-        }
-    }
-
+            leftFilterKeys.push_back(key); 
+        } 
+    } 
+ 
     for (const auto& key : rightJoinKeys) {
         rightFilterKeys.push_back(key);
-    }
-
+    } 
+ 
     auto leftFilteredInput = BuildSkipNullKeys(ctx, join.Pos(), leftInput, leftFilterKeys);
     auto rightFilteredInput = BuildSkipNullKeys(ctx, join.Pos(), rightInput, rightFilterKeys);
 
-    return Build<TDqPhyMapJoin>(ctx, join.Pos())
+    return Build<TDqPhyMapJoin>(ctx, join.Pos()) 
         .LeftInput(leftFilteredInput)
-        .LeftLabel(join.LeftLabel())
+        .LeftLabel(join.LeftLabel()) 
         .RightInput(rightFilteredInput)
-        .RightLabel(join.RightLabel())
-        .JoinType(join.JoinType())
-        .JoinKeys(join.JoinKeys())
-        .Done();
-}
-
-} // namespace
-
+        .RightLabel(join.RightLabel()) 
+        .JoinType(join.JoinType()) 
+        .JoinKeys(join.JoinKeys()) 
+        .Done(); 
+} 
+ 
+} // namespace 
+ 
 // used in yql_dq_recapture.cpp
 bool CheckJoinColumns(const TExprBase& node) {
     try {
         auto equiJoin = node.Cast<TCoEquiJoin>();
-        THashMap<TStringBuf, TVector<TStringBuf>> columnsToRename;
+        THashMap<TStringBuf, TVector<TStringBuf>> columnsToRename; 
         THashSet<TStringBuf> columnsToDrop;
         CollectJoinColumns(equiJoin.Arg(equiJoin.ArgCount() - 1), &columnsToRename, &columnsToDrop);
         return true;
@@ -296,88 +296,88 @@ bool CheckJoinLinkSettings(const TExprBase& node) {
     return CheckJoinTupleLinkSettings(joinTuple);
 }
 
-/**
- * Rewrite `EquiJoin` to a number of `DqJoin` callables. This is done to simplify next step of building
- * physical stages with join operators.
- * Potentially this optimizer can also perform joins reorder given cardinality information.
- */
-TExprBase DqRewriteEquiJoin(const TExprBase& node, TExprContext& ctx) {
-    if (!node.Maybe<TCoEquiJoin>()) {
-        return node;
-    }
-    auto equiJoin = node.Cast<TCoEquiJoin>();
-    YQL_ENSURE(equiJoin.ArgCount() >= 4);
-
-    THashMap<TStringBuf, TJoinInputDesc> inputs;
-    for (size_t i = 0; i < equiJoin.ArgCount() - 2; ++i) {
-        if (auto input = PrepareJoinInput(equiJoin.Arg(i).Cast<TCoEquiJoinInput>())) {
-            inputs.emplace(*input->Label, std::move(*input));
-        } else {
-            return node;
-        }
-    }
-
-    auto joinTuple = equiJoin.Arg(equiJoin.ArgCount() - 2).Cast<TCoEquiJoinTuple>();
-    auto result = BuildDqJoin(joinTuple, inputs, ctx);
-    if (!result) {
-        return node;
-    }
-
-    THashMap<TStringBuf, TVector<TStringBuf>> columnsToRename;
-    THashSet<TStringBuf> columnsToDrop;
+/** 
+ * Rewrite `EquiJoin` to a number of `DqJoin` callables. This is done to simplify next step of building 
+ * physical stages with join operators. 
+ * Potentially this optimizer can also perform joins reorder given cardinality information. 
+ */ 
+TExprBase DqRewriteEquiJoin(const TExprBase& node, TExprContext& ctx) { 
+    if (!node.Maybe<TCoEquiJoin>()) { 
+        return node; 
+    } 
+    auto equiJoin = node.Cast<TCoEquiJoin>(); 
+    YQL_ENSURE(equiJoin.ArgCount() >= 4); 
+ 
+    THashMap<TStringBuf, TJoinInputDesc> inputs; 
+    for (size_t i = 0; i < equiJoin.ArgCount() - 2; ++i) { 
+        if (auto input = PrepareJoinInput(equiJoin.Arg(i).Cast<TCoEquiJoinInput>())) { 
+            inputs.emplace(*input->Label, std::move(*input)); 
+        } else { 
+            return node; 
+        } 
+    } 
+ 
+    auto joinTuple = equiJoin.Arg(equiJoin.ArgCount() - 2).Cast<TCoEquiJoinTuple>(); 
+    auto result = BuildDqJoin(joinTuple, inputs, ctx); 
+    if (!result) { 
+        return node; 
+    } 
+ 
+    THashMap<TStringBuf, TVector<TStringBuf>> columnsToRename; 
+    THashSet<TStringBuf> columnsToDrop; 
     CollectJoinColumns(equiJoin.Arg(equiJoin.ArgCount() - 1), &columnsToRename, &columnsToDrop);
-
-    if (columnsToRename.empty() && columnsToDrop.empty()) {
-        return result->Input;
-    }
-
-    auto row = Build<TCoArgument>(ctx, node.Pos())
-            .Name("row")
-            .Done();
-
-    TVector<TExprBase> members;
-    for (auto key : result->Keys) {
-        auto fqColumnName = FullColumnName(key.first, key.second);
-        if (columnsToDrop.contains(fqColumnName)) {
-            continue;
-        }
-
-        auto member = Build<TCoMember>(ctx, node.Pos())
-            .Struct(row)
-            .Name().Build(fqColumnName)
-            .Done();
-
-        auto* renames = columnsToRename.FindPtr(fqColumnName);
-        if (renames) {
-            for (const auto& name : *renames) {
-                members.emplace_back(
-                    Build<TCoNameValueTuple>(ctx, node.Pos())
-                        .Name().Build(name)
-                        .Value(member)
-                        .Done());
-            }
-        } else {
-            members.emplace_back(
-                Build<TCoNameValueTuple>(ctx, node.Pos())
-                    .Name().Build(fqColumnName)
-                    .Value(member)
-                    .Done());
-        }
-    }
-
-    auto projection = Build<TCoMap>(ctx, node.Pos())
-        .Input(result->Input)
-        .Lambda()
-            .Args({row})
-            .Body<TCoAsStruct>()
-                .Add(members)
-                .Build()
-            .Build()
-        .Done();
-
-    return projection;
-}
-
+ 
+    if (columnsToRename.empty() && columnsToDrop.empty()) { 
+        return result->Input; 
+    } 
+ 
+    auto row = Build<TCoArgument>(ctx, node.Pos()) 
+            .Name("row") 
+            .Done(); 
+ 
+    TVector<TExprBase> members; 
+    for (auto key : result->Keys) { 
+        auto fqColumnName = FullColumnName(key.first, key.second); 
+        if (columnsToDrop.contains(fqColumnName)) { 
+            continue; 
+        } 
+ 
+        auto member = Build<TCoMember>(ctx, node.Pos()) 
+            .Struct(row) 
+            .Name().Build(fqColumnName) 
+            .Done(); 
+ 
+        auto* renames = columnsToRename.FindPtr(fqColumnName); 
+        if (renames) { 
+            for (const auto& name : *renames) { 
+                members.emplace_back( 
+                    Build<TCoNameValueTuple>(ctx, node.Pos()) 
+                        .Name().Build(name) 
+                        .Value(member) 
+                        .Done()); 
+            } 
+        } else { 
+            members.emplace_back( 
+                Build<TCoNameValueTuple>(ctx, node.Pos()) 
+                    .Name().Build(fqColumnName) 
+                    .Value(member) 
+                    .Done()); 
+        } 
+    } 
+ 
+    auto projection = Build<TCoMap>(ctx, node.Pos()) 
+        .Input(result->Input) 
+        .Lambda() 
+            .Args({row}) 
+            .Body<TCoAsStruct>() 
+                .Add(members) 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    return projection; 
+} 
+ 
 TExprBase DqRewriteRightJoinToLeft(const TExprBase node, TExprContext& ctx) {
     if (!node.Maybe<TDqJoin>()) {
         return node;
@@ -410,68 +410,68 @@ TExprBase DqRewriteRightJoinToLeft(const TExprBase node, TExprContext& ctx) {
         .Done();
 }
 
-TExprBase DqPushJoinToStage(const TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
+TExprBase DqPushJoinToStage(const TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx, 
     const TParentsMap& parentsMap, bool allowStageMultiUsage)
-{
-    if (!node.Maybe<TDqJoin>()) {
-        return node;
+{ 
+    if (!node.Maybe<TDqJoin>()) { 
+        return node; 
     }
 
-    auto join = node.Cast<TDqJoin>();
-
+    auto join = node.Cast<TDqJoin>(); 
+ 
     static const std::set<std::string_view> supportedTypes = {"Inner"sv, "Left"sv, "LeftOnly"sv, "LeftSemi"sv};
     auto joinType = join.JoinType().Value();
     if (!supportedTypes.contains(joinType)) {
         return node;
     }
 
-    TMaybeNode<TDqCnUnionAll> connection;
-    bool pushLeft = false;
-    if (join.LeftInput().Maybe<TDqCnUnionAll>() && IsDqPureExpr(join.RightInput())) {
-        connection = join.LeftInput().Cast<TDqCnUnionAll>();
-        pushLeft = true;
-    }
-    if (join.RightInput().Maybe<TDqCnUnionAll>() && IsDqPureExpr(join.LeftInput())) {
-        connection = join.RightInput().Cast<TDqCnUnionAll>();
+    TMaybeNode<TDqCnUnionAll> connection; 
+    bool pushLeft = false; 
+    if (join.LeftInput().Maybe<TDqCnUnionAll>() && IsDqPureExpr(join.RightInput())) { 
+        connection = join.LeftInput().Cast<TDqCnUnionAll>(); 
+        pushLeft = true; 
+    } 
+    if (join.RightInput().Maybe<TDqCnUnionAll>() && IsDqPureExpr(join.LeftInput())) { 
+        connection = join.RightInput().Cast<TDqCnUnionAll>(); 
         pushLeft = false;
-    }
+    } 
 
-    if (!connection) {
-        return node;
-    }
+    if (!connection) { 
+        return node; 
+    } 
 
     if (!IsSingleConsumerConnection(connection.Cast(), parentsMap, allowStageMultiUsage)) {
-        return node;
-    }
-
-    TCoArgument inputArg{ctx.NewArgument(join.Pos(), "_dq_join_input")};
-
-    auto makeFlow = [&ctx](const TExprBase& list) {
-        return Build<TCoToFlow>(ctx, list.Pos())
-            .Input(list)
+        return node; 
+    } 
+
+    TCoArgument inputArg{ctx.NewArgument(join.Pos(), "_dq_join_input")}; 
+ 
+    auto makeFlow = [&ctx](const TExprBase& list) { 
+        return Build<TCoToFlow>(ctx, list.Pos()) 
+            .Input(list) 
             .Done();
-    };
-
-    auto phyJoin = DqMakePhyMapJoin(
-        join,
-        pushLeft ? TExprBase(inputArg) : makeFlow(join.LeftInput()),
-        pushLeft ? makeFlow(join.RightInput()) : TExprBase(inputArg),
-        ctx);
-
-    auto lambda = Build<TCoLambda>(ctx, join.Pos())
-        .Args({inputArg})
-        .Body(phyJoin)
-        .Done();
-
+    }; 
+ 
+    auto phyJoin = DqMakePhyMapJoin( 
+        join, 
+        pushLeft ? TExprBase(inputArg) : makeFlow(join.LeftInput()), 
+        pushLeft ? makeFlow(join.RightInput()) : TExprBase(inputArg), 
+        ctx); 
+ 
+    auto lambda = Build<TCoLambda>(ctx, join.Pos()) 
+        .Args({inputArg}) 
+        .Body(phyJoin) 
+        .Done(); 
+ 
     auto result = DqPushLambdaToStageUnionAll(connection.Cast(), lambda, {}, ctx, optCtx);
     if (!result) {
         return node;
     }
 
-    YQL_ENSURE(result.Maybe<TDqCnUnionAll>());
-    return result.Cast();
-}
-
+    YQL_ENSURE(result.Maybe<TDqCnUnionAll>()); 
+    return result.Cast(); 
+} 
+ 
 TExprBase DqBuildPhyJoin(const TDqJoin& join, bool pushLeftStage, TExprContext& ctx, IOptimizationContext& optCtx) {
     static const std::set<std::string_view> supportedTypes = {
         "Inner"sv,
@@ -481,18 +481,18 @@ TExprBase DqBuildPhyJoin(const TDqJoin& join, bool pushLeftStage, TExprContext&
         "LeftSemi"sv
     };
 
-    auto joinType = join.JoinType().Value();
+    auto joinType = join.JoinType().Value(); 
 
     if (!supportedTypes.contains(joinType)) {
-        return join;
-    }
-
-    YQL_ENSURE(join.LeftInput().Maybe<TDqCnUnionAll>());
+        return join; 
+    } 
+ 
+    YQL_ENSURE(join.LeftInput().Maybe<TDqCnUnionAll>()); 
     TDqCnUnionAll leftCn = join.LeftInput().Cast<TDqCnUnionAll>();
-
+ 
     TMaybeNode<TDqCnUnionAll> rightCn = join.RightInput().Maybe<TDqCnUnionAll>();
     YQL_ENSURE(rightCn || IsDqPureExpr(join.RightInput(), /* isPrecomputePure */ true));
-
+ 
     TMaybeNode<TDqCnBroadcast> rightBroadcast;
     TNodeOnNodeOwnedMap rightPrecomputes;
 
@@ -573,10 +573,10 @@ TExprBase DqBuildPhyJoin(const TDqJoin& join, bool pushLeftStage, TExprContext&
         }
     }
 
-    TCoArgument leftInputArg{ctx.NewArgument(join.Pos(), "_dq_join_left")};
-    TCoArgument rightInputArg{ctx.NewArgument(join.Pos(), "_dq_join_right")};
+    TCoArgument leftInputArg{ctx.NewArgument(join.Pos(), "_dq_join_left")}; 
+    TCoArgument rightInputArg{ctx.NewArgument(join.Pos(), "_dq_join_right")}; 
 
-    bool buildNewStage = !pushLeftStage;
+    bool buildNewStage = !pushLeftStage; 
     if (!rightCn) {
         // right input is DqPure expression, try to push down the join...
         if (rightPrecomputes.empty()) {
@@ -603,67 +603,67 @@ TExprBase DqBuildPhyJoin(const TDqJoin& join, bool pushLeftStage, TExprContext&
                 .Input(join.RightInput())
                 .Done());
 
-    TMaybeNode<TExprBase> phyJoin;
+    TMaybeNode<TExprBase> phyJoin; 
     if (join.JoinType().Value() != "Cross"sv) {
         phyJoin = DqMakePhyMapJoin(join, leftInputArg, joinRightInput, ctx);
-    } else {
-        YQL_ENSURE(join.JoinKeys().Empty());
-
-        phyJoin = Build<TDqPhyCrossJoin>(ctx, join.Pos())
-            .LeftInput(leftInputArg)
-            .LeftLabel(join.LeftLabel())
+    } else { 
+        YQL_ENSURE(join.JoinKeys().Empty()); 
+ 
+        phyJoin = Build<TDqPhyCrossJoin>(ctx, join.Pos()) 
+            .LeftInput(leftInputArg) 
+            .LeftLabel(join.LeftLabel()) 
             .RightInput(joinRightInput)
-            .RightLabel(join.RightLabel())
-            .JoinType(join.JoinType())
-            .JoinKeys(join.JoinKeys())
+            .RightLabel(join.RightLabel()) 
+            .JoinType(join.JoinType()) 
+            .JoinKeys(join.JoinKeys()) 
             .Done();
-    }
-
-    TMaybeNode<TDqCnUnionAll> newConnection;
-    if (buildNewStage) {
-        auto newJoinStage = Build<TDqStage>(ctx, join.Pos())
-            .Inputs()
-                .Add<TDqCnMap>()
+    } 
+ 
+    TMaybeNode<TDqCnUnionAll> newConnection; 
+    if (buildNewStage) { 
+        auto newJoinStage = Build<TDqStage>(ctx, join.Pos()) 
+            .Inputs() 
+                .Add<TDqCnMap>() 
                     .Output(leftCn.Output())
-                    .Build()
+                    .Build() 
                 .Add(rightBroadcast.Cast())
-                .Build()
-            .Program()
-                .Args({leftInputArg, rightInputArg})
-                .Body(phyJoin.Cast())
-                .Build()
+                .Build() 
+            .Program() 
+                .Args({leftInputArg, rightInputArg}) 
+                .Body(phyJoin.Cast()) 
+                .Build() 
             .Settings(TDqStageSettings().BuildNode(ctx, join.Pos()))
-            .Done();
-
-        newConnection = Build<TDqCnUnionAll>(ctx, join.Pos())
-            .Output()
-                .Stage(newJoinStage)
-                .Index().Build("0")
-                .Build()
-            .Done();
-    } else {
-        auto lambda = Build<TCoLambda>(ctx, join.Pos())
-            .Args({leftInputArg})
-            .Body(phyJoin.Cast())
-            .Done();
-
+            .Done(); 
+ 
+        newConnection = Build<TDqCnUnionAll>(ctx, join.Pos()) 
+            .Output() 
+                .Stage(newJoinStage) 
+                .Index().Build("0") 
+                .Build() 
+            .Done(); 
+    } else { 
+        auto lambda = Build<TCoLambda>(ctx, join.Pos()) 
+            .Args({leftInputArg}) 
+            .Body(phyJoin.Cast()) 
+            .Done(); 
+ 
         TVector<TDqConnection> lambdaConnections;
         if (rightBroadcast) {
             lambdaConnections.emplace_back(rightBroadcast.Cast());
         }
 
         auto maybeCn = DqPushLambdaToStageUnionAll(leftCn, lambda, lambdaConnections, ctx, optCtx);
-        YQL_ENSURE(maybeCn);
-
-        auto newCn = maybeCn.Cast();
-        YQL_ENSURE(newCn.Maybe<TDqCnUnionAll>());
-
-        newConnection = newCn.Cast<TDqCnUnionAll>();
-    }
-
-    return newConnection.Cast();
-}
-
+        YQL_ENSURE(maybeCn); 
+ 
+        auto newCn = maybeCn.Cast(); 
+        YQL_ENSURE(newCn.Maybe<TDqCnUnionAll>()); 
+ 
+        newConnection = newCn.Cast<TDqCnUnionAll>(); 
+    } 
+ 
+    return newConnection.Cast(); 
+} 
+ 
 TExprBase DqBuildJoinDict(const TDqJoin& join, TExprContext& ctx) {
     auto joinType = join.JoinType().Value();
 
@@ -814,4 +814,4 @@ TExprBase DqBuildJoinDict(const TDqJoin& join, TExprContext& ctx) {
     return join;
 }
 
-} // namespace NYql::NDq
+} // namespace NYql::NDq 
diff --git a/ydb/library/yql/dq/opt/dq_opt_log.cpp b/ydb/library/yql/dq/opt/dq_opt_log.cpp
index fed0f09f0f..79c94cd19d 100644
--- a/ydb/library/yql/dq/opt/dq_opt_log.cpp
+++ b/ydb/library/yql/dq/opt/dq_opt_log.cpp
@@ -44,7 +44,7 @@ TExprBase DqRewriteTakeSortToTopSort(TExprBase node, TExprContext& ctx, const TP
         return node;
     }
 
-    if (!IsDqPureExpr(take.Count())) {
+    if (!IsDqPureExpr(take.Count())) { 
         return node;
     }
 
diff --git a/ydb/library/yql/dq/opt/dq_opt_log.h b/ydb/library/yql/dq/opt/dq_opt_log.h
index 8e9ed97b06..78f68f245b 100644
--- a/ydb/library/yql/dq/opt/dq_opt_log.h
+++ b/ydb/library/yql/dq/opt/dq_opt_log.h
@@ -16,8 +16,8 @@ NNodes::TExprBase DqRewriteAggregate(NNodes::TExprBase node, TExprContext& ctx);
 
 NNodes::TExprBase DqRewriteTakeSortToTopSort(NNodes::TExprBase node, TExprContext& ctx, const TParentsMap& parents);
 
-NNodes::TExprBase DqRewriteEquiJoin(const NNodes::TExprBase& node, TExprContext& ctx);
-
+NNodes::TExprBase DqRewriteEquiJoin(const NNodes::TExprBase& node, TExprContext& ctx); 
+ 
 NNodes::TExprBase DqEnforceCompactPartition(NNodes::TExprBase node, NNodes::TExprList frames, TExprContext& ctx);
 
 NNodes::TExprBase DqExpandWindowFunctions(NNodes::TExprBase node, TExprContext& ctx, bool enforceCompact);
diff --git a/ydb/library/yql/dq/opt/dq_opt_peephole.cpp b/ydb/library/yql/dq/opt/dq_opt_peephole.cpp
index 87ac170eea..aa2977b20a 100644
--- a/ydb/library/yql/dq/opt/dq_opt_peephole.cpp
+++ b/ydb/library/yql/dq/opt/dq_opt_peephole.cpp
@@ -1,17 +1,17 @@
-#include "dq_opt_peephole.h"
-
+#include "dq_opt_peephole.h" 
+ 
 #include <ydb/library/yql/core/yql_join.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/core/yql_expr_type_annotation.h>
-
+ 
 #include <ydb/library/yql/utils/log/log.h>
 
 #include <util/generic/size_literals.h>
 
-namespace NYql::NDq {
-
-using namespace NYql::NNodes;
-
+namespace NYql::NDq { 
+ 
+using namespace NYql::NNodes; 
+ 
 namespace {
 
 inline std::string_view GetTableLabel(const TExprBase& node) {
@@ -122,37 +122,37 @@ TExprNode::TPtr BuildDictKeySelector(TExprContext& ctx, TPositionHandle pos, con
 
 } // anonymous namespace end
 
-/**
- * Rewrites a `KqpMapJoin` to the `MapJoinCore`.
- *
- * Restrictions:
- *  - Don't select join strategy, always use `MapJoin`
- *  - Explicitly convert right input to the dict
+/** 
+ * Rewrites a `KqpMapJoin` to the `MapJoinCore`. 
+ * 
+ * Restrictions: 
+ *  - Don't select join strategy, always use `MapJoin` 
+ *  - Explicitly convert right input to the dict 
  *  - Use quite pretty trick: do `MapJoinCore` in `FlatMap`-lambda
  *    (rely on the fact that there will be only one element in the `FlatMap`-stream)
- */
-TExprBase DqPeepholeRewriteMapJoin(const TExprBase& node, TExprContext& ctx) {
-    if (!node.Maybe<TDqPhyMapJoin>()) {
-        return node;
-    }
+ */ 
+TExprBase DqPeepholeRewriteMapJoin(const TExprBase& node, TExprContext& ctx) { 
+    if (!node.Maybe<TDqPhyMapJoin>()) { 
+        return node; 
+    } 
     const auto mapJoin = node.Cast<TDqPhyMapJoin>();
     const auto pos = mapJoin.Pos();
-
+ 
     const auto leftTableLabel = GetTableLabel(mapJoin.LeftLabel());
     const auto rightTableLabel = GetTableLabel(mapJoin.RightLabel());
-
+ 
     auto [leftKeyColumnNodes, rightKeyColumnNodes] = JoinKeysToAtoms(ctx, mapJoin, leftTableLabel, rightTableLabel);
     const auto keyWidth = leftKeyColumnNodes.size();
-
+ 
     const auto makeRenames = [&ctx, pos](TStringBuf label, const TStructExprType& type) {
-        TExprNode::TListType renames;
+        TExprNode::TListType renames; 
         for (const auto& member : type.GetItems()) {
             renames.emplace_back(ctx.NewAtom(pos, member->GetName()));
             renames.emplace_back(ctx.NewAtom(pos, GetColumnName(label, member)));
-        }
-        return renames;
-    };
-
+        } 
+        return renames; 
+    }; 
+ 
     const auto itemTypeLeft = GetSeqItemType(mapJoin.LeftInput().Ref().GetTypeAnn())->Cast<TStructExprType>();
     const auto itemTypeRight = GetSeqItemType(mapJoin.RightInput().Ref().GetTypeAnn())->Cast<TStructExprType>();
 
@@ -164,8 +164,8 @@ TExprBase DqPeepholeRewriteMapJoin(const TExprBase& node, TExprContext& ctx) {
         rightPayloads.reserve(rightRenames.size() >> 1U);
         for (auto it = rightRenames.cbegin(); rightRenames.cend() != it; ++++it)
             rightPayloads.emplace_back(*it);
-    }
-
+    } 
+ 
     TTypeAnnotationNode::TListType keyTypes(keyWidth);
     for (auto i = 0U; i < keyTypes.size(); ++i) {
         const auto keyTypeLeft = itemTypeLeft->FindItemType(leftKeyColumnNodes[i]->Content());
@@ -178,7 +178,7 @@ TExprBase DqPeepholeRewriteMapJoin(const TExprBase& node, TExprContext& ctx) {
 
     auto leftInput = ctx.NewCallable(mapJoin.LeftInput().Pos(), "ToFlow", {mapJoin.LeftInput().Ptr()});
     auto rightInput = ctx.NewCallable(mapJoin.RightInput().Pos(), "ToFlow", {mapJoin.RightInput().Ptr()});
-
+ 
     if (keyTypes.empty()) {
         const auto type = mapJoin.Ref().GetTypeAnn();
         if (mapJoin.JoinType().Value() == "Inner" || mapJoin.JoinType().Value() == "LeftSemi")
@@ -234,91 +234,91 @@ TExprBase DqPeepholeRewriteMapJoin(const TExprBase& node, TExprContext& ctx) {
                 .LeftRenames(ctx.NewList(pos, std::move(leftRenames)))
                 .RightRenames(ctx.NewList(pos, std::move(rightRenames)))
                 .Build()
-            .Build()
-        .Done();
-}
-
-TExprBase DqPeepholeRewriteCrossJoin(const TExprBase& node, TExprContext& ctx) {
-    if (!node.Maybe<TDqPhyCrossJoin>()) {
-        return node;
-    }
-    auto crossJoin = node.Cast<TDqPhyCrossJoin>();
-
+            .Build() 
+        .Done(); 
+} 
+ 
+TExprBase DqPeepholeRewriteCrossJoin(const TExprBase& node, TExprContext& ctx) { 
+    if (!node.Maybe<TDqPhyCrossJoin>()) { 
+        return node; 
+    } 
+    auto crossJoin = node.Cast<TDqPhyCrossJoin>(); 
+ 
     auto leftTableLabel = GetTableLabel(crossJoin.LeftLabel());
     auto rightTableLabel = GetTableLabel(crossJoin.RightLabel());
-
-    TCoArgument leftArg{ctx.NewArgument(crossJoin.Pos(), "_kqp_left")};
-    TCoArgument rightArg{ctx.NewArgument(crossJoin.Pos(), "_kqp_right")};
-
-    TExprNodeList keys;
-    auto collectKeys = [&ctx, &keys](const TExprBase& input, TStringBuf label, const TCoArgument& arg) {
-        for (auto key : GetSeqItemType(input.Ref().GetTypeAnn())->Cast<TStructExprType>()->GetItems()) {
+ 
+    TCoArgument leftArg{ctx.NewArgument(crossJoin.Pos(), "_kqp_left")}; 
+    TCoArgument rightArg{ctx.NewArgument(crossJoin.Pos(), "_kqp_right")}; 
+ 
+    TExprNodeList keys; 
+    auto collectKeys = [&ctx, &keys](const TExprBase& input, TStringBuf label, const TCoArgument& arg) { 
+        for (auto key : GetSeqItemType(input.Ref().GetTypeAnn())->Cast<TStructExprType>()->GetItems()) { 
             auto fqColumnName = GetColumnName(label, key);
-            keys.emplace_back(
-                Build<TCoNameValueTuple>(ctx, input.Pos())
-                    .Name().Build(fqColumnName)
-                    .Value<TCoMember>()
-                        .Struct(arg)
-                        .Name().Build(ToString(key->GetName()))
-                        .Build()
-                    .Done().Ptr());
-        }
-    };
-    collectKeys(crossJoin.LeftInput(), leftTableLabel, leftArg);
-    collectKeys(crossJoin.RightInput(), rightTableLabel, rightArg);
-
-    // we have to `Condense` right input as single-element stream of lists (single list of all elements from the right),
-    // because stream supports single iteration only
-    auto itemArg = Build<TCoArgument>(ctx, crossJoin.Pos()).Name("item").Done();
-    auto rightAsStreamOfLists = Build<TCoCondense1>(ctx, crossJoin.Pos())
+            keys.emplace_back( 
+                Build<TCoNameValueTuple>(ctx, input.Pos()) 
+                    .Name().Build(fqColumnName) 
+                    .Value<TCoMember>() 
+                        .Struct(arg) 
+                        .Name().Build(ToString(key->GetName())) 
+                        .Build() 
+                    .Done().Ptr()); 
+        } 
+    }; 
+    collectKeys(crossJoin.LeftInput(), leftTableLabel, leftArg); 
+    collectKeys(crossJoin.RightInput(), rightTableLabel, rightArg); 
+ 
+    // we have to `Condense` right input as single-element stream of lists (single list of all elements from the right), 
+    // because stream supports single iteration only 
+    auto itemArg = Build<TCoArgument>(ctx, crossJoin.Pos()).Name("item").Done(); 
+    auto rightAsStreamOfLists = Build<TCoCondense1>(ctx, crossJoin.Pos()) 
         .Input<TCoToFlow>()
             .Input(crossJoin.RightInput())
             .Build()
-        .InitHandler()
-            .Args({itemArg})
-            .Body<TCoAsList>()
-                .Add(itemArg)
-                .Build()
-            .Build()
-        .SwitchHandler()
-            .Args({"item", "state"})
-            .Body<TCoBool>()
-                .Literal().Build("false")
-                .Build()
-            .Build()
-        .UpdateHandler()
-            .Args({"item", "state"})
-            .Body<TCoAppend>()
-                .List("state")
-                .Item("item")
-                .Build()
-            .Build()
-        .Done();
-
-    return Build<TCoFlatMap>(ctx, crossJoin.Pos())
-        .Input(rightAsStreamOfLists)
-        .Lambda()
-            .Args({"rightAsList"})
-            .Body<TCoFlatMap>()
-                .Input(crossJoin.LeftInput())
-                .Lambda()
-                    .Args({leftArg})
-                    .Body<TCoMap>()
-                        // here we have `List`, so we can iterate over it many times (for every `leftArg`)
-                        .Input("rightAsList")
-                        .Lambda()
-                            .Args({rightArg})
-                            .Body<TCoAsStruct>()
-                                .Add(keys)
-                                .Build()
-                            .Build()
-                        .Build()
-                    .Build()
-                .Build()
-            .Build()
-        .Done();
-}
-
+        .InitHandler() 
+            .Args({itemArg}) 
+            .Body<TCoAsList>() 
+                .Add(itemArg) 
+                .Build() 
+            .Build() 
+        .SwitchHandler() 
+            .Args({"item", "state"}) 
+            .Body<TCoBool>() 
+                .Literal().Build("false") 
+                .Build() 
+            .Build() 
+        .UpdateHandler() 
+            .Args({"item", "state"}) 
+            .Body<TCoAppend>() 
+                .List("state") 
+                .Item("item") 
+                .Build() 
+            .Build() 
+        .Done(); 
+ 
+    return Build<TCoFlatMap>(ctx, crossJoin.Pos()) 
+        .Input(rightAsStreamOfLists) 
+        .Lambda() 
+            .Args({"rightAsList"}) 
+            .Body<TCoFlatMap>() 
+                .Input(crossJoin.LeftInput()) 
+                .Lambda() 
+                    .Args({leftArg}) 
+                    .Body<TCoMap>() 
+                        // here we have `List`, so we can iterate over it many times (for every `leftArg`) 
+                        .Input("rightAsList") 
+                        .Lambda() 
+                            .Args({rightArg}) 
+                            .Body<TCoAsStruct>() 
+                                .Add(keys) 
+                                .Build() 
+                            .Build() 
+                        .Build() 
+                    .Build() 
+                .Build() 
+            .Build() 
+        .Done(); 
+} 
+ 
 namespace {
 
 TExprNode::TPtr UnpackJoinedData(const TStructExprType* leftRowType, const TStructExprType* rightRowType,
@@ -475,46 +475,46 @@ NNodes::TExprBase DqPeepholeRewriteJoinDict(const NNodes::TExprBase& node, TExpr
         .Done();
 }
 
-NNodes::TExprBase DqPeepholeRewritePureJoin(const NNodes::TExprBase& node, TExprContext& ctx) {
-    if (!node.Maybe<TDqJoin>()) {
-        return node;
-    }
-
-    auto join = node.Cast<TDqJoin>();
-
-    if (join.JoinType().Value() == "Cross") {
-        return Build<TCoCollect>(ctx, join.Pos())
-            .Input<TDqPhyCrossJoin>()
-                .LeftInput<TCoIterator>()
-                    .List(join.LeftInput())
-                    .Build()
-                .LeftLabel(join.LeftLabel())
-                .RightInput<TCoIterator>()
-                    .List(join.RightInput())
-                    .Build()
-                .RightLabel(join.RightLabel())
-                .JoinType(join.JoinType())
-                .JoinKeys(join.JoinKeys())
-                .Build()
-            .Done();
-    } else {
-        return Build<TCoCollect>(ctx, join.Pos())
-            .Input<TDqPhyJoinDict>()
-                .LeftInput<TCoIterator>()
-                    .List(join.LeftInput())
-                    .Build()
-                .LeftLabel(join.LeftLabel())
-                .RightInput<TCoIterator>()
-                    .List(join.RightInput())
-                    .Build()
-                .RightLabel(join.RightLabel())
-                .JoinType(join.JoinType())
-                .JoinKeys(join.JoinKeys())
-                .Build()
-            .Done();
-    }
-}
-
+NNodes::TExprBase DqPeepholeRewritePureJoin(const NNodes::TExprBase& node, TExprContext& ctx) { 
+    if (!node.Maybe<TDqJoin>()) { 
+        return node; 
+    } 
+ 
+    auto join = node.Cast<TDqJoin>(); 
+ 
+    if (join.JoinType().Value() == "Cross") { 
+        return Build<TCoCollect>(ctx, join.Pos()) 
+            .Input<TDqPhyCrossJoin>() 
+                .LeftInput<TCoIterator>() 
+                    .List(join.LeftInput()) 
+                    .Build() 
+                .LeftLabel(join.LeftLabel()) 
+                .RightInput<TCoIterator>() 
+                    .List(join.RightInput()) 
+                    .Build() 
+                .RightLabel(join.RightLabel()) 
+                .JoinType(join.JoinType()) 
+                .JoinKeys(join.JoinKeys()) 
+                .Build() 
+            .Done(); 
+    } else { 
+        return Build<TCoCollect>(ctx, join.Pos()) 
+            .Input<TDqPhyJoinDict>() 
+                .LeftInput<TCoIterator>() 
+                    .List(join.LeftInput()) 
+                    .Build() 
+                .LeftLabel(join.LeftLabel()) 
+                .RightInput<TCoIterator>() 
+                    .List(join.RightInput()) 
+                    .Build() 
+                .RightLabel(join.RightLabel()) 
+                .JoinType(join.JoinType()) 
+                .JoinKeys(join.JoinKeys()) 
+                .Build() 
+            .Done(); 
+    } 
+} 
+ 
 NNodes::TExprBase DqPeepholeRewriteReplicate(const NNodes::TExprBase& node, TExprContext& ctx) {
     if (!node.Maybe<TDqReplicate>()) {
         return node;
@@ -541,4 +541,4 @@ NNodes::TExprBase DqPeepholeRewriteReplicate(const NNodes::TExprBase& node, TExp
         .Done();
 }
 
-} // namespace NYql::NDq
+} // namespace NYql::NDq 
diff --git a/ydb/library/yql/dq/opt/dq_opt_peephole.h b/ydb/library/yql/dq/opt/dq_opt_peephole.h
index 565ee4296d..4e27bb79a6 100644
--- a/ydb/library/yql/dq/opt/dq_opt_peephole.h
+++ b/ydb/library/yql/dq/opt/dq_opt_peephole.h
@@ -1,16 +1,16 @@
-#pragma once
-
-#include "dq_opt.h"
-
+#pragma once 
+ 
+#include "dq_opt.h" 
+ 
 #include <ydb/library/yql/dq/common/dq_common.h>
 #include <ydb/library/yql/dq/expr_nodes/dq_expr_nodes.h>
-
-namespace NYql::NDq {
-
+ 
+namespace NYql::NDq { 
+ 
 NNodes::TExprBase DqPeepholeRewriteCrossJoin(const NNodes::TExprBase& node, TExprContext& ctx);
 NNodes::TExprBase DqPeepholeRewriteJoinDict(const NNodes::TExprBase& node, TExprContext& ctx);
-NNodes::TExprBase DqPeepholeRewriteMapJoin(const NNodes::TExprBase& node, TExprContext& ctx);
+NNodes::TExprBase DqPeepholeRewriteMapJoin(const NNodes::TExprBase& node, TExprContext& ctx); 
 NNodes::TExprBase DqPeepholeRewriteReplicate(const NNodes::TExprBase& node, TExprContext& ctx);
-NNodes::TExprBase DqPeepholeRewritePureJoin(const NNodes::TExprBase& node, TExprContext& ctx);
-
-} // namespace NYql::NDq
+NNodes::TExprBase DqPeepholeRewritePureJoin(const NNodes::TExprBase& node, TExprContext& ctx); 
+ 
+} // namespace NYql::NDq 
diff --git a/ydb/library/yql/dq/opt/dq_opt_phy.cpp b/ydb/library/yql/dq/opt/dq_opt_phy.cpp
index cbe871059d..4159a577ec 100644
--- a/ydb/library/yql/dq/opt/dq_opt_phy.cpp
+++ b/ydb/library/yql/dq/opt/dq_opt_phy.cpp
@@ -13,26 +13,26 @@ using namespace NYql::NNodes;
 namespace {
 
 TVector<TCoArgument> PrepareArgumentsReplacement(const TCoArguments& args, const TVector<TDqConnection>& newInputs,
-    TExprContext& ctx, TNodeOnNodeOwnedMap& replaceMap)
+    TExprContext& ctx, TNodeOnNodeOwnedMap& replaceMap) 
 {
     TVector<TCoArgument> newArgs;
-    newArgs.reserve(args.Size() + newInputs.size());
+    newArgs.reserve(args.Size() + newInputs.size()); 
     replaceMap.clear();
 
     for (size_t i = 0; i < args.Size(); ++i) {
-        TCoArgument newArg{ctx.NewArgument(args.Pos(), TStringBuilder()
-            << "_dq_replace_arg_" << i)};
+        TCoArgument newArg{ctx.NewArgument(args.Pos(), TStringBuilder() 
+            << "_dq_replace_arg_" << i)}; 
         replaceMap[args.Arg(i).Raw()] = newArg.Ptr();
         newArgs.emplace_back(newArg);
     }
 
-    for (size_t i = 0; i < newInputs.size(); ++i) {
-        TCoArgument newArg{ctx.NewArgument(args.Pos(), TStringBuilder()
-            << "_dq_replace_input_arg_" << args.Size() + i)};
-        replaceMap[newInputs[i].Raw()] = newArg.Ptr();
-        newArgs.emplace_back(newArg);
-    }
-
+    for (size_t i = 0; i < newInputs.size(); ++i) { 
+        TCoArgument newArg{ctx.NewArgument(args.Pos(), TStringBuilder() 
+            << "_dq_replace_input_arg_" << args.Size() + i)}; 
+        replaceMap[newInputs[i].Raw()] = newArg.Ptr(); 
+        newArgs.emplace_back(newArg); 
+    } 
+ 
     return newArgs;
 }
 
@@ -128,16 +128,16 @@ TExprBase DqBuildPartitionsStageStub(TExprBase node, TExprContext& ctx, const TP
             .Build()
         .Program()
             .Args({"rows"})
-            .Body<TPartition>()
-                .Input("rows")
+            .Body<TPartition>() 
+                .Input("rows") 
                 .KeySelectorLambda(ctx.DeepCopyLambda(partition.KeySelectorLambda().Ref()))
-                .SortDirections(partition.SortDirections())
+                .SortDirections(partition.SortDirections()) 
                 .SortKeySelectorLambda(partition.SortKeySelectorLambda().template Maybe<TCoLambda>()
                     ? ctx.DeepCopyLambda(partition.SortKeySelectorLambda().Ref())
                     : partition.SortKeySelectorLambda().Ptr())
-                .ListHandlerLambda()
-                    .Args({"list"})
-                    .template Body<TExprApplier>()
+                .ListHandlerLambda() 
+                    .Args({"list"}) 
+                    .template Body<TExprApplier>() 
                         .Apply(handler)
                             .With(handler.Args().Arg(0), "list")
                         .Build()
@@ -179,35 +179,35 @@ TExprBase DqPushMembersFilterToStage(TExprBase node, TExprContext& ctx, IOptimiz
             .Done();
 
     auto result = DqPushLambdaToStageUnionAll(dqUnion, lambda, {}, ctx, optCtx);
-    if (!result) {
-        return node;
-    }
-
-    return result.Cast();
+    if (!result) { 
+        return node; 
+    } 
+ 
+    return result.Cast(); 
 }
 
 } // namespace
 
 TMaybeNode<TDqStage> DqPushLambdaToStage(const TDqStage& stage, const TCoAtom& outputIndex, TCoLambda& lambda,
     const TVector<TDqConnection>& lambdaInputs, TExprContext& ctx, IOptimizationContext& optCtx)
-{
+{ 
     YQL_CLOG(TRACE, CoreDq) << "stage #" << stage.Ref().UniqueId() << ": " << PrintDqStageOnly(stage, ctx)
         << ", add lambda to output #" << outputIndex.Value();
-
-    if (IsDqDependsOnStage(lambda, stage)) {
+ 
+    if (IsDqDependsOnStage(lambda, stage)) { 
         YQL_CLOG(TRACE, CoreDq) << "Lambda " << lambda.Ref().Dump() << " depends on stage: " << PrintDqStageOnly(stage, ctx);
-        return {};
-    }
-
+        return {}; 
+    } 
+ 
     auto program = TCoLambda(DuplicateIndependentStreams(stage.Program().Ptr(),
         [](const TExprNode* node) {
             return TDqPhyPrecompute::Match(node) || TDqConnection::Match(node);
         }, ctx));
-    ui32 index = FromString<ui32>(outputIndex.Value());
+    ui32 index = FromString<ui32>(outputIndex.Value()); 
     ui32 branchesCount = GetStageOutputsCount(stage, true);
-
+ 
     TExprNode::TPtr newProgram;
-    if (branchesCount == 1) {
+    if (branchesCount == 1) { 
         newProgram = ctx.FuseLambdas(lambda.Ref(), program.Ref());
     } else {
         auto dqReplicate = program.Body().Cast<TDqReplicate>();
@@ -224,14 +224,14 @@ TMaybeNode<TDqStage> DqPushLambdaToStage(const TDqStage& stage, const TCoAtom& o
 
         for (size_t i = 0; i < branchesCount; ++i) {
             auto branchLambda = dqReplicate.Arg(/* input */ 1 + i).Cast<TCoLambda>();
-            YQL_ENSURE(branchLambda.Args().Size() == 1);
+            YQL_ENSURE(branchLambda.Args().Size() == 1); 
 
             TExprNode::TPtr newBranchProgram;
             if (index == i) {
                 newBranchProgram = ctx.FuseLambdas(lambda.Ref(), branchLambda.Ref());
-            } else {
+            } else { 
                 newBranchProgram = ctx.DeepCopyLambda(branchLambda.Ref());
-            }
+            } 
 
             newBranchLambdas.emplace_back(ctx.ReplaceNodes(std::move(newBranchProgram), argReplaces));
         }
@@ -242,13 +242,13 @@ TMaybeNode<TDqStage> DqPushLambdaToStage(const TDqStage& stage, const TCoAtom& o
                 .Input(ctx.ReplaceNodes(dqReplicate.Input().Ptr(), argReplaces))
                 .FreeArgs()
                     .Add(newBranchLambdas)
-                    .Build()
-                .Build()
+                    .Build() 
+                .Build() 
             .Done().Ptr();
 
         // YQL_CLOG(TRACE, CoreDq) << "-- newProgram: " << newProgram->Dump();
     }
-
+ 
     TNodeOnNodeOwnedMap inputArgReplaces;
     TVector<TCoArgument> newArgs = PrepareArgumentsReplacement(TCoLambda(newProgram).Args(), lambdaInputs, ctx, inputArgReplaces);
     TVector<TExprBase> inputNodes;
@@ -263,7 +263,7 @@ TMaybeNode<TDqStage> DqPushLambdaToStage(const TDqStage& stage, const TCoAtom& o
             }
             return true;
         });
-
+ 
         YQL_CLOG(TRACE, CoreDq) << "lambda with " << precomputesInsideLambda.size() << " precomputes and "
             << lambdaInputs.size() << " inputs";
 
@@ -284,11 +284,11 @@ TMaybeNode<TDqStage> DqPushLambdaToStage(const TDqStage& stage, const TCoAtom& o
                 inputArgReplaces[raw] = newArgs.back().Ptr();
             }
         }
-    }
-
+    } 
+ 
     YQL_ENSURE(newArgs.size() == inputNodes.size(), "" << newArgs.size() << " != " << inputNodes.size());
 
-    auto newStage = Build<TDqStage>(ctx, stage.Pos())
+    auto newStage = Build<TDqStage>(ctx, stage.Pos()) 
             .Inputs()
                 .Add(inputNodes)
                 .Build()
@@ -297,30 +297,30 @@ TMaybeNode<TDqStage> DqPushLambdaToStage(const TDqStage& stage, const TCoAtom& o
                 .Body(ctx.ReplaceNodes(newProgram->TailPtr(), inputArgReplaces))
                 .Build()
             .Settings(TDqStageSettings().BuildNode(ctx, stage.Pos()))
-            .Done();
-
-    optCtx.RemapNode(stage.Ref(), newStage.Ptr());
-
+            .Done(); 
+ 
+    optCtx.RemapNode(stage.Ref(), newStage.Ptr()); 
+ 
     return newStage;
 }
 
-TMaybeNode<TDqConnection> DqPushLambdaToStageUnionAll(const TDqConnection& connection, TCoLambda& lambda,
+TMaybeNode<TDqConnection> DqPushLambdaToStageUnionAll(const TDqConnection& connection, TCoLambda& lambda, 
     const TVector<TDqConnection>& lambdaInputs, TExprContext& ctx, IOptimizationContext& optCtx)
 {
     auto stage = connection.Output().Stage().Cast<TDqStage>();
     auto newStage = DqPushLambdaToStage(stage, connection.Output().Index(), lambda, lambdaInputs, ctx, optCtx);
-    if (!newStage) {
-        return {};
-    }
-
-    auto output = Build<TDqOutput>(ctx, connection.Pos())
-        .Stage(newStage.Cast())
-        .Index(connection.Output().Index())
-        .Done();
-
+    if (!newStage) { 
+        return {}; 
+    } 
+
+    auto output = Build<TDqOutput>(ctx, connection.Pos()) 
+        .Stage(newStage.Cast()) 
+        .Index(connection.Output().Index()) 
+        .Done(); 
+ 
     return TDqConnection(ctx.ChangeChild(connection.Ref(), TDqConnection::idx_Output, output.Ptr()));
-}
-
+} 
+ 
 TExprBase DqPushSkipNullMembersToStage(TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage)
 {
@@ -333,7 +333,7 @@ TExprBase DqPushExtractMembersToStage(TExprBase node, TExprContext& ctx, IOptimi
     return DqPushMembersFilterToStage<TCoExtractMembers>(node, ctx, optCtx, parentsMap, allowStageMultiUsage);
 }
 
-TExprBase DqBuildFlatmapStage(TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
+TExprBase DqBuildFlatmapStage(TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx, 
     const TParentsMap& parentsMap, bool allowStageMultiUsage)
 {
     if (!node.Maybe<TCoFlatMapBase>().Input().Maybe<TDqCnUnionAll>()) {
@@ -341,12 +341,12 @@ TExprBase DqBuildFlatmapStage(TExprBase node, TExprContext& ctx, IOptimizationCo
     }
 
     auto flatmap = node.Cast<TCoFlatMapBase>();
-    auto dqUnion = flatmap.Input().Cast<TDqCnUnionAll>();
-    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) {
+    auto dqUnion = flatmap.Input().Cast<TDqCnUnionAll>(); 
+    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) { 
         return node;
     }
 
-    if (!IsDqPureExpr(flatmap.Lambda())) {
+    if (!IsDqPureExpr(flatmap.Lambda())) { 
         return node;
     }
 
@@ -360,26 +360,26 @@ TExprBase DqBuildFlatmapStage(TExprBase node, TExprContext& ctx, IOptimizationCo
         .Seal().Build());
 
     auto pushResult = DqPushLambdaToStageUnionAll(dqUnion, lambda, {}, ctx, optCtx);
-    if (pushResult) {
-        return pushResult.Cast();
-    }
-
-    auto flatmapStage = Build<TDqStage>(ctx, flatmap.Pos())
-        .Inputs()
-            .Add<TDqCnMap>()
-                .Output(dqUnion.Output())
-                .Build()
-            .Build()
-        .Program(lambda)
-        .Settings(TDqStageSettings().BuildNode(ctx, flatmap.Pos()))
-        .Done();
-
-    return Build<TDqCnUnionAll>(ctx, node.Pos())
-        .Output()
-            .Stage(flatmapStage)
-            .Index().Build("0")
-            .Build()
-        .Done();
+    if (pushResult) { 
+        return pushResult.Cast(); 
+    } 
+ 
+    auto flatmapStage = Build<TDqStage>(ctx, flatmap.Pos()) 
+        .Inputs() 
+            .Add<TDqCnMap>() 
+                .Output(dqUnion.Output()) 
+                .Build() 
+            .Build() 
+        .Program(lambda) 
+        .Settings(TDqStageSettings().BuildNode(ctx, flatmap.Pos())) 
+        .Done(); 
+ 
+    return Build<TDqCnUnionAll>(ctx, node.Pos()) 
+        .Output() 
+            .Stage(flatmapStage) 
+            .Index().Build("0") 
+            .Build() 
+        .Done(); 
 }
 
 template <typename BaseLMap>
@@ -391,12 +391,12 @@ TExprBase DqPushBaseLMapToStage(TExprBase node, TExprContext& ctx, IOptimization
     }
 
     auto lmap = node.Cast<BaseLMap>();
-    auto dqUnion = lmap.Input().template Cast<TDqCnUnionAll>();
-    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) {
+    auto dqUnion = lmap.Input().template Cast<TDqCnUnionAll>(); 
+    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) { 
         return node;
     }
 
-    if (!CanPushDqExpr(lmap.Lambda(), dqUnion)) {
+    if (!CanPushDqExpr(lmap.Lambda(), dqUnion)) { 
         return node;
     }
 
@@ -555,17 +555,17 @@ TExprBase DqPushCombineToStage(TExprBase node, TExprContext& ctx, IOptimizationC
     }
 
     auto combine = node.Cast<TCoCombineByKey>();
-    auto dqUnion = combine.Input().Cast<TDqCnUnionAll>();
-    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) {
+    auto dqUnion = combine.Input().Cast<TDqCnUnionAll>(); 
+    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) { 
         return node;
     }
 
-    if (!CanPushDqExpr(combine.PreMapLambda(), dqUnion) ||
-        !CanPushDqExpr(combine.KeySelectorLambda(), dqUnion) ||
-        !CanPushDqExpr(combine.InitHandlerLambda(), dqUnion) ||
-        !CanPushDqExpr(combine.UpdateHandlerLambda(), dqUnion) ||
-        !CanPushDqExpr(combine.FinishHandlerLambda(), dqUnion))
-    {
+    if (!CanPushDqExpr(combine.PreMapLambda(), dqUnion) || 
+        !CanPushDqExpr(combine.KeySelectorLambda(), dqUnion) || 
+        !CanPushDqExpr(combine.InitHandlerLambda(), dqUnion) || 
+        !CanPushDqExpr(combine.UpdateHandlerLambda(), dqUnion) || 
+        !CanPushDqExpr(combine.FinishHandlerLambda(), dqUnion)) 
+    { 
         return node;
     }
 
@@ -582,11 +582,11 @@ TExprBase DqPushCombineToStage(TExprBase node, TExprContext& ctx, IOptimizationC
             .Done();
 
     auto result = DqPushLambdaToStageUnionAll(dqUnion, lambda, {}, ctx, optCtx);
-    if (!result) {
-        return node;
-    }
-
-    return result.Cast();
+    if (!result) { 
+        return node; 
+    } 
+ 
+    return result.Cast(); 
 }
 
 TExprBase DqBuildPartitionsStage(TExprBase node, TExprContext& ctx, const TParentsMap& parentsMap) {
@@ -597,13 +597,13 @@ TExprBase DqBuildPartitionStage(TExprBase node, TExprContext& ctx, const TParent
     return DqBuildPartitionsStageStub<TCoPartitionByKey>(std::move(node), ctx, parentsMap);
 }
 
-
-/*
- * Optimizer rule which handles a switch to scalar expression context for aggregation results.
- * This switch happens for full aggregations, such as @code select sum(column) from table @endcode).
- * The result of such aggregations has a following expression pattern:
+ 
+/* 
+ * Optimizer rule which handles a switch to scalar expression context for aggregation results. 
+ * This switch happens for full aggregations, such as @code select sum(column) from table @endcode). 
+ * The result of such aggregations has a following expression pattern: 
  * @code
- *   (AsList (AsStruct '((<StructMember>)+) ...)
+ *   (AsList (AsStruct '((<StructMember>)+) ...) 
  *   StructMember_i := function_i(ToOptional (TDqCnUnionAll ...))
  * @endcode
  *
@@ -611,7 +611,7 @@ TExprBase DqBuildPartitionStage(TExprBase node, TExprContext& ctx, const TParent
  * If for all `i` function `function_i` depends on single connection via `ToOptional` callable
  * then we do the following stuff:
  *
- * For each list item create a new stage with `Condense` callable:
+ * For each list item create a new stage with `Condense` callable: 
  *
  * 1. with `initState` (it is the _default_ _value_ in case of empty input stream)
  * @code
@@ -623,17 +623,17 @@ TExprBase DqBuildPartitionStage(TExprBase node, TExprContext& ctx, const TParent
  * @code
  *   updateHandler := `AsStruct` callable with all `ToOptional (DqCnUnionAll))` replaced with input state argument
  * @endocde
- *
- * If there are more than a single list item, create a separate stage to merge all the results from previous stages.
+ * 
+ * If there are more than a single list item, create a separate stage to merge all the results from previous stages. 
  */
-
-// TODO: Creating a separate stage for each AsList element is redundant, it's better to use
+ 
+// TODO: Creating a separate stage for each AsList element is redundant, it's better to use 
 //       a single stage with something like MultiCondense here.
-
-// TODO: The way such context switch is presented in the expression graph is very implicit, so it is
+ 
+// TODO: The way such context switch is presented in the expression graph is very implicit, so it is 
 //       hard to work with. We should consider making it more explicit, something like ProcessScalar on the
 //       top level of expression graph.
-
+ 
 TExprBase DqBuildAggregationResultStage(TExprBase node, TExprContext& ctx, IOptimizationContext&) {
     if (!node.Maybe<TCoAsList>()) {
         return node;
@@ -641,15 +641,15 @@ TExprBase DqBuildAggregationResultStage(TExprBase node, TExprContext& ctx, IOpti
 
     const auto asList = node.Cast<TCoAsList>();
 
-    TVector<TExprBase> resultConnections;
-    for (const auto& listItem : asList) {
-        if (!listItem.Maybe<TCoAsStruct>()) {
-            return node;
-        }
+    TVector<TExprBase> resultConnections; 
+    for (const auto& listItem : asList) { 
+        if (!listItem.Maybe<TCoAsStruct>()) { 
+            return node; 
+        } 
 
         const auto asStruct = listItem.Cast<TCoAsStruct>();
-
-        TExprNode::TPtr connection;
+ 
+        TExprNode::TPtr connection; 
         bool hasDirectConnection = false;
         bool dependsOnManyConnections = false;
         bool valueConnection = false;
@@ -698,12 +698,12 @@ TExprBase DqBuildAggregationResultStage(TExprBase node, TExprContext& ctx, IOpti
 
             return true;
         });
-
+ 
         if (!connection) {
             return node;
         }
-
-        if (hasDirectConnection || dependsOnManyConnections) {
+ 
+        if (hasDirectConnection || dependsOnManyConnections) { 
             return node;
         }
 
@@ -754,49 +754,49 @@ TExprBase DqBuildAggregationResultStage(TExprBase node, TExprContext& ctx, IOpti
                         .Body<TCoMap>()
                             .Input(mapInput)
                             .Lambda(std::move(lambda))
-                            .Build()
+                            .Build() 
                         .Build()
                     .Settings(TDqStageSettings().BuildNode(ctx, pos))
                     .Build()
-                .Index().Build("0")
+                .Index().Build("0") 
                 .Build()
             .Done();
 
-        resultConnections.push_back(resultConnection);
-    }
-
-    YQL_ENSURE(!resultConnections.empty());
-    if (resultConnections.size() == 1) {
-        return resultConnections[0];
-    }
-
-    TVector<TCoArgument> inputArgs;
-    TVector<TExprBase> extendArgs;
-    inputArgs.reserve(resultConnections.size());
-    for (ui32 i = 0; i < resultConnections.size(); ++i) {
-        TCoArgument inputArg = Build<TCoArgument>(ctx, node.Pos())
-            .Name("input" + ToString(i))
-            .Done();
-        inputArgs.push_back(inputArg);
-        extendArgs.push_back(inputArg);
-    }
-
-    auto unionStage = Build<TDqStage>(ctx, node.Pos())
-        .Inputs()
-            .Add(resultConnections)
-            .Build()
-        .Program()
-            .Args(inputArgs)
-            .Body<TCoExtend>() // TODO: check Extend effectiveness
-                .Add(extendArgs)
-                .Build()
-            .Build()
-        .Settings(TDqStageSettings().BuildNode(ctx, node.Pos()))
-        .Done();
-
+        resultConnections.push_back(resultConnection); 
+    } 
+ 
+    YQL_ENSURE(!resultConnections.empty()); 
+    if (resultConnections.size() == 1) { 
+        return resultConnections[0]; 
+    } 
+ 
+    TVector<TCoArgument> inputArgs; 
+    TVector<TExprBase> extendArgs; 
+    inputArgs.reserve(resultConnections.size()); 
+    for (ui32 i = 0; i < resultConnections.size(); ++i) { 
+        TCoArgument inputArg = Build<TCoArgument>(ctx, node.Pos()) 
+            .Name("input" + ToString(i)) 
+            .Done(); 
+        inputArgs.push_back(inputArg); 
+        extendArgs.push_back(inputArg); 
+    } 
+ 
+    auto unionStage = Build<TDqStage>(ctx, node.Pos()) 
+        .Inputs() 
+            .Add(resultConnections) 
+            .Build() 
+        .Program() 
+            .Args(inputArgs) 
+            .Body<TCoExtend>() // TODO: check Extend effectiveness 
+                .Add(extendArgs) 
+                .Build() 
+            .Build() 
+        .Settings(TDqStageSettings().BuildNode(ctx, node.Pos())) 
+        .Done(); 
+ 
     return Build<TDqCnUnionAll>(ctx, node.Pos())
         .Output()
-            .Stage(unionStage)
+            .Stage(unionStage) 
             .Index().Build("0")
             .Build()
         .Done();
@@ -847,16 +847,16 @@ TExprBase DqBuildTopSortStage(TExprBase node, TExprContext& ctx, IOptimizationCo
     }
 
     auto topSort = node.Cast<TCoTopSort>();
-    auto dqUnion = topSort.Input().Cast<TDqCnUnionAll>();
-    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) {
+    auto dqUnion = topSort.Input().Cast<TDqCnUnionAll>(); 
+    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) { 
         return node;
     }
 
-    if (!CanPushDqExpr(topSort.Count(), dqUnion) || !CanPushDqExpr(topSort.KeySelectorLambda(), dqUnion)) {
+    if (!CanPushDqExpr(topSort.Count(), dqUnion) || !CanPushDqExpr(topSort.KeySelectorLambda(), dqUnion)) { 
         return node;
     }
 
-    auto result = dqUnion.Output().Stage().Program().Body();
+    auto result = dqUnion.Output().Stage().Program().Body(); 
 
     auto sortKeySelector = topSort.KeySelectorLambda();
     auto sortDirections = topSort.SortDirections();
@@ -887,7 +887,7 @@ TExprBase DqBuildTopSortStage(TExprBase node, TExprContext& ctx, IOptimizationCo
 
         for (size_t i = 0; i < tuple.Size(); ++i) {
             auto sortDirection = GetSortDirection(sortDirections, i);
-            if (!AddSortColumn(tuple.Item(i), sortDirection, ctx, node, sortKeySelector, sortColumnList,
+            if (!AddSortColumn(tuple.Item(i), sortDirection, ctx, node, sortKeySelector, sortColumnList, 
                 sortKeyTypes))
             {
                 canMerge = false;
@@ -969,7 +969,7 @@ TExprBase DqBuildSortStage(TExprBase node, TExprContext& ctx, IOptimizationConte
         return node;
     }
 
-    auto result = dqUnion.Output().Stage().Program().Body();
+    auto result = dqUnion.Output().Stage().Program().Body(); 
 
     auto sortKeySelector = sort.KeySelectorLambda();
     auto sortDirections = sort.SortDirections();
@@ -986,7 +986,7 @@ TExprBase DqBuildSortStage(TExprBase node, TExprContext& ctx, IOptimizationConte
 
             for (size_t i = 0; i < tuple.Size(); ++i) {
                 auto sortDirection = GetSortDirection(sortDirections, i);
-                if (!AddSortColumn(tuple.Item(i), TExprBase(sortDirection), ctx, node, sortKeySelector, sortColumnList,
+                if (!AddSortColumn(tuple.Item(i), TExprBase(sortDirection), ctx, node, sortKeySelector, sortColumnList, 
                     sortKeyTypes))
                 {
                     canMerge = false;
@@ -1043,10 +1043,10 @@ TExprBase DqBuildSortStage(TExprBase node, TExprContext& ctx, IOptimizationConte
                 .Build()
             .Program()
                 .Args({"stream"})
-                .Body<TCoSort>()
-                    .Input("stream")
-                    .SortDirections(sort.SortDirections())
-                    .KeySelectorLambda(ctx.DeepCopyLambda(sort.KeySelectorLambda().Ref()))
+                .Body<TCoSort>() 
+                    .Input("stream") 
+                    .SortDirections(sort.SortDirections()) 
+                    .KeySelectorLambda(ctx.DeepCopyLambda(sort.KeySelectorLambda().Ref())) 
                     .Build()
                 .Build()
             .Settings(TDqStageSettings().BuildNode(ctx, node.Pos()))
@@ -1113,16 +1113,16 @@ TExprBase DqBuildTakeStage(TExprBase node, TExprContext& ctx, IOptimizationConte
     }
 
     auto take = node.Cast<TCoTake>();
-    auto dqUnion = take.Input().Cast<TDqCnUnionAll>();
-    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) {
+    auto dqUnion = take.Input().Cast<TDqCnUnionAll>(); 
+    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) { 
         return node;
     }
 
-    if (!CanPushDqExpr(take.Count(), dqUnion)) {
+    if (!CanPushDqExpr(take.Count(), dqUnion)) { 
         return node;
     }
 
-    auto result = dqUnion.Output().Stage().Program().Body();
+    auto result = dqUnion.Output().Stage().Program().Body(); 
     auto stage = dqUnion.Output().Stage();
 
     auto lambda = Build<TCoLambda>(ctx, take.Pos())
@@ -1134,20 +1134,20 @@ TExprBase DqBuildTakeStage(TExprBase node, TExprContext& ctx, IOptimizationConte
             .Done();
 
     auto newDqUnion = DqPushLambdaToStageUnionAll(dqUnion, lambda, {}, ctx, optCtx);
-    if (!newDqUnion) {
-        return node;
-    }
+    if (!newDqUnion) { 
+        return node; 
+    } 
 
     // make outer stage to collect all inner stages
     auto outerTakeStage = Build<TDqStage>(ctx, node.Pos())
             .Inputs()
-                .Add(newDqUnion.Cast())
+                .Add(newDqUnion.Cast()) 
                 .Build()
             .Program()
                 .Args({"stream"})
-                .Body<TCoTake>()
-                    .Input("stream")
-                    .Count(take.Count())
+                .Body<TCoTake>() 
+                    .Input("stream") 
+                    .Count(take.Count()) 
                     .Build()
                 .Build()
             .Settings(TDqStageSettings().BuildNode(ctx, node.Pos()))
@@ -1169,18 +1169,18 @@ TExprBase DqBuildTakeSkipStage(TExprBase node, TExprContext& ctx, IOptimizationC
     }
 
     auto take = node.Cast<TCoTake>();
-    auto skip = take.Input().Cast<TCoSkip>();
-    auto dqUnion = skip.Input().Cast<TDqCnUnionAll>();
-
-    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) {
+    auto skip = take.Input().Cast<TCoSkip>(); 
+    auto dqUnion = skip.Input().Cast<TDqCnUnionAll>(); 
+ 
+    if (!IsSingleConsumerConnection(dqUnion, parentsMap, allowStageMultiUsage)) { 
         return node;
     }
 
-    if (!CanPushDqExpr(take.Count(), dqUnion)) {
+    if (!CanPushDqExpr(take.Count(), dqUnion)) { 
         return node;
     }
 
-    if (!CanPushDqExpr(skip.Count(), dqUnion)) {
+    if (!CanPushDqExpr(skip.Count(), dqUnion)) { 
         return node;
     }
 
@@ -1372,7 +1372,7 @@ TExprBase DqBuildPureExprStage(TExprBase node, TExprContext& ctx) {
  * is needed for handling UNION ALL case, which generates top-level Extend where some arguments
  * can be pure expressions not wrapped in DqStage (e.g. ... UNION ALL SELECT 1).
  */
-TExprBase DqBuildExtendStage(TExprBase node, TExprContext& ctx) {
+TExprBase DqBuildExtendStage(TExprBase node, TExprContext& ctx) { 
     if (!node.Maybe<TCoExtendBase>()) {
         return node;
     }
diff --git a/ydb/library/yql/dq/opt/dq_opt_phy.h b/ydb/library/yql/dq/opt/dq_opt_phy.h
index 70a9d70082..5e990dc8d8 100644
--- a/ydb/library/yql/dq/opt/dq_opt_phy.h
+++ b/ydb/library/yql/dq/opt/dq_opt_phy.h
@@ -10,19 +10,19 @@
 
 namespace NYql::NDq {
 
-NNodes::TMaybeNode<NNodes::TDqStage> DqPushLambdaToStage(const NNodes::TDqStage &stage,
-    const NNodes::TCoAtom& outputIndex, NNodes::TCoLambda& lambda,
+NNodes::TMaybeNode<NNodes::TDqStage> DqPushLambdaToStage(const NNodes::TDqStage &stage, 
+    const NNodes::TCoAtom& outputIndex, NNodes::TCoLambda& lambda, 
     const TVector<NNodes::TDqConnection>& lambdaInputs, TExprContext& ctx, IOptimizationContext& optCtx);
-
-NNodes::TMaybeNode<NNodes::TDqConnection> DqPushLambdaToStageUnionAll(const NNodes::TDqConnection& connection, NNodes::TCoLambda& lambda,
+ 
+NNodes::TMaybeNode<NNodes::TDqConnection> DqPushLambdaToStageUnionAll(const NNodes::TDqConnection& connection, NNodes::TCoLambda& lambda, 
     const TVector<NNodes::TDqConnection>& lambdaInputs, TExprContext& ctx, IOptimizationContext& optCtx);
 
 NNodes::TExprBase DqPushSkipNullMembersToStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
-
+ 
 NNodes::TExprBase DqPushExtractMembersToStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
-
+ 
 NNodes::TExprBase DqPushOrderedLMapToStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
 
@@ -32,31 +32,31 @@ NNodes::TExprBase DqPushLMapToStage(NNodes::TExprBase node, TExprContext& ctx, I
 NNodes::TExprBase DqBuildExtFunctionStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
 
-NNodes::TExprBase DqBuildFlatmapStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
+NNodes::TExprBase DqBuildFlatmapStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx, 
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
-
+ 
 NNodes::TExprBase DqPushCombineToStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
-
+ 
 NNodes::TExprBase DqBuildPartitionsStage(NNodes::TExprBase node, TExprContext& ctx, const TParentsMap& parentsMap);
-
+ 
 NNodes::TExprBase DqBuildPartitionStage(NNodes::TExprBase node, TExprContext& ctx, const TParentsMap& parentsMap);
-
-NNodes::TExprBase DqBuildAggregationResultStage(NNodes::TExprBase node, TExprContext& ctx,
-    IOptimizationContext& optCtx);
-
+ 
+NNodes::TExprBase DqBuildAggregationResultStage(NNodes::TExprBase node, TExprContext& ctx, 
+    IOptimizationContext& optCtx); 
+ 
 NNodes::TExprBase DqBuildTopSortStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
-
+ 
 NNodes::TExprBase DqBuildSortStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
-
+ 
 NNodes::TExprBase DqBuildSkipStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
 
 NNodes::TExprBase DqBuildTakeStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
-
+ 
 NNodes::TExprBase DqBuildTakeSkipStage(NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
 
@@ -64,20 +64,20 @@ NNodes::TExprBase DqRewriteLengthOfStageOutput(NNodes::TExprBase node, TExprCont
 
 NNodes::TExprBase DqRewriteRightJoinToLeft(const NNodes::TExprBase node, TExprContext& ctx);
 
-NNodes::TExprBase DqPushJoinToStage(const NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx,
+NNodes::TExprBase DqPushJoinToStage(const NNodes::TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx, 
     const TParentsMap& parentsMap, bool allowStageMultiUsage = true);
-
+ 
 NNodes::TExprBase DqBuildPhyJoin(const NNodes::TDqJoin& join, bool pushLeftStage, TExprContext& ctx,
     IOptimizationContext& optCtx);
-
+ 
 NNodes::TExprBase DqBuildJoinDict(const NNodes::TDqJoin& join, TExprContext& ctx);
 
-TMaybe<std::pair<NNodes::TExprBase, NNodes::TDqConnection>>  ExtractPureExprStage(TExprNode::TPtr input,
+TMaybe<std::pair<NNodes::TExprBase, NNodes::TDqConnection>>  ExtractPureExprStage(TExprNode::TPtr input, 
     TExprContext& ctx);
 
 NNodes::TExprBase DqBuildPureExprStage(NNodes::TExprBase node, TExprContext& ctx);
 
-NNodes::TExprBase DqBuildExtendStage(NNodes::TExprBase node, TExprContext& ctx);
+NNodes::TExprBase DqBuildExtendStage(NNodes::TExprBase node, TExprContext& ctx); 
 
 NNodes::TExprBase DqBuildPrecomputeStage(NNodes::TExprBase node, TExprContext& ctx);
 
diff --git a/ydb/library/yql/dq/opt/dq_opt_phy_finalizing.cpp b/ydb/library/yql/dq/opt/dq_opt_phy_finalizing.cpp
index a1c8cf10c2..3936df5dae 100644
--- a/ydb/library/yql/dq/opt/dq_opt_phy_finalizing.cpp
+++ b/ydb/library/yql/dq/opt/dq_opt_phy_finalizing.cpp
@@ -16,11 +16,11 @@ namespace {
 std::pair<TDqStage, TVector<TCoAtom>> ReplicateStageOutput(const TDqStage& stage, const TCoAtom& indexAtom,
     const TVector<TCoLambda>& lambdas, TExprContext& ctx)
 {
-    auto result = stage.Program().Body();
+    auto result = stage.Program().Body(); 
     auto resultType = result.Ref().GetTypeAnn();
 
     const TTypeAnnotationNode* resultItemType = nullptr;
-    if (!EnsureNewSeqType<false, false>(result.Pos(), *resultType, ctx, &resultItemType)) {
+    if (!EnsureNewSeqType<false, false>(result.Pos(), *resultType, ctx, &resultItemType)) { 
         YQL_ENSURE(false, "got " << FormatType(resultType));
     }
 
@@ -133,8 +133,8 @@ struct TMultiUsedOutput {
 struct TMultiUsedConnection {
     TDqConnection Connection;
     const TNodeMultiSet& Consumers;
-
-    // set if Connection has single consumer, but it's Output has many consumers
+ 
+    // set if Connection has single consumer, but it's Output has many consumers 
     // in that case, Connection - is on of connections, references to this Output
     TMaybe<TMultiUsedOutput> Output;
 
@@ -153,8 +153,8 @@ struct TMultiUsedConnection {
                 sb << "consumer: " << PrintConsumer(consumer, output.Stage(), ctx) << Endl;
             }
         } else {
-            sb << "multiused output, index: " << Output->Output.Index().Value()
-               << ", #" << Output->Output.Ref().UniqueId()
+            sb << "multiused output, index: " << Output->Output.Index().Value() 
+               << ", #" << Output->Output.Ref().UniqueId() 
                << ", stage: " << PrintDqStageOnly(Output->Output.Stage(), ctx)
                << ", consumers: " << Output->Consumers.size() << Endl;
             for (const auto& consumer : Output->Consumers) {
@@ -201,136 +201,136 @@ TString IndexesToString(const TCoAtom& head, const TVector<TCoAtom>& tail) {
     return sb;
 }
 
-void BuildIdentityLambdas(TVector<TCoLambda>& lambdas, ui32 count, TExprContext& ctx, TPositionHandle pos) {
-    lambdas.reserve(count);
-    for (size_t i = 0; i < count; ++i) {
-        lambdas.emplace_back(BuildIdentityLambda(pos, ctx));
-    }
-}
-
+void BuildIdentityLambdas(TVector<TCoLambda>& lambdas, ui32 count, TExprContext& ctx, TPositionHandle pos) { 
+    lambdas.reserve(count); 
+    for (size_t i = 0; i < count; ++i) { 
+        lambdas.emplace_back(BuildIdentityLambda(pos, ctx)); 
+    } 
+} 
+ 
 TExprNode::TPtr ReplicateDqOutput(TExprNode::TPtr&& input, const TMultiUsedConnection& muConnection, TExprContext& ctx)
-{
-    YQL_ENSURE(muConnection.Output.Defined());
-    auto dqOutput = muConnection.Output->Output;
-    auto dqStage = dqOutput.Stage().Cast<TDqStage>();
-    auto outputIndex = dqOutput.Index();
-    auto consumersCount = muConnection.Output->Consumers.size();
-    YQL_ENSURE(consumersCount > 1);
-
-    TVector<TCoLambda> lambdas;
-    BuildIdentityLambdas(lambdas, consumersCount - 1, ctx, dqOutput.Pos());
-
+{ 
+    YQL_ENSURE(muConnection.Output.Defined()); 
+    auto dqOutput = muConnection.Output->Output; 
+    auto dqStage = dqOutput.Stage().Cast<TDqStage>(); 
+    auto outputIndex = dqOutput.Index(); 
+    auto consumersCount = muConnection.Output->Consumers.size(); 
+    YQL_ENSURE(consumersCount > 1); 
+ 
+    TVector<TCoLambda> lambdas; 
+    BuildIdentityLambdas(lambdas, consumersCount - 1, ctx, dqOutput.Pos()); 
+ 
     auto ret = ReplicateStageOutput(dqStage, outputIndex, lambdas, ctx);
-    auto newStage = ret.first;
-    auto newAdditionalIndexes = ret.second;
-
+    auto newStage = ret.first; 
+    auto newAdditionalIndexes = ret.second; 
+ 
     YQL_CLOG(TRACE, CoreDq) << "Replicate DQ output (stage #" << dqStage.Ref().UniqueId() << ", "
         << outputIndex.Value() << ") -> (#" << newStage.Ref().UniqueId() << ", ["
         << IndexesToString(outputIndex, newAdditionalIndexes) << "])." << Endl << PrintDqStageOnly(newStage, ctx);
-
-    TNodeOnNodeOwnedMap replaces;
-    replaces[dqStage.Raw()] = newStage.Ptr();
-
-    ui32 consumerIdx = 0;
-    for (auto& connection : muConnection.Output->Consumers) {
-        YQL_ENSURE(TExprBase(connection).Maybe<TDqConnection>(), "DqOutput "
-            << NCommon::ExprToPrettyString(ctx, muConnection.Output->Output.Ref())
-            << " used by not DqConnection callable: " << connection->Content());
-
-        if (consumerIdx == 0) {
-            // Keep first (any of) consumer as is.
-            ++consumerIdx;
-            continue;
-        }
-
-        auto newOutput = Build<TDqOutput>(ctx, connection->Pos())
-            .Stage(newStage)
-            .Index(newAdditionalIndexes[consumerIdx - 1])
-            .Done();
-        auto newConnection = ctx.ChangeChild(*connection, TDqConnection::idx_Output, newOutput.Ptr());
-        replaces[connection] = newConnection;
-        ++consumerIdx;
-    }
-
-    return ctx.ReplaceNodes(std::move(input), replaces);
-}
-
-TExprNode::TPtr ReplicateDqConnection(TExprNode::TPtr&& input, const TMultiUsedConnection& muConnection,
+ 
+    TNodeOnNodeOwnedMap replaces; 
+    replaces[dqStage.Raw()] = newStage.Ptr(); 
+ 
+    ui32 consumerIdx = 0; 
+    for (auto& connection : muConnection.Output->Consumers) { 
+        YQL_ENSURE(TExprBase(connection).Maybe<TDqConnection>(), "DqOutput " 
+            << NCommon::ExprToPrettyString(ctx, muConnection.Output->Output.Ref()) 
+            << " used by not DqConnection callable: " << connection->Content()); 
+ 
+        if (consumerIdx == 0) { 
+            // Keep first (any of) consumer as is. 
+            ++consumerIdx; 
+            continue; 
+        } 
+ 
+        auto newOutput = Build<TDqOutput>(ctx, connection->Pos()) 
+            .Stage(newStage) 
+            .Index(newAdditionalIndexes[consumerIdx - 1]) 
+            .Done(); 
+        auto newConnection = ctx.ChangeChild(*connection, TDqConnection::idx_Output, newOutput.Ptr()); 
+        replaces[connection] = newConnection; 
+        ++consumerIdx; 
+    } 
+ 
+    return ctx.ReplaceNodes(std::move(input), replaces); 
+} 
+ 
+TExprNode::TPtr ReplicateDqConnection(TExprNode::TPtr&& input, const TMultiUsedConnection& muConnection, 
     TExprContext& ctx)
-{
+{ 
     YQL_CLOG(TRACE, CoreDq) << "-- ReplicateDqConnection: " << NCommon::ExprToPrettyString(ctx, *input);
 
-    YQL_ENSURE(!muConnection.Output.Defined());
-    auto dqOutput = muConnection.Connection.Output();
-    auto dqStage = dqOutput.Stage().Cast<TDqStage>();
-    auto outputIndex = dqOutput.Index();
-
-    auto& consumers = muConnection.Consumers;
-    YQL_ENSURE(consumers.size() > 1);
-
-    // NOTE: Only handle one consumer at a time, as there might be dependencies between them.
+    YQL_ENSURE(!muConnection.Output.Defined()); 
+    auto dqOutput = muConnection.Connection.Output(); 
+    auto dqStage = dqOutput.Stage().Cast<TDqStage>(); 
+    auto outputIndex = dqOutput.Index(); 
+ 
+    auto& consumers = muConnection.Consumers; 
+    YQL_ENSURE(consumers.size() > 1); 
+ 
+    // NOTE: Only handle one consumer at a time, as there might be dependencies between them. 
     // Ensure stable order by processing connection with minimal ID
-    auto& consumer = *std::min_element(consumers.begin(), consumers.end(),
-        [](auto l, auto r) { return l->UniqueId() < r->UniqueId(); });
-
-    auto usagesCount = consumers.count(consumer);
-    bool isLastConsumer = consumers.size() == usagesCount;
-
-    YQL_CLOG(TRACE, CoreDq) << "-- usagesCount: " << usagesCount << ", isLastConsumer: " << isLastConsumer;
-
-    if (isLastConsumer) {
-        YQL_ENSURE(usagesCount > 1);
-    }
-
-    auto lambdasCount = isLastConsumer
-        ? usagesCount - 1
-        : usagesCount;
-
+    auto& consumer = *std::min_element(consumers.begin(), consumers.end(), 
+        [](auto l, auto r) { return l->UniqueId() < r->UniqueId(); }); 
+
+    auto usagesCount = consumers.count(consumer); 
+    bool isLastConsumer = consumers.size() == usagesCount; 
+
+    YQL_CLOG(TRACE, CoreDq) << "-- usagesCount: " << usagesCount << ", isLastConsumer: " << isLastConsumer; 
+ 
+    if (isLastConsumer) { 
+        YQL_ENSURE(usagesCount > 1); 
+    } 
+ 
+    auto lambdasCount = isLastConsumer 
+        ? usagesCount - 1 
+        : usagesCount; 
+ 
     YQL_CLOG(TRACE, CoreDq) << "-- lambdas count: " << lambdasCount;
 
-    TVector<TCoLambda> lambdas;
-    BuildIdentityLambdas(lambdas, lambdasCount, ctx, dqOutput.Pos());
-
-    auto [newStage, newAdditionalIndexes] = ReplicateStageOutput(dqStage, outputIndex, lambdas, ctx);
-
-    bool isStageConsumer = TMaybeNode<TDqStage>(consumer).IsValid();
-    auto consumerNode = isStageConsumer
-        ? TDqStage(consumer).Inputs().Raw()
-        : consumer;
-
-    ui32 usageIdx = 0;
-    bool skipUsage = isLastConsumer;
-    TExprNode::TPtr newConsumer = ctx.ShallowCopy(*consumerNode);
-    for (size_t childIndex = 0; childIndex < newConsumer->ChildrenSize(); ++childIndex) {
-        TExprBase child(newConsumer->Child(childIndex));
-
-        if (child.Raw() == muConnection.Connection.Raw()) {
-            if (skipUsage && usageIdx == 0) {
-                // Keep first (any of) usage as is.
-                skipUsage = false;
-                continue;
-            }
-
-            auto newOutput = Build<TDqOutput>(ctx, child.Pos())
-                .Stage(newStage)
-                .Index(newAdditionalIndexes[usageIdx])
-                .Done();
-
-            auto newConnection = ctx.ChangeChild(child.Ref(), TDqConnection::idx_Output, newOutput.Ptr());
-
-            newConsumer = ctx.ChangeChild(*newConsumer, childIndex, std::move(newConnection));
-            ++usageIdx;
-        }
-    }
-
-    if (isStageConsumer) {
-        newConsumer = ctx.ChangeChild(*consumer, TDqStage::idx_Inputs, std::move(newConsumer));
-    }
-
-    auto result = ctx.ReplaceNode(std::move(input), *consumer, newConsumer);
-    return ctx.ReplaceNode(std::move(result), dqStage.Ref(), newStage.Ptr());
-}
-
+    TVector<TCoLambda> lambdas; 
+    BuildIdentityLambdas(lambdas, lambdasCount, ctx, dqOutput.Pos()); 
+ 
+    auto [newStage, newAdditionalIndexes] = ReplicateStageOutput(dqStage, outputIndex, lambdas, ctx); 
+ 
+    bool isStageConsumer = TMaybeNode<TDqStage>(consumer).IsValid(); 
+    auto consumerNode = isStageConsumer 
+        ? TDqStage(consumer).Inputs().Raw() 
+        : consumer; 
+ 
+    ui32 usageIdx = 0; 
+    bool skipUsage = isLastConsumer; 
+    TExprNode::TPtr newConsumer = ctx.ShallowCopy(*consumerNode); 
+    for (size_t childIndex = 0; childIndex < newConsumer->ChildrenSize(); ++childIndex) { 
+        TExprBase child(newConsumer->Child(childIndex)); 
+ 
+        if (child.Raw() == muConnection.Connection.Raw()) { 
+            if (skipUsage && usageIdx == 0) { 
+                // Keep first (any of) usage as is. 
+                skipUsage = false; 
+                continue; 
+            } 
+ 
+            auto newOutput = Build<TDqOutput>(ctx, child.Pos()) 
+                .Stage(newStage) 
+                .Index(newAdditionalIndexes[usageIdx]) 
+                .Done(); 
+ 
+            auto newConnection = ctx.ChangeChild(child.Ref(), TDqConnection::idx_Output, newOutput.Ptr()); 
+ 
+            newConsumer = ctx.ChangeChild(*newConsumer, childIndex, std::move(newConnection)); 
+            ++usageIdx; 
+        } 
+    } 
+ 
+    if (isStageConsumer) { 
+        newConsumer = ctx.ChangeChild(*consumer, TDqStage::idx_Inputs, std::move(newConsumer)); 
+    } 
+ 
+    auto result = ctx.ReplaceNode(std::move(input), *consumer, newConsumer); 
+    return ctx.ReplaceNode(std::move(result), dqStage.Ref(), newStage.Ptr()); 
+} 
+ 
 template <typename TExpr>
 TVector<TExpr> CollectNodes(const TExprNode::TPtr& input) {
     TVector<TExpr> result;
@@ -345,92 +345,92 @@ TVector<TExpr> CollectNodes(const TExprNode::TPtr& input) {
     return result;
 }
 
-bool GatherConsumersImpl(const TExprNode& node, TNodeMap<TNodeMultiSet>& consumers, TNodeSet& visited) {
-    if (!visited.emplace(&node).second) {
-        return true;
-    }
-
-    switch (node.Type()) {
-        case TExprNode::Atom:
-        case TExprNode::Argument:
-        case TExprNode::Arguments:
-        case TExprNode::World:
-            return true;
-
-        case TExprNode::List:
-        case TExprNode::Callable:
-        case TExprNode::Lambda:
-            break;
-    }
-
-    if (auto stageBase = TMaybeNode<TDqStageBase>(&node)) {
-        if (!stageBase.Maybe<TDqStage>()) {
-            return false;
-        }
-
-        TDqStage stage(&node);
-        for (const auto& input : stage.Inputs()) {
-            if (auto connection = input.Maybe<TDqConnection>()) {
-                consumers[connection.Cast().Raw()].insert(stage.Raw());
-                consumers[connection.Cast().Output().Raw()].insert(connection.Raw());
-            }
-
-            if (!GatherConsumersImpl(input.Ref(), consumers, visited)) {
-                return false;
-            }
-        }
-
-        if (!GatherConsumersImpl(stage.Program().Ref(), consumers, visited)) {
-            return false;
-        }
-
-        if (!GatherConsumersImpl(stage.Settings().Ref(), consumers, visited)) {
-            return false;
-        }
-
-        if (stage.Sinks()) {
-            if (!GatherConsumersImpl(stage.Sinks().Ref(), consumers, visited)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    for (const auto& child : node.Children()) {
-        if (auto connection = TMaybeNode<TDqConnection>(child)) {
-            consumers[connection.Cast().Raw()].insert(&node);
-            consumers[connection.Cast().Output().Raw()].insert(&node);
-        }
-
-        if (!GatherConsumersImpl(*child, consumers, visited)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool GatherConsumers(const TExprNode& root, TNodeMap<TNodeMultiSet>& consumers) {
-    TNodeSet visited;
-    return GatherConsumersImpl(root, consumers, visited);
-}
-
+bool GatherConsumersImpl(const TExprNode& node, TNodeMap<TNodeMultiSet>& consumers, TNodeSet& visited) { 
+    if (!visited.emplace(&node).second) { 
+        return true; 
+    } 
+ 
+    switch (node.Type()) { 
+        case TExprNode::Atom: 
+        case TExprNode::Argument: 
+        case TExprNode::Arguments: 
+        case TExprNode::World: 
+            return true; 
+ 
+        case TExprNode::List: 
+        case TExprNode::Callable: 
+        case TExprNode::Lambda: 
+            break; 
+    } 
+ 
+    if (auto stageBase = TMaybeNode<TDqStageBase>(&node)) { 
+        if (!stageBase.Maybe<TDqStage>()) { 
+            return false; 
+        } 
+ 
+        TDqStage stage(&node); 
+        for (const auto& input : stage.Inputs()) { 
+            if (auto connection = input.Maybe<TDqConnection>()) { 
+                consumers[connection.Cast().Raw()].insert(stage.Raw()); 
+                consumers[connection.Cast().Output().Raw()].insert(connection.Raw()); 
+            } 
+ 
+            if (!GatherConsumersImpl(input.Ref(), consumers, visited)) { 
+                return false; 
+            } 
+        } 
+ 
+        if (!GatherConsumersImpl(stage.Program().Ref(), consumers, visited)) { 
+            return false; 
+        } 
+ 
+        if (!GatherConsumersImpl(stage.Settings().Ref(), consumers, visited)) { 
+            return false; 
+        } 
+ 
+        if (stage.Sinks()) { 
+            if (!GatherConsumersImpl(stage.Sinks().Ref(), consumers, visited)) { 
+                return false; 
+            } 
+        } 
+ 
+        return true; 
+    } 
+ 
+    for (const auto& child : node.Children()) { 
+        if (auto connection = TMaybeNode<TDqConnection>(child)) { 
+            consumers[connection.Cast().Raw()].insert(&node); 
+            consumers[connection.Cast().Output().Raw()].insert(&node); 
+        } 
+ 
+        if (!GatherConsumersImpl(*child, consumers, visited)) { 
+            return false; 
+        } 
+    } 
+ 
+    return true; 
+} 
+ 
+bool GatherConsumers(const TExprNode& root, TNodeMap<TNodeMultiSet>& consumers) { 
+    TNodeSet visited; 
+    return GatherConsumersImpl(root, consumers, visited); 
+} 
+ 
 } // anonymous namespace
 
 IGraphTransformer::TStatus DqReplicateStageMultiOutput(TExprNode::TPtr input, TExprNode::TPtr& output,
     TExprContext& ctx)
 {
-    output = input;
-
-    // YQL_CLOG(TRACE, CoreDq) << "-- replicate query: " << NCommon::ExprToPrettyString(ctx, *input);
-    // YQL_CLOG(TRACE, CoreDq) << "-- replicate query: " << input->Dump();
+    output = input; 
 
-    TNodeMap<TNodeMultiSet> consumersMap;
-    if (!GatherConsumers(*input, consumersMap)) {
-        return IGraphTransformer::TStatus::Ok;
-    }
+    // YQL_CLOG(TRACE, CoreDq) << "-- replicate query: " << NCommon::ExprToPrettyString(ctx, *input); 
+    // YQL_CLOG(TRACE, CoreDq) << "-- replicate query: " << input->Dump(); 
 
+    TNodeMap<TNodeMultiSet> consumersMap; 
+    if (!GatherConsumers(*input, consumersMap)) { 
+        return IGraphTransformer::TStatus::Ok; 
+    } 
+ 
     // rewrite only 1 (any of) multi-used connection at a time
     std::optional<TMultiUsedConnection> multiUsedConnection;
     TDeque<TExprNode::TPtr> precomputes;
@@ -442,8 +442,8 @@ IGraphTransformer::TStatus DqReplicateStageMultiOutput(TExprNode::TPtr input, TE
         auto head = precomputes.front();
         precomputes.pop_front();
 
-        YQL_CLOG(TRACE, CoreDq) << "DqReplicateStageMultiOutput: start traverse node #" << head->UniqueId()
-            << ", " << head->Content();
+        YQL_CLOG(TRACE, CoreDq) << "DqReplicateStageMultiOutput: start traverse node #" << head->UniqueId() 
+            << ", " << head->Content(); 
 
         visitedNodes.erase(head.Get());
 
@@ -464,33 +464,33 @@ IGraphTransformer::TStatus DqReplicateStageMultiOutput(TExprNode::TPtr input, TE
                 TExprBase expr{ptr};
 
                 if (auto precompute = expr.Maybe<TDqPhyPrecompute>()) {
-                    YQL_CLOG(TRACE, CoreDq) << "DqReplicateStageMultiOutput: got precompute (#"
-                        << ptr->UniqueId() << "),"
+                    YQL_CLOG(TRACE, CoreDq) << "DqReplicateStageMultiOutput: got precompute (#" 
+                        << ptr->UniqueId() << ")," 
                         << " stop iteration. Child: " << precompute.Connection().Ref().Content()
                         << ", #" << precompute.Connection().Ref().UniqueId();
                     precomputes.emplace_back(ptr);
                     return false;
                 }
 
-                if (expr.Maybe<TDqConnection>() && consumersMap.find(expr.Raw()) != consumersMap.end()) {
+                if (expr.Maybe<TDqConnection>() && consumersMap.find(expr.Raw()) != consumersMap.end()) { 
                     auto connection = expr.Cast<TDqConnection>();
                     YQL_CLOG(TRACE, CoreDq) << "DqReplicateStageMultiOutput: test connection "
                         << connection.Ref().Content() << " (#" << ptr->UniqueId() << ")";
-                    const auto& consumers = GetConsumers(connection, consumersMap);
+                    const auto& consumers = GetConsumers(connection, consumersMap); 
                     if (consumers.size() > 1) {
                         // if connection has multiple consumers - stop traversing and return this connection
                         multiUsedConnection.emplace(connection, consumers);
                         return false;
                     }
                     auto output = connection.Output();
-                    const auto& outputConsumers = GetConsumers(output, consumersMap);
+                    const auto& outputConsumers = GetConsumers(output, consumersMap); 
                     if (outputConsumers.size() > 1) {
                         // connection has single consumer, but it's output has multiple ones
                         // in that case we check, that this output is used by single-client connections only
                         bool allConnectionsWithSingleConsumer = true;
                         for (auto conn : outputConsumers) {
-                            bool singleConsumer = GetConsumers(TExprBase(conn), consumersMap).size() == 1;
-                            allConnectionsWithSingleConsumer &= singleConsumer;
+                            bool singleConsumer = GetConsumers(TExprBase(conn), consumersMap).size() == 1; 
+                            allConnectionsWithSingleConsumer &= singleConsumer; 
                         }
                         if (allConnectionsWithSingleConsumer) {
                             multiUsedConnection.emplace(connection, consumers);
@@ -512,7 +512,7 @@ IGraphTransformer::TStatus DqReplicateStageMultiOutput(TExprNode::TPtr input, TE
 
     YQL_CLOG(TRACE, CoreDq) << "DqReplicateStageMultiOutput: " << multiUsedConnection->Print(ctx);
 
-    if (multiUsedConnection->Output.Defined()) {
+    if (multiUsedConnection->Output.Defined()) { 
         output = ReplicateDqOutput(std::move(input), *multiUsedConnection, ctx);
     } else {
         output = ReplicateDqConnection(std::move(input), *multiUsedConnection, ctx);
diff --git a/ydb/library/yql/dq/opt/ya.make b/ydb/library/yql/dq/opt/ya.make
index be88e1e1f6..4c9f481df0 100644
--- a/ydb/library/yql/dq/opt/ya.make
+++ b/ydb/library/yql/dq/opt/ya.make
@@ -17,10 +17,10 @@ PEERDIR(
 SRCS(
     dq_opt.cpp
     dq_opt_build.cpp
-    dq_opt_join.cpp
+    dq_opt_join.cpp 
     dq_opt_log.cpp
-    dq_opt_peephole.cpp
-    dq_opt_phy_finalizing.cpp
+    dq_opt_peephole.cpp 
+    dq_opt_phy_finalizing.cpp 
     dq_opt_phy.cpp
 )
 
diff --git a/ydb/library/yql/dq/proto/dq_tasks.proto b/ydb/library/yql/dq/proto/dq_tasks.proto
index e29e64ef2c..b5c1c09796 100644
--- a/ydb/library/yql/dq/proto/dq_tasks.proto
+++ b/ydb/library/yql/dq/proto/dq_tasks.proto
@@ -26,9 +26,9 @@ message TProgram {
         bool HasSort = 2;
         bool HasUdf = 3;
     }
-
-    uint32 RuntimeVersion = 1;
-    bytes Raw = 2;
+ 
+    uint32 RuntimeVersion = 1; 
+    bytes Raw = 2; 
     TSettings Settings = 3;
 }
 
@@ -55,7 +55,7 @@ message TChannel {
     TEndpoint SrcEndpoint = 5;
     TEndpoint DstEndpoint = 6;
 
-    bool IsPersistent = 7;
+    bool IsPersistent = 7; 
     bool InMemory = 8;
     ECheckpointingMode CheckpointingMode = 9;
 }
@@ -109,9 +109,9 @@ message TTaskOutputHashPartition {
     uint32 PartitionsCount = 2;
 }
 
-message TTaskOutputEffects {
+message TTaskOutputEffects { 
 }
-
+ 
 message TTaskOutputSink {
     string Type = 1;
     google.protobuf.Any Settings = 2;
@@ -124,7 +124,7 @@ message TTaskOutput {
         TTaskOutputRangePartition RangePartition = 11;
         TTaskOutputHashPartition HashPartition = 12;
         TTaskOutputBroadcast Broadcast = 13;
-        TTaskOutputEffects Effects = 14;
+        TTaskOutputEffects Effects = 14; 
         TTaskOutputSink Sink = 15;
     }
 }
diff --git a/ydb/library/yql/dq/proto/dq_transport.proto b/ydb/library/yql/dq/proto/dq_transport.proto
index d78fa7806c..fdf37d59d1 100644
--- a/ydb/library/yql/dq/proto/dq_transport.proto
+++ b/ydb/library/yql/dq/proto/dq_transport.proto
@@ -5,8 +5,8 @@ package NYql.NDqProto;
 
 enum EDataTransportVersion {
     DATA_TRANSPORT_VERSION_UNSPECIFIED = 0;
-    DATA_TRANSPORT_YSON_1_0 = 10000;
-    DATA_TRANSPORT_UV_PICKLE_1_0 = 20000;
+    DATA_TRANSPORT_YSON_1_0 = 10000; 
+    DATA_TRANSPORT_UV_PICKLE_1_0 = 20000; 
     DATA_TRANSPORT_ARROW_1_0 = 30000;
 }
 
diff --git a/ydb/library/yql/dq/proto/ya.make b/ydb/library/yql/dq/proto/ya.make
index d5327f2634..5afe04ffc1 100644
--- a/ydb/library/yql/dq/proto/ya.make
+++ b/ydb/library/yql/dq/proto/ya.make
@@ -11,8 +11,8 @@ PEERDIR(
 SRCS(
     dq_checkpoint.proto
     dq_state_load_plan.proto
-    dq_tasks.proto
-    dq_transport.proto
+    dq_tasks.proto 
+    dq_transport.proto 
 )
 
 EXCLUDE_TAGS(GO_PROTO)
diff --git a/ydb/library/yql/dq/runtime/dq_columns_resolve.cpp b/ydb/library/yql/dq/runtime/dq_columns_resolve.cpp
index 850f6108d9..59ee1a8f06 100644
--- a/ydb/library/yql/dq/runtime/dq_columns_resolve.cpp
+++ b/ydb/library/yql/dq/runtime/dq_columns_resolve.cpp
@@ -1,4 +1,4 @@
-#include "dq_columns_resolve.h"
+#include "dq_columns_resolve.h" 
 
 #include <ydb/library/yql/utils/yql_panic.h>
 
@@ -11,11 +11,11 @@ TMaybe<TColumnInfo> FindColumnInfo(const NKikimr::NMiniKQL::TType* type, TString
     const auto& structType = static_cast<const TStructType&>(*type);
 
     auto columnIndex = structType.FindMemberIndex(columnName);
-    if (!columnIndex) {
-        return {};
-    }
+    if (!columnIndex) { 
+        return {}; 
+    } 
 
-    auto memberType = structType.GetMemberType(*columnIndex);
+    auto memberType = structType.GetMemberType(*columnIndex); 
 
     if (memberType->GetKind() == TType::EKind::Optional) {
         memberType = static_cast<TOptionalType&>(*memberType).GetItemType();
@@ -29,9 +29,9 @@ TMaybe<TColumnInfo> FindColumnInfo(const NKikimr::NMiniKQL::TType* type, TString
 
 TColumnInfo GetColumnInfo(const TType* type, TStringBuf columnName) {
     auto columnInfo = FindColumnInfo(type, columnName);
-    YQL_ENSURE(columnInfo);
-
-    return *columnInfo;
-}
-
+    YQL_ENSURE(columnInfo); 
+ 
+    return *columnInfo; 
 }
+ 
+} 
diff --git a/ydb/library/yql/dq/runtime/dq_columns_resolve.h b/ydb/library/yql/dq/runtime/dq_columns_resolve.h
index b61d14f477..3e5d445bdd 100644
--- a/ydb/library/yql/dq/runtime/dq_columns_resolve.h
+++ b/ydb/library/yql/dq/runtime/dq_columns_resolve.h
@@ -21,7 +21,7 @@ struct TSortColumnInfo : public TColumnInfo {
     {}
 };
 
-TMaybe<TColumnInfo> FindColumnInfo(const NKikimr::NMiniKQL::TType* type, TStringBuf column);
+TMaybe<TColumnInfo> FindColumnInfo(const NKikimr::NMiniKQL::TType* type, TStringBuf column); 
 TColumnInfo GetColumnInfo(const NKikimr::NMiniKQL::TType* type, TStringBuf column);
 
 template<typename TList>
diff --git a/ydb/library/yql/dq/runtime/dq_compute.cpp b/ydb/library/yql/dq/runtime/dq_compute.cpp
index 0da2ed9630..060cba4b30 100644
--- a/ydb/library/yql/dq/runtime/dq_compute.cpp
+++ b/ydb/library/yql/dq/runtime/dq_compute.cpp
@@ -1,4 +1,4 @@
-#include "dq_compute.h"
+#include "dq_compute.h" 
 
 #include <ydb/library/yql/minikql/comp_nodes/mkql_factories.h>
 #include <ydb/library/yql/minikql/mkql_node.h>
diff --git a/ydb/library/yql/dq/runtime/dq_tasks_runner.cpp b/ydb/library/yql/dq/runtime/dq_tasks_runner.cpp
index 10900352c3..09fbd4f8b1 100644
--- a/ydb/library/yql/dq/runtime/dq_tasks_runner.cpp
+++ b/ydb/library/yql/dq/runtime/dq_tasks_runner.cpp
@@ -1,4 +1,4 @@
-#include "dq_tasks_runner.h"
+#include "dq_tasks_runner.h" 
 
 #include <ydb/library/yql/dq/expr_nodes/dq_expr_nodes.h>
 #include <ydb/library/yql/dq/runtime/dq_columns_resolve.h>
@@ -22,102 +22,102 @@ using namespace NYql::NDqProto;
 
 namespace NYql::NDq {
 
-namespace {
-
-void ValidateParamValue(std::string_view paramName, const TType* type, const NUdf::TUnboxedValuePod& value) {
-    switch (type->GetKind()) {
-        case TType::EKind::Void:
-            break;
-        case TType::EKind::Null:
-            break;
-        case TType::EKind::EmptyList:
-            break;
-        case TType::EKind::EmptyDict:
-            break;
-
-        case TType::EKind::Data: {
-            auto dataType = static_cast<const TDataType*>(type);
-            auto slot = dataType->GetDataSlot();
-            YQL_ENSURE(slot);
-            YQL_ENSURE(IsValidValue(*slot, value), "Error parsing task parameter, malformed value"
-                << ", parameter: " << paramName
-                << ", type: " << NUdf::GetDataTypeInfo(*slot).Name
-                << ", value: " << value);
-            break;
-        }
-
-        case TType::EKind::Optional: {
-            auto optionalType = static_cast<const TOptionalType*>(type);
-            if (value) {
-                ValidateParamValue(paramName, optionalType->GetItemType(), value.GetOptionalValue());
-            }
-            break;
-        }
-
-        case TType::EKind::List: {
-            auto listType = static_cast<const TListType*>(type);
-            auto itemType = listType->GetItemType();
-            const auto iter = value.GetListIterator();
-            for (NUdf::TUnboxedValue item; iter.Next(item);) {
-                ValidateParamValue(paramName, itemType, item);
-            }
-            break;
-        }
-
-        case TType::EKind::Struct: {
-            auto structType = static_cast<const TStructType*>(type);
-            for (ui32 index = 0; index < structType->GetMembersCount(); ++index) {
-                auto memberType = structType->GetMemberType(index);
-                ValidateParamValue(paramName, memberType, value.GetElement(index));
-            }
-            break;
-        }
-
-        case TType::EKind::Tuple: {
-            auto tupleType = static_cast<const TTupleType*>(type);
-            for (ui32 index = 0; index < tupleType->GetElementsCount(); ++index) {
-                auto elementType = tupleType->GetElementType(index);
-                ValidateParamValue(paramName, elementType, value.GetElement(index));
-            }
-            break;
-        }
-
-        case TType::EKind::Dict:  {
-            auto dictType = static_cast<const TDictType*>(type);
-            auto keyType = dictType->GetKeyType();
-            auto payloadType = dictType->GetPayloadType();
-
-            const auto iter = value.GetDictIterator();
-            for (NUdf::TUnboxedValue key, payload; iter.NextPair(key, payload);) {
-                ValidateParamValue(paramName, keyType, key);
-                ValidateParamValue(paramName, payloadType, payload);
-            }
-            break;
-        }
-
-        case TType::EKind::Variant: {
-            auto variantType = static_cast<const TVariantType*>(type);
-            ui32 variantIndex = value.GetVariantIndex();
-            TType* innerType = variantType->GetUnderlyingType();
-            if (innerType->IsStruct()) {
-                innerType = static_cast<TStructType*>(innerType)->GetMemberType(variantIndex);
-            } else {
-                YQL_ENSURE(innerType->IsTuple(), "Unexpected underlying variant type: " << innerType->GetKindAsStr());
-                innerType = static_cast<TTupleType*>(innerType)->GetElementType(variantIndex);
-            }
-            ValidateParamValue(paramName, innerType, value.GetVariantItem());
-            break;
-        }
-
-        default:
-            YQL_ENSURE(false, "Unexpected value type in parameter"
-                << ", parameter: " << paramName
-                << ", type: " << type->GetKindAsStr());
-    }
-}
-
-} // namespace
-
+namespace { 
+ 
+void ValidateParamValue(std::string_view paramName, const TType* type, const NUdf::TUnboxedValuePod& value) { 
+    switch (type->GetKind()) { 
+        case TType::EKind::Void: 
+            break; 
+        case TType::EKind::Null: 
+            break; 
+        case TType::EKind::EmptyList: 
+            break; 
+        case TType::EKind::EmptyDict: 
+            break; 
+ 
+        case TType::EKind::Data: { 
+            auto dataType = static_cast<const TDataType*>(type); 
+            auto slot = dataType->GetDataSlot(); 
+            YQL_ENSURE(slot); 
+            YQL_ENSURE(IsValidValue(*slot, value), "Error parsing task parameter, malformed value" 
+                << ", parameter: " << paramName 
+                << ", type: " << NUdf::GetDataTypeInfo(*slot).Name 
+                << ", value: " << value); 
+            break; 
+        } 
+ 
+        case TType::EKind::Optional: { 
+            auto optionalType = static_cast<const TOptionalType*>(type); 
+            if (value) { 
+                ValidateParamValue(paramName, optionalType->GetItemType(), value.GetOptionalValue()); 
+            } 
+            break; 
+        } 
+ 
+        case TType::EKind::List: { 
+            auto listType = static_cast<const TListType*>(type); 
+            auto itemType = listType->GetItemType(); 
+            const auto iter = value.GetListIterator(); 
+            for (NUdf::TUnboxedValue item; iter.Next(item);) { 
+                ValidateParamValue(paramName, itemType, item); 
+            } 
+            break; 
+        } 
+ 
+        case TType::EKind::Struct: { 
+            auto structType = static_cast<const TStructType*>(type); 
+            for (ui32 index = 0; index < structType->GetMembersCount(); ++index) { 
+                auto memberType = structType->GetMemberType(index); 
+                ValidateParamValue(paramName, memberType, value.GetElement(index)); 
+            } 
+            break; 
+        } 
+ 
+        case TType::EKind::Tuple: { 
+            auto tupleType = static_cast<const TTupleType*>(type); 
+            for (ui32 index = 0; index < tupleType->GetElementsCount(); ++index) { 
+                auto elementType = tupleType->GetElementType(index); 
+                ValidateParamValue(paramName, elementType, value.GetElement(index)); 
+            } 
+            break; 
+        } 
+ 
+        case TType::EKind::Dict:  { 
+            auto dictType = static_cast<const TDictType*>(type); 
+            auto keyType = dictType->GetKeyType(); 
+            auto payloadType = dictType->GetPayloadType(); 
+ 
+            const auto iter = value.GetDictIterator(); 
+            for (NUdf::TUnboxedValue key, payload; iter.NextPair(key, payload);) { 
+                ValidateParamValue(paramName, keyType, key); 
+                ValidateParamValue(paramName, payloadType, payload); 
+            } 
+            break; 
+        } 
+ 
+        case TType::EKind::Variant: { 
+            auto variantType = static_cast<const TVariantType*>(type); 
+            ui32 variantIndex = value.GetVariantIndex(); 
+            TType* innerType = variantType->GetUnderlyingType(); 
+            if (innerType->IsStruct()) { 
+                innerType = static_cast<TStructType*>(innerType)->GetMemberType(variantIndex); 
+            } else { 
+                YQL_ENSURE(innerType->IsTuple(), "Unexpected underlying variant type: " << innerType->GetKindAsStr()); 
+                innerType = static_cast<TTupleType*>(innerType)->GetElementType(variantIndex); 
+            } 
+            ValidateParamValue(paramName, innerType, value.GetVariantItem()); 
+            break; 
+        } 
+ 
+        default: 
+            YQL_ENSURE(false, "Unexpected value type in parameter" 
+                << ", parameter: " << paramName 
+                << ", type: " << type->GetKindAsStr()); 
+    } 
+} 
+ 
+} // namespace 
+ 
 #define LOG(...) do { if (Y_UNLIKELY(LogFunc)) { LogFunc(__VA_ARGS__); } } while (0)
 
 NUdf::TUnboxedValue DqBuildInputValue(const NDqProto::TTaskInput& inputDesc, const NKikimr::NMiniKQL::TType* type,
@@ -371,8 +371,8 @@ public:
 
                     TDqDataSerializer::DeserializeParam(it->second, type, graphHolderFactory, structMembers[i]);
                 }
-
-                ValidateParamValue(name, type, structMembers[i]);
+ 
+                ValidateParamValue(name, type, structMembers[i]); 
             }
 
             paramNode->SetValue(ProgramParsed.CompGraph->GetContext(), std::move(paramsStructValue));
@@ -511,7 +511,7 @@ public:
         }
     }
 
-    ERunStatus Run() final {
+    ERunStatus Run() final { 
         LOG(TStringBuilder() << "Run task: " << TaskId);
 
         RunComputeTime = TDuration::Zero();
@@ -532,7 +532,7 @@ public:
             }
         }
 
-        if (runStatus == ERunStatus::Finished) {
+        if (runStatus == ERunStatus::Finished) { 
             if (Stats) {
                 Stats->FinishTs = TInstant::Now();
             }
@@ -540,7 +540,7 @@ public:
                 StopWaiting(Stats->FinishTs);
             }
 
-            return ERunStatus::Finished;
+            return ERunStatus::Finished; 
         }
 
         if (Y_UNLIKELY(CollectProfileStats)) {
@@ -555,7 +555,7 @@ public:
     }
 
     bool HasEffects() const final {
-        return TaskHasEffects;
+        return TaskHasEffects; 
     }
 
     IDqInputChannel::TPtr GetInputChannel(ui64 channelId) override {
@@ -681,7 +681,7 @@ private:
                 }
             }
         }
-
+ 
         return ERunStatus::PendingOutput;
     }
 
diff --git a/ydb/library/yql/dq/runtime/dq_tasks_runner.h b/ydb/library/yql/dq/runtime/dq_tasks_runner.h
index a0cc816e91..8f86eb9b90 100644
--- a/ydb/library/yql/dq/runtime/dq_tasks_runner.h
+++ b/ydb/library/yql/dq/runtime/dq_tasks_runner.h
@@ -154,7 +154,7 @@ public:
     virtual void Prepare(const NDqProto::TDqTask& task, const TDqTaskRunnerMemoryLimits& memoryLimits,
         const IDqTaskRunnerExecutionContext& execCtx = TDqTaskRunnerExecutionContext(),
         const TDqTaskRunnerParameterProvider& parameterProvider = {}) = 0;
-    virtual ERunStatus Run() = 0;
+    virtual ERunStatus Run() = 0; 
 
     virtual bool HasEffects() const = 0;
 
diff --git a/ydb/library/yql/dq/runtime/dq_transport.cpp b/ydb/library/yql/dq/runtime/dq_transport.cpp
index 93b85b0c6f..876d54d6f2 100644
--- a/ydb/library/yql/dq/runtime/dq_transport.cpp
+++ b/ydb/library/yql/dq/runtime/dq_transport.cpp
@@ -1,4 +1,4 @@
-#include "dq_transport.h"
+#include "dq_transport.h" 
 #include "dq_arrow_helpers.h"
 
 #include <ydb/library/mkql_proto/mkql_proto.h>
@@ -27,7 +27,7 @@ NDqProto::TData SerializeValuePickleV1(const TType* type, const NUdf::TUnboxedVa
     TStringBuf packResult = packer.Pack(value);
 
     NDqProto::TData data;
-    data.SetTransportVersion(NDqProto::DATA_TRANSPORT_UV_PICKLE_1_0);
+    data.SetTransportVersion(NDqProto::DATA_TRANSPORT_UV_PICKLE_1_0); 
     data.SetRaw(packResult.data(), packResult.size());
     data.SetRows(1);
 
diff --git a/ydb/library/yql/dq/runtime/ya.make b/ydb/library/yql/dq/runtime/ya.make
index 4cc8585431..1e507a2c7a 100644
--- a/ydb/library/yql/dq/runtime/ya.make
+++ b/ydb/library/yql/dq/runtime/ya.make
@@ -20,19 +20,19 @@ PEERDIR(
 
 SRCS(
     dq_arrow_helpers.cpp
-    dq_columns_resolve.cpp
-    dq_compute.cpp
+    dq_columns_resolve.cpp 
+    dq_compute.cpp 
     dq_input_channel.cpp
     dq_input_producer.cpp
     dq_output_channel.cpp
     dq_output_consumer.cpp
     dq_source.cpp
     dq_sink.cpp
-    dq_tasks_runner.cpp
-    dq_transport.cpp
+    dq_tasks_runner.cpp 
+    dq_transport.cpp 
 )
 
-GENERATE_ENUM_SERIALIZATION(dq_tasks_runner.h)
+GENERATE_ENUM_SERIALIZATION(dq_tasks_runner.h) 
 
 YQL_LAST_ABI_VERSION()
 
diff --git a/ydb/library/yql/dq/tasks/dq_connection_builder.h b/ydb/library/yql/dq/tasks/dq_connection_builder.h
index 2c46061f60..fe9659b2ca 100644
--- a/ydb/library/yql/dq/tasks/dq_connection_builder.h
+++ b/ydb/library/yql/dq/tasks/dq_connection_builder.h
@@ -31,7 +31,7 @@ void CommonBuildTasks(TDqTasksGraph<TStageInfoMeta, TTaskMeta, TInputMeta, TOutp
 
         if (auto maybeCnShuffle = input.Maybe<NNodes::TDqCnHashShuffle>()) {
             auto shuffle = maybeCnShuffle.Cast();
-            auto& originStageInfo = graph.GetStageInfo(shuffle.Output().Stage());
+            auto& originStageInfo = graph.GetStageInfo(shuffle.Output().Stage()); 
             if (stageSettings.IsExternalFunction) {
                 partitionsCount = stageSettings.MaxTransformConcurrency();
             } else {
@@ -40,7 +40,7 @@ void CommonBuildTasks(TDqTasksGraph<TStageInfoMeta, TTaskMeta, TInputMeta, TOutp
             }
         } else if (auto maybeCnMap = input.Maybe<NNodes::TDqCnMap>()) {
             auto cnMap = maybeCnMap.Cast();
-            auto& originStageInfo = graph.GetStageInfo(cnMap.Output().Stage());
+            auto& originStageInfo = graph.GetStageInfo(cnMap.Output().Stage()); 
             partitionsCount = originStageInfo.Tasks.size();
         }
     }
@@ -53,11 +53,11 @@ void CommonBuildTasks(TDqTasksGraph<TStageInfoMeta, TTaskMeta, TInputMeta, TOutp
     }
 }
 
-template <typename TGraph>
-void BuildUnionAllChannels(TGraph& graph, const typename TGraph::TStageInfoType& stageInfo, ui32 inputIndex,
+template <typename TGraph> 
+void BuildUnionAllChannels(TGraph& graph, const typename TGraph::TStageInfoType& stageInfo, ui32 inputIndex, 
     const typename TGraph::TStageInfoType& inputStageInfo, ui32 outputIndex, bool enableSpilling,
     const TChannelLogFunc& logFunc)
-{
+{ 
     YQL_ENSURE(stageInfo.Tasks.size() == 1, "Multiple tasks on union all input. StageId: " << stageInfo.Id);
     auto& targetTask = graph.GetTask(stageInfo.Tasks[0]);
 
@@ -82,30 +82,30 @@ void BuildUnionAllChannels(TGraph& graph, const typename TGraph::TStageInfoType&
     }
 }
 
-template <typename TGraph>
-void BuildUnionAllChannels(TGraph& graph, const NNodes::TDqPhyStage& stage, ui32 inputIndex,
-    const TChannelLogFunc& logFunc)
-{
+template <typename TGraph> 
+void BuildUnionAllChannels(TGraph& graph, const NNodes::TDqPhyStage& stage, ui32 inputIndex, 
+    const TChannelLogFunc& logFunc) 
+{ 
     auto& stageInfo = graph.GetStageInfo(stage);
 
-    auto dqUnion = stage.Inputs().Item(inputIndex).Cast<NNodes::TDqCnUnionAll>();
-    auto& inputStageInfo = graph.GetStageInfo(dqUnion.Output().Stage());
-    auto outputIndex = FromString<ui32>(dqUnion.Output().Index().Value());
-
+    auto dqUnion = stage.Inputs().Item(inputIndex).Cast<NNodes::TDqCnUnionAll>(); 
+    auto& inputStageInfo = graph.GetStageInfo(dqUnion.Output().Stage()); 
+    auto outputIndex = FromString<ui32>(dqUnion.Output().Index().Value()); 
+ 
     BuildUnionAllChannels(graph, stageInfo, inputIndex, inputStageInfo, outputIndex, false, logFunc);
-}
-
-template <typename TGraph, typename TKeyColumns>
+} 
+ 
+template <typename TGraph, typename TKeyColumns> 
 void BuildHashShuffleChannels(TGraph& graph, const typename TGraph::TStageInfoType& stageInfo, ui32 inputIndex,
-    const typename TGraph::TStageInfoType& inputStageInfo, ui32 outputIndex, const TKeyColumns& keyColumns,
+    const typename TGraph::TStageInfoType& inputStageInfo, ui32 outputIndex, const TKeyColumns& keyColumns, 
     bool enableSpilling, const TChannelLogFunc& logFunc)
-{
-    for (auto& originTaskId : inputStageInfo.Tasks) {
+{ 
+    for (auto& originTaskId : inputStageInfo.Tasks) { 
         auto& originTask = graph.GetTask(originTaskId);
         auto& taskOutput = originTask.Outputs[outputIndex];
         taskOutput.Type = TTaskOutputType::HashPartition;
-        for (const auto& keyColumn : keyColumns) {
-            taskOutput.KeyColumns.push_back(keyColumn);
+        for (const auto& keyColumn : keyColumns) { 
+            taskOutput.KeyColumns.push_back(keyColumn); 
         }
 
         taskOutput.PartitionsCount = stageInfo.Tasks.size();
@@ -129,33 +129,33 @@ void BuildHashShuffleChannels(TGraph& graph, const typename TGraph::TStageInfoTy
     }
 }
 
-template <typename TGraph>
+template <typename TGraph> 
 void BuildHashShuffleChannels(TGraph& graph, const NNodes::TDqPhyStage& stage, ui32 inputIndex,
-    const TChannelLogFunc& logFunc)
-{
+    const TChannelLogFunc& logFunc) 
+{ 
     auto& stageInfo = graph.GetStageInfo(stage);
     auto shuffle = stage.Inputs().Item(inputIndex).Cast<NNodes::TDqCnHashShuffle>();
-    auto& originStageInfo = graph.GetStageInfo(shuffle.Output().Stage());
-    auto outputIndex = FromString<ui32>(shuffle.Output().Index().Value());
+    auto& originStageInfo = graph.GetStageInfo(shuffle.Output().Stage()); 
+    auto outputIndex = FromString<ui32>(shuffle.Output().Index().Value()); 
 
-    TVector<TString> keyColumns;
-    for (const auto& keyColumn : shuffle.KeyColumns()) {
-        keyColumns.push_back(TString(keyColumn));
-    }
+    TVector<TString> keyColumns; 
+    for (const auto& keyColumn : shuffle.KeyColumns()) { 
+        keyColumns.push_back(TString(keyColumn)); 
+    } 
 
     BuildHashShuffleChannels(graph, stageInfo, inputIndex, originStageInfo, outputIndex, keyColumns, false, logFunc);
-}
-
-template <typename TGraph>
-void BuildMapChannels(TGraph& graph, const typename TGraph::TStageInfoType& stageInfo, ui32 inputIndex,
+} 
+ 
+template <typename TGraph> 
+void BuildMapChannels(TGraph& graph, const typename TGraph::TStageInfoType& stageInfo, ui32 inputIndex, 
     const typename TGraph::TStageInfoType& inputStageInfo, ui32 outputIndex, bool enableSpilling,
     const TChannelLogFunc& logFunc)
-{
-    auto& originTasks = inputStageInfo.Tasks;
+{ 
+    auto& originTasks = inputStageInfo.Tasks; 
     auto& targetTasks = stageInfo.Tasks;
 
     YQL_ENSURE(originTasks.size() == targetTasks.size(),
-        "" << originTasks.size() << " != " << targetTasks.size());
+        "" << originTasks.size() << " != " << targetTasks.size()); 
 
     for (size_t i = 0; i < originTasks.size(); ++i) {
         auto originTaskId = originTasks[i];
@@ -182,27 +182,27 @@ void BuildMapChannels(TGraph& graph, const typename TGraph::TStageInfoType& stag
     }
 }
 
-template <typename TGraph>
-void BuildMapChannels(TGraph& graph, const NNodes::TDqPhyStage& stage, ui32 inputIndex,
-    const TChannelLogFunc& logFunc)
-{
+template <typename TGraph> 
+void BuildMapChannels(TGraph& graph, const NNodes::TDqPhyStage& stage, ui32 inputIndex, 
+    const TChannelLogFunc& logFunc) 
+{ 
     auto& stageInfo = graph.GetStageInfo(stage);
-    auto cnMap = stage.Inputs().Item(inputIndex).Cast<NNodes::TDqCnMap>();
+    auto cnMap = stage.Inputs().Item(inputIndex).Cast<NNodes::TDqCnMap>(); 
 
-    auto& originStageInfo = graph.GetStageInfo(cnMap.Output().Stage());
-    auto outputIndex = FromString<ui32>(cnMap.Output().Index().Value());
+    auto& originStageInfo = graph.GetStageInfo(cnMap.Output().Stage()); 
+    auto outputIndex = FromString<ui32>(cnMap.Output().Index().Value()); 
 
     BuildMapChannels(graph, stageInfo, inputIndex, originStageInfo, outputIndex, false /*spilling*/, logFunc);
-}
+} 
 
-template <typename TGraph>
-void BuildBroadcastChannels(TGraph& graph, const typename TGraph::TStageInfoType& stageInfo, ui32 inputIndex,
+template <typename TGraph> 
+void BuildBroadcastChannels(TGraph& graph, const typename TGraph::TStageInfoType& stageInfo, ui32 inputIndex, 
     const typename TGraph::TStageInfoType& inputStageInfo, ui32 outputIndex, bool enableSpilling,
     const TChannelLogFunc& logFunc)
-{
-    YQL_ENSURE(inputStageInfo.Tasks.size() == 1);
-
-    auto originTaskId = inputStageInfo.Tasks[0];
+{ 
+    YQL_ENSURE(inputStageInfo.Tasks.size() == 1); 
+ 
+    auto originTaskId = inputStageInfo.Tasks[0]; 
     auto& targetTasks = stageInfo.Tasks;
 
     for (size_t i = 0; i < targetTasks.size(); ++i) {
@@ -229,19 +229,19 @@ void BuildBroadcastChannels(TGraph& graph, const typename TGraph::TStageInfoType
     }
 }
 
-template <typename TGraph>
-void BuildBroadcastChannels(TGraph& graph, const NNodes::TDqPhyStage& stage, ui32 inputIndex,
-    const TChannelLogFunc& logFunc)
-{
-    auto& stageInfo = graph.GetStageInfo(stage);
-    auto cnBroadcast = stage.Inputs().Item(inputIndex).Cast<NNodes::TDqCnBroadcast>();
-
-    auto& originStageInfo = graph.GetStageInfo(cnBroadcast.Output().Stage());
-    auto outputIndex = FromString<ui32>(cnBroadcast.Output().Index().Value());
-
+template <typename TGraph> 
+void BuildBroadcastChannels(TGraph& graph, const NNodes::TDqPhyStage& stage, ui32 inputIndex, 
+    const TChannelLogFunc& logFunc) 
+{ 
+    auto& stageInfo = graph.GetStageInfo(stage); 
+    auto cnBroadcast = stage.Inputs().Item(inputIndex).Cast<NNodes::TDqCnBroadcast>(); 
+ 
+    auto& originStageInfo = graph.GetStageInfo(cnBroadcast.Output().Stage()); 
+    auto outputIndex = FromString<ui32>(cnBroadcast.Output().Index().Value()); 
+ 
     BuildBroadcastChannels(graph, stageInfo, inputIndex, originStageInfo, outputIndex, false, logFunc);
 }
-
+ 
 template <typename TGraph>
 void BuildMergeChannels(TGraph& graph, const typename TGraph::TStageInfoType& stageInfo, ui32 inputIndex,
     const typename TGraph::TStageInfoType& inputStageInfo, ui32 outputIndex, const TVector<TSortColumn>& sortColumns,
@@ -271,7 +271,7 @@ void BuildMergeChannels(TGraph& graph, const typename TGraph::TStageInfoType& st
 
         logFunc(channel.Id, originTaskId, targetTask.Id, "Merge/Map", !channel.InMemory);
     }
-}
+} 
 
 template <typename TGraph>
 void BuildMergeChannels(TGraph& graph, const NNodes::TDqPhyStage& stage, ui32 inputIndex,
diff --git a/ydb/library/yql/dq/tasks/dq_task_program.cpp b/ydb/library/yql/dq/tasks/dq_task_program.cpp
index d06a6023b3..81d7808cda 100644
--- a/ydb/library/yql/dq/tasks/dq_task_program.cpp
+++ b/ydb/library/yql/dq/tasks/dq_task_program.cpp
@@ -1,4 +1,4 @@
-#include "dq_task_program.h"
+#include "dq_task_program.h" 
 
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 #include <ydb/library/yql/minikql/mkql_node_serialization.h>
diff --git a/ydb/library/yql/dq/tasks/dq_tasks_graph.h b/ydb/library/yql/dq/tasks/dq_tasks_graph.h
index e5c772310b..f902977588 100644
--- a/ydb/library/yql/dq/tasks/dq_tasks_graph.h
+++ b/ydb/library/yql/dq/tasks/dq_tasks_graph.h
@@ -9,41 +9,41 @@
 
 namespace NYql::NDq {
 
-struct TStageId {
-    ui64 TxId = 0;
-    ui64 StageId = 0;
-
-    TStageId(ui64 txId, ui64 stageId)
-        : TxId(txId)
-        , StageId(stageId) {}
-
-    bool operator==(const TStageId& other) const {
-        return TxId == other.TxId && StageId == other.StageId;
-    }
-
+struct TStageId { 
+    ui64 TxId = 0; 
+    ui64 StageId = 0; 
+ 
+    TStageId(ui64 txId, ui64 stageId) 
+        : TxId(txId) 
+        , StageId(stageId) {} 
+ 
+    bool operator==(const TStageId& other) const { 
+        return TxId == other.TxId && StageId == other.StageId; 
+    } 
+ 
     bool operator!=(const TStageId& other) const {
-        return !(*this == other);
-    }
-
-    bool operator<(const TStageId&) = delete;
-    bool operator>(const TStageId&) = delete;
-    bool operator<=(const TStageId&) = delete;
-    bool operator>=(const TStageId&) = delete;
-
-    ui64 Hash() const noexcept {
-        auto tuple = std::make_tuple(TxId, StageId);
-        return THash<decltype(tuple)>()(tuple);
-    }
-};
-
+        return !(*this == other); 
+    } 
+ 
+    bool operator<(const TStageId&) = delete; 
+    bool operator>(const TStageId&) = delete; 
+    bool operator<=(const TStageId&) = delete; 
+    bool operator>=(const TStageId&) = delete; 
+ 
+    ui64 Hash() const noexcept { 
+        auto tuple = std::make_tuple(TxId, StageId); 
+        return THash<decltype(tuple)>()(tuple); 
+    } 
+}; 
+ 
 template <class TStageInfoMeta>
 struct TStageInfo : private TMoveOnly {
-    TStageInfo(ui64 txId, const NNodes::TDqPhyStage& stage, TStageInfoMeta&& meta)
-        : Id(txId, stage.Ref().UniqueId())
+    TStageInfo(ui64 txId, const NNodes::TDqPhyStage& stage, TStageInfoMeta&& meta) 
+        : Id(txId, stage.Ref().UniqueId()) 
         , InputsCount(stage.Inputs().Size())
         , Meta(std::move(meta))
     {
-        auto result = stage.Program().Body();
+        auto result = stage.Program().Body(); 
         auto resultType = result.Ref().GetTypeAnn();
 
         if (resultType->GetKind() == ETypeAnnotationKind::Stream) {
@@ -62,17 +62,17 @@ struct TStageInfo : private TMoveOnly {
         }
     }
 
-    TStageInfo(const NNodes::TDqPhyStage& stage, TStageInfoMeta&& meta)
-        : TStageInfo(0, stage, std::move(meta)) {}
-
-    TStageInfo(const TStageId& id, ui32 inputsCount, ui32 outputsCount, TStageInfoMeta&& meta)
-        : Id(id)
-        , InputsCount(inputsCount)
-        , OutputsCount(outputsCount)
-        , Meta(std::move(meta)) {}
-
-    TStageId Id;
-
+    TStageInfo(const NNodes::TDqPhyStage& stage, TStageInfoMeta&& meta) 
+        : TStageInfo(0, stage, std::move(meta)) {} 
+ 
+    TStageInfo(const TStageId& id, ui32 inputsCount, ui32 outputsCount, TStageInfoMeta&& meta) 
+        : Id(id) 
+        , InputsCount(inputsCount) 
+        , OutputsCount(outputsCount) 
+        , Meta(std::move(meta)) {} 
+ 
+    TStageId Id; 
+ 
     ui32 InputsCount = 0;
     ui32 OutputsCount = 0;
 
@@ -135,7 +135,7 @@ struct TTaskOutputType {
         Map,
         HashPartition,
         Broadcast,
-        Effects,
+        Effects, 
         Sink,
         COMMON_TASK_OUTPUT_TYPE_END
     };
@@ -160,9 +160,9 @@ struct TTransform {
 
 template <class TStageInfoMeta, class TTaskMeta, class TInputMeta, class TOutputMeta>
 struct TTask {
-    using TInputType = TTaskInput<TInputMeta>;
-    using TOutputType = TTaskOutput<TOutputMeta>;
-
+    using TInputType = TTaskInput<TInputMeta>; 
+    using TOutputType = TTaskOutput<TOutputMeta>; 
+ 
     explicit TTask(const TStageInfo<TStageInfoMeta>& stageInfo)
         : StageId(stageInfo.Id)
         , Inputs(stageInfo.InputsCount)
@@ -170,9 +170,9 @@ struct TTask {
     }
 
     ui64 Id = 0;
-    TStageId StageId;
-    TVector<TInputType> Inputs;
-    TVector<TOutputType> Outputs;
+    TStageId StageId; 
+    TVector<TInputType> Inputs; 
+    TVector<TOutputType> Outputs; 
     NActors::TActorId ComputeActorId;
     TTaskMeta Meta;
     NDqProto::ECheckpointingMode CheckpointingMode = NDqProto::CHECKPOINTING_MODE_DEFAULT;
@@ -206,39 +206,39 @@ public:
         return Channels;
     }
 
-    const TStageInfoType& GetStageInfo(const TStageId& id) const {
-        auto stageInfo = StagesInfo.FindPtr(id);
-        YQL_ENSURE(stageInfo, "no stage #" << id);
+    const TStageInfoType& GetStageInfo(const TStageId& id) const { 
+        auto stageInfo = StagesInfo.FindPtr(id); 
+        YQL_ENSURE(stageInfo, "no stage #" << id); 
         return *stageInfo;
     }
 
-    TStageInfoType& GetStageInfo(const TStageId& id) {
-        auto stageInfo = StagesInfo.FindPtr(id);
-        YQL_ENSURE(stageInfo, "no stage #" << id);
+    TStageInfoType& GetStageInfo(const TStageId& id) { 
+        auto stageInfo = StagesInfo.FindPtr(id); 
+        YQL_ENSURE(stageInfo, "no stage #" << id); 
         return *stageInfo;
     }
 
-    const TStageInfoType& GetStageInfo(ui64 txId, const NNodes::TDqStageBase& stage) const {
-        return GetStageInfo(TStageId(txId, stage.Ref().UniqueId()));
-    }
-
-    TStageInfoType& GetStageInfo(ui64 txId, const NNodes::TDqStageBase& stage) {
-        return GetStageInfo(TStageId(txId, stage.Ref().UniqueId()));
-    }
-
+    const TStageInfoType& GetStageInfo(ui64 txId, const NNodes::TDqStageBase& stage) const { 
+        return GetStageInfo(TStageId(txId, stage.Ref().UniqueId())); 
+    } 
+ 
+    TStageInfoType& GetStageInfo(ui64 txId, const NNodes::TDqStageBase& stage) { 
+        return GetStageInfo(TStageId(txId, stage.Ref().UniqueId())); 
+    } 
+ 
     const TStageInfoType& GetStageInfo(const NNodes::TDqStageBase& stage) const {
-        return GetStageInfo(0, stage);
+        return GetStageInfo(0, stage); 
     }
 
     TStageInfoType& GetStageInfo(const NNodes::TDqStageBase& stage) {
-        return GetStageInfo(0, stage);
+        return GetStageInfo(0, stage); 
     }
 
-    const THashMap<TStageId, TStageInfoType>& GetStagesInfo() const {
+    const THashMap<TStageId, TStageInfoType>& GetStagesInfo() const { 
         return StagesInfo;
     }
 
-    THashMap<TStageId, TStageInfoType>& GetStagesInfo() {
+    THashMap<TStageId, TStageInfoType>& GetStagesInfo() { 
         return StagesInfo;
     }
 
@@ -283,21 +283,21 @@ public:
     }
 
 private:
-    THashMap<TStageId, TStageInfoType> StagesInfo;
+    THashMap<TStageId, TStageInfoType> StagesInfo; 
     TVector<TTaskType> Tasks;
     TVector<TChannel> Channels;
 };
 
 } // namespace NYql::NDq
-
-template<>
-struct THash<NYql::NDq::TStageId> {
-    inline size_t operator()(const NYql::NDq::TStageId& id) const {
-        return id.Hash();
-    }
-};
-
-template<>
-inline void Out<NYql::NDq::TStageId>(IOutputStream& o, const NYql::NDq::TStageId& id) {
-    o << '[' << id.TxId << ',' << id.StageId << ']';
-}
+ 
+template<> 
+struct THash<NYql::NDq::TStageId> { 
+    inline size_t operator()(const NYql::NDq::TStageId& id) const { 
+        return id.Hash(); 
+    } 
+}; 
+ 
+template<> 
+inline void Out<NYql::NDq::TStageId>(IOutputStream& o, const NYql::NDq::TStageId& id) { 
+    o << '[' << id.TxId << ',' << id.StageId << ']'; 
+} 
diff --git a/ydb/library/yql/dq/tasks/ya.make b/ydb/library/yql/dq/tasks/ya.make
index 74592aab58..5ae21e259c 100644
--- a/ydb/library/yql/dq/tasks/ya.make
+++ b/ydb/library/yql/dq/tasks/ya.make
@@ -11,7 +11,7 @@ PEERDIR(
 )
 
 SRCS(
-    dq_task_program.cpp
+    dq_task_program.cpp 
 )
 
 
diff --git a/ydb/library/yql/dq/type_ann/dq_type_ann.cpp b/ydb/library/yql/dq/type_ann/dq_type_ann.cpp
index fcbd3bb9ec..052d803f9d 100644
--- a/ydb/library/yql/dq/type_ann/dq_type_ann.cpp
+++ b/ydb/library/yql/dq/type_ann/dq_type_ann.cpp
@@ -16,7 +16,7 @@ using TStatus = NYql::IGraphTransformer::TStatus;
 namespace {
 
 const TTypeAnnotationNode* GetDqOutputType(const TDqOutput& output, TExprContext& ctx) {
-    auto stageResultTuple = output.Stage().Ref().GetTypeAnn()->Cast<TTupleExprType>();
+    auto stageResultTuple = output.Stage().Ref().GetTypeAnn()->Cast<TTupleExprType>(); 
 
     ui32 resultIndex;
     if (!TryFromString(output.Index().Value(), resultIndex)) {
@@ -112,14 +112,14 @@ TStatus AnnotateStage(const TExprNode::TPtr& stage, TExprContext& ctx) {
     }
 
     if (!UpdateLambdaAllArgumentsTypes(programLambda, argTypes, ctx)) {
-        return TStatus::Error;
-    }
+        return TStatus::Error; 
+    } 
 
     auto* resultType = programLambda->GetTypeAnn();
     if (!resultType) {
         return TStatus::Repeat;
-    }
-
+    } 
+ 
     TVector<const TTypeAnnotationNode*> resultTypesTuple;
 
     if (resultType->GetKind() == ETypeAnnotationKind::Void) {
@@ -159,145 +159,145 @@ TStatus AnnotateStage(const TExprNode::TPtr& stage, TExprContext& ctx) {
     return TStatus::Ok;
 }
 
-THashMap<TStringBuf, THashMap<TStringBuf, const TTypeAnnotationNode*>>
+THashMap<TStringBuf, THashMap<TStringBuf, const TTypeAnnotationNode*>> 
 ParseJoinInputType(const TStructExprType& rowType, TStringBuf tableLabel, TExprContext& ctx, bool optional) {
-    THashMap<TStringBuf, THashMap<TStringBuf, const TTypeAnnotationNode*>> result;
-    for (auto member : rowType.GetItems()) {
-        TStringBuf label, column;
-        if (member->GetName().Contains('.')) {
-            SplitTableName(member->GetName(), label, column);
-        } else {
-            column = member->GetName();
-        }
-        if (label.empty() && tableLabel.empty()) {
-            ctx.AddError(TIssue(TStringBuilder() << "Invalid join input type " << FormatType(&rowType)));
-            result.clear();
-            return result;
-        }
+    THashMap<TStringBuf, THashMap<TStringBuf, const TTypeAnnotationNode*>> result; 
+    for (auto member : rowType.GetItems()) { 
+        TStringBuf label, column; 
+        if (member->GetName().Contains('.')) { 
+            SplitTableName(member->GetName(), label, column); 
+        } else { 
+            column = member->GetName(); 
+        } 
+        if (label.empty() && tableLabel.empty()) { 
+            ctx.AddError(TIssue(TStringBuilder() << "Invalid join input type " << FormatType(&rowType))); 
+            result.clear(); 
+            return result; 
+        } 
         auto memberType = member->GetItemType();
         if (optional && !memberType->IsOptionalOrNull()) {
             memberType = ctx.MakeType<TOptionalExprType>(memberType);
         }
-        if (!tableLabel.empty()) {
+        if (!tableLabel.empty()) { 
             result[tableLabel][member->GetName()] = memberType;
-        } else {
+        } else { 
             result[label][column] = memberType;
-        }
-    }
-    return result;
-}
-
+        } 
+    } 
+    return result; 
+} 
+ 
 template <bool IsMapJoin>
-const TStructExprType* GetDqJoinResultType(TPositionHandle pos, const TStructExprType& leftRowType,
-    const TStringBuf& leftLabel, const TStructExprType& rightRowType, const TStringBuf& rightLabel,
-    const TStringBuf& joinType, const TDqJoinKeyTupleList& joinKeys, TExprContext& ctx)
-{
-    // check left
+const TStructExprType* GetDqJoinResultType(TPositionHandle pos, const TStructExprType& leftRowType, 
+    const TStringBuf& leftLabel, const TStructExprType& rightRowType, const TStringBuf& rightLabel, 
+    const TStringBuf& joinType, const TDqJoinKeyTupleList& joinKeys, TExprContext& ctx) 
+{ 
+    // check left 
     bool isLeftOptional = IsLeftJoinSideOptional(joinType);
     auto leftType = ParseJoinInputType(leftRowType, leftLabel, ctx, isLeftOptional);
     if (leftType.empty() && joinType != "Cross") {
         TStringStream str; str << "Cannot parse left join input type: ";
         leftRowType.Out(str);
         ctx.AddError(TIssue(ctx.GetPosition(pos), str.Str()));
-        return nullptr;
-    }
-
-    // check right
+        return nullptr; 
+    } 
+ 
+    // check right 
     bool isRightOptional = IsRightJoinSideOptional(joinType);
     auto rightType = ParseJoinInputType(rightRowType, rightLabel, ctx, isRightOptional);
     if (rightType.empty() && joinType != "Cross") {
         TStringStream str; str << "Cannot parse right join input type: ";
         rightRowType.Out(str);
         ctx.AddError(TIssue(ctx.GetPosition(pos), str.Str()));
-        return nullptr;
-    }
-
+        return nullptr; 
+    } 
+ 
     if constexpr (IsMapJoin) {
         if (joinType.StartsWith("Right") || joinType == "Cross") {
             ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder()
                 << "Unsupported map join type: " << joinType));
             return nullptr;
         }
-    }
-
-    // check join keys
-    if (joinKeys.Empty() && joinType != "Cross") {
-        ctx.AddError(TIssue(ctx.GetPosition(pos), "No join keys"));
-        return nullptr;
-    }
-
-    for (const auto& key : joinKeys) {
-        auto leftKeyLabel = key.LeftLabel().Value();
-        auto leftKeyColumn = key.LeftColumn().Value();
-        auto rightKeyLabel = key.RightLabel().Value();
-        auto rightKeyColumn = key.RightColumn().Value();
-
-        if (leftLabel && leftLabel != leftKeyLabel) {
-            ctx.AddError(TIssue(ctx.GetPosition(pos), "different labels for left table"));
-            return nullptr;
-        }
-        if (rightLabel && rightLabel != rightKeyLabel) {
-            ctx.AddError(TIssue(ctx.GetPosition(pos), "different labels for right table"));
-            return nullptr;
-        }
-
-        auto maybeLeftKeyType = leftType[leftKeyLabel].FindPtr(leftKeyColumn);
-        if (!maybeLeftKeyType) {
-            ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder()
-                << "Left key " << leftKeyLabel << "." << leftKeyColumn << " not found"));
-            return nullptr;
-        }
-
-        auto maybeRightKeyType = rightType[rightKeyLabel].FindPtr(rightKeyColumn);
-        if (!maybeRightKeyType) {
-            ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder()
-                << "Right key " << rightKeyLabel << "." << rightKeyColumn << " not found"));
-            return nullptr;
-        }
-
-        auto comparable = CanCompare<true>(*maybeLeftKeyType, *maybeRightKeyType);
-        if (comparable != ECompareOptions::Comparable && comparable != ECompareOptions::Optional) {
-            ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder()
-                << "Not comparable keys: " << leftKeyLabel << "." << leftKeyColumn
-                << " and " << rightKeyLabel << "." << rightKeyColumn << ", "
-                << FormatType(*maybeLeftKeyType) << " != " << FormatType(*maybeRightKeyType)));
-            return nullptr;
-        }
-    }
-
-    auto addAllMembersFrom = [&ctx](const THashMap<TStringBuf, THashMap<TStringBuf, const TTypeAnnotationNode*>>& type,
+    } 
+ 
+    // check join keys 
+    if (joinKeys.Empty() && joinType != "Cross") { 
+        ctx.AddError(TIssue(ctx.GetPosition(pos), "No join keys")); 
+        return nullptr; 
+    } 
+ 
+    for (const auto& key : joinKeys) { 
+        auto leftKeyLabel = key.LeftLabel().Value(); 
+        auto leftKeyColumn = key.LeftColumn().Value(); 
+        auto rightKeyLabel = key.RightLabel().Value(); 
+        auto rightKeyColumn = key.RightColumn().Value(); 
+ 
+        if (leftLabel && leftLabel != leftKeyLabel) { 
+            ctx.AddError(TIssue(ctx.GetPosition(pos), "different labels for left table")); 
+            return nullptr; 
+        } 
+        if (rightLabel && rightLabel != rightKeyLabel) { 
+            ctx.AddError(TIssue(ctx.GetPosition(pos), "different labels for right table")); 
+            return nullptr; 
+        } 
+ 
+        auto maybeLeftKeyType = leftType[leftKeyLabel].FindPtr(leftKeyColumn); 
+        if (!maybeLeftKeyType) { 
+            ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder() 
+                << "Left key " << leftKeyLabel << "." << leftKeyColumn << " not found")); 
+            return nullptr; 
+        } 
+ 
+        auto maybeRightKeyType = rightType[rightKeyLabel].FindPtr(rightKeyColumn); 
+        if (!maybeRightKeyType) { 
+            ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder() 
+                << "Right key " << rightKeyLabel << "." << rightKeyColumn << " not found")); 
+            return nullptr; 
+        } 
+ 
+        auto comparable = CanCompare<true>(*maybeLeftKeyType, *maybeRightKeyType); 
+        if (comparable != ECompareOptions::Comparable && comparable != ECompareOptions::Optional) { 
+            ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder() 
+                << "Not comparable keys: " << leftKeyLabel << "." << leftKeyColumn 
+                << " and " << rightKeyLabel << "." << rightKeyColumn << ", " 
+                << FormatType(*maybeLeftKeyType) << " != " << FormatType(*maybeRightKeyType))); 
+            return nullptr; 
+        } 
+    } 
+ 
+    auto addAllMembersFrom = [&ctx](const THashMap<TStringBuf, THashMap<TStringBuf, const TTypeAnnotationNode*>>& type, 
         TVector<const TItemExprType*>* result, bool makeOptional = false)
-    {
-        for (const auto& it : type) {
-            for (const auto& it2 : it.second) {
-                auto memberName = FullColumnName(it.first, it2.first);
+    { 
+        for (const auto& it : type) { 
+            for (const auto& it2 : it.second) { 
+                auto memberName = FullColumnName(it.first, it2.first); 
                 if (makeOptional && it2.second->GetKind() != ETypeAnnotationKind::Optional) {
                     result->emplace_back(ctx.MakeType<TItemExprType>(memberName, ctx.MakeType<TOptionalExprType>(it2.second)));
                 } else {
                     result->emplace_back(ctx.MakeType<TItemExprType>(memberName, it2.second));
                 }
-            }
-        }
-    };
-
-    TVector<const TItemExprType*> resultStructItems;
+            } 
+        } 
+    }; 
+ 
+    TVector<const TItemExprType*> resultStructItems; 
     if (joinType != "RightOnly" && joinType != "RightSemi") {
         addAllMembersFrom(leftType, &resultStructItems, joinType == "Right");
     }
     if (joinType != "LeftOnly" && joinType != "LeftSemi") {
         addAllMembersFrom(rightType, &resultStructItems, joinType == "Left");
-    }
-
-    auto rowType = ctx.MakeType<TStructExprType>(resultStructItems);
-    return rowType;
-}
-
+    } 
+ 
+    auto rowType = ctx.MakeType<TStructExprType>(resultStructItems); 
+    return rowType; 
+} 
+ 
 template <bool IsMapJoin>
 const TStructExprType* GetDqJoinResultType(const TExprNode::TPtr& input, bool stream, TExprContext& ctx) {
     if (!EnsureArgsCount(*input, 6, ctx)) {
         return nullptr;
     }
-
+ 
     if (!input->Child(TDqJoin::idx_LeftLabel)->IsCallable("Void")) {
         if (!EnsureAtom(*input->Child(TDqJoin::idx_LeftLabel), ctx)) {
             return nullptr;
@@ -334,44 +334,44 @@ const TStructExprType* GetDqJoinResultType(const TExprNode::TPtr& input, bool st
     auto leftInputType = join.LeftInput().Ref().GetTypeAnn();
     auto rightInputType = join.RightInput().Ref().GetTypeAnn();
 
-    if (stream) {
+    if (stream) { 
         if (!EnsureNewSeqType<false, false, true>(join.Pos(), *leftInputType, ctx)) {
-            return nullptr;
-        }
+            return nullptr; 
+        } 
         if (!EnsureNewSeqType<false, false, true>(join.Pos(), *rightInputType, ctx)) {
-            return nullptr;
-        }
-    } else {
+            return nullptr; 
+        } 
+    } else { 
         if (!EnsureNewSeqType<false, true, false>(join.Pos(), *leftInputType, ctx)) {
-            return nullptr;
-        }
+            return nullptr; 
+        } 
         if (!EnsureNewSeqType<false, true, false>(join.Pos(), *rightInputType, ctx)) {
-            return nullptr;
-        }
-    }
-
-    auto leftInputItemType = GetSeqItemType(leftInputType);
+            return nullptr; 
+        } 
+    } 
+ 
+    auto leftInputItemType = GetSeqItemType(leftInputType); 
     if (!EnsureStructType(join.Pos(), *leftInputItemType, ctx)) {
-        return nullptr;
-    }
-    auto leftStructType = leftInputItemType->Cast<TStructExprType>();
+        return nullptr; 
+    } 
+    auto leftStructType = leftInputItemType->Cast<TStructExprType>(); 
     auto leftTableLabel = join.LeftLabel().Maybe<TCoAtom>()
         ? join.LeftLabel().Cast<TCoAtom>().Value()
         : TStringBuf("");
-
-    auto rightInputItemType = GetSeqItemType(rightInputType);
+ 
+    auto rightInputItemType = GetSeqItemType(rightInputType); 
     if (!EnsureStructType(join.Pos(), *rightInputItemType, ctx)) {
-        return nullptr;
-    }
-    auto rightStructType = rightInputItemType->Cast<TStructExprType>();
+        return nullptr; 
+    } 
+    auto rightStructType = rightInputItemType->Cast<TStructExprType>(); 
     auto rightTableLabel = join.RightLabel().Maybe<TCoAtom>()
         ? join.RightLabel().Cast<TCoAtom>().Value()
         : TStringBuf("");
-
+ 
     return GetDqJoinResultType<IsMapJoin>(join.Pos(), *leftStructType, leftTableLabel, *rightStructType,
         rightTableLabel, join.JoinType(), join.JoinKeys(), ctx);
-}
-
+} 
+ 
 TStatus AnnotateDqPrecompute(const TExprNode::TPtr& node, TExprContext& ctx) {
     if (!EnsureArgsCount(*node, 1, ctx)) {
         return TStatus::Error;
@@ -814,8 +814,8 @@ THolder<IGraphTransformer> CreateDqTypeAnnotationTransformer(TTypeAnnotationCont
 
             if (TDqCnValue::Match(input.Get())) {
                 return AnnotateDqCnValue(input, ctx);
-            }
-
+            } 
+ 
             if (TDqCnMerge::Match(input.Get())) {
                 return AnnotateDqCnMerge(input, ctx);
             }
@@ -826,20 +826,20 @@ THolder<IGraphTransformer> CreateDqTypeAnnotationTransformer(TTypeAnnotationCont
 
             if (TDqJoin::Match(input.Get())) {
                 return AnnotateDqJoin(input, ctx);
-            }
-
+            } 
+ 
             if (TDqPhyMapJoin::Match(input.Get())) {
                 return AnnotateDqMapOrDictJoin(input, ctx);
-            }
-
+            } 
+ 
             if (TDqPhyJoinDict::Match(input.Get())) {
                 return AnnotateDqMapOrDictJoin(input, ctx);
             }
 
             if (TDqPhyCrossJoin::Match(input.Get())) {
                 return AnnotateDqCrossJoin(input, ctx);
-            }
-
+            } 
+ 
             if (TDqSource::Match(input.Get())) {
                 return AnnotateDqSource(input, ctx);
             }
diff --git a/ydb/library/yql/minikql/aligned_page_pool.cpp b/ydb/library/yql/minikql/aligned_page_pool.cpp
index e015c255c8..420c67694d 100644
--- a/ydb/library/yql/minikql/aligned_page_pool.cpp
+++ b/ydb/library/yql/minikql/aligned_page_pool.cpp
@@ -164,20 +164,20 @@ void TAlignedPagePool::OffloadAlloc(ui64 size) {
         throw TMemoryLimitExceededException();
     }
 
-    if (AllocNotifyCallback) {
-        if (AllocNotifyCurrentBytes > AllocNotifyBytes) {
-            AllocNotifyCallback();
-            AllocNotifyCurrentBytes = 0;
-        }
-    }
-
+    if (AllocNotifyCallback) { 
+        if (AllocNotifyCurrentBytes > AllocNotifyBytes) { 
+            AllocNotifyCallback(); 
+            AllocNotifyCurrentBytes = 0; 
+        } 
+    } 
+ 
     ++OffloadedAllocCount;
     OffloadedBytes += size;
     OffloadedActiveBytes += size;
     TotalAllocated += size;
-    if (AllocNotifyCallback) {
-        AllocNotifyCurrentBytes += size;
-    }
+    if (AllocNotifyCallback) { 
+        AllocNotifyCurrentBytes += size; 
+    } 
     if (Counters.TotalBytesAllocatedCntr) {
         (*Counters.TotalBytesAllocatedCntr) += size;
     }
@@ -212,9 +212,9 @@ void* TAlignedPagePool::GetPage() {
 
     if (const auto ptr = TGlobalPools::Instance().Get(0).GetPage()) {
         TotalAllocated += POOL_PAGE_SIZE;
-        if (AllocNotifyCallback) {
-            AllocNotifyCurrentBytes += POOL_PAGE_SIZE;
-        }
+        if (AllocNotifyCallback) { 
+            AllocNotifyCurrentBytes += POOL_PAGE_SIZE; 
+        } 
         if (Counters.TotalBytesAllocatedCntr) {
             (*Counters.TotalBytesAllocatedCntr) += POOL_PAGE_SIZE;
         }
@@ -265,22 +265,22 @@ void* TAlignedPagePool::Alloc(size_t size) {
         throw TMemoryLimitExceededException();
     }
 
-    if (AllocNotifyCallback) {
-        if (AllocNotifyCurrentBytes > AllocNotifyBytes) {
-            AllocNotifyCallback();
-            AllocNotifyCurrentBytes = 0;
-        }
-    }
-
+    if (AllocNotifyCallback) { 
+        if (AllocNotifyCurrentBytes > AllocNotifyBytes) { 
+            AllocNotifyCallback(); 
+            AllocNotifyCurrentBytes = 0; 
+        } 
+    } 
+ 
     if (size > TAlignedPagePool::POOL_PAGE_SIZE && size <= MaxMidSize) {
         size = FastClp2(size);
         auto level = LeastSignificantBit(size) - LeastSignificantBit(TAlignedPagePool::POOL_PAGE_SIZE);
         Y_VERIFY_DEBUG(level >= 1 && level <= MidLevels);
         if (res = TGlobalPools::Instance().Get(level).GetPage()) {
             TotalAllocated += size;
-            if (AllocNotifyCallback) {
-                AllocNotifyCurrentBytes += size;
-            }
+            if (AllocNotifyCallback) { 
+                AllocNotifyCurrentBytes += size; 
+            } 
             if (Counters.TotalBytesAllocatedCntr) {
                 (*Counters.TotalBytesAllocatedCntr) += size;
             }
@@ -298,9 +298,9 @@ void* TAlignedPagePool::Alloc(size_t size) {
         }
         Y_VERIFY((reinterpret_cast<uintptr_t>(res) & PAGE_ADDR_MASK) == reinterpret_cast<uintptr_t>(res), "Got unaligned address");
         TotalAllocated += size;
-        if (AllocNotifyCallback) {
-            AllocNotifyCurrentBytes += size;
-        }
+        if (AllocNotifyCallback) { 
+            AllocNotifyCurrentBytes += size; 
+        } 
         if (Counters.TotalBytesAllocatedCntr) {
             (*Counters.TotalBytesAllocatedCntr) += size;
         }
@@ -319,9 +319,9 @@ void* TAlignedPagePool::Alloc(size_t size) {
                 AllPages.emplace(extraPage);
                 FreePages.emplace(extraPage);
                 TotalAllocated += size + POOL_PAGE_SIZE;
-                if (AllocNotifyCallback) {
-                    AllocNotifyCurrentBytes += size + POOL_PAGE_SIZE;
-                }
+                if (AllocNotifyCallback) { 
+                    AllocNotifyCurrentBytes += size + POOL_PAGE_SIZE; 
+                } 
                 if (Counters.TotalBytesAllocatedCntr) {
                     (*Counters.TotalBytesAllocatedCntr) += size + POOL_PAGE_SIZE;
                 }
@@ -332,9 +332,9 @@ void* TAlignedPagePool::Alloc(size_t size) {
                         << ", " << (0 + POOL_PAGE_SIZE) << ") failed: " << LastSystemErrorText();
                 }
                 TotalAllocated += size;
-                if (AllocNotifyCallback) {
-                    AllocNotifyCurrentBytes += size;
-                }
+                if (AllocNotifyCallback) { 
+                    AllocNotifyCurrentBytes += size; 
+                } 
                 if (Counters.TotalBytesAllocatedCntr) {
                     (*Counters.TotalBytesAllocatedCntr) += size;
                 }
@@ -352,9 +352,9 @@ void* TAlignedPagePool::Alloc(size_t size) {
                     << ", " << (POOL_PAGE_SIZE - off) << ") failed: " << LastSystemErrorText();
             }
             TotalAllocated += size;
-            if (AllocNotifyCallback) {
-                AllocNotifyCurrentBytes += size;
-            }
+            if (AllocNotifyCallback) { 
+                AllocNotifyCurrentBytes += size; 
+            } 
             if (Counters.TotalBytesAllocatedCntr) {
                 (*Counters.TotalBytesAllocatedCntr) += size;
             }
@@ -394,10 +394,10 @@ void TAlignedPagePool::Free(void* ptr, size_t size) noexcept {
 }
 
 bool TAlignedPagePool::TryIncreaseLimit(ui64 required) {
-    if (!IncreaseMemoryLimitCallback) {
+    if (!IncreaseMemoryLimitCallback) { 
         return false;
     }
-    IncreaseMemoryLimitCallback(Limit, required);
+    IncreaseMemoryLimitCallback(Limit, required); 
     return Limit >= required;
 }
 
diff --git a/ydb/library/yql/minikql/aligned_page_pool.h b/ydb/library/yql/minikql/aligned_page_pool.h
index 2ef2878655..7f4bc5a479 100644
--- a/ydb/library/yql/minikql/aligned_page_pool.h
+++ b/ydb/library/yql/minikql/aligned_page_pool.h
@@ -31,9 +31,9 @@ struct TAlignedPagePoolCounters {
     }
 };
 
-// NOTE: We intentionally avoid inheritance from std::exception here to make it harder
-// to catch this exception in UDFs code, so we can handle it in the host.
-class TMemoryLimitExceededException {};
+// NOTE: We intentionally avoid inheritance from std::exception here to make it harder 
+// to catch this exception in UDFs code, so we can handle it in the host. 
+class TMemoryLimitExceededException {}; 
 
 class TAlignedPagePool {
 public:
@@ -98,8 +98,8 @@ public:
         DoSwap(OffloadedActiveBytes, other.OffloadedActiveBytes);
         DoSwap(Counters, other.Counters);
         DoSwap(CheckLostMem, other.CheckLostMem);
-        DoSwap(AllocNotifyCallback, other.AllocNotifyCallback);
-        DoSwap(IncreaseMemoryLimitCallback, other.IncreaseMemoryLimitCallback);
+        DoSwap(AllocNotifyCallback, other.AllocNotifyCallback); 
+        DoSwap(IncreaseMemoryLimitCallback, other.IncreaseMemoryLimitCallback); 
     }
 
     void PrintStat(size_t usedPages, IOutputStream& out) const;
@@ -163,17 +163,17 @@ public:
         CheckLostMem = false;
     }
 
-    using TAllocNotifyCallback = std::function<void()>;
-    void SetAllocNotifyCallback(TAllocNotifyCallback&& callback, ui64 notifyBytes = 0) {
-        AllocNotifyCallback = std::move(callback);
-        AllocNotifyBytes = notifyBytes;
-        AllocNotifyCurrentBytes = 0;
-    }
-
+    using TAllocNotifyCallback = std::function<void()>; 
+    void SetAllocNotifyCallback(TAllocNotifyCallback&& callback, ui64 notifyBytes = 0) { 
+        AllocNotifyCallback = std::move(callback); 
+        AllocNotifyBytes = notifyBytes; 
+        AllocNotifyCurrentBytes = 0; 
+    } 
+ 
     using TIncreaseMemoryLimitCallback = std::function<void(ui64 currentLimit, ui64 required)>;
 
     void SetIncreaseMemoryLimitCallback(TIncreaseMemoryLimitCallback&& callback) {
-        IncreaseMemoryLimitCallback = std::move(callback);
+        IncreaseMemoryLimitCallback = std::move(callback); 
     }
 
 protected:
@@ -209,11 +209,11 @@ protected:
     TAlignedPagePoolCounters Counters;
     bool CheckLostMem = true;
 
-    TAllocNotifyCallback AllocNotifyCallback;
-    ui64 AllocNotifyBytes = 0;
-    ui64 AllocNotifyCurrentBytes = 0;
-
-    TIncreaseMemoryLimitCallback IncreaseMemoryLimitCallback;
+    TAllocNotifyCallback AllocNotifyCallback; 
+    ui64 AllocNotifyBytes = 0; 
+    ui64 AllocNotifyCurrentBytes = 0; 
+ 
+    TIncreaseMemoryLimitCallback IncreaseMemoryLimitCallback; 
 };
 
 } // NKikimr
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_extend.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_extend.cpp
index 36fd03b0a4..a80564f91d 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_extend.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_extend.cpp
@@ -83,10 +83,10 @@ private:
     const TComputationNodePtrVector Flows;
 };
 
-template <bool IsStream>
+template <bool IsStream> 
 class TExtendWrapper : public TMutableCodegeneratorNode<TExtendWrapper<IsStream>> {
     typedef TMutableCodegeneratorNode<TExtendWrapper<IsStream>> TBaseComputation;
-public:
+public: 
     TExtendWrapper(TComputationMutables& mutables, TComputationNodePtrVector&& lists)
         : TBaseComputation(mutables, EValueRepresentation::Boxed)
         , Lists(std::move(lists))
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_extend.h b/ydb/library/yql/minikql/comp_nodes/mkql_extend.h
index 5a046b07e9..2861748069 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_extend.h
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_extend.h
@@ -6,5 +6,5 @@ namespace NMiniKQL {
 
 IComputationNode* WrapExtend(TCallable& callable, const TComputationNodeFactoryContext& ctx);
 
-} // namespace NMiniKQL
-} // namespace NKikimr
+} // namespace NMiniKQL 
+} // namespace NKikimr 
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_group.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_group.cpp
index 0d0ff62fae..7e1111cc80 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_group.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_group.cpp
@@ -63,10 +63,10 @@ public:
                 }
             }
 
-            Self->KeyExtractorItemNode->SetValue(CompCtx, NUdf::TUnboxedValue(Value));
+            Self->KeyExtractorItemNode->SetValue(CompCtx, NUdf::TUnboxedValue(Value)); 
             key = Self->KeyExtractorResultNode->GetValue(CompCtx);
-            Self->GroupSwitchKeyNode->SetValue(CompCtx, NUdf::TUnboxedValue(key));
-            Self->GroupSwitchItemNode->SetValue(CompCtx, NUdf::TUnboxedValue(Value));
+            Self->GroupSwitchKeyNode->SetValue(CompCtx, NUdf::TUnboxedValue(key)); 
+            Self->GroupSwitchItemNode->SetValue(CompCtx, NUdf::TUnboxedValue(Value)); 
             State = AtGroupStart;
 
             return NUdf::EFetchStatus::Ok;
@@ -89,7 +89,7 @@ public:
             }
 
             if (Fetching == State) {
-                Self->GroupSwitchItemNode->SetValue(CompCtx, NUdf::TUnboxedValue(Value));
+                Self->GroupSwitchItemNode->SetValue(CompCtx, NUdf::TUnboxedValue(Value)); 
                 if (Self->GroupSwitchResultNode->GetValue(CompCtx).template Get<bool>()) {
                     State = GroupFinished;
                     return NUdf::EFetchStatus::Finish;
@@ -152,7 +152,7 @@ public:
     TGroupingCoreWrapper(TComputationMutables& mutables,
         IComputationNode* stream,
         IComputationExternalNode* keyExtractorItem,
-        IComputationNode* keyExtractorResult,
+        IComputationNode* keyExtractorResult, 
         IComputationExternalNode* groupSwitchKey,
         IComputationExternalNode* groupSwitchItem,
         IComputationNode* groupSwitchResult,
@@ -160,10 +160,10 @@ public:
         IComputationNode* handlerResult)
         : TBaseComputation(mutables)
         , Stream(stream)
-        , KeyExtractorItemNode(keyExtractorItem)
-        , KeyExtractorResultNode(keyExtractorResult)
-        , GroupSwitchKeyNode(groupSwitchKey)
-        , GroupSwitchItemNode(groupSwitchItem)
+        , KeyExtractorItemNode(keyExtractorItem) 
+        , KeyExtractorResultNode(keyExtractorResult) 
+        , GroupSwitchKeyNode(groupSwitchKey) 
+        , GroupSwitchItemNode(groupSwitchItem) 
         , GroupSwitchResultNode(groupSwitchResult)
         , HandlerItemNode(handlerItem)
         , HandlerResultNode(handlerResult)
@@ -177,12 +177,12 @@ public:
 private:
     void RegisterDependencies() const final {
         this->DependsOn(Stream);
-        this->DependsOn(KeyExtractorResultNode);
+        this->DependsOn(KeyExtractorResultNode); 
         this->DependsOn(GroupSwitchResultNode);
         this->DependsOn(HandlerResultNode);
-        this->Own(KeyExtractorItemNode);
-        this->Own(GroupSwitchKeyNode);
-        this->Own(GroupSwitchItemNode);
+        this->Own(KeyExtractorItemNode); 
+        this->Own(GroupSwitchKeyNode); 
+        this->Own(GroupSwitchItemNode); 
         this->Own(HandlerItemNode);
     }
 
@@ -190,7 +190,7 @@ private:
     IComputationNode* const Stream;
 
     IComputationExternalNode* const KeyExtractorItemNode;
-    IComputationNode* const KeyExtractorResultNode;
+    IComputationNode* const KeyExtractorResultNode; 
 
     IComputationExternalNode* const GroupSwitchKeyNode;
     IComputationExternalNode* const GroupSwitchItemNode;
@@ -228,12 +228,12 @@ IComputationNode* WrapGroupingCore(TCallable& callable, const TComputationNodeFa
     }
 
     return new TGroupingCoreWrapper<false>(
-        ctx.Mutables,
-        stream,
-        keyExtractorItem,
-        keyExtractorResult,
-        groupSwitchKey,
-        groupSwitchItem,
+        ctx.Mutables, 
+        stream, 
+        keyExtractorItem, 
+        keyExtractorResult, 
+        groupSwitchKey, 
+        groupSwitchItem, 
         groupSwitchResult,
         nullptr,
         nullptr);
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_join.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_join.cpp
index d2182bbc23..2db2112bc6 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_join.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_join.cpp
@@ -1566,7 +1566,7 @@ private:
         FileState->Buffer.Reserve(length);
         wasRead = FileState->Input->Load((void*)FileState->Buffer.Data(), length);
         Y_VERIFY(wasRead == length);
-        return ItemPacker.Unpack(TStringBuf(FileState->Buffer.Data(), length), Ctx->HolderFactory);
+        return ItemPacker.Unpack(TStringBuf(FileState->Buffer.Data(), length), Ctx->HolderFactory); 
     }
 
 private:
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_sort.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_sort.cpp
index 2f67b24406..a12278a83b 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_sort.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_sort.cpp
@@ -189,7 +189,7 @@ using TComparator = std::function<bool(const TKeyPayloadPairVector::value_type&,
 using TAlgorithm = void(*)(TKeyPayloadPairVector::iterator, TKeyPayloadPairVector::iterator, TComparator);
 using TAlgorithmInplace = void(*)(TGatherIterator, TGatherIterator, TComparator);
 using TNthAlgorithm = void(*)(TKeyPayloadPairVector::iterator, TKeyPayloadPairVector::iterator, TKeyPayloadPairVector::iterator, TComparator);
-
+ 
 struct TCompareDescr {
     TCompareDescr(TComputationMutables& mutables, std::vector<std::tuple<NUdf::EDataSlot, bool, TType*>>&& keySchemeTypes)
         : KeySchemeTypes(std::move(keySchemeTypes))
@@ -358,7 +358,7 @@ public:
                 Description.MakeComparator<TKeyPayloadPairVector>(Ascending->GetValue(ctx)));
         }
     }
-
+ 
 protected:
     void RegisterDependencies() const override {
         this->DependsOn(List);
@@ -403,13 +403,13 @@ public:
             *inplace++ = std::move(item.second);
         }
         return result;
-    }
+    } 
 
     void PerformInplace(TComputationContext& ctx, ui32 size, NUdf::TUnboxedValue* keys, NUdf::TUnboxedValue* items, const TComparator& comparator) const {
         AlgorithmInplace(TGatherIterator(keys, items), TGatherIterator(keys, items) + size, comparator);
     }
 
-private:
+private: 
     const TAlgorithm Algorithm;
     const TAlgorithmInplace AlgorithmInplace;
 };
@@ -637,7 +637,7 @@ IComputationNode* WrapAlgo(TAlgorithm algorithm, TAlgorithmInplace algorithmInpl
     const auto key = LocateNode(ctx.NodeLocator, callable, 2);
     const auto ascending = LocateNode(ctx.NodeLocator, callable, 3);
     const auto itemArg = LocateExternalNode(ctx.NodeLocator, callable, 1);
-
+ 
     return new TAlgoWrapper(algorithm, algorithmInplace, ctx.Mutables, GetKeySchemeTypes(keyType, ascType), list,
         itemArg, key, ascending, stealed);
 }
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_todict.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_todict.cpp
index 2e299e487d..da1f2bb058 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_todict.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_todict.cpp
@@ -1,5 +1,5 @@
 #include "mkql_todict.h"
-
+ 
 #include <ydb/library/yql/minikql/computation/mkql_computation_list_adapter.h>
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_codegen.h>
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_holders.h>
@@ -23,12 +23,12 @@ namespace {
 
 class THashedMultiMapAccumulator {
     using TMapType = std::unordered_map<
-        NUdf::TUnboxedValue,
+        NUdf::TUnboxedValue, 
         TUnboxedValueVector,
         NYql::TVaryingHash<NUdf::TUnboxedValue, TValueHasher>,
-        TValueEqual,
+        TValueEqual, 
         TMKQLAllocator<std::pair<const NUdf::TUnboxedValue, TUnboxedValueVector>>>;
-
+ 
     TComputationContext& Ctx;
     TType* KeyType;
     const TKeyTypes& KeyTypes;
@@ -50,7 +50,7 @@ public:
     }
 
     void Add(NUdf::TUnboxedValue&& key, NUdf::TUnboxedValue&& payload)
-    {
+    { 
         if (Packer) {
             key = MakeString(Packer->Pack(key));
         }
@@ -63,31 +63,31 @@ public:
     }
 
     NUdf::TUnboxedValue Build()
-    {
+    { 
         const auto filler = [this](TValuesDictHashMap& targetMap) {
             targetMap.reserve(Map.size());
-
+ 
             for (auto& pair : Map) {
                 auto itemFactory = [](const NUdf::TUnboxedValuePod& value) {
-                    return value;
-                };
-
+                    return value; 
+                }; 
+ 
                 ui64 start = 0;
                 ui64 finish = pair.second.size();
-                auto payloadList = CreateOwningVectorListAdapter(std::move(pair.second), itemFactory,
+                auto payloadList = CreateOwningVectorListAdapter(std::move(pair.second), itemFactory, 
                     start, finish, false, Ctx.HolderFactory.GetMemInfo());
-
+ 
                 targetMap.emplace(pair.first, std::move(payloadList));
-            }
-        };
-
+            } 
+        }; 
+ 
         return Ctx.HolderFactory.CreateDirectHashedDictHolder(filler, KeyTypes, IsTuple, true, Packer ? KeyType : nullptr);
-    }
-};
-
+    } 
+}; 
+ 
 class THashedMapAccumulator {
     using TMapType = TValuesDictHashMap;
-
+ 
     TComputationContext& Ctx;
     TType* KeyType;
     const TKeyTypes& KeyTypes;
@@ -104,21 +104,21 @@ public:
             Packer.emplace(true, keyType);
         }
 
-        Y_UNUSED(payloadType);
+        Y_UNUSED(payloadType); 
         Map.reserve(itemsCountHint);
-    }
-
+    } 
+ 
     void Add(NUdf::TUnboxedValue&& key, NUdf::TUnboxedValue&& payload)
-    {
+    { 
         if (Packer) {
             key = MakeString(Packer->Pack(key));
         }
 
         Map.emplace(std::move(key), std::move(payload));
-    }
-
+    } 
+ 
     NUdf::TUnboxedValue Build()
-    {
+    { 
         const auto filler = [this](TMapType& targetMap) {
             targetMap = std::move(Map);
         };
@@ -127,15 +127,15 @@ public:
     }
 };
 
-template<typename T>
+template<typename T> 
 class THashedSingleFixedMultiMapAccumulator {
     using TMapType = std::unordered_map<
-        T,
+        T, 
         TUnboxedValueVector,
         NYql::TVaryingHash<T, TMyHash<T>>,
         TMyEquals<T>,
         TMKQLAllocator<std::pair<const T, TUnboxedValueVector>>>;
-
+ 
     TComputationContext& Ctx;
     const TKeyTypes& KeyTypes;
     TMapType Map;
@@ -143,77 +143,77 @@ class THashedSingleFixedMultiMapAccumulator {
 public:
     THashedSingleFixedMultiMapAccumulator(TType* keyType, TType* payloadType, const TKeyTypes& keyTypes, bool isTuple, bool encoded, TComputationContext& ctx, ui64 itemsCountHint)
         : Ctx(ctx), KeyTypes(keyTypes), Map(0, TMyHash<T>(), TMyEquals<T>())
-    {
+    { 
         Y_UNUSED(keyType);
-        Y_UNUSED(payloadType);
+        Y_UNUSED(payloadType); 
         Y_UNUSED(isTuple);
         Y_UNUSED(encoded);
         Map.reserve(itemsCountHint);
-    }
-
+    } 
+ 
     void Add(NUdf::TUnboxedValue&& key, NUdf::TUnboxedValue&& payload)
-    {
+    { 
         const auto ins = Map.emplace(key.Get<T>(), 1U);
         if (ins.second)
             ins.first->second.front() = std::move(payload);
         else
             ins.first->second.emplace_back(std::move(payload));
-    }
-
+    } 
+ 
     NUdf::TUnboxedValue Build()
-    {
+    { 
         const auto filler = [this](TValuesDictHashMap& targetMap) {
             targetMap.reserve(Map.size());
-
+ 
             for (auto& pair : Map) {
                 auto itemFactory = [](const NUdf::TUnboxedValuePod& value) {
-                    return value;
-                };
-
+                    return value; 
+                }; 
+ 
                 ui64 start = 0;
                 ui64 finish = pair.second.size();
-                auto payloadList = CreateOwningVectorListAdapter(std::move(pair.second), itemFactory,
+                auto payloadList = CreateOwningVectorListAdapter(std::move(pair.second), itemFactory, 
                     start, finish, false,
                     Ctx.HolderFactory.GetMemInfo());
-
+ 
                 targetMap.emplace(NUdf::TUnboxedValuePod(pair.first), std::move(payloadList));
-            }
-        };
-
+            } 
+        }; 
+ 
         return Ctx.HolderFactory.CreateDirectHashedDictHolder(filler, KeyTypes, false, true, nullptr);
-    }
-};
-
-template<typename T>
+    } 
+}; 
+ 
+template<typename T> 
 class THashedSingleFixedMapAccumulator {
     using TMapType = TValuesDictHashSingleFixedMap<T>;
-
+ 
     TComputationContext& Ctx;
     TMapType Map;
 
 public:
     THashedSingleFixedMapAccumulator(TType* keyType, TType* payloadType, const TKeyTypes& keyTypes, bool isTuple, bool encoded, TComputationContext& ctx, ui64 itemsCountHint)
         : Ctx(ctx), Map(0, TMyHash<T>(), TMyEquals<T>())
-    {
+    { 
         Y_UNUSED(keyType);
-        Y_UNUSED(payloadType);
+        Y_UNUSED(payloadType); 
         Y_UNUSED(keyTypes);
         Y_UNUSED(isTuple);
         Y_UNUSED(encoded);
         Map.reserve(itemsCountHint);
-    }
-
+    } 
+ 
     void Add(NUdf::TUnboxedValue&& key, NUdf::TUnboxedValue&& payload)
-    {
+    { 
         Map.emplace(key.Get<T>(), std::move(payload));
-    }
-
+    } 
+ 
     NUdf::TUnboxedValue Build()
-    {
+    { 
         return Ctx.HolderFactory.CreateDirectHashedSingleFixedMapHolder<T>(std::move(Map));
-    }
-};
-
+    } 
+}; 
+ 
 class THashedSetAccumulator {
     using TSetType = TValuesDictHashSet;
 
@@ -350,7 +350,7 @@ class THashedCompactMapAccumulator;
 template <>
 class THashedCompactMapAccumulator<false> {
     using TMapType = TValuesDictHashCompactMap;
-
+ 
     TComputationContext& Ctx;
     TPagedArena Pool;
     TMapType Map;
@@ -382,7 +382,7 @@ public:
 template <>
 class THashedCompactMapAccumulator<true> {
     using TMapType = TValuesDictHashCompactMultiMap;
-
+ 
     TComputationContext& Ctx;
     TPagedArena Pool;
     TMapType Map;
@@ -417,7 +417,7 @@ class THashedSingleFixedCompactMapAccumulator;
 template <typename T>
 class THashedSingleFixedCompactMapAccumulator<T, false> {
     using TMapType = TValuesDictHashSingleFixedCompactMap<T>;
-
+ 
     TComputationContext& Ctx;
     TPagedArena Pool;
     TMapType Map;
@@ -450,7 +450,7 @@ public:
 template <typename T>
 class THashedSingleFixedCompactMapAccumulator<T, true> {
     using TMapType = TValuesDictHashSingleFixedCompactMultiMap<T>;
-
+ 
     TComputationContext& Ctx;
     TPagedArena Pool;
     TMapType Map;
diff --git a/ydb/library/yql/minikql/comp_nodes/ut/mkql_chopper_ut.cpp b/ydb/library/yql/minikql/comp_nodes/ut/mkql_chopper_ut.cpp
index 8d9d557669..0217ce26bf 100644
--- a/ydb/library/yql/minikql/comp_nodes/ut/mkql_chopper_ut.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/ut/mkql_chopper_ut.cpp
@@ -43,7 +43,7 @@ TRuntimeNode GroupWithBomb(TSetup<UseLLVM>& setup, TRuntimeNode stream) {
 }
 
 template<bool UseLLVM>
-TRuntimeNode Group(TSetup<UseLLVM>& setup, TRuntimeNode stream, const std::function<TRuntimeNode(TRuntimeNode, TRuntimeNode)>& groupSwitch) {
+TRuntimeNode Group(TSetup<UseLLVM>& setup, TRuntimeNode stream, const std::function<TRuntimeNode(TRuntimeNode, TRuntimeNode)>& groupSwitch) { 
     TProgramBuilder& pb = *setup.PgmBuilder;
 
     const auto keyExtractor = [&](TRuntimeNode item) { return item; };
@@ -83,7 +83,7 @@ TRuntimeNode GroupGetKeysFirst(TSetup<UseLLVM>& setup, TRuntimeNode stream, cons
 }
 
 template<bool UseLLVM>
-TRuntimeNode GroupKeys(TSetup<UseLLVM>& setup, TRuntimeNode stream, const std::function<TRuntimeNode(TRuntimeNode, TRuntimeNode)>& groupSwitch) {
+TRuntimeNode GroupKeys(TSetup<UseLLVM>& setup, TRuntimeNode stream, const std::function<TRuntimeNode(TRuntimeNode, TRuntimeNode)>& groupSwitch) { 
     TProgramBuilder& pb = *setup.PgmBuilder;
 
     const auto keyExtractor = [&](TRuntimeNode item) { return item; };
@@ -132,8 +132,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLChopperStreamTest) {
         TProgramBuilder& pb = *setup.PgmBuilder;
 
         auto stream = MakeStream(setup);
-        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
-            Y_UNUSED(key);
+        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
+            Y_UNUSED(key); 
             return pb.Equals(item, pb.NewDataLiteral<ui64>(0));
         });
         const auto pgm = StreamToString(setup, stream);
@@ -163,30 +163,30 @@ Y_UNIT_TEST_SUITE(TMiniKQLChopperStreamTest) {
         UNIT_ASSERT_VALUES_EQUAL(TStringBuf(result.AsStringRef()), "|0:0|0:01|0:0|0:0|0:0123|");
     }
 
-    Y_UNIT_TEST_LLVM(TestGroupingKeyNotEquals) {
-        TSetup<LLVM> setup;
+    Y_UNIT_TEST_LLVM(TestGroupingKeyNotEquals) { 
+        TSetup<LLVM> setup; 
         TProgramBuilder& pb = *setup.PgmBuilder;
-
-        auto stream = MakeStream(setup);
-        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
+ 
+        auto stream = MakeStream(setup); 
+        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
             return pb.NotEquals(item, key);
-        });
+        }); 
         const auto pgm = StreamToString(setup, stream);
         const auto graph = setup.BuildGraph(pgm);
         const auto streamVal = graph->GetValue();
-        NUdf::TUnboxedValue result;
-        UNIT_ASSERT_EQUAL(streamVal.Fetch(result), NUdf::EFetchStatus::Ok);
-
-        UNIT_ASSERT_VALUES_EQUAL(TStringBuf(result.AsStringRef()), "|*00*00*|*11*|*00*00*00*|*11*|*22*|*33*|");
-    }
-
+        NUdf::TUnboxedValue result; 
+        UNIT_ASSERT_EQUAL(streamVal.Fetch(result), NUdf::EFetchStatus::Ok); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(TStringBuf(result.AsStringRef()), "|*00*00*|*11*|*00*00*00*|*11*|*22*|*33*|"); 
+    } 
+ 
     Y_UNIT_TEST_LLVM(TestGroupingWithEmptyInput) {
         TSetup<LLVM> setup;
         TProgramBuilder& pb = *setup.PgmBuilder;
 
         auto stream = MakeStream(setup, 0);
-        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
-            Y_UNUSED(key);
+        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
+            Y_UNUSED(key); 
             return pb.Equals(item, pb.NewDataLiteral<ui64>(0));
         });
         const auto pgm = StreamToString(setup, stream);
@@ -203,8 +203,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLChopperStreamTest) {
         TProgramBuilder& pb = *setup.PgmBuilder;
 
         auto stream = MakeStream(setup);
-        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
-            Y_UNUSED(key);
+        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
+            Y_UNUSED(key); 
             Y_UNUSED(item);
             return pb.NewDataLiteral<bool>(false);
         });
@@ -229,8 +229,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLChopperStreamTest) {
         stream = pb.Switch(stream,
                 MakeArrayRef(&switchInput, 1),
                 [&](ui32 /*index*/, TRuntimeNode item1) {
-                    return Group(setup, item1, [&](TRuntimeNode key, TRuntimeNode item2) {
-                        Y_UNUSED(key);
+                    return Group(setup, item1, [&](TRuntimeNode key, TRuntimeNode item2) { 
+                        Y_UNUSED(key); 
                         return pb.Equals(item2, pb.NewDataLiteral<ui64>(0));
                     });
                 },
@@ -253,8 +253,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLChopperStreamTest) {
 
         auto stream = MakeStream(setup);
 
-        stream = GroupKeys(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
-            Y_UNUSED(key);
+        stream = GroupKeys(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
+            Y_UNUSED(key); 
             return pb.Equals(item, pb.NewDataLiteral<ui64>(0));
         });
 
@@ -279,8 +279,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLChopperStreamTest) {
         stream = pb.Switch(stream,
                 MakeArrayRef(&switchInput, 1),
                 [&](ui32 /*index*/, TRuntimeNode item1) {
-                    return GroupKeys(setup, item1, [&](TRuntimeNode key, TRuntimeNode item2) {
-                        Y_UNUSED(key);
+                    return GroupKeys(setup, item1, [&](TRuntimeNode key, TRuntimeNode item2) { 
+                        Y_UNUSED(key); 
                         return pb.Equals(item2, pb.NewDataLiteral<ui64>(0));
                     });
                 },
diff --git a/ydb/library/yql/minikql/comp_nodes/ut/mkql_group_ut.cpp b/ydb/library/yql/minikql/comp_nodes/ut/mkql_group_ut.cpp
index 1833bbf509..78c217fe66 100644
--- a/ydb/library/yql/minikql/comp_nodes/ut/mkql_group_ut.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/ut/mkql_group_ut.cpp
@@ -48,7 +48,7 @@ TRuntimeNode Group(TSetup<UseLLVM>& setup, TRuntimeNode stream, const std::funct
 }
 
 template<bool UseLLVM>
-TRuntimeNode GroupKeys(TSetup<UseLLVM>& setup, TRuntimeNode stream, const std::function<TRuntimeNode(TRuntimeNode, TRuntimeNode)>& groupSwitch) {
+TRuntimeNode GroupKeys(TSetup<UseLLVM>& setup, TRuntimeNode stream, const std::function<TRuntimeNode(TRuntimeNode, TRuntimeNode)>& groupSwitch) { 
     TProgramBuilder& pgmBuilder = *setup.PgmBuilder;
 
     auto keyExtractor = [&](TRuntimeNode item) {
@@ -79,8 +79,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLGroupingTest) {
         TProgramBuilder& pgmBuilder = *setup.PgmBuilder;
 
         auto stream = MakeStream(setup);
-        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
-            Y_UNUSED(key);
+        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
+            Y_UNUSED(key); 
             return pgmBuilder.Equals(item, pgmBuilder.NewDataLiteral<ui64>(0));
         });
         auto pgm = StreamToString(setup, stream);
@@ -92,30 +92,30 @@ Y_UNIT_TEST_SUITE(TMiniKQLGroupingTest) {
         UNIT_ASSERT_VALUES_EQUAL(TStringBuf(result.AsStringRef()), "|*00*|*00*01*|*00*|*00*|*00*01*02*03*|");
     }
 
-    Y_UNIT_TEST_LLVM(TestGroupingKeyNotEquals) {
-        TSetup<LLVM> setup;
-        TProgramBuilder& pgmBuilder = *setup.PgmBuilder;
-
-        auto stream = MakeStream(setup);
-        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
+    Y_UNIT_TEST_LLVM(TestGroupingKeyNotEquals) { 
+        TSetup<LLVM> setup; 
+        TProgramBuilder& pgmBuilder = *setup.PgmBuilder; 
+ 
+        auto stream = MakeStream(setup); 
+        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
             return pgmBuilder.NotEquals(item, key);
-        });
-        auto pgm = StreamToString(setup, stream);
-        auto graph = setup.BuildGraph(pgm);
-        auto streamVal = graph->GetValue();
-        NUdf::TUnboxedValue result;
-        UNIT_ASSERT_EQUAL(streamVal.Fetch(result), NUdf::EFetchStatus::Ok);
-
-        UNIT_ASSERT_VALUES_EQUAL(TStringBuf(result.AsStringRef()), "|*00*00*|*11*|*00*00*00*|*11*|*22*|*33*|");
-    }
-
+        }); 
+        auto pgm = StreamToString(setup, stream); 
+        auto graph = setup.BuildGraph(pgm); 
+        auto streamVal = graph->GetValue(); 
+        NUdf::TUnboxedValue result; 
+        UNIT_ASSERT_EQUAL(streamVal.Fetch(result), NUdf::EFetchStatus::Ok); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(TStringBuf(result.AsStringRef()), "|*00*00*|*11*|*00*00*00*|*11*|*22*|*33*|"); 
+    } 
+ 
     Y_UNIT_TEST_LLVM(TestGroupingWithEmptyInput) {
         TSetup<LLVM> setup;
         TProgramBuilder& pgmBuilder = *setup.PgmBuilder;
 
         auto stream = MakeStream(setup, 0);
-        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
-            Y_UNUSED(key);
+        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
+            Y_UNUSED(key); 
             return pgmBuilder.Equals(item, pgmBuilder.NewDataLiteral<ui64>(0));
         });
         auto pgm = StreamToString(setup, stream);
@@ -132,8 +132,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLGroupingTest) {
         TProgramBuilder& pgmBuilder = *setup.PgmBuilder;
 
         auto stream = MakeStream(setup);
-        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
-            Y_UNUSED(key);
+        stream = Group(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
+            Y_UNUSED(key); 
             Y_UNUSED(item);
             return pgmBuilder.NewDataLiteral<bool>(false);
         });
@@ -158,8 +158,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLGroupingTest) {
         stream = pgmBuilder.Switch(stream,
                 MakeArrayRef(&switchInput, 1),
                 [&](ui32 /*index*/, TRuntimeNode item1) {
-                    return Group(setup, item1, [&](TRuntimeNode key, TRuntimeNode item2) {
-                        Y_UNUSED(key);
+                    return Group(setup, item1, [&](TRuntimeNode key, TRuntimeNode item2) { 
+                        Y_UNUSED(key); 
                         return pgmBuilder.Equals(item2, pgmBuilder.NewDataLiteral<ui64>(0));
                     });
                 },
@@ -182,8 +182,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLGroupingTest) {
 
         auto stream = MakeStream(setup);
 
-        stream = GroupKeys(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) {
-            Y_UNUSED(key);
+        stream = GroupKeys(setup, stream, [&](TRuntimeNode key, TRuntimeNode item) { 
+            Y_UNUSED(key); 
             return pgmBuilder.Equals(item, pgmBuilder.NewDataLiteral<ui64>(0));
         });
 
@@ -208,8 +208,8 @@ Y_UNIT_TEST_SUITE(TMiniKQLGroupingTest) {
         stream = pgmBuilder.Switch(stream,
                 MakeArrayRef(&switchInput, 1),
                 [&](ui32 /*index*/, TRuntimeNode item1) {
-                    return GroupKeys(setup, item1, [&](TRuntimeNode key, TRuntimeNode item2) {
-                        Y_UNUSED(key);
+                    return GroupKeys(setup, item1, [&](TRuntimeNode key, TRuntimeNode item2) { 
+                        Y_UNUSED(key); 
                         return pgmBuilder.Equals(item2, pgmBuilder.NewDataLiteral<ui64>(0));
                     });
                 },
diff --git a/ydb/library/yql/minikql/comp_nodes/ut/mkql_sort_ut.cpp b/ydb/library/yql/minikql/comp_nodes/ut/mkql_sort_ut.cpp
index 2457baabc0..a74a6005f6 100644
--- a/ydb/library/yql/minikql/comp_nodes/ut/mkql_sort_ut.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/ut/mkql_sort_ut.cpp
@@ -5,96 +5,96 @@
 #include <ydb/library/yql/minikql/mkql_node.h>
 #include <ydb/library/yql/minikql/mkql_program_builder.h>
 #include <ydb/library/yql/minikql/mkql_string_util.h>
-
+ 
 #include "mkql_computation_node_ut.h"
-
+ 
 #include <random>
 #include <ctime>
 #include <algorithm>
 
-namespace NKikimr {
-namespace NMiniKQL {
-
-namespace {
-
+namespace NKikimr { 
+namespace NMiniKQL { 
+ 
+namespace { 
+ 
 template <bool LLVM>
 TRuntimeNode MakeStream(TSetup<LLVM>& setup) {
-    TProgramBuilder& pgmBuilder = *setup.PgmBuilder;
-
+    TProgramBuilder& pgmBuilder = *setup.PgmBuilder; 
+ 
     TCallableBuilder callableBuilder(*setup.Env, "TestYieldStream",
-        pgmBuilder.NewStreamType(
-            pgmBuilder.NewStructType({
+        pgmBuilder.NewStreamType( 
+            pgmBuilder.NewStructType({ 
                 {TStringBuf("a"), pgmBuilder.NewDataType(NUdf::EDataSlot::Uint64)},
                 {TStringBuf("b"), pgmBuilder.NewDataType(NUdf::EDataSlot::String)}
-            })
-        )
-    );
-
-    return TRuntimeNode(callableBuilder.Build(), false);
-}
-
+            }) 
+        ) 
+    ); 
+ 
+    return TRuntimeNode(callableBuilder.Build(), false); 
+} 
+ 
 TRuntimeNode StreamToString(TProgramBuilder& pgmBuilder, TRuntimeNode stream) {
     return pgmBuilder.Condense(stream,
-        pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("|"),
+        pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("|"), 
             [&] (TRuntimeNode, TRuntimeNode) { return pgmBuilder.NewDataLiteral<bool>(false); },
-            [&] (TRuntimeNode item, TRuntimeNode state) {
-                auto str = pgmBuilder.Concat(
-                    pgmBuilder.Concat(
-                        pgmBuilder.ToString(pgmBuilder.Member(item, "a")),
-                        pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("-")
-                    ),
-                    pgmBuilder.Member(item, "b")
-                );
-
-                return pgmBuilder.Concat(pgmBuilder.Concat(state, str),
-                    pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("|"));
+            [&] (TRuntimeNode item, TRuntimeNode state) { 
+                auto str = pgmBuilder.Concat( 
+                    pgmBuilder.Concat( 
+                        pgmBuilder.ToString(pgmBuilder.Member(item, "a")), 
+                        pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("-") 
+                    ), 
+                    pgmBuilder.Member(item, "b") 
+                ); 
+ 
+                return pgmBuilder.Concat(pgmBuilder.Concat(state, str), 
+                    pgmBuilder.NewDataLiteral<NUdf::EDataSlot::String>("|")); 
             }
         );
-}
-
-} // namespace
-
-Y_UNIT_TEST_SUITE(TMiniKQLSortTest) {
+} 
+ 
+} // namespace 
+ 
+Y_UNIT_TEST_SUITE(TMiniKQLSortTest) { 
     Y_UNIT_TEST_LLVM(TestStreamSort) {
         TSetup<LLVM> setup;
-        TProgramBuilder& pgmBuilder = *setup.PgmBuilder;
-
-        auto stream = MakeStream(setup);
+        TProgramBuilder& pgmBuilder = *setup.PgmBuilder; 
+ 
+        auto stream = MakeStream(setup); 
         std::vector<TRuntimeNode> order {
-            pgmBuilder.NewDataLiteral<bool>(true),
-            pgmBuilder.NewDataLiteral<bool>(false)
-        };
-        auto sort = pgmBuilder.Sort(stream, pgmBuilder.NewTuple(order),
-            [&pgmBuilder](TRuntimeNode item) {
+            pgmBuilder.NewDataLiteral<bool>(true), 
+            pgmBuilder.NewDataLiteral<bool>(false) 
+        }; 
+        auto sort = pgmBuilder.Sort(stream, pgmBuilder.NewTuple(order), 
+            [&pgmBuilder](TRuntimeNode item) { 
                 std::vector<TRuntimeNode> keys {
-                    pgmBuilder.Member(item, "a"),
-                    pgmBuilder.Member(item, "b")
-                };
-
-                return pgmBuilder.NewTuple(keys);
-            });
-
+                    pgmBuilder.Member(item, "a"), 
+                    pgmBuilder.Member(item, "b") 
+                }; 
+ 
+                return pgmBuilder.NewTuple(keys); 
+            }); 
+ 
         auto pgmResult = StreamToString(pgmBuilder, sort);
-
-        auto graph = setup.BuildGraph(pgmResult);
-        auto value = graph->GetValue();
-
-
-        NUdf::TUnboxedValue result;
+ 
+        auto graph = setup.BuildGraph(pgmResult); 
+        auto value = graph->GetValue(); 
+ 
+ 
+        NUdf::TUnboxedValue result; 
         auto yieldCount = 0U;
-        auto status = NUdf::EFetchStatus::Ok;
-        while (status != NUdf::EFetchStatus::Finish) {
-            status = value.Fetch(result);
-            if (status == NUdf::EFetchStatus::Yield) {
-                ++yieldCount;
-            }
-        }
-
-        UNIT_ASSERT_EQUAL(status, NUdf::EFetchStatus::Finish);
+        auto status = NUdf::EFetchStatus::Ok; 
+        while (status != NUdf::EFetchStatus::Finish) { 
+            status = value.Fetch(result); 
+            if (status == NUdf::EFetchStatus::Yield) { 
+                ++yieldCount; 
+            } 
+        } 
+ 
+        UNIT_ASSERT_EQUAL(status, NUdf::EFetchStatus::Finish); 
         UNIT_ASSERT_EQUAL(yieldCount, 3U);
-        UNIT_ASSERT_VALUES_EQUAL(TStringBuf(result.AsStringRef()),
-            "|0-8|0-4|0-11|0-0|1-9|1-6|1-13|1-1|2-7|2-2|2-14|2-10|");
-    }
+        UNIT_ASSERT_VALUES_EQUAL(TStringBuf(result.AsStringRef()), 
+            "|0-8|0-4|0-11|0-0|1-9|1-6|1-13|1-1|2-7|2-2|2-14|2-10|"); 
+    } 
 
     Y_UNIT_TEST_LLVM(TestFlowSortByLambdaComparator) {
         TSetup<LLVM> setup;
@@ -516,6 +516,6 @@ Y_UNIT_TEST_SUITE(TMiniKQLSortTest) {
         UNIT_ASSERT_VALUES_EQUAL(res.size(), n);
         UNIT_ASSERT(copy == res);
     }
-}
-} // NMiniKQL
-} // NKikimr
+} 
+} // NMiniKQL 
+} // NKikimr 
diff --git a/ydb/library/yql/minikql/comp_nodes/ut/ya.make b/ydb/library/yql/minikql/comp_nodes/ut/ya.make
index dffda1318f..76f09f91d7 100644
--- a/ydb/library/yql/minikql/comp_nodes/ut/ya.make
+++ b/ydb/library/yql/minikql/comp_nodes/ut/ya.make
@@ -40,7 +40,7 @@ SRCS(
     mkql_join_dict_ut.cpp
     mkql_map_join_ut.cpp
     mkql_safe_circular_buffer_ut.cpp
-    mkql_sort_ut.cpp
+    mkql_sort_ut.cpp 
     mkql_switch_ut.cpp
     mkql_todict_ut.cpp
     mkql_variant_ut.cpp
diff --git a/ydb/library/yql/minikql/computation/mkql_computation_list_adapter.h b/ydb/library/yql/minikql/computation/mkql_computation_list_adapter.h
index 2b3b7fb886..c690a811c5 100644
--- a/ydb/library/yql/minikql/computation/mkql_computation_list_adapter.h
+++ b/ydb/library/yql/minikql/computation/mkql_computation_list_adapter.h
@@ -209,39 +209,39 @@ private:
 
 template <typename TVectorType>
 class TOwningVectorListAdapter : private TVectorType, public TVectorListAdapter<TVectorType> {
-public:
+public: 
     using TAdapterBase = TVectorListAdapter<TVectorType>;
-
-    TOwningVectorListAdapter(
-            TMemoryUsageInfo* memInfo,
+ 
+    TOwningVectorListAdapter( 
+            TMemoryUsageInfo* memInfo, 
             TVectorType&& list,
-            typename TAdapterBase::TItemFactory itemFactory,
-            ui64 start, ui64 finish,
-            bool reversed)
+            typename TAdapterBase::TItemFactory itemFactory, 
+            ui64 start, ui64 finish, 
+            bool reversed) 
         : TVectorType(std::move(list))
         , TAdapterBase(memInfo, *this, itemFactory, start, finish, reversed) {}
-
-    TOwningVectorListAdapter(
-            TMemoryUsageInfo* memInfo,
+ 
+    TOwningVectorListAdapter( 
+            TMemoryUsageInfo* memInfo, 
             const TVectorType& list,
-            typename TAdapterBase::TItemFactory itemFactory,
-            ui64 start, ui64 finish,
-            bool reversed)
+            typename TAdapterBase::TItemFactory itemFactory, 
+            ui64 start, ui64 finish, 
+            bool reversed) 
         : TVectorType(list)
         , TAdapterBase(memInfo, *this, itemFactory, start, finish, reversed) {}
-};
-
+}; 
+ 
 template<typename TVectorType>
 NUdf::TUnboxedValue CreateOwningVectorListAdapter(
     TVectorType&& list,
     typename TVectorListAdapter<std::remove_reference_t<TVectorType>>::TItemFactory itemFactory,
-    ui64 start, ui64 finish,
-    bool reversed,
-    TMemoryUsageInfo& memInfo)
-{
+    ui64 start, ui64 finish, 
+    bool reversed, 
+    TMemoryUsageInfo& memInfo) 
+{ 
     return NUdf::TUnboxedValuePod(new TOwningVectorListAdapter<std::remove_reference_t<TVectorType>>(
         &memInfo, std::forward<TVectorType>(list), itemFactory, start, finish, reversed));
 }
-
-}
+ 
 }
+} 
diff --git a/ydb/library/yql/minikql/computation/mkql_computation_node_graph.cpp b/ydb/library/yql/minikql/computation/mkql_computation_node_graph.cpp
index f2b188ae47..c6b00be036 100644
--- a/ydb/library/yql/minikql/computation/mkql_computation_node_graph.cpp
+++ b/ydb/library/yql/minikql/computation/mkql_computation_node_graph.cpp
@@ -496,14 +496,14 @@ public:
     }
 
 private:
-    void PushBackNode(const IComputationNode::TPtr& computationNode) {
+    void PushBackNode(const IComputationNode::TPtr& computationNode) { 
         computationNode->RegisterDependencies();
-        PatternNodes->ComputationNodesList.push_back(computationNode);
+        PatternNodes->ComputationNodesList.push_back(computationNode); 
     }
 
-    void AddNode(TNode& node, const IComputationNode::TPtr& computationNode) {
+    void AddNode(TNode& node, const IComputationNode::TPtr& computationNode) { 
         PushBackNode(computationNode);
-        node.SetCookie((ui64)computationNode.Get());
+        node.SetCookie((ui64)computationNode.Get()); 
     }
 
 private:
diff --git a/ydb/library/yql/minikql/computation/mkql_computation_node_pack.cpp b/ydb/library/yql/minikql/computation/mkql_computation_node_pack.cpp
index 625a269eaf..133043f755 100644
--- a/ydb/library/yql/minikql/computation/mkql_computation_node_pack.cpp
+++ b/ydb/library/yql/minikql/computation/mkql_computation_node_pack.cpp
@@ -418,7 +418,7 @@ NUdf::TUnboxedValue TValuePacker::Unpack(TStringBuf buf, const THolderFactory& h
 
 NUdf::TUnboxedValue TValuePacker::UnpackImpl(const TType* type, TStringBuf& buf, ui32 topLength,
     const THolderFactory& holderFactory) const
-{
+{ 
     switch (type->GetKind()) {
     case TType::EKind::Void:
         return NUdf::TUnboxedValuePod::Void();
@@ -538,7 +538,7 @@ NUdf::TUnboxedValue TValuePacker::UnpackImpl(const TType* type, TStringBuf& buf,
         auto res = holderFactory.CreateDirectArrayHolder(structType->GetMembersCount(), itemsPtr);
         for (ui32 index = 0; index < structType->GetMembersCount(); ++index) {
             auto memberType = structType->GetMemberType(index);
-            itemsPtr[index] = UnpackImpl(memberType, buf, topLength, holderFactory);
+            itemsPtr[index] = UnpackImpl(memberType, buf, topLength, holderFactory); 
         }
         return std::move(res);
     }
@@ -549,7 +549,7 @@ NUdf::TUnboxedValue TValuePacker::UnpackImpl(const TType* type, TStringBuf& buf,
         auto res = holderFactory.CreateDirectArrayHolder(tupleType->GetElementsCount(), itemsPtr);
         for (ui32 index = 0; index < tupleType->GetElementsCount(); ++index) {
             auto elementType = tupleType->GetElementType(index);
-            itemsPtr[index] = UnpackImpl(elementType, buf, topLength, holderFactory);
+            itemsPtr[index] = UnpackImpl(elementType, buf, topLength, holderFactory); 
         }
         return std::move(res);
     }
@@ -562,8 +562,8 @@ NUdf::TUnboxedValue TValuePacker::UnpackImpl(const TType* type, TStringBuf& buf,
 
         ui64 len = NDetails::UnpackUInt64(buf);
         for (ui64 i = 0; i < len; ++i) {
-            auto key = UnpackImpl(keyType, buf, topLength, holderFactory);
-            auto payload = UnpackImpl(payloadType, buf, topLength, holderFactory);
+            auto key = UnpackImpl(keyType, buf, topLength, holderFactory); 
+            auto payload = UnpackImpl(payloadType, buf, topLength, holderFactory); 
             dictBuilder->Add(std::move(key), std::move(payload));
         }
         return dictBuilder->Build();
@@ -762,7 +762,7 @@ void TValuePacker::PackImpl(const TType* type, const NUdf::TUnboxedValuePod& val
     case TType::EKind::List: {
         auto listType = static_cast<const TListType*>(type);
         auto itemType = listType->GetItemType();
-        if (value.HasFastListLength()) {
+        if (value.HasFastListLength()) { 
             auto len = value.GetListLength();
             NDetails::PackUInt64(len, Buffer);
             if (len) {
@@ -774,18 +774,18 @@ void TValuePacker::PackImpl(const TType* type, const NUdf::TUnboxedValuePod& val
                     for (NUdf::TUnboxedValue item; iter.Next(item); PackImpl(itemType, item))
                         continue;
                 }
-            }
-        } else {
+            } 
+        } else { 
             TUnboxedValueVector items;
             const auto iter = value.GetListIterator();
             for (NUdf::TUnboxedValue item; iter.Next(item);) {
                 items.emplace_back(std::move(item));
-            }
-
-            NDetails::PackUInt64(items.size(), Buffer);
-            for (const auto& item : items) {
-                PackImpl(itemType, item);
-            }
+            } 
+ 
+            NDetails::PackUInt64(items.size(), Buffer); 
+            for (const auto& item : items) { 
+                PackImpl(itemType, item); 
+            } 
         }
         break;
     }
diff --git a/ydb/library/yql/minikql/computation/mkql_validate_ut.cpp b/ydb/library/yql/minikql/computation/mkql_validate_ut.cpp
index ed2f12303a..cd692de58e 100644
--- a/ydb/library/yql/minikql/computation/mkql_validate_ut.cpp
+++ b/ydb/library/yql/minikql/computation/mkql_validate_ut.cpp
@@ -33,8 +33,8 @@ NUdf::TUnboxedValue ToUnboxedValue(const T& val) {
 
 NUdf::TUnboxedValue ToUnboxedValue(const TString& val) {
     return MakeString(val);
-}
-
+} 
+ 
 NUdf::TUnboxedValue ToUnboxedValue(const NUdf::IBoxedValuePtr& val) {
     return NUdf::TUnboxedValuePod(NUdf::IBoxedValuePtr(val));
 }
diff --git a/ydb/library/yql/minikql/defs.h b/ydb/library/yql/minikql/defs.h
index 3e332363c6..7fc8fb7d7b 100644
--- a/ydb/library/yql/minikql/defs.h
+++ b/ydb/library/yql/minikql/defs.h
@@ -29,8 +29,8 @@
             (THROW yexception() << __FUNCTION__ << "(): requirement " \
                 << #condition << " failed. " << "" __VA_ARGS__);      \
         }                                                             \
-    } while (0)
-
+    } while (0) 
+ 
 namespace NKikimr {
 
 template <typename T>
diff --git a/ydb/library/yql/minikql/mkql_alloc.cpp b/ydb/library/yql/minikql/mkql_alloc.cpp
index 9b77147a26..a1ef4c3536 100644
--- a/ydb/library/yql/minikql/mkql_alloc.cpp
+++ b/ydb/library/yql/minikql/mkql_alloc.cpp
@@ -53,14 +53,14 @@ void TAllocState::KillAllBoxed() {
 #endif
 }
 
-void TAllocState::InvalidateMemInfo() {
+void TAllocState::InvalidateMemInfo() { 
 #ifndef NDEBUG
-    for (auto& pair : ActiveMemInfo) {
-        pair.first->CheckOnExit(false);
-    }
+    for (auto& pair : ActiveMemInfo) { 
+        pair.first->CheckOnExit(false); 
+    } 
 #endif
-}
-
+} 
+ 
 size_t TAllocState::GetDeallocatedInPages() const {
     size_t deallocated = 0;
     for (auto x : AllPages) {
@@ -79,15 +79,15 @@ void* MKQLAllocSlow(size_t sz, TAllocState* state) {
     auto currPage = (TAllocPageHeader*)state->GetBlock(capacity);
     currPage->Deallocated = 0;
     currPage->Capacity = capacity;
-    currPage->Offset = roundedSize;
-
-    auto newPageAvailable = capacity - roundedSize;
-    auto curPageAvailable = state->CurrentPage->Capacity - state->CurrentPage->Offset;
-
-    if (newPageAvailable > curPageAvailable) {
-        state->CurrentPage = currPage;
-    }
-
+    currPage->Offset = roundedSize; 
+ 
+    auto newPageAvailable = capacity - roundedSize; 
+    auto curPageAvailable = state->CurrentPage->Capacity - state->CurrentPage->Offset; 
+ 
+    if (newPageAvailable > curPageAvailable) { 
+        state->CurrentPage = currPage; 
+    } 
+ 
     void* ret = (char*)currPage + sizeof(TAllocPageHeader);
     currPage->UseCount = 1;
     currPage->Link = nullptr;
diff --git a/ydb/library/yql/minikql/mkql_alloc.h b/ydb/library/yql/minikql/mkql_alloc.h
index 5e864cdc4c..262680875e 100644
--- a/ydb/library/yql/minikql/mkql_alloc.h
+++ b/ydb/library/yql/minikql/mkql_alloc.h
@@ -64,7 +64,7 @@ struct TAllocState : public TAlignedPagePool
 
     explicit TAllocState(const TAlignedPagePoolCounters& counters, bool supportsSizedAllocators);
     void KillAllBoxed();
-    void InvalidateMemInfo();
+    void InvalidateMemInfo(); 
     size_t GetDeallocatedInPages() const;
 };
 
@@ -117,7 +117,7 @@ public:
     void DisableStrictAllocationCheck() { MyState_.DisableStrictAllocationCheck(); }
 
     void ReleaseFreePages() { MyState_.ReleaseFreePages(); }
-    void InvalidateMemInfo() { MyState_.InvalidateMemInfo(); }
+    void InvalidateMemInfo() { MyState_.InvalidateMemInfo(); } 
 
     bool IsAttached() const { return AttachedCount_ > 0; }
 
diff --git a/ydb/library/yql/minikql/mkql_node.cpp b/ydb/library/yql/minikql/mkql_node.cpp
index 4c6f3e45ad..b57cb19b7d 100644
--- a/ydb/library/yql/minikql/mkql_node.cpp
+++ b/ydb/library/yql/minikql/mkql_node.cpp
@@ -1535,7 +1535,7 @@ TCallable::TCallable(TRuntimeNode result, TCallableType* type, bool validate)
         return;
     }
 
-    MKQL_ENSURE(result.GetStaticType()->IsSameType(*type->GetReturnType()), "incorrect result type for callable: "
+    MKQL_ENSURE(result.GetStaticType()->IsSameType(*type->GetReturnType()), "incorrect result type for callable: " 
         << GetType()->GetName());
     Result.Freeze();
 }
diff --git a/ydb/library/yql/minikql/mkql_node_visitor.cpp b/ydb/library/yql/minikql/mkql_node_visitor.cpp
index 5a4ac8e479..08ac4135a4 100644
--- a/ydb/library/yql/minikql/mkql_node_visitor.cpp
+++ b/ydb/library/yql/minikql/mkql_node_visitor.cpp
@@ -308,7 +308,7 @@ void TExploringNodeVisitor::Visit(TTypeType& node) {
 }
 
 void TExploringNodeVisitor::Visit(TVoidType& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
 }
 
 void TExploringNodeVisitor::Visit(TNullType& node) {
@@ -324,66 +324,66 @@ void TExploringNodeVisitor::Visit(TEmptyDictType& node) {
 }
 
 void TExploringNodeVisitor::Visit(TDataType& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
 }
 
 void TExploringNodeVisitor::Visit(TStructType& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
     for (ui32 i = 0, e = node.GetMembersCount(); i < e; ++i) {
-        AddChildNode(&node, *node.GetMemberType(i));
+        AddChildNode(&node, *node.GetMemberType(i)); 
     }
 }
 
 void TExploringNodeVisitor::Visit(TListType& node) {
-    AddChildNode(&node, *node.GetType());
-    AddChildNode(&node, *node.GetItemType());
+    AddChildNode(&node, *node.GetType()); 
+    AddChildNode(&node, *node.GetItemType()); 
 }
 
 void TExploringNodeVisitor::Visit(TOptionalType& node) {
-    AddChildNode(&node, *node.GetType());
-    AddChildNode(&node, *node.GetItemType());
+    AddChildNode(&node, *node.GetType()); 
+    AddChildNode(&node, *node.GetItemType()); 
 }
 
 void TExploringNodeVisitor::Visit(TDictType& node) {
-    AddChildNode(&node, *node.GetType());
-    AddChildNode(&node, *node.GetKeyType());
-    AddChildNode(&node, *node.GetPayloadType());
+    AddChildNode(&node, *node.GetType()); 
+    AddChildNode(&node, *node.GetKeyType()); 
+    AddChildNode(&node, *node.GetPayloadType()); 
 }
 
 void TExploringNodeVisitor::Visit(TCallableType& node) {
-    AddChildNode(&node, *node.GetType());
-    AddChildNode(&node, *node.GetReturnType());
+    AddChildNode(&node, *node.GetType()); 
+    AddChildNode(&node, *node.GetReturnType()); 
     for (ui32 i = 0, e = node.GetArgumentsCount(); i < e; ++i) {
-        AddChildNode(&node, *node.GetArgumentType(i));
+        AddChildNode(&node, *node.GetArgumentType(i)); 
     }
 
     if (node.GetPayload()) {
-        AddChildNode(&node, *node.GetPayload());
+        AddChildNode(&node, *node.GetPayload()); 
     }
 }
 
 void TExploringNodeVisitor::Visit(TAnyType& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
 }
 
 void TExploringNodeVisitor::Visit(TTupleType& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
     for (ui32 i = 0, e = node.GetElementsCount(); i < e; ++i) {
-        AddChildNode(&node, *node.GetElementType(i));
+        AddChildNode(&node, *node.GetElementType(i)); 
     }
 }
 
 void TExploringNodeVisitor::Visit(TResourceType& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
 }
 
 void TExploringNodeVisitor::Visit(TVariantType& node) {
-    AddChildNode(&node, *node.GetType());
-    AddChildNode(&node, *node.GetUnderlyingType());
+    AddChildNode(&node, *node.GetType()); 
+    AddChildNode(&node, *node.GetUnderlyingType()); 
 }
 
 void TExploringNodeVisitor::Visit(TVoid& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
 }
 
 void TExploringNodeVisitor::Visit(TNull& node) {
@@ -399,71 +399,71 @@ void TExploringNodeVisitor::Visit(TEmptyDict& node) {
 }
 
 void TExploringNodeVisitor::Visit(TDataLiteral& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
 }
 
 void TExploringNodeVisitor::Visit(TStructLiteral& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
     for (ui32 i = 0, e = node.GetValuesCount(); i < e; ++i) {
-        AddChildNode(&node, *node.GetValue(i).GetNode());
+        AddChildNode(&node, *node.GetValue(i).GetNode()); 
     }
 }
 
 void TExploringNodeVisitor::Visit(TListLiteral& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
     for (ui32 i = 0; i < node.GetItemsCount(); ++i) {
         AddChildNode(&node, *node.GetItems()[i].GetNode());
     }
 }
 
 void TExploringNodeVisitor::Visit(TOptionalLiteral& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
     if (node.HasItem()) {
-        AddChildNode(&node, *node.GetItem().GetNode());
+        AddChildNode(&node, *node.GetItem().GetNode()); 
     }
 }
 
 void TExploringNodeVisitor::Visit(TDictLiteral& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
     for (ui32 i = 0, e = node.GetItemsCount(); i < e; ++i) {
         auto item = node.GetItem(i);
-        AddChildNode(&node, *item.first.GetNode());
-        AddChildNode(&node, *item.second.GetNode());
+        AddChildNode(&node, *item.first.GetNode()); 
+        AddChildNode(&node, *item.second.GetNode()); 
     }
 }
 
 void TExploringNodeVisitor::Visit(TCallable& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
     for (ui32 i = 0, e = node.GetInputsCount(); i < e; ++i) {
-        AddChildNode(&node, *node.GetInput(i).GetNode());
+        AddChildNode(&node, *node.GetInput(i).GetNode()); 
     }
 
     if (node.HasResult())
-        AddChildNode(&node, *node.GetResult().GetNode());
+        AddChildNode(&node, *node.GetResult().GetNode()); 
 }
 
 void TExploringNodeVisitor::Visit(TAny& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
     if (node.HasItem()) {
         AddChildNode(&node, *node.GetItem().GetNode());
     }
 }
 
 void TExploringNodeVisitor::Visit(TTupleLiteral& node) {
-    AddChildNode(&node, *node.GetType());
+    AddChildNode(&node, *node.GetType()); 
     for (ui32 i = 0, e = node.GetValuesCount(); i < e; ++i) {
-        AddChildNode(&node, *node.GetValue(i).GetNode());
+        AddChildNode(&node, *node.GetValue(i).GetNode()); 
     }
 }
 
 void TExploringNodeVisitor::Visit(TVariantLiteral& node) {
-    AddChildNode(&node, *node.GetType());
-    AddChildNode(&node, *node.GetItem().GetNode());
+    AddChildNode(&node, *node.GetType()); 
+    AddChildNode(&node, *node.GetItem().GetNode()); 
 }
 
 void TExploringNodeVisitor::Visit(TStreamType& node) {
-    AddChildNode(&node, *node.GetType());
-    AddChildNode(&node, *node.GetItemType());
+    AddChildNode(&node, *node.GetType()); 
+    AddChildNode(&node, *node.GetItemType()); 
 }
 
 void TExploringNodeVisitor::Visit(TFlowType& node) {
@@ -481,41 +481,41 @@ void TExploringNodeVisitor::Visit(TBlockType& node) {
     AddChildNode(&node, *node.GetItemType());
 }
 
-void TExploringNodeVisitor::AddChildNode(TNode* parent, TNode& child) {
-    Stack->push_back(&child);
-
-    if (BuildConsumersMap) {
-        if (parent != nullptr) {
-            ConsumersMap[&child].push_back(parent);
-        } else {
-            ConsumersMap[&child] = {};
-        }
-    }
+void TExploringNodeVisitor::AddChildNode(TNode* parent, TNode& child) { 
+    Stack->push_back(&child); 
+ 
+    if (BuildConsumersMap) { 
+        if (parent != nullptr) { 
+            ConsumersMap[&child].push_back(parent); 
+        } else { 
+            ConsumersMap[&child] = {}; 
+        } 
+    } 
 }
 
 void TExploringNodeVisitor::Clear() {
     NodeList.clear();
     Stack = nullptr;
-    ConsumersMap.clear();
+    ConsumersMap.clear(); 
 }
 
 void TExploringNodeVisitor::Walk(TNode* root, const TTypeEnvironment& env, const std::vector<TNode*>& terminalNodes,
-    bool buildConsumersMap, size_t nodesCountHint)
-{
-    BuildConsumersMap = buildConsumersMap;
-
+    bool buildConsumersMap, size_t nodesCountHint) 
+{ 
+    BuildConsumersMap = buildConsumersMap; 
+ 
     Clear();
-
-    if (BuildConsumersMap && nodesCountHint) {
-        ConsumersMap.reserve(nodesCountHint);
-    }
-
+ 
+    if (BuildConsumersMap && nodesCountHint) { 
+        ConsumersMap.reserve(nodesCountHint); 
+    } 
+ 
     Stack = &env.GetNodeStack();
     Stack->clear();
-    AddChildNode(nullptr, *root);
+    AddChildNode(nullptr, *root); 
     while (!Stack->empty()) {
         auto node = Stack->back();
-
+ 
         if (node->GetCookie() == 0) {
             node->SetCookie(IS_NODE_ENTERED);
 
@@ -546,13 +546,13 @@ const std::vector<TNode*>& TExploringNodeVisitor::GetNodes() {
     return NodeList;
 }
 
-const TExploringNodeVisitor::TNodesVec& TExploringNodeVisitor::GetConsumerNodes(TNode& node) {
-    Y_VERIFY(BuildConsumersMap);
+const TExploringNodeVisitor::TNodesVec& TExploringNodeVisitor::GetConsumerNodes(TNode& node) { 
+    Y_VERIFY(BuildConsumersMap); 
     const auto consumers = ConsumersMap.find(&node);
     Y_VERIFY(consumers != ConsumersMap.cend());
     return consumers->second;
-}
-
+} 
+ 
 template <bool InPlace>
 TRuntimeNode SinglePassVisitCallablesImpl(TRuntimeNode root, TExploringNodeVisitor& explorer,
     const TCallableVisitFuncProvider& funcProvider, const TTypeEnvironment& env, bool& wereChanges)
diff --git a/ydb/library/yql/minikql/mkql_node_visitor.h b/ydb/library/yql/minikql/mkql_node_visitor.h
index f5bf76d520..8d16d95cec 100644
--- a/ydb/library/yql/minikql/mkql_node_visitor.h
+++ b/ydb/library/yql/minikql/mkql_node_visitor.h
@@ -125,8 +125,8 @@ public:
 
 class TExploringNodeVisitor : public INodeVisitor {
 public:
-    using TNodesVec = TStackVec<TNode*, 2>;
-public:
+    using TNodesVec = TStackVec<TNode*, 2>; 
+public: 
     void Visit(TTypeType& node) override;
     void Visit(TVoidType& node) override;
     void Visit(TNullType& node) override;
@@ -161,18 +161,18 @@ public:
     void Visit(TBlockType& node) override;
 
     void Walk(TNode* root, const TTypeEnvironment& env, const std::vector<TNode*>& terminalNodes = std::vector<TNode*>(),
-        bool buildConsumersMap = false, size_t nodesCountHint = 0);
+        bool buildConsumersMap = false, size_t nodesCountHint = 0); 
     const std::vector<TNode*>& GetNodes();
-    const TNodesVec& GetConsumerNodes(TNode& node);
+    const TNodesVec& GetConsumerNodes(TNode& node); 
     void Clear();
 
 private:
-    void AddChildNode(TNode* parent, TNode& child);
+    void AddChildNode(TNode* parent, TNode& child); 
 
 private:
     std::vector<TNode*> NodeList;
     std::vector<TNode*>* Stack = nullptr;
-    bool BuildConsumersMap = false;
+    bool BuildConsumersMap = false; 
     std::unordered_map<TNode*, TNodesVec> ConsumersMap;
 };
 
diff --git a/ydb/library/yql/minikql/mkql_opt_literal.cpp b/ydb/library/yql/minikql/mkql_opt_literal.cpp
index 832a87ea80..e03c4a2d0a 100644
--- a/ydb/library/yql/minikql/mkql_opt_literal.cpp
+++ b/ydb/library/yql/minikql/mkql_opt_literal.cpp
@@ -213,16 +213,16 @@ TRuntimeNode OptimizeFlatMap(TCallable& callable, const TTypeEnvironment& env) {
     const auto listType = static_cast<TListType*>(returnType);
     const auto newItemInput = callable.GetInput(2);
     if (listType->GetItemType()->IsVoid() && newItemInput.HasValue()) {
-        if (newItemInput.GetStaticType()->IsList()) {
-            TListLiteral* list = AS_VALUE(TListLiteral, newItemInput);
-            if (list->GetItemsCount() == 0) {
-                return TRuntimeNode(env.GetListOfVoid(), true);
-            }
-        } else {
-            TOptionalLiteral* opt = AS_VALUE(TOptionalLiteral, newItemInput);
-            if (!opt->HasItem()) {
-                return TRuntimeNode(env.GetListOfVoid(), true);
-            }
+        if (newItemInput.GetStaticType()->IsList()) { 
+            TListLiteral* list = AS_VALUE(TListLiteral, newItemInput); 
+            if (list->GetItemsCount() == 0) { 
+                return TRuntimeNode(env.GetListOfVoid(), true); 
+            } 
+        } else { 
+            TOptionalLiteral* opt = AS_VALUE(TOptionalLiteral, newItemInput); 
+            if (!opt->HasItem()) { 
+                return TRuntimeNode(env.GetListOfVoid(), true); 
+            } 
         }
     }
 
@@ -279,37 +279,37 @@ TRuntimeNode OptimizeNth(TCallable& callable, const TTypeEnvironment& env) {
     return TRuntimeNode(&callable, false);
 }
 
-TRuntimeNode OptimizeExtend(TCallable& callable, const TTypeEnvironment& env) {
-    auto returnType = callable.GetType()->GetReturnType();
-    if (!returnType->IsList()) {
-        return TRuntimeNode(&callable, false);
-    }
-
-    auto itemType = static_cast<TListType*>(returnType)->GetItemType();
-    if (!itemType->IsVoid()) {
-        return TRuntimeNode(&callable, false);
-    }
-
-    for (ui32 i = 0; i < callable.GetInputsCount(); ++i) {
-        auto seq = callable.GetInput(i);
-        auto seqType = seq.GetStaticType();
-
-        MKQL_ENSURE(seqType->IsList(), "Expected list type in extend");
-        MKQL_ENSURE(static_cast<TListType*>(seqType)->GetItemType()->IsVoid(), "Expected list of void");
-
-        if (!seq.HasValue()) {
-            return TRuntimeNode(&callable, false);
-        }
-
-        TListLiteral* listValue = AS_VALUE(TListLiteral, seq);
-        if (listValue->GetItemsCount() != 0) {
-            return TRuntimeNode(&callable, false);
-        }
-    }
-
-    return TRuntimeNode(env.GetListOfVoid(), true);
-}
-
+TRuntimeNode OptimizeExtend(TCallable& callable, const TTypeEnvironment& env) { 
+    auto returnType = callable.GetType()->GetReturnType(); 
+    if (!returnType->IsList()) { 
+        return TRuntimeNode(&callable, false); 
+    } 
+ 
+    auto itemType = static_cast<TListType*>(returnType)->GetItemType(); 
+    if (!itemType->IsVoid()) { 
+        return TRuntimeNode(&callable, false); 
+    } 
+ 
+    for (ui32 i = 0; i < callable.GetInputsCount(); ++i) { 
+        auto seq = callable.GetInput(i); 
+        auto seqType = seq.GetStaticType(); 
+ 
+        MKQL_ENSURE(seqType->IsList(), "Expected list type in extend"); 
+        MKQL_ENSURE(static_cast<TListType*>(seqType)->GetItemType()->IsVoid(), "Expected list of void"); 
+ 
+        if (!seq.HasValue()) { 
+            return TRuntimeNode(&callable, false); 
+        } 
+ 
+        TListLiteral* listValue = AS_VALUE(TListLiteral, seq); 
+        if (listValue->GetItemsCount() != 0) { 
+            return TRuntimeNode(&callable, false); 
+        } 
+    } 
+ 
+    return TRuntimeNode(env.GetListOfVoid(), true); 
+} 
+ 
 struct TOptimizationFuncMapFiller {
     THashMap<TString, TCallableVisitFunc> Map;
     TCallableVisitFuncProvider Provider;
@@ -328,7 +328,7 @@ struct TOptimizationFuncMapFiller {
         Map["Coalesce"] = &OptimizeCoalesce;
         Map["Exists"] = &OptimizeExists;
         Map["Nth"] = &OptimizeNth;
-        Map["Extend"] = &OptimizeExtend;
+        Map["Extend"] = &OptimizeExtend; 
 
         Provider = [&](TInternName name) {
             auto it = Map.find(name.Str());
diff --git a/ydb/library/yql/minikql/mkql_opt_literal_ut.cpp b/ydb/library/yql/minikql/mkql_opt_literal_ut.cpp
index c1c0a5b79d..001e37b816 100644
--- a/ydb/library/yql/minikql/mkql_opt_literal_ut.cpp
+++ b/ydb/library/yql/minikql/mkql_opt_literal_ut.cpp
@@ -230,23 +230,23 @@ Y_UNIT_TEST_SUITE(TMiniKQLLPOTest) {
         TScopedAlloc alloc;
         TTypeEnvironment env(alloc);
         TProgramBuilder pgmBuilder(env, *functionRegistry);
-
+ 
         TVector<TRuntimeNode> items;
         items.push_back(pgmBuilder.NewDataLiteral<ui32>(1));
         items.push_back(pgmBuilder.NewDataLiteral<ui32>(2));
         auto list = pgmBuilder.AsList(items);
-
+ 
         auto pgmReturn = pgmBuilder.FlatMap(list,
             [&](TRuntimeNode item) {
                 Y_UNUSED(item);
                 return pgmBuilder.NewEmptyOptional(pgmBuilder.NewOptionalType(env.GetTypeOfVoid()));
             });
-
+ 
         auto pgm = LiteralPropagationOptimization(pgmReturn, env, true).GetNode();
         UNIT_ASSERT_EQUAL(pgm->GetType()->GetKind(), TType::EKind::List);
         UNIT_ASSERT_EQUAL(static_cast<TListLiteral&>(*pgm).GetItemsCount(), 0);
-    }
-
+    } 
+ 
     Y_UNIT_TEST(TestLiteralCoalesceExist) {
         auto functionRegistry = CreateFunctionRegistry(IBuiltinFunctionRegistry::TPtr());
         TScopedAlloc alloc;
@@ -301,44 +301,44 @@ Y_UNIT_TEST_SUITE(TMiniKQLLPOTest) {
         UNIT_ASSERT_EQUAL(static_cast<TDataType&>(*pgm->GetType()).GetSchemeType(), NUdf::TDataType<ui32>::Id);
         UNIT_ASSERT_EQUAL(static_cast<TDataLiteral&>(*pgm).AsValue().Get<ui32>(), 56);
     }
-
-    Y_UNIT_TEST(TestExtend) {
-        auto functionRegistry = CreateFunctionRegistry(IBuiltinFunctionRegistry::TPtr());
-        TScopedAlloc alloc;
-        TTypeEnvironment env(alloc);
-        TProgramBuilder pgmBuilder(env, *functionRegistry);
-
-        auto pgmReturn = pgmBuilder.Extend({
-            pgmBuilder.NewEmptyListOfVoid(),
-            pgmBuilder.NewEmptyListOfVoid(),
-            pgmBuilder.NewEmptyListOfVoid()});
-
-        auto pgm = LiteralPropagationOptimization(pgmReturn, env, true).GetNode();
-        UNIT_ASSERT_EQUAL(pgm->GetType()->GetKind(), TType::EKind::List);
-        const auto& result1 = static_cast<const TListLiteral&>(*pgm);
-        UNIT_ASSERT_EQUAL(result1.GetItemsCount(), 0);
-
-        pgmReturn = pgmBuilder.Extend({
-            pgmBuilder.NewEmptyListOfVoid(),
-            pgmBuilder.Extend({
-                pgmBuilder.NewEmptyListOfVoid(),
-                pgmBuilder.NewEmptyListOfVoid(),
-            }),
-            pgmBuilder.NewEmptyListOfVoid()});
-
-        pgm = LiteralPropagationOptimization(pgmReturn, env, true).GetNode();
-        UNIT_ASSERT_EQUAL(pgm->GetType()->GetKind(), TType::EKind::List);
-        const auto& result2 = static_cast<const TListLiteral&>(*pgm);
-        UNIT_ASSERT_EQUAL(result2.GetItemsCount(), 0);
-
-        pgmReturn = pgmBuilder.Extend({
-            pgmBuilder.NewEmptyListOfVoid(),
-            pgmBuilder.AsList(MakeVoidCallable(pgmBuilder)),
-            pgmBuilder.NewEmptyListOfVoid()});
-
-        pgm = LiteralPropagationOptimization(pgmReturn, env, true).GetNode();
-        UNIT_ASSERT_EQUAL(pgm->GetType()->GetKind(), TType::EKind::Callable);
-    }
+ 
+    Y_UNIT_TEST(TestExtend) { 
+        auto functionRegistry = CreateFunctionRegistry(IBuiltinFunctionRegistry::TPtr()); 
+        TScopedAlloc alloc; 
+        TTypeEnvironment env(alloc); 
+        TProgramBuilder pgmBuilder(env, *functionRegistry); 
+ 
+        auto pgmReturn = pgmBuilder.Extend({ 
+            pgmBuilder.NewEmptyListOfVoid(), 
+            pgmBuilder.NewEmptyListOfVoid(), 
+            pgmBuilder.NewEmptyListOfVoid()}); 
+ 
+        auto pgm = LiteralPropagationOptimization(pgmReturn, env, true).GetNode(); 
+        UNIT_ASSERT_EQUAL(pgm->GetType()->GetKind(), TType::EKind::List); 
+        const auto& result1 = static_cast<const TListLiteral&>(*pgm); 
+        UNIT_ASSERT_EQUAL(result1.GetItemsCount(), 0); 
+ 
+        pgmReturn = pgmBuilder.Extend({ 
+            pgmBuilder.NewEmptyListOfVoid(), 
+            pgmBuilder.Extend({ 
+                pgmBuilder.NewEmptyListOfVoid(), 
+                pgmBuilder.NewEmptyListOfVoid(), 
+            }), 
+            pgmBuilder.NewEmptyListOfVoid()}); 
+ 
+        pgm = LiteralPropagationOptimization(pgmReturn, env, true).GetNode(); 
+        UNIT_ASSERT_EQUAL(pgm->GetType()->GetKind(), TType::EKind::List); 
+        const auto& result2 = static_cast<const TListLiteral&>(*pgm); 
+        UNIT_ASSERT_EQUAL(result2.GetItemsCount(), 0); 
+ 
+        pgmReturn = pgmBuilder.Extend({ 
+            pgmBuilder.NewEmptyListOfVoid(), 
+            pgmBuilder.AsList(MakeVoidCallable(pgmBuilder)), 
+            pgmBuilder.NewEmptyListOfVoid()}); 
+ 
+        pgm = LiteralPropagationOptimization(pgmReturn, env, true).GetNode(); 
+        UNIT_ASSERT_EQUAL(pgm->GetType()->GetKind(), TType::EKind::Callable); 
+    } 
 }
 
 }
diff --git a/ydb/library/yql/minikql/mkql_program_builder.cpp b/ydb/library/yql/minikql/mkql_program_builder.cpp
index 47ae6e4c8f..c04a83203e 100644
--- a/ydb/library/yql/minikql/mkql_program_builder.cpp
+++ b/ydb/library/yql/minikql/mkql_program_builder.cpp
@@ -728,7 +728,7 @@ TRuntimeNode TProgramBuilder::Discard(TRuntimeNode stream) {
 
 TRuntimeNode TProgramBuilder::Map(TRuntimeNode list, const TUnaryLambda& handler) {
     return BuildMap(__func__, list, handler);
-}
+} 
 
 TRuntimeNode TProgramBuilder::OrderedMap(TRuntimeNode list, const TUnaryLambda& handler) {
     return BuildMap(__func__, list, handler);
@@ -903,14 +903,14 @@ TRuntimeNode TProgramBuilder::Nanvl(TRuntimeNode data, TRuntimeNode dataIfNaN) {
 }
 
 TRuntimeNode TProgramBuilder::FlatMap(TRuntimeNode list, const TUnaryLambda& handler)
-{
+{ 
     return BuildFlatMap(__func__, list, handler);
-}
+} 
 
 TRuntimeNode TProgramBuilder::OrderedFlatMap(TRuntimeNode list, const TUnaryLambda& handler)
-{
+{ 
     return BuildFlatMap(__func__, list, handler);
-}
+} 
 
 TRuntimeNode TProgramBuilder::Filter(TRuntimeNode list, const TUnaryLambda& handler)
 {
@@ -923,7 +923,7 @@ TRuntimeNode TProgramBuilder::Filter(TRuntimeNode list, TRuntimeNode limit, cons
 }
 
 TRuntimeNode TProgramBuilder::OrderedFilter(TRuntimeNode list, const TUnaryLambda& handler)
-{
+{ 
     return BuildFilter(__func__, list, handler);
 }
 
@@ -954,19 +954,19 @@ TRuntimeNode TProgramBuilder::SkipWhileInclusive(TRuntimeNode list, const TUnary
 
 TRuntimeNode TProgramBuilder::BuildListSort(const std::string_view& callableName, TRuntimeNode list, TRuntimeNode ascending,
     const TUnaryLambda& keyExtractor)
-{
+{ 
     const auto listType = list.GetStaticType();
     MKQL_ENSURE(listType->IsList(), "Expected list.");
-
+ 
     const auto itemType = static_cast<const TListType&>(*listType).GetItemType();
-
-    ThrowIfListOfVoid(itemType);
-
+ 
+    ThrowIfListOfVoid(itemType); 
+ 
     const auto ascendingType = ascending.GetStaticType();
     const auto itemArg = Arg(itemType);
-
+ 
     auto key = keyExtractor(itemArg);
-
+ 
     if (ascendingType->IsTuple()) {
         const auto ascendingTuple = AS_TYPE(TTupleType, ascendingType);
         if (ascendingTuple->GetElementsCount() == 0) {
@@ -980,13 +980,13 @@ TRuntimeNode TProgramBuilder::BuildListSort(const std::string_view& callableName
     }
 
     TCallableBuilder callableBuilder(Env, callableName, listType);
-    callableBuilder.Add(list);
-    callableBuilder.Add(itemArg);
-    callableBuilder.Add(key);
-    callableBuilder.Add(ascending);
-    return TRuntimeNode(callableBuilder.Build(), false);
-}
-
+    callableBuilder.Add(list); 
+    callableBuilder.Add(itemArg); 
+    callableBuilder.Add(key); 
+    callableBuilder.Add(ascending); 
+    return TRuntimeNode(callableBuilder.Build(), false); 
+} 
+ 
 TRuntimeNode TProgramBuilder::BuildListNth(const std::string_view& callableName, TRuntimeNode list, TRuntimeNode n, TRuntimeNode ascending,
     const TUnaryLambda& keyExtractor)
 {
@@ -1074,7 +1074,7 @@ TRuntimeNode TProgramBuilder::BuildNth(const std::string_view& callableName, TRu
 
 TRuntimeNode TProgramBuilder::BuildTake(const std::string_view& callableName, TRuntimeNode flow, TRuntimeNode count) {
     const auto listType = flow.GetStaticType();
-
+ 
     TType* itemType = nullptr;
     if (listType->IsFlow()) {
         itemType = AS_TYPE(TFlowType, listType)->GetItemType();
@@ -1087,15 +1087,15 @@ TRuntimeNode TProgramBuilder::BuildTake(const std::string_view& callableName, TR
     MKQL_ENSURE(itemType, "Expected flow, list or stream.");
     ThrowIfListOfVoid(itemType);
 
-    MKQL_ENSURE(count.GetStaticType()->IsData(), "Expected data");
+    MKQL_ENSURE(count.GetStaticType()->IsData(), "Expected data"); 
     MKQL_ENSURE(static_cast<const TDataType&>(*count.GetStaticType()).GetSchemeType() == NUdf::TDataType<ui64>::Id, "Expected ui64");
-
-    TCallableBuilder callableBuilder(Env, callableName, listType);
+ 
+    TCallableBuilder callableBuilder(Env, callableName, listType); 
     callableBuilder.Add(flow);
-    callableBuilder.Add(count);
-    return TRuntimeNode(callableBuilder.Build(), false);
-}
-
+    callableBuilder.Add(count); 
+    return TRuntimeNode(callableBuilder.Build(), false); 
+} 
+ 
 template<bool IsFilter, bool OnStruct>
 TRuntimeNode TProgramBuilder::BuildFilterNulls(TRuntimeNode list) {
     const auto listType = list.GetStaticType();
@@ -1523,7 +1523,7 @@ TRuntimeNode TProgramBuilder::Take(TRuntimeNode list, TRuntimeNode count) {
 }
 
 TRuntimeNode TProgramBuilder::Sort(TRuntimeNode list, TRuntimeNode ascending, const TUnaryLambda& keyExtractor)
-{
+{ 
     return BuildSort(__func__, list, ascending, keyExtractor);
 }
 
@@ -3188,56 +3188,56 @@ void TProgramBuilder::ThrowIfListOfVoid(TType* type) {
 }
 
 TRuntimeNode TProgramBuilder::BuildFlatMap(const std::string_view& callableName, TRuntimeNode list, const TUnaryLambda& handler)
-{
+{ 
     const auto listType = list.GetStaticType();
     MKQL_ENSURE(listType->IsFlow() || listType->IsList() || listType->IsOptional() || listType->IsStream(), "Expected flow, list, stream or optional");
-
-    if (listType->IsOptional()) {
+ 
+    if (listType->IsOptional()) { 
         const auto itemArg = Arg(AS_TYPE(TOptionalType, listType)->GetItemType());
         const auto newList = handler(itemArg);
         const auto type = newList.GetStaticType();
         MKQL_ENSURE(type->IsList() || type->IsOptional() || type->IsStream() || type->IsFlow(), "Expected flow, list, stream or optional");
-        return IfPresent(list, [&](TRuntimeNode item) {
-            return handler(item);
+        return IfPresent(list, [&](TRuntimeNode item) { 
+            return handler(item); 
         }, type->IsOptional() ? NewEmptyOptional(type) : type->IsList() ? NewEmptyList(AS_TYPE(TListType, type)->GetItemType()) : EmptyIterator(type));
-    }
-
+    } 
+ 
     const auto itemType = listType->IsFlow() ?
             AS_TYPE(TFlowType, listType)->GetItemType():
             listType->IsList() ?
                 AS_TYPE(TListType, listType)->GetItemType():
                 AS_TYPE(TStreamType, listType)->GetItemType();
-
-    ThrowIfListOfVoid(itemType);
+ 
+    ThrowIfListOfVoid(itemType); 
     const auto itemArg = Arg(itemType);
     const auto newList = handler(itemArg);
     const auto type = newList.GetStaticType();
-
-    TType* retItemType = nullptr;
-    if (type->IsOptional()) {
+ 
+    TType* retItemType = nullptr; 
+    if (type->IsOptional()) { 
         retItemType = AS_TYPE(TOptionalType, type)->GetItemType();
     } else if (type->IsFlow()) {
         retItemType = AS_TYPE(TFlowType, type)->GetItemType();
-    } else if (type->IsList()) {
+    } else if (type->IsList()) { 
         retItemType = AS_TYPE(TListType, type)->GetItemType();
     } else if (type->IsStream()) {
         retItemType = AS_TYPE(TStreamType, type)->GetItemType();
-    } else {
+    } else { 
         THROW yexception() << "Expected flow, list or stream.";
-    }
-
+    } 
+ 
     const auto resultListType = listType->IsFlow() || type->IsFlow() ?
         TFlowType::Create(retItemType, Env):
         listType->IsList() ?
             (TType*)TListType::Create(retItemType, Env):
             (TType*)TStreamType::Create(retItemType, Env);
-    TCallableBuilder callableBuilder(Env, callableName, resultListType);
-    callableBuilder.Add(list);
-    callableBuilder.Add(itemArg);
-    callableBuilder.Add(newList);
-    return TRuntimeNode(callableBuilder.Build(), false);
-}
-
+    TCallableBuilder callableBuilder(Env, callableName, resultListType); 
+    callableBuilder.Add(list); 
+    callableBuilder.Add(itemArg); 
+    callableBuilder.Add(newList); 
+    return TRuntimeNode(callableBuilder.Build(), false); 
+} 
+ 
 TRuntimeNode TProgramBuilder::MultiMap(TRuntimeNode list, const TExpandLambda& handler)
 {
     if constexpr (RuntimeVersion < 16U) {
@@ -3492,33 +3492,33 @@ TRuntimeNode TProgramBuilder::WideFilter(TRuntimeNode flow, TRuntimeNode limit,
 }
 
 TRuntimeNode TProgramBuilder::BuildFilter(const std::string_view& callableName, TRuntimeNode list, const TUnaryLambda& handler, TType* resultType)
-{
+{ 
     const auto listType = list.GetStaticType();
     MKQL_ENSURE(listType->IsFlow() || listType->IsList() || listType->IsStream(), "Expected flow, list or stream.");
     const auto outputType = resultType ? resultType : listType;
-
+ 
     const auto itemType = listType->IsFlow() ?
         AS_TYPE(TFlowType, listType)->GetItemType():
         listType->IsList() ?
             AS_TYPE(TListType, listType)->GetItemType():
             AS_TYPE(TStreamType, listType)->GetItemType();
-    ThrowIfListOfVoid(itemType);
-
+    ThrowIfListOfVoid(itemType); 
+ 
     const auto itemArg = Arg(itemType);
     const auto predicate = handler(itemArg);
-
-    MKQL_ENSURE(predicate.GetStaticType()->IsData(), "Expected boolean data");
-
-    const auto& detailedPredicateType = static_cast<const TDataType&>(*predicate.GetStaticType());
+ 
+    MKQL_ENSURE(predicate.GetStaticType()->IsData(), "Expected boolean data"); 
+ 
+    const auto& detailedPredicateType = static_cast<const TDataType&>(*predicate.GetStaticType()); 
     MKQL_ENSURE(detailedPredicateType.GetSchemeType() == NUdf::TDataType<bool>::Id, "Expected boolean data");
-
+ 
     TCallableBuilder callableBuilder(Env, callableName, outputType);
-    callableBuilder.Add(list);
-    callableBuilder.Add(itemArg);
-    callableBuilder.Add(predicate);
-    return TRuntimeNode(callableBuilder.Build(), false);
-}
-
+    callableBuilder.Add(list); 
+    callableBuilder.Add(itemArg); 
+    callableBuilder.Add(predicate); 
+    return TRuntimeNode(callableBuilder.Build(), false); 
+} 
+ 
 TRuntimeNode TProgramBuilder::BuildFilter(const std::string_view& callableName, TRuntimeNode list, TRuntimeNode limit, const TUnaryLambda& handler, TType* resultType)
 {
     if constexpr (RuntimeVersion < 4U) {
@@ -3637,43 +3637,43 @@ TRuntimeNode TProgramBuilder::PartialSort(TRuntimeNode list, TRuntimeNode n, con
 }
 
 TRuntimeNode TProgramBuilder::BuildMap(const std::string_view& callableName, TRuntimeNode list, const TUnaryLambda& handler)
-{
+{ 
     const auto listType = list.GetStaticType();
     MKQL_ENSURE(listType->IsFlow() || listType->IsList() || listType->IsStream() || listType->IsOptional(), "Expected flow, list, stream or optional");
-
-    if (listType->IsOptional()) {
+ 
+    if (listType->IsOptional()) { 
         const auto itemArg = Arg(AS_TYPE(TOptionalType, listType)->GetItemType());
         const auto newItem = handler(itemArg);
-
+ 
         return IfPresent(list,
             [&](TRuntimeNode item) { return NewOptional(handler(item)); },
             NewEmptyOptional(NewOptionalType(newItem.GetStaticType()))
         );
-    }
-
+    } 
+ 
     const auto itemType = listType->IsFlow() ?
         AS_TYPE(TFlowType, listType)->GetItemType():
         listType->IsList() ?
             AS_TYPE(TListType, listType)->GetItemType():
             AS_TYPE(TStreamType, listType)->GetItemType();
-
-    ThrowIfListOfVoid(itemType);
-
+ 
+    ThrowIfListOfVoid(itemType); 
+ 
     const auto itemArg = Arg(itemType);
     const auto newItem = handler(itemArg);
-
+ 
     const auto resultListType = listType->IsFlow() ?
         (TType*)TFlowType::Create(newItem.GetStaticType(), Env):
         listType->IsList() ?
             (TType*)TListType::Create(newItem.GetStaticType(), Env):
             (TType*)TStreamType::Create(newItem.GetStaticType(), Env);
-    TCallableBuilder callableBuilder(Env, callableName, resultListType);
-    callableBuilder.Add(list);
-    callableBuilder.Add(itemArg);
-    callableBuilder.Add(newItem);
-    return TRuntimeNode(callableBuilder.Build(), false);
-}
-
+    TCallableBuilder callableBuilder(Env, callableName, resultListType); 
+    callableBuilder.Add(list); 
+    callableBuilder.Add(itemArg); 
+    callableBuilder.Add(newItem); 
+    return TRuntimeNode(callableBuilder.Build(), false); 
+} 
+ 
 TRuntimeNode TProgramBuilder::Invoke(const std::string_view& funcName, TType* resultType, const TArrayRef<const TRuntimeNode>& args) {
     MKQL_ENSURE(args.size() >= 1U && args.size() <= 3U, "Expected from one to three arguments.");
     std::array<TArgType, 4U> argTypes;
@@ -3818,7 +3818,7 @@ TRuntimeNode TProgramBuilder::Apply(TRuntimeNode callableNode, const TArrayRef<c
         TType* argType = callableType->GetArgumentType(i);
         TRuntimeNode arg = args[i];
         MKQL_ENSURE(arg.GetStaticType()->IsConvertableTo(*argType),
-                    "Argument type mismatch for argument " << i << ": runtime " << argType->GetKindAsStr()
+                    "Argument type mismatch for argument " << i << ": runtime " << argType->GetKindAsStr() 
                                    << " with static " << arg.GetStaticType()->GetKindAsStr());
     }
 
@@ -4480,16 +4480,16 @@ TRuntimeNode TProgramBuilder::GroupingCore(TRuntimeNode stream,
 
     auto itemType = AS_TYPE(TStreamType, stream)->GetItemType();
 
-    TRuntimeNode keyExtractorItemArg = Arg(itemType);
-    TRuntimeNode keyExtractorResult = keyExtractor(keyExtractorItemArg);
-
-    TRuntimeNode groupSwitchKeyArg = Arg(keyExtractorResult.GetStaticType());
-    TRuntimeNode groupSwitchItemArg = Arg(itemType);
+    TRuntimeNode keyExtractorItemArg = Arg(itemType); 
+    TRuntimeNode keyExtractorResult = keyExtractor(keyExtractorItemArg); 
 
-    TRuntimeNode groupSwitchResult = groupSwitch(groupSwitchKeyArg, groupSwitchItemArg);
-    MKQL_ENSURE(AS_TYPE(TDataType, groupSwitchResult)->GetSchemeType() == NUdf::TDataType<bool>::Id,
-        "Expected bool type");
+    TRuntimeNode groupSwitchKeyArg = Arg(keyExtractorResult.GetStaticType()); 
+    TRuntimeNode groupSwitchItemArg = Arg(itemType); 
 
+    TRuntimeNode groupSwitchResult = groupSwitch(groupSwitchKeyArg, groupSwitchItemArg); 
+    MKQL_ENSURE(AS_TYPE(TDataType, groupSwitchResult)->GetSchemeType() == NUdf::TDataType<bool>::Id, 
+        "Expected bool type"); 
+ 
     TRuntimeNode handlerItemArg;
     TRuntimeNode handlerResult;
 
@@ -4504,11 +4504,11 @@ TRuntimeNode TProgramBuilder::GroupingCore(TRuntimeNode stream,
 
     TCallableBuilder callableBuilder(Env, __func__, finishType);
     callableBuilder.Add(stream);
-    callableBuilder.Add(keyExtractorResult);
-    callableBuilder.Add(groupSwitchResult);
-    callableBuilder.Add(keyExtractorItemArg);
-    callableBuilder.Add(groupSwitchKeyArg);
-    callableBuilder.Add(groupSwitchItemArg);
+    callableBuilder.Add(keyExtractorResult); 
+    callableBuilder.Add(groupSwitchResult); 
+    callableBuilder.Add(keyExtractorItemArg); 
+    callableBuilder.Add(groupSwitchKeyArg); 
+    callableBuilder.Add(groupSwitchItemArg); 
     if (handler) {
         callableBuilder.Add(handlerResult);
         callableBuilder.Add(handlerItemArg);
diff --git a/ydb/library/yql/minikql/mkql_program_builder.h b/ydb/library/yql/minikql/mkql_program_builder.h
index 10f1ad7ccf..119dbd8bc4 100644
--- a/ydb/library/yql/minikql/mkql_program_builder.h
+++ b/ydb/library/yql/minikql/mkql_program_builder.h
@@ -647,7 +647,7 @@ protected:
     TRuntimeNode BuildLogical(const std::string_view& callableName, const TArrayRef<const TRuntimeNode>& args);
     TRuntimeNode BuildBinaryLogical(const std::string_view& callableName, TRuntimeNode data1, TRuntimeNode data2);
     TRuntimeNode BuildMinMax(const std::string_view& callableName, const TRuntimeNode* data, size_t size);
-
+ 
 private:
     TRuntimeNode BuildWideFilter(const std::string_view& callableName, TRuntimeNode flow, const TNarrowLambda& handler);
 
diff --git a/ydb/library/yql/minikql/mkql_type_builder.cpp b/ydb/library/yql/minikql/mkql_type_builder.cpp
index 4aecb564bf..9ce4c7da1c 100644
--- a/ydb/library/yql/minikql/mkql_type_builder.cpp
+++ b/ydb/library/yql/minikql/mkql_type_builder.cpp
@@ -1250,7 +1250,7 @@ TFunctionTypeInfoBuilder::TFunctionTypeInfoBuilder(
     : Env_(env)
     , ReturnType_(nullptr)
     , RunConfigType_(Env_.GetTypeOfVoid())
-    , UserType_(Env_.GetTypeOfVoid())
+    , UserType_(Env_.GetTypeOfVoid()) 
     , TypeInfoHelper_(typeInfoHelper)
     , ModuleName_(moduleName)
     , CountersProvider_(countersProvider)
@@ -1375,25 +1375,25 @@ NUdf::IFunctionTypeInfoBuilder1& TFunctionTypeInfoBuilder::RunConfigImpl(
 
 NUdf::IFunctionTypeInfoBuilder1& TFunctionTypeInfoBuilder::UserTypeImpl(
         NUdf::TDataTypeId typeId)
-{
-    UserType_ = TDataType::Create(typeId, Env_);
-    return *this;
-}
-
+{ 
+    UserType_ = TDataType::Create(typeId, Env_); 
+    return *this; 
+} 
+ 
 NUdf::IFunctionTypeInfoBuilder1& TFunctionTypeInfoBuilder::UserTypeImpl(
-        const NUdf::TType* type)
-{
-    UserType_ = static_cast<const NMiniKQL::TType*>(type);
-    return *this;
-}
-
+        const NUdf::TType* type) 
+{ 
+    UserType_ = static_cast<const NMiniKQL::TType*>(type); 
+    return *this; 
+} 
+ 
 NUdf::IFunctionTypeInfoBuilder1& TFunctionTypeInfoBuilder::UserTypeImpl(
-        const NUdf::ITypeBuilder& typeBuilder)
-{
-    UserType_ = static_cast<TType*>(typeBuilder.Build());
-    return *this;
-}
-
+        const NUdf::ITypeBuilder& typeBuilder) 
+{ 
+    UserType_ = static_cast<TType*>(typeBuilder.Build()); 
+    return *this; 
+} 
+ 
 void TFunctionTypeInfoBuilder::SetError(const NUdf::TStringRef& error)
 {
     if (!Error_) {
@@ -1425,7 +1425,7 @@ void TFunctionTypeInfoBuilder::Build(TFunctionTypeInfo* funcInfo)
     }
 
     funcInfo->RunConfigType = RunConfigType_;
-    funcInfo->UserType = UserType_;
+    funcInfo->UserType = UserType_; 
     funcInfo->Implementation = std::move(Implementation_);
     funcInfo->ModuleIR = std::move(ModuleIR_);
     funcInfo->ModuleIRUniqID = std::move(ModuleIRUniqID_);
diff --git a/ydb/library/yql/minikql/mkql_type_builder.h b/ydb/library/yql/minikql/mkql_type_builder.h
index a93fb41cee..c939160f71 100644
--- a/ydb/library/yql/minikql/mkql_type_builder.h
+++ b/ydb/library/yql/minikql/mkql_type_builder.h
@@ -14,7 +14,7 @@ struct TFunctionTypeInfo
 {
     TCallableType* FunctionType = nullptr;
     const TType* RunConfigType = nullptr;
-    const TType* UserType = nullptr;
+    const TType* UserType = nullptr; 
     NUdf::TUniquePtr<NUdf::IBoxedValue> Implementation;
     NUdf::TUniquePtr<NUdf::IBoxedValue> BlockImplementation;
     TString ModuleIR;
@@ -66,7 +66,7 @@ public:
     NUdf::IFunctionTypeInfoBuilder1& UserTypeImpl(NUdf::TDataTypeId typeId) override;
     NUdf::IFunctionTypeInfoBuilder1& UserTypeImpl(const NUdf::TType* type) override;
     NUdf::IFunctionTypeInfoBuilder1& UserTypeImpl(const NUdf::ITypeBuilder& typeBuilder) override;
-
+ 
     void SetError(const NUdf::TStringRef& error) override;
     inline bool HasError() const { return !Error_.empty(); }
     inline const TString& GetError() const { return Error_; }
@@ -125,7 +125,7 @@ private:
     NUdf::TUniquePtr<NUdf::IBoxedValue> BlockImplementation_;
     const TType* ReturnType_;
     const TType* RunConfigType_;
-    const TType* UserType_;
+    const TType* UserType_; 
     TVector<TArgInfo> Args_;
     TString Error_;
     ui32 OptionalArgs_ = 0;
diff --git a/ydb/library/yql/providers/common/codec/yql_codec.cpp b/ydb/library/yql/providers/common/codec/yql_codec.cpp
index 7587e188fa..67fe48181a 100644
--- a/ydb/library/yql/providers/common/codec/yql_codec.cpp
+++ b/ydb/library/yql/providers/common/codec/yql_codec.cpp
@@ -9,7 +9,7 @@
 #include <ydb/library/yql/minikql/mkql_node_cast.h>
 #include <ydb/library/yql/minikql/mkql_string_util.h>
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_pack.h>
-
+ 
 #include <ydb/library/yql/utils/yql_panic.h>
 #include <ydb/library/yql/utils/swap_bytes.h>
 
diff --git a/ydb/library/yql/providers/common/config/yql_configuration_transformer.cpp b/ydb/library/yql/providers/common/config/yql_configuration_transformer.cpp
index 9fbd44acb3..d3c990d2a2 100644
--- a/ydb/library/yql/providers/common/config/yql_configuration_transformer.cpp
+++ b/ydb/library/yql/providers/common/config/yql_configuration_transformer.cpp
@@ -12,10 +12,10 @@ namespace NCommon {
 
 using namespace NNodes;
 
-TProviderConfigurationTransformer::TProviderConfigurationTransformer(TSettingDispatcher::TPtr dispatcher,
+TProviderConfigurationTransformer::TProviderConfigurationTransformer(TSettingDispatcher::TPtr dispatcher, 
     const TTypeAnnotationContext& types, const TString& provider, const THashSet<TStringBuf>& configureCallables)
-    : Dispatcher(dispatcher)
-    , Types(types)
+    : Dispatcher(dispatcher) 
+    , Types(types) 
     , Provider(provider)
     , ConfigureCallables(configureCallables)
 {
@@ -23,70 +23,70 @@ TProviderConfigurationTransformer::TProviderConfigurationTransformer(TSettingDis
         ConfigureCallables.insert(TCoConfigure::CallableName());
     }
 }
-
-IGraphTransformer::TStatus TProviderConfigurationTransformer::DoTransform(TExprNode::TPtr input,
-    TExprNode::TPtr& output, TExprContext& ctx)
-{
-    output = input;
-    if (ctx.Step.IsDone(TExprStep::Configure)) {
-        return TStatus::Ok;
+ 
+IGraphTransformer::TStatus TProviderConfigurationTransformer::DoTransform(TExprNode::TPtr input, 
+    TExprNode::TPtr& output, TExprContext& ctx) 
+{ 
+    output = input; 
+    if (ctx.Step.IsDone(TExprStep::Configure)) { 
+        return TStatus::Ok; 
     }
 
-    TOptimizeExprSettings settings(nullptr);
-    settings.VisitChanges = true;
-    auto status = OptimizeExpr(input, output, [&](const TExprNode::TPtr& node, TExprContext& ctx) -> TExprNode::TPtr {
+    TOptimizeExprSettings settings(nullptr); 
+    settings.VisitChanges = true; 
+    auto status = OptimizeExpr(input, output, [&](const TExprNode::TPtr& node, TExprContext& ctx) -> TExprNode::TPtr { 
         if (node->IsCallable(ConfigureCallables)) {
-            if (!EnsureMinArgsCount(*node, 2, ctx)) {
-                return nullptr;
-            }
+            if (!EnsureMinArgsCount(*node, 2, ctx)) { 
+                return nullptr; 
+            } 
 
             if (!TCoDataSource::Match(node->Child(TCoConfigure::idx_DataSource))) {
-                return node;
-            }
+                return node; 
+            } 
             auto ds = node->Child(TCoConfigure::idx_DataSource);
             if (ds->Child(TCoDataSource::idx_Category)->Content() != Provider) {
-                return node;
-            }
+                return node; 
+            } 
             if (!EnsureMinArgsCount(*ds, 2, ctx)) {
-                return nullptr;
-            }
+                return nullptr; 
+            } 
             if (!EnsureAtom(*ds->Child(1), ctx)) {
-                return nullptr;
-            }
+                return nullptr; 
+            } 
             auto clusterName = TString(ds->Child(1)->Content());
-
-            if (!EnsureMinArgsCount(*node, 3, ctx)) {
-                return nullptr;
-            }
+ 
+            if (!EnsureMinArgsCount(*node, 3, ctx)) { 
+                return nullptr; 
+            } 
             if (!EnsureAtom(*node->Child(2), ctx)) {
-                return nullptr;
-            }
-
+                return nullptr; 
+            } 
+ 
             auto atom = node->Child(2)->Content();
             if (atom == TStringBuf("Attr")) {
-                if (!EnsureMinArgsCount(*node, 4, ctx)) {
+                if (!EnsureMinArgsCount(*node, 4, ctx)) { 
                     return nullptr;
                 }
 
-                if (!EnsureMaxArgsCount(*node, 5, ctx)) {
+                if (!EnsureMaxArgsCount(*node, 5, ctx)) { 
                     return nullptr;
                 }
-
+ 
                 if (!EnsureAtom(*node->Child(3), ctx)) {
                     return nullptr;
                 }
 
                 auto name = TString(node->Child(3)->Content());
-                if (name.StartsWith('_')) {
+                if (name.StartsWith('_')) { 
                     ctx.AddError(TIssue(ctx.GetPosition(node->Child(3)->Pos()),
-                        TStringBuilder() << "Failed to override system setting: " << name));
+                        TStringBuilder() << "Failed to override system setting: " << name)); 
                     return nullptr;
                 }
 
-                TMaybe<TString> value;
+                TMaybe<TString> value; 
                 if (node->ChildrenSize() == 5) {
                     if (node->Child(4)->IsCallable("EvaluateAtom")) {
-                        return node;
+                        return node; 
                     }
 
                     if (!EnsureAtom(*node->Child(4), ctx)) {
@@ -94,66 +94,66 @@ IGraphTransformer::TStatus TProviderConfigurationTransformer::DoTransform(TExprN
                     }
 
                     value = TString(node->Child(4)->Content());
-                }
+                } 
 
                 if (!HandleAttr(node->Child(3)->Pos(), clusterName, name, value, ctx)) {
-                    return nullptr;
-                }
+                    return nullptr; 
+                } 
             } else if (atom == TStringBuf("Auth")) {
-                if (!EnsureArgsCount(*node, 4, ctx)) {
-                    return nullptr;
-                }
+                if (!EnsureArgsCount(*node, 4, ctx)) { 
+                    return nullptr; 
+                } 
 
                 if (!EnsureAtom(*node->Child(3), ctx)) {
-                    return nullptr;
+                    return nullptr; 
                 }
 
                 auto credAlias = TString(node->Child(3)->Content());
                 if (!HandleAuth(node->Child(3)->Pos(), clusterName, credAlias, ctx)) {
                     return nullptr;
                 }
-            } else {
+            } else { 
                 ctx.AddError(TIssue(ctx.GetPosition(node->Child(2)->Pos()), TStringBuilder()
-                    << "Unsupported configuration option: " << atom));
-                return nullptr;
+                    << "Unsupported configuration option: " << atom)); 
+                return nullptr; 
             }
-        }
+        } 
 
-        return node;
-    }, ctx, settings);
-
-    return status;
-}
+        return node; 
+    }, ctx, settings); 
 
+    return status; 
+} 
+ 
 bool TProviderConfigurationTransformer::HandleAttr(TPositionHandle pos, const TString& cluster, const TString& name,
-    const TMaybe<TString>& value, TExprContext& ctx)
-{
-    Y_UNUSED(pos);
-    Y_UNUSED(ctx);
-    Dispatcher->Dispatch(cluster, name, value, TSettingDispatcher::EStage::STATIC);
-    return true;
-}
-
+    const TMaybe<TString>& value, TExprContext& ctx) 
+{ 
+    Y_UNUSED(pos); 
+    Y_UNUSED(ctx); 
+    Dispatcher->Dispatch(cluster, name, value, TSettingDispatcher::EStage::STATIC); 
+    return true; 
+} 
+ 
 bool TProviderConfigurationTransformer::HandleAuth(TPositionHandle pos, const TString& cluster, const TString& alias,
-    TExprContext& ctx)
-{
-    auto cred = Types.FindCredential(alias);
-    if (!cred) {
+    TExprContext& ctx) 
+{ 
+    auto cred = Types.FindCredential(alias); 
+    if (!cred) { 
         ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder() << "Unknown credential: " << alias));
-        return false;
+        return false; 
     }
 
-    if (cred->Category != Provider) {
+    if (cred->Category != Provider) { 
         ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder()
-            << "Mismatch credential category, expected: "
-            << Provider << ", but found: " << cred->Category));
-        return false;
-    }
-
-    Dispatcher->Dispatch(cluster, "Auth", cred->Content, TSettingDispatcher::EStage::STATIC);
-    return true;
-}
-
+            << "Mismatch credential category, expected: " 
+            << Provider << ", but found: " << cred->Category)); 
+        return false; 
+    } 
+
+    Dispatcher->Dispatch(cluster, "Auth", cred->Content, TSettingDispatcher::EStage::STATIC); 
+    return true; 
+} 
+ 
 THolder<IGraphTransformer> CreateProviderConfigurationTransformer(
     TSettingDispatcher::TPtr dispatcher,
     const TTypeAnnotationContext& types,
diff --git a/ydb/library/yql/providers/common/config/yql_configuration_transformer.h b/ydb/library/yql/providers/common/config/yql_configuration_transformer.h
index 38997103ff..bc9235c59b 100644
--- a/ydb/library/yql/providers/common/config/yql_configuration_transformer.h
+++ b/ydb/library/yql/providers/common/config/yql_configuration_transformer.h
@@ -12,25 +12,25 @@
 namespace NYql {
 namespace NCommon {
 
-class TProviderConfigurationTransformer : public TSyncTransformerBase {
-public:
-    TProviderConfigurationTransformer(TSettingDispatcher::TPtr dispatcher,const TTypeAnnotationContext& types,
+class TProviderConfigurationTransformer : public TSyncTransformerBase { 
+public: 
+    TProviderConfigurationTransformer(TSettingDispatcher::TPtr dispatcher,const TTypeAnnotationContext& types, 
         const TString& provider, const THashSet<TStringBuf>& configureCallables = {});
-
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final;
-
-protected:
+ 
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final; 
+ 
+protected: 
     virtual bool HandleAttr(TPositionHandle pos, const TString& cluster, const TString& name,
-        const TMaybe<TString>& value, TExprContext& ctx);
+        const TMaybe<TString>& value, TExprContext& ctx); 
     virtual bool HandleAuth(TPositionHandle pos, const TString& cluster, const TString& alias, TExprContext& ctx);
-
-protected:
-    TSettingDispatcher::TPtr Dispatcher;
-    const TTypeAnnotationContext& Types;
-    TString Provider;
+ 
+protected: 
+    TSettingDispatcher::TPtr Dispatcher; 
+    const TTypeAnnotationContext& Types; 
+    TString Provider; 
     THashSet<TStringBuf> ConfigureCallables;
-};
-
+}; 
+ 
 THolder<IGraphTransformer> CreateProviderConfigurationTransformer(
     TSettingDispatcher::TPtr dispatcher,
     const TTypeAnnotationContext& types,
diff --git a/ydb/library/yql/providers/common/config/yql_dispatch.cpp b/ydb/library/yql/providers/common/config/yql_dispatch.cpp
index 4e6df45a8f..ffd467bbaf 100644
--- a/ydb/library/yql/providers/common/config/yql_dispatch.cpp
+++ b/ydb/library/yql/providers/common/config/yql_dispatch.cpp
@@ -151,12 +151,12 @@ void TSettingDispatcher::FreezeDefaults() {
     }
 }
 
-void TSettingDispatcher::Restore() {
-    for (auto& item: Handlers) {
-        item.second->Restore(ALL_CLUSTERS);
-    }
-}
-
+void TSettingDispatcher::Restore() { 
+    for (auto& item: Handlers) { 
+        item.second->Restore(ALL_CLUSTERS); 
+    } 
+} 
+ 
 template <class TActivation>
 bool TSettingDispatcher::Allow(const TActivation& activation, const TString& userName) {
     if (AnyOf(activation.GetIncludeUsers(), [&](const auto& user) { return user == userName; })) {
diff --git a/ydb/library/yql/providers/common/config/yql_dispatch.h b/ydb/library/yql/providers/common/config/yql_dispatch.h
index 7389cbf082..187499dbab 100644
--- a/ydb/library/yql/providers/common/config/yql_dispatch.h
+++ b/ydb/library/yql/providers/common/config/yql_dispatch.h
@@ -75,19 +75,19 @@ TParser<TInstant> GetDefaultParser<TInstant>();
 YQL_PRIMITIVE_SETTING_PARSER_TYPES(YQL_DECLARE_SETTING_PARSER)
 YQL_CONTAINER_SETTING_PARSER_TYPES(YQL_DECLARE_SETTING_PARSER)
 
-template<typename TType>
-TMaybe<TType> GetValue(const NCommon::TConfSetting<TType, true>& setting, const TString& cluster) {
-    return setting.Get(cluster);
-}
-
-template<typename TType>
-TMaybe<TType> GetValue(const NCommon::TConfSetting<TType, false>& setting, const TString& cluster) {
-    Y_UNUSED(cluster);
-    return setting.Get();
-}
-
+template<typename TType> 
+TMaybe<TType> GetValue(const NCommon::TConfSetting<TType, true>& setting, const TString& cluster) { 
+    return setting.Get(cluster); 
 }
 
+template<typename TType> 
+TMaybe<TType> GetValue(const NCommon::TConfSetting<TType, false>& setting, const TString& cluster) { 
+    Y_UNUSED(cluster); 
+    return setting.Get(); 
+} 
+ 
+} 
+ 
 namespace NCommon {
 
 class TSettingDispatcher: public TThrRefBase {
@@ -113,9 +113,9 @@ public:
             return Name_ ;
         }
 
-        virtual void Handle(const TString& cluster, const TMaybe<TString>& value, bool validateOnly) = 0;
+        virtual void Handle(const TString& cluster, const TMaybe<TString>& value, bool validateOnly) = 0; 
         virtual void FreezeDefault() = 0;
-        virtual void Restore(const TString& cluster) = 0;
+        virtual void Restore(const TString& cluster) = 0; 
         virtual bool IsRuntime() const = 0;
 
     protected:
@@ -140,7 +140,7 @@ public:
         {
         }
 
-        void Handle(const TString& cluster, const TMaybe<TString>& value, bool validateOnly) override {
+        void Handle(const TString& cluster, const TMaybe<TString>& value, bool validateOnly) override { 
             try {
                 if (value) {
                     TType v = Parser_(*value);
@@ -163,7 +163,7 @@ public:
             Defaul_ = Setting_;
         }
 
-        void Restore(const TString& cluster) override {
+        void Restore(const TString& cluster) override { 
             if (!Defaul_) {
                 ythrow yexception() << "Cannot restore " << Name_.Quote() << " setting without freeze";
             }
@@ -351,7 +351,7 @@ public:
     }
 
     void FreezeDefaults();
-    void Restore();
+    void Restore(); 
 
 protected:
     template <class TActivation>
diff --git a/ydb/library/yql/providers/common/config/yql_setting.h b/ydb/library/yql/providers/common/config/yql_setting.h
index 148b211bb7..315928fd2e 100644
--- a/ydb/library/yql/providers/common/config/yql_setting.h
+++ b/ydb/library/yql/providers/common/config/yql_setting.h
@@ -109,7 +109,7 @@ public:
     TConfSetting& operator =(const TConfSetting&) = default;
     TConfSetting& operator =(TConfSetting&&) = default;
 
-    TMaybe<TType> Get() const {
+    TMaybe<TType> Get() const { 
         return Value;
     }
 
diff --git a/ydb/library/yql/providers/common/gateway/ya.make b/ydb/library/yql/providers/common/gateway/ya.make
index 488ab986ea..27c56466b1 100644
--- a/ydb/library/yql/providers/common/gateway/ya.make
+++ b/ydb/library/yql/providers/common/gateway/ya.make
@@ -1,18 +1,18 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(
     spuchin
     g:yql_ydb_core
 )
-
-SRCS(
-    yql_provider_gateway.h
-    yql_provider_gateway.cpp
-)
-
-PEERDIR(
+ 
+SRCS( 
+    yql_provider_gateway.h 
+    yql_provider_gateway.cpp 
+) 
+ 
+PEERDIR( 
     library/cpp/threading/future
     ydb/library/yql/ast
-)
-
-END()
+) 
+ 
+END() 
diff --git a/ydb/library/yql/providers/common/gateway/yql_provider_gateway.cpp b/ydb/library/yql/providers/common/gateway/yql_provider_gateway.cpp
index 3c92c84692..47952915f2 100644
--- a/ydb/library/yql/providers/common/gateway/yql_provider_gateway.cpp
+++ b/ydb/library/yql/providers/common/gateway/yql_provider_gateway.cpp
@@ -1,4 +1,4 @@
-#include "yql_provider_gateway.h"
+#include "yql_provider_gateway.h" 
 
 #include <ydb/library/yql/core/issue/yql_issue.h>
 #include <ydb/library/yql/utils/log/log.h>
@@ -6,35 +6,35 @@
 namespace NYql {
 namespace NCommon {
 
-void TOperationResult::AddIssue(const TIssue& issue) {
-    WalkThroughIssues(issue, false, [&](const TIssue& err, ui16 level) {
-        Y_UNUSED(level);
+void TOperationResult::AddIssue(const TIssue& issue) { 
+    WalkThroughIssues(issue, false, [&](const TIssue& err, ui16 level) { 
+        Y_UNUSED(level); 
         YQL_CLOG(NOTICE, ProviderCommon) << err;
     });
-    Issues_.AddIssue(issue);
+    Issues_.AddIssue(issue); 
 }
 
-void TOperationResult::AddIssues(const TIssues& issues) {
+void TOperationResult::AddIssues(const TIssues& issues) { 
     for (auto& topIssue: issues) {
-        WalkThroughIssues(topIssue, false, [&](const TIssue& err, ui16 level) {
-            Y_UNUSED(level);
+        WalkThroughIssues(topIssue, false, [&](const TIssue& err, ui16 level) { 
+            Y_UNUSED(level); 
             YQL_CLOG(NOTICE, ProviderCommon) << err;
         });
     }
-    Issues_.AddIssues(issues);
+    Issues_.AddIssues(issues); 
 }
 
 void TOperationResult::SetException(const std::exception& e, const TPosition& pos) {
     YQL_CLOG(ERROR, ProviderCommon) << e.what();
-
-    auto issue = ExceptionToIssue(e, pos);
-    Status_ = static_cast<NYql::EYqlIssueCode>(issue.GetCode());
-    Issues_.AddIssue(issue);
-}
-
-void TOperationResult::ReportIssues(TIssueManager& issueManager) const {
-    issueManager.RaiseIssues(Issues_);
+ 
+    auto issue = ExceptionToIssue(e, pos); 
+    Status_ = static_cast<NYql::EYqlIssueCode>(issue.GetCode()); 
+    Issues_.AddIssue(issue); 
 }
 
+void TOperationResult::ReportIssues(TIssueManager& issueManager) const { 
+    issueManager.RaiseIssues(Issues_); 
+} 
+ 
 } // NCommon
 } // NYql
diff --git a/ydb/library/yql/providers/common/gateway/yql_provider_gateway.h b/ydb/library/yql/providers/common/gateway/yql_provider_gateway.h
index c4b498e9a1..92aa670a44 100644
--- a/ydb/library/yql/providers/common/gateway/yql_provider_gateway.h
+++ b/ydb/library/yql/providers/common/gateway/yql_provider_gateway.h
@@ -1,93 +1,93 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/core/issue/yql_issue.h>
 #include <ydb/library/yql/public/issue/yql_issue_manager.h>
-
+ 
 #include <library/cpp/threading/future/future.h>
-
-namespace NYql {
-namespace NCommon {
-
-class TOperationResult {
-public:
+ 
+namespace NYql { 
+namespace NCommon { 
+ 
+class TOperationResult { 
+public: 
     [[nodiscard]]
-    bool Success() const { return Status_ == TIssuesIds::SUCCESS; };
-    const EYqlIssueCode& Status() const { return Status_; }
-    const TIssues& Issues() const { return Issues_; }
-
-    void SetSuccess() { Status_ = TIssuesIds::SUCCESS; }
-    void SetStatus(EYqlIssueCode status) { Status_ = status; }
-
-    void AddIssue(const TIssue& issue);
-    void AddIssues(const TIssues& issues);
+    bool Success() const { return Status_ == TIssuesIds::SUCCESS; }; 
+    const EYqlIssueCode& Status() const { return Status_; } 
+    const TIssues& Issues() const { return Issues_; } 
+ 
+    void SetSuccess() { Status_ = TIssuesIds::SUCCESS; } 
+    void SetStatus(EYqlIssueCode status) { Status_ = status; } 
+ 
+    void AddIssue(const TIssue& issue); 
+    void AddIssues(const TIssues& issues); 
     void SetException(const std::exception& e, const TPosition& pos = {});
-
-    void ReportIssues(TIssueManager& issueManager) const;
-private:
-    EYqlIssueCode Status_ = TIssuesIds::DEFAULT_ERROR;
-    TIssues Issues_;
-};
-
-template<typename TResult>
+ 
+    void ReportIssues(TIssueManager& issueManager) const; 
+private: 
+    EYqlIssueCode Status_ = TIssuesIds::DEFAULT_ERROR; 
+    TIssues Issues_; 
+}; 
+ 
+template<typename TResult> 
 TResult ResultFromException(const std::exception& e, const TPosition& pos = {}) {
-    TResult result;
+    TResult result; 
     result.SetException(e, pos);
-    return result;
-}
-
-template<typename TResult>
-TResult ResultFromIssues(EYqlIssueCode status, const TString& message, const TIssues& issues) {
-    TIssue statusIssue = message.empty()
-        ? YqlIssue(TPosition(), status)
-        : YqlIssue(TPosition(), status, message);
-
-    for (auto& issue : issues) {
-        statusIssue.AddSubIssue(MakeIntrusive<TIssue>(issue));
-    }
-
-    TResult result;
-    result.SetStatus(status);
-    result.AddIssue(statusIssue);
-
-    return result;
-}
-
-template<typename TResult>
-TResult ResultFromIssues(EYqlIssueCode status, const TIssues& issues) {
-    return ResultFromIssues<TResult>(status, "", issues);
-}
-
-template<typename TResult>
-TResult ResultFromError(const TIssue& error) {
-    TResult result;
-    result.AddIssue(error);
-
-    return result;
-}
-
-template<typename TResult>
-TResult ResultFromError(const TString& error, TPosition pos = TPosition()) {
-    return ResultFromError<TResult>(TIssue(pos, error));
-}
-
-template<typename TResult>
+    return result; 
+} 
+ 
+template<typename TResult> 
+TResult ResultFromIssues(EYqlIssueCode status, const TString& message, const TIssues& issues) { 
+    TIssue statusIssue = message.empty() 
+        ? YqlIssue(TPosition(), status) 
+        : YqlIssue(TPosition(), status, message); 
+ 
+    for (auto& issue : issues) { 
+        statusIssue.AddSubIssue(MakeIntrusive<TIssue>(issue)); 
+    } 
+ 
+    TResult result; 
+    result.SetStatus(status); 
+    result.AddIssue(statusIssue); 
+ 
+    return result; 
+} 
+ 
+template<typename TResult> 
+TResult ResultFromIssues(EYqlIssueCode status, const TIssues& issues) { 
+    return ResultFromIssues<TResult>(status, "", issues); 
+} 
+ 
+template<typename TResult> 
+TResult ResultFromError(const TIssue& error) { 
+    TResult result; 
+    result.AddIssue(error); 
+ 
+    return result; 
+} 
+ 
+template<typename TResult> 
+TResult ResultFromError(const TString& error, TPosition pos = TPosition()) { 
+    return ResultFromError<TResult>(TIssue(pos, error)); 
+} 
+ 
+template<typename TResult> 
 TResult ResultFromErrors(const TIssues& errors) {
-    TResult result;
-    result.AddIssues(errors);
-    return result;
-}
-
-template <typename T>
-inline void SetPromiseValue(NThreading::TPromise<T>& promise, const NThreading::TFuture<T>& future)
-{
-    future.Subscribe([=] (const NThreading::TFuture<T>& f) mutable {
+    TResult result; 
+    result.AddIssues(errors); 
+    return result; 
+} 
+ 
+template <typename T> 
+inline void SetPromiseValue(NThreading::TPromise<T>& promise, const NThreading::TFuture<T>& future) 
+{ 
+    future.Subscribe([=] (const NThreading::TFuture<T>& f) mutable { 
         try {
-            promise.SetValue(f.GetValue());
+            promise.SetValue(f.GetValue()); 
         } catch (...) {
             promise.SetException(std::current_exception());
         }
-    });
-}
-
+    }); 
+} 
+ 
 } // NCommon
 } // NYql
diff --git a/ydb/library/yql/providers/common/mkql/ya.make b/ydb/library/yql/providers/common/mkql/ya.make
index 8de943fad2..42b5377ced 100644
--- a/ydb/library/yql/providers/common/mkql/ya.make
+++ b/ydb/library/yql/providers/common/mkql/ya.make
@@ -1,21 +1,21 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(
     spuchin
     g:yql
     g:yql_ydb_core
 )
-
-SRCS(
+ 
+SRCS( 
     parser.cpp
     parser.h
     yql_provider_mkql.cpp
-    yql_provider_mkql.h
+    yql_provider_mkql.h 
     yql_type_mkql.cpp
     yql_type_mkql.h
-)
-
-PEERDIR(
+) 
+ 
+PEERDIR( 
     library/cpp/json
     ydb/library/yql/ast
     ydb/library/yql/minikql
@@ -26,8 +26,8 @@ PEERDIR(
     ydb/library/yql/core/expr_nodes
     ydb/library/yql/providers/common/schema/expr
     ydb/library/yql/providers/dq/expr_nodes
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
 END()
diff --git a/ydb/library/yql/providers/common/mkql/yql_provider_mkql.cpp b/ydb/library/yql/providers/common/mkql/yql_provider_mkql.cpp
index dd1f162d78..ba2a52b3d4 100644
--- a/ydb/library/yql/providers/common/mkql/yql_provider_mkql.cpp
+++ b/ydb/library/yql/providers/common/mkql/yql_provider_mkql.cpp
@@ -1,12 +1,12 @@
-#include "yql_provider_mkql.h"
+#include "yql_provider_mkql.h" 
 #include "yql_type_mkql.h"
-
+ 
 #include <ydb/library/yql/providers/common/schema/expr/yql_expr_schema.h>
 #include <ydb/library/yql/core/expr_nodes/yql_expr_nodes.h>
 #include <ydb/library/yql/core/yql_expr_type_annotation.h>
 #include <ydb/library/yql/core/yql_join.h>
 #include <ydb/library/yql/core/yql_opt_utils.h>
-
+ 
 #include <ydb/library/yql/minikql/mkql_node.h>
 #include <ydb/library/yql/minikql/mkql_node_cast.h>
 #include <ydb/library/yql/minikql/mkql_program_builder.h>
@@ -17,13 +17,13 @@
 #include <util/stream/null.h>
 
 #include <array>
-
-using namespace NKikimr;
-using namespace NKikimr::NMiniKQL;
-
-namespace NYql {
-namespace NCommon {
-
+ 
+using namespace NKikimr; 
+using namespace NKikimr::NMiniKQL; 
+ 
+namespace NYql { 
+namespace NCommon { 
+ 
 TRuntimeNode CombineByKeyImpl(const TExprNode& node, TMkqlBuildContext& ctx) {
     NNodes::TCoCombineByKey combine(&node);
     const bool isStreamOrFlow = combine.Ref().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Stream ||
@@ -32,17 +32,17 @@ TRuntimeNode CombineByKeyImpl(const TExprNode& node, TMkqlBuildContext& ctx) {
     YQL_ENSURE(!isStreamOrFlow);
 
     const auto input = MkqlBuildExpr(combine.Input().Ref(), ctx);
-
-    TRuntimeNode preMapList = ctx.ProgramBuilder.FlatMap(input, [&](TRuntimeNode item) {
+ 
+    TRuntimeNode preMapList = ctx.ProgramBuilder.FlatMap(input, [&](TRuntimeNode item) { 
         return MkqlBuildLambda(combine.PreMapLambda().Ref(), ctx, {item});
-    });
-
+    }); 
+ 
     const auto dict = ctx.ProgramBuilder.ToHashedDict(preMapList, true, [&](TRuntimeNode item) {
         return MkqlBuildLambda(combine.KeySelectorLambda().Ref(), ctx, {item});
     }, [&](TRuntimeNode item) {
         return item;
     });
-
+ 
     const auto values = ctx.ProgramBuilder.DictItems(dict);
     return ctx.ProgramBuilder.FlatMap(values, [&](TRuntimeNode item) {
         auto key = ctx.ProgramBuilder.Nth(item, 0);
@@ -51,16 +51,16 @@ TRuntimeNode CombineByKeyImpl(const TExprNode& node, TMkqlBuildContext& ctx) {
             return MkqlBuildLambda(combine.InitHandlerLambda().Ref(), ctx, {key, item2});
         }, [&](TRuntimeNode item2, TRuntimeNode state) {
             return MkqlBuildLambda(combine.UpdateHandlerLambda().Ref(), ctx, {key, item2, state});
-        });
+        }); 
         auto res = ctx.ProgramBuilder.FlatMap(fold1, [&](TRuntimeNode state) {
             return MkqlBuildLambda(combine.FinishHandlerLambda().Ref(), ctx, {key, state});
         });
         return res;
     });
 }
-
-namespace {
-
+ 
+namespace { 
+ 
 std::array<TRuntimeNode, 2U> MkqlBuildSplitLambda(const TExprNode& lambda, TMkqlBuildContext& ctx, const std::initializer_list<TRuntimeNode>& args) {
     TMkqlBuildContext::TArgumentsMap innerArguments;
     innerArguments.reserve(args.size());
@@ -168,33 +168,33 @@ std::vector<TRuntimeNode> GetArgumentsFrom(const TExprNode& node, TMkqlBuildCont
 NUdf::TDataTypeId ParseDataType(const TExprNode& owner, const std::string_view& type) {
     if (const auto slot = NUdf::FindDataSlot(type)) {
         return NUdf::GetDataTypeInfo(*slot).TypeId;
-    }
-
-    ythrow TNodeException(owner) << "Unsupported data type: " << type;
-}
-
+    } 
+ 
+    ythrow TNodeException(owner) << "Unsupported data type: " << type; 
+} 
+ 
 EJoinKind GetJoinKind(const TExprNode& owner, const std::string_view& content) {
-    if (content == "Inner") {
-        return EJoinKind::Inner;
-    }
-    else if (content == "Left") {
-        return EJoinKind::Left;
-    }
-    else if (content == "Right") {
-        return EJoinKind::Right;
-    }
-    else if (content == "Full") {
-        return EJoinKind::Full;
-    }
-    else if (content == "LeftOnly") {
-        return EJoinKind::LeftOnly;
-    }
-    else if (content == "RightOnly") {
-        return EJoinKind::RightOnly;
-    }
-    else if (content == "Exclusion") {
-        return EJoinKind::Exclusion;
-    }
+    if (content == "Inner") { 
+        return EJoinKind::Inner; 
+    } 
+    else if (content == "Left") { 
+        return EJoinKind::Left; 
+    } 
+    else if (content == "Right") { 
+        return EJoinKind::Right; 
+    } 
+    else if (content == "Full") { 
+        return EJoinKind::Full; 
+    } 
+    else if (content == "LeftOnly") { 
+        return EJoinKind::LeftOnly; 
+    } 
+    else if (content == "RightOnly") { 
+        return EJoinKind::RightOnly; 
+    } 
+    else if (content == "Exclusion") { 
+        return EJoinKind::Exclusion; 
+    } 
     else if (content == "LeftSemi") {
         return EJoinKind::LeftSemi;
     }
@@ -204,11 +204,11 @@ EJoinKind GetJoinKind(const TExprNode& owner, const std::string_view& content) {
     else if (content == "Cross") {
         return EJoinKind::Cross;
     }
-    else {
-        ythrow TNodeException(owner) << "Unexpected join kind: " << content;
-    }
-}
-
+    else { 
+        ythrow TNodeException(owner) << "Unexpected join kind: " << content; 
+    } 
+} 
+ 
 template<typename TLayout>
 std::pair<TLayout, ui16> CutTimezone(const std::string_view& atom) {
     const auto pos = atom.find(',');
@@ -216,8 +216,8 @@ std::pair<TLayout, ui16> CutTimezone(const std::string_view& atom) {
     return std::make_pair(::FromString<TLayout>(atom.substr(0, pos)), GetTimezoneId(atom.substr(pos + 1)));
 }
 
-} // namespace
-
+} // namespace 
+ 
 bool TMkqlCallableCompilerBase::HasCallable(const std::string_view& name) const {
     return Callables.contains(name);
 }
@@ -225,14 +225,14 @@ bool TMkqlCallableCompilerBase::HasCallable(const std::string_view& name) const
 void TMkqlCallableCompilerBase::AddCallable(const std::string_view& name, TCompiler compiler) {
     const auto result = Callables.emplace(TString(name), compiler);
     YQL_ENSURE(result.second, "Callable already exists: " << name);
-}
-
+} 
+ 
 void TMkqlCallableCompilerBase::AddCallable(const std::initializer_list<std::string_view>& names, TCompiler compiler) {
     for (const auto& name : names) {
-        AddCallable(name, compiler);
-    }
-}
-
+        AddCallable(name, compiler); 
+    } 
+} 
+ 
 void TMkqlCallableCompilerBase::ChainCallable(const std::string_view& name, TCompiler compiler) {
     auto prevCompiler = GetCallable(name);
     auto chainedCompiler = [compiler = std::move(compiler), prevCompiler = std::move(prevCompiler)](const TExprNode& node, TMkqlBuildContext& ctx) -> NKikimr::NMiniKQL::TRuntimeNode {
@@ -326,14 +326,14 @@ void TMkqlCallableCompilerBase::OverrideCallable(const std::string_view& name, T
     YQL_ENSURE(Callables.cend() != prevCompiler, "Missed callable: " << name);
     prevCompiler->second = compiler;
     Callables[name] = compiler;
-}
-
+} 
+ 
 IMkqlCallableCompiler::TCompiler TMkqlCallableCompilerBase::GetCallable(const std::string_view& name) const {
     const auto compiler = Callables.find(name);
     YQL_ENSURE(Callables.cend() != compiler, "Missed callable: " << name);
     return compiler->second;
-}
-
+} 
+ 
 IMkqlCallableCompiler::TCompiler TMkqlCallableCompilerBase::FindCallable(const std::string_view& name) const {
     const auto compiler = Callables.find(name);
     return Callables.cend() != compiler ? compiler->second : IMkqlCallableCompiler::TCompiler();
@@ -368,15 +368,15 @@ void TMkqlCommonCallableCompiler::OverrideCallable(const std::string_view& name,
         TMkqlCallableCompilerBase::OverrideCallable(name, compiler);
     } else {
         YQL_ENSURE(GetShared().HasCallable(name));
-        TMkqlCallableCompilerBase::AddCallable(name, compiler);
-    }
-}
-
+        TMkqlCallableCompilerBase::AddCallable(name, compiler); 
+    } 
+} 
+ 
 void TMkqlCommonCallableCompiler::AddCallable(const std::string_view& name, TCompiler compiler) {
     YQL_ENSURE(!GetShared().HasCallable(name), "Compiler already set for callable: " << name);
-    TMkqlCallableCompilerBase::AddCallable(name, compiler);
-}
-
+    TMkqlCallableCompilerBase::AddCallable(name, compiler); 
+} 
+ 
 void TMkqlCommonCallableCompiler::AddCallable(const std::initializer_list<std::string_view>& names, TCompiler compiler) {
     for (const auto& name : names) {
         AddCallable(name, compiler);
@@ -447,63 +447,63 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         {"DictPayloads", &TProgramBuilder::DictPayloads},
 
         {"QueuePop", &TProgramBuilder::QueuePop}
-    });
-
+    }); 
+ 
     AddSimpleCallables({
         {"+", &TProgramBuilder::Add},
         {"-", &TProgramBuilder::Sub},
         {"*", &TProgramBuilder::Mul},
         {"/", &TProgramBuilder::Div},
         {"%", &TProgramBuilder::Mod},
-
+ 
         {"Add", &TProgramBuilder::Add},
         {"Sub", &TProgramBuilder::Sub},
         {"Mul", &TProgramBuilder::Mul},
         {"Div", &TProgramBuilder::Div},
         {"Mod", &TProgramBuilder::Mod},
-
+ 
         {"DecimalMul", &TProgramBuilder::DecimalMul},
         {"DecimalDiv", &TProgramBuilder::DecimalDiv},
         {"DecimalMod", &TProgramBuilder::DecimalMod},
-
+ 
         {"==", &TProgramBuilder::Equals},
         {"!=", &TProgramBuilder::NotEquals},
         {"<", &TProgramBuilder::Less},
         {"<=", &TProgramBuilder::LessOrEqual},
         {">", &TProgramBuilder::Greater},
         {">=", &TProgramBuilder::GreaterOrEqual},
-
+ 
         {"Equals", &TProgramBuilder::Equals},
         {"NotEquals", &TProgramBuilder::NotEquals},
         {"Less", &TProgramBuilder::Less},
         {"LessOrEqual", &TProgramBuilder::LessOrEqual},
         {"Greater", &TProgramBuilder::Greater},
         {"GreaterOrEqual", &TProgramBuilder::GreaterOrEqual},
-
+ 
         {"AggrEquals", &TProgramBuilder::AggrEquals},
         {"AggrNotEquals", &TProgramBuilder::AggrNotEquals},
         {"AggrLess", &TProgramBuilder::AggrLess},
         {"AggrLessOrEqual", &TProgramBuilder::AggrLessOrEqual},
         {"AggrGreater", &TProgramBuilder::AggrGreater},
         {"AggrGreaterOrEqual", &TProgramBuilder::AggrGreaterOrEqual},
-
+ 
         {"AggrMin", &TProgramBuilder::AggrMin},
         {"AggrMax", &TProgramBuilder::AggrMax},
         {"AggrAdd", &TProgramBuilder::AggrAdd},
-
+ 
         {"AggrCountUpdate", &TProgramBuilder::AggrCountUpdate},
-
+ 
         {"BitOr", &TProgramBuilder::BitOr},
         {"BitAnd", &TProgramBuilder::BitAnd},
         {"BitXor", &TProgramBuilder::BitXor},
-
+ 
         {"ShiftLeft", &TProgramBuilder::ShiftLeft},
         {"ShiftRight", &TProgramBuilder::ShiftRight},
         {"RotLeft", &TProgramBuilder::RotLeft},
         {"RotRight", &TProgramBuilder::RotRight},
-
+ 
         {"ListIf", &TProgramBuilder::ListIf},
-
+ 
         {"Concat", &TProgramBuilder::Concat},
         {"AggrConcat", &TProgramBuilder::AggrConcat},
         {"ByteAt", &TProgramBuilder::ByteAt},
@@ -528,8 +528,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         {"SqueezeToList", &TProgramBuilder::SqueezeToList},
 
         {"QueuePush", &TProgramBuilder::QueuePush}
-    });
-
+    }); 
+ 
     AddSimpleCallables({
         {"Substring", &TProgramBuilder::Substring},
         {"Find", &TProgramBuilder::Find},
@@ -756,8 +756,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto structObj = MkqlBuildExpr(node.Head(), ctx);
         const auto name = node.Tail().Content();
         return ctx.ProgramBuilder.Member(structObj, name);
-    });
-
+    }); 
+ 
     AddCallable("RemoveMember", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto structObj = MkqlBuildExpr(node.Head(), ctx);
         const auto name = node.Tail().Content();
@@ -774,8 +774,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto tupleObj = MkqlBuildExpr(node.Head(), ctx);
         const auto index = FromString<ui32>(node.Tail().Content());
         return ctx.ProgramBuilder.Nth(tupleObj, index);
-    });
-
+    }); 
+ 
     AddCallable("Guess", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto variantObj = MkqlBuildExpr(node.Head(), ctx);
         auto type = node.Head().GetTypeAnn();
@@ -844,8 +844,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
 
     AddCallable("Uint8", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral(FromString<ui8>(node.Head(), NUdf::EDataSlot::Uint8));
-    });
-
+    }); 
+ 
     AddCallable("Int8", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral(FromString<i8>(node.Head(), NUdf::EDataSlot::Int8));
     });
@@ -860,32 +860,32 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
 
     AddCallable("Int32", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral(FromString<i32>(node.Head(), NUdf::EDataSlot::Int32));
-    });
-
+    }); 
+ 
     AddCallable("Uint32", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral(FromString<ui32>(node.Head(), NUdf::EDataSlot::Uint32));
-    });
-
+    }); 
+ 
     AddCallable("Int64", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral(FromString<i64>(node.Head(), NUdf::EDataSlot::Int64));
-    });
-
+    }); 
+ 
     AddCallable("Uint64", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral(FromString<ui64>(node.Head(), NUdf::EDataSlot::Uint64));
-    });
-
+    }); 
+ 
     AddCallable("String", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral<NUdf::EDataSlot::String>(node.Head().Content());
-    });
-
+    }); 
+ 
     AddCallable("Utf8", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral<NUdf::EDataSlot::Utf8>(node.Head().Content());
-    });
-
+    }); 
+ 
     AddCallable("Yson", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral<NUdf::EDataSlot::Yson>(node.Head().Content());
-    });
-
+    }); 
+ 
     AddCallable("Json", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral<NUdf::EDataSlot::Json>(node.Head().Content());
     });
@@ -915,16 +915,16 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
 
     AddCallable("Bool", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral(FromString<bool>(node.Head(), NUdf::EDataSlot::Bool));
-    });
-
+    }); 
+ 
     AddCallable("Float", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral(FromString<float>(node.Head(), NUdf::EDataSlot::Float));
-    });
-
+    }); 
+ 
     AddCallable("Double", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral(FromString<double>(node.Head(), NUdf::EDataSlot::Double));
-    });
-
+    }); 
+ 
     AddCallable("DyNumber", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const NUdf::TUnboxedValue val = ValueFromString(NUdf::EDataSlot::DyNumber, node.Head().Content());
         MKQL_ENSURE(val, "Bad DyNumber: " << TString(node.Head().Content()).Quote());
@@ -1004,30 +1004,30 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto name = node.Tail().Content();
         return ctx.ProgramBuilder.Extract(list, name);
     });
-
+ 
     AddCallable("OrderedExtract", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto list = MkqlBuildExpr(node.Head(), ctx);
         const auto name = node.Child(1)->Content();
         return ctx.ProgramBuilder.OrderedExtract(list, name);
-    });
-
+    }); 
+ 
     AddCallable("Fold", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto list = MkqlBuildExpr(node.Head(), ctx);
         const auto state = MkqlBuildExpr(*node.Child(1), ctx);
         return ctx.ProgramBuilder.Fold(list, state, [&](TRuntimeNode item, TRuntimeNode state) {
             return MkqlBuildLambda(*node.Child(2), ctx, {item, state});
         });
-    });
-
+    }); 
+ 
     AddCallable("Fold1", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto list = MkqlBuildExpr(node.Head(), ctx);
         return ctx.ProgramBuilder.Fold1(list, [&](TRuntimeNode item) {
             return MkqlBuildLambda(*node.Child(1), ctx, {item});
-        }, [&](TRuntimeNode item, TRuntimeNode state) {
+        }, [&](TRuntimeNode item, TRuntimeNode state) { 
             return MkqlBuildLambda(*node.Child(2), ctx, {item, state});
         });
-    });
-
+    }); 
+ 
     AddCallable("Condense", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto stream = MkqlBuildExpr(node.Head(), ctx);
         const auto state = MkqlBuildExpr(*node.Child(1), ctx);
@@ -1085,8 +1085,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         return ctx.ProgramBuilder.Sort(list, ascending, [&](TRuntimeNode item) {
             return MkqlBuildLambda(*node.Child(2), ctx, {item});
         });
-    });
-
+    }); 
+ 
     AddCallable({"Top", "TopSort"}, [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto list = MkqlBuildExpr(node.Head(), ctx);
         const auto count = MkqlBuildExpr(*node.Child(1), ctx);
@@ -1115,36 +1115,36 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         node.ForEachChild([&](const TExprNode& child) {
             members.emplace_back(child.Head().Content(), MkqlBuildExpr(child.Tail(), ctx));
         });
-
+ 
         return ctx.ProgramBuilder.NewStruct(verifiedStructType, members);
-    });
-
+    }); 
+ 
     AddCallable("AddMember", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto structObj = MkqlBuildExpr(node.Head(), ctx);
         const auto memberName = node.Child(1)->Content();
         const auto value = MkqlBuildExpr(node.Tail(), ctx);
         return ctx.ProgramBuilder.AddMember(structObj, memberName, value);
-    });
-
+    }); 
+ 
     AddCallable("List", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto listType = BuildType(node.Head(), *node.Head().GetTypeAnn()->Cast<TTypeExprType>()->GetType(), ctx.ProgramBuilder);
         const auto itemType = AS_TYPE(TListType, listType)->GetItemType();
         const auto& items = GetArgumentsFrom<1U>(node, ctx);
         return ctx.ProgramBuilder.NewList(itemType, items);
-    });
-
+    }); 
+ 
     AddCallable("FromString", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         const auto type = BuildType(node.Head(), *node.GetTypeAnn(), ctx.ProgramBuilder);
         return ctx.ProgramBuilder.FromString(arg, type);
-    });
-
+    }); 
+ 
     AddCallable("StrictFromString", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         const auto type = BuildType(node.Head(), *node.GetTypeAnn(), ctx.ProgramBuilder);
         return ctx.ProgramBuilder.StrictFromString(arg, type);
-    });
-
+    }); 
+ 
     AddCallable("FromBytes", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         const auto schemeType = ParseDataType(node, node.Tail().Content());
@@ -1155,14 +1155,14 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         const auto type = BuildType(node.Head(), *node.GetTypeAnn(), ctx.ProgramBuilder);
         return ctx.ProgramBuilder.Convert(arg, type);
-    });
-
+    }); 
+ 
     AddCallable("ToIntegral", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         const auto type = BuildType(node.Head(), *node.GetTypeAnn(), ctx.ProgramBuilder);
         return ctx.ProgramBuilder.ToIntegral(arg, type);
-    });
-
+    }); 
+ 
     AddCallable("UnsafeTimestampCast", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         const auto type = BuildType(node.Head(), *node.GetTypeAnn(), ctx.ProgramBuilder);
@@ -1173,8 +1173,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         const auto type = BuildType(node.Head(), *node.GetTypeAnn(), ctx.ProgramBuilder);
         return ctx.ProgramBuilder.Cast(arg, type);
-    });
-
+    }); 
+ 
     AddCallable("Default", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto type = BuildType(node, *node.GetTypeAnn(), ctx.ProgramBuilder);
         return ctx.ProgramBuilder.Default(type);
@@ -1184,24 +1184,24 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         auto ret = MkqlBuildExpr(node.Head(), ctx);
         for (ui32 i = 1; i < node.ChildrenSize(); ++i) {
             auto value = MkqlBuildExpr(*node.Child(i), ctx);
-            ret = ctx.ProgramBuilder.Coalesce(ret, value);
-        }
-
+            ret = ctx.ProgramBuilder.Coalesce(ret, value); 
+        } 
+ 
         return ret;
-    });
-
+    }); 
+ 
     AddCallable("Unwrap", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto opt = MkqlBuildExpr(node.Head(), ctx);
         const auto message = node.ChildrenSize() > 1 ? MkqlBuildExpr(node.Tail(), ctx) : ctx.ProgramBuilder.NewDataLiteral<NUdf::EDataSlot::String>("");
         const auto pos = ctx.ExprCtx.GetPosition(node.Pos());
         return ctx.ProgramBuilder.Unwrap(opt, message, pos.File, pos.Row, pos.Column);
-    });
-
+    }); 
+ 
     AddCallable("Nothing", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto optType = BuildType(node.Head(), *node.Head().GetTypeAnn()->Cast<TTypeExprType>()->GetType(), ctx.ProgramBuilder);
         return ctx.ProgramBuilder.NewEmptyOptional(optType);
-    });
-
+    }); 
+ 
     AddCallable("Unpickle", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto type = BuildType(node.Head(), *node.Head().GetTypeAnn()->Cast<TTypeExprType>()->GetType(), ctx.ProgramBuilder);
         const auto serialized = MkqlBuildExpr(node.Tail(), ctx);
@@ -1212,8 +1212,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto optType = BuildType(node.Head(), *node.Head().GetTypeAnn()->Cast<TTypeExprType>()->GetType(), ctx.ProgramBuilder);
         const auto arg = MkqlBuildExpr(node.Tail(), ctx);
         return ctx.ProgramBuilder.NewOptional(optType, arg);
-    });
-
+    }); 
+ 
     AddCallable("Iterator", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         const auto& args = GetArgumentsFrom<1U>(node, ctx);
@@ -1268,13 +1268,13 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
     AddCallable(LeftName, [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         return ctx.ProgramBuilder.Nth(arg, 0);
-    });
-
+    }); 
+ 
     AddCallable(RightName, [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         return ctx.ProgramBuilder.Nth(arg, 1);
-    });
-
+    }); 
+ 
     AddCallable("FilterNullMembers", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto list = MkqlBuildExpr(node.Head(), ctx);
         if (node.ChildrenSize() < 2U) {
@@ -1640,22 +1640,22 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
 
     AddCallable("ToDict", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto list = MkqlBuildExpr(node.Head(), ctx);
-        TMaybe<bool> isMany;
-        TMaybe<bool> isHashed;
+        TMaybe<bool> isMany; 
+        TMaybe<bool> isHashed; 
         TMaybe<ui64> itemsCount;
         bool isCompact;
         if (const auto error = ParseToDictSettings(node, ctx.ExprCtx, isMany, isHashed, itemsCount, isCompact)) {
             ythrow TNodeException(node) << error->Message;
-        }
-
+        } 
+ 
         const auto factory = *isHashed ? &TProgramBuilder::ToHashedDict : &TProgramBuilder::ToSortedDict;
         return (ctx.ProgramBuilder.*factory)(list, *isMany, [&](TRuntimeNode item) {
             return MkqlBuildLambda(*node.Child(1), ctx, {item});
         }, [&](TRuntimeNode item) {
             return MkqlBuildLambda(*node.Child(2), ctx, {item});
         }, isCompact, itemsCount.GetOrElse(0));
-    });
-
+    }); 
+ 
     AddCallable("SqueezeToDict", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto stream = MkqlBuildExpr(node.Head(), ctx);
         TMaybe<bool> isMany;
@@ -1696,18 +1696,18 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto list = MkqlBuildExpr(node.Head(), ctx);
         const auto dict = ctx.ProgramBuilder.ToHashedDict(list, true, [&](TRuntimeNode item) {
             return MkqlBuildLambda(*node.Child(1), ctx, {item});
-        }, [&](TRuntimeNode item) {
-            return item;
-        });
-
+        }, [&](TRuntimeNode item) { 
+            return item; 
+        }); 
+ 
         const auto values = ctx.ProgramBuilder.DictItems(dict);
         return ctx.ProgramBuilder.FlatMap(values, [&](TRuntimeNode item) {
             const auto key = ctx.ProgramBuilder.Nth(item, 0);
             const auto payloadList = ctx.ProgramBuilder.Nth(item, 1);
             return MkqlBuildLambda(*node.Child(2), ctx, {key, payloadList});
         });
-    });
-
+    }); 
+ 
     AddCallable("PartitionByKey", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const NNodes::TCoPartitionByKey partition(&node);
         const auto input = MkqlBuildExpr(partition.Input().Ref(), ctx);
@@ -1730,7 +1730,7 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
                 }
             );
         };
-
+ 
         switch (const auto kind = partition.Ref().GetTypeAnn()->GetKind()) {
             case ETypeAnnotationKind::Flow:
             case ETypeAnnotationKind::Stream: {
@@ -1742,56 +1742,56 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
                     ),
                     makePartitions
                 );
-
+ 
                 return ETypeAnnotationKind::Stream == kind ?MkqlBuildLambda(partition.ListHandlerLambda().Ref(), ctx, {sorted}):
                     ctx.ProgramBuilder.ToFlow(MkqlBuildLambda(partition.ListHandlerLambda().Ref(), ctx, {ctx.ProgramBuilder.FromFlow(sorted)}));
-            }
+            } 
             case ETypeAnnotationKind::List: {
                 const auto sorted = ctx.ProgramBuilder.Iterator(makePartitions(input), {});
                 return ctx.ProgramBuilder.Collect(MkqlBuildLambda(partition.ListHandlerLambda().Ref(), ctx, {sorted}));
             }
             default: break;
-        }
+        } 
         Y_FAIL("Wrong case.");
     });
 
     AddCallable("CombineByKey", [](const TExprNode& node, TMkqlBuildContext& ctx) {
-        return CombineByKeyImpl(node, ctx);
-    });
-
+        return CombineByKeyImpl(node, ctx); 
+    }); 
+ 
     AddCallable("Enumerate", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
-        TRuntimeNode start;
+        TRuntimeNode start; 
         if (node.ChildrenSize() > 1) {
             start = MkqlBuildExpr(*node.Child(1), ctx);
         } else {
             start = ctx.ProgramBuilder.NewDataLiteral<ui64>(0);
-        }
-
-        TRuntimeNode step;
+        } 
+ 
+        TRuntimeNode step; 
         if (node.ChildrenSize() > 2) {
             step = MkqlBuildExpr(node.Tail(), ctx);
         } else {
             step = ctx.ProgramBuilder.NewDataLiteral<ui64>(1);
-        }
-
+        } 
+ 
         return ctx.ProgramBuilder.Enumerate(arg, start, step);
-    });
-
+    }); 
+ 
     AddCallable("Dict", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto listType = BuildType(node.Head(), *node.Head().GetTypeAnn()->Cast<TTypeExprType>()->GetType(), ctx.ProgramBuilder);
         const auto dictType = AS_TYPE(TDictType, listType);
-
+ 
         std::vector<std::pair<TRuntimeNode, TRuntimeNode>> items;
         for (size_t i = 1; i < node.ChildrenSize(); ++i) {
             const auto key = MkqlBuildExpr(node.Child(i)->Head(), ctx);
             const auto payload = MkqlBuildExpr(node.Child(i)->Tail(), ctx);
             items.emplace_back(key, payload);
-        }
-
+        } 
+ 
         return ctx.ProgramBuilder.NewDict(dictType, items);
-    });
-
+    }); 
+ 
     AddCallable("Variant", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto varType = node.Child(2)->GetTypeAnn()->Cast<TTypeExprType>()->GetType()->Cast<TVariantExprType>();
         const auto type = BuildType(*node.Child(2), *varType, ctx.ProgramBuilder);
@@ -1807,16 +1807,16 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         members.reserve(node.ChildrenSize());
         node.ForEachChild([&](const TExprNode& child){ members.emplace_back(child.Head().Content(), MkqlBuildExpr(child.Tail(), ctx)); });
         return ctx.ProgramBuilder.NewStruct(members);
-    });
-
+    }); 
+ 
     AddCallable("AsDict", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         std::vector<std::pair<TRuntimeNode, TRuntimeNode>> items;
         items.reserve(node.ChildrenSize());
         node.ForEachChild([&](const TExprNode& child){ items.emplace_back(MkqlBuildExpr(*child.Child(0), ctx), MkqlBuildExpr(*child.Child(1), ctx)); });
         const auto dictType = ctx.ProgramBuilder.NewDictType(items[0].first.GetStaticType(), items[0].second.GetStaticType(), false);
         return ctx.ProgramBuilder.NewDict(dictType, items);
-    });
-
+    }); 
+ 
     AddCallable("Ensure", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto value = MkqlBuildExpr(node.Head(), ctx);
         const auto predicate = MkqlBuildExpr(*node.Child(1), ctx);
@@ -1842,20 +1842,20 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         return ctx.ProgramBuilder.IfPresent(optionals, [&](TRuntimeNode::TList items) {
             return MkqlBuildLambda(*node.Child(width), ctx, items);
         }, elseBranch);
-    });
-
-    AddCallable({"DataType",
-                 "ListType",
-                 "OptionalType",
-                 "TupleType",
-                 "StructType",
-                 "DictType",
-                 "VoidType",
+    }); 
+ 
+    AddCallable({"DataType", 
+                 "ListType", 
+                 "OptionalType", 
+                 "TupleType", 
+                 "StructType", 
+                 "DictType", 
+                 "VoidType", 
                  "NullType",
-                 "CallableType",
+                 "CallableType", 
                  "UnitType",
-                 "GenericType",
-                 "ResourceType",
+                 "GenericType", 
+                 "ResourceType", 
                  "TaggedType",
                  "VariantType",
                  "StreamType",
@@ -1865,18 +1865,18 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         [](const TExprNode& node, TMkqlBuildContext& ctx) {
             const auto type = BuildType(node, *node.GetTypeAnn(), ctx.ProgramBuilder);
             return TRuntimeNode(type, true);
-        });
-
+        }); 
+ 
     AddCallable("ParseType", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto type = BuildType(node, *node.GetTypeAnn(), ctx.ProgramBuilder);
         return TRuntimeNode(type, true);
-    });
-
+    }); 
+ 
     AddCallable("TypeOf", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto type = BuildType(node, *node.GetTypeAnn(), ctx.ProgramBuilder);
         return TRuntimeNode(type, true);
-    });
-
+    }); 
+ 
     AddCallable("EmptyList", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         Y_UNUSED(node);
         if (RuntimeVersion < 11) {
@@ -2044,12 +2044,12 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
             str = ctx.ProgramBuilder.NewDataLiteral<NUdf::EDataSlot::String>(FormatType(node.Head().GetTypeAnn()->Cast<TTypeExprType>()->GetType()));
         }
         return str;
-    });
-
+    }); 
+ 
     AddCallable("Void", [](const TExprNode&, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewVoid();
-    });
-
+    }); 
+ 
     AddCallable("Null", [](const TExprNode&, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewNull();
     });
@@ -2073,20 +2073,20 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto list2 = MkqlBuildExpr(*node.Child(1), ctx);
         const auto dict1 = ctx.ProgramBuilder.ToHashedDict(list1, true, [&](TRuntimeNode item) {
             return MkqlBuildLambda(*node.Child(2), ctx, {item});
-        }, [&](TRuntimeNode item) {
-            return item;
-        });
-
+        }, [&](TRuntimeNode item) { 
+            return item; 
+        }); 
+ 
         const auto dict2 = ctx.ProgramBuilder.ToHashedDict(list2, true, [&](TRuntimeNode item) {
             return MkqlBuildLambda(*node.Child(3), ctx, {item});
-        }, [&](TRuntimeNode item) {
-            return item;
-        });
-
+        }, [&](TRuntimeNode item) { 
+            return item; 
+        }); 
+ 
         const auto joinKind = GetJoinKind(node, node.Child(4)->Content());
         return ctx.ProgramBuilder.JoinDict(dict1, true, dict2, true, joinKind);
-    });
-
+    }); 
+ 
     AddCallable("JoinDict", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto dict1 = MkqlBuildExpr(*node.Child(0), ctx);
         const auto dict2 = MkqlBuildExpr(*node.Child(1), ctx);
@@ -2109,8 +2109,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         TCallableBuilder call(ctx.ProgramBuilder.GetTypeEnvironment(), node.Content(), ctx.ProgramBuilder.NewDataType(NUdf::TDataType<char*>::Id));
         call.Add(ctx.ProgramBuilder.NewDataLiteral<NUdf::EDataSlot::String>(node.Head().Content()));
         return TRuntimeNode(call.Build(), false);
-    });
-
+    }); 
+ 
     AddCallable("TablePath", [](const TExprNode&, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral<NUdf::EDataSlot::String>("");
     });
@@ -2129,16 +2129,16 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto pos = ctx.ExprCtx.GetPosition(node.Pos());
         return ctx.ProgramBuilder.TypedUdf(function, callableType, runConfig, userType, typeConfig,
             pos.File, pos.Row, pos.Column);
-    });
-
+    }); 
+ 
     AddCallable("ScriptUdf", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         EScriptType scriptType = ScriptTypeFromStr(node.Head().Content());
-        if (scriptType == EScriptType::Unknown) {
+        if (scriptType == EScriptType::Unknown) { 
             ythrow TNodeException(node.Head())
-                << "Unknown script type '"
+                << "Unknown script type '" 
                 << node.Head().Content() << '\'';
-        }
-
+        } 
+ 
         std::string_view funcName = node.Child(1)->Content();
         const auto typeNode = node.Child(2);
         const auto funcType = BuildType(*typeNode, *typeNode->GetTypeAnn(), ctx.ProgramBuilder);
@@ -2146,15 +2146,15 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto pos = ctx.ExprCtx.GetPosition(node.Pos());
         return ctx.ProgramBuilder.ScriptUdf(scriptType, funcName, funcType, script,
             pos.File, pos.Row, pos.Column);
-    });
-
+    }); 
+ 
     AddCallable("Apply", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto pos = ctx.ExprCtx.GetPosition(node.Pos());
         const auto callable = MkqlBuildExpr(node.Head(), ctx);
         const auto& args = GetArgumentsFrom<1U>(node, ctx);
         return ctx.ProgramBuilder.Apply(callable, args, pos.File, pos.Row, pos.Column);
-    });
-
+    }); 
+ 
     AddCallable("NamedApply", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto pos = ctx.ExprCtx.GetPosition(node.Pos());
         const auto callable = MkqlBuildExpr(node.Head(), ctx);
@@ -2227,8 +2227,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
             TMkqlBuildContext innerCtx(ctx, std::move(innerArguments), lambda.UniqueId());
             return MkqlBuildExpr(lambda.Tail(), innerCtx);
         });
-    });
-
+    }); 
+ 
     AddCallable("QueueCreate", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto initCapacity = MkqlBuildExpr(*node.Child(1), ctx);
         const auto initSize = MkqlBuildExpr(*node.Child(2), ctx);
@@ -2281,7 +2281,7 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
     AddCallable("Parameter", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         const NNodes::TCoParameter parameter(&node);
         return ctx.ProgramBuilder.Member(ctx.Parameters, parameter.Name());
-    });
+    }); 
 
     AddCallable("SecureParam", [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return ctx.ProgramBuilder.NewDataLiteral<NUdf::EDataSlot::String>(node.Head().Content());
@@ -2317,8 +2317,8 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
             return extend;
         }
     });
-}
-
+} 
+ 
 TRuntimeNode MkqlBuildLambda(const TExprNode& lambda, TMkqlBuildContext& ctx, const TRuntimeNode::TList& args) {
     MKQL_ENSURE(2U == lambda.ChildrenSize(), "Wide lambda isn't supported.");
     TMkqlBuildContext::TArgumentsMap innerArguments;
@@ -2348,9 +2348,9 @@ TRuntimeNode MkqlBuildExpr(const TExprNode& node, TMkqlBuildContext& ctx) {
         const auto knownNode = currCtx->Memoization.find(&node);
         if (currCtx->Memoization.cend() != knownNode) {
             return knownNode->second;
-        }
-    }
-
+        } 
+    } 
+ 
     switch (const auto type = node.Type()) {
     case TExprNode::List:
         return CheckTypeAndMemoize(node, ctx, ctx.ProgramBuilder.NewTuple(GetAllArguments(node, ctx)));
@@ -2360,8 +2360,8 @@ TRuntimeNode MkqlBuildExpr(const TExprNode& node, TMkqlBuildContext& ctx) {
         ythrow TNodeException(node) << "Unexpected argument: " << node.Content();
     default:
         ythrow TNodeException(node) << "Unexpected node type: " << type;
-    }
-}
-
-} // namespace NCommon
-} // namespace NYql
+    } 
+} 
+ 
+} // namespace NCommon 
+} // namespace NYql 
diff --git a/ydb/library/yql/providers/common/mkql/yql_provider_mkql.h b/ydb/library/yql/providers/common/mkql/yql_provider_mkql.h
index a25c03b488..3006405cfe 100644
--- a/ydb/library/yql/providers/common/mkql/yql_provider_mkql.h
+++ b/ydb/library/yql/providers/common/mkql/yql_provider_mkql.h
@@ -1,30 +1,30 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/ast/yql_expr.h>
 #include <ydb/library/yql/minikql/mkql_node.h>
 #include <ydb/library/yql/minikql/mkql_program_builder.h>
-
-namespace NYql {
-namespace NCommon {
-
-class IMkqlCallableCompiler;
-
-struct TMkqlBuildContext {
+ 
+namespace NYql { 
+namespace NCommon { 
+ 
+class IMkqlCallableCompiler; 
+ 
+struct TMkqlBuildContext { 
     using TArgumentsMap = TNodeMap<NKikimr::NMiniKQL::TRuntimeNode>;
     using TMemoizedNodesMap = TArgumentsMap;
-
-    const IMkqlCallableCompiler& MkqlCompiler;
+ 
+    const IMkqlCallableCompiler& MkqlCompiler; 
     NKikimr::NMiniKQL::TProgramBuilder& ProgramBuilder;
     TExprContext& ExprCtx;
     TMemoizedNodesMap Memoization;
     TMkqlBuildContext *const ParentCtx = nullptr;
     const size_t Level = 0ULL;
     const ui64 LambdaId = 0ULL;
-    NKikimr::NMiniKQL::TRuntimeNode Parameters;
-
+    NKikimr::NMiniKQL::TRuntimeNode Parameters; 
+ 
     TMkqlBuildContext(const IMkqlCallableCompiler& mkqlCompiler, NKikimr::NMiniKQL::TProgramBuilder& builder, TExprContext& exprCtx, ui64 lambdaId = 0ULL, TArgumentsMap&& args = {})
-        : MkqlCompiler(mkqlCompiler)
-        , ProgramBuilder(builder)
+        : MkqlCompiler(mkqlCompiler) 
+        , ProgramBuilder(builder) 
         , ExprCtx(exprCtx)
         , Memoization(std::move(args))
         , LambdaId(lambdaId)
@@ -40,20 +40,20 @@ struct TMkqlBuildContext {
         , LambdaId(lambdaId)
         , Parameters(parent.Parameters)
     {}
-};
-
-class IMkqlCallableCompiler : public TThrRefBase {
-public:
+}; 
+ 
+class IMkqlCallableCompiler : public TThrRefBase { 
+public: 
     typedef std::function<NKikimr::NMiniKQL::TRuntimeNode(const TExprNode&, TMkqlBuildContext&)> TCompiler;
     virtual bool HasCallable(const std::string_view& name) const = 0;
     virtual TCompiler FindCallable(const std::string_view& name) const = 0;
     virtual TCompiler GetCallable(const std::string_view& name) const = 0;
-
-    virtual ~IMkqlCallableCompiler() {}
-};
-
-class TMkqlCallableCompilerBase : public IMkqlCallableCompiler {
-public:
+ 
+    virtual ~IMkqlCallableCompiler() {} 
+}; 
+ 
+class TMkqlCallableCompilerBase : public IMkqlCallableCompiler { 
+public: 
     bool HasCallable(const std::string_view& name) const override;
     TCompiler FindCallable(const std::string_view& name) const override;
     TCompiler GetCallable(const std::string_view& name) const override;
@@ -62,8 +62,8 @@ public:
     virtual void ChainCallable(const std::string_view& name, TCompiler compiler);
     virtual void ChainCallable(const std::initializer_list<std::string_view>& names, TCompiler compiler);
     virtual void OverrideCallable(const std::string_view& name, TCompiler compiler);
-
-private:
+ 
+private: 
     THashMap<TString, TCompiler> Callables;
 
 protected:
@@ -73,10 +73,10 @@ protected:
     void AddSimpleCallables(const std::initializer_list<std::pair<std::string_view, NKikimr::NMiniKQL::TProgramBuilder::ArrayFunctionMethod>>& callables);
     void AddSimpleCallables(const std::initializer_list<std::pair<std::string_view, NKikimr::NMiniKQL::TProgramBuilder::ProcessFunctionMethod>>& callables);
     void AddSimpleCallables(const std::initializer_list<std::pair<std::string_view, NKikimr::NMiniKQL::TProgramBuilder::NarrowFunctionMethod>>& callables);
-};
-
-class TMkqlCommonCallableCompiler : public TMkqlCallableCompilerBase {
-public:
+}; 
+ 
+class TMkqlCommonCallableCompiler : public TMkqlCallableCompilerBase { 
+public: 
     bool HasCallable(const std::string_view& name) const override;
     TCompiler FindCallable(const std::string_view& name) const override;
     TCompiler GetCallable(const std::string_view& name) const override;
@@ -93,12 +93,12 @@ private:
     const TShared& GetShared() const {
         return *Singleton<TShared>();
     }
-};
-
+}; 
+ 
 NKikimr::NMiniKQL::TRuntimeNode CombineByKeyImpl(const TExprNode& node, TMkqlBuildContext& ctx);
 NKikimr::NMiniKQL::TRuntimeNode MkqlBuildExpr(const TExprNode& node, TMkqlBuildContext& ctx);
 NKikimr::NMiniKQL::TRuntimeNode MkqlBuildLambda(const TExprNode& lambda, TMkqlBuildContext& ctx, const NKikimr::NMiniKQL::TRuntimeNode::TList& args);
 NKikimr::NMiniKQL::TRuntimeNode::TList MkqlBuildWideLambda(const TExprNode& lambda, TMkqlBuildContext& ctx, const NKikimr::NMiniKQL::TRuntimeNode::TList& args);
 
-} // namespace NCommon
-} // namespace NYql
+} // namespace NCommon 
+} // namespace NYql 
diff --git a/ydb/library/yql/providers/common/mkql/yql_type_mkql.cpp b/ydb/library/yql/providers/common/mkql/yql_type_mkql.cpp
index 4ba0e6d740..16dbff6bd7 100644
--- a/ydb/library/yql/providers/common/mkql/yql_type_mkql.cpp
+++ b/ydb/library/yql/providers/common/mkql/yql_type_mkql.cpp
@@ -160,7 +160,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
             return nullptr;
         }
         return pgmBuilder.NewVariantType(underlyingType);
-    }
+    } 
 
     case ETypeAnnotationKind::Stream: {
         auto stream = annotation.Cast<TStreamExprType>();
diff --git a/ydb/library/yql/providers/common/proto/gateways_config.proto b/ydb/library/yql/providers/common/proto/gateways_config.proto
index 8561fe2536..cf7bf9a369 100644
--- a/ydb/library/yql/providers/common/proto/gateways_config.proto
+++ b/ydb/library/yql/providers/common/proto/gateways_config.proto
@@ -94,24 +94,24 @@ message TYtGatewayConfig {
 message THostPort {
     required string Host = 1;
     required uint32 Port = 2;
-    optional uint64 TotalTimeoutMs = 3;
+    optional uint64 TotalTimeoutMs = 3; 
 }
 
-message TKikimrGrpcData {
-    repeated string Locators = 1;
-    optional uint64 TimeoutMs = 2;
-    optional uint64 MaxMessageSizeBytes = 3;
-    optional uint32 MaxInFlight = 4;
-    optional bool EnableEndpointDiscovery = 5;
+message TKikimrGrpcData { 
+    repeated string Locators = 1; 
+    optional uint64 TimeoutMs = 2; 
+    optional uint64 MaxMessageSizeBytes = 3; 
+    optional uint32 MaxInFlight = 4; 
+    optional bool EnableEndpointDiscovery = 5; 
     optional bool UseLegacyApi = 6;
-}
-
+} 
+ 
 message TKikimrClusterConfig {
     optional string Name = 1;
     optional bool Default = 2 [default = false];
     repeated THostPort MessageBus = 3;
-    optional TKikimrGrpcData Grpc = 4;
-    optional string Database = 5;
+    optional TKikimrGrpcData Grpc = 4; 
+    optional string Database = 5; 
     optional uint32 TvmId = 6 [default = 0];
     optional string Token = 7;
     optional string ProxyUrl = 8;
diff --git a/ydb/library/yql/providers/common/provider/ya.make b/ydb/library/yql/providers/common/provider/ya.make
index 0d927b3376..f45bfe7390 100644
--- a/ydb/library/yql/providers/common/provider/ya.make
+++ b/ydb/library/yql/providers/common/provider/ya.make
@@ -1,28 +1,28 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(
     spuchin
     g:yql
     g:yql_ydb_core
 )
-
-SRCS(
+ 
+SRCS( 
     yql_data_provider_impl.cpp
     yql_data_provider_impl.h
     yql_provider.cpp
-    yql_provider.h
+    yql_provider.h 
     yql_provider_names.h
     yql_table_lookup.cpp
-    yql_table_lookup.h
-)
-
-PEERDIR(
+    yql_table_lookup.h 
+) 
+ 
+PEERDIR( 
     ydb/library/yql/minikql
     ydb/library/yql/public/udf
     ydb/library/yql/sql # fixme
     ydb/library/yql/core
-)
-
+) 
+ 
 YQL_LAST_ABI_VERSION()
 
-END()
+END() 
diff --git a/ydb/library/yql/providers/common/provider/yql_data_provider_impl.cpp b/ydb/library/yql/providers/common/provider/yql_data_provider_impl.cpp
index 8de3d57fd3..74baa862fb 100644
--- a/ydb/library/yql/providers/common/provider/yql_data_provider_impl.cpp
+++ b/ydb/library/yql/providers/common/provider/yql_data_provider_impl.cpp
@@ -282,10 +282,10 @@ ITrackableNodeProcessor& TDataProviderBase::GetTrackableNodeProcessor() {
     return NullTrackableNodeProcessor_;
 }
 
-IGraphTransformer& TDataProviderBase::GetPlanInfoTransformer() {
-    return NullTransformer_;
-}
-
+IGraphTransformer& TDataProviderBase::GetPlanInfoTransformer() { 
+    return NullTransformer_; 
+} 
+ 
 IDqIntegration* TDataProviderBase::GetDqIntegration() {
     return nullptr;
 }
diff --git a/ydb/library/yql/providers/common/provider/yql_data_provider_impl.h b/ydb/library/yql/providers/common/provider/yql_data_provider_impl.h
index 242a39877e..c534abce6d 100644
--- a/ydb/library/yql/providers/common/provider/yql_data_provider_impl.h
+++ b/ydb/library/yql/providers/common/provider/yql_data_provider_impl.h
@@ -80,7 +80,7 @@ public:
     bool CollectDiscoveredData(NYson::TYsonWriter& writer) override;
     IPlanFormatter& GetPlanFormatter() override;
     ITrackableNodeProcessor& GetTrackableNodeProcessor() override;
-    IGraphTransformer& GetPlanInfoTransformer() override;
+    IGraphTransformer& GetPlanInfoTransformer() override; 
     IDqIntegration* GetDqIntegration() override;
 
 protected:
diff --git a/ydb/library/yql/providers/common/provider/yql_provider.cpp b/ydb/library/yql/providers/common/provider/yql_provider.cpp
index aa782ee93f..ed8bff5fa4 100644
--- a/ydb/library/yql/providers/common/provider/yql_provider.cpp
+++ b/ydb/library/yql/providers/common/provider/yql_provider.cpp
@@ -1,5 +1,5 @@
-#include "yql_provider.h"
-
+#include "yql_provider.h" 
+ 
 #include <ydb/library/yql/core/expr_nodes/yql_expr_nodes.h>
 #include <ydb/library/yql/core/type_ann/type_ann_core.h>
 #include <ydb/library/yql/core/type_ann/type_ann_expr.h>
@@ -9,107 +9,107 @@
 #include <ydb/library/yql/core/yql_opt_utils.h>
 #include <ydb/library/yql/minikql/mkql_function_registry.h>
 #include <ydb/library/yql/minikql/mkql_program_builder.h>
-
+ 
 #include <util/folder/path.h>
 #include <util/generic/utility.h>
 
-namespace NYql {
-namespace NCommon {
-
-using namespace NNodes;
-
-bool TCommitSettings::EnsureModeEmpty(TExprContext& ctx) {
-    if (Mode) {
+namespace NYql { 
+namespace NCommon { 
+ 
+using namespace NNodes; 
+ 
+bool TCommitSettings::EnsureModeEmpty(TExprContext& ctx) { 
+    if (Mode) { 
         ctx.AddError(TIssue(ctx.GetPosition(Pos), TStringBuilder()
-            << "Unsupported mode:" << Mode.Cast().Value()));
-        return false;
-    }
-
-    return true;
-}
-
-bool TCommitSettings::EnsureEpochEmpty(TExprContext& ctx) {
-    if (Epoch) {
+            << "Unsupported mode:" << Mode.Cast().Value())); 
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
+bool TCommitSettings::EnsureEpochEmpty(TExprContext& ctx) { 
+    if (Epoch) { 
         ctx.AddError(TIssue(ctx.GetPosition(Pos), TStringBuilder()
-            << "Epochs are unsupported."));
-        return false;
-    }
-
-    return true;
-}
-
-bool TCommitSettings::EnsureOtherEmpty(TExprContext& ctx) {
-    if (!Other.Empty()) {
+            << "Epochs are unsupported.")); 
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
+bool TCommitSettings::EnsureOtherEmpty(TExprContext& ctx) { 
+    if (!Other.Empty()) { 
         ctx.AddError(TIssue(ctx.GetPosition(Pos), TStringBuilder()
-            << "Unsupported setting:" << Other.Item(0).Name().Value()));
-        return false;
-    }
-
-    return true;
-}
-
+            << "Unsupported setting:" << Other.Item(0).Name().Value())); 
+        return false; 
+    } 
+ 
+    return true; 
+} 
+ 
 TCoNameValueTupleList TCommitSettings::BuildNode(TExprContext& ctx) const {
     TVector<TExprBase> settings;
-
+ 
     auto addSettings = [this, &settings, &ctx] (const TString& name, TMaybeNode<TExprBase> value) {
-        if (value) {
-
+        if (value) { 
+ 
             auto node = Build<TCoNameValueTuple>(ctx, Pos)
-                .Name().Build(name)
-                .Value(value.Cast())
-                .Done();
-
-            settings.push_back(node);
-
-        }
-    };
-
-    addSettings("mode", Mode);
-    addSettings("epoch", Epoch);
-
-    for (auto setting : Other) {
-        settings.push_back(setting);
-    }
-
+                .Name().Build(name) 
+                .Value(value.Cast()) 
+                .Done(); 
+ 
+            settings.push_back(node); 
+ 
+        } 
+    }; 
+ 
+    addSettings("mode", Mode); 
+    addSettings("epoch", Epoch); 
+ 
+    for (auto setting : Other) { 
+        settings.push_back(setting); 
+    } 
+ 
     auto ret = Build<TCoNameValueTupleList>(ctx, Pos)
-        .Add(settings)
-        .Done();
-
-    return ret;
-}
-
+        .Add(settings) 
+        .Done(); 
+ 
+    return ret; 
+} 
+ 
 const TStructExprType* BuildCommonTableListType(TExprContext& ctx) {
     TVector<const TItemExprType*> items;
     auto stringType = ctx.MakeType<TDataExprType>(EDataSlot::String);
     auto listOfString = ctx.MakeType<TListExprType>(stringType);
-
+ 
     items.push_back(ctx.MakeType<TItemExprType>("Prefix", stringType));
     items.push_back(ctx.MakeType<TItemExprType>("Folders", listOfString));
     items.push_back(ctx.MakeType<TItemExprType>("Tables", listOfString));
-
+ 
     return ctx.MakeType<TStructExprType>(items);
-}
-
+} 
+ 
 TExprNode::TPtr BuildTypeExpr(TPositionHandle pos, const TTypeAnnotationNode& ann, TExprContext& ctx) {
     return ExpandType(pos, ann, ctx);
-}
-
+} 
+ 
 bool HasResOrPullOption(const TExprNode& node, const TStringBuf& option) {
     if (node.Content() == "Result" || node.Content() == "Pull") {
         auto options = node.Child(4);
         for (auto setting : options->Children()) {
             if (setting->Head().Content() == option) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
+                return true; 
+            } 
+        } 
+    } 
+    return false; 
+} 
+ 
 TVector<TString> GetResOrPullColumnHints(const TExprNode& node) {
     TVector<TString> columns;
     auto setting = GetSetting(*node.Child(4), "columns");
-    if (setting) {
+    if (setting) { 
         auto type = node.Head().GetTypeAnn();
         if (type->GetKind() != ETypeAnnotationKind::EmptyList) {
             auto structType = type->Cast<TListExprType>()->GetItemType()->Cast<TStructExprType>();
@@ -117,40 +117,40 @@ TVector<TString> GetResOrPullColumnHints(const TExprNode& node) {
                auto field = setting->Child(1)->Child(i);
                columns.push_back(TString(field->Content()));
             }
-        }
-    }
-    return columns;
-}
-
+        } 
+    } 
+    return columns; 
+} 
+ 
 TString FullTableName(const TStringBuf& cluster, const TStringBuf& table) {
-    return TStringBuilder() << cluster << ".[" << table << "]";
-}
-
-IDataProvider::TFillSettings GetFillSettings(const TExprNode& node) {
-    IDataProvider::TFillSettings fillSettings;
+    return TStringBuilder() << cluster << ".[" << table << "]"; 
+} 
+ 
+IDataProvider::TFillSettings GetFillSettings(const TExprNode& node) { 
+    IDataProvider::TFillSettings fillSettings; 
     fillSettings.AllResultsBytesLimit = node.Child(1)->Content().empty()
-        ? Nothing()
-        : TMaybe<ui64>(FromString<ui64>(node.Child(1)->Content()));
+        ? Nothing() 
+        : TMaybe<ui64>(FromString<ui64>(node.Child(1)->Content())); 
 
     fillSettings.RowsLimitPerWrite = node.Child(2)->Content().empty()
-        ? Nothing()
-        : TMaybe<ui64>(FromString<ui64>(node.Child(2)->Content()));
+        ? Nothing() 
+        : TMaybe<ui64>(FromString<ui64>(node.Child(2)->Content())); 
 
-    fillSettings.Format = (IDataProvider::EResultFormat)FromString<ui32>(node.Child(5)->Content());
-    fillSettings.FormatDetails = node.Child(3)->Content();
+    fillSettings.Format = (IDataProvider::EResultFormat)FromString<ui32>(node.Child(5)->Content()); 
+    fillSettings.FormatDetails = node.Child(3)->Content(); 
     fillSettings.Discard = FromString<bool>(node.Child(7)->Content());
-
-    return fillSettings;
-}
-
+ 
+    return fillSettings; 
+} 
+ 
 NYson::EYsonFormat GetYsonFormat(const IDataProvider::TFillSettings& fillSettings) {
-    YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Yson);
+    YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Yson); 
     return (NYson::EYsonFormat)FromString<ui32>(fillSettings.FormatDetails);
-}
-
-TWriteTableSettings ParseWriteTableSettings(TExprList node, TExprContext& ctx) {
+} 
+ 
+TWriteTableSettings ParseWriteTableSettings(TExprList node, TExprContext& ctx) { 
     TMaybeNode<TCoAtom> mode;
-    TMaybeNode<TExprList> columns;
+    TMaybeNode<TExprList> columns; 
     TMaybeNode<TCoAtomList> primaryKey;
     TMaybeNode<TCoAtomList> partitionBy;
     TMaybeNode<TCoNameValueTupleList> orderBy;
@@ -162,18 +162,18 @@ TWriteTableSettings ParseWriteTableSettings(TExprList node, TExprContext& ctx) {
     TMaybeNode<TExprList> columnFamilies;
     TVector<TCoNameValueTuple> tableSettings;
     TVector<TCoNameValueTuple> alterActions;
-    for (auto child : node) {
+    for (auto child : node) { 
         if (auto maybeTuple = child.Maybe<TCoNameValueTuple>()) {
-            auto tuple = maybeTuple.Cast();
-            auto name = tuple.Name().Value();
-
-            if (name == "mode") {
+            auto tuple = maybeTuple.Cast(); 
+            auto name = tuple.Name().Value(); 
+ 
+            if (name == "mode") { 
                 YQL_ENSURE(tuple.Value().Maybe<TCoAtom>());
                 mode = tuple.Value().Cast<TCoAtom>();
-            } else if (name == "columns")  {
-                YQL_ENSURE(tuple.Value().Maybe<TExprList>());
-                columns = tuple.Value().Cast<TExprList>();
-            } else if (name == "primarykey")  {
+            } else if (name == "columns")  { 
+                YQL_ENSURE(tuple.Value().Maybe<TExprList>()); 
+                columns = tuple.Value().Cast<TExprList>(); 
+            } else if (name == "primarykey")  { 
                 YQL_ENSURE(tuple.Value().Maybe<TCoAtomList>());
                 primaryKey = tuple.Value().Cast<TCoAtomList>();
             } else if (name == "partitionby")  {
@@ -182,10 +182,10 @@ TWriteTableSettings ParseWriteTableSettings(TExprList node, TExprContext& ctx) {
             } else if (name == "orderby")  {
                 YQL_ENSURE(tuple.Value().Maybe<TCoNameValueTupleList>());
                 orderBy = tuple.Value().Cast<TCoNameValueTupleList>();
-            } else if (name == "filter") {
+            } else if (name == "filter") { 
                 YQL_ENSURE(tuple.Value().Maybe<TCoLambda>());
                 filter = tuple.Value().Cast<TCoLambda>();
-            } else if (name == "update") {
+            } else if (name == "update") { 
                 YQL_ENSURE(tuple.Value().Maybe<TCoLambda>());
                 update = tuple.Value().Cast<TCoLambda>();
             } else if (name == "index") {
@@ -236,16 +236,16 @@ TWriteTableSettings ParseWriteTableSettings(TExprList node, TExprContext& ctx) {
                 for (const auto& item : tuple.Value().Cast<TCoNameValueTupleList>()) {
                     alterActions.push_back(item);
                 }
-            } else {
-                other.push_back(tuple);
-            }
-        }
-    }
-
+            } else { 
+                other.push_back(tuple); 
+            } 
+        } 
+    } 
+ 
     const auto& otherSettings = Build<TCoNameValueTupleList>(ctx, node.Pos())
-        .Add(other)
-        .Done();
-
+        .Add(other) 
+        .Done(); 
+ 
     const auto& idx = Build<TCoIndexList>(ctx, node.Pos())
         .Add(indexes)
         .Done();
@@ -267,22 +267,22 @@ TWriteTableSettings ParseWriteTableSettings(TExprList node, TExprContext& ctx) {
     }
 
     TWriteTableSettings ret(otherSettings);
-    ret.Mode = mode;
-    ret.Columns = columns;
-    ret.PrimaryKey = primaryKey;
+    ret.Mode = mode; 
+    ret.Columns = columns; 
+    ret.PrimaryKey = primaryKey; 
     ret.PartitionBy = partitionBy;
     ret.OrderBy = orderBy;
-    ret.Filter = filter;
-    ret.Update = update;
+    ret.Filter = filter; 
+    ret.Update = update; 
     ret.Indexes = idx;
     ret.Changefeeds = cfs;
     ret.ColumnFamilies = columnFamilies;
     ret.TableSettings = tableProfileSettings;
     ret.AlterActions = alterTableActions;
-
-    return ret;
-}
-
+ 
+    return ret; 
+} 
+ 
 TWriteRoleSettings ParseWriteRoleSettings(TExprList node, TExprContext& ctx) {
     TMaybeNode<TCoAtom> mode;
     TMaybeNode<TCoAtomList> roles;
@@ -316,41 +316,41 @@ TWriteRoleSettings ParseWriteRoleSettings(TExprList node, TExprContext& ctx) {
 }
 
 TCommitSettings ParseCommitSettings(NNodes::TCoCommit node, TExprContext& ctx) {
-    if (!node.Settings()) {
+    if (!node.Settings()) { 
         return TCommitSettings(Build<TCoNameValueTupleList>(ctx, node.Pos()).Done());
-    }
-
+    } 
+ 
     TMaybeNode<TCoAtom> mode;
     TMaybeNode<TCoAtom> epoch;
     TVector<TExprBase> other;
-
-    if (node.Settings()) {
-        auto settings = node.Settings().Cast();
-        for (auto setting : settings) {
-            if (setting.Name() == "mode") {
+ 
+    if (node.Settings()) { 
+        auto settings = node.Settings().Cast(); 
+        for (auto setting : settings) { 
+            if (setting.Name() == "mode") { 
                 YQL_ENSURE(setting.Value().Maybe<TCoAtom>());
                 mode = setting.Value().Cast<TCoAtom>();
-            } else if (setting.Name() == "epoch") {
+            } else if (setting.Name() == "epoch") { 
                 YQL_ENSURE(setting.Value().Maybe<TCoAtom>());
                 epoch = setting.Value().Cast<TCoAtom>();
-            } else {
-                other.push_back(setting);
-            }
-        }
-    }
-
+            } else { 
+                other.push_back(setting); 
+            } 
+        } 
+    } 
+ 
     auto otherSettings = Build<TCoNameValueTupleList>(ctx, node.Pos())
-        .Add(other)
-        .Done();
-
-    TCommitSettings ret(otherSettings);
-    ret.Pos = node.Pos();
-    ret.Mode = mode;
-    ret.Epoch = epoch;
-
-    return ret;
-}
-
+        .Add(other) 
+        .Done(); 
+ 
+    TCommitSettings ret(otherSettings); 
+    ret.Pos = node.Pos(); 
+    ret.Mode = mode; 
+    ret.Epoch = epoch; 
+ 
+    return ret; 
+} 
+ 
 TVector<TString> GetStructFields(const TTypeAnnotationNode* type) {
     TVector<TString> fields;
     if (type->GetKind() == ETypeAnnotationKind::List) {
@@ -365,59 +365,59 @@ TVector<TString> GetStructFields(const TTypeAnnotationNode* type) {
     return fields;
 }
 
-
-void TransformerStatsToYson(const TString& name, const IGraphTransformer::TStatistics& stats,
+ 
+void TransformerStatsToYson(const TString& name, const IGraphTransformer::TStatistics& stats, 
     NYson::TYsonWriter& writer)
-{
-    writer.OnBeginMap();
-
-    if (!name.empty()) {
-        writer.OnKeyedItem("Name");
-        writer.OnStringScalar(name);
-    }
-
-    if (stats.TransformDuration.MicroSeconds() > 0) {
-        writer.OnKeyedItem("TransformDurationUs");
-        writer.OnUint64Scalar(stats.TransformDuration.MicroSeconds());
-    }
-    if (stats.WaitDuration.MicroSeconds() > 0) {
-        writer.OnKeyedItem("WaitDurationUs");
-        writer.OnUint64Scalar(stats.WaitDuration.MicroSeconds());
-    }
-    if (stats.NewExprNodes > 0) {
-        writer.OnKeyedItem("NewExprNodes");
-        writer.OnInt64Scalar(stats.NewExprNodes);
-    }
-    if (stats.NewTypeNodes > 0) {
-        writer.OnKeyedItem("NewTypeNodes");
-        writer.OnInt64Scalar(stats.NewTypeNodes);
-    }
+{ 
+    writer.OnBeginMap(); 
+ 
+    if (!name.empty()) { 
+        writer.OnKeyedItem("Name"); 
+        writer.OnStringScalar(name); 
+    } 
+ 
+    if (stats.TransformDuration.MicroSeconds() > 0) { 
+        writer.OnKeyedItem("TransformDurationUs"); 
+        writer.OnUint64Scalar(stats.TransformDuration.MicroSeconds()); 
+    } 
+    if (stats.WaitDuration.MicroSeconds() > 0) { 
+        writer.OnKeyedItem("WaitDurationUs"); 
+        writer.OnUint64Scalar(stats.WaitDuration.MicroSeconds()); 
+    } 
+    if (stats.NewExprNodes > 0) { 
+        writer.OnKeyedItem("NewExprNodes"); 
+        writer.OnInt64Scalar(stats.NewExprNodes); 
+    } 
+    if (stats.NewTypeNodes > 0) { 
+        writer.OnKeyedItem("NewTypeNodes"); 
+        writer.OnInt64Scalar(stats.NewTypeNodes); 
+    } 
     if (stats.NewConstraintNodes > 0) {
         writer.OnKeyedItem("NewConstraintNodes");
         writer.OnInt64Scalar(stats.NewConstraintNodes);
     }
-    if (stats.Repeats > 0) {
-        writer.OnKeyedItem("Repeats");
-        writer.OnUint64Scalar(stats.Repeats);
-    }
-    if (stats.Restarts > 0) {
-        writer.OnKeyedItem("Restarts");
-        writer.OnUint64Scalar(stats.Restarts);
-    }
-
-    if (!stats.Stages.empty()) {
-        writer.OnKeyedItem("Stages");
-        writer.OnBeginList();
-        for (auto& stage : stats.Stages) {
-            writer.OnListItem();
-            TransformerStatsToYson(stage.first, stage.second, writer);
-        }
-        writer.OnEndList();
-    }
-
-    writer.OnEndMap();
-}
-
+    if (stats.Repeats > 0) { 
+        writer.OnKeyedItem("Repeats"); 
+        writer.OnUint64Scalar(stats.Repeats); 
+    } 
+    if (stats.Restarts > 0) { 
+        writer.OnKeyedItem("Restarts"); 
+        writer.OnUint64Scalar(stats.Restarts); 
+    } 
+ 
+    if (!stats.Stages.empty()) { 
+        writer.OnKeyedItem("Stages"); 
+        writer.OnBeginList(); 
+        for (auto& stage : stats.Stages) { 
+            writer.OnListItem(); 
+            TransformerStatsToYson(stage.first, stage.second, writer); 
+        } 
+        writer.OnEndList(); 
+    } 
+ 
+    writer.OnEndMap(); 
+} 
+ 
 bool FillUsedFilesImpl(
     const TExprNode& node,
     TUserDataTable& files,
@@ -679,41 +679,41 @@ bool FreezeUsedFilesSync(const TExprNode& node, TUserDataTable& files, const TTy
 }
 
 void WriteColumns(NYson::TYsonWriter& writer, const TExprBase& columns) {
-    if (auto maybeList = columns.Maybe<TCoAtomList>()) {
-        writer.OnBeginList();
-        for (const auto& column : maybeList.Cast()) {
-            writer.OnListItem();
-            writer.OnStringScalar(column.Value());
-        }
-        writer.OnEndList();
-    } else if (columns.Maybe<TCoVoid>()) {
-        writer.OnStringScalar("*");
-    } else {
-        writer.OnStringScalar("?");
-    }
-}
+    if (auto maybeList = columns.Maybe<TCoAtomList>()) { 
+        writer.OnBeginList(); 
+        for (const auto& column : maybeList.Cast()) { 
+            writer.OnListItem(); 
+            writer.OnStringScalar(column.Value()); 
+        } 
+        writer.OnEndList(); 
+    } else if (columns.Maybe<TCoVoid>()) { 
+        writer.OnStringScalar("*"); 
+    } else { 
+        writer.OnStringScalar("?"); 
+    } 
+} 
 
 TString SerializeExpr(TExprContext& ctx, const TExprNode& expr, bool withTypes) {
-    ui32 typeFlags = TExprAnnotationFlags::None;
-    if (withTypes) {
-        typeFlags |= TExprAnnotationFlags::Types;
-    }
-
+    ui32 typeFlags = TExprAnnotationFlags::None; 
+    if (withTypes) { 
+        typeFlags |= TExprAnnotationFlags::Types; 
+    } 
+ 
     auto ast = ConvertToAst(expr, ctx, typeFlags, true);
-    YQL_ENSURE(ast.Root);
-    return ast.Root->ToString();
-}
-
+    YQL_ENSURE(ast.Root); 
+    return ast.Root->ToString(); 
+} 
+ 
 TString ExprToPrettyString(TExprContext& ctx, const TExprNode& expr) {
     auto ast = ConvertToAst(expr, ctx, TExprAnnotationFlags::None, true);
-    TStringStream exprStream;
-    YQL_ENSURE(ast.Root);
-    ast.Root->PrettyPrintTo(exprStream, NYql::TAstPrintFlags::PerLine | NYql::TAstPrintFlags::ShortQuote);
-    TString exprText = exprStream.Str();
-
-    return exprText;
-}
-
+    TStringStream exprStream; 
+    YQL_ENSURE(ast.Root); 
+    ast.Root->PrettyPrintTo(exprStream, NYql::TAstPrintFlags::PerLine | NYql::TAstPrintFlags::ShortQuote); 
+    TString exprText = exprStream.Str(); 
+ 
+    return exprText; 
+} 
+ 
 bool IsFlowOrStream(const TExprNode* node) {
     auto kind = node->GetTypeAnn()->GetKind();
     return kind == ETypeAnnotationKind::Stream || kind == ETypeAnnotationKind::Flow;
@@ -1047,5 +1047,5 @@ void WriteStatistics(NYson::TYsonWriter& writer, bool totalOnly, const THashMap<
     writer.OnEndMap();
 }
 
-} // namespace NCommon
-} // namespace NYql
+} // namespace NCommon 
+} // namespace NYql 
diff --git a/ydb/library/yql/providers/common/provider/yql_provider.h b/ydb/library/yql/providers/common/provider/yql_provider.h
index 9e80cfd135..a1d2d0d51e 100644
--- a/ydb/library/yql/providers/common/provider/yql_provider.h
+++ b/ydb/library/yql/providers/common/provider/yql_provider.h
@@ -1,12 +1,12 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/ast/yql_expr.h>
 #include <ydb/library/yql/core/yql_data_provider.h>
 #include <ydb/library/yql/core/yql_graph_transformer.h>
 #include <ydb/library/yql/core/yql_expr_optimize.h>
 #include <ydb/library/yql/core/yql_expr_type_annotation.h>
 #include <ydb/library/yql/core/expr_nodes/yql_expr_nodes.h>
-
+ 
 #include <library/cpp/yson/writer.h>
 
 #include <util/generic/hash_set.h>
@@ -19,22 +19,22 @@ namespace NYson {
     class TYsonWriter;
 }
 
-namespace NKikimr {
-    namespace NMiniKQL {
-        class IFunctionRegistry;
-    }
-}
-
-namespace NYql {
-
-struct TTypeAnnotationContext;
+namespace NKikimr { 
+    namespace NMiniKQL { 
+        class IFunctionRegistry; 
+    } 
+} 
+ 
+namespace NYql { 
+ 
+struct TTypeAnnotationContext; 
 struct TOperationStatistics;
-
-namespace NCommon {
-
-struct TWriteTableSettings {
+ 
+namespace NCommon { 
+ 
+struct TWriteTableSettings { 
     NNodes::TMaybeNode<NNodes::TCoAtom> Mode;
-    NNodes::TMaybeNode<NNodes::TExprList> Columns;
+    NNodes::TMaybeNode<NNodes::TExprList> Columns; 
     NNodes::TMaybeNode<NNodes::TCoAtomList> PrimaryKey;
     NNodes::TMaybeNode<NNodes::TCoAtomList> PartitionBy;
     NNodes::TMaybeNode<NNodes::TCoNameValueTupleList> OrderBy;
@@ -46,11 +46,11 @@ struct TWriteTableSettings {
     NNodes::TMaybeNode<NNodes::TExprList> ColumnFamilies;
     NNodes::TMaybeNode<NNodes::TCoNameValueTupleList> TableSettings;
     NNodes::TMaybeNode<NNodes::TCoNameValueTupleList> AlterActions;
-
+ 
     TWriteTableSettings(const NNodes::TCoNameValueTupleList& other)
-        : Other(other) {}
-};
-
+        : Other(other) {} 
+}; 
+ 
 struct TWriteRoleSettings {
     NNodes::TMaybeNode<NNodes::TCoAtom> Mode;
     NNodes::TMaybeNode<NNodes::TCoAtomList> Roles;
@@ -60,46 +60,46 @@ struct TWriteRoleSettings {
         : Other(other) {}
 };
 
-struct TCommitSettings
-{
+struct TCommitSettings 
+{ 
     TPositionHandle Pos;
     NNodes::TMaybeNode<NNodes::TCoAtom> Mode;
     NNodes::TMaybeNode<NNodes::TCoAtom> Epoch;
     NNodes::TCoNameValueTupleList Other;
-
+ 
     TCommitSettings(NNodes::TCoNameValueTupleList other)
-        : Other(other) {}
-
+        : Other(other) {} 
+ 
     NNodes::TCoNameValueTupleList BuildNode(TExprContext& ctx) const;
-
-    bool EnsureModeEmpty(TExprContext& ctx);
-    bool EnsureEpochEmpty(TExprContext& ctx);
-    bool EnsureOtherEmpty(TExprContext& ctx);
-};
-
+ 
+    bool EnsureModeEmpty(TExprContext& ctx); 
+    bool EnsureEpochEmpty(TExprContext& ctx); 
+    bool EnsureOtherEmpty(TExprContext& ctx); 
+}; 
+ 
 const TStructExprType* BuildCommonTableListType(TExprContext& ctx);
-
+ 
 TExprNode::TPtr BuildTypeExpr(TPositionHandle pos, const TTypeAnnotationNode& ann, TExprContext& ctx);
-
+ 
 bool HasResOrPullOption(const TExprNode& node, const TStringBuf& option);
-
+ 
 TVector<TString> GetResOrPullColumnHints(const TExprNode& node);
-
-TWriteTableSettings ParseWriteTableSettings(NNodes::TExprList node, TExprContext& ctx);
-
+ 
+TWriteTableSettings ParseWriteTableSettings(NNodes::TExprList node, TExprContext& ctx); 
+ 
 TWriteRoleSettings ParseWriteRoleSettings(NNodes::TExprList node, TExprContext& ctx);
 
 TCommitSettings ParseCommitSettings(NNodes::TCoCommit node, TExprContext& ctx);
-
+ 
 TString FullTableName(const TStringBuf& cluster, const TStringBuf& table);
-
-IDataProvider::TFillSettings GetFillSettings(const TExprNode& node);
+ 
+IDataProvider::TFillSettings GetFillSettings(const TExprNode& node); 
 NYson::EYsonFormat GetYsonFormat(const IDataProvider::TFillSettings& fillSettings);
-
+ 
 TVector<TString> GetStructFields(const TTypeAnnotationNode* type);
 
 void TransformerStatsToYson(const TString& name, const IGraphTransformer::TStatistics& stats, NYson::TYsonWriter& writer);
-
+ 
 void FillSecureParams(const TExprNode::TPtr& node, const TTypeAnnotationContext& types, THashMap<TString, TString>& secureParams);
 
 bool FillUsedFiles(const TExprNode& node, TUserDataTable& files, const TTypeAnnotationContext& types, TExprContext& ctx, const TUserDataTable& crutches = {});
@@ -109,10 +109,10 @@ std::pair<IGraphTransformer::TStatus, TAsyncTransformCallbackFuture> FreezeUsedF
 bool FreezeUsedFilesSync(const TExprNode& node, TUserDataTable& files, const TTypeAnnotationContext& types, TExprContext& ctx, const std::function<bool(const TString&)>& urlDownloadFilter);
 
 void WriteColumns(NYson::TYsonWriter& writer, const NNodes::TExprBase& columns);
-
+ 
 TString SerializeExpr(TExprContext& ctx, const TExprNode& expr, bool withTypes = false);
 TString ExprToPrettyString(TExprContext& ctx, const TExprNode& expr);
-
+ 
 void WriteStream(NYson::TYsonWriter& writer, const TExprNode* node, const TExprNode* source);
 void WriteStreams(NYson::TYsonWriter& writer, TStringBuf name, const NNodes::TCoLambda& lambda);
 
@@ -120,5 +120,5 @@ double GetDataReplicationFactor(const TExprNode& lambda, TExprContext& ctx);
 
 void WriteStatistics(NYson::TYsonWriter& writer, bool totalOnly, const THashMap<ui32, TOperationStatistics>& statistics);
 
-} // namespace NCommon
-} // namespace NYql
+} // namespace NCommon 
+} // namespace NYql 
diff --git a/ydb/library/yql/providers/common/provider/yql_table_lookup.cpp b/ydb/library/yql/providers/common/provider/yql_table_lookup.cpp
index 93b84f6db0..2b19ce1582 100644
--- a/ydb/library/yql/providers/common/provider/yql_table_lookup.cpp
+++ b/ydb/library/yql/providers/common/provider/yql_table_lookup.cpp
@@ -1,571 +1,571 @@
-#include "yql_table_lookup.h"
-
+#include "yql_table_lookup.h" 
+ 
 #include <ydb/library/yql/ast/yql_expr.h>
 #include <array>
 
-namespace NYql {
-namespace NCommon {
-
-using namespace NNodes;
-
-namespace {
-
-template<typename TCompare>
+namespace NYql { 
+namespace NCommon { 
+ 
+using namespace NNodes; 
+ 
+namespace { 
+ 
+template<typename TCompare> 
 TExprBase BuildColumnCompare(TExprBase row, const TString& columnName, TExprBase value, TExprContext& ctx) {
-    auto compare = Build<TCompare>(ctx, row.Pos())
+    auto compare = Build<TCompare>(ctx, row.Pos()) 
         .template Left<TCoMember>()
-            .Struct(row)
-            .Name().Build(columnName)
-            .Build()
-        .Right(value)
-        .Done();
-
-    TMaybeNode<TExprBase> ret = compare;
-
+            .Struct(row) 
+            .Name().Build(columnName) 
+            .Build() 
+        .Right(value) 
+        .Done(); 
+ 
+    TMaybeNode<TExprBase> ret = compare; 
+ 
     auto rowType = row.Ref().GetTypeAnn()->Cast<TStructExprType>();
-    auto columnType = rowType->GetItems()[*rowType->FindItem(columnName)]->GetItemType();
-
-    if (columnType->GetKind() == ETypeAnnotationKind::Optional) {
+    auto columnType = rowType->GetItems()[*rowType->FindItem(columnName)]->GetItemType(); 
+ 
+    if (columnType->GetKind() == ETypeAnnotationKind::Optional) { 
         ret = Build<TCoCoalesce>(ctx, row.Pos())
-            .Predicate(compare)
+            .Predicate(compare) 
             .template Value<TCoBool>()
-                .Literal().Build("false")
-                .Build()
-            .Done();
-    }
-
-    return ret.Cast();
-}
-
-TMaybeNode<TExprBase> CombinePredicatesAnd(TMaybeNode<TExprBase> left, TMaybeNode<TExprBase> right, TExprContext& ctx) {
-    if (left && right) {
+                .Literal().Build("false") 
+                .Build() 
+            .Done(); 
+    } 
+ 
+    return ret.Cast(); 
+} 
+ 
+TMaybeNode<TExprBase> CombinePredicatesAnd(TMaybeNode<TExprBase> left, TMaybeNode<TExprBase> right, TExprContext& ctx) { 
+    if (left && right) { 
         return Build<TCoAnd>(ctx, left.Cast().Pos())
             .Add({left.Cast(), right.Cast()})
-            .Done();
-    } else if (left) {
-        return left;
-    } else if (right) {
-        return right;
-    }
-
-    return TMaybeNode<TExprBase>();
-}
-
-TMaybeNode<TExprBase> CombinePredicatesOr(TMaybeNode<TExprBase> left, TMaybeNode<TExprBase> right, TExprContext& ctx) {
-    if (left && right) {
+            .Done(); 
+    } else if (left) { 
+        return left; 
+    } else if (right) { 
+        return right; 
+    } 
+ 
+    return TMaybeNode<TExprBase>(); 
+} 
+ 
+TMaybeNode<TExprBase> CombinePredicatesOr(TMaybeNode<TExprBase> left, TMaybeNode<TExprBase> right, TExprContext& ctx) { 
+    if (left && right) { 
         return Build<TCoOr>(ctx, left.Cast().Pos())
             .Add({left.Cast(), right.Cast()})
-            .Done();
-    }
-
-    return TMaybeNode<TExprBase>();
-}
-
-template<typename TItem, typename TFunc>
+            .Done(); 
+    } 
+ 
+    return TMaybeNode<TExprBase>(); 
+} 
+ 
+template<typename TItem, typename TFunc> 
 TMaybeNode<TExprBase> CombinePredicateListOr(const TVector<TItem>& list, TExprContext& ctx,
-    TFunc getPredicateFunc)
-{
-    if (list.empty()) {
-        return {};
-    }
-
-    TMaybeNode<TExprBase> residualPredicate = getPredicateFunc(list[0]);
-    for (size_t i = 1; i < list.size(); ++i) {
-        auto predicate = getPredicateFunc(list[i]);
-        residualPredicate = CombinePredicatesOr(residualPredicate, predicate, ctx);
-    }
-
-    return residualPredicate;
-}
-
+    TFunc getPredicateFunc) 
+{ 
+    if (list.empty()) { 
+        return {}; 
+    } 
+ 
+    TMaybeNode<TExprBase> residualPredicate = getPredicateFunc(list[0]); 
+    for (size_t i = 1; i < list.size(); ++i) { 
+        auto predicate = getPredicateFunc(list[i]); 
+        residualPredicate = CombinePredicatesOr(residualPredicate, predicate, ctx); 
+    } 
+ 
+    return residualPredicate; 
+} 
+ 
 TMaybeNode<TExprBase> BuildColumnRangePredicate(const TString& column, const TColumnRange& range,
-    TExprBase row, TExprContext& ctx)
-{
-    if (range.IsNull()) {
-        return Build<TCoNot>(ctx, row.Pos())
-            .Value<TCoExists>()
-                .Optional<TCoMember>()
-                    .Struct(row)
-                    .Name().Build(column)
-                    .Build()
-                .Build()
-            .Done();
-    }
-
-    if (range.IsPoint()) {
+    TExprBase row, TExprContext& ctx) 
+{ 
+    if (range.IsNull()) { 
+        return Build<TCoNot>(ctx, row.Pos()) 
+            .Value<TCoExists>() 
+                .Optional<TCoMember>() 
+                    .Struct(row) 
+                    .Name().Build(column) 
+                    .Build() 
+                .Build() 
+            .Done(); 
+    } 
+ 
+    if (range.IsPoint()) { 
         return BuildColumnCompare<TCoCmpEqual>(row, column, range.GetFrom().GetValue(), ctx);
-    }
-
-    TMaybeNode<TExprBase> fromPredicate;
-    if (range.GetFrom().IsDefined()) {
-        fromPredicate = range.GetFrom().IsInclusive()
+    } 
+ 
+    TMaybeNode<TExprBase> fromPredicate; 
+    if (range.GetFrom().IsDefined()) { 
+        fromPredicate = range.GetFrom().IsInclusive() 
             ? BuildColumnCompare<TCoCmpGreaterOrEqual>(row, column, range.GetFrom().GetValue(), ctx)
             : BuildColumnCompare<TCoCmpGreater>(row, column, range.GetFrom().GetValue(), ctx);
-    }
-
-    TMaybeNode<TExprBase> toPredicate;
-    if (range.GetTo().IsDefined()) {
-        toPredicate = range.GetTo().IsInclusive()
+    } 
+ 
+    TMaybeNode<TExprBase> toPredicate; 
+    if (range.GetTo().IsDefined()) { 
+        toPredicate = range.GetTo().IsInclusive() 
             ? BuildColumnCompare<TCoCmpLessOrEqual>(row, column, range.GetTo().GetValue(), ctx)
             : BuildColumnCompare<TCoCmpLess>(row, column, range.GetTo().GetValue(), ctx);
-    }
-
-    if (fromPredicate && toPredicate) {
+    } 
+ 
+    if (fromPredicate && toPredicate) { 
         return Build<TCoAnd>(ctx, row.Pos())
             .Add({fromPredicate.Cast(), toPredicate.Cast()})
-            .Done();
-    } else if (fromPredicate) {
-        return fromPredicate.Cast();
-    } else if (toPredicate){
-        return toPredicate.Cast();
-    }
-
-    return TMaybeNode<TExprBase>();
-}
-
+            .Done(); 
+    } else if (fromPredicate) { 
+        return fromPredicate.Cast(); 
+    } else if (toPredicate){ 
+        return toPredicate.Cast(); 
+    } 
+ 
+    return TMaybeNode<TExprBase>(); 
+} 
+ 
 TMaybeNode<TExprBase> BuildKeyRangePredicate(const TVector<TString>& columns, const TKeyRange& keyRange,
-    TExprBase row, TExprContext& ctx)
-{
-    YQL_ENSURE(columns.size() == keyRange.GetColumnRangesCount());
-
-    TMaybeNode<TExprBase> predicate = keyRange.GetResidualPredicate();
-    for (size_t i = 0; i < columns.size(); ++i) {
-        auto& column = columns[i];
-        auto& range = keyRange.GetColumnRange(i);
-
-        auto rangePredicate = BuildColumnRangePredicate(column, range, row, ctx);
-        predicate = CombinePredicatesAnd(predicate, rangePredicate, ctx);
-    }
-
-    return predicate;
-}
-
-struct TLookupContext {
-    TLookupContext(TExprContext& exprCtx, TTableLookup::TGetValueFunc getValueFunc,
-        TTableLookup::TCanCompareFunc canCompareFunc, TTableLookup::TCompareFunc compareFunc)
-        : ExprCtx(exprCtx)
-        , GetValueFunc(getValueFunc)
-        , CanCompareFunc(canCompareFunc)
-        , CompareFunc(compareFunc) {}
-
-    TRangeBound MinBound(const TRangeBound& a, const TRangeBound& b) const {
-        YQL_ENSURE(a.IsDefined() && b.IsDefined());
-
-        if (!CanCompareFunc(a.GetValue()) || !CanCompareFunc(b.GetValue())) {
-            return TRangeBound::MakeUndefined();
-        }
-
-        switch (CompareFunc(a.GetValue(), b.GetValue()).Result) {
-            case TTableLookup::TCompareResult::Less:
-                return a;
-            case TTableLookup::TCompareResult::Greater:
-                return b;
-            case TTableLookup::TCompareResult::Equal:
-                return a.IsInclusive() && b.IsInclusive() ? a : TRangeBound(a.GetValue(), false);
-        }
-
-        YQL_ENSURE(false);
-    }
-
-    TRangeBound MaxBound(const TRangeBound& a, const TRangeBound& b) const {
-        YQL_ENSURE(a.IsDefined() && b.IsDefined());
-
-        if (!CanCompareFunc(a.GetValue()) || !CanCompareFunc(b.GetValue())) {
-            return TRangeBound::MakeUndefined();
-        }
-
-        switch (CompareFunc(a.GetValue(), b.GetValue()).Result) {
-            case TTableLookup::TCompareResult::Less:
-                return b;
-            case TTableLookup::TCompareResult::Greater:
-                return a;
-            case TTableLookup::TCompareResult::Equal:
-                return a.IsInclusive() && b.IsInclusive() ? a : TRangeBound(a.GetValue(), false);
-        }
-
-        YQL_ENSURE(false);
-    }
-
-    TExprContext& ExprCtx;
-    TTableLookup::TGetValueFunc GetValueFunc;
-    TTableLookup::TCanCompareFunc CanCompareFunc;
-    TTableLookup::TCompareFunc CompareFunc;
-    bool AllowNullCompare = false;
-};
-
-TColumnRange MakeColumnRange(TRangeBound left, TRangeBound right, const TLookupContext& ctx) {
-    if (!left.IsDefined() || !right.IsDefined()) {
-        return TColumnRange(left, right);
-    }
-
-    if (!ctx.CanCompareFunc(left.GetValue()) || !ctx.CanCompareFunc(right.GetValue())) {
-        return TColumnRange(left, right);
-    }
-
-    auto cmp = ctx.CompareFunc(left.GetValue(), right.GetValue());
-    switch (cmp.Result) {
-        case TTableLookup::TCompareResult::Less:
-            if (cmp.AreAdjacent()) {
-                if (left.IsInclusive() && !right.IsInclusive()) {
-                    return TColumnRange::MakePoint(left.GetValue());
-                } else if (!left.IsInclusive() && right.IsInclusive()) {
-                    return TColumnRange::MakePoint(right.GetValue());
-                }
-            }
-            break;
-
-        case TTableLookup::TCompareResult::Greater:
-            break;
-
-        case TTableLookup::TCompareResult::Equal:
-            if (left.IsInclusive() && right.IsInclusive()) {
-                return TColumnRange::MakePoint(left.GetValue());
-            }
-            break;
-    }
-
-    return TColumnRange(left, right);
-}
-
-class TKeyRangeBuilder {
-public:
+    TExprBase row, TExprContext& ctx) 
+{ 
+    YQL_ENSURE(columns.size() == keyRange.GetColumnRangesCount()); 
+ 
+    TMaybeNode<TExprBase> predicate = keyRange.GetResidualPredicate(); 
+    for (size_t i = 0; i < columns.size(); ++i) { 
+        auto& column = columns[i]; 
+        auto& range = keyRange.GetColumnRange(i); 
+ 
+        auto rangePredicate = BuildColumnRangePredicate(column, range, row, ctx); 
+        predicate = CombinePredicatesAnd(predicate, rangePredicate, ctx); 
+    } 
+ 
+    return predicate; 
+} 
+ 
+struct TLookupContext { 
+    TLookupContext(TExprContext& exprCtx, TTableLookup::TGetValueFunc getValueFunc, 
+        TTableLookup::TCanCompareFunc canCompareFunc, TTableLookup::TCompareFunc compareFunc) 
+        : ExprCtx(exprCtx) 
+        , GetValueFunc(getValueFunc) 
+        , CanCompareFunc(canCompareFunc) 
+        , CompareFunc(compareFunc) {} 
+ 
+    TRangeBound MinBound(const TRangeBound& a, const TRangeBound& b) const { 
+        YQL_ENSURE(a.IsDefined() && b.IsDefined()); 
+ 
+        if (!CanCompareFunc(a.GetValue()) || !CanCompareFunc(b.GetValue())) { 
+            return TRangeBound::MakeUndefined(); 
+        } 
+ 
+        switch (CompareFunc(a.GetValue(), b.GetValue()).Result) { 
+            case TTableLookup::TCompareResult::Less: 
+                return a; 
+            case TTableLookup::TCompareResult::Greater: 
+                return b; 
+            case TTableLookup::TCompareResult::Equal: 
+                return a.IsInclusive() && b.IsInclusive() ? a : TRangeBound(a.GetValue(), false); 
+        } 
+ 
+        YQL_ENSURE(false); 
+    } 
+ 
+    TRangeBound MaxBound(const TRangeBound& a, const TRangeBound& b) const { 
+        YQL_ENSURE(a.IsDefined() && b.IsDefined()); 
+ 
+        if (!CanCompareFunc(a.GetValue()) || !CanCompareFunc(b.GetValue())) { 
+            return TRangeBound::MakeUndefined(); 
+        } 
+ 
+        switch (CompareFunc(a.GetValue(), b.GetValue()).Result) { 
+            case TTableLookup::TCompareResult::Less: 
+                return b; 
+            case TTableLookup::TCompareResult::Greater: 
+                return a; 
+            case TTableLookup::TCompareResult::Equal: 
+                return a.IsInclusive() && b.IsInclusive() ? a : TRangeBound(a.GetValue(), false); 
+        } 
+ 
+        YQL_ENSURE(false); 
+    } 
+ 
+    TExprContext& ExprCtx; 
+    TTableLookup::TGetValueFunc GetValueFunc; 
+    TTableLookup::TCanCompareFunc CanCompareFunc; 
+    TTableLookup::TCompareFunc CompareFunc; 
+    bool AllowNullCompare = false; 
+}; 
+ 
+TColumnRange MakeColumnRange(TRangeBound left, TRangeBound right, const TLookupContext& ctx) { 
+    if (!left.IsDefined() || !right.IsDefined()) { 
+        return TColumnRange(left, right); 
+    } 
+ 
+    if (!ctx.CanCompareFunc(left.GetValue()) || !ctx.CanCompareFunc(right.GetValue())) { 
+        return TColumnRange(left, right); 
+    } 
+ 
+    auto cmp = ctx.CompareFunc(left.GetValue(), right.GetValue()); 
+    switch (cmp.Result) { 
+        case TTableLookup::TCompareResult::Less: 
+            if (cmp.AreAdjacent()) { 
+                if (left.IsInclusive() && !right.IsInclusive()) { 
+                    return TColumnRange::MakePoint(left.GetValue()); 
+                } else if (!left.IsInclusive() && right.IsInclusive()) { 
+                    return TColumnRange::MakePoint(right.GetValue()); 
+                } 
+            } 
+            break; 
+ 
+        case TTableLookup::TCompareResult::Greater: 
+            break; 
+ 
+        case TTableLookup::TCompareResult::Equal: 
+            if (left.IsInclusive() && right.IsInclusive()) { 
+                return TColumnRange::MakePoint(left.GetValue()); 
+            } 
+            break; 
+    } 
+ 
+    return TColumnRange(left, right); 
+} 
+ 
+class TKeyRangeBuilder { 
+public: 
     TKeyRangeBuilder(const TVector<TString>& keyColumns)
-        : KeyColumns(keyColumns)
-    {
-        for (auto& keyColumn : keyColumns) {
-            ColumnRanges[keyColumn] = TColumnRange::MakeUnbounded();
-        }
-    }
-
-    TKeyRangeBuilder(const TKeyRangeBuilder& builder, TMaybeNode<TExprBase> residualPredicate)
-        : KeyColumns(builder.KeyColumns)
-        , ColumnRanges(builder.ColumnRanges)
-        , ResidualPredicate(residualPredicate) {}
-
-    bool IsFullScan() const {
-        return std::find_if(ColumnRanges.begin(), ColumnRanges.end(),
+        : KeyColumns(keyColumns) 
+    { 
+        for (auto& keyColumn : keyColumns) { 
+            ColumnRanges[keyColumn] = TColumnRange::MakeUnbounded(); 
+        } 
+    } 
+ 
+    TKeyRangeBuilder(const TKeyRangeBuilder& builder, TMaybeNode<TExprBase> residualPredicate) 
+        : KeyColumns(builder.KeyColumns) 
+        , ColumnRanges(builder.ColumnRanges) 
+        , ResidualPredicate(residualPredicate) {} 
+ 
+    bool IsFullScan() const { 
+        return std::find_if(ColumnRanges.begin(), ColumnRanges.end(), 
             [] (const std::pair<TString, TColumnRange>& pair) {
-                return pair.second.IsDefined();
-            }) == ColumnRanges.end();
-    }
-
+                return pair.second.IsDefined(); 
+            }) == ColumnRanges.end(); 
+    } 
+ 
     const TVector<TString>& GetKeyColumns() const {
-        return KeyColumns;
-    }
-
+        return KeyColumns; 
+    } 
+ 
     TColumnRange GetColumnRange(const TStringBuf& column) const {
-        auto* keyRange = ColumnRanges.FindPtr(column);
-        YQL_ENSURE(keyRange);
-
-        return *keyRange;
-    }
-
+        auto* keyRange = ColumnRanges.FindPtr(column); 
+        YQL_ENSURE(keyRange); 
+ 
+        return *keyRange; 
+    } 
+ 
     bool HasColumnRange(const TStringBuf& column) const {
-        auto* keyRange = ColumnRanges.FindPtr(column);
-        return keyRange != nullptr;
-    }
-
+        auto* keyRange = ColumnRanges.FindPtr(column); 
+        return keyRange != nullptr; 
+    } 
+ 
     void SetColumnRange(const TStringBuf& column, const TColumnRange& range) {
-        auto it = ColumnRanges.find(column);
-        YQL_ENSURE(it != ColumnRanges.end());
-
-        it->second = range;
-    }
-
-    TMaybeNode<TExprBase> GetResidualPredicate() const {
-        return ResidualPredicate;
-    }
-
-    void SetResidualPredicate(TMaybeNode<TExprBase> predicate) {
-        ResidualPredicate = predicate;
-    }
-
+        auto it = ColumnRanges.find(column); 
+        YQL_ENSURE(it != ColumnRanges.end()); 
+ 
+        it->second = range; 
+    } 
+ 
+    TMaybeNode<TExprBase> GetResidualPredicate() const { 
+        return ResidualPredicate; 
+    } 
+ 
+    void SetResidualPredicate(TMaybeNode<TExprBase> predicate) { 
+        ResidualPredicate = predicate; 
+    } 
+ 
     TMaybeNode<TExprBase> BuildPredicate(const TVector<TString>& columns,
-        TExprBase row, TExprContext& ctx) const
-    {
-        auto keyRange = BuildKeyRange(row, ctx);
-        return BuildKeyRangePredicate(columns, keyRange, row, ctx);
-    }
-
-    TKeyRange BuildKeyRange(TExprBase row, TExprContext& ctx) const {
-        if (IsFullScan()) {
+        TExprBase row, TExprContext& ctx) const 
+    { 
+        auto keyRange = BuildKeyRange(row, ctx); 
+        return BuildKeyRangePredicate(columns, keyRange, row, ctx); 
+    } 
+ 
+    TKeyRange BuildKeyRange(TExprBase row, TExprContext& ctx) const { 
+        if (IsFullScan()) { 
             return TKeyRange(ctx, KeyColumns.size(), ResidualPredicate);
-        }
-
-        auto newResidualPredicate = ResidualPredicate;
+        } 
+ 
+        auto newResidualPredicate = ResidualPredicate; 
         TVector<TColumnRange> newColumnRanges;
-
-        bool keyRangeFinished = false;
+ 
+        bool keyRangeFinished = false; 
         for (const TString& column : KeyColumns) {
-            auto columnRange = GetColumnRange(column);
-
-            if (keyRangeFinished) {
-                if (columnRange.IsDefined()) {
-                    auto predicate = BuildColumnRangePredicate(column, columnRange, row, ctx);
-                    newResidualPredicate = CombinePredicatesAnd(newResidualPredicate, predicate, ctx);
-                }
-                newColumnRanges.push_back(TColumnRange::MakeUnbounded());
-            } else {
-                keyRangeFinished = !columnRange.IsPoint();
-                newColumnRanges.push_back(columnRange);
-            }
-        }
-
+            auto columnRange = GetColumnRange(column); 
+ 
+            if (keyRangeFinished) { 
+                if (columnRange.IsDefined()) { 
+                    auto predicate = BuildColumnRangePredicate(column, columnRange, row, ctx); 
+                    newResidualPredicate = CombinePredicatesAnd(newResidualPredicate, predicate, ctx); 
+                } 
+                newColumnRanges.push_back(TColumnRange::MakeUnbounded()); 
+            } else { 
+                keyRangeFinished = !columnRange.IsPoint(); 
+                newColumnRanges.push_back(columnRange); 
+            } 
+        } 
+ 
         return TKeyRange(ctx, newColumnRanges, newResidualPredicate);
-    }
-
-private:
+    } 
+ 
+private: 
     TVector<TString> KeyColumns;
     THashMap<TString, TColumnRange> ColumnRanges;
-    TMaybeNode<TExprBase> ResidualPredicate;
-};
-
-class TTableLookupBuilder {
-public:
+    TMaybeNode<TExprBase> ResidualPredicate; 
+}; 
+ 
+class TTableLookupBuilder { 
+public: 
     TTableLookupBuilder(const TVector<TString>& keyColumns, const TVector<TKeyRangeBuilder>& keyRangeBuilders)
-        : KeyColumns(keyColumns)
-        , KeyRangeBuilders(keyRangeBuilders) {}
-
+        : KeyColumns(keyColumns) 
+        , KeyRangeBuilders(keyRangeBuilders) {} 
+ 
     TTableLookupBuilder(const TVector<TString>& keyColumns)
-        : TTableLookupBuilder(keyColumns, {}) {}
-
+        : TTableLookupBuilder(keyColumns, {}) {} 
+ 
     TTableLookupBuilder(const TVector<TString>& keyColumns, const TKeyRangeBuilder& keyRangeBuilder)
         : TTableLookupBuilder(keyColumns, TVector<TKeyRangeBuilder>{keyRangeBuilder}) {}
-
-    bool IsSingleRange() const {
-        return KeyRangeBuilders.size() == 1;
-    }
-
-    bool HasNonFullscanRanges() const {
-        for (auto& range : KeyRangeBuilders) {
-            if (!range.IsFullScan()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
+ 
+    bool IsSingleRange() const { 
+        return KeyRangeBuilders.size() == 1; 
+    } 
+ 
+    bool HasNonFullscanRanges() const { 
+        for (auto& range : KeyRangeBuilders) { 
+            if (!range.IsFullScan()) { 
+                return true; 
+            } 
+        } 
+ 
+        return false; 
+    } 
+ 
     const TVector<TKeyRangeBuilder>& GetKeyRangeBuilders() const {
-        return KeyRangeBuilders;
-    }
-
-    const TKeyRangeBuilder& GetKeyRangeBuilder() const {
-        YQL_ENSURE(IsSingleRange());
-        return KeyRangeBuilders.front();
-    }
-
-    TTableLookup BuildTableLookup(TExprBase row, const TLookupContext& ctx) const {
+        return KeyRangeBuilders; 
+    } 
+ 
+    const TKeyRangeBuilder& GetKeyRangeBuilder() const { 
+        YQL_ENSURE(IsSingleRange()); 
+        return KeyRangeBuilders.front(); 
+    } 
+ 
+    TTableLookup BuildTableLookup(TExprBase row, const TLookupContext& ctx) const { 
         TVector<TKeyRange> keyRanges;
-        for (auto& keyRangeBuilder : KeyRangeBuilders) {
-            keyRanges.push_back(keyRangeBuilder.BuildKeyRange(row, ctx.ExprCtx));
-        }
-
-        if (!IsSingleRange()) {
-            if (CheckIndependentRanges(keyRanges, ctx)) {
-                return TTableLookup(KeyColumns, keyRanges);
-            }
-
-            if (TryBuildPointRanges(keyRanges, ctx)) {
-                return TTableLookup(KeyColumns, keyRanges);
-            }
-
-            auto keyRange = BuildBoundingKeyRange(keyRanges, row, ctx.ExprCtx);
-            return TTableLookup(KeyColumns, {keyRange});
-        }
-
-        return TTableLookup(KeyColumns, keyRanges);
-    }
-
-private:
+        for (auto& keyRangeBuilder : KeyRangeBuilders) { 
+            keyRanges.push_back(keyRangeBuilder.BuildKeyRange(row, ctx.ExprCtx)); 
+        } 
+ 
+        if (!IsSingleRange()) { 
+            if (CheckIndependentRanges(keyRanges, ctx)) { 
+                return TTableLookup(KeyColumns, keyRanges); 
+            } 
+ 
+            if (TryBuildPointRanges(keyRanges, ctx)) { 
+                return TTableLookup(KeyColumns, keyRanges); 
+            } 
+ 
+            auto keyRange = BuildBoundingKeyRange(keyRanges, row, ctx.ExprCtx); 
+            return TTableLookup(KeyColumns, {keyRange}); 
+        } 
+ 
+        return TTableLookup(KeyColumns, keyRanges); 
+    } 
+ 
+private: 
     static bool TryBuildPointRanges(TVector<TKeyRange>& keyRanges, const TLookupContext& ctx) {
-        YQL_ENSURE(keyRanges.size() > 1);
-
-        const auto& firstRange = keyRanges[0];
-        ui32 numDefined = firstRange.GetNumDefined();
-
-        for (const auto& range : keyRanges) {
-            if (range.GetNumDefined() != numDefined) {
-                return false;
-            }
-
-            for (size_t i = 0; i < numDefined; ++i) {
-                auto& columnRange = range.GetColumnRange(i);
-                if (!columnRange.IsPoint()) {
-                    return false;
-                }
-
-                if (columnRange.IsNull()) {
-                    return false;
-                }
-
-                if (!ctx.CanCompareFunc(columnRange.GetFrom().GetValue())) {
-                    return false;
-                }
-            }
-        }
-
-        auto less = [&ctx, numDefined] (const TKeyRange &a, const TKeyRange& b) {
-            for (size_t i = 0; i < numDefined; ++i) {
-                auto cmpResult = ctx.CompareFunc(
-                    a.GetColumnRange(i).GetFrom().GetValue(),
-                    b.GetColumnRange(i).GetFrom().GetValue());
-
-                switch (cmpResult.Result) {
-                    case TTableLookup::TCompareResult::Less:
-                        return true;
-                    case TTableLookup::TCompareResult::Greater:
-                        return false;
-                    case TTableLookup::TCompareResult::Equal:
-                        break;
-                }
-            }
-
-            return false;
-        };
-
-        std::stable_sort(keyRanges.begin(), keyRanges.end(), less);
-
-        TMaybeNode<TExprBase> residualPredicate;
-        size_t curIndex = 0;
-        for (size_t i = 0; i < keyRanges.size(); ++i) {
-            auto predicate = keyRanges[i].GetResidualPredicate();
-
-            residualPredicate = residualPredicate
-                ? CombinePredicatesOr(residualPredicate, predicate, ctx.ExprCtx)
-                : predicate;
-
-            if (i == keyRanges.size() - 1 || less(keyRanges[i], keyRanges[i + 1])) {
+        YQL_ENSURE(keyRanges.size() > 1); 
+ 
+        const auto& firstRange = keyRanges[0]; 
+        ui32 numDefined = firstRange.GetNumDefined(); 
+ 
+        for (const auto& range : keyRanges) { 
+            if (range.GetNumDefined() != numDefined) { 
+                return false; 
+            } 
+ 
+            for (size_t i = 0; i < numDefined; ++i) { 
+                auto& columnRange = range.GetColumnRange(i); 
+                if (!columnRange.IsPoint()) { 
+                    return false; 
+                } 
+ 
+                if (columnRange.IsNull()) { 
+                    return false; 
+                } 
+ 
+                if (!ctx.CanCompareFunc(columnRange.GetFrom().GetValue())) { 
+                    return false; 
+                } 
+            } 
+        } 
+ 
+        auto less = [&ctx, numDefined] (const TKeyRange &a, const TKeyRange& b) { 
+            for (size_t i = 0; i < numDefined; ++i) { 
+                auto cmpResult = ctx.CompareFunc( 
+                    a.GetColumnRange(i).GetFrom().GetValue(), 
+                    b.GetColumnRange(i).GetFrom().GetValue()); 
+ 
+                switch (cmpResult.Result) { 
+                    case TTableLookup::TCompareResult::Less: 
+                        return true; 
+                    case TTableLookup::TCompareResult::Greater: 
+                        return false; 
+                    case TTableLookup::TCompareResult::Equal: 
+                        break; 
+                } 
+            } 
+ 
+            return false; 
+        }; 
+ 
+        std::stable_sort(keyRanges.begin(), keyRanges.end(), less); 
+ 
+        TMaybeNode<TExprBase> residualPredicate; 
+        size_t curIndex = 0; 
+        for (size_t i = 0; i < keyRanges.size(); ++i) { 
+            auto predicate = keyRanges[i].GetResidualPredicate(); 
+ 
+            residualPredicate = residualPredicate 
+                ? CombinePredicatesOr(residualPredicate, predicate, ctx.ExprCtx) 
+                : predicate; 
+ 
+            if (i == keyRanges.size() - 1 || less(keyRanges[i], keyRanges[i + 1])) { 
                 TKeyRange keyRange(ctx.ExprCtx, keyRanges[i].GetColumnRanges(), residualPredicate);
-                keyRanges[curIndex] = keyRange;
-                ++curIndex;
-
-                residualPredicate = {};
-            }
-        }
-
-        keyRanges.erase(keyRanges.begin() + curIndex, keyRanges.end());
-        return true;
-    }
-
+                keyRanges[curIndex] = keyRange; 
+                ++curIndex; 
+ 
+                residualPredicate = {}; 
+            } 
+        } 
+ 
+        keyRanges.erase(keyRanges.begin() + curIndex, keyRanges.end()); 
+        return true; 
+    } 
+ 
     static bool CheckIndependentRanges(TVector<TKeyRange>& keyRanges, const TLookupContext& ctx) {
-        for (auto& keyRange : keyRanges) {
-            for (auto& columnRange : keyRange.GetColumnRanges()) {
-                if (columnRange.GetFrom().IsDefined() && !ctx.CanCompareFunc(columnRange.GetFrom().GetValue())) {
-                    return false;
-                }
-
-                if (columnRange.GetTo().IsDefined() && !ctx.CanCompareFunc(columnRange.GetTo().GetValue())) {
-                    return false;
-                }
-            }
-        }
-
-        auto less = [&ctx] (const TKeyRange &a, const TKeyRange& b) {
-            return KeyTupleLess(a.GetFromTuple(), b.GetFromTuple(), ctx.CompareFunc);
-        };
-
-        std::stable_sort(keyRanges.begin(), keyRanges.end(), less);
-
-        for (size_t i = 0; i < keyRanges.size() - 1; ++i) {
-            if (!KeyTupleLess(keyRanges[i].GetToTuple(), keyRanges[i + 1].GetFromTuple(), ctx.CompareFunc)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
+        for (auto& keyRange : keyRanges) { 
+            for (auto& columnRange : keyRange.GetColumnRanges()) { 
+                if (columnRange.GetFrom().IsDefined() && !ctx.CanCompareFunc(columnRange.GetFrom().GetValue())) { 
+                    return false; 
+                } 
+ 
+                if (columnRange.GetTo().IsDefined() && !ctx.CanCompareFunc(columnRange.GetTo().GetValue())) { 
+                    return false; 
+                } 
+            } 
+        } 
+ 
+        auto less = [&ctx] (const TKeyRange &a, const TKeyRange& b) { 
+            return KeyTupleLess(a.GetFromTuple(), b.GetFromTuple(), ctx.CompareFunc); 
+        }; 
+ 
+        std::stable_sort(keyRanges.begin(), keyRanges.end(), less); 
+ 
+        for (size_t i = 0; i < keyRanges.size() - 1; ++i) { 
+            if (!KeyTupleLess(keyRanges[i].GetToTuple(), keyRanges[i + 1].GetFromTuple(), ctx.CompareFunc)) { 
+                return false; 
+            } 
+        } 
+ 
+        return true; 
+    } 
+ 
     TKeyRange BuildBoundingKeyRange(const TVector<TKeyRange> &keyRanges,
-        TExprBase row, TExprContext& ctx) const
-    {
-        YQL_ENSURE(keyRanges.size() > 0);
-
-        auto residualPredicate = CombinePredicateListOr(keyRanges, ctx,
-            [this, row, &ctx] (const TKeyRange& keyRange) {
-                return BuildKeyRangePredicate(KeyColumns, keyRange, row, ctx);
-            });
-
-        // TODO: Compute actual bounding range.
+        TExprBase row, TExprContext& ctx) const 
+    { 
+        YQL_ENSURE(keyRanges.size() > 0); 
+ 
+        auto residualPredicate = CombinePredicateListOr(keyRanges, ctx, 
+            [this, row, &ctx] (const TKeyRange& keyRange) { 
+                return BuildKeyRangePredicate(KeyColumns, keyRange, row, ctx); 
+            }); 
+ 
+        // TODO: Compute actual bounding range. 
         return TKeyRange(ctx, KeyColumns.size(), residualPredicate);
-    }
-
-private:
+    } 
+ 
+private: 
     TVector<TString> KeyColumns;
     TVector<TKeyRangeBuilder> KeyRangeBuilders;
-};
-
-TKeyRangeBuilder CombineKeyRangesAnd(TExprBase row, const TVector<TString>& keyColumns, const TKeyRangeBuilder& left,
-    const TKeyRangeBuilder& right, const TLookupContext& ctx)
-{
-    TKeyRangeBuilder combinedLookup(keyColumns);
-
-    auto rp = CombinePredicatesAnd(left.GetResidualPredicate(), right.GetResidualPredicate(), ctx.ExprCtx);
-
+}; 
+ 
+TKeyRangeBuilder CombineKeyRangesAnd(TExprBase row, const TVector<TString>& keyColumns, const TKeyRangeBuilder& left, 
+    const TKeyRangeBuilder& right, const TLookupContext& ctx) 
+{ 
+    TKeyRangeBuilder combinedLookup(keyColumns); 
+ 
+    auto rp = CombinePredicatesAnd(left.GetResidualPredicate(), right.GetResidualPredicate(), ctx.ExprCtx); 
+ 
     for (const TString& column : left.GetKeyColumns()) {
-        auto columnLeft = left.GetColumnRange(column);
-        auto columnRight = right.GetColumnRange(column);
-
-        TColumnRange columnRange;
-
-        if (columnLeft.IsNull()) {
-            columnRange = columnLeft;
-            if (columnRight.IsDefined()) {
-                auto predicate = BuildColumnRangePredicate(column, columnRight, row, ctx.ExprCtx);
-                rp = CombinePredicatesAnd(rp, predicate, ctx.ExprCtx);
-            }
-        } else if (columnRight.IsNull()) {
-            columnRange = columnRight;
-            if (columnLeft.IsDefined()) {
-                auto predicate = BuildColumnRangePredicate(column, columnLeft, row, ctx.ExprCtx);
-                rp = CombinePredicatesAnd(rp, predicate, ctx.ExprCtx);
-            }
-        } else {
-            TRangeBound combinedFrom;
-            TRangeBound combinedTo;
-
-            if (columnLeft.GetFrom().IsDefined() && columnRight.GetFrom().IsDefined()) {
-                combinedFrom = ctx.MaxBound(columnLeft.GetFrom(), columnRight.GetFrom());
-                if (!combinedFrom.IsDefined()) {
-                    combinedFrom = columnLeft.GetFrom();
-                    rp = CombinePredicatesAnd(rp,
-                        BuildColumnRangePredicate(column, columnRight, row, ctx.ExprCtx),
-                        ctx.ExprCtx);
-                }
-            } else if (columnLeft.GetFrom().IsDefined()) {
-                combinedFrom = columnLeft.GetFrom();
-            } else if (columnRight.GetFrom().IsDefined()) {
-                combinedFrom = columnRight.GetFrom();
-            }
-
-            if (columnLeft.GetTo().IsDefined() && columnRight.GetTo().IsDefined()) {
-                combinedTo = ctx.MinBound(columnLeft.GetTo(), columnRight.GetTo());
-                if (!combinedTo.IsDefined()) {
-                    combinedTo = columnLeft.GetTo();
-                    rp = CombinePredicatesAnd(rp,
-                        BuildColumnRangePredicate(column, columnRight, row, ctx.ExprCtx),
-                        ctx.ExprCtx);
-                }
-            } else if (columnLeft.GetTo().IsDefined()) {
-                combinedTo = columnLeft.GetTo();
-            } else if (columnRight.GetTo().IsDefined()) {
-                combinedTo = columnRight.GetTo();
-            }
-
-            columnRange = MakeColumnRange(combinedFrom, combinedTo, ctx);
-        }
-
-        combinedLookup.SetColumnRange(column, columnRange);
-    }
-
-    combinedLookup.SetResidualPredicate(rp);
-
-    return combinedLookup;
-}
-
+        auto columnLeft = left.GetColumnRange(column); 
+        auto columnRight = right.GetColumnRange(column); 
+ 
+        TColumnRange columnRange; 
+ 
+        if (columnLeft.IsNull()) { 
+            columnRange = columnLeft; 
+            if (columnRight.IsDefined()) { 
+                auto predicate = BuildColumnRangePredicate(column, columnRight, row, ctx.ExprCtx); 
+                rp = CombinePredicatesAnd(rp, predicate, ctx.ExprCtx); 
+            } 
+        } else if (columnRight.IsNull()) { 
+            columnRange = columnRight; 
+            if (columnLeft.IsDefined()) { 
+                auto predicate = BuildColumnRangePredicate(column, columnLeft, row, ctx.ExprCtx); 
+                rp = CombinePredicatesAnd(rp, predicate, ctx.ExprCtx); 
+            } 
+        } else { 
+            TRangeBound combinedFrom; 
+            TRangeBound combinedTo; 
+ 
+            if (columnLeft.GetFrom().IsDefined() && columnRight.GetFrom().IsDefined()) { 
+                combinedFrom = ctx.MaxBound(columnLeft.GetFrom(), columnRight.GetFrom()); 
+                if (!combinedFrom.IsDefined()) { 
+                    combinedFrom = columnLeft.GetFrom(); 
+                    rp = CombinePredicatesAnd(rp, 
+                        BuildColumnRangePredicate(column, columnRight, row, ctx.ExprCtx), 
+                        ctx.ExprCtx); 
+                } 
+            } else if (columnLeft.GetFrom().IsDefined()) { 
+                combinedFrom = columnLeft.GetFrom(); 
+            } else if (columnRight.GetFrom().IsDefined()) { 
+                combinedFrom = columnRight.GetFrom(); 
+            } 
+ 
+            if (columnLeft.GetTo().IsDefined() && columnRight.GetTo().IsDefined()) { 
+                combinedTo = ctx.MinBound(columnLeft.GetTo(), columnRight.GetTo()); 
+                if (!combinedTo.IsDefined()) { 
+                    combinedTo = columnLeft.GetTo(); 
+                    rp = CombinePredicatesAnd(rp, 
+                        BuildColumnRangePredicate(column, columnRight, row, ctx.ExprCtx), 
+                        ctx.ExprCtx); 
+                } 
+            } else if (columnLeft.GetTo().IsDefined()) { 
+                combinedTo = columnLeft.GetTo(); 
+            } else if (columnRight.GetTo().IsDefined()) { 
+                combinedTo = columnRight.GetTo(); 
+            } 
+ 
+            columnRange = MakeColumnRange(combinedFrom, combinedTo, ctx); 
+        } 
+ 
+        combinedLookup.SetColumnRange(column, columnRange); 
+    } 
+ 
+    combinedLookup.SetResidualPredicate(rp); 
+ 
+    return combinedLookup; 
+} 
+ 
 TTableLookupBuilder CombineLookupsAnd(TExprBase row, const TVector<TString>& keyColumns,
     const TTableLookupBuilder* builders, size_t size, const TLookupContext& ctx)
-{
+{ 
     switch (size) {
         case 0U: Y_FAIL("Wrong case");
         case 1U: return *builders;
@@ -584,7 +584,7 @@ TTableLookupBuilder CombineLookupsAnd(TExprBase row, const TVector<TString>& key
                             [&keyColumns, row, &ctx](const TKeyRangeBuilder& keyRange) {
                                 return keyRange.BuildPredicate(keyColumns, row, ctx.ExprCtx);
                             });
-
+ 
                         TVector<TKeyRangeBuilder> newKeyRanges;
                         for (auto& keyRange : lookup.GetKeyRangeBuilders()) {
                             auto newResidualPredicate = CombinePredicatesAnd(keyRange.GetResidualPredicate(),
@@ -592,39 +592,39 @@ TTableLookupBuilder CombineLookupsAnd(TExprBase row, const TVector<TString>& key
                             auto newRange = TKeyRangeBuilder(keyRange, newResidualPredicate);
                             newKeyRanges.push_back(newRange);
                         }
-
+ 
                         return TTableLookupBuilder(keyColumns, newKeyRanges);
                     };
-
+ 
                 const bool keepRight = right.HasNonFullscanRanges() && !left.HasNonFullscanRanges();
                 return keepRight ? combineRanges(right, left) : combineRanges(left, right);
             }
         }
         default: break;
     }
-
+ 
     const auto half = (size + 1U) >> 1U;
     const std::array<TTableLookupBuilder, 2U> pair = {{
         CombineLookupsAnd(row, keyColumns, builders, half, ctx),
         CombineLookupsAnd(row, keyColumns, builders + half, size - half, ctx)
     }};
     return CombineLookupsAnd(row, keyColumns, pair.data(), pair.size(), ctx);
-}
-
+} 
+ 
 TTableLookupBuilder CombineLookupsOr(TExprBase, const TVector<TString>& keyColumns,
     const TTableLookupBuilder* builders, size_t size, const TLookupContext&)
-{
+{ 
     TVector<TKeyRangeBuilder> newKeyRanges;
     newKeyRanges.reserve(size);
     for (size_t i = 0U; i < size; ++i) {
         newKeyRanges.insert(newKeyRanges.end(), builders[i].GetKeyRangeBuilders().cbegin(), builders[i].GetKeyRangeBuilders().cend());
     }
-    return TTableLookupBuilder(keyColumns, newKeyRanges);
-}
-
-TTableLookupBuilder CollectLookups(TExprBase row, TExprBase predicate,
+    return TTableLookupBuilder(keyColumns, newKeyRanges); 
+} 
+ 
+TTableLookupBuilder CollectLookups(TExprBase row, TExprBase predicate, 
     const TVector<TString>& keyColumns, const TLookupContext& ctx)
-{
+{ 
     if (const auto maybeAnd = predicate.Maybe<TCoAnd>()) {
         const auto size = maybeAnd.Cast().Args().size();
         std::vector<TTableLookupBuilder> builders;
@@ -633,8 +633,8 @@ TTableLookupBuilder CollectLookups(TExprBase row, TExprBase predicate,
             builders.emplace_back(CollectLookups(row, maybeAnd.Cast().Arg(i), keyColumns, ctx));
         }
         return CombineLookupsAnd(row, keyColumns, builders.data(), builders.size(), ctx);
-    }
-
+    } 
+ 
     if (const auto maybeOr = predicate.Maybe<TCoOr>()) {
         const auto size = maybeOr.Cast().Args().size();
         std::vector<TTableLookupBuilder> builders;
@@ -643,132 +643,132 @@ TTableLookupBuilder CollectLookups(TExprBase row, TExprBase predicate,
             builders.emplace_back(CollectLookups(row, maybeOr.Cast().Arg(i), keyColumns, ctx));
         }
         return CombineLookupsOr(row, keyColumns, builders.data(), builders.size(), ctx);
-    }
-
+    } 
+ 
     TMaybeNode<TCoCompare> maybeCompare = predicate.Maybe<TCoCompare>();
     if (auto maybeLiteral = predicate.Maybe<TCoCoalesce>().Value().Maybe<TCoBool>().Literal()) {
-        if (maybeLiteral.Cast().Value() == "false") {
+        if (maybeLiteral.Cast().Value() == "false") { 
             maybeCompare = predicate.Cast<TCoCoalesce>().Predicate().Maybe<TCoCompare>();
-        }
-    }
-
-    TTableLookupBuilder fullScan(keyColumns, TKeyRangeBuilder(keyColumns, predicate));
-
-    auto getRowMember = [row] (TExprBase expr) {
+        } 
+    } 
+ 
+    TTableLookupBuilder fullScan(keyColumns, TKeyRangeBuilder(keyColumns, predicate)); 
+ 
+    auto getRowMember = [row] (TExprBase expr) { 
         if (auto maybeMember = expr.Maybe<TCoMember>()) {
-            if (maybeMember.Cast().Struct().Raw() == row.Raw()) {
-                return maybeMember;
-            }
-        }
-
+            if (maybeMember.Cast().Struct().Raw() == row.Raw()) { 
+                return maybeMember; 
+            } 
+        } 
+ 
         return TMaybeNode<TCoMember>();
-    };
-
-    auto getTableLookup = [&keyColumns, fullScan] (const TStringBuf& column, const TColumnRange& range,
-        TMaybeNode<TExprBase> residualPredicate)
-    {
-        TKeyRangeBuilder keyRange(keyColumns, residualPredicate);
-        if (keyRange.HasColumnRange(column)) {
-            keyRange.SetColumnRange(column, range);
-            return TTableLookupBuilder(keyColumns, keyRange);
-        }
-
-        return fullScan;
-    };
-
-    auto getNullComparePredicate = [&ctx](TExprBase value, TExprBase rowValue) -> TMaybeNode<TExprBase> {
+    }; 
+ 
+    auto getTableLookup = [&keyColumns, fullScan] (const TStringBuf& column, const TColumnRange& range, 
+        TMaybeNode<TExprBase> residualPredicate) 
+    { 
+        TKeyRangeBuilder keyRange(keyColumns, residualPredicate); 
+        if (keyRange.HasColumnRange(column)) { 
+            keyRange.SetColumnRange(column, range); 
+            return TTableLookupBuilder(keyColumns, keyRange); 
+        } 
+ 
+        return fullScan; 
+    }; 
+ 
+    auto getNullComparePredicate = [&ctx](TExprBase value, TExprBase rowValue) -> TMaybeNode<TExprBase> { 
         if (ctx.AllowNullCompare || rowValue.Ref().GetTypeAnn()->GetKind() != ETypeAnnotationKind::Optional) {
-            return TMaybeNode<TExprBase>();
-        }
-
-        return Build<TCoExists>(ctx.ExprCtx, rowValue.Pos())
-            .Optional(value)
-            .Done();
-    };
-
-    if (maybeCompare) {
-        auto left = maybeCompare.Cast().Left();
-        auto right = maybeCompare.Cast().Right();
-
-        TMaybeNode<TCoMember> maybeLeftMember = getRowMember(left);
-        TMaybeNode<TCoMember> maybeRightMember = getRowMember(right);
-
-        TMaybeNode<TCoMember> maybeMember;
-        TMaybeNode<TExprBase> maybeValue;
-        bool reverseCompare = false;
-        if (maybeLeftMember) {
-            maybeMember = maybeLeftMember;
+            return TMaybeNode<TExprBase>(); 
+        } 
+ 
+        return Build<TCoExists>(ctx.ExprCtx, rowValue.Pos()) 
+            .Optional(value) 
+            .Done(); 
+    }; 
+ 
+    if (maybeCompare) { 
+        auto left = maybeCompare.Cast().Left(); 
+        auto right = maybeCompare.Cast().Right(); 
+ 
+        TMaybeNode<TCoMember> maybeLeftMember = getRowMember(left); 
+        TMaybeNode<TCoMember> maybeRightMember = getRowMember(right); 
+ 
+        TMaybeNode<TCoMember> maybeMember; 
+        TMaybeNode<TExprBase> maybeValue; 
+        bool reverseCompare = false; 
+        if (maybeLeftMember) { 
+            maybeMember = maybeLeftMember; 
             maybeValue = ctx.GetValueFunc(right, maybeMember.Cast().Ref().GetTypeAnn(), ctx.ExprCtx);
-        } else if (maybeRightMember) {
-            maybeMember = maybeRightMember;
+        } else if (maybeRightMember) { 
+            maybeMember = maybeRightMember; 
             maybeValue = ctx.GetValueFunc(left, maybeMember.Cast().Ref().GetTypeAnn(), ctx.ExprCtx);
-            reverseCompare = true;
-        }
-
-        if (!maybeValue) {
-            return fullScan;
-        }
-
-        auto value = maybeValue.Cast();
+            reverseCompare = true; 
+        } 
+ 
+        if (!maybeValue) { 
+            return fullScan; 
+        } 
+ 
+        auto value = maybeValue.Cast(); 
         auto column = maybeMember.Cast().Name().Value();
-
-        TMaybe<TColumnRange> columnRange;
-
+ 
+        TMaybe<TColumnRange> columnRange; 
+ 
         if (maybeCompare.Maybe<TCoCmpEqual>()) {
-            columnRange = TColumnRange::MakePoint(value);
-        }
-
+            columnRange = TColumnRange::MakePoint(value); 
+        } 
+ 
         if (maybeCompare.Maybe<TCoCmpLess>()) {
-            columnRange = reverseCompare
-                ? MakeColumnRange(TRangeBound::MakeExclusive(value), TRangeBound::MakeUndefined(), ctx)
-                : MakeColumnRange(TRangeBound::MakeUndefined(), TRangeBound::MakeExclusive(value), ctx);
-        }
-
+            columnRange = reverseCompare 
+                ? MakeColumnRange(TRangeBound::MakeExclusive(value), TRangeBound::MakeUndefined(), ctx) 
+                : MakeColumnRange(TRangeBound::MakeUndefined(), TRangeBound::MakeExclusive(value), ctx); 
+        } 
+ 
         if (maybeCompare.Maybe<TCoCmpLessOrEqual>()) {
-            columnRange = reverseCompare
-                ? MakeColumnRange(TRangeBound::MakeInclusive(value), TRangeBound::MakeUndefined(), ctx)
-                : MakeColumnRange(TRangeBound::MakeUndefined(), TRangeBound::MakeInclusive(value), ctx);
-        }
-
+            columnRange = reverseCompare 
+                ? MakeColumnRange(TRangeBound::MakeInclusive(value), TRangeBound::MakeUndefined(), ctx) 
+                : MakeColumnRange(TRangeBound::MakeUndefined(), TRangeBound::MakeInclusive(value), ctx); 
+        } 
+ 
         if (maybeCompare.Maybe<TCoCmpGreater>()) {
-            columnRange = reverseCompare
-                ? MakeColumnRange(TRangeBound::MakeUndefined(), TRangeBound::MakeExclusive(value), ctx)
-                : MakeColumnRange(TRangeBound::MakeExclusive(value), TRangeBound::MakeUndefined(), ctx);
-        }
-
+            columnRange = reverseCompare 
+                ? MakeColumnRange(TRangeBound::MakeUndefined(), TRangeBound::MakeExclusive(value), ctx) 
+                : MakeColumnRange(TRangeBound::MakeExclusive(value), TRangeBound::MakeUndefined(), ctx); 
+        } 
+ 
         if (maybeCompare.Maybe<TCoCmpGreaterOrEqual>()) {
-            columnRange = reverseCompare
-                ? MakeColumnRange(TRangeBound::MakeUndefined(), TRangeBound::MakeInclusive(value), ctx)
-                : MakeColumnRange(TRangeBound::MakeInclusive(value), TRangeBound::MakeUndefined(), ctx);
-        }
-
-        if (columnRange) {
-            return getTableLookup(column, *columnRange, getNullComparePredicate(value, maybeMember.Cast()));
-        }
-    }
-
+            columnRange = reverseCompare 
+                ? MakeColumnRange(TRangeBound::MakeUndefined(), TRangeBound::MakeInclusive(value), ctx) 
+                : MakeColumnRange(TRangeBound::MakeInclusive(value), TRangeBound::MakeUndefined(), ctx); 
+        } 
+ 
+        if (columnRange) { 
+            return getTableLookup(column, *columnRange, getNullComparePredicate(value, maybeMember.Cast())); 
+        } 
+    } 
+ 
     auto maybeLookup = TMaybeNode<TCoLookupBase>();
     if (auto maybeLiteral = predicate.Maybe<TCoCoalesce>().Value().Maybe<TCoBool>().Literal()) {
         if (maybeLiteral.Cast().Value() == "false") {
             maybeLookup = predicate.Maybe<TCoCoalesce>().Predicate().Maybe<TCoLookupBase>();
-        }
+        } 
     } else {
         maybeLookup = predicate.Maybe<TCoLookupBase>();
     }
-
+ 
     if (maybeLookup) {
         auto lookup = maybeLookup.Cast();
 
         if (!lookup.Lookup().Maybe<TCoMember>()) {
-            return fullScan;
-        }
-
+            return fullScan; 
+        } 
+ 
         auto member = lookup.Lookup().Cast<TCoMember>();
-        auto column = member.Name().Value();
-        if (member.Struct().Raw() != row.Raw()) {
-            return fullScan;
-        }
-
+        auto column = member.Name().Value(); 
+        if (member.Struct().Raw() != row.Raw()) { 
+            return fullScan; 
+        } 
+ 
         TExprNode::TPtr collection;
         if (lookup.Collection().Ref().IsList()) {
             collection = lookup.Collection().Ptr();
@@ -787,275 +787,275 @@ TTableLookupBuilder CollectLookups(TExprBase row, TExprBase predicate,
         keyRanges.reserve(size);
         for (const auto& key : collection->Children()) {
             auto maybeValue = ctx.GetValueFunc(TExprBase(key), member.Ref().GetTypeAnn(), ctx.ExprCtx);
-            if (!maybeValue) {
-                return fullScan;
-            }
-
-            TKeyRangeBuilder keyRange(keyColumns);
-            if (!keyRange.HasColumnRange(column)) {
-                return fullScan;
-            }
-            keyRange.SetColumnRange(column, TColumnRange::MakePoint(maybeValue.Cast()));
-
-            keyRanges.push_back(keyRange);
-        }
-
-        return TTableLookupBuilder(keyColumns, keyRanges);
-    }
-
+            if (!maybeValue) { 
+                return fullScan; 
+            } 
+ 
+            TKeyRangeBuilder keyRange(keyColumns); 
+            if (!keyRange.HasColumnRange(column)) { 
+                return fullScan; 
+            } 
+            keyRange.SetColumnRange(column, TColumnRange::MakePoint(maybeValue.Cast())); 
+ 
+            keyRanges.push_back(keyRange); 
+        } 
+ 
+        return TTableLookupBuilder(keyColumns, keyRanges); 
+    } 
+ 
     if (auto maybeBool = predicate.Maybe<TCoCoalesce>().Value().Maybe<TCoBool>().Literal()) {
-        if (maybeBool.Cast().Value() == "false") {
+        if (maybeBool.Cast().Value() == "false") { 
             TExprBase value = predicate.Cast<TCoCoalesce>().Predicate();
             TMaybeNode<TCoMember> maybeMember = getRowMember(value);
-            if (maybeMember) {
-                auto column = maybeMember.Cast().Name().Value();
-                auto columnRange = TColumnRange::MakePoint(
+            if (maybeMember) { 
+                auto column = maybeMember.Cast().Name().Value(); 
+                auto columnRange = TColumnRange::MakePoint( 
                     Build<TCoBool>(ctx.ExprCtx, row.Pos()).Literal().Build("true").Done());
-                return getTableLookup(column, columnRange, {});
-            }
-        }
-    }
-
+                return getTableLookup(column, columnRange, {}); 
+            } 
+        } 
+    } 
+ 
     if (auto maybeBool = predicate.Maybe<TCoNot>().Value().Maybe<TCoCoalesce>().Value().Maybe<TCoBool>().Literal()) {
-        if (maybeBool.Cast().Value() == "true") {
+        if (maybeBool.Cast().Value() == "true") { 
             TExprBase value = predicate.Cast<TCoNot>().Value().Cast<TCoCoalesce>().Predicate();
             TMaybeNode<TCoMember> maybeMember = getRowMember(value);
-            if (maybeMember) {
-                auto column = maybeMember.Cast().Name().Value();
-                auto columnRange = TColumnRange::MakePoint(
+            if (maybeMember) { 
+                auto column = maybeMember.Cast().Name().Value(); 
+                auto columnRange = TColumnRange::MakePoint( 
                     Build<TCoBool>(ctx.ExprCtx, row.Pos()).Literal().Build("false").Done());
-                return getTableLookup(column, columnRange, {});
-            }
-        }
-    }
-
-    if (auto maybeExists = predicate.Maybe<TCoNot>().Value().Maybe<TCoExists>()) {
-        TMaybeNode<TCoMember> maybeMember = getRowMember(maybeExists.Cast().Optional());
-        if (maybeMember) {
-            auto column = maybeMember.Cast().Name().Value();
-            auto columnRange = TColumnRange::MakeNull(ctx.ExprCtx);
-            return getTableLookup(column, columnRange, {});
-        }
-    }
-
-    return fullScan;
-}
-
-} // namespace
-
-TColumnRange TColumnRange::MakeNull(TExprContext& ctx) {
+                return getTableLookup(column, columnRange, {}); 
+            } 
+        } 
+    } 
+ 
+    if (auto maybeExists = predicate.Maybe<TCoNot>().Value().Maybe<TCoExists>()) { 
+        TMaybeNode<TCoMember> maybeMember = getRowMember(maybeExists.Cast().Optional()); 
+        if (maybeMember) { 
+            auto column = maybeMember.Cast().Name().Value(); 
+            auto columnRange = TColumnRange::MakeNull(ctx.ExprCtx); 
+            return getTableLookup(column, columnRange, {}); 
+        } 
+    } 
+ 
+    return fullScan; 
+} 
+ 
+} // namespace 
+ 
+TColumnRange TColumnRange::MakeNull(TExprContext& ctx) { 
     auto nullValue = Build<TCoNull>(ctx, TPositionHandle()).Done();
-    TColumnRange range = MakePoint(nullValue);
-    range.Null = true;
-    return range;
-}
-
+    TColumnRange range = MakePoint(nullValue); 
+    range.Null = true; 
+    return range; 
+} 
+ 
 TKeyRange::TKeyRange(TExprContext& ctx, const TVector<TColumnRange>& columnRanges, TMaybeNode<NNodes::TExprBase> residualPredicate)
     : Ctx(&ctx)
     , ColumnRanges(columnRanges)
-    , ResidualPredicate(residualPredicate)
-    , NumDefined(0)
-{
-    EquiRange = true;
-
-    TVector<NNodes::TMaybeNode<NNodes::TExprBase>> fromValues(columnRanges.size());
-    bool fromInclusive = true;
-
-    TVector<NNodes::TMaybeNode<NNodes::TExprBase>> toValues(columnRanges.size());
-    bool toInclusive = true;
-
-    for (size_t i = 0; i < columnRanges.size(); ++i) {
-        const auto& range = columnRanges[i];
-
-        if (!range.IsPoint()) {
-            if (range.IsDefined()) {
-                YQL_ENSURE(EquiRange);
-            }
-
-            EquiRange = false;
-        }
-
-        if (range.IsDefined()) {
-            ++NumDefined;
-        }
-
-        if (range.GetFrom().IsDefined()) {
-            fromValues[i] = range.GetFrom().GetValue();
-            fromInclusive = range.GetFrom().IsInclusive();
-        }
-
-        if (range.GetTo().IsDefined()) {
-            toValues[i] = range.GetTo().GetValue();
-            toInclusive = range.GetTo().IsInclusive();
-        }
-    }
-
+    , ResidualPredicate(residualPredicate) 
+    , NumDefined(0) 
+{ 
+    EquiRange = true; 
+ 
+    TVector<NNodes::TMaybeNode<NNodes::TExprBase>> fromValues(columnRanges.size()); 
+    bool fromInclusive = true; 
+ 
+    TVector<NNodes::TMaybeNode<NNodes::TExprBase>> toValues(columnRanges.size()); 
+    bool toInclusive = true; 
+ 
+    for (size_t i = 0; i < columnRanges.size(); ++i) { 
+        const auto& range = columnRanges[i]; 
+ 
+        if (!range.IsPoint()) { 
+            if (range.IsDefined()) { 
+                YQL_ENSURE(EquiRange); 
+            } 
+ 
+            EquiRange = false; 
+        } 
+ 
+        if (range.IsDefined()) { 
+            ++NumDefined; 
+        } 
+ 
+        if (range.GetFrom().IsDefined()) { 
+            fromValues[i] = range.GetFrom().GetValue(); 
+            fromInclusive = range.GetFrom().IsInclusive(); 
+        } 
+ 
+        if (range.GetTo().IsDefined()) { 
+            toValues[i] = range.GetTo().GetValue(); 
+            toInclusive = range.GetTo().IsInclusive(); 
+        } 
+    } 
+ 
     FromTuple = TKeyTuple(Ctx, fromValues, true, fromInclusive);
     ToTuple = TKeyTuple(Ctx, toValues, false, toInclusive);
-}
-
+} 
+ 
 void TTableLookup::Print(IOutputStream& output) const {
-    output << Endl << "[" << Endl;
-    for (auto& keyRange : KeyRanges) {
-        keyRange.Print(output);
-    }
-    output << "]" << Endl;
-}
-
+    output << Endl << "[" << Endl; 
+    for (auto& keyRange : KeyRanges) { 
+        keyRange.Print(output); 
+    } 
+    output << "]" << Endl; 
+} 
+ 
 void TKeyRange::Print(IOutputStream& output) const {
     auto printExpr = [ctx = Ctx] (TExprBase node, IOutputStream& output) {
         auto ast = ConvertToAst(node.Ref(), *ctx, TExprAnnotationFlags::None, true);
-        ast.Root->PrintTo(output);
-    };
-
-    output << "{" << Endl;
-    for (size_t i = 0; i < GetColumnRangesCount(); ++i) {
-        auto& range = GetColumnRange(i);
-
-        output << "  " << i << " ";
-
-        if (range.IsNull()) {
-            output << "NULL" << Endl;
-            continue;
-        }
-
-        if (range.GetFrom().IsInclusive()) {
-            output << "[";
-        } else {
-            output << "(";
-        }
-
-        if (range.GetFrom().IsDefined()) {
-            printExpr(range.GetFrom().GetValue(), output);
-        } else {
-            output << "*";
-        }
-
-        output << "; ";
-
-        if (range.GetTo().IsDefined()) {
-            printExpr(range.GetTo().GetValue(), output);
-        } else {
-            output << "*";
-        }
-
-        if (range.GetTo().IsInclusive()) {
-            output << "]";
-        } else {
-            output << ")";
-        }
-
-        output << Endl;
-    }
-
-    auto residualPredicate = GetResidualPredicate();
-    output << "  Residual: ";
-    if (residualPredicate) {
-        printExpr(residualPredicate.Cast(), output);
-    } else {
-        output << "None";
-    }
-
-    output << Endl << "}" << Endl;
-}
-
+        ast.Root->PrintTo(output); 
+    }; 
+ 
+    output << "{" << Endl; 
+    for (size_t i = 0; i < GetColumnRangesCount(); ++i) { 
+        auto& range = GetColumnRange(i); 
+ 
+        output << "  " << i << " "; 
+ 
+        if (range.IsNull()) { 
+            output << "NULL" << Endl; 
+            continue; 
+        } 
+ 
+        if (range.GetFrom().IsInclusive()) { 
+            output << "["; 
+        } else { 
+            output << "("; 
+        } 
+ 
+        if (range.GetFrom().IsDefined()) { 
+            printExpr(range.GetFrom().GetValue(), output); 
+        } else { 
+            output << "*"; 
+        } 
+ 
+        output << "; "; 
+ 
+        if (range.GetTo().IsDefined()) { 
+            printExpr(range.GetTo().GetValue(), output); 
+        } else { 
+            output << "*"; 
+        } 
+ 
+        if (range.GetTo().IsInclusive()) { 
+            output << "]"; 
+        } else { 
+            output << ")"; 
+        } 
+ 
+        output << Endl; 
+    } 
+ 
+    auto residualPredicate = GetResidualPredicate(); 
+    output << "  Residual: "; 
+    if (residualPredicate) { 
+        printExpr(residualPredicate.Cast(), output); 
+    } else { 
+        output << "None"; 
+    } 
+ 
+    output << Endl << "}" << Endl; 
+} 
+ 
 void TKeyTuple::Print(IOutputStream& output) const {
     auto printExpr = [] (TExprContext& ctx, TExprBase node, IOutputStream& output) {
         auto ast = ConvertToAst(node.Ref(), ctx, TExprAnnotationFlags::None, true);
-        ast.Root->PrintTo(output);
-    };
-
-    output << "\"";
-    output << (IsFrom()
-        ? IsInclusive() ? "[" : "("
-        : IsInclusive() ? "]" : ")");
-    output << "\" (";
-
-    for (size_t i = 0; i < Size(); ++i) {
-        auto value = GetValue(i);
-        if (value) {
+        ast.Root->PrintTo(output); 
+    }; 
+ 
+    output << "\""; 
+    output << (IsFrom() 
+        ? IsInclusive() ? "[" : "(" 
+        : IsInclusive() ? "]" : ")"); 
+    output << "\" ("; 
+ 
+    for (size_t i = 0; i < Size(); ++i) { 
+        auto value = GetValue(i); 
+        if (value) { 
             YQL_ENSURE(Ctx);
             printExpr(*Ctx, value.Cast(), output);
-        } else {
-            output << (IsFrom()
-                ? IsInclusive() ? "-Inf" : "+Inf"
-                : IsInclusive() ? "+Inf" : "-Inf");
-        }
-
-        if (i < Size() - 1) {
-            output << ", ";
-        }
-    }
-
-    output << ")";
-}
-
-bool KeyTupleLess(const TKeyTuple& left, const TKeyTuple& right, const TTableLookup::TCompareFunc& cmpFunc) {
-    YQL_ENSURE(left.Size() == right.Size());
-
-    TTableLookup::TCompareResult::TResult cmpResult = TTableLookup::TCompareResult::Equal;
-    for (size_t i = 0; i < left.Size(); ++i) {
-        auto leftValue = left.GetValue(i);
-        auto rightValue = right.GetValue(i);
-
-        if (leftValue && rightValue) {
-            cmpResult = cmpFunc(leftValue.Cast(),rightValue.Cast()).Result;
-        } else if (!leftValue) {
-            if (left.IsFrom() == left.IsInclusive()) {
-                if (rightValue || right.IsFrom() != right.IsInclusive()) {
-                    cmpResult = TTableLookup::TCompareResult::Less;
-                }
-            } else {
-                if (rightValue || right.IsFrom() == right.IsInclusive()) {
-                    cmpResult = TTableLookup::TCompareResult::Greater;
-                }
-            }
-        } else {
-            cmpResult = right.IsFrom() == right.IsInclusive()
-                ? TTableLookup::TCompareResult::Greater
-                : TTableLookup::TCompareResult::Less;
-        }
-
-        if (cmpResult != TTableLookup::TCompareResult::Equal) {
-            break;
-        }
-    }
-
-    if (cmpResult == TTableLookup::TCompareResult::Equal) {
-        if (left.IsFrom() && right.IsFrom() && left.IsInclusive() && !right.IsInclusive()) {
-            return true;
-        }
-
-        if (!left.IsFrom() && right.IsFrom() && !(left.IsInclusive() && right.IsInclusive())) {
-            return true;
-        }
-
-        if (!left.IsFrom() && !right.IsFrom() && !left.IsInclusive() && right.IsInclusive()) {
-            return true;
-        }
-    }
-
-    return cmpResult == TTableLookup::TCompareResult::Less;
-}
-
-TTableLookup ExtractTableLookup(
-    TExprBase row,
-    TExprBase predicate,
+        } else { 
+            output << (IsFrom() 
+                ? IsInclusive() ? "-Inf" : "+Inf" 
+                : IsInclusive() ? "+Inf" : "-Inf"); 
+        } 
+ 
+        if (i < Size() - 1) { 
+            output << ", "; 
+        } 
+    } 
+ 
+    output << ")"; 
+} 
+ 
+bool KeyTupleLess(const TKeyTuple& left, const TKeyTuple& right, const TTableLookup::TCompareFunc& cmpFunc) { 
+    YQL_ENSURE(left.Size() == right.Size()); 
+ 
+    TTableLookup::TCompareResult::TResult cmpResult = TTableLookup::TCompareResult::Equal; 
+    for (size_t i = 0; i < left.Size(); ++i) { 
+        auto leftValue = left.GetValue(i); 
+        auto rightValue = right.GetValue(i); 
+ 
+        if (leftValue && rightValue) { 
+            cmpResult = cmpFunc(leftValue.Cast(),rightValue.Cast()).Result; 
+        } else if (!leftValue) { 
+            if (left.IsFrom() == left.IsInclusive()) { 
+                if (rightValue || right.IsFrom() != right.IsInclusive()) { 
+                    cmpResult = TTableLookup::TCompareResult::Less; 
+                } 
+            } else { 
+                if (rightValue || right.IsFrom() == right.IsInclusive()) { 
+                    cmpResult = TTableLookup::TCompareResult::Greater; 
+                } 
+            } 
+        } else { 
+            cmpResult = right.IsFrom() == right.IsInclusive() 
+                ? TTableLookup::TCompareResult::Greater 
+                : TTableLookup::TCompareResult::Less; 
+        } 
+ 
+        if (cmpResult != TTableLookup::TCompareResult::Equal) { 
+            break; 
+        } 
+    } 
+ 
+    if (cmpResult == TTableLookup::TCompareResult::Equal) { 
+        if (left.IsFrom() && right.IsFrom() && left.IsInclusive() && !right.IsInclusive()) { 
+            return true; 
+        } 
+ 
+        if (!left.IsFrom() && right.IsFrom() && !(left.IsInclusive() && right.IsInclusive())) { 
+            return true; 
+        } 
+ 
+        if (!left.IsFrom() && !right.IsFrom() && !left.IsInclusive() && right.IsInclusive()) { 
+            return true; 
+        } 
+    } 
+ 
+    return cmpResult == TTableLookup::TCompareResult::Less; 
+} 
+ 
+TTableLookup ExtractTableLookup( 
+    TExprBase row, 
+    TExprBase predicate, 
     const TVector<TString>& keyColumns,
-    TTableLookup::TGetValueFunc getValueFunc,
-    TTableLookup::TCanCompareFunc canCompareFunc,
-    TTableLookup::TCompareFunc compareFunc,
-    TExprContext& exprCtx,
-    bool allowNullCompare)
-{
-    TLookupContext ctx(exprCtx, getValueFunc, canCompareFunc, compareFunc);
-    ctx.AllowNullCompare = allowNullCompare;
-
-    auto tableLookupBuilder = CollectLookups(row, predicate, keyColumns, ctx);
-    auto tableLookup = tableLookupBuilder.BuildTableLookup(row, ctx);
-
-    return tableLookup;
-}
-
-} // namespace NCommon
-} // namespace NYql
+    TTableLookup::TGetValueFunc getValueFunc, 
+    TTableLookup::TCanCompareFunc canCompareFunc, 
+    TTableLookup::TCompareFunc compareFunc, 
+    TExprContext& exprCtx, 
+    bool allowNullCompare) 
+{ 
+    TLookupContext ctx(exprCtx, getValueFunc, canCompareFunc, compareFunc); 
+    ctx.AllowNullCompare = allowNullCompare; 
+ 
+    auto tableLookupBuilder = CollectLookups(row, predicate, keyColumns, ctx); 
+    auto tableLookup = tableLookupBuilder.BuildTableLookup(row, ctx); 
+ 
+    return tableLookup; 
+} 
+ 
+} // namespace NCommon 
+} // namespace NYql 
diff --git a/ydb/library/yql/providers/common/provider/yql_table_lookup.h b/ydb/library/yql/providers/common/provider/yql_table_lookup.h
index 988fb5b4ba..72f52dbbe2 100644
--- a/ydb/library/yql/providers/common/provider/yql_table_lookup.h
+++ b/ydb/library/yql/providers/common/provider/yql_table_lookup.h
@@ -1,249 +1,249 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/library/yql/core/expr_nodes/yql_expr_nodes.h>
-
-#include <functional>
-
-namespace NYql {
-namespace NCommon {
-
-class TRangeBound
-{
-public:
-    TRangeBound(NNodes::TMaybeNode<NNodes::TExprBase> value, bool isInclusive)
-        : Value(value)
-        , Inclusive(isInclusive) {}
-
-    TRangeBound()
-        : TRangeBound(NNodes::TMaybeNode<NNodes::TExprBase>(), false) {}
-
-    bool IsDefined() const {
-        return Value.IsValid();
-    }
-
-    NNodes::TExprBase GetValue() const {
-        YQL_ENSURE(IsDefined());
-        return Value.Cast();
-    }
-
-    bool IsInclusive() const {
-        return Inclusive;
-    }
-
-    static TRangeBound MakeUndefined() {
-        return TRangeBound();
-    }
-
-    static TRangeBound MakeInclusive(NNodes::TExprBase value) {
-        return TRangeBound(value, true);
-    }
-
-    static TRangeBound MakeExclusive(NNodes::TExprBase value) {
-        return TRangeBound(value, false);
-    }
-
-private:
-    NNodes::TMaybeNode<NNodes::TExprBase> Value;
-    bool Inclusive;
-};
-
-class TColumnRange {
-public:
-    TColumnRange(const TRangeBound& from, const TRangeBound& to)
-        : From(from)
-        , To(to)
-        , Defined(From.IsDefined() || To.IsDefined())
-    {
-        Point = From.IsDefined() && To.IsDefined() &&
-            From.IsInclusive() && To.IsInclusive() &&
+ 
+#include <functional> 
+ 
+namespace NYql { 
+namespace NCommon { 
+ 
+class TRangeBound 
+{ 
+public: 
+    TRangeBound(NNodes::TMaybeNode<NNodes::TExprBase> value, bool isInclusive) 
+        : Value(value) 
+        , Inclusive(isInclusive) {} 
+ 
+    TRangeBound() 
+        : TRangeBound(NNodes::TMaybeNode<NNodes::TExprBase>(), false) {} 
+ 
+    bool IsDefined() const { 
+        return Value.IsValid(); 
+    } 
+ 
+    NNodes::TExprBase GetValue() const { 
+        YQL_ENSURE(IsDefined()); 
+        return Value.Cast(); 
+    } 
+ 
+    bool IsInclusive() const { 
+        return Inclusive; 
+    } 
+ 
+    static TRangeBound MakeUndefined() { 
+        return TRangeBound(); 
+    } 
+ 
+    static TRangeBound MakeInclusive(NNodes::TExprBase value) { 
+        return TRangeBound(value, true); 
+    } 
+ 
+    static TRangeBound MakeExclusive(NNodes::TExprBase value) { 
+        return TRangeBound(value, false); 
+    } 
+ 
+private: 
+    NNodes::TMaybeNode<NNodes::TExprBase> Value; 
+    bool Inclusive; 
+}; 
+ 
+class TColumnRange { 
+public: 
+    TColumnRange(const TRangeBound& from, const TRangeBound& to) 
+        : From(from) 
+        , To(to) 
+        , Defined(From.IsDefined() || To.IsDefined()) 
+    { 
+        Point = From.IsDefined() && To.IsDefined() && 
+            From.IsInclusive() && To.IsInclusive() && 
             From.GetValue().Raw() == To.GetValue().Raw();
-    }
-
-    TColumnRange()
-        : TColumnRange(TRangeBound(), TRangeBound()) {}
-
-    TRangeBound GetFrom() const { return From; }
-    TRangeBound GetTo() const { return To; }
-
-    bool IsDefined() const {
-        return Defined;
-    }
-
-    bool IsPoint() const {
-        return Point;
-    }
-
-    bool IsNull() const {
-        return Null;
-    }
-
-    static TColumnRange MakeUnbounded() {
-        return TColumnRange(TRangeBound(), TRangeBound());
-    }
-
-    static TColumnRange MakePoint(NNodes::TExprBase value) {
-        return TColumnRange(TRangeBound(value, true), TRangeBound(value, true));
-    }
-
-    static TColumnRange MakeNull(TExprContext& ctx);
-
-private:
-    TRangeBound From;
-    TRangeBound To;
-    bool Defined;
-    bool Point;
-    bool Null = false;
-};
-
-class TKeyTuple {
-public:
+    } 
+ 
+    TColumnRange() 
+        : TColumnRange(TRangeBound(), TRangeBound()) {} 
+ 
+    TRangeBound GetFrom() const { return From; } 
+    TRangeBound GetTo() const { return To; } 
+ 
+    bool IsDefined() const { 
+        return Defined; 
+    } 
+ 
+    bool IsPoint() const { 
+        return Point; 
+    } 
+ 
+    bool IsNull() const { 
+        return Null; 
+    } 
+ 
+    static TColumnRange MakeUnbounded() { 
+        return TColumnRange(TRangeBound(), TRangeBound()); 
+    } 
+ 
+    static TColumnRange MakePoint(NNodes::TExprBase value) { 
+        return TColumnRange(TRangeBound(value, true), TRangeBound(value, true)); 
+    } 
+ 
+    static TColumnRange MakeNull(TExprContext& ctx); 
+ 
+private: 
+    TRangeBound From; 
+    TRangeBound To; 
+    bool Defined; 
+    bool Point; 
+    bool Null = false; 
+}; 
+ 
+class TKeyTuple { 
+public: 
     TKeyTuple(TExprContext* ctx, const TVector<NNodes::TMaybeNode<NNodes::TExprBase>>& values, bool isFrom, bool isInclusive)
         : Ctx(ctx)
         , Values(values)
-        , From(isFrom)
-        , Inclusive(isInclusive) {}
-
-    TKeyTuple()
+        , From(isFrom) 
+        , Inclusive(isInclusive) {} 
+ 
+    TKeyTuple() 
         : TKeyTuple(nullptr, {}, false, false) {}
-
-    size_t Size() const { return Values.size(); }
-    bool IsFrom() const { return From; }
-    bool IsInclusive() const { return Inclusive; }
-    NNodes::TMaybeNode<NNodes::TExprBase> GetValue(size_t index) const { return Values[index]; }
-
+ 
+    size_t Size() const { return Values.size(); } 
+    bool IsFrom() const { return From; } 
+    bool IsInclusive() const { return Inclusive; } 
+    NNodes::TMaybeNode<NNodes::TExprBase> GetValue(size_t index) const { return Values[index]; } 
+ 
     void Print(IOutputStream& output) const;
-
-private:
+ 
+private: 
     TExprContext* Ctx;
     TVector<NNodes::TMaybeNode<NNodes::TExprBase>> Values;
-    bool From;
-    bool Inclusive;
-};
-
-class TKeyRange {
-public:
+    bool From; 
+    bool Inclusive; 
+}; 
+ 
+class TKeyRange { 
+public: 
     TKeyRange(TExprContext& ctx, const TVector<TColumnRange>& columnRanges, NNodes::TMaybeNode<NNodes::TExprBase> residualPredicate);
-
+ 
     TKeyRange(TExprContext& ctx, size_t keySize, NNodes::TMaybeNode<NNodes::TExprBase> residualPredicate)
         : TKeyRange(ctx, TVector<TColumnRange>(keySize, TColumnRange()), residualPredicate) {}
-
-    size_t GetColumnRangesCount() const {
-        return ColumnRanges.size();
-    }
-
-    const TColumnRange& GetColumnRange(size_t index) const {
-        return ColumnRanges[index];
-    }
-
+ 
+    size_t GetColumnRangesCount() const { 
+        return ColumnRanges.size(); 
+    } 
+ 
+    const TColumnRange& GetColumnRange(size_t index) const { 
+        return ColumnRanges[index]; 
+    } 
+ 
     const TVector<TColumnRange>& GetColumnRanges() const {
-        return ColumnRanges;
-    }
-
-    bool IsFullScan() const {
-        return NumDefined == 0;
-    }
-
-    bool IsEquiRange() const {
-        return EquiRange;
-    }
-
-    size_t GetNumDefined() const {
-        return NumDefined;
-    }
-
-    bool HasResidualPredicate() const {
-        return ResidualPredicate.IsValid();
-    }
-
-    NNodes::TMaybeNode<NNodes::TExprBase> GetResidualPredicate() const {
-        return ResidualPredicate;
-    }
-
-    const TKeyTuple& GetFromTuple() const {
-        return FromTuple;
-    }
-
-    const TKeyTuple& GetToTuple() const {
-        return ToTuple;
-    }
-
+        return ColumnRanges; 
+    } 
+ 
+    bool IsFullScan() const { 
+        return NumDefined == 0; 
+    } 
+ 
+    bool IsEquiRange() const { 
+        return EquiRange; 
+    } 
+ 
+    size_t GetNumDefined() const { 
+        return NumDefined; 
+    } 
+ 
+    bool HasResidualPredicate() const { 
+        return ResidualPredicate.IsValid(); 
+    } 
+ 
+    NNodes::TMaybeNode<NNodes::TExprBase> GetResidualPredicate() const { 
+        return ResidualPredicate; 
+    } 
+ 
+    const TKeyTuple& GetFromTuple() const { 
+        return FromTuple; 
+    } 
+ 
+    const TKeyTuple& GetToTuple() const { 
+        return ToTuple; 
+    } 
+ 
     void Print(IOutputStream& output) const;
-
-private:
+ 
+private: 
     TExprContext* Ctx;
     TVector<TColumnRange> ColumnRanges;
-    NNodes::TMaybeNode<NNodes::TExprBase> ResidualPredicate;
-    bool EquiRange;
-    size_t NumDefined;
-    TKeyTuple FromTuple;
-    TKeyTuple ToTuple;
-};
-
-class TTableLookup {
-public:
-    struct TCompareResult
-    {
-        enum TResult {
-            Equal,
-            Less,
-            Greater
-        };
-
-        TCompareResult(TResult result, TMaybe<bool> adjacent = {})
-            : Result(result)
-            , Adjacent(adjacent) {}
-
-        bool AreAdjacent() const {
-            return Adjacent.Defined() && *Adjacent;
-        }
-
-        TResult Result;
-        TMaybe<bool> Adjacent;
-    };
-
-    typedef std::function<NNodes::TMaybeNode<NNodes::TExprBase>(NNodes::TExprBase,
-        const TTypeAnnotationNode*, TExprContext& ctx)> TGetValueFunc;
-    typedef std::function<bool(NNodes::TExprBase)> TCanCompareFunc;
-    typedef std::function<TCompareResult(NNodes::TExprBase, NNodes::TExprBase)> TCompareFunc;
-
+    NNodes::TMaybeNode<NNodes::TExprBase> ResidualPredicate; 
+    bool EquiRange; 
+    size_t NumDefined; 
+    TKeyTuple FromTuple; 
+    TKeyTuple ToTuple; 
+}; 
+ 
+class TTableLookup { 
+public: 
+    struct TCompareResult 
+    { 
+        enum TResult { 
+            Equal, 
+            Less, 
+            Greater 
+        }; 
+ 
+        TCompareResult(TResult result, TMaybe<bool> adjacent = {}) 
+            : Result(result) 
+            , Adjacent(adjacent) {} 
+ 
+        bool AreAdjacent() const { 
+            return Adjacent.Defined() && *Adjacent; 
+        } 
+ 
+        TResult Result; 
+        TMaybe<bool> Adjacent; 
+    }; 
+ 
+    typedef std::function<NNodes::TMaybeNode<NNodes::TExprBase>(NNodes::TExprBase, 
+        const TTypeAnnotationNode*, TExprContext& ctx)> TGetValueFunc; 
+    typedef std::function<bool(NNodes::TExprBase)> TCanCompareFunc; 
+    typedef std::function<TCompareResult(NNodes::TExprBase, NNodes::TExprBase)> TCompareFunc; 
+ 
     TTableLookup(const TVector<TString>& keyColumns, const TVector<TKeyRange>& keyRanges)
-        : KeyColumns(keyColumns)
-        , KeyRanges(keyRanges) {}
-
+        : KeyColumns(keyColumns) 
+        , KeyRanges(keyRanges) {} 
+ 
     const TVector<TString>& GetKeyColumns() const {
-        return KeyColumns;
-    }
-
+        return KeyColumns; 
+    } 
+ 
     const TVector<TKeyRange>& GetKeyRanges() const {
-        return KeyRanges;
-    }
-
-    bool IsSingleRange() const {
-        return KeyRanges.size() == 1;
-    }
-
-    bool IsFullScan() const {
-        return IsSingleRange() && KeyRanges.front().IsFullScan();
-    }
-
+        return KeyRanges; 
+    } 
+ 
+    bool IsSingleRange() const { 
+        return KeyRanges.size() == 1; 
+    } 
+ 
+    bool IsFullScan() const { 
+        return IsSingleRange() && KeyRanges.front().IsFullScan(); 
+    } 
+ 
     void Print(IOutputStream& output) const;
-
-private:
+ 
+private: 
     TVector<TString> KeyColumns;
     TVector<TKeyRange> KeyRanges;
-};
-
-TTableLookup ExtractTableLookup(
-    NNodes::TExprBase row,
-    NNodes::TExprBase predicate,
+}; 
+ 
+TTableLookup ExtractTableLookup( 
+    NNodes::TExprBase row, 
+    NNodes::TExprBase predicate, 
     const TVector<TString>& keyColumns,
-    TTableLookup::TGetValueFunc getValueFunc,
-    TTableLookup::TCanCompareFunc canCompareFunc,
-    TTableLookup::TCompareFunc compareFunc,
-    TExprContext& exprCtx,
-    bool allowNullCompare);
-
-bool KeyTupleLess(const TKeyTuple& left, const TKeyTuple& right, const TTableLookup::TCompareFunc& cmpFunc);
-
-} // namespace NCommon
-} // namespace NYql
+    TTableLookup::TGetValueFunc getValueFunc, 
+    TTableLookup::TCanCompareFunc canCompareFunc, 
+    TTableLookup::TCompareFunc compareFunc, 
+    TExprContext& exprCtx, 
+    bool allowNullCompare); 
+ 
+bool KeyTupleLess(const TKeyTuple& left, const TKeyTuple& right, const TTableLookup::TCompareFunc& cmpFunc); 
+ 
+} // namespace NCommon 
+} // namespace NYql 
diff --git a/ydb/library/yql/providers/common/schema/expr/yql_expr_schema.cpp b/ydb/library/yql/providers/common/schema/expr/yql_expr_schema.cpp
index 0bbaf5c339..77dd1e62f4 100644
--- a/ydb/library/yql/providers/common/schema/expr/yql_expr_schema.cpp
+++ b/ydb/library/yql/providers/common/schema/expr/yql_expr_schema.cpp
@@ -204,9 +204,9 @@ public:
             case ETypeAnnotationKind::Resource:
                 TBase::SaveResourceType(type->Cast<TResourceExprType>()->GetTag());
                 break;
-            case ETypeAnnotationKind::Tagged:
-                TBase::SaveTaggedType(*type->Cast<TTaggedExprType>());
-                break;
+            case ETypeAnnotationKind::Tagged: 
+                TBase::SaveTaggedType(*type->Cast<TTaggedExprType>()); 
+                break; 
             case ETypeAnnotationKind::Error:
                 SaveErrorType(*type->Cast<TErrorExprType>());
                 break;
diff --git a/ydb/library/yql/providers/common/transform/yql_exec.h b/ydb/library/yql/providers/common/transform/yql_exec.h
index 0f134e5688..894b9d9455 100644
--- a/ydb/library/yql/providers/common/transform/yql_exec.h
+++ b/ydb/library/yql/providers/common/transform/yql_exec.h
@@ -19,7 +19,7 @@ public:
     using TPrerequisite = std::function<TStatus(const TExprNode::TPtr&)>;
     using THandler = std::function<TStatusCallbackPair(const TExprNode::TPtr&, TExprNode::TPtr&, TExprContext&)>;
 
-    TStatusCallbackPair CallbackTransform(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx);
+    TStatusCallbackPair CallbackTransform(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx); 
 
     bool CanExec(const TExprNode& node) const {
         return Handlers.contains(node.Content());
diff --git a/ydb/library/yql/providers/common/transform/yql_visit.h b/ydb/library/yql/providers/common/transform/yql_visit.h
index 5e6212579e..2556ded480 100644
--- a/ydb/library/yql/providers/common/transform/yql_visit.h
+++ b/ydb/library/yql/providers/common/transform/yql_visit.h
@@ -21,7 +21,7 @@ public:
     {
     }
 
-    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final;
+    TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final; 
 
     bool CanParse(const TExprNode& node) const {
         return Handlers.contains(node.Content());
diff --git a/ydb/library/yql/providers/common/ya.make b/ydb/library/yql/providers/common/ya.make
index 66778b0bcf..a103b2f98c 100644
--- a/ydb/library/yql/providers/common/ya.make
+++ b/ydb/library/yql/providers/common/ya.make
@@ -1,14 +1,14 @@
-RECURSE(
+RECURSE( 
     codec
     config
     dq
-    gateway
+    gateway 
     http_gateway
     metrics
-    mkql
+    mkql 
     comp_nodes
     proto
-    provider
+    provider 
     schema
     schema/expr
     schema/mkql
@@ -18,4 +18,4 @@ RECURSE(
     token_accessor
     transform
     udf_resolve
-)
+) 
diff --git a/ydb/library/yql/providers/config/yql_config_provider.cpp b/ydb/library/yql/providers/config/yql_config_provider.cpp
index 6952e96cf0..dad35be7e2 100644
--- a/ydb/library/yql/providers/config/yql_config_provider.cpp
+++ b/ydb/library/yql/providers/config/yql_config_provider.cpp
@@ -23,9 +23,9 @@
 namespace NYql {
 
 namespace {
-    using namespace NNodes;
-
-    class TConfigCallableExecutionTransformer : public TSyncTransformerBase {
+    using namespace NNodes; 
+ 
+    class TConfigCallableExecutionTransformer : public TSyncTransformerBase { 
     public:
         TConfigCallableExecutionTransformer(const TTypeAnnotationContext& types)
             : Types(types)
@@ -33,7 +33,7 @@ namespace {
             Y_UNUSED(Types);
         }
 
-        TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+        TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
             output = input;
             YQL_ENSURE(input->Type() == TExprNode::Callable);
             if (input->Content() == "Pull") {
@@ -43,9 +43,9 @@ namespace {
                 }
 
                 IDataProvider::TFillSettings fillSettings = NCommon::GetFillSettings(*input);
-                YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Yson);
+                YQL_ENSURE(fillSettings.Format == IDataProvider::EResultFormat::Yson); 
                 NYson::EYsonFormat ysonFormat = NCommon::GetYsonFormat(fillSettings);
-
+ 
                 auto nodeToPull = input->Child(0)->Child(0);
                 if (nodeToPull->IsCallable(ConfReadName)) {
                     auto key = nodeToPull->Child(2);
@@ -159,7 +159,7 @@ namespace {
                 return false;
             }
 
-            cluster = Nothing();
+            cluster = Nothing(); 
             return true;
         }
 
@@ -182,7 +182,7 @@ namespace {
                 return *ConfigurationTransformer;
             }
 
-            ConfigurationTransformer = CreateFunctorTransformer(
+            ConfigurationTransformer = CreateFunctorTransformer( 
                 [this](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) -> IGraphTransformer::TStatus {
                 output = input;
                 if (ctx.Step.IsDone(TExprStep::Configure)) {
@@ -230,8 +230,8 @@ namespace {
 
                         if (!ApplyFlag(ctx.GetPosition(node->Child(2)->Pos()), command, args, ctx)) {
                             return {};
-                        }
-
+                        } 
+ 
                         if (command == "PureDataSource") {
                             if (Types.PureResultDataSource != node->Child(3)->Content()) {
                                 res = ctx.ChangeChild(*node, 3, ctx.RenameNode(*node->Child(3), Types.PureResultDataSource));
@@ -251,7 +251,7 @@ namespace {
         IGraphTransformer& GetTypeAnnotationTransformer(bool instantOnly) override {
             Y_UNUSED(instantOnly);
             if (!TypeAnnotationTransformer) {
-                TypeAnnotationTransformer = CreateFunctorTransformer(
+                TypeAnnotationTransformer = CreateFunctorTransformer( 
                     [&](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) -> IGraphTransformer::TStatus {
                     output = input;
                     if (input->Content() == ConfReadName) {
@@ -360,18 +360,18 @@ namespace {
         }
 
         bool CanPullResult(const TExprNode& node, TSyncMap& syncList, bool& canRef) override {
-            Y_UNUSED(syncList);
-
+            Y_UNUSED(syncList); 
+ 
             if (node.IsCallable(RightName)) {
                 if (node.Child(0)->IsCallable(ConfReadName)) {
-                    canRef = false;
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
+                    canRef = false; 
+                    return true; 
+                } 
+            } 
+ 
+            return false; 
+        } 
+ 
         bool CanExecute(const TExprNode& node) override {
             if (ConfigProviderFunctions().contains(node.Content()) ||
                 node.Content() == ConfigureName)
@@ -401,7 +401,7 @@ namespace {
 
         void WritePullDetails(const TExprNode& node, NYson::TYsonWriter& writer) override {
             YQL_ENSURE(node.IsCallable(RightName));
-
+ 
             writer.OnKeyedItem("PullOperation");
             writer.OnStringScalar(node.Child(0)->Content());
         }
diff --git a/ydb/library/yql/providers/dq/opt/dqs_opt.cpp b/ydb/library/yql/providers/dq/opt/dqs_opt.cpp
index b4bc07fbef..8749619740 100644
--- a/ydb/library/yql/providers/dq/opt/dqs_opt.cpp
+++ b/ydb/library/yql/providers/dq/opt/dqs_opt.cpp
@@ -49,8 +49,8 @@ namespace NYql::NDqs {
                                 .Build()
                             .Program()
                                 .Args({})
-                                .Body<TCoIterator>()
-                                    .List(input)
+                                .Body<TCoIterator>() 
+                                    .List(input) 
                                     .Build()
                                 .Build()
                             .Settings(TDqStageSettings().BuildNode(ctx, input->Pos()))
@@ -85,13 +85,13 @@ namespace NYql::NDqs {
                         .Build()
                     .Program()
                         .Args({"row"})
-                        .Body("row")
-                        .Build()
+                        .Body("row") 
+                        .Build() 
                     .Settings(TDqStageSettings().BuildNode(ctx, node.Pos()))
-                    .Build()
+                    .Build() 
                 .Index()
                     .Build("0")
-                .Build()
+                .Build() 
               .ColumnHints() // TODO: set column hints
                 .Build()
               .Done().Ptr(); // clang-format on
@@ -109,7 +109,7 @@ namespace NYql::NDqs {
                     PERFORM_RULE(DqPeepholeRewriteCrossJoin, node, ctx);
                     PERFORM_RULE(DqPeepholeRewriteJoinDict, node, ctx);
                     PERFORM_RULE(DqPeepholeRewriteMapJoin, node, ctx);
-                    PERFORM_RULE(DqPeepholeRewritePureJoin, node, ctx);
+                    PERFORM_RULE(DqPeepholeRewritePureJoin, node, ctx); 
                     PERFORM_RULE(DqPeepholeRewriteReplicate, node, ctx);
                     return inputExpr;
                 }, ctx, optSettings);
diff --git a/ydb/library/yql/providers/dq/opt/physical_optimize.cpp b/ydb/library/yql/providers/dq/opt/physical_optimize.cpp
index 858e3da45a..ad71688cf3 100644
--- a/ydb/library/yql/providers/dq/opt/physical_optimize.cpp
+++ b/ydb/library/yql/providers/dq/opt/physical_optimize.cpp
@@ -25,7 +25,7 @@ public:
         AddHandler(0, &TDqReadWrap::Match, HNDL(BuildStageWithReadWrap));
         AddHandler(0, &TCoSkipNullMembers::Match, HNDL(PushSkipNullMembersToStage<false>));
         AddHandler(0, &TCoExtractMembers::Match, HNDL(PushExtractMembersToStage<false>));
-        AddHandler(0, &TCoFlatMapBase::Match, HNDL(BuildFlatmapStage<false>));
+        AddHandler(0, &TCoFlatMapBase::Match, HNDL(BuildFlatmapStage<false>)); 
         AddHandler(0, &TCoCombineByKey::Match, HNDL(PushCombineToStage<false>));
         AddHandler(0, &TCoPartitionsByKeys::Match, HNDL(BuildPartitionsStage));
         AddHandler(0, &TCoPartitionByKey::Match, HNDL(BuildPartitionStage));
@@ -51,7 +51,7 @@ public:
 
         AddHandler(1, &TCoSkipNullMembers::Match, HNDL(PushSkipNullMembersToStage<true>));
         AddHandler(1, &TCoExtractMembers::Match, HNDL(PushExtractMembersToStage<true>));
-        AddHandler(1, &TCoFlatMapBase::Match, HNDL(BuildFlatmapStage<true>));
+        AddHandler(1, &TCoFlatMapBase::Match, HNDL(BuildFlatmapStage<true>)); 
         AddHandler(1, &TCoCombineByKey::Match, HNDL(PushCombineToStage<true>));
         AddHandler(1, &TCoTopSort::Match, HNDL(BuildTopSortStage<true>));
         AddHandler(1, &TCoSort::Match, HNDL(BuildSortStage<true>));
@@ -198,7 +198,7 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> BuildFlatmapStage(TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx, const TGetParents& getParents) {
+    TMaybeNode<TExprBase> BuildFlatmapStage(TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx, const TGetParents& getParents) { 
         return DqBuildFlatmapStage(node, ctx, optCtx, *getParents(), IsGlobal);
     }
 
@@ -258,7 +258,7 @@ protected:
     }
 
     TMaybeNode<TExprBase> BuildExtendStage(TExprBase node, TExprContext& ctx) {
-        return DqBuildExtendStage(node, ctx);
+        return DqBuildExtendStage(node, ctx); 
     }
 
     TMaybeNode<TExprBase> RewriteRightJoinToLeft(TExprBase node, TExprContext& ctx) {
@@ -266,10 +266,10 @@ protected:
     }
 
     template <bool IsGlobal>
-    TMaybeNode<TExprBase> PushJoinToStage(TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx, const TGetParents& getParents) {
+    TMaybeNode<TExprBase> PushJoinToStage(TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx, const TGetParents& getParents) { 
         return DqPushJoinToStage(node, ctx, optCtx, *getParents(), IsGlobal);
-    }
-
+    } 
+ 
     template <bool IsGlobal>
     TMaybeNode<TExprBase> BuildJoin(TExprBase node, TExprContext& ctx, IOptimizationContext& optCtx, const TGetParents& getParents) {
         auto join = node.Cast<TDqJoin>();
@@ -277,7 +277,7 @@ protected:
         if (!JoinPrerequisitesVerify(join, parentsMap, IsGlobal)) {
             return node;
         }
-
+ 
         return DqBuildPhyJoin(join, false /* TODO */, ctx, optCtx);
     }
 
diff --git a/ydb/library/yql/providers/dq/planner/execution_planner.cpp b/ydb/library/yql/providers/dq/planner/execution_planner.cpp
index ec404c0a6d..cb256acb1c 100644
--- a/ydb/library/yql/providers/dq/planner/execution_planner.cpp
+++ b/ydb/library/yql/providers/dq/planner/execution_planner.cpp
@@ -30,7 +30,7 @@
 
 using namespace NYql;
 using namespace NYql::NCommon;
-using namespace NYql::NDq;
+using namespace NYql::NDq; 
 using namespace NYql::NDqProto;
 using namespace NYql::NNodes;
 
diff --git a/ydb/library/yql/providers/result/provider/yql_result_provider.cpp b/ydb/library/yql/providers/result/provider/yql_result_provider.cpp
index 13bfd5e0f7..96381e1687 100644
--- a/ydb/library/yql/providers/result/provider/yql_result_provider.cpp
+++ b/ydb/library/yql/providers/result/provider/yql_result_provider.cpp
@@ -15,7 +15,7 @@
 #include <ydb/library/yql/utils/log/log.h>
 
 #include <library/cpp/yson/node/node_io.h>
-
+ 
 #include <util/string/cast.h>
 
 namespace NYql {
@@ -23,15 +23,15 @@ namespace NYql {
 namespace {
     using namespace NKikimr;
     using namespace NKikimr::NMiniKQL;
-    using namespace NNodes;
-
-    class TYsonResultWriter : public IResultWriter
-    {
-    public:
+    using namespace NNodes; 
+ 
+    class TYsonResultWriter : public IResultWriter 
+    { 
+    public: 
         TYsonResultWriter(NYson::EYsonFormat format)
             : Writer(new NYson::TYsonWriter(&PartialStream, format, ::NYson::EYsonType::Node, true))
         {}
-
+ 
         void Init(bool discard, const TString& label, TMaybe<TPosition> pos) override {
             Discard = discard;
             if (!Discard) {
@@ -56,16 +56,16 @@ namespace {
                 Writer->OnKeyedItem("Write");
                 Writer->OnBeginList();
             }
-        }
-
-        void Write(const TStringBuf& resultData) override {
+        } 
+ 
+        void Write(const TStringBuf& resultData) override { 
             if (!Discard) {
                 Writer->OnListItem();
                 Writer->OnRaw(resultData);
             }
-        }
-
-        void Commit(bool overflow) override {
+        } 
+ 
+        void Commit(bool overflow) override { 
             if (!Discard) {
                 Writer->OnEndList();
                 if (overflow) {
@@ -73,27 +73,27 @@ namespace {
                     Writer->OnBooleanScalar(true);
                 }
                 Writer->OnEndMap();
-            }
-        }
-
+            } 
+        } 
+ 
         bool IsDiscard() const override {
             return Discard;
         }
 
-        TStringBuf Str() override {
-            return PartialStream.Str();
-        }
-
-        ui64 Size() override {
-            return PartialStream.Size();
-        }
-
-    private:
-        TStringStream PartialStream;
+        TStringBuf Str() override { 
+            return PartialStream.Str(); 
+        } 
+ 
+        ui64 Size() override { 
+            return PartialStream.Size(); 
+        } 
+ 
+    private: 
+        TStringStream PartialStream; 
         TAutoPtr<NYson::TYsonWriter> Writer;
         bool Discard = false;
-    };
-
+    }; 
+ 
     IGraphTransformer::TStatus ValidateColumns(TExprNode::TPtr& columns, const TTypeAnnotationNode* listType, TExprContext& ctx) {
         bool hasPrefixes = false;
         for (auto& child : columns->Children()) {
@@ -192,7 +192,7 @@ namespace {
         return IGraphTransformer::TStatus::Ok;
     }
 
-    class TResultCallableExecutionTransformer : public TGraphTransformerBase {
+    class TResultCallableExecutionTransformer : public TGraphTransformerBase { 
     public:
         TResultCallableExecutionTransformer(const TIntrusivePtr<TResultProviderConfig>& config)
             : Config(config)
@@ -200,7 +200,7 @@ namespace {
             YQL_ENSURE(!Config->Types.AvailablePureResultDataSources.empty());
         }
 
-        TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+        TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
             output = input;
 
             TString uniqId = TStringBuilder() << '#' << input->UniqueId();
@@ -219,7 +219,7 @@ namespace {
             }
 
             if (input->Content() == CommitName) {
-                if (ResultWriter) {
+                if (ResultWriter) { 
                     TExprBase commitChild(input->ChildPtr(0));
 
                     bool overflow = commitChild.Maybe<TResPull>() ? PullOverflow : FillOverflow;
@@ -231,7 +231,7 @@ namespace {
                         committedSize += Config->CommittedResults.back().size();
                     }
 
-                    ResultWriter.Reset();
+                    ResultWriter.Reset(); 
                 }
 
                 input->SetState(TExprNode::EState::ExecutionComplete);
@@ -249,13 +249,13 @@ namespace {
             return TStatus::Ok;
         }
 
-        NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
+        NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final { 
             Y_UNUSED(input);
             return DelegatedProvider->GetCallableExecutionTransformer()
                 .GetAsyncFuture(*DelegatedNode);
         }
 
-        TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
+        TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
             output = input;
             auto status = DelegatedProvider->GetCallableExecutionTransformer()
                 .ApplyAsyncChanges(DelegatedNode, DelegatedNodeOutput, ctx);
@@ -288,10 +288,10 @@ namespace {
                     auto resultYsonString = input.Ref().GetResult().Content();
                     auto resultNode = NYT::NodeFromYsonString(TString(resultYsonString), ::NYson::EYsonType::Node);
                     YQL_ENSURE(resultNode.IsMap());
-                    auto resultBoolNode = resultNode.AsMap()["Data"];
+                    auto resultBoolNode = resultNode.AsMap()["Data"]; 
                     YQL_ENSURE(resultBoolNode.IsBool());
-                    const bool predicate = resultBoolNode.AsBool();
-
+                    const bool predicate = resultBoolNode.AsBool(); 
+ 
                     auto branchStatus = RequireChild(input.Ref(), predicate ? TResIf::idx_Then : TResIf::idx_Else);
                     if (branchStatus.Level != IGraphTransformer::TStatus::Ok) {
                         return branchStatus;
@@ -465,7 +465,7 @@ namespace {
             DelegatedProvider = &provider;
             auto fillSettings = Config->FillSettings;
             auto resultSize = ResultWriter ? ResultWriter->Size() : 0;
-
+ 
             ui64 committedSize;
             bool& overflow = GetOverflowFlagAndCommitedSize<TTarget>(committedSize);
 
@@ -569,8 +569,8 @@ namespace {
                 const bool needWriter = input.Content() != TResIf::CallableName()
                     && input.Content() != TResFor::CallableName();
                 if (needWriter) {
-                    ResultWriter->Write(data);
-
+                    ResultWriter->Write(data); 
+ 
                     input.SetResult(ctx.NewAtom(input.Pos(), ""));
                     input.SetState(TExprNode::EState::ExecutionComplete);
                 } else {
@@ -602,7 +602,7 @@ namespace {
         ui64 CommittedFillSize = 0;
         bool FillOverflow = false;
 
-        TIntrusivePtr<IResultWriter> ResultWriter;
+        TIntrusivePtr<IResultWriter> ResultWriter; 
     };
 
     template <class TTarget>
@@ -636,229 +636,229 @@ namespace {
         const TIntrusivePtr<TResultProviderConfig> Config;
     };
 
-    class TPhysicalFinalizingTransformer final : public TSyncTransformerBase {
-    public:
-        TPhysicalFinalizingTransformer(const TIntrusivePtr<TResultProviderConfig>& config)
-            : Config(config) {}
-
-        TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-            TOptimizeExprSettings settings(&Config->Types);
-            settings.ProcessedNodes = &PhysicalOptProcessedNodes;
-            TStatus status = OptimizeExprEx(input, output,
-                [&](const TExprNode::TPtr& node, TExprContext& ctx, IOptimizationContext& optCtx) -> TExprNode::TPtr {
-                auto ret = node;
-                if (auto maybeWrite = TMaybeNode<TResWrite>(node)) {
-                    auto resWrite = maybeWrite.Cast();
-                    bool isRef = false;
-                    bool isAutoRef = false;
-                    for (auto child: resWrite.Settings()) {
-                        if (child.Name().Value() == "ref") {
-                            isRef = true;
-                        }
-
-                        if (child.Name().Value() == "autoref") {
-                            isAutoRef = true;
-                        }
-                    }
-
-                    auto writeInput = resWrite.Data();
-                    for (auto& source : Config->Types.DataSources) {
-                        TSyncMap syncList;
-                        bool canRef;
-                        if (source->CanPullResult(writeInput.Ref(), syncList, canRef)) {
-                            auto newInput = writeInput;
-
-                            if (isRef && !canRef) {
+    class TPhysicalFinalizingTransformer final : public TSyncTransformerBase { 
+    public: 
+        TPhysicalFinalizingTransformer(const TIntrusivePtr<TResultProviderConfig>& config) 
+            : Config(config) {} 
+ 
+        TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final { 
+            TOptimizeExprSettings settings(&Config->Types); 
+            settings.ProcessedNodes = &PhysicalOptProcessedNodes; 
+            TStatus status = OptimizeExprEx(input, output, 
+                [&](const TExprNode::TPtr& node, TExprContext& ctx, IOptimizationContext& optCtx) -> TExprNode::TPtr { 
+                auto ret = node; 
+                if (auto maybeWrite = TMaybeNode<TResWrite>(node)) { 
+                    auto resWrite = maybeWrite.Cast(); 
+                    bool isRef = false; 
+                    bool isAutoRef = false; 
+                    for (auto child: resWrite.Settings()) { 
+                        if (child.Name().Value() == "ref") { 
+                            isRef = true; 
+                        } 
+ 
+                        if (child.Name().Value() == "autoref") { 
+                            isAutoRef = true; 
+                        } 
+                    } 
+ 
+                    auto writeInput = resWrite.Data(); 
+                    for (auto& source : Config->Types.DataSources) { 
+                        TSyncMap syncList; 
+                        bool canRef; 
+                        if (source->CanPullResult(writeInput.Ref(), syncList, canRef)) { 
+                            auto newInput = writeInput; 
+ 
+                            if (isRef && !canRef) { 
                                 ctx.AddError(TIssue(ctx.GetPosition(writeInput.Pos()), TStringBuilder() <<
-                                    "RefSelect mode isn't supported by provider: " << source->GetName()));
-                                return nullptr;
-                            }
-
+                                    "RefSelect mode isn't supported by provider: " << source->GetName())); 
+                                return nullptr; 
+                            } 
+ 
                             auto fillSettings = Config->FillSettings;
-                            if (!isRef && (!isAutoRef || !canRef)) {
-                                for (auto setting: resWrite.Settings()) {
-                                    if (setting.Name().Value() == "take") {
-                                        auto value = FromString<ui64>(setting.Value().Cast<TCoAtom>().Value());
-                                        if (fillSettings.RowsLimitPerWrite) {
-                                            fillSettings.RowsLimitPerWrite = Min(*fillSettings.RowsLimitPerWrite, value);
-                                        } else {
-                                            fillSettings.RowsLimitPerWrite = value;
-                                        }
-                                    }
-                                }
-
-                                if (fillSettings.RowsLimitPerWrite) {
-                                    *fillSettings.RowsLimitPerWrite += 1;
-                                }
+                            if (!isRef && (!isAutoRef || !canRef)) { 
+                                for (auto setting: resWrite.Settings()) { 
+                                    if (setting.Name().Value() == "take") { 
+                                        auto value = FromString<ui64>(setting.Value().Cast<TCoAtom>().Value()); 
+                                        if (fillSettings.RowsLimitPerWrite) { 
+                                            fillSettings.RowsLimitPerWrite = Min(*fillSettings.RowsLimitPerWrite, value); 
+                                        } else { 
+                                            fillSettings.RowsLimitPerWrite = value; 
+                                        } 
+                                    } 
+                                } 
+ 
+                                if (fillSettings.RowsLimitPerWrite) { 
+                                    *fillSettings.RowsLimitPerWrite += 1; 
+                                } 
                             } else {
                                 fillSettings.RowsLimitPerWrite.Clear();
-                            }
+                            } 
                             newInput = TExprBase(source->OptimizePull(newInput.Ptr(), fillSettings, ctx, optCtx));
-
-                            ret = Build<TResPull>(ctx, resWrite.Pos())
-                                .World(ApplySyncListToWorld(resWrite.World().Ptr(), syncList, ctx))
-                                .DataSink(resWrite.DataSink())
-                                .Key(resWrite.Key())
-                                .Data(newInput)
-                                .Settings(resWrite.Settings())
-                                .DelegatedSource()
-                                    .Value(source->GetName())
-                                .Build()
-                                .Done().Ptr();
-
-                            YQL_CLOG(INFO, ProviderResult) << "ResPull";
-                            return ret;
-                        }
-                    }
-
-                    if (!isRef) {
-                        auto data = resWrite.Data();
+ 
+                            ret = Build<TResPull>(ctx, resWrite.Pos()) 
+                                .World(ApplySyncListToWorld(resWrite.World().Ptr(), syncList, ctx)) 
+                                .DataSink(resWrite.DataSink()) 
+                                .Key(resWrite.Key()) 
+                                .Data(newInput) 
+                                .Settings(resWrite.Settings()) 
+                                .DelegatedSource() 
+                                    .Value(source->GetName()) 
+                                .Build() 
+                                .Done().Ptr(); 
+ 
+                            YQL_CLOG(INFO, ProviderResult) << "ResPull"; 
+                            return ret; 
+                        } 
+                    } 
+ 
+                    if (!isRef) { 
+                        auto data = resWrite.Data(); 
                         if (auto unordered = data.Maybe<TCoUnorderedBase>()) {
-                            data = unordered.Cast().Input();
-                        }
-
-                        if (IsPureIsolatedLambda(writeInput.Ref())) {
-                            ret = Build<TResFill>(ctx, resWrite.Pos())
-                                .World(resWrite.World())
-                                .DataSink(resWrite.DataSink())
-                                .Key(resWrite.Key())
-                                .Data(data)
-                                .Settings(resWrite.Settings())
-                                .DelegatedSource()
-                                    .Value(Config->Types.GetDefaultDataSource())
-                                .Build()
-                                .Done().Ptr();
-
-                            YQL_CLOG(INFO, ProviderResult) << "ResFill";
-                            return ret;
-                        }
-
-                        for (auto& source : Config->Types.DataSources) {
-                            TSyncMap syncList;
-                            if (source->CanBuildResult(writeInput.Ref(), syncList)) {
-                                auto cleanup = source->CleanupWorld(data.Ptr(), ctx);
-                                if (!cleanup) {
-                                    return nullptr;
-                                }
-
-                                ret = Build<TResFill>(ctx, resWrite.Pos())
-                                    .World(ApplySyncListToWorld(resWrite.World().Ptr(), syncList, ctx))
-                                    .DataSink(resWrite.DataSink())
-                                    .Key(resWrite.Key())
-                                    .Data(cleanup)
-                                    .Settings(resWrite.Settings())
-                                    .DelegatedSource()
-                                        .Value(source->GetName())
-                                    .Build()
-                                    .Done().Ptr();
-
-                                YQL_CLOG(INFO, ProviderResult) << "ResFill";
-                                return ret;
-                            }
-                        }
-                    }
-                } else if (node->Content() == IfName) {
-                    TSyncMap syncList;
-                    auto foundDataSource = FindDataSource(*node->Child(1), syncList);
-                    if (!foundDataSource.empty()) {
-                        auto provider = Config->Types.DataSourceMap.FindPtr(foundDataSource);
-                        Y_ENSURE(provider, "DataSource doesn't exist: " << foundDataSource);
-                        auto cleanup = (*provider)->CleanupWorld(node->ChildPtr(1), ctx);
-                        if (!cleanup) {
-                            return nullptr;
-                        }
-
-                        ret = Build<TResIf>(ctx, node->Pos())
-                            .World(ApplySyncListToWorld(node->ChildPtr(0), syncList, ctx))
-                            .DataSink()
-                            .Build()
-                            .Condition(cleanup)
-                            .Then(node->ChildPtr(2))
-                            .Else(node->ChildPtr(3))
-                            .DelegatedSource()
-                                .Value(foundDataSource)
-                            .Build()
-                            .Settings()
-                            .Build()
-                            .Done().Ptr();
-
-                        YQL_CLOG(INFO, ProviderResult) << "ResIf";
-                        return ret;
-                    }
-                } else if (node->Content() == ForName) {
-                    TSyncMap syncList;
-                    auto foundDataSource = FindDataSource(*node->Child(1), syncList);
-                    if (!foundDataSource.empty()) {
-                        auto provider = Config->Types.DataSourceMap.FindPtr(foundDataSource);
-                        Y_ENSURE(provider, "DataSource doesn't exist: " << foundDataSource);
-                        auto cleanup = (*provider)->CleanupWorld(node->ChildPtr(1), ctx);
-                        if (!cleanup) {
-                            return nullptr;
-                        }
-
-                        ret = Build<TResFor>(ctx, node->Pos())
-                            .World(ApplySyncListToWorld(node->ChildPtr(0), syncList, ctx))
-                            .DataSink()
-                            .Build()
-                            .Items(cleanup)
-                            .Iter(node->ChildPtr(2))
-                            .Else(node->ChildPtr(3))
-                            .DelegatedSource()
-                                .Value(foundDataSource)
-                            .Build()
-                            .Settings()
-                            .Build()
-                            .Total()
-                                .Value("")
-                            .Build()
-                            .Current()
-                                .Value("")
-                            .Build()
-                            .Active<TCoVoid>()
-                            .Build()
-                            .Done().Ptr();
-
-                        YQL_CLOG(INFO, ProviderResult) << "ResFor";
-                        return ret;
-                    }
-                }
-
-                return ret;
-            }, ctx, settings);
-
-            return status;
-        }
-
-        void Rewind() final {
-            PhysicalOptProcessedNodes.clear();
-        }
-
-    private:
-        TString FindDataSource(const TExprNode& node, TSyncMap& syncList) const {
-            syncList.clear();
-            TString foundDataSource;
-            if (IsPureIsolatedLambda(node)) {
-                foundDataSource = Config->Types.GetDefaultDataSource();
-            }
-
-            if (foundDataSource.empty()) {
-                for (auto& source : Config->Types.DataSources) {
-                    syncList.clear();
-                    if (source->CanBuildResult(node, syncList)) {
+                            data = unordered.Cast().Input(); 
+                        } 
+ 
+                        if (IsPureIsolatedLambda(writeInput.Ref())) { 
+                            ret = Build<TResFill>(ctx, resWrite.Pos()) 
+                                .World(resWrite.World()) 
+                                .DataSink(resWrite.DataSink()) 
+                                .Key(resWrite.Key()) 
+                                .Data(data) 
+                                .Settings(resWrite.Settings()) 
+                                .DelegatedSource() 
+                                    .Value(Config->Types.GetDefaultDataSource()) 
+                                .Build() 
+                                .Done().Ptr(); 
+ 
+                            YQL_CLOG(INFO, ProviderResult) << "ResFill"; 
+                            return ret; 
+                        } 
+ 
+                        for (auto& source : Config->Types.DataSources) { 
+                            TSyncMap syncList; 
+                            if (source->CanBuildResult(writeInput.Ref(), syncList)) { 
+                                auto cleanup = source->CleanupWorld(data.Ptr(), ctx); 
+                                if (!cleanup) { 
+                                    return nullptr; 
+                                } 
+ 
+                                ret = Build<TResFill>(ctx, resWrite.Pos()) 
+                                    .World(ApplySyncListToWorld(resWrite.World().Ptr(), syncList, ctx)) 
+                                    .DataSink(resWrite.DataSink()) 
+                                    .Key(resWrite.Key()) 
+                                    .Data(cleanup) 
+                                    .Settings(resWrite.Settings()) 
+                                    .DelegatedSource() 
+                                        .Value(source->GetName()) 
+                                    .Build() 
+                                    .Done().Ptr(); 
+ 
+                                YQL_CLOG(INFO, ProviderResult) << "ResFill"; 
+                                return ret; 
+                            } 
+                        } 
+                    } 
+                } else if (node->Content() == IfName) { 
+                    TSyncMap syncList; 
+                    auto foundDataSource = FindDataSource(*node->Child(1), syncList); 
+                    if (!foundDataSource.empty()) { 
+                        auto provider = Config->Types.DataSourceMap.FindPtr(foundDataSource); 
+                        Y_ENSURE(provider, "DataSource doesn't exist: " << foundDataSource); 
+                        auto cleanup = (*provider)->CleanupWorld(node->ChildPtr(1), ctx); 
+                        if (!cleanup) { 
+                            return nullptr; 
+                        } 
+ 
+                        ret = Build<TResIf>(ctx, node->Pos()) 
+                            .World(ApplySyncListToWorld(node->ChildPtr(0), syncList, ctx)) 
+                            .DataSink() 
+                            .Build() 
+                            .Condition(cleanup) 
+                            .Then(node->ChildPtr(2)) 
+                            .Else(node->ChildPtr(3)) 
+                            .DelegatedSource() 
+                                .Value(foundDataSource) 
+                            .Build() 
+                            .Settings() 
+                            .Build() 
+                            .Done().Ptr(); 
+ 
+                        YQL_CLOG(INFO, ProviderResult) << "ResIf"; 
+                        return ret; 
+                    } 
+                } else if (node->Content() == ForName) { 
+                    TSyncMap syncList; 
+                    auto foundDataSource = FindDataSource(*node->Child(1), syncList); 
+                    if (!foundDataSource.empty()) { 
+                        auto provider = Config->Types.DataSourceMap.FindPtr(foundDataSource); 
+                        Y_ENSURE(provider, "DataSource doesn't exist: " << foundDataSource); 
+                        auto cleanup = (*provider)->CleanupWorld(node->ChildPtr(1), ctx); 
+                        if (!cleanup) { 
+                            return nullptr; 
+                        } 
+ 
+                        ret = Build<TResFor>(ctx, node->Pos()) 
+                            .World(ApplySyncListToWorld(node->ChildPtr(0), syncList, ctx)) 
+                            .DataSink() 
+                            .Build() 
+                            .Items(cleanup) 
+                            .Iter(node->ChildPtr(2)) 
+                            .Else(node->ChildPtr(3)) 
+                            .DelegatedSource() 
+                                .Value(foundDataSource) 
+                            .Build() 
+                            .Settings() 
+                            .Build() 
+                            .Total() 
+                                .Value("") 
+                            .Build() 
+                            .Current() 
+                                .Value("") 
+                            .Build() 
+                            .Active<TCoVoid>() 
+                            .Build() 
+                            .Done().Ptr(); 
+ 
+                        YQL_CLOG(INFO, ProviderResult) << "ResFor"; 
+                        return ret; 
+                    } 
+                } 
+ 
+                return ret; 
+            }, ctx, settings); 
+ 
+            return status; 
+        } 
+ 
+        void Rewind() final { 
+            PhysicalOptProcessedNodes.clear(); 
+        } 
+ 
+    private: 
+        TString FindDataSource(const TExprNode& node, TSyncMap& syncList) const { 
+            syncList.clear(); 
+            TString foundDataSource; 
+            if (IsPureIsolatedLambda(node)) { 
+                foundDataSource = Config->Types.GetDefaultDataSource(); 
+            } 
+ 
+            if (foundDataSource.empty()) { 
+                for (auto& source : Config->Types.DataSources) { 
+                    syncList.clear(); 
+                    if (source->CanBuildResult(node, syncList)) { 
                         foundDataSource = TString(source->GetName());
-                        break;
-                    }
-                }
-            }
-
-            return foundDataSource;
-        }
-
-    private:
-        const TIntrusivePtr<TResultProviderConfig> Config;
-        TProcessedNodesSet PhysicalOptProcessedNodes;
-    };
-
+                        break; 
+                    } 
+                } 
+            } 
+ 
+            return foundDataSource; 
+        } 
+ 
+    private: 
+        const TIntrusivePtr<TResultProviderConfig> Config; 
+        TProcessedNodesSet PhysicalOptProcessedNodes; 
+    }; 
+ 
     class TResultProvider : public TDataProviderBase {
     public:
         struct TFunctions {
@@ -887,7 +887,7 @@ namespace {
                 return false;
             }
 
-            cluster = Nothing();
+            cluster = Nothing(); 
             return true;
         }
 
@@ -902,7 +902,7 @@ namespace {
         IGraphTransformer& GetTypeAnnotationTransformer(bool instantOnly) override {
             Y_UNUSED(instantOnly);
             if (!TypeAnnotationTransformer) {
-                TypeAnnotationTransformer = CreateFunctorTransformer(
+                TypeAnnotationTransformer = CreateFunctorTransformer( 
                     [&](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx)->IGraphTransformer::TStatus {
                     output = input;
 
@@ -1028,23 +1028,23 @@ namespace {
 
                         if (auto right = res.Data().Maybe<TCoRight>()) {
                             auto source = right.Cast().Input();
-                            const TIntrusivePtr<IDataProvider>* provider = nullptr;
-
+                            const TIntrusivePtr<IDataProvider>* provider = nullptr; 
+ 
                             if (source.Ref().Type() == TExprNode::Callable || source.Ref().ChildrenSize() >= 2) {
                                 if (source.Ref().Child(1)->IsCallable("DataSource")) {
                                     auto name = source.Ref().Child(1)->Child(0)->Content();
                                     provider = Config->Types.DataSourceMap.FindPtr(name);
                                     Y_ENSURE(provider, "DataSource doesn't exist: " << name);
-                                }
+                                } 
 
                                 if (source.Ref().Child(1)->IsCallable("DataSink")) {
                                     auto name = source.Ref().Child(1)->Child(0)->Content();
                                     provider = Config->Types.DataSinkMap.FindPtr(name);
                                     Y_ENSURE(provider, "DataSink doesn't exist: " << name);
                                 }
-                            }
-
-                            if (!provider) {
+                            } 
+ 
+                            if (!provider) { 
                                 ctx.AddError(TIssue(ctx.GetPosition(res.Data().Pos()), "Expected Right! over Datasource or Datasink"));
                                 return IGraphTransformer::TStatus::Error;
                             }
@@ -1243,27 +1243,27 @@ namespace {
                         return IGraphTransformer::TStatus::Ok;
                     }
                     else if (auto maybeCommit = TMaybeNode<TCoCommit>(input)) {
-                        auto commit = maybeCommit.Cast();
-                        auto settings = NCommon::ParseCommitSettings(commit, ctx);
-
-                        if (!settings.EnsureModeEmpty(ctx)) {
-                            return IGraphTransformer::TStatus::Error;
-                        }
-                        if (!settings.EnsureEpochEmpty(ctx)) {
-                            return IGraphTransformer::TStatus::Error;
-                        }
-                        if (!settings.EnsureOtherEmpty(ctx)) {
-                            return IGraphTransformer::TStatus::Error;
-                        }
-
+                        auto commit = maybeCommit.Cast(); 
+                        auto settings = NCommon::ParseCommitSettings(commit, ctx); 
+
+                        if (!settings.EnsureModeEmpty(ctx)) { 
+                            return IGraphTransformer::TStatus::Error; 
+                        } 
+                        if (!settings.EnsureEpochEmpty(ctx)) { 
+                            return IGraphTransformer::TStatus::Error; 
+                        } 
+                        if (!settings.EnsureOtherEmpty(ctx)) { 
+                            return IGraphTransformer::TStatus::Error; 
+                        } 
+ 
                         input->SetTypeAnn(commit.World().Ref().GetTypeAnn());
-                        return IGraphTransformer::TStatus::Ok;
-                    }
+                        return IGraphTransformer::TStatus::Ok; 
+                    } 
                     else if (input->Content() == ConfigureName) {
                         if (!EnsureMinArgsCount(*input, 3, ctx)) {
                             return IGraphTransformer::TStatus::Error;
                         }
-
+ 
                         if (!EnsureWorldType(*input->Child(0), ctx)) {
                             return IGraphTransformer::TStatus::Error;
                         }
@@ -1341,7 +1341,7 @@ namespace {
 
         IGraphTransformer& GetPhysicalFinalizingTransformer() override {
             if (!PhysicalFinalizingTransformer) {
-                PhysicalFinalizingTransformer = new TPhysicalFinalizingTransformer(Config);
+                PhysicalFinalizingTransformer = new TPhysicalFinalizingTransformer(Config); 
             }
 
             return *PhysicalFinalizingTransformer;
@@ -1417,7 +1417,7 @@ namespace {
                 auto dataSourceName = resPull.Cast().DelegatedSource().Value();
                 auto dataSource = Config->Types.DataSourceMap.FindPtr(dataSourceName);
                 YQL_ENSURE(dataSource);
-
+ 
                 (*dataSource)->GetPlanFormatter().WritePullDetails(resPull.Cast().Data().Ref(), writer);
             }
         }
@@ -1462,9 +1462,9 @@ namespace {
 }
 
 TIntrusivePtr<IResultWriter> CreateYsonResultWriter(NYson::EYsonFormat format) {
-    return MakeIntrusive<TYsonResultWriter>(format);
-}
-
+    return MakeIntrusive<TYsonResultWriter>(format); 
+} 
+ 
 TIntrusivePtr<IDataProvider> CreateResultProvider(const TIntrusivePtr<TResultProviderConfig>& config) {
     return new TResultProvider(config);
 }
diff --git a/ydb/library/yql/providers/result/provider/yql_result_provider.h b/ydb/library/yql/providers/result/provider/yql_result_provider.h
index ee5bb5a9f6..340ee9fde9 100644
--- a/ydb/library/yql/providers/result/provider/yql_result_provider.h
+++ b/ydb/library/yql/providers/result/provider/yql_result_provider.h
@@ -9,36 +9,36 @@ namespace Nkikimr::NMiniKQL {
 
 namespace NYql {
 
-class IResultWriter : public TThrRefBase {
-public:
+class IResultWriter : public TThrRefBase { 
+public: 
     virtual void Init(bool discard, const TString& label, TMaybe<TPosition> pos) = 0;
-    virtual void Write(const TStringBuf& resultData) = 0;
-    virtual void Commit(bool overflow) = 0;
+    virtual void Write(const TStringBuf& resultData) = 0; 
+    virtual void Commit(bool overflow) = 0; 
     virtual bool IsDiscard() const = 0;
-    virtual TStringBuf Str() = 0;
-    virtual ui64 Size() = 0;
-};
-
+    virtual TStringBuf Str() = 0; 
+    virtual ui64 Size() = 0; 
+}; 
+ 
 TIntrusivePtr<IResultWriter> CreateYsonResultWriter(NYson::EYsonFormat format);
-
+ 
 struct TResultProviderConfig : TThrRefBase {
-    using TResultWriterFactory = std::function<TIntrusivePtr<IResultWriter>()>;
-
+    using TResultWriterFactory = std::function<TIntrusivePtr<IResultWriter>()>; 
+ 
     TResultProviderConfig(TTypeAnnotationContext& types,
         const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
         IDataProvider::EResultFormat format, const TString& formatDetails, TResultWriterFactory writerFactory)
         : Types(types)
         , FunctionRegistry(functionRegistry)
-        , WriterFactory(writerFactory)
+        , WriterFactory(writerFactory) 
     {
-        FillSettings.Format = format;
-        FillSettings.FormatDetails = formatDetails;
+        FillSettings.Format = format; 
+        FillSettings.FormatDetails = formatDetails; 
     }
 
     TTypeAnnotationContext& Types;
     const NKikimr::NMiniKQL::IFunctionRegistry& FunctionRegistry;
     IDataProvider::TFillSettings FillSettings;
-    TResultWriterFactory WriterFactory;
+    TResultWriterFactory WriterFactory; 
     TVector<TString> CommittedResults;
     bool SupportsResultPosition = false;
 };
diff --git a/ydb/library/yql/public/issue/yql_issue.h b/ydb/library/yql/public/issue/yql_issue.h
index 7b97674c9d..6029bdfa1a 100644
--- a/ydb/library/yql/public/issue/yql_issue.h
+++ b/ydb/library/yql/public/issue/yql_issue.h
@@ -119,15 +119,15 @@ public:
     TIssue() = default;
 
     template <typename T>
-    explicit TIssue(const T& message)
-        : Position(TPosition())
-        , EndPosition(TPosition())
-        , Message(message)
-    {
+    explicit TIssue(const T& message) 
+        : Position(TPosition()) 
+        , EndPosition(TPosition()) 
+        , Message(message) 
+    { 
         SanitizeNonAscii(Message);
-    }
-
-    template <typename T>
+    } 
+ 
+    template <typename T> 
     TIssue(TPosition position, const T& message)
         : Position(position)
         , EndPosition(position)
@@ -206,15 +206,15 @@ public:
     TIssues() = default;
 
     inline TIssues(const TVector<TIssue>& issues)
-        : Issues_(issues)
-    {
-    }
-
-    inline TIssues(const std::initializer_list<TIssue>& issues)
-        : TIssues(TVector<TIssue>(issues))
-    {
-    }
-
+        : Issues_(issues) 
+    { 
+    } 
+ 
+    inline TIssues(const std::initializer_list<TIssue>& issues) 
+        : TIssues(TVector<TIssue>(issues)) 
+    { 
+    } 
+ 
     inline TIssues(const TIssues& rhs)
         : Issues_(rhs.Issues_)
     {
@@ -234,16 +234,16 @@ public:
         return *this;
     }
 
-    template <typename ... Args> void AddIssue(Args&& ... args) {
+    template <typename ... Args> void AddIssue(Args&& ... args) { 
         Issues_.emplace_back(std::forward<Args>(args)...);
     }
 
-    inline void AddIssues(const TIssues& errors) {
+    inline void AddIssues(const TIssues& errors) { 
         Issues_.insert(Issues_.end(),
                        errors.Issues_.begin(), errors.Issues_.end());
     }
 
-    inline void AddIssues(const TPosition& pos, const TIssues& errors) {
+    inline void AddIssues(const TPosition& pos, const TIssues& errors) { 
         Issues_.reserve(Issues_.size() + errors.Size());
         for (const auto& e: errors) {
             Issues_.push_back(TIssue(pos, e.Message));
diff --git a/ydb/library/yql/public/issue/yql_issue_manager.cpp b/ydb/library/yql/public/issue/yql_issue_manager.cpp
index 7375d2d30f..13b21be8a8 100644
--- a/ydb/library/yql/public/issue/yql_issue_manager.cpp
+++ b/ydb/library/yql/public/issue/yql_issue_manager.cpp
@@ -100,7 +100,7 @@ void TIssueManager::RaiseIssue(const TIssue& issue) {
         return;
     }
     if (RawIssues_.empty()) {
-        CompletedIssues_.AddIssue(issue);
+        CompletedIssues_.AddIssue(issue); 
         return;
     }
     if (RawIssues_.top().first.Empty()) {
diff --git a/ydb/library/yql/public/issue/yql_issue_message.cpp b/ydb/library/yql/public/issue/yql_issue_message.cpp
index f9d512ca5a..239fbd388d 100644
--- a/ydb/library/yql/public/issue/yql_issue_message.cpp
+++ b/ydb/library/yql/public/issue/yql_issue_message.cpp
@@ -38,7 +38,7 @@ TIssue IssueFromMessage(const TIssueMessage& issueMessage) {
             issue.AddSubIssue(subIssue);
             queue.push_front(std::make_pair(subIssue, &subMessage));
         }
-
+ 
         issue.SetCode(message.issue_code(), static_cast<ESeverity>(message.severity()));
     }
     return topIssue;
diff --git a/ydb/library/yql/public/udf/udf_data_type.h b/ydb/library/yql/public/udf/udf_data_type.h
index 29558c1879..38ae9980cf 100644
--- a/ydb/library/yql/public/udf/udf_data_type.h
+++ b/ydb/library/yql/public/udf/udf_data_type.h
@@ -174,7 +174,7 @@ constexpr ui32 MAX_YEAR = 2106u;
     XX(TzDatetime, NYql::NProto::TzDatetime, TTzDatetime, CommonType | TzDateType, ui32, 0) \
     XX(TzTimestamp, NYql::NProto::TzTimestamp, TTzTimestamp, CommonType | TzDateType, ui64, 0) \
     XX(Decimal, NYql::NProto::Decimal, TDecimal, CommonType | DecimalType, TDecimal, 2) \
-    XX(DyNumber, NYql::NProto::DyNumber, TDyNumber, CommonType, TDyNumber, 0) \
+    XX(DyNumber, NYql::NProto::DyNumber, TDyNumber, CommonType, TDyNumber, 0) \ 
     XX(JsonDocument, NYql::NProto::JsonDocument, TJsonDocument, PayloadType, TJsonDocument, 0) \
 
 #define UDF_TYPE_ID(xName, xTypeId, xType, xFeatures, xLayoutType, xParamsCount)                 \
diff --git a/ydb/library/yql/public/udf/udf_type_builder.h b/ydb/library/yql/public/udf/udf_type_builder.h
index 8bfc73a449..9fd7e8281f 100644
--- a/ydb/library/yql/public/udf/udf_type_builder.h
+++ b/ydb/library/yql/public/udf/udf_type_builder.h
@@ -485,14 +485,14 @@ public:
     // 1.2
     virtual IFunctionTypeInfoBuilder1& PayloadImpl(const TStringRef& payload) = 0;
 
-    // Important: Always add new ABI VERSION methods to the end of the class definition.
-
+    // Important: Always add new ABI VERSION methods to the end of the class definition. 
+ 
     virtual IVariantTypeBuilder::TPtr Variant() const = 0;
-
+ 
     virtual IFunctionTypeInfoBuilder1& UserTypeImpl(TDataTypeId type) = 0;
     virtual IFunctionTypeInfoBuilder1& UserTypeImpl(const TType* type) = 0;
     virtual IFunctionTypeInfoBuilder1& UserTypeImpl(const ITypeBuilder& typeBuilder) = 0;
-
+ 
     virtual NUdf::IStreamTypeBuilder::TPtr Stream() const = 0;
 };
 
diff --git a/ydb/library/yql/sql/sql.cpp b/ydb/library/yql/sql/sql.cpp
index 9b03f681f3..8e4d216a6d 100644
--- a/ydb/library/yql/sql/sql.cpp
+++ b/ydb/library/yql/sql/sql.cpp
@@ -11,22 +11,22 @@
 
 #include <util/string/builder.h>
 
-namespace NSQLTranslation {
-
-    NYql::TAstParseResult SqlToYql(const TString& query, const TTranslationSettings& settings,
+namespace NSQLTranslation { 
+ 
+    NYql::TAstParseResult SqlToYql(const TString& query, const TTranslationSettings& settings, 
         NYql::TWarningRules* warningRules, ui16* actualSyntaxVersion)
-    {
-        NYql::TAstParseResult result;
-        TTranslationSettings parsedSettings(settings);
+    { 
+        NYql::TAstParseResult result; 
+        TTranslationSettings parsedSettings(settings); 
         google::protobuf::Arena arena;
         if (!parsedSettings.Arena) {
             parsedSettings.Arena = &arena;
         }
 
-        if (!ParseTranslationSettings(query, parsedSettings, result.Issues)) {
-            return result;
-        }
-
+        if (!ParseTranslationSettings(query, parsedSettings, result.Issues)) { 
+            return result; 
+        } 
+ 
         if (actualSyntaxVersion) {
             *actualSyntaxVersion = parsedSettings.SyntaxVersion;
         }
@@ -35,7 +35,7 @@ namespace NSQLTranslation {
             return NSQLTranslationPG::PGToYql(query, parsedSettings);
         }
 
-        switch (parsedSettings.SyntaxVersion) {
+        switch (parsedSettings.SyntaxVersion) { 
             case 0:
                 if (settings.V0ForceDisable || parsedSettings.V0Behavior == EV0Behavior::Disable) {
                     result.Issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
@@ -49,29 +49,29 @@ namespace NSQLTranslation {
                     return result;
                 }
 
-                return NSQLTranslationV0::SqlToYql(query, parsedSettings, warningRules);
+                return NSQLTranslationV0::SqlToYql(query, parsedSettings, warningRules); 
             case 1:
-                return NSQLTranslationV1::SqlToYql(query, parsedSettings, warningRules);
+                return NSQLTranslationV1::SqlToYql(query, parsedSettings, warningRules); 
             default:
-                result.Issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
-                    TStringBuilder() << "Unknown SQL syntax version: " << parsedSettings.SyntaxVersion));
-                return result;
+                result.Issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR, 
+                    TStringBuilder() << "Unknown SQL syntax version: " << parsedSettings.SyntaxVersion)); 
+                return result; 
         }
     }
 
     google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NYql::TIssues& issues,
         size_t maxErrors, const TTranslationSettings& settings, ui16* actualSyntaxVersion)
-    {
-        TTranslationSettings parsedSettings(settings);
-        if (!ParseTranslationSettings(query, parsedSettings, issues)) {
-            return nullptr;
-        }
-
+    { 
+        TTranslationSettings parsedSettings(settings); 
+        if (!ParseTranslationSettings(query, parsedSettings, issues)) { 
+            return nullptr; 
+        } 
+ 
         if (actualSyntaxVersion) {
             *actualSyntaxVersion = parsedSettings.SyntaxVersion;
         }
 
-        switch (parsedSettings.SyntaxVersion) {
+        switch (parsedSettings.SyntaxVersion) { 
             case 0:
                 if (settings.V0ForceDisable || settings.V0Behavior == EV0Behavior::Disable) {
                     issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
@@ -89,9 +89,9 @@ namespace NSQLTranslation {
             case 1:
                 return NSQLTranslationV1::SqlAST(query, queryName, issues, maxErrors, parsedSettings.AnsiLexer, settings.Arena);
             default:
-                issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
-                    TStringBuilder() << "Unknown SQL syntax version: " << parsedSettings.SyntaxVersion));
-                return nullptr;
+                issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR, 
+                    TStringBuilder() << "Unknown SQL syntax version: " << parsedSettings.SyntaxVersion)); 
+                return nullptr; 
         }
     }
 
@@ -131,7 +131,7 @@ namespace NSQLTranslation {
     }
 
     NYql::TAstParseResult SqlASTToYql(const google::protobuf::Message& protoAst, const TTranslationSettings& settings) {
-        NYql::TAstParseResult result;
+        NYql::TAstParseResult result; 
         switch (settings.SyntaxVersion) {
             case 0:
                 if (settings.V0ForceDisable || settings.V0Behavior == EV0Behavior::Disable) {
@@ -150,9 +150,9 @@ namespace NSQLTranslation {
             case 1:
                 return NSQLTranslationV1::SqlASTToYql(protoAst, settings);
             default:
-                result.Issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
-                    TStringBuilder() << "Unknown SQL syntax version: " << settings.SyntaxVersion));
-                return result;
+                result.Issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR, 
+                    TStringBuilder() << "Unknown SQL syntax version: " << settings.SyntaxVersion)); 
+                return result; 
         }
     }
 
diff --git a/ydb/library/yql/sql/v0/SQL.g b/ydb/library/yql/sql/v0/SQL.g
index 3b616b9c9f..e172666a87 100644
--- a/ydb/library/yql/sql/v0/SQL.g
+++ b/ydb/library/yql/sql/v0/SQL.g
@@ -28,7 +28,7 @@ sql_stmt_core:
   | commit_stmt
   | update_stmt
   | delete_stmt
-  | rollback_stmt
+  | rollback_stmt 
   | declare_stmt
   | import_stmt
   | export_stmt
@@ -329,8 +329,8 @@ table_hints: WITH (id_or_string | pure_column_list);
 simple_table_ref: ((opt_id_prefix id_or_at) | AT? bind_parameter) table_hints?;
 into_simple_table_ref: simple_table_ref (ERASE BY pure_column_list)?;
 
-delete_stmt: DELETE FROM simple_table_ref (WHERE expr | ON into_values_source)?;
-update_stmt: UPDATE simple_table_ref (SET set_clause_choice (WHERE expr)? | ON into_values_source);
+delete_stmt: DELETE FROM simple_table_ref (WHERE expr | ON into_values_source)?; 
+update_stmt: UPDATE simple_table_ref (SET set_clause_choice (WHERE expr)? | ON into_values_source); 
 
 /// out of 2003 standart
 set_clause_choice: set_clause_list | multiple_column_assignment;
@@ -405,8 +405,8 @@ named_nodes_stmt: bind_parameter_list EQUALS (expr | LPAREN select_stmt RPAREN);
 
 commit_stmt: COMMIT;
 
-rollback_stmt: ROLLBACK;
-
+rollback_stmt: ROLLBACK; 
+ 
 // Special rules that allow to use certain keywords as identifiers.
 
 id_or_string: IDENTIFIER | STRING | keyword;
@@ -580,7 +580,7 @@ keyword_compat: (
   | RESPECT
   | RESTRICT
   | RESULT
-  | REVERT
+  | REVERT 
   | RIGHT
   | RLIKE
   | ROLLBACK
@@ -834,7 +834,7 @@ RESPECT: R E S P E C T;
 RESTRICT: R E S T R I C T;
 RESULT: R E S U L T;
 RETURN: R E T U R N;
-REVERT: R E V E R T;
+REVERT: R E V E R T; 
 RIGHT: R I G H T;
 RLIKE: R L I K E;
 ROLLBACK: R O L L B A C K;
diff --git a/ydb/library/yql/sql/v0/builtin.cpp b/ydb/library/yql/sql/v0/builtin.cpp
index a0945f9d05..76d5a37087 100644
--- a/ydb/library/yql/sql/v0/builtin.cpp
+++ b/ydb/library/yql/sql/v0/builtin.cpp
@@ -1080,7 +1080,7 @@ private:
         auto key = Args[0];
         auto inNode = Args[1];
         auto hints = Args[2];
-
+ 
         if (!key->Init(ctx, src)) {
             return false;
         }
@@ -1105,7 +1105,7 @@ private:
                                                                       << "perhaps you should remove "
                                                                       << parenKind << "parenthesis here";
             }
-        }
+        } 
 
         if (inNode->GetSource() || inNode->IsSelect()) {
             TVector<TNodePtr> hintElements;
@@ -1125,7 +1125,7 @@ private:
             key,
             hints
         };
-
+ 
         return TCallNode::DoInit(ctx, src);
     }
 
@@ -1161,7 +1161,7 @@ private:
     void DoUpdateState() const override {
         TCallNode::DoUpdateState();
         State.Set(ENodeState::Aggregated, false/*!RunConfig || RunConfig->IsAggregated()*/);
-        State.Set(ENodeState::Const, true /* FIXME: To avoid CheckAggregationLevel issue for non-const TypeOf. */);
+        State.Set(ENodeState::Const, true /* FIXME: To avoid CheckAggregationLevel issue for non-const TypeOf. */); 
     }
 
 private:
@@ -1382,7 +1382,7 @@ public:
         : INode(pos)
         , Module(module)
         , Name(name)
-        , Args(args)
+        , Args(args) 
     {}
 
     bool DoInit(TContext& ctx, ISource* src) override {
@@ -1442,7 +1442,7 @@ public:
     }
 
     TNodePtr DoClone() const override {
-        return new TCallableNode(Pos, Module, Name, Args);
+        return new TCallableNode(Pos, Module, Name, Args); 
     }
 
 private:
@@ -1453,7 +1453,7 @@ private:
 };
 
 TNodePtr BuildCallable(TPosition pos, const TString& module, const TString& name, const TVector<TNodePtr>& args) {
-    return new TCallableNode(pos, module, name, args);
+    return new TCallableNode(pos, module, name, args); 
 }
 
 TNodePtr BuildUdf(TContext& ctx, TPosition pos, const TString& module, const TString& name, const TVector<TNodePtr>& args) {
diff --git a/ydb/library/yql/sql/v0/context.cpp b/ydb/library/yql/sql/v0/context.cpp
index a3a9013f2b..1fa626a057 100644
--- a/ydb/library/yql/sql/v0/context.cpp
+++ b/ydb/library/yql/sql/v0/context.cpp
@@ -2,11 +2,11 @@
 
 #include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
 #include <ydb/library/yql/utils/yql_panic.h>
-
-#include <util/folder/pathsplit.h>
+ 
+#include <util/folder/pathsplit.h> 
 #include <util/string/join.h>
 #include <util/stream/null.h>
-
+ 
 #ifdef GetMessage
 #undef GetMessage
 #endif
@@ -15,45 +15,45 @@ using namespace NYql;
 
 namespace NSQLTranslationV0 {
 
-namespace {
-
+namespace { 
+ 
 TNodePtr AddTablePathPrefix(TContext &ctx, TStringBuf prefixPath, const TDeferredAtom& path) {
     Y_UNUSED(ctx);
-    if (prefixPath.empty()) {
+    if (prefixPath.empty()) { 
         return path.Build();
-    }
-
+    } 
+ 
     YQL_ENSURE(path.GetLiteral(), "TODO support prefix for deferred atoms");
     prefixPath.SkipPrefix("//");
 
-    TPathSplitUnix prefixPathSplit(prefixPath);
+    TPathSplitUnix prefixPathSplit(prefixPath); 
     TPathSplitUnix pathSplit(*path.GetLiteral());
-
-    if (pathSplit.IsAbsolute) {
+ 
+    if (pathSplit.IsAbsolute) { 
         return path.Build();
-    }
-
+    } 
+ 
     return BuildQuotedAtom(path.Build()->GetPos(), prefixPathSplit.AppendMany(pathSplit.begin(), pathSplit.end()).Reconstruct());
-}
-
+} 
+ 
 typedef bool TContext::*TPragmaField;
 
 THashMap<TStringBuf, TPragmaField> CTX_PRAGMA_FIELDS = {
     {"PullUpFlatMapOverJoin", &TContext::PragmaPullUpFlatMapOverJoin},
 };
 
-} // namespace
-
+} // namespace 
+ 
 TContext::TContext(const NSQLTranslation::TTranslationSettings& settings,
                    TIssues& issues)
     : ClusterMapping(settings.ClusterMapping)
-    , PathPrefix(settings.PathPrefix)
-    , ClusterPathPrefixes(settings.ClusterPathPrefixes)
-    , Settings(settings)
+    , PathPrefix(settings.PathPrefix) 
+    , ClusterPathPrefixes(settings.ClusterPathPrefixes) 
+    , Settings(settings) 
     , Pool(new TMemoryPool(4096))
     , Issues(issues)
-    , IncrementMonCounterFunction(settings.IncrementCounter)
-    , CurrCluster(settings.DefaultCluster)
+    , IncrementMonCounterFunction(settings.IncrementCounter) 
+    , CurrCluster(settings.DefaultCluster) 
     , HasPendingErrors(false)
     , Libraries(settings.Libraries)
 {
@@ -137,7 +137,7 @@ IOutputStream& TContext::MakeIssue(ESeverity severity, TIssueCode code, NYql::TP
         }
     }
 
-    Issues.AddIssue(TIssue(pos, TString()));
+    Issues.AddIssue(TIssue(pos, TString())); 
     auto& curIssue = Issues.back();
     curIssue.Severity = severity;
     curIssue.IssueCode = code;
@@ -146,50 +146,50 @@ IOutputStream& TContext::MakeIssue(ESeverity severity, TIssueCode code, NYql::TP
 }
 
 bool TContext::SetPathPrefix(const TString& value, TMaybe<TString> arg) {
-    if (arg.Defined()) {
+    if (arg.Defined()) { 
         if (*arg == YtProviderName
             || *arg == KikimrProviderName
             || *arg == RtmrProviderName
             )
-        {
-            ProviderPathPrefixes[*arg] = value;
-            return true;
-        }
-
+        { 
+            ProviderPathPrefixes[*arg] = value; 
+            return true; 
+        } 
+ 
         TString normalizedClusterName;
         if (!GetClusterProvider(*arg, normalizedClusterName)) {
             Error() << "Unknown cluster or provider: " << *arg;
-            IncrementMonCounter("sql_errors", "BadPragmaValue");
-            return false;
-        }
-
+            IncrementMonCounter("sql_errors", "BadPragmaValue"); 
+            return false; 
+        } 
+ 
         ClusterPathPrefixes[normalizedClusterName] = value;
-    } else {
-        PathPrefix = value;
-    }
-
-    return true;
-}
-
+    } else { 
+        PathPrefix = value; 
+    } 
+ 
+    return true; 
+} 
+ 
 TNodePtr TContext::GetPrefixedPath(const TString& cluster, const TDeferredAtom& path) {
     auto* clusterPrefix = ClusterPathPrefixes.FindPtr(cluster);
-    if (clusterPrefix && !clusterPrefix->empty()) {
-        return AddTablePathPrefix(*this, *clusterPrefix, path);
-    } else {
+    if (clusterPrefix && !clusterPrefix->empty()) { 
+        return AddTablePathPrefix(*this, *clusterPrefix, path); 
+    } else { 
         auto provider = GetClusterProvider(cluster);
         YQL_ENSURE(provider.Defined());
-
-        auto* providerPrefix = ProviderPathPrefixes.FindPtr(*provider);
-        if (providerPrefix && !providerPrefix->empty()) {
-            return AddTablePathPrefix(*this, *providerPrefix, path);
+ 
+        auto* providerPrefix = ProviderPathPrefixes.FindPtr(*provider); 
+        if (providerPrefix && !providerPrefix->empty()) { 
+            return AddTablePathPrefix(*this, *providerPrefix, path); 
         } else if (!PathPrefix.empty()) {
-            return AddTablePathPrefix(*this, PathPrefix, path);
-        }
-
+            return AddTablePathPrefix(*this, PathPrefix, path); 
+        } 
+ 
         return path.Build();
-    }
-}
-
+    } 
+} 
+ 
 TNodePtr TContext::UniversalAlias(const TString& baseName, TNodePtr&& node) {
     auto alias = MakeName(baseName);
     UniversalAliases.emplace(alias, node);
@@ -351,8 +351,8 @@ IOutputStream& TTranslation::Error() {
 }
 
 TNodePtr TTranslation::GetNamedNode(const TString& name) {
-    auto mapIt = Ctx.NamedNodes.find(name);
-    if (mapIt == Ctx.NamedNodes.end()) {
+    auto mapIt = Ctx.NamedNodes.find(name); 
+    if (mapIt == Ctx.NamedNodes.end()) { 
         Ctx.Error() << "Unknown name: " << name;
         return nullptr;
     }
@@ -362,23 +362,23 @@ TNodePtr TTranslation::GetNamedNode(const TString& name) {
 
 void TTranslation::PushNamedNode(const TString& name, TNodePtr node) {
     Y_VERIFY_DEBUG(node);
-    auto mapIt = Ctx.NamedNodes.find(name);
-    if (mapIt == Ctx.NamedNodes.end()) {
+    auto mapIt = Ctx.NamedNodes.find(name); 
+    if (mapIt == Ctx.NamedNodes.end()) { 
         auto result = Ctx.NamedNodes.insert(std::make_pair(name, TStack<TNodePtr>()));
         Y_VERIFY_DEBUG(result.second);
-        mapIt = result.first;
+        mapIt = result.first; 
     }
-
-    mapIt->second.push(node);
-}
-
+ 
+    mapIt->second.push(node); 
+} 
+ 
 void TTranslation::PopNamedNode(const TString& name) {
-    auto mapIt = Ctx.NamedNodes.find(name);
+    auto mapIt = Ctx.NamedNodes.find(name); 
     Y_VERIFY_DEBUG(mapIt != Ctx.NamedNodes.end());
     Y_VERIFY_DEBUG(mapIt->second.size() > 0);
-    mapIt->second.pop();
-    if (mapIt->second.empty()) {
-        Ctx.NamedNodes.erase(mapIt);
+    mapIt->second.pop(); 
+    if (mapIt->second.empty()) { 
+        Ctx.NamedNodes.erase(mapIt); 
     }
 }
 
diff --git a/ydb/library/yql/sql/v0/context.h b/ydb/library/yql/sql/v0/context.h
index 45f40fae61..c8f2a2e16c 100644
--- a/ydb/library/yql/sql/v0/context.h
+++ b/ydb/library/yql/sql/v0/context.h
@@ -1,8 +1,8 @@
 #pragma once
 
-#include "node.h"
-#include "sql.h"
-
+#include "node.h" 
+#include "sql.h" 
+ 
 #include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
 #include <ydb/library/yql/core/issue/protos/issue_id.pb.h>
 #include <ydb/library/yql/public/issue/yql_warning.h>
@@ -11,9 +11,9 @@
 
 #include <util/generic/hash.h>
 #include <util/generic/map.h>
-#include <util/generic/maybe.h>
+#include <util/generic/maybe.h> 
 #include <util/generic/set.h>
-#include <util/generic/stack.h>
+#include <util/generic/stack.h> 
 #include <util/generic/vector.h>
 
 namespace NSQLTranslationV0 {
@@ -78,16 +78,16 @@ namespace NSQLTranslationV0 {
             }
 
             return provider;
-        }
-
+        } 
+ 
         TString GetServiceName(const ISource& source) const;
         bool UseUnordered(const ISource& source) const;
         bool UseUnordered(const TTableRef& table) const;
 
         bool SetPathPrefix(const TString& value, TMaybe<TString> arg = TMaybe<TString>());
-
+ 
         TNodePtr GetPrefixedPath(const TString& cluster, const TDeferredAtom& path);
-
+ 
         TNodePtr UniversalAlias(const TString& baseName, TNodePtr&& node);
 
         TString HasBlockShortcut(const TNodePtr& baseNode);
@@ -120,8 +120,8 @@ namespace NSQLTranslationV0 {
         THolder<TStringOutput> IssueMsgHolder;
         NSQLTranslation::TClusterMapping ClusterMapping;
         TString PathPrefix;
-        THashMap<TString, TString> ProviderPathPrefixes;
-        THashMap<TString, TString> ClusterPathPrefixes;
+        THashMap<TString, TString> ProviderPathPrefixes; 
+        THashMap<TString, TString> ClusterPathPrefixes; 
         bool IntoHeading = true;
 
     public:
diff --git a/ydb/library/yql/sql/v0/insert.cpp b/ydb/library/yql/sql/v0/insert.cpp
index 1d8aec7134..0fd1545d83 100644
--- a/ydb/library/yql/sql/v0/insert.cpp
+++ b/ydb/library/yql/sql/v0/insert.cpp
@@ -2,16 +2,16 @@
 #include "context.h"
 
 #include <ydb/library/yql/utils/yql_panic.h>
-
+ 
 using namespace NYql;
 
 namespace NSQLTranslationV0 {
 
 static const TMap<ESQLWriteColumnMode, EWriteColumnMode> sqlIntoMode2WriteColumn = {
-    {ESQLWriteColumnMode::InsertInto, EWriteColumnMode::Insert},
-    {ESQLWriteColumnMode::InsertOrAbortInto, EWriteColumnMode::InsertOrAbort},
-    {ESQLWriteColumnMode::InsertOrIgnoreInto, EWriteColumnMode::InsertOrIgnore},
-    {ESQLWriteColumnMode::InsertOrRevertInto, EWriteColumnMode::InsertOrRevert},
+    {ESQLWriteColumnMode::InsertInto, EWriteColumnMode::Insert}, 
+    {ESQLWriteColumnMode::InsertOrAbortInto, EWriteColumnMode::InsertOrAbort}, 
+    {ESQLWriteColumnMode::InsertOrIgnoreInto, EWriteColumnMode::InsertOrIgnore}, 
+    {ESQLWriteColumnMode::InsertOrRevertInto, EWriteColumnMode::InsertOrRevert}, 
     {ESQLWriteColumnMode::UpsertInto, EWriteColumnMode::Upsert},
     {ESQLWriteColumnMode::ReplaceInto, EWriteColumnMode::Replace},
     {ESQLWriteColumnMode::InsertIntoWithTruncate, EWriteColumnMode::Renew},
@@ -85,18 +85,18 @@ public:
 
     TNodePtr Build(TContext& ctx) override {
         Y_UNUSED(ctx);
-        YQL_ENSURE(Values.size() == ColumnsHint.size());
-
+        YQL_ENSURE(Values.size() == ColumnsHint.size()); 
+ 
         auto structObj = Y("AsStruct");
-        for (size_t i = 0; i < Values.size(); ++i) {
+        for (size_t i = 0; i < Values.size(); ++i) { 
             TString column = ColumnsHint[i];
-            TNodePtr value = Values[i];
-
+            TNodePtr value = Values[i]; 
+ 
             structObj = L(structObj, Q(Y(Q(column), value)));
         }
-
+ 
         auto updateRow = BuildLambda(Pos, Y("row"), structObj);
-        return updateRow;
+        return updateRow; 
     }
 
     TNodePtr DoClone() const final {
@@ -123,11 +123,11 @@ public:
         Y_UNUSED(src);
         bool hasError = false;
         for (const auto& row: Values) {
-            if (ColumnsHint.empty()) {
-                ctx.Error(Pos) << OperationHumanName << " ... VALUES requires specification of table columns";
+            if (ColumnsHint.empty()) { 
+                ctx.Error(Pos) << OperationHumanName << " ... VALUES requires specification of table columns"; 
                 hasError = true;
                 continue;
-            }
+            } 
             if (ColumnsHint.size() != row.size()) {
                 ctx.Error(Pos) << "VALUES have " << row.size() << " columns, " << OperationHumanName << " expects: " << ColumnsHint.size();
                 hasError = true;
@@ -145,7 +145,7 @@ public:
 
     TNodePtr Build(TContext& ctx) override {
         Y_UNUSED(ctx);
-        auto tuple = Y();
+        auto tuple = Y(); 
         for (const auto& row: Values) {
             auto rowValues = Y("AsStruct");
             auto column = ColumnsHint.begin();
@@ -153,7 +153,7 @@ public:
                 rowValues = L(rowValues, Q(Y(BuildQuotedAtom(Pos, *column), value)));
                 ++column;
             }
-            tuple = L(tuple, rowValues);
+            tuple = L(tuple, rowValues); 
         }
         return Y("EnsurePersistable", Q(tuple));
     }
@@ -284,13 +284,13 @@ public:
 
     void ResetUpdate(TSourcePtr update) {
         Update = std::move(update);
-    }
-
+    } 
+ 
     bool DoInit(TContext& ctx, ISource* src) override {
         if (!Table.Check(ctx)) {
             return false;
         }
-
+ 
         TTableList tableList;
         TNodePtr values;
         auto options = Y();
@@ -302,22 +302,22 @@ public:
         }
 
         ISource* underlyingSrc = src;
-
+ 
         if (TableSource) {
             ctx.PushBlockShortcuts();
             if (!TableSource->Init(ctx, src) || !TableSource->InitFilters(ctx)) {
-                return false;
-            }
+                return false; 
+            } 
             options = L(options, Q(Y(Q("filter"), TableSource->BuildFilterLambda(ctx.GroundBlockShortcuts(Pos)))));
-        }
-
+        } 
+ 
         bool unordered = false;
         ctx.PushBlockShortcuts();
         if (Values) {
             if (!Values->Init(ctx, TableSource.Get())) {
                 return false;
             }
-
+ 
             Values->GetInputTables(tableList);
             underlyingSrc = Values.Get();
             values = Values->Build(ctx);
@@ -331,13 +331,13 @@ public:
         if (!node->Init(ctx, underlyingSrc)) {
             return false;
         }
-
-        if (Update) {
+ 
+        if (Update) { 
             if (!Update->Init(ctx, TableSource.Get()) || !Update->InitFilters(ctx)) {
                 return false;
             }
             options = L(options, Q(Y(Q("update"), Update->Build(ctx))));
-        }
+        } 
 
         auto write = BuildWriteTable(Pos, "values", Table, Mode, std::move(options));
         if (!write->Init(ctx, FakeSource.Get())) {
@@ -349,8 +349,8 @@ public:
             if (unordered && ctx.UseUnordered(Table)) {
                 node = L(node, Y("let", "values", Y("Unordered", "values")));
             }
-        } else {
-            node = L(node, Y("let", "values", Y("Void")));
+        } else { 
+            node = L(node, Y("let", "values", Y("Void"))); 
         }
         node = L(node, Y("let", "world", write));
         node = L(node, Y("return", "world"));
@@ -368,7 +368,7 @@ protected:
     TSourcePtr TableSource;
     EWriteColumnMode Mode;
     TSourcePtr Values;
-    TSourcePtr Update;
+    TSourcePtr Update; 
     TSourcePtr FakeSource;
     TNodePtr Options;
 };
@@ -384,7 +384,7 @@ TNodePtr BuildWriteColumns(TPosition pos, const TTableRef& table, EWriteColumnMo
 
 TNodePtr BuildUpdateColumns(TPosition pos, const TTableRef& table, TSourcePtr values, TSourcePtr source) {
     YQL_ENSURE(values, "Invalid values node");
-    TIntrusivePtr<TWriteColumnsNode> writeNode = new TWriteColumnsNode(pos, table, EWriteColumnMode::Update);
+    TIntrusivePtr<TWriteColumnsNode> writeNode = new TWriteColumnsNode(pos, table, EWriteColumnMode::Update); 
     writeNode->ResetSource(std::move(source));
     writeNode->ResetUpdate(std::move(values));
     return writeNode;
diff --git a/ydb/library/yql/sql/v0/join.cpp b/ydb/library/yql/sql/v0/join.cpp
index 78f5affb49..a89484ede6 100644
--- a/ydb/library/yql/sql/v0/join.cpp
+++ b/ydb/library/yql/sql/v0/join.cpp
@@ -2,7 +2,7 @@
 #include "context.h"
 
 #include <ydb/library/yql/utils/yql_panic.h>
-
+ 
 #include <library/cpp/charset/ci_string.h>
 #include <util/generic/hash_set.h>
 #include <util/string/cast.h>
diff --git a/ydb/library/yql/sql/v0/node.cpp b/ydb/library/yql/sql/v0/node.cpp
index 57f0c6a561..aab7909e1c 100644
--- a/ydb/library/yql/sql/v0/node.cpp
+++ b/ydb/library/yql/sql/v0/node.cpp
@@ -50,7 +50,7 @@ TString TTableRef::ShortName() const {
 }
 
 TString TTableRef::ServiceName(const TContext& ctx) const {
-    auto service = ctx.GetClusterProvider(Cluster);
+    auto service = ctx.GetClusterProvider(Cluster); 
     YQL_ENSURE(service);
     return *service;
 }
@@ -61,7 +61,7 @@ bool TTableRef::Check(TContext& ctx) const {
         return false;
     }
 
-    auto service = ctx.GetClusterProvider(Cluster);
+    auto service = ctx.GetClusterProvider(Cluster); 
     if (!service) {
         ctx.Error() << "Unknown cluster name: " << Cluster;
         return false;
@@ -2122,38 +2122,38 @@ TNodePtr BuildListOfNamedNodes(TPosition pos, TVector<TNodePtr>&& exprs) {
     return new TListOfNamedNodes(pos, std::move(exprs));
 }
 
-const char* const TArgPlaceholderNode::ProcessRows = "$ROWS";
-const char* const TArgPlaceholderNode::ProcessRow = "$ROW";
-
+const char* const TArgPlaceholderNode::ProcessRows = "$ROWS"; 
+const char* const TArgPlaceholderNode::ProcessRow = "$ROW"; 
+ 
 TArgPlaceholderNode::TArgPlaceholderNode(TPosition pos, const TString &name) :
-    INode(pos),
-    Name(name)
-{
-}
-
-bool TArgPlaceholderNode::DoInit(TContext& ctx, ISource* src) {
+    INode(pos), 
+    Name(name) 
+{ 
+} 
+ 
+bool TArgPlaceholderNode::DoInit(TContext& ctx, ISource* src) { 
     Y_UNUSED(src);
-    ctx.Error(Pos) << Name << " can't be used as a part of expression.";
-    return false;
-}
-
-TAstNode* TArgPlaceholderNode::Translate(TContext& ctx) const {
+    ctx.Error(Pos) << Name << " can't be used as a part of expression."; 
+    return false; 
+} 
+ 
+TAstNode* TArgPlaceholderNode::Translate(TContext& ctx) const { 
     Y_UNUSED(ctx);
-    return nullptr;
-}
-
+    return nullptr; 
+} 
+ 
 TString TArgPlaceholderNode::GetName() const {
-    return Name;
-}
-
+    return Name; 
+} 
+ 
 TNodePtr TArgPlaceholderNode::DoClone() const {
     return {};
 }
 
 TNodePtr BuildArgPlaceholder(TPosition pos, const TString& name) {
-    return new TArgPlaceholderNode(pos, name);
-}
-
+    return new TArgPlaceholderNode(pos, name); 
+} 
+ 
 class TAccessNode: public INode {
 public:
     TAccessNode(TPosition pos, const TVector<TIdPart>& ids, bool isLookup)
diff --git a/ydb/library/yql/sql/v0/node.h b/ydb/library/yql/sql/v0/node.h
index 4c7cfc273b..c179e803ba 100644
--- a/ydb/library/yql/sql/v0/node.h
+++ b/ydb/library/yql/sql/v0/node.h
@@ -37,9 +37,9 @@ namespace NSQLTranslationV0 {
 
     enum class ESQLWriteColumnMode {
         InsertInto,
-        InsertOrAbortInto,
-        InsertOrIgnoreInto,
-        InsertOrRevertInto,
+        InsertOrAbortInto, 
+        InsertOrIgnoreInto, 
+        InsertOrRevertInto, 
         UpsertInto,
         ReplaceInto,
         InsertIntoWithTruncate,
@@ -49,17 +49,17 @@ namespace NSQLTranslationV0 {
 
     enum class EWriteColumnMode {
         Default,
-        Insert,
-        InsertOrAbort,
-        InsertOrIgnore,
-        InsertOrRevert,
+        Insert, 
+        InsertOrAbort, 
+        InsertOrIgnore, 
+        InsertOrRevert, 
         Upsert,
         Replace,
         Renew,
         Update,
-        UpdateOn,
+        UpdateOn, 
         Delete,
-        DeleteOn,
+        DeleteOn, 
     };
 
     enum class EAlterTableIntentnt {
@@ -434,16 +434,16 @@ namespace NSQLTranslationV0 {
         bool Check(TContext& ctx) const;
     };
 
-    struct TIdentifier
-    {
-        TPosition Pos;
+    struct TIdentifier 
+    { 
+        TPosition Pos; 
         TString Name;
-
+ 
         TIdentifier(TPosition pos, const TString& name)
-            : Pos(pos)
-            , Name(name) {}
-    };
-
+            : Pos(pos) 
+            , Name(name) {} 
+    }; 
+ 
     struct TColumnSchema {
         TPosition Pos;
         TString Name;
@@ -587,25 +587,25 @@ namespace NSQLTranslationV0 {
     };
 
     class TArgPlaceholderNode final: public INode
-    {
-    public:
-        static const char* const ProcessRows;
-        static const char* const ProcessRow;
-    public:
+    { 
+    public: 
+        static const char* const ProcessRows; 
+        static const char* const ProcessRow; 
+    public: 
         TArgPlaceholderNode(TPosition pos, const TString &name);
-
+ 
         TAstNode* Translate(TContext& ctx) const override;
-
+ 
         TString GetName() const;
         TNodePtr DoClone() const final;
-
-    protected:
+ 
+    protected: 
         bool DoInit(TContext& ctx, ISource* src) override;
-
-    private:
+ 
+    private: 
         TString Name;
-    };
-
+    }; 
+ 
     enum class EAggregateMode {
         Normal,
         Distinct,
@@ -884,7 +884,7 @@ namespace NSQLTranslationV0 {
     TNodePtr BuildListOfNamedNodes(TPosition pos, TVector<TNodePtr>&& exprs);
 
     TNodePtr BuildArgPlaceholder(TPosition pos, const TString& name);
-
+ 
     TNodePtr BuildColumn(TPosition pos, const TString& column = TString(), const TString& source = TString());
     TNodePtr BuildColumn(TPosition pos, const TNodePtr& column, const TString& source = TString());
     TNodePtr BuildColumn(TPosition pos, const TDeferredAtom& column, const TString& source = TString());
@@ -948,7 +948,7 @@ namespace NSQLTranslationV0 {
     TNodePtr BuildSourceNode(TPosition pos, TSourcePtr source, bool checkExist = false);
     TSourcePtr BuildMuxSource(TPosition pos, TVector<TSourcePtr>&& sources);
     TSourcePtr BuildFakeSource(TPosition pos);
-    TSourcePtr BuildNodeSource(TPosition pos, const TNodePtr& node);
+    TSourcePtr BuildNodeSource(TPosition pos, const TNodePtr& node); 
     TSourcePtr BuildTableSource(TPosition pos, const TTableRef& table, bool stream, const TString& label = TString());
     TSourcePtr BuildInnerSource(TPosition pos, TNodePtr node, const TString& label = TString());
     TSourcePtr BuildRefColumnSource(TPosition pos, const TString& partExpression);
@@ -970,7 +970,7 @@ namespace NSQLTranslationV0 {
         TWinSpecs&& windowSpec,
         THoppingWindowSpecPtr hoppingWindowSpec,
         TVector<TNodePtr>&& terms,
-        bool distinct,
+        bool distinct, 
         TVector<TNodePtr>&& without,
         bool stream,
         const TWriteSettings& settings
diff --git a/ydb/library/yql/sql/v0/query.cpp b/ydb/library/yql/sql/v0/query.cpp
index 7752b28b01..e502b58e14 100644
--- a/ydb/library/yql/sql/v0/query.cpp
+++ b/ydb/library/yql/sql/v0/query.cpp
@@ -18,7 +18,7 @@ class TUniqueTableKey: public ITableKeys {
 public:
     TUniqueTableKey(TPosition pos, const TString& cluster, const TDeferredAtom& name, const TString& view)
         : ITableKeys(pos)
-        , Cluster(cluster)
+        , Cluster(cluster) 
         , Name(name)
         , View(view)
         , Full(name.GetRepr())
@@ -43,10 +43,10 @@ public:
             ctx.Error(Pos) << "Table view can not be created with CREATE TABLE clause";
             return nullptr;
         }
-        auto path = ctx.GetPrefixedPath(Cluster, Name);
-        if (!path) {
-            return nullptr;
-        }
+        auto path = ctx.GetPrefixedPath(Cluster, Name); 
+        if (!path) { 
+            return nullptr; 
+        } 
         auto key = Y("Key", Q(Y(Q(tableScheme ? "tablescheme" : "table"), Y("String", path))));
         if (!View.empty()) {
             key = L(key, Q(Y(Q("view"), Y("String", BuildQuotedAtom(Pos, View)))));
@@ -69,14 +69,14 @@ private:
 };
 
 TNodePtr BuildTableKey(TPosition pos, const TString& cluster, const TDeferredAtom& name, const TString& view) {
-    return new TUniqueTableKey(pos, cluster, name, view);
+    return new TUniqueTableKey(pos, cluster, name, view); 
 }
 
 class TPrepTableKeys: public ITableKeys {
 public:
     TPrepTableKeys(TPosition pos, const TString& cluster, const TString& func, const TVector<TTableArg>& args)
         : ITableKeys(pos)
-        , Cluster(cluster)
+        , Cluster(cluster) 
         , Func(func)
         , Args(args)
     {
@@ -111,7 +111,7 @@ public:
                     if (!arg.View.empty()) {
                         key = L(key, Q(Y(Q("view"), Y("String", BuildQuotedAtom(Pos, arg.View)))));
                     }
-                }
+                } 
 
                 tuple = L(tuple, key);
             }
@@ -134,7 +134,7 @@ public:
                     if (!arg.View.empty()) {
                         key = L(key, Q(Y(Q("view"), Y("String", BuildQuotedAtom(Pos, arg.View)))));
                     }
-                }
+                } 
 
                 concat = L(concat, key);
             }
@@ -182,9 +182,9 @@ public:
             }
 
             auto path = ctx.GetPrefixedPath(Cluster, Args[0].Id);
-            if (!path) {
-                return nullptr;
-            }
+            if (!path) { 
+                return nullptr; 
+            } 
             auto range = Y(func.EndsWith("_strict") ? "MrTableRangeStrict" : "MrTableRange", path);
             TNodePtr predicate;
             TDeferredAtom suffix;
@@ -312,7 +312,7 @@ private:
 };
 
 TNodePtr BuildTableKeys(TPosition pos, const TString& cluster, const TString& func, const TVector<TTableArg>& args) {
-    return new TPrepTableKeys(pos, cluster, func, args);
+    return new TPrepTableKeys(pos, cluster, func, args); 
 }
 
 class TInputOptions final: public TAstListNode {
@@ -426,7 +426,7 @@ public:
         : TAstListNode(pos)
         , Table(tr)
         , Columns(columns)
-        , PkColumns(pkColumns)
+        , PkColumns(pkColumns) 
         , PartitionByColumns(partitionByColumns)
         , OrderByColumns(orderByColumns)
     {}
@@ -441,19 +441,19 @@ public:
             return false;
         }
         keys = ctx.GroundBlockShortcutsForExpr(keys);
-
+ 
         if (!PkColumns.empty() || !PartitionByColumns.empty() || !OrderByColumns.empty()) {
             THashSet<TString> columnsSet;
-            for (auto& col : Columns) {
-                columnsSet.insert(col.Name);
-            }
-
-            for (auto& keyColumn : PkColumns) {
+            for (auto& col : Columns) { 
+                columnsSet.insert(col.Name); 
+            } 
+ 
+            for (auto& keyColumn : PkColumns) { 
                 if (!columnsSet.contains(keyColumn.Name)) {
-                    ctx.Error(keyColumn.Pos) << "Undefined column: " << keyColumn.Name;
-                    return false;
-                }
-            }
+                    ctx.Error(keyColumn.Pos) << "Undefined column: " << keyColumn.Name; 
+                    return false; 
+                } 
+            } 
             for (auto& keyColumn : PartitionByColumns) {
                 if (!columnsSet.contains(keyColumn.Name)) {
                     ctx.Error(keyColumn.Pos) << "Undefined column: " << keyColumn.Name;
@@ -466,8 +466,8 @@ public:
                     return false;
                 }
             }
-        }
-
+        } 
+ 
         auto columns = Y();
         for (auto& col: Columns) {
             auto type = ParseType(TypeByAlias(col.Type, !col.IsTypeString), *ctx.Pool, ctx.Issues, col.Pos);
@@ -520,12 +520,12 @@ public:
             }
         }
 
-        if (!PkColumns.empty()) {
+        if (!PkColumns.empty()) { 
             auto primaryKey = Y();
             for (auto& col : PkColumns) {
                 primaryKey = L(primaryKey, BuildQuotedAtom(col.Pos, col.Name));
             }
-            opts = L(opts, Q(Y(Q("primarykey"), Q(primaryKey))));
+            opts = L(opts, Q(Y(Q("primarykey"), Q(primaryKey)))); 
             if (!OrderByColumns.empty()) {
                 ctx.Error() << "PRIMARY KEY cannot be used with ORDER BY, use PARTITION BY instead";
                 return false;
@@ -546,7 +546,7 @@ public:
                 opts = L(opts, Q(Y(Q("orderby"), Q(orderBy))));
             }
         }
-
+ 
         Add("block", Q(Y(
             Y("let", "sink", Y("DataSink", BuildQuotedAtom(Pos, Table.ServiceName(ctx)), BuildQuotedAtom(Pos, Table.Cluster))),
             Y("let", "world", Y(TString(WriteName), "world", "sink", keys, Y("Void"), Q(opts))),
@@ -571,7 +571,7 @@ private:
 TNodePtr BuildCreateTable(TPosition pos, const TTableRef& tr, const TVector<TColumnSchema>& columns,
     const TVector<TIdentifier>& pkColumns, const TVector<TIdentifier>& partitionByColumns,
     const TVector<std::pair<TIdentifier, bool>>& orderByColumns)
-{
+{ 
     return new TCreateTableNode(pos, tr, columns, pkColumns, partitionByColumns, orderByColumns);
 }
 
@@ -708,8 +708,8 @@ TNodePtr BuildDropTable(TPosition pos, const TTableRef& tr) {
 
 static const TMap<EWriteColumnMode, TString> columnModeToStrMapMR {
     {EWriteColumnMode::Default, ""},
-    {EWriteColumnMode::Insert, "append"},
-    {EWriteColumnMode::Renew, "renew"}
+    {EWriteColumnMode::Insert, "append"}, 
+    {EWriteColumnMode::Renew, "renew"} 
 };
 
 static const TMap<EWriteColumnMode, TString> columnModeToStrMapStat {
@@ -717,19 +717,19 @@ static const TMap<EWriteColumnMode, TString> columnModeToStrMapStat {
 };
 
 static const TMap<EWriteColumnMode, TString> columnModeToStrMapKikimr {
-    {EWriteColumnMode::Default, ""},
-    {EWriteColumnMode::Insert, "insert_abort"},
-    {EWriteColumnMode::InsertOrAbort, "insert_abort"},
-    {EWriteColumnMode::InsertOrIgnore, "insert_ignore"},
-    {EWriteColumnMode::InsertOrRevert, "insert_revert"},
-    {EWriteColumnMode::Upsert, "upsert"},
-    {EWriteColumnMode::Replace, "replace"},
-    {EWriteColumnMode::Update, "update"},
-    {EWriteColumnMode::UpdateOn, "update_on"},
-    {EWriteColumnMode::Delete, "delete"},
-    {EWriteColumnMode::DeleteOn, "delete_on"},
-};
-
+    {EWriteColumnMode::Default, ""}, 
+    {EWriteColumnMode::Insert, "insert_abort"}, 
+    {EWriteColumnMode::InsertOrAbort, "insert_abort"}, 
+    {EWriteColumnMode::InsertOrIgnore, "insert_ignore"}, 
+    {EWriteColumnMode::InsertOrRevert, "insert_revert"}, 
+    {EWriteColumnMode::Upsert, "upsert"}, 
+    {EWriteColumnMode::Replace, "replace"}, 
+    {EWriteColumnMode::Update, "update"}, 
+    {EWriteColumnMode::UpdateOn, "update_on"}, 
+    {EWriteColumnMode::Delete, "delete"}, 
+    {EWriteColumnMode::DeleteOn, "delete_on"}, 
+}; 
+ 
 class TWriteTableNode final: public TAstListNode {
 public:
     TWriteTableNode(TPosition pos, const TString& label, const TTableRef& table, EWriteColumnMode mode,
@@ -738,7 +738,7 @@ public:
         , Label(label)
         , Table(table)
         , Mode(mode)
-        , Options(options)
+        , Options(options) 
     {}
 
     bool DoInit(TContext& ctx, ISource* src) override {
@@ -751,19 +751,19 @@ public:
             return false;
         }
         keys = ctx.GroundBlockShortcutsForExpr(keys);
-
+ 
         const auto serviceName = to_lower(Table.ServiceName(ctx));
         auto getModesMap = [] (const TString& serviceName) -> const TMap<EWriteColumnMode, TString>& {
-            if (serviceName == KikimrProviderName) {
-                return columnModeToStrMapKikimr;
+            if (serviceName == KikimrProviderName) { 
+                return columnModeToStrMapKikimr; 
             } else if (serviceName == StatProviderName) {
                 return columnModeToStrMapStat;
-            } else {
-                return columnModeToStrMapMR;
-            }
-        };
-
-        auto options = Y();
+            } else { 
+                return columnModeToStrMapMR; 
+            } 
+        }; 
+ 
+        auto options = Y(); 
         if (Options) {
             if (!Options->Init(ctx, src)) {
                 return false;
@@ -772,12 +772,12 @@ public:
             options = L(Options);
         }
 
-        if (Mode != EWriteColumnMode::Default) {
-            auto modeStr = getModesMap(serviceName).FindPtr(Mode);
-
-            options->Add(Q(Y(Q("mode"), Q(modeStr ? *modeStr : "unsupported"))));
-        }
-
+        if (Mode != EWriteColumnMode::Default) { 
+            auto modeStr = getModesMap(serviceName).FindPtr(Mode); 
+ 
+            options->Add(Q(Y(Q("mode"), Q(modeStr ? *modeStr : "unsupported")))); 
+        } 
+ 
         Add("block", Q((Y(
             Y("let", "sink", Y("DataSink", BuildQuotedAtom(Pos, Table.ServiceName(ctx)), BuildQuotedAtom(Pos, Table.Cluster))),
             Y("let", "world", Y(TString(WriteName), "world", "sink", keys, Label, Q(options))),
@@ -799,28 +799,28 @@ private:
 };
 
 TNodePtr BuildWriteTable(TPosition pos, const TString& label, const TTableRef& table, EWriteColumnMode mode, TNodePtr options)
-{
+{ 
     return new TWriteTableNode(pos, label, table, mode, std::move(options));
 }
 
-class TClustersSinkOperationBase: public TAstListNode {
-protected:
+class TClustersSinkOperationBase: public TAstListNode { 
+protected: 
     TClustersSinkOperationBase(TPosition pos, const TSet<TString>& clusters)
         : TAstListNode(pos)
-        , Clusters(clusters) {}
+        , Clusters(clusters) {} 
 
     virtual TPtr ProduceOperation(TContext& ctx, const TString& sinkName, const TString& service) = 0;
 
-    bool DoInit(TContext& ctx, ISource* src) override {
+    bool DoInit(TContext& ctx, ISource* src) override { 
         auto block(Y());
         auto clusters = &Clusters;
         if (Clusters.empty()) {
             clusters = &ctx.UsedClusters;
         }
-        if (clusters->empty() && !ctx.CurrCluster.empty()) {
-            clusters->insert(ctx.CurrCluster);
-        }
-
+        if (clusters->empty() && !ctx.CurrCluster.empty()) { 
+            clusters->insert(ctx.CurrCluster); 
+        } 
+ 
         for (auto& cluster: *clusters) {
             TString normalizedClusterName;
             auto service = ctx.GetClusterProvider(cluster, normalizedClusterName);
@@ -828,24 +828,24 @@ protected:
                 ctx.Error(ctx.Pos()) << "Unknown cluster: " << cluster;
                 return false;
             }
-
+ 
             auto sinkName = normalizedClusterName + "_sink";
-
-            auto op = ProduceOperation(ctx, sinkName, *service);
-            if (!op) {
-                return false;
-            }
-
+ 
+            auto op = ProduceOperation(ctx, sinkName, *service); 
+            if (!op) { 
+                return false; 
+            } 
+ 
             block = L(block, Y("let", sinkName, Y("DataSink", BuildQuotedAtom(Pos, *service), BuildQuotedAtom(Pos, normalizedClusterName))));
-            block = L(block, op);
+            block = L(block, op); 
         }
-
+ 
         clusters->clear();
         block = L(block, Y("return", "world"));
         Add("block", Q(block));
-
+ 
         return TAstListNode::DoInit(ctx, src);
-     }
+     } 
 
     TPtr DoClone() const final {
         return {};
@@ -854,41 +854,41 @@ private:
     TSet<TString> Clusters;
 };
 
-class TCommitClustersNode: public TClustersSinkOperationBase {
-public:
+class TCommitClustersNode: public TClustersSinkOperationBase { 
+public: 
     TCommitClustersNode(TPosition pos, const TSet<TString>& clusters)
-        : TClustersSinkOperationBase(pos, clusters) {}
-
+        : TClustersSinkOperationBase(pos, clusters) {} 
+ 
     TPtr ProduceOperation(TContext& ctx, const TString& sinkName, const TString& service) override {
         Y_UNUSED(ctx);
         Y_UNUSED(service);
         return Y("let", "world", Y(TString(CommitName), "world", sinkName));
-    }
-};
-
+    } 
+}; 
+ 
 TNodePtr BuildCommitClusters(TPosition pos, const TSet<TString>& clusters) {
     return new TCommitClustersNode(pos, clusters);
 }
 
-class TRollbackClustersNode: public TClustersSinkOperationBase {
-public:
+class TRollbackClustersNode: public TClustersSinkOperationBase { 
+public: 
     TRollbackClustersNode(TPosition pos, const TSet<TString>& clusters)
-        : TClustersSinkOperationBase(pos, clusters) {}
-
+        : TClustersSinkOperationBase(pos, clusters) {} 
+ 
     TPtr ProduceOperation(TContext& ctx, const TString& sinkName, const TString& service) override {
-        if (service != KikimrProviderName) {
+        if (service != KikimrProviderName) { 
             ctx.Error(ctx.Pos()) << "ROLLBACK isn't supported for provider: " << TStringBuf(service);
-            return nullptr;
-        }
-
+            return nullptr; 
+        } 
+ 
         return Y("let", "world", Y(TString(CommitName), "world", sinkName, Q(Y(Q(Y(Q("mode"), Q("rollback")))))));
-    }
-};
-
+    } 
+}; 
+ 
 TNodePtr BuildRollbackClusters(TPosition pos, const TSet<TString>& clusters) {
-    return new TRollbackClustersNode(pos, clusters);
-}
-
+    return new TRollbackClustersNode(pos, clusters); 
+} 
+ 
 class TWriteResultNode final: public TAstListNode {
 public:
     TWriteResultNode(TPosition pos, const TString& label, TNodePtr settings, const TSet<TString>& clusters)
diff --git a/ydb/library/yql/sql/v0/select.cpp b/ydb/library/yql/sql/v0/select.cpp
index ef47023be1..06a1094e2f 100644
--- a/ydb/library/yql/sql/v0/select.cpp
+++ b/ydb/library/yql/sql/v0/select.cpp
@@ -4,7 +4,7 @@
 #include "context.h"
 
 #include <ydb/library/yql/utils/yql_panic.h>
-
+ 
 #include <library/cpp/charset/ci_string.h>
 
 using namespace NYql;
@@ -212,71 +212,71 @@ TSourcePtr BuildFakeSource(TPosition pos) {
     return new TFakeSource(pos);
 }
 
-class TNodeSource: public ISource {
-public:
-    TNodeSource(TPosition pos, const TNodePtr& node)
-        : ISource(pos)
-        , Node(node)
-    {
-        YQL_ENSURE(Node);
+class TNodeSource: public ISource { 
+public: 
+    TNodeSource(TPosition pos, const TNodePtr& node) 
+        : ISource(pos) 
+        , Node(node) 
+    { 
+        YQL_ENSURE(Node); 
         FakeSource = BuildFakeSource(pos);
-    }
-
-    void AllColumns() final {
-        UseAllColumns = true;
-    }
-
-    TMaybe<bool> AddColumn(TContext& ctx, TColumnNode& column) final {
+    } 
+ 
+    void AllColumns() final { 
+        UseAllColumns = true; 
+    } 
+ 
+    TMaybe<bool> AddColumn(TContext& ctx, TColumnNode& column) final { 
         Y_UNUSED(ctx);
-        if (UseAllColumns) {
-            return true;
-        }
-
-        if (column.IsAsterisk()) {
-            AllColumns();
-        } else {
-            Columns.push_back(*column.GetColumnName());
-        }
-
-        return true;
-    }
-
-    TNodePtr Build(TContext& ctx) final  {
+        if (UseAllColumns) { 
+            return true; 
+        } 
+ 
+        if (column.IsAsterisk()) { 
+            AllColumns(); 
+        } else { 
+            Columns.push_back(*column.GetColumnName()); 
+        } 
+ 
+        return true; 
+    } 
+ 
+    TNodePtr Build(TContext& ctx) final  { 
         ctx.PushBlockShortcuts();
         if (!Node->Init(ctx, FakeSource.Get())) {
             return {};
-        }
-
+        } 
+ 
         Node = ctx.GroundBlockShortcutsForExpr(Node);
-        auto nodeAst = AstNode(Node);
-
-        if (UseAllColumns) {
-            return nodeAst;
-        } else {
-            auto members = Y();
-            for (auto& column : Columns) {
-                members = L(members, BuildQuotedAtom(Pos, column));
-            }
-
+        auto nodeAst = AstNode(Node); 
+ 
+        if (UseAllColumns) { 
+            return nodeAst; 
+        } else { 
+            auto members = Y(); 
+            for (auto& column : Columns) { 
+                members = L(members, BuildQuotedAtom(Pos, column)); 
+            } 
+ 
             return Y(ctx.UseUnordered(*this) ? "OrderedMap" : "Map", nodeAst, BuildLambda(Pos, Y("row"), Y("SelectMembers", "row", Q(members))));
-        }
-    }
-
-    TPtr DoClone() const final {
-        return new TNodeSource(Pos, Node);
-    }
-
-private:
-    TNodePtr Node;
+        } 
+    } 
+ 
+    TPtr DoClone() const final { 
+        return new TNodeSource(Pos, Node); 
+    } 
+ 
+private: 
+    TNodePtr Node; 
     TSourcePtr FakeSource;
-    TVector<TString> Columns;
-    bool UseAllColumns = false;
-};
-
-TSourcePtr BuildNodeSource(TPosition pos, const TNodePtr& node) {
-    return new TNodeSource(pos, node);
-}
-
+    TVector<TString> Columns; 
+    bool UseAllColumns = false; 
+}; 
+ 
+TSourcePtr BuildNodeSource(TPosition pos, const TNodePtr& node) { 
+    return new TNodeSource(pos, node); 
+} 
+ 
 class IProxySource: public ISource {
 protected:
     IProxySource(TPosition pos, ISource* src)
@@ -1051,7 +1051,7 @@ public:
         TWinSpecs& winSpecs,
         THoppingWindowSpecPtr hoppingWindowSpec,
         const TVector<TNodePtr>& terms,
-        bool distinct,
+        bool distinct, 
         const TVector<TNodePtr>& without,
         bool stream,
         const TWriteSettings& settings
@@ -1962,7 +1962,7 @@ TSourcePtr BuildSelectCore(
     TWinSpecs&& winSpecs,
     THoppingWindowSpecPtr hoppingWindowSpec,
     TVector<TNodePtr>&& terms,
-    bool distinct,
+    bool distinct, 
     TVector<TNodePtr>&& without,
     bool stream,
     const TWriteSettings& settings
diff --git a/ydb/library/yql/sql/v0/sql.cpp b/ydb/library/yql/sql/v0/sql.cpp
index b028fc0439..5b8a1b4464 100644
--- a/ydb/library/yql/sql/v0/sql.cpp
+++ b/ydb/library/yql/sql/v0/sql.cpp
@@ -1,6 +1,6 @@
 #include "sql.h"
-
-#include "context.h"
+ 
+#include "context.h" 
 #include "node.h"
 
 #include <ydb/library/yql/ast/yql_expr.h>
@@ -14,7 +14,7 @@
 #include <ydb/library/yql/sql/settings/translation_settings.h>
 
 #include <library/cpp/charset/ci_string.h>
-
+ 
 #include <google/protobuf/repeated_field.h>
 
 #include <util/generic/array_ref.h>
@@ -42,10 +42,10 @@ using NALP::SQLLexerTokens;
 
 using namespace NSQLGenerated;
 
-static TPosition GetPos(const TToken& token) {
-    return TPosition(token.GetColumn(), token.GetLine());
-}
-
+static TPosition GetPos(const TToken& token) { 
+    return TPosition(token.GetColumn(), token.GetLine()); 
+} 
+ 
 template <typename TToken>
 TIdentifier GetIdentifier(TTranslation& ctx, const TToken& node) {
     auto token = node.GetToken1();
@@ -299,7 +299,7 @@ static TColumnSchema ColumnSchemaImpl(const TRule_column_schema& node, TTranslat
     return TColumnSchema(pos, name, type.first, nullable, type.second);
 }
 
-static bool CreateTableEntry(const TRule_create_table_entry& node, TTranslation& ctx,
+static bool CreateTableEntry(const TRule_create_table_entry& node, TTranslation& ctx, 
     TVector<TColumnSchema>& columns, TVector<TIdentifier>& pkColumns,
     TVector<TIdentifier>& partitionByColumns, TVector<std::pair<TIdentifier, bool>>& orderByColumns)
 {
@@ -309,8 +309,8 @@ static bool CreateTableEntry(const TRule_create_table_entry& node, TTranslation&
             break;
 
         case TRule_create_table_entry::kAltCreateTableEntry2:
-        {
-            auto& constraint = node.GetAlt_create_table_entry2().GetRule_table_constraint1();
+        { 
+            auto& constraint = node.GetAlt_create_table_entry2().GetRule_table_constraint1(); 
             switch (constraint.Alt_case()) {
                 case TRule_table_constraint::kAltTableConstraint1: {
                     auto& pkConstraint = constraint.GetAlt_table_constraint1();
@@ -368,9 +368,9 @@ static bool CreateTableEntry(const TRule_create_table_entry& node, TTranslation&
                 default:
                     ctx.AltNotImplemented("table_constraint", constraint);
                     return false;
-            }
-            break;
-        }
+            } 
+            break; 
+        } 
         default:
             ctx.AltNotImplemented("create_table_entry", node);
             return false;
@@ -451,7 +451,7 @@ static TVector<TString> GetTableFuncHints(TStringBuf funcName) {
     TCiString func(funcName);
     if (func.StartsWith("range") || func.StartsWith("like") || func.StartsWith("regexp") || func.StartsWith("filter")
         || func.StartsWith("each")) {
-
+ 
         return TVector<TString>{"ignore_non_existing"};
     }
 
@@ -1634,7 +1634,7 @@ TNodePtr TSqlExpression::AtomExpr(const TRule_atom_expr& node) {
             TPosition pos(Ctx.Pos());
             bool rawString = true;
             const TString name(IdOrString(alt.GetRule_id_or_string3(), *this, rawString));
-            return BuildCallable(pos, module, name, {});
+            return BuildCallable(pos, module, name, {}); 
         }
         case TRule_atom_expr::kAltAtomExpr9:
             return BitCastRule(node.GetAlt_atom_expr9().GetRule_bitcast_expr1());
@@ -2630,30 +2630,30 @@ TSourcePtr TSqlSelect::SingleSource(const TRule_single_source& node) {
     switch (node.Alt_case()) {
         case TRule_single_source::kAltSingleSource1: {
             const auto& alt = node.GetAlt_single_source1();
-            const auto& table_ref = alt.GetRule_table_ref1();
-
+            const auto& table_ref = alt.GetRule_table_ref1(); 
+ 
             if (auto maybeSource = AsTableImpl(table_ref)) {
-                auto source = *maybeSource;
-                if (!source) {
-                    return nullptr;
-                }
-
-                if (!source->Init(Ctx, source.Get())) {
-                    return nullptr;
-                }
-
-                return source;
-            } else {
+                auto source = *maybeSource; 
+                if (!source) { 
+                    return nullptr; 
+                } 
+ 
+                if (!source->Init(Ctx, source.Get())) { 
+                    return nullptr; 
+                } 
+ 
+                return source; 
+            } else { 
                 TTableRef table(TableRefImpl(alt.GetRule_table_ref1()));
-                TPosition pos(Ctx.Pos());
-                Ctx.IncrementMonCounter("sql_select_clusters", table.Cluster);
-                if (!table.Check(Ctx)) {
-                    return nullptr;
-                }
-                const auto serviceName = to_lower(table.ServiceName(Ctx));
-                const bool stream = serviceName == RtmrProviderName;
-
-                return BuildTableSource(pos, table, stream);
+                TPosition pos(Ctx.Pos()); 
+                Ctx.IncrementMonCounter("sql_select_clusters", table.Cluster); 
+                if (!table.Check(Ctx)) { 
+                    return nullptr; 
+                } 
+                const auto serviceName = to_lower(table.ServiceName(Ctx)); 
+                const bool stream = serviceName == RtmrProviderName; 
+ 
+                return BuildTableSource(pos, table, stream); 
             }
         }
         case TRule_single_source::kAltSingleSource2: {
@@ -2932,22 +2932,22 @@ TSourcePtr TSqlSelect::ProcessCore(const TRule_process_core& node, const TWriteS
     /// \todo other solution
     PushNamedNode(TArgPlaceholderNode::ProcessRows, BuildArgPlaceholder(Ctx.Pos(), TArgPlaceholderNode::ProcessRows));
     PushNamedNode(TArgPlaceholderNode::ProcessRow, BuildArgPlaceholder(Ctx.Pos(), TArgPlaceholderNode::ProcessRow));
-
-    bool listCall = false;
+ 
+    bool listCall = false; 
     TSqlCallExpr call(Ctx, Mode);
     bool initRet = call.Init(block5.GetRule_call_expr2());
     if (initRet) {
         call.IncCounters();
     }
 
-    PopNamedNode(TArgPlaceholderNode::ProcessRows);
-    PopNamedNode(TArgPlaceholderNode::ProcessRow);
+    PopNamedNode(TArgPlaceholderNode::ProcessRows); 
+    PopNamedNode(TArgPlaceholderNode::ProcessRow); 
     if (!initRet) {
         return nullptr;
     }
-
-    auto args = call.GetArgs();
-
+ 
+    auto args = call.GetArgs(); 
+ 
     /// SIN: special processing of binds
     for (auto& arg: args) {
         auto placeholder = dynamic_cast<TArgPlaceholderNode*>(arg.Get());
@@ -2957,17 +2957,17 @@ TSourcePtr TSqlSelect::ProcessCore(const TRule_process_core& node, const TWriteS
                 if (listCall) {
                     Ctx.Error(arg->GetPos()) << "Only single instance of " << name << " is allowed.";
                     return nullptr;
-                }
+                } 
                 listCall = true;
                 arg = new TAstAtomNodeImpl(arg->GetPos(), "inputRowsList", 0);
             } else if (name == TArgPlaceholderNode::ProcessRow) {
                 arg = BuildColumn(arg->GetPos(), "*");
-            }
-        }
-    }
-
-    TSqlCallExpr finalCall(call, args);
-
+            } 
+        } 
+    } 
+ 
+    TSqlCallExpr finalCall(call, args); 
+ 
     TNodePtr with(finalCall.BuildUdf(true));
     if (!with || !finalCall.EnsureNotDistinct("PROCESS")) {
         return {};
@@ -3871,46 +3871,46 @@ TSourcePtr TSqlSelect::Build(const TRule_select_stmt& node, TPosition& selectPos
     return res;
 }
 
-class TSqlIntoValues: public TSqlTranslation {
+class TSqlIntoValues: public TSqlTranslation { 
 public:
     TSqlIntoValues(TContext& ctx, NSQLTranslation::ESqlMode mode)
         : TSqlTranslation(ctx, mode)
     {
     }
 
-    TSourcePtr Build(const TRule_into_values_source& node, const TString& operationName);
+    TSourcePtr Build(const TRule_into_values_source& node, const TString& operationName); 
 
 private:
     bool BuildValuesRow(const TRule_values_source_row& inRow, TVector<TNodePtr>& outRow);
-    TSourcePtr ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint,
-        const TString& operationName);
+    TSourcePtr ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint, 
+        const TString& operationName); 
 };
 
-TSourcePtr TSqlIntoValues::Build(const TRule_into_values_source& node, const TString& operationName) {
-    switch (node.Alt_case()) {
-        case TRule_into_values_source::kAltIntoValuesSource1: {
-            auto alt = node.GetAlt_into_values_source1();
-            TVector<TString> columnsHint;
-            if (alt.HasBlock1()) {
-                PureColumnListStr(alt.GetBlock1().GetRule_pure_column_list1(), *this, columnsHint);
-            }
-            return ValuesSource(alt.GetRule_values_source2(), columnsHint, operationName);
-        }
-        default:
-            Ctx.IncrementMonCounter("sql_errors", "DefaultValuesOrOther");
-            AltNotImplemented("into_values_source", node);
-            return nullptr;
-    }
-}
-
-bool TSqlIntoValues::BuildValuesRow(const TRule_values_source_row& inRow, TVector<TNodePtr>& outRow){
+TSourcePtr TSqlIntoValues::Build(const TRule_into_values_source& node, const TString& operationName) { 
+    switch (node.Alt_case()) { 
+        case TRule_into_values_source::kAltIntoValuesSource1: { 
+            auto alt = node.GetAlt_into_values_source1(); 
+            TVector<TString> columnsHint; 
+            if (alt.HasBlock1()) { 
+                PureColumnListStr(alt.GetBlock1().GetRule_pure_column_list1(), *this, columnsHint); 
+            } 
+            return ValuesSource(alt.GetRule_values_source2(), columnsHint, operationName); 
+        } 
+        default: 
+            Ctx.IncrementMonCounter("sql_errors", "DefaultValuesOrOther"); 
+            AltNotImplemented("into_values_source", node); 
+            return nullptr; 
+    } 
+} 
+
+bool TSqlIntoValues::BuildValuesRow(const TRule_values_source_row& inRow, TVector<TNodePtr>& outRow){ 
     TSqlExpression sqlExpr(Ctx, Mode);
     return ExprList(sqlExpr, outRow, inRow.GetRule_expr_list2());
 }
 
-TSourcePtr TSqlIntoValues::ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint,
-    const TString& operationName)
-{
+TSourcePtr TSqlIntoValues::ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint, 
+    const TString& operationName) 
+{ 
     Ctx.IncrementMonCounter("sql_features", "ValuesSource");
     TPosition pos(Ctx.Pos());
     switch (node.Alt_case()) {
@@ -3929,7 +3929,7 @@ TSourcePtr TSqlIntoValues::ValuesSource(const TRule_values_source& node, TVector
                 }
             }
 
-            return BuildWriteValues(pos, operationName, columnsHint, rows);
+            return BuildWriteValues(pos, operationName, columnsHint, rows); 
         }
         case TRule_values_source::kAltValuesSource2: {
             TSqlSelect select(Ctx, Mode);
@@ -3947,99 +3947,99 @@ TSourcePtr TSqlIntoValues::ValuesSource(const TRule_values_source& node, TVector
     }
 }
 
-class TSqlIntoTable: public TSqlTranslation {
-public:
+class TSqlIntoTable: public TSqlTranslation { 
+public: 
     TSqlIntoTable(TContext& ctx, NSQLTranslation::ESqlMode mode)
-        : TSqlTranslation(ctx, mode)
-    {
-    }
-
-    TNodePtr Build(const TRule_into_table_stmt& node);
-
-private:
-    //bool BuildValuesRow(const TRule_values_source_row& inRow, TVector<TNodePtr>& outRow);
-    //TSourcePtr ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint);
-    //TSourcePtr IntoValuesSource(const TRule_into_values_source& node);
-
-    bool ValidateServiceName(const TRule_into_table_stmt& node, const TTableRef& table, ESQLWriteColumnMode mode,
-        const TPosition& pos);
-    TString SqlIntoModeStr;
-    TString SqlIntoUserModeStr;
-};
-
+        : TSqlTranslation(ctx, mode) 
+    { 
+    } 
+ 
+    TNodePtr Build(const TRule_into_table_stmt& node); 
+ 
+private: 
+    //bool BuildValuesRow(const TRule_values_source_row& inRow, TVector<TNodePtr>& outRow); 
+    //TSourcePtr ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint); 
+    //TSourcePtr IntoValuesSource(const TRule_into_values_source& node); 
+ 
+    bool ValidateServiceName(const TRule_into_table_stmt& node, const TTableRef& table, ESQLWriteColumnMode mode, 
+        const TPosition& pos); 
+    TString SqlIntoModeStr; 
+    TString SqlIntoUserModeStr; 
+}; 
+ 
 TNodePtr TSqlIntoTable::Build(const TRule_into_table_stmt& node) {
     static const TMap<TString, ESQLWriteColumnMode> str2Mode = {
         {"InsertInto", ESQLWriteColumnMode::InsertInto},
-        {"InsertOrAbortInto", ESQLWriteColumnMode::InsertOrAbortInto},
-        {"InsertOrIgnoreInto", ESQLWriteColumnMode::InsertOrIgnoreInto},
-        {"InsertOrRevertInto", ESQLWriteColumnMode::InsertOrRevertInto},
+        {"InsertOrAbortInto", ESQLWriteColumnMode::InsertOrAbortInto}, 
+        {"InsertOrIgnoreInto", ESQLWriteColumnMode::InsertOrIgnoreInto}, 
+        {"InsertOrRevertInto", ESQLWriteColumnMode::InsertOrRevertInto}, 
         {"UpsertInto", ESQLWriteColumnMode::UpsertInto},
         {"ReplaceInto", ESQLWriteColumnMode::ReplaceInto},
-        {"InsertIntoWithTruncate", ESQLWriteColumnMode::InsertIntoWithTruncate}
+        {"InsertIntoWithTruncate", ESQLWriteColumnMode::InsertIntoWithTruncate} 
     };
 
-    auto& modeBlock = node.GetBlock1();
-
-    TVector<TToken> modeTokens;
-    switch (modeBlock.Alt_case()) {
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt1:
-            modeTokens = {modeBlock.GetAlt1().GetToken1()};
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt2:
-            modeTokens = {
-                modeBlock.GetAlt2().GetToken1(),
-                modeBlock.GetAlt2().GetToken2(),
-                modeBlock.GetAlt2().GetToken3()
-            };
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt3:
-            modeTokens = {
-                modeBlock.GetAlt3().GetToken1(),
-                modeBlock.GetAlt3().GetToken2(),
-                modeBlock.GetAlt3().GetToken3()
-            };
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt4:
-            modeTokens = {
-                modeBlock.GetAlt4().GetToken1(),
-                modeBlock.GetAlt4().GetToken2(),
-                modeBlock.GetAlt4().GetToken3()
-            };
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt5:
-            modeTokens = {modeBlock.GetAlt5().GetToken1()};
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt6:
-            modeTokens = {modeBlock.GetAlt6().GetToken1()};
-            break;
+    auto& modeBlock = node.GetBlock1(); 
+ 
+    TVector<TToken> modeTokens; 
+    switch (modeBlock.Alt_case()) { 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt1: 
+            modeTokens = {modeBlock.GetAlt1().GetToken1()}; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt2: 
+            modeTokens = { 
+                modeBlock.GetAlt2().GetToken1(), 
+                modeBlock.GetAlt2().GetToken2(), 
+                modeBlock.GetAlt2().GetToken3() 
+            }; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt3: 
+            modeTokens = { 
+                modeBlock.GetAlt3().GetToken1(), 
+                modeBlock.GetAlt3().GetToken2(), 
+                modeBlock.GetAlt3().GetToken3() 
+            }; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt4: 
+            modeTokens = { 
+                modeBlock.GetAlt4().GetToken1(), 
+                modeBlock.GetAlt4().GetToken2(), 
+                modeBlock.GetAlt4().GetToken3() 
+            }; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt5: 
+            modeTokens = {modeBlock.GetAlt5().GetToken1()}; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt6: 
+            modeTokens = {modeBlock.GetAlt6().GetToken1()}; 
+            break; 
         default:
             Y_FAIL("You should change implementation according grammar changes");
-    }
-
-    TVector<TString> modeStrings;
-    modeStrings.reserve(modeTokens.size());
-    TVector<TString> userModeStrings;
-    userModeStrings.reserve(modeTokens.size());
-
-    for (auto& token : modeTokens) {
-        auto tokenStr = Token(token);
-
-        auto modeStr = tokenStr;
-        modeStr.to_lower();
-        modeStr.to_upper(0, 1);
-        modeStrings.push_back(modeStr);
-
-        auto userModeStr = tokenStr;
-        userModeStr.to_upper();
-        userModeStrings.push_back(userModeStr);
-    }
-
-    modeStrings.push_back("Into");
-    userModeStrings.push_back("INTO");
-
-    SqlIntoModeStr = JoinRange("", modeStrings.begin(), modeStrings.end());
-    SqlIntoUserModeStr = JoinRange(" ", userModeStrings.begin(), userModeStrings.end());
-
+    } 
+ 
+    TVector<TString> modeStrings; 
+    modeStrings.reserve(modeTokens.size()); 
+    TVector<TString> userModeStrings; 
+    userModeStrings.reserve(modeTokens.size()); 
+ 
+    for (auto& token : modeTokens) { 
+        auto tokenStr = Token(token); 
+ 
+        auto modeStr = tokenStr; 
+        modeStr.to_lower(); 
+        modeStr.to_upper(0, 1); 
+        modeStrings.push_back(modeStr); 
+ 
+        auto userModeStr = tokenStr; 
+        userModeStr.to_upper(); 
+        userModeStrings.push_back(userModeStr); 
+    } 
+ 
+    modeStrings.push_back("Into"); 
+    userModeStrings.push_back("INTO"); 
+ 
+    SqlIntoModeStr = JoinRange("", modeStrings.begin(), modeStrings.end()); 
+    SqlIntoUserModeStr = JoinRange(" ", userModeStrings.begin(), userModeStrings.end()); 
+ 
     auto intoTableRef = node.GetRule_into_simple_table_ref3();
     auto tableRef = intoTableRef.GetRule_simple_table_ref1();
 
@@ -4123,15 +4123,15 @@ TNodePtr TSqlIntoTable::Build(const TRule_into_table_stmt& node) {
 
     TPosition pos(Ctx.Pos());
     TNodePtr tableKey = BuildTableKey(pos, cluster, nameOrAt.second, nameOrAt.first ? "@" : "");
-
+ 
     TTableRef table(Ctx.MakeName("table"), cluster, tableKey);
     Ctx.IncrementMonCounter("sql_insert_clusters", table.Cluster);
 
-    auto values = TSqlIntoValues(Ctx, Mode).Build(node.GetRule_into_values_source4(), SqlIntoUserModeStr);
+    auto values = TSqlIntoValues(Ctx, Mode).Build(node.GetRule_into_values_source4(), SqlIntoUserModeStr); 
     if (!values) {
         return nullptr;
     }
-    if (!ValidateServiceName(node, table, SqlIntoMode, GetPos(modeTokens[0]))) {
+    if (!ValidateServiceName(node, table, SqlIntoMode, GetPos(modeTokens[0]))) { 
         return nullptr;
     }
     Ctx.IncrementMonCounter("sql_features", SqlIntoModeStr);
@@ -4144,8 +4144,8 @@ TNodePtr TSqlIntoTable::Build(const TRule_into_table_stmt& node) {
     return BuildWriteColumns(pos, table, ToWriteColumnsMode(SqlIntoMode), std::move(values), std::move(options));
 }
 
-bool TSqlIntoTable::ValidateServiceName(const TRule_into_table_stmt& node, const TTableRef& table,
-    ESQLWriteColumnMode mode, const TPosition& pos) {
+bool TSqlIntoTable::ValidateServiceName(const TRule_into_table_stmt& node, const TTableRef& table, 
+    ESQLWriteColumnMode mode, const TPosition& pos) { 
     Y_UNUSED(node);
     if (!table.Check(Ctx)) {
         return false;
@@ -4155,19 +4155,19 @@ bool TSqlIntoTable::ValidateServiceName(const TRule_into_table_stmt& node, const
     const bool isKikimr = serviceName == KikimrProviderName;
     const bool isRtmr = serviceName == RtmrProviderName;
     const bool isStat = serviceName == StatProviderName;
-
-    if (!isKikimr) {
-        if (mode == ESQLWriteColumnMode::InsertOrAbortInto ||
-            mode == ESQLWriteColumnMode::InsertOrIgnoreInto ||
-            mode == ESQLWriteColumnMode::InsertOrRevertInto ||
+ 
+    if (!isKikimr) { 
+        if (mode == ESQLWriteColumnMode::InsertOrAbortInto || 
+            mode == ESQLWriteColumnMode::InsertOrIgnoreInto || 
+            mode == ESQLWriteColumnMode::InsertOrRevertInto || 
             mode == ESQLWriteColumnMode::UpsertInto && !isStat)
-        {
-            Ctx.Error(pos) << SqlIntoUserModeStr << " is not supported for " << serviceName << " tables";
-            Ctx.IncrementMonCounter("sql_errors", TStringBuilder() << SqlIntoUserModeStr << "UnsupportedFor" << serviceName);
-            return false;
-        }
-    }
-
+        { 
+            Ctx.Error(pos) << SqlIntoUserModeStr << " is not supported for " << serviceName << " tables"; 
+            Ctx.IncrementMonCounter("sql_errors", TStringBuilder() << SqlIntoUserModeStr << "UnsupportedFor" << serviceName); 
+            return false; 
+        } 
+    } 
+ 
     if (isMapReduce) {
         if (mode == ESQLWriteColumnMode::ReplaceInto) {
             Ctx.Error(pos) << "Meaning of REPLACE INTO has been changed, now you should use INSERT INTO <table> WITH TRUNCATE ... for " << serviceName;
@@ -4175,8 +4175,8 @@ bool TSqlIntoTable::ValidateServiceName(const TRule_into_table_stmt& node, const
             return false;
         }
     } else if (isKikimr) {
-        if (mode == ESQLWriteColumnMode::InsertIntoWithTruncate) {
-            Ctx.Error(pos) << "INSERT INTO WITH TRUNCATE is not supported for " << serviceName << " tables";
+        if (mode == ESQLWriteColumnMode::InsertIntoWithTruncate) { 
+            Ctx.Error(pos) << "INSERT INTO WITH TRUNCATE is not supported for " << serviceName << " tables"; 
             Ctx.IncrementMonCounter("sql_errors", TStringBuilder() << SqlIntoUserModeStr << "UnsupportedFor" << serviceName);
             return false;
         }
@@ -4193,7 +4193,7 @@ bool TSqlIntoTable::ValidateServiceName(const TRule_into_table_stmt& node, const
             return false;
         }
     }
-
+ 
     return true;
 }
 
@@ -4356,11 +4356,11 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
         case TRule_sql_stmt_core::kAltSqlStmtCore5: {
             Ctx.BodyPart();
             const auto& rule = core.GetAlt_sql_stmt_core5().GetRule_drop_table_stmt1();
-            if (rule.HasBlock3()) {
+            if (rule.HasBlock3()) { 
                 Context().Error(GetPos(rule.GetToken1())) << "IF EXISTS in " << humanStatementName
-                    << " is not supported.";
-                return false;
-            }
+                    << " is not supported."; 
+                return false; 
+            } 
             TTableRef tr(SimpleTableRefImpl(rule.GetRule_simple_table_ref4(), Mode, *this));
             AddStatementToBlocks(blocks, BuildDropTable(Ctx.Pos(), tr));
             break;
@@ -4409,13 +4409,13 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             blocks.emplace_back(deleteNode);
             break;
         }
-        case TRule_sql_stmt_core::kAltSqlStmtCore11: {
+        case TRule_sql_stmt_core::kAltSqlStmtCore11: { 
             Ctx.BodyPart();
-            const auto& rule = core.GetAlt_sql_stmt_core11().GetRule_rollback_stmt1();
-            Token(rule.GetToken1());
+            const auto& rule = core.GetAlt_sql_stmt_core11().GetRule_rollback_stmt1(); 
+            Token(rule.GetToken1()); 
             blocks.emplace_back(BuildRollbackClusters(Ctx.Pos()));
-            break;
-        }
+            break; 
+        } 
         case TRule_sql_stmt_core::kAltSqlStmtCore12:
             if (!DeclareStatement(core.GetAlt_sql_stmt_core12().GetRule_declare_stmt1())) {
                 return false;
@@ -4888,47 +4888,47 @@ TNodePtr TSqlQuery::Build(const TRule_delete_stmt& stmt) {
     if (!table.Check(Ctx)) {
         return nullptr;
     }
-
+ 
     auto serviceName = to_lower(table.ServiceName(Ctx));
-    const bool isKikimr = serviceName == KikimrProviderName;
-
-    if (!isKikimr) {
-        Ctx.Error(GetPos(stmt.GetToken1())) << "DELETE is unsupported for " << serviceName;
+    const bool isKikimr = serviceName == KikimrProviderName; 
+ 
+    if (!isKikimr) { 
+        Ctx.Error(GetPos(stmt.GetToken1())) << "DELETE is unsupported for " << serviceName; 
         return nullptr;
     }
-
-    TSourcePtr source = BuildTableSource(Ctx.Pos(), table, false);
-
+ 
+    TSourcePtr source = BuildTableSource(Ctx.Pos(), table, false); 
+ 
     if (stmt.HasBlock4()) {
-        switch (stmt.GetBlock4().Alt_case()) {
-            case TRule_delete_stmt_TBlock4::kAlt1: {
-                const auto& alt = stmt.GetBlock4().GetAlt1();
-
-                TSqlExpression sqlExpr(Ctx, Mode);
-                auto whereExpr = sqlExpr.Build(alt.GetRule_expr2());
-                if (!whereExpr) {
-                    return nullptr;
-                }
-                source->AddFilter(Ctx, whereExpr);
-                break;
-            }
-
-            case TRule_delete_stmt_TBlock4::kAlt2: {
-                const auto& alt = stmt.GetBlock4().GetAlt2();
-
-                auto values = TSqlIntoValues(Ctx, Mode).Build(alt.GetRule_into_values_source2(), "DELETE ON");
-                if (!values) {
-                    return nullptr;
-                }
-
-                return BuildWriteColumns(Ctx.Pos(), table, EWriteColumnMode::DeleteOn, std::move(values));
-            }
-
-            default:
-                return nullptr;
-        }
-    }
-
+        switch (stmt.GetBlock4().Alt_case()) { 
+            case TRule_delete_stmt_TBlock4::kAlt1: { 
+                const auto& alt = stmt.GetBlock4().GetAlt1(); 
+ 
+                TSqlExpression sqlExpr(Ctx, Mode); 
+                auto whereExpr = sqlExpr.Build(alt.GetRule_expr2()); 
+                if (!whereExpr) { 
+                    return nullptr; 
+                } 
+                source->AddFilter(Ctx, whereExpr); 
+                break; 
+            } 
+ 
+            case TRule_delete_stmt_TBlock4::kAlt2: { 
+                const auto& alt = stmt.GetBlock4().GetAlt2(); 
+ 
+                auto values = TSqlIntoValues(Ctx, Mode).Build(alt.GetRule_into_values_source2(), "DELETE ON"); 
+                if (!values) { 
+                    return nullptr; 
+                } 
+ 
+                return BuildWriteColumns(Ctx.Pos(), table, EWriteColumnMode::DeleteOn, std::move(values)); 
+            } 
+ 
+            default: 
+                return nullptr; 
+        }
+    }
+ 
     return BuildDelete(Ctx.Pos(), table, std::move(source));
 }
 
@@ -4937,45 +4937,45 @@ TNodePtr TSqlQuery::Build(const TRule_update_stmt& stmt) {
     if (!table.Check(Ctx)) {
         return nullptr;
     }
-
+ 
     auto serviceName = to_lower(table.ServiceName(Ctx));
-    const bool isKikimr = serviceName == KikimrProviderName;
-
-    if (!isKikimr) {
-        Ctx.Error(GetPos(stmt.GetToken1())) << "UPDATE is unsupported for " << serviceName;
+    const bool isKikimr = serviceName == KikimrProviderName; 
+ 
+    if (!isKikimr) { 
+        Ctx.Error(GetPos(stmt.GetToken1())) << "UPDATE is unsupported for " << serviceName; 
         return nullptr;
     }
-
-    switch (stmt.GetBlock3().Alt_case()) {
-        case TRule_update_stmt_TBlock3::kAlt1: {
-            const auto& alt = stmt.GetBlock3().GetAlt1();
-            TSourcePtr values = Build(alt.GetRule_set_clause_choice2());
-            auto source = BuildTableSource(Ctx.Pos(), table, false);
-
-            if (alt.HasBlock3()) {
-                TSqlExpression sqlExpr(Ctx, Mode);
-                auto whereExpr = sqlExpr.Build(alt.GetBlock3().GetRule_expr2());
-                if (!whereExpr) {
-                    return nullptr;
-                }
-                source->AddFilter(Ctx, whereExpr);
-            }
-
-            return BuildUpdateColumns(Ctx.Pos(), table, std::move(values), std::move(source));
-        }
-
-        case TRule_update_stmt_TBlock3::kAlt2: {
-            const auto& alt = stmt.GetBlock3().GetAlt2();
-
-            auto values = TSqlIntoValues(Ctx, Mode).Build(alt.GetRule_into_values_source2(), "UPDATE ON");
-            if (!values) {
-                return nullptr;
-            }
-
-            return BuildWriteColumns(Ctx.Pos(), table, EWriteColumnMode::UpdateOn, std::move(values));
-        }
-
-        default:
+ 
+    switch (stmt.GetBlock3().Alt_case()) { 
+        case TRule_update_stmt_TBlock3::kAlt1: { 
+            const auto& alt = stmt.GetBlock3().GetAlt1(); 
+            TSourcePtr values = Build(alt.GetRule_set_clause_choice2()); 
+            auto source = BuildTableSource(Ctx.Pos(), table, false); 
+ 
+            if (alt.HasBlock3()) { 
+                TSqlExpression sqlExpr(Ctx, Mode); 
+                auto whereExpr = sqlExpr.Build(alt.GetBlock3().GetRule_expr2()); 
+                if (!whereExpr) { 
+                    return nullptr; 
+                } 
+                source->AddFilter(Ctx, whereExpr); 
+            } 
+ 
+            return BuildUpdateColumns(Ctx.Pos(), table, std::move(values), std::move(source)); 
+        } 
+ 
+        case TRule_update_stmt_TBlock3::kAlt2: { 
+            const auto& alt = stmt.GetBlock3().GetAlt2(); 
+ 
+            auto values = TSqlIntoValues(Ctx, Mode).Build(alt.GetRule_into_values_source2(), "UPDATE ON"); 
+            if (!values) { 
+                return nullptr; 
+            } 
+ 
+            return BuildWriteColumns(Ctx.Pos(), table, EWriteColumnMode::UpdateOn, std::move(values)); 
+        } 
+ 
+        default: 
             return nullptr;
     }
 }
@@ -5237,8 +5237,8 @@ google::protobuf::Message* SqlAST(const TString& query, const TString& queryName
     NSQLTranslation::TErrorCollectorOverIssues collector(err, maxErrors, "");
     NProtoAST::TProtoASTBuilder<NALP::SQLParser, NALP::SQLLexer> builder(query, queryName, arena);
     return builder.BuildAST(collector);
-}
-
+} 
+ 
 google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NProtoAST::IErrorCollector& err, google::protobuf::Arena* arena) {
     YQL_ENSURE(arena);
 #if defined(_tsan_enabled_)
@@ -5248,7 +5248,7 @@ google::protobuf::Message* SqlAST(const TString& query, const TString& queryName
     return builder.BuildAST(err);
 }
 
-TAstNode* SqlASTToYql(const google::protobuf::Message& protoAst, TContext& ctx) {
+TAstNode* SqlASTToYql(const google::protobuf::Message& protoAst, TContext& ctx) { 
     const google::protobuf::Descriptor* d = protoAst.GetDescriptor();
     if (d && d->name() != "TSQLParserAST") {
         ctx.Error() << "Invalid AST structure: " << d->name() << ", expected TSQLParserAST";
@@ -5285,21 +5285,21 @@ void SqlASTToYqlImpl(NYql::TAstParseResult& res, const google::protobuf::Message
 
 NYql::TAstParseResult SqlASTToYql(const google::protobuf::Message& protoAst,
     const NSQLTranslation::TTranslationSettings& settings)
-{
+{ 
     YQL_ENSURE(IsQueryMode(settings.Mode));
-    TAstParseResult res;
+    TAstParseResult res; 
     TContext ctx(settings, res.Issues);
     SqlASTToYqlImpl(res, protoAst, ctx);
-    return res;
-}
-
+    return res; 
+} 
+ 
 
 NYql::TAstParseResult SqlToYql(const TString& query, const NSQLTranslation::TTranslationSettings& settings, NYql::TWarningRules* warningRules)
-{
-    TAstParseResult res;
+{ 
+    TAstParseResult res; 
     TContext ctx(settings, res.Issues);
     NSQLTranslation::TErrorCollectorOverIssues collector(res.Issues, settings.MaxErrors, settings.File);
-
+ 
     google::protobuf::Message* ast(SqlAST(query, "query", collector, settings.Arena));
     if (ast) {
         SqlASTToYqlImpl(res, *ast, ctx);
diff --git a/ydb/library/yql/sql/v0/sql.h b/ydb/library/yql/sql/v0/sql.h
index fda4387c27..926f1f90f3 100644
--- a/ydb/library/yql/sql/v0/sql.h
+++ b/ydb/library/yql/sql/v0/sql.h
@@ -13,5 +13,5 @@ namespace NSQLTranslationV0 {
     NYql::TAstParseResult SqlToYql(const TString& query, const NSQLTranslation::TTranslationSettings& settings, NYql::TWarningRules* warningRules = nullptr);
     google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NYql::TIssues& err, size_t maxErrors, google::protobuf::Arena* arena = nullptr);
     NYql::TAstParseResult SqlASTToYql(const google::protobuf::Message& protoAst, const NSQLTranslation::TTranslationSettings& settings);
-
+ 
 }  // namespace NSQLTranslationV0
diff --git a/ydb/library/yql/sql/v0/sql_ut.cpp b/ydb/library/yql/sql/v0/sql_ut.cpp
index 3a70aef93c..b5be9e0993 100644
--- a/ydb/library/yql/sql/v0/sql_ut.cpp
+++ b/ydb/library/yql/sql/v0/sql_ut.cpp
@@ -1,10 +1,10 @@
 #include "sql.h"
-
+ 
 #include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
 #include <util/generic/map.h>
-
+ 
 #include <library/cpp/testing/unittest/registar.h>
-
+ 
 #include <util/string/split.h>
 
 using namespace NSQLTranslationV0;
@@ -30,7 +30,7 @@ NYql::TAstParseResult SqlToYqlWithMode(const TString& query, NSQLTranslation::ES
     const TString cluster = "plato";
     NSQLTranslation::TTranslationSettings settings;
     settings.ClusterMapping[cluster] = service;
-    settings.MaxErrors = maxErrors;
+    settings.MaxErrors = maxErrors; 
     settings.Mode = mode;
     settings.Arena = &arena;
     settings.V0Behavior = NSQLTranslation::EV0Behavior::Report;
@@ -484,7 +484,7 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
         NYql::TAstParseResult res = SqlToYql("select in, s.check from (select 1 as in, \"test\" as check) as s;");
         UNIT_ASSERT(res.Root);
     }
-
+ 
     Y_UNIT_TEST(SelectAllGroupBy) {
         NYql::TAstParseResult res = SqlToYql("select * from plato.Input group by subkey;");
         UNIT_ASSERT(res.Root);
@@ -492,21 +492,21 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
 
     Y_UNIT_TEST(PrimaryKeyParseCorrect) {
         NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE tableName (Key Uint32, Subkey Int64, Value String, PRIMARY KEY (Key, Subkey));");
-        UNIT_ASSERT(res.Root);
-
+        UNIT_ASSERT(res.Root); 
+ 
         TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
+            if (word == "Write") { 
                 UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"Key\""));
                 UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"Subkey\""));
-            }
-        };
-
+            } 
+        }; 
+ 
         TWordCountHive elementStat = {{TString("Write"), 0}, {TString("primarykey"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["primarykey"]);
-    }
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["primarykey"]); 
+    } 
 
     Y_UNIT_TEST(DeleteFromTableByKey) {
         NYql::TAstParseResult res = SqlToYql("delete from plato.Input where key = 200;", 10, "kikimr");
@@ -541,39 +541,39 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
     }
 
     Y_UNIT_TEST(DeleteFromTableOnValues) {
-        NYql::TAstParseResult res = SqlToYql("delete from plato.Input on (key) values (1);",
-            10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
-        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
-                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)"));
-            }
-        };
-
-        TWordCountHive elementStat = {{TString("Write"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-    }
-
+        NYql::TAstParseResult res = SqlToYql("delete from plato.Input on (key) values (1);", 
+            10, "kikimr"); 
+        UNIT_ASSERT(res.Root); 
+ 
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) { 
+            if (word == "Write") { 
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)")); 
+            } 
+        }; 
+ 
+        TWordCountHive elementStat = {{TString("Write"), 0}}; 
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+    } 
+ 
     Y_UNIT_TEST(DeleteFromTableOnSelect) {
-        NYql::TAstParseResult res = SqlToYql(
-            "delete from plato.Input on select key from plato.Input where value > 0;", 10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
-        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
-                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)"));
-            }
-        };
-
-        TWordCountHive elementStat = {{TString("Write"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-    }
-
+        NYql::TAstParseResult res = SqlToYql( 
+            "delete from plato.Input on select key from plato.Input where value > 0;", 10, "kikimr"); 
+        UNIT_ASSERT(res.Root); 
+ 
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) { 
+            if (word == "Write") { 
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)")); 
+            } 
+        }; 
+ 
+        TWordCountHive elementStat = {{TString("Write"), 0}}; 
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+    } 
+ 
     Y_UNIT_TEST(UpdateByValues) {
         NYql::TAstParseResult res = SqlToYql("update plato.Input set key = 777, value = 'cool' where key = 200;", 10, "kikimr");
         UNIT_ASSERT(res.Root);
@@ -612,7 +612,7 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
                 const bool isSubkey = line.find("subkey") != TString::npos;
                 const bool isValue = line.find("value") != TString::npos;
                 UNIT_ASSERT(isKey || isSubkey || isValue);
-                if (isKey && !isSubkey) {
+                if (isKey && !isSubkey) { 
                     UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("2")));
                 } else if (isSubkey) {
                     UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote(":")));
@@ -678,38 +678,38 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
     }
 
     Y_UNIT_TEST(UpdateOnValues) {
-        NYql::TAstParseResult res = SqlToYql("update plato.Input on (key, value) values (5, 'cool')", 10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
-        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
-                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)"));
-            }
-        };
-
-        TWordCountHive elementStat = {{TString("Write"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-    }
-
+        NYql::TAstParseResult res = SqlToYql("update plato.Input on (key, value) values (5, 'cool')", 10, "kikimr"); 
+        UNIT_ASSERT(res.Root); 
+ 
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) { 
+            if (word == "Write") { 
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)")); 
+            } 
+        }; 
+ 
+        TWordCountHive elementStat = {{TString("Write"), 0}}; 
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+    } 
+ 
     Y_UNIT_TEST(UpdateOnSelect) {
-        NYql::TAstParseResult res = SqlToYql(
-            "update plato.Input on select key, value + 1 as value from plato.Input", 10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
-        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
-                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)"));
-            }
-        };
-
-        TWordCountHive elementStat = {{TString("Write"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-    }
-
+        NYql::TAstParseResult res = SqlToYql( 
+            "update plato.Input on select key, value + 1 as value from plato.Input", 10, "kikimr"); 
+        UNIT_ASSERT(res.Root); 
+ 
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) { 
+            if (word == "Write") { 
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)")); 
+            } 
+        }; 
+ 
+        TWordCountHive elementStat = {{TString("Write"), 0}}; 
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+    } 
+ 
     Y_UNIT_TEST(UnionAllTest) {
         NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input UNION ALL select subkey FROM plato.Input;");
         UNIT_ASSERT(res.Root);
@@ -735,15 +735,15 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
         /// Verify that parsed well without crash
         UNIT_ASSERT(res.Root);
     }
-
+ 
     Y_UNIT_TEST(KikimrRollback) {
         NYql::TAstParseResult res = SqlToYql("use plato; rollback;", 10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
+        UNIT_ASSERT(res.Root); 
+ 
         TWordCountHive elementStat = {{TString("rollback"), 0}};
-        VerifyProgram(res, elementStat);
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["rollback"]);
-    }
+        VerifyProgram(res, elementStat); 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["rollback"]); 
+    } 
 
     Y_UNIT_TEST(PragmaFile) {
         NYql::TAstParseResult res = SqlToYql(R"(pragma file("HW", "sbr:181041334");)");
@@ -821,17 +821,17 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
         )", 10, TString(NYql::RtmrProviderName));
         UNIT_ASSERT(res.Root);
     }
-
+ 
     Y_UNIT_TEST(KikimrInserts) {
-         NYql::TAstParseResult res = SqlToYql(R"(
-            USE plato;
-            INSERT INTO Output SELECT key, value FROM Input;
-            INSERT OR ABORT INTO Output SELECT key, value FROM Input;
-            INSERT OR IGNORE INTO Output SELECT key, value FROM Input;
-            INSERT OR REVERT INTO Output SELECT key, value FROM Input;
-        )", 10, TString(NYql::KikimrProviderName));
-        UNIT_ASSERT(res.Root);
-    }
+         NYql::TAstParseResult res = SqlToYql(R"( 
+            USE plato; 
+            INSERT INTO Output SELECT key, value FROM Input; 
+            INSERT OR ABORT INTO Output SELECT key, value FROM Input; 
+            INSERT OR IGNORE INTO Output SELECT key, value FROM Input; 
+            INSERT OR REVERT INTO Output SELECT key, value FROM Input; 
+        )", 10, TString(NYql::KikimrProviderName)); 
+        UNIT_ASSERT(res.Root); 
+    } 
 
     Y_UNIT_TEST(WarnMissingIsBeforeNotNull) {
         NYql::TAstParseResult res = SqlToYql("select 1 NOT NULL");
@@ -1197,16 +1197,16 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
 
     Y_UNIT_TEST(UpsertValuesNoLabelsKikimr) {
         NYql::TAstParseResult res = SqlToYql("upsert into plato.Output values (1)", 10, TString(NYql::KikimrProviderName));
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:19: Error: UPSERT INTO ... VALUES requires specification of table columns\n");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(ReplaceValuesNoLabelsKikimr) {
         NYql::TAstParseResult res = SqlToYql("replace into plato.Output values (1)", 10, TString(NYql::KikimrProviderName));
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:20: Error: REPLACE INTO ... VALUES requires specification of table columns\n");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(InsertValuesInvalidLabels) {
         NYql::TAstParseResult res = SqlToYql("insert into plato.Output (foo) values (1, 2)");
         UNIT_ASSERT(!res.Root);
@@ -1236,45 +1236,45 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
         UNIT_ASSERT(!res.Root);
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:52: Error: REDUCE does not allow DISTINCT arguments\n");
     }
-
+ 
     Y_UNIT_TEST(ProcessMultipleRowsPlaceholders) {
         NYql::TAstParseResult res = SqlToYql("process plato.Input using some::udf($ROWS, $ROWS)");
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:15: Error: Only single instance of $ROWS is allowed.\n");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(ProcessRowInExpression) {
         NYql::TAstParseResult res = SqlToYql("process plato.Input using some::udf($ROW + 1)");
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:15: Error: $ROW can't be used as a part of expression.\n");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(ProcessRowsInExpression) {
         NYql::TAstParseResult res = SqlToYql("process plato.Input using some::udf($ROWS + 1)");
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:15: Error: $ROWS can't be used as a part of expression.\n");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(ProcessRowsWithColumnAccess) {
         NYql::TAstParseResult res = SqlToYql("process plato.Input using some::udf(key, $ROWS)");
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:15: Error: Source does not allow column references\n");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(ProcessRowsWithRowAccess) {
         NYql::TAstParseResult res = SqlToYql("process plato.Input using some::udf($ROWS, $ROW)");
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:15: Error: Source does not allow column references\n");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(ProcessRowsPlaceholderOutOfScope) {
-        NYql::TAstParseResult res = SqlToYql(
+        NYql::TAstParseResult res = SqlToYql( 
             "$data = (process plato.Input using some::udf($ROWS));\n"
             "SELECT * FROM $ROWS;\n"
-        );
-        UNIT_ASSERT(!res.Root);
+        ); 
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:15: Error: Unknown name: $ROWS\n");
-    }
+    } 
 
     Y_UNIT_TEST(ProcessWithInvalidSource) {
         NYql::TAstParseResult res = SqlToYql("PROCESS $input USING YQL::AsList($ROWS);");
@@ -1459,11 +1459,11 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
     }
 
     Y_UNIT_TEST(InsertAbortMapReduce) {
-        NYql::TAstParseResult res = SqlToYql("INSERT OR ABORT INTO plato.Output SELECT key FROM plato.Input");
-        UNIT_ASSERT(!res.Root);
-        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: INSERT OR ABORT INTO is not supported for yt tables\n");
-    }
-
+        NYql::TAstParseResult res = SqlToYql("INSERT OR ABORT INTO plato.Output SELECT key FROM plato.Input"); 
+        UNIT_ASSERT(!res.Root); 
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: INSERT OR ABORT INTO is not supported for yt tables\n"); 
+    } 
+ 
     Y_UNIT_TEST(ReplaceIntoMapReduce) {
         NYql::TAstParseResult res = SqlToYql("REPLACE INTO plato.Output SELECT key FROM plato.Input");
         UNIT_ASSERT(!res.Root);
@@ -1609,12 +1609,12 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
         UNIT_ASSERT(!res.Root);
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:43: Error: Column name can not be empty\n");
     }
-
+ 
     Y_UNIT_TEST(RollbackUnsupported) {
         NYql::TAstParseResult res = SqlToYql("insert into plato.Output (v0, v1) values (0, 1); rollback;");
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:50: Error: ROLLBACK isn't supported for provider: yt\n");
-    }
+    } 
 
     Y_UNIT_TEST(ShouldFailAsTruncatedBinaryNotSucceedAsLegacyTinyZeroInt) {
         NYql::TAstParseResult res = SqlToYql("select 0b;");
@@ -1660,12 +1660,12 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
         UNIT_ASSERT(!res.Root);
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Failed to use window function: Lead without window specification\n");
     }
-
+ 
     Y_UNIT_TEST(DropTableWithIfExists) {
-        NYql::TAstParseResult res = SqlToYql("DROP TABLE IF EXISTS plato.foo;");
-        UNIT_ASSERT(!res.Root);
+        NYql::TAstParseResult res = SqlToYql("DROP TABLE IF EXISTS plato.foo;"); 
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: IF EXISTS in DROP TABLE is not supported.\n");
-    }
+    } 
 
     Y_UNIT_TEST(TooManyErrors) {
         const char* q = R"(
diff --git a/ydb/library/yql/sql/v1/SQLv1.g.in b/ydb/library/yql/sql/v1/SQLv1.g.in
index ef394c7a00..3fbdc2bd36 100644
--- a/ydb/library/yql/sql/v1/SQLv1.g.in
+++ b/ydb/library/yql/sql/v1/SQLv1.g.in
@@ -29,7 +29,7 @@ sql_stmt_core:
   | commit_stmt
   | update_stmt
   | delete_stmt
-  | rollback_stmt
+  | rollback_stmt 
   | declare_stmt
   | import_stmt
   | export_stmt
@@ -328,8 +328,8 @@ sort_specification_list: sort_specification (COMMA sort_specification)*;
 
 select_stmt: select_kind_parenthesis (select_op select_kind_parenthesis)*;
 
-select_unparenthesized_stmt: select_kind_partial (select_op select_kind_parenthesis)*;
-
+select_unparenthesized_stmt: select_kind_partial (select_op select_kind_parenthesis)*; 
+ 
 select_kind_parenthesis: select_kind_partial | LPAREN select_kind_partial RPAREN;
 
 select_op: UNION (ALL)? | INTERSECT | EXCEPT;
@@ -583,8 +583,8 @@ table_hint:
 simple_table_ref: (((cluster_expr DOT)? id_or_at) | AT? bind_parameter) table_hints?;
 into_simple_table_ref: simple_table_ref (ERASE BY pure_column_list)?;
 
-delete_stmt: DELETE FROM simple_table_ref (WHERE expr | ON into_values_source)?;
-update_stmt: UPDATE simple_table_ref (SET set_clause_choice (WHERE expr)? | ON into_values_source);
+delete_stmt: DELETE FROM simple_table_ref (WHERE expr | ON into_values_source)?; 
+update_stmt: UPDATE simple_table_ref (SET set_clause_choice (WHERE expr)? | ON into_values_source); 
 
 /// out of 2003 standart
 set_clause_choice: set_clause_list | multiple_column_assignment;
@@ -643,16 +643,16 @@ window_frame_exclusion: EXCLUDE CURRENT ROW | EXCLUDE GROUP | EXCLUDE TIES | EXC
 // EXTRAS
 use_stmt: USE cluster_expr;
 
-subselect_stmt: (LPAREN select_stmt RPAREN | select_unparenthesized_stmt);
+subselect_stmt: (LPAREN select_stmt RPAREN | select_unparenthesized_stmt); 
 
 // TODO: [fatal] rule named_nodes_stmt has non-LL(*) decision due to recursive rule invocations reachable from alts 1,3
 // named_nodes_stmt: bind_parameter_list EQUALS (expr | subselect_stmt | values_stmt | LPAREN values_stmt RPAREN);
-named_nodes_stmt: bind_parameter_list EQUALS (expr | subselect_stmt);
-
+named_nodes_stmt: bind_parameter_list EQUALS (expr | subselect_stmt); 
+ 
 commit_stmt: COMMIT;
 
-rollback_stmt: ROLLBACK;
-
+rollback_stmt: ROLLBACK; 
+ 
 // Special rules that allow to use certain keywords as identifiers.
 identifier: ID_PLAIN | ID_QUOTED;
 id: identifier | keyword;
@@ -977,7 +977,7 @@ keyword_compat: (
   | RESTRICT
   | RESULT
   | RETURNING
-  | REVERT
+  | REVERT 
   | RIGHT
   | RLIKE
   | ROLLBACK
@@ -1281,7 +1281,7 @@ RESTRICT: R E S T R I C T;
 RESULT: R E S U L T;
 RETURN: R E T U R N;
 RETURNING: R E T U R N I N G;
-REVERT: R E V E R T;
+REVERT: R E V E R T; 
 RIGHT: R I G H T;
 RLIKE: R L I K E;
 ROLLBACK: R O L L B A C K;
diff --git a/ydb/library/yql/sql/v1/builtin.cpp b/ydb/library/yql/sql/v1/builtin.cpp
index 43ef1243f1..cc9b3b40a8 100644
--- a/ydb/library/yql/sql/v1/builtin.cpp
+++ b/ydb/library/yql/sql/v1/builtin.cpp
@@ -1339,7 +1339,7 @@ private:
         auto key = Args[0];
         auto inNode = Args[1];
         auto hints = Args[2];
-
+ 
         const auto pos = inNode->GetPos();
 
         if (!key->Init(ctx, src)) {
@@ -1366,7 +1366,7 @@ private:
                                                                       << "perhaps you should remove "
                                                                       << parenKind << "parenthesis here";
             }
-        }
+        } 
 
         TVector<TNodePtr> hintElements;
         for (size_t i = 0; i < hints->GetTupleSize(); ++i) {
@@ -1390,7 +1390,7 @@ private:
             key,
             BuildTuple(pos, hintElements)
         };
-
+ 
         return TCallNode::DoInit(ctx, src);
     }
 
@@ -1430,7 +1430,7 @@ private:
     void DoUpdateState() const override {
         TCallNode::DoUpdateState();
         State.Set(ENodeState::Aggregated, false/*!RunConfig || RunConfig->IsAggregated()*/);
-        State.Set(ENodeState::Const, true /* FIXME: To avoid CheckAggregationLevel issue for non-const TypeOf. */);
+        State.Set(ENodeState::Const, true /* FIXME: To avoid CheckAggregationLevel issue for non-const TypeOf. */); 
     }
 
 private:
@@ -1992,7 +1992,7 @@ public:
         : INode(pos)
         , Module(module)
         , Name(name)
-        , Args(args)
+        , Args(args) 
         , ForReduce(forReduce)
     {}
 
diff --git a/ydb/library/yql/sql/v1/context.cpp b/ydb/library/yql/sql/v1/context.cpp
index c08fe96cae..cebdbcbd77 100644
--- a/ydb/library/yql/sql/v1/context.cpp
+++ b/ydb/library/yql/sql/v1/context.cpp
@@ -3,11 +3,11 @@
 #include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
 #include <ydb/library/yql/utils/yql_panic.h>
 #include <ydb/library/yql/utils/yql_paths.h>
-
-#include <util/folder/pathsplit.h>
+ 
+#include <util/folder/pathsplit.h> 
 #include <util/string/join.h>
 #include <util/stream/null.h>
-
+ 
 #ifdef GetMessage
 #undef GetMessage
 #endif
@@ -16,14 +16,14 @@ using namespace NYql;
 
 namespace NSQLTranslationV1 {
 
-namespace {
-
+namespace { 
+ 
 TNodePtr AddTablePathPrefix(TContext& ctx, TStringBuf prefixPath, const TDeferredAtom& path) {
     Y_UNUSED(ctx);
-    if (prefixPath.empty()) {
+    if (prefixPath.empty()) { 
         return path.Build();
-    }
-
+    } 
+ 
     if (path.GetLiteral()) {
         return BuildQuotedAtom(path.Build()->GetPos(), BuildTablePath(prefixPath, *path.GetLiteral()));
     }
@@ -31,14 +31,14 @@ TNodePtr AddTablePathPrefix(TContext& ctx, TStringBuf prefixPath, const TDeferre
     auto pathNode = path.Build();
     pathNode = new TCallNodeImpl(pathNode->GetPos(), "String", { pathNode });
     auto prefixNode = BuildLiteralRawString(pathNode->GetPos(), TString(prefixPath));
-
+ 
     TNodePtr buildPathNode = new TCallNodeImpl(pathNode->GetPos(), "BuildTablePath", { prefixNode, pathNode });
-
+ 
     TDeferredAtom result;
     MakeTableFromExpression(ctx, buildPathNode, result);
     return result.Build();
-}
-
+} 
+ 
 typedef bool TContext::*TPragmaField;
 
 THashMap<TStringBuf, TPragmaField> CTX_PRAGMA_FIELDS = {
@@ -63,17 +63,17 @@ THashMap<TStringBuf, TPragmaMaybeField> CTX_PRAGMA_MAYBE_FIELDS = {
     {"AnsiInForEmptyOrNullableItemsCollections", &TContext::AnsiInForEmptyOrNullableItemsCollections},
 };
 
-} // namespace
-
+} // namespace 
+ 
 TContext::TContext(const NSQLTranslation::TTranslationSettings& settings,
                    TIssues& issues)
     : ClusterMapping(settings.ClusterMapping)
-    , PathPrefix(settings.PathPrefix)
-    , ClusterPathPrefixes(settings.ClusterPathPrefixes)
-    , Settings(settings)
+    , PathPrefix(settings.PathPrefix) 
+    , ClusterPathPrefixes(settings.ClusterPathPrefixes) 
+    , Settings(settings) 
     , Pool(new TMemoryPool(4096))
     , Issues(issues)
-    , IncrementMonCounterFunction(settings.IncrementCounter)
+    , IncrementMonCounterFunction(settings.IncrementCounter) 
     , HasPendingErrors(false)
     , DqEngineEnable(Settings.DqDefaultAuto->Allow())
     , AnsiQuotedIdentifiers(settings.AnsiLexer)
@@ -190,7 +190,7 @@ IOutputStream& TContext::MakeIssue(ESeverity severity, TIssueCode code, NYql::TP
         }
     }
 
-    Issues.AddIssue(TIssue(pos, TString()));
+    Issues.AddIssue(TIssue(pos, TString())); 
     auto& curIssue = Issues.back();
     curIssue.Severity = severity;
     curIssue.IssueCode = code;
@@ -199,47 +199,47 @@ IOutputStream& TContext::MakeIssue(ESeverity severity, TIssueCode code, NYql::TP
 }
 
 bool TContext::SetPathPrefix(const TString& value, TMaybe<TString> arg) {
-    if (arg.Defined()) {
+    if (arg.Defined()) { 
         if (*arg == YtProviderName
             || *arg == KikimrProviderName
             || *arg == RtmrProviderName
             )
-        {
-            ProviderPathPrefixes[*arg] = value;
-            return true;
-        }
-
+        { 
+            ProviderPathPrefixes[*arg] = value; 
+            return true; 
+        } 
+ 
         TString normalizedClusterName;
         if (!GetClusterProvider(*arg, normalizedClusterName)) {
             Error() << "Unknown cluster or provider: " << *arg;
-            IncrementMonCounter("sql_errors", "BadPragmaValue");
-            return false;
-        }
-
+            IncrementMonCounter("sql_errors", "BadPragmaValue"); 
+            return false; 
+        } 
+ 
         ClusterPathPrefixes[normalizedClusterName] = value;
-    } else {
-        PathPrefix = value;
-    }
-
-    return true;
-}
-
+    } else { 
+        PathPrefix = value; 
+    } 
+ 
+    return true; 
+} 
+ 
 TNodePtr TContext::GetPrefixedPath(const TString& service, const TDeferredAtom& cluster, const TDeferredAtom& path) {
     auto* clusterPrefix = cluster.GetLiteral() ? ClusterPathPrefixes.FindPtr(*cluster.GetLiteral()) : nullptr;
-    if (clusterPrefix && !clusterPrefix->empty()) {
-        return AddTablePathPrefix(*this, *clusterPrefix, path);
-    } else {
+    if (clusterPrefix && !clusterPrefix->empty()) { 
+        return AddTablePathPrefix(*this, *clusterPrefix, path); 
+    } else { 
         auto* providerPrefix = ProviderPathPrefixes.FindPtr(service);
-        if (providerPrefix && !providerPrefix->empty()) {
-            return AddTablePathPrefix(*this, *providerPrefix, path);
+        if (providerPrefix && !providerPrefix->empty()) { 
+            return AddTablePathPrefix(*this, *providerPrefix, path); 
         } else if (!PathPrefix.empty()) {
-            return AddTablePathPrefix(*this, PathPrefix, path);
-        }
-
+            return AddTablePathPrefix(*this, PathPrefix, path); 
+        } 
+ 
         return path.Build();
-    }
-}
-
+    } 
+} 
+ 
 TNodePtr TContext::UniversalAlias(const TString& baseName, TNodePtr&& node) {
     auto alias = MakeName(baseName);
     UniversalAliases.emplace(alias, node);
@@ -494,13 +494,13 @@ TString TTranslation::PushNamedNode(TPosition namePos, const TString& name, cons
     if (mapIt == Ctx.Scoped->NamedNodes.end()) {
         auto result = Ctx.Scoped->NamedNodes.insert(std::make_pair(resultName, TDeque<TNodeWithUsageInfoPtr>()));
         Y_VERIFY_DEBUG(result.second);
-        mapIt = result.first;
+        mapIt = result.first; 
     }
-
+ 
     mapIt->second.push_front(MakeIntrusive<TNodeWithUsageInfo>(node, namePos, Ctx.ScopeLevel));
     return resultName;
-}
-
+} 
+ 
 TString TTranslation::PushNamedNode(NYql::TPosition namePos, const TString &name, NSQLTranslationV1::TNodePtr node) {
     return PushNamedNode(namePos, name, [node](const TString&) { return node; });
 }
@@ -521,7 +521,7 @@ void TTranslation::PopNamedNode(const TString& name) {
         Ctx.Warning(top->NamePos, TIssuesIds::YQL_UNUSED_SYMBOL) << "Symbol " << name << " is not used";
     }
     mapIt->second.pop_front();
-    if (mapIt->second.empty()) {
+    if (mapIt->second.empty()) { 
         Ctx.Scoped->NamedNodes.erase(mapIt);
     }
 }
diff --git a/ydb/library/yql/sql/v1/context.h b/ydb/library/yql/sql/v1/context.h
index 8951757486..91e30ce172 100644
--- a/ydb/library/yql/sql/v1/context.h
+++ b/ydb/library/yql/sql/v1/context.h
@@ -1,8 +1,8 @@
 #pragma once
 
-#include "node.h"
-#include "sql.h"
-
+#include "node.h" 
+#include "sql.h" 
+ 
 #include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
 #include <ydb/library/yql/core/issue/protos/issue_id.pb.h>
 #include <ydb/library/yql/public/issue/yql_warning.h>
@@ -11,7 +11,7 @@
 
 #include <util/generic/hash.h>
 #include <util/generic/map.h>
-#include <util/generic/maybe.h>
+#include <util/generic/maybe.h> 
 #include <util/generic/set.h>
 #include <util/generic/deque.h>
 #include <util/generic/vector.h>
@@ -136,16 +136,16 @@ namespace NSQLTranslationV1 {
             }
 
             return provider;
-        }
-
+        } 
+ 
         bool HasNonYtProvider(const ISource& source) const;
         bool UseUnordered(const ISource& source) const;
         bool UseUnordered(const TTableRef& table) const;
 
         bool SetPathPrefix(const TString& value, TMaybe<TString> arg = TMaybe<TString>());
-
+ 
         TNodePtr GetPrefixedPath(const TString& service, const TDeferredAtom& cluster, const TDeferredAtom& path);
-
+ 
         TNodePtr UniversalAlias(const TString& baseName, TNodePtr&& node);
 
         void BodyPart() {
@@ -190,8 +190,8 @@ namespace NSQLTranslationV1 {
         THolder<TStringOutput> IssueMsgHolder;
         NSQLTranslation::TClusterMapping ClusterMapping;
         TString PathPrefix;
-        THashMap<TString, TString> ProviderPathPrefixes;
-        THashMap<TString, TString> ClusterPathPrefixes;
+        THashMap<TString, TString> ProviderPathPrefixes; 
+        THashMap<TString, TString> ClusterPathPrefixes; 
         bool IntoHeading = true;
 
         friend class TColumnRefScope;
diff --git a/ydb/library/yql/sql/v1/insert.cpp b/ydb/library/yql/sql/v1/insert.cpp
index 4f4c863018..6c64026384 100644
--- a/ydb/library/yql/sql/v1/insert.cpp
+++ b/ydb/library/yql/sql/v1/insert.cpp
@@ -2,16 +2,16 @@
 #include "context.h"
 
 #include <ydb/library/yql/utils/yql_panic.h>
-
+ 
 using namespace NYql;
 
 namespace NSQLTranslationV1 {
 
 static const TMap<ESQLWriteColumnMode, EWriteColumnMode> sqlIntoMode2WriteColumn = {
-    {ESQLWriteColumnMode::InsertInto, EWriteColumnMode::Insert},
-    {ESQLWriteColumnMode::InsertOrAbortInto, EWriteColumnMode::InsertOrAbort},
-    {ESQLWriteColumnMode::InsertOrIgnoreInto, EWriteColumnMode::InsertOrIgnore},
-    {ESQLWriteColumnMode::InsertOrRevertInto, EWriteColumnMode::InsertOrRevert},
+    {ESQLWriteColumnMode::InsertInto, EWriteColumnMode::Insert}, 
+    {ESQLWriteColumnMode::InsertOrAbortInto, EWriteColumnMode::InsertOrAbort}, 
+    {ESQLWriteColumnMode::InsertOrIgnoreInto, EWriteColumnMode::InsertOrIgnore}, 
+    {ESQLWriteColumnMode::InsertOrRevertInto, EWriteColumnMode::InsertOrRevert}, 
     {ESQLWriteColumnMode::UpsertInto, EWriteColumnMode::Upsert},
     {ESQLWriteColumnMode::ReplaceInto, EWriteColumnMode::Replace},
     {ESQLWriteColumnMode::InsertIntoWithTruncate, EWriteColumnMode::Renew},
@@ -84,18 +84,18 @@ public:
 
     TNodePtr Build(TContext& ctx) override {
         Y_UNUSED(ctx);
-        YQL_ENSURE(Values.size() == ColumnsHint.size());
-
+        YQL_ENSURE(Values.size() == ColumnsHint.size()); 
+ 
         auto structObj = Y("AsStruct");
-        for (size_t i = 0; i < Values.size(); ++i) {
+        for (size_t i = 0; i < Values.size(); ++i) { 
             TString column = ColumnsHint[i];
-            TNodePtr value = Values[i];
-
+            TNodePtr value = Values[i]; 
+ 
             structObj = L(structObj, Q(Y(Q(column), value)));
         }
-
+ 
         auto updateRow = BuildLambda(Pos, Y("row"), structObj);
-        return updateRow;
+        return updateRow; 
     }
 
     TNodePtr DoClone() const final {
@@ -122,11 +122,11 @@ public:
         Y_UNUSED(src);
         bool hasError = false;
         for (const auto& row: Values) {
-            if (ColumnsHint.empty()) {
-                ctx.Error(Pos) << OperationHumanName << " ... VALUES requires specification of table columns";
+            if (ColumnsHint.empty()) { 
+                ctx.Error(Pos) << OperationHumanName << " ... VALUES requires specification of table columns"; 
                 hasError = true;
                 continue;
-            }
+            } 
             if (ColumnsHint.size() != row.size()) {
                 ctx.Error(Pos) << "VALUES have " << row.size() << " columns, " << OperationHumanName << " expects: " << ColumnsHint.size();
                 hasError = true;
@@ -144,7 +144,7 @@ public:
 
     TNodePtr Build(TContext& ctx) override {
         Y_UNUSED(ctx);
-        auto tuple = Y();
+        auto tuple = Y(); 
         for (const auto& row: Values) {
             auto rowValues = Y("AsStruct"); // ordered struct
             auto column = ColumnsHint.begin();
@@ -152,7 +152,7 @@ public:
                 rowValues = L(rowValues, Q(Y(BuildQuotedAtom(Pos, *column), value)));
                 ++column;
             }
-            tuple = L(tuple, rowValues);
+            tuple = L(tuple, rowValues); 
         }
         return Y("PersistableRepr", Q(tuple));
     }
@@ -281,8 +281,8 @@ public:
 
     void ResetUpdate(TSourcePtr update) {
         Update = std::move(update);
-    }
-
+    } 
+ 
     bool DoInit(TContext& ctx, ISource* src) override {
         TTableList tableList;
         TNodePtr values;
@@ -295,20 +295,20 @@ public:
         }
 
         ISource* underlyingSrc = src;
-
+ 
         if (TableSource) {
             if (!TableSource->Init(ctx, src) || !TableSource->InitFilters(ctx)) {
-                return false;
-            }
+                return false; 
+            } 
             options = L(options, Q(Y(Q("filter"), TableSource->BuildFilterLambda())));
-        }
-
+        } 
+ 
         bool unordered = false;
         if (Values) {
             if (!Values->Init(ctx, TableSource.Get())) {
                 return false;
             }
-
+ 
             Values->GetInputTables(tableList);
             underlyingSrc = Values.Get();
             values = Values->Build(ctx);
@@ -322,13 +322,13 @@ public:
         if (!node->Init(ctx, underlyingSrc)) {
             return false;
         }
-
-        if (Update) {
+ 
+        if (Update) { 
             if (!Update->Init(ctx, TableSource.Get()) || !Update->InitFilters(ctx)) {
                 return false;
             }
             options = L(options, Q(Y(Q("update"), Update->Build(ctx))));
-        }
+        } 
 
         auto write = BuildWriteTable(Pos, "values", Table, Mode, std::move(options), Scoped);
         if (!write->Init(ctx, FakeSource.Get())) {
@@ -339,8 +339,8 @@ public:
             if (unordered && ctx.UseUnordered(Table)) {
                 node = L(node, Y("let", "values", Y("Unordered", "values")));
             }
-        } else {
-            node = L(node, Y("let", "values", Y("Void")));
+        } else { 
+            node = L(node, Y("let", "values", Y("Void"))); 
         }
         node = L(node, Y("let", "world", write));
         node = L(node, Y("return", "world"));
@@ -359,7 +359,7 @@ protected:
     TSourcePtr TableSource;
     EWriteColumnMode Mode;
     TSourcePtr Values;
-    TSourcePtr Update;
+    TSourcePtr Update; 
     TSourcePtr FakeSource;
     TNodePtr Options;
 };
diff --git a/ydb/library/yql/sql/v1/join.cpp b/ydb/library/yql/sql/v1/join.cpp
index 29f5b3ec4b..59d3a76e16 100644
--- a/ydb/library/yql/sql/v1/join.cpp
+++ b/ydb/library/yql/sql/v1/join.cpp
@@ -2,7 +2,7 @@
 #include "context.h"
 
 #include <ydb/library/yql/utils/yql_panic.h>
-
+ 
 #include <library/cpp/charset/ci_string.h>
 #include <util/generic/hash_set.h>
 #include <util/string/cast.h>
diff --git a/ydb/library/yql/sql/v1/node.cpp b/ydb/library/yql/sql/v1/node.cpp
index 870bbd9cc7..3d942b0bad 100644
--- a/ydb/library/yql/sql/v1/node.cpp
+++ b/ydb/library/yql/sql/v1/node.cpp
@@ -2695,34 +2695,34 @@ TNodePtr BuildListOfNamedNodes(TPosition pos, TVector<TNodePtr>&& exprs) {
 }
 
 TArgPlaceholderNode::TArgPlaceholderNode(TPosition pos, const TString &name) :
-    INode(pos),
-    Name(name)
-{
-}
-
-bool TArgPlaceholderNode::DoInit(TContext& ctx, ISource* src) {
+    INode(pos), 
+    Name(name) 
+{ 
+} 
+ 
+bool TArgPlaceholderNode::DoInit(TContext& ctx, ISource* src) { 
     Y_UNUSED(src);
-    ctx.Error(Pos) << Name << " can't be used as a part of expression.";
-    return false;
-}
-
-TAstNode* TArgPlaceholderNode::Translate(TContext& ctx) const {
+    ctx.Error(Pos) << Name << " can't be used as a part of expression."; 
+    return false; 
+} 
+ 
+TAstNode* TArgPlaceholderNode::Translate(TContext& ctx) const { 
     Y_UNUSED(ctx);
-    return nullptr;
-}
-
+    return nullptr; 
+} 
+ 
 TString TArgPlaceholderNode::GetName() const {
-    return Name;
-}
-
+    return Name; 
+} 
+ 
 TNodePtr TArgPlaceholderNode::DoClone() const {
     return {};
 }
 
 TNodePtr BuildArgPlaceholder(TPosition pos, const TString& name) {
-    return new TArgPlaceholderNode(pos, name);
-}
-
+    return new TArgPlaceholderNode(pos, name); 
+} 
+ 
 class TAccessNode: public INode {
 public:
     TAccessNode(TPosition pos, const TVector<TIdPart>& ids, bool isLookup)
diff --git a/ydb/library/yql/sql/v1/node.h b/ydb/library/yql/sql/v1/node.h
index de82b45a23..1876868b07 100644
--- a/ydb/library/yql/sql/v1/node.h
+++ b/ydb/library/yql/sql/v1/node.h
@@ -43,9 +43,9 @@ namespace NSQLTranslationV1 {
 
     enum class ESQLWriteColumnMode {
         InsertInto,
-        InsertOrAbortInto,
-        InsertOrIgnoreInto,
-        InsertOrRevertInto,
+        InsertOrAbortInto, 
+        InsertOrIgnoreInto, 
+        InsertOrRevertInto, 
         UpsertInto,
         ReplaceInto,
         InsertIntoWithTruncate,
@@ -55,17 +55,17 @@ namespace NSQLTranslationV1 {
 
     enum class EWriteColumnMode {
         Default,
-        Insert,
-        InsertOrAbort,
-        InsertOrIgnore,
-        InsertOrRevert,
+        Insert, 
+        InsertOrAbort, 
+        InsertOrIgnore, 
+        InsertOrRevert, 
         Upsert,
         Replace,
         Renew,
         Update,
-        UpdateOn,
+        UpdateOn, 
         Delete,
-        DeleteOn,
+        DeleteOn, 
     };
 
     enum class EAlterTableIntentnt {
@@ -520,14 +520,14 @@ namespace NSQLTranslationV1 {
     };
 
     struct TIdentifier {
-        TPosition Pos;
+        TPosition Pos; 
         TString Name;
-
+ 
         TIdentifier(TPosition pos, const TString& name)
-            : Pos(pos)
-            , Name(name) {}
-    };
-
+            : Pos(pos) 
+            , Name(name) {} 
+    }; 
+ 
     struct TColumnSchema {
         TPosition Pos;
         TString Name;
@@ -684,22 +684,22 @@ namespace NSQLTranslationV1 {
     };
 
     class TArgPlaceholderNode final: public INode
-    {
-    public:
+    { 
+    public: 
         TArgPlaceholderNode(TPosition pos, const TString &name);
-
+ 
         TAstNode* Translate(TContext& ctx) const override;
-
+ 
         TString GetName() const;
         TNodePtr DoClone() const final;
-
-    protected:
+ 
+    protected: 
         bool DoInit(TContext& ctx, ISource* src) override;
-
-    private:
+ 
+    private: 
         TString Name;
-    };
-
+    }; 
+ 
     enum class EAggregateMode {
         Normal,
         Distinct,
@@ -1201,7 +1201,7 @@ namespace NSQLTranslationV1 {
     TNodePtr BuildListOfNamedNodes(TPosition pos, TVector<TNodePtr>&& exprs);
 
     TNodePtr BuildArgPlaceholder(TPosition pos, const TString& name);
-
+ 
     TNodePtr BuildColumn(TPosition pos, const TString& column = TString(), const TString& source = TString());
     TNodePtr BuildColumn(TPosition pos, const TNodePtr& column, const TString& source = TString());
     TNodePtr BuildColumn(TPosition pos, const TDeferredAtom& column, const TString& source = TString());
@@ -1285,7 +1285,7 @@ namespace NSQLTranslationV1 {
         TWinSpecs&& windowSpec,
         THoppingWindowSpecPtr hoppingWindowSpec,
         TVector<TNodePtr>&& terms,
-        bool distinct,
+        bool distinct, 
         TVector<TNodePtr>&& without,
         bool selectStream,
         const TWriteSettings& settings
diff --git a/ydb/library/yql/sql/v1/query.cpp b/ydb/library/yql/sql/v1/query.cpp
index 725356b9f5..677421a9c7 100644
--- a/ydb/library/yql/sql/v1/query.cpp
+++ b/ydb/library/yql/sql/v1/query.cpp
@@ -20,7 +20,7 @@ public:
         const TDeferredAtom& name, const TString& view)
         : ITableKeys(pos)
         , Service(service)
-        , Cluster(cluster)
+        , Cluster(cluster) 
         , Name(name)
         , View(view)
         , Full(name.GetRepr())
@@ -58,9 +58,9 @@ public:
             return nullptr;
         }
         auto path = ctx.GetPrefixedPath(Service, Cluster, Name);
-        if (!path) {
-            return nullptr;
-        }
+        if (!path) { 
+            return nullptr; 
+        } 
         auto key = Y("Key", Q(Y(Q(tableScheme ? "tablescheme" : "table"), Y("String", path))));
         if (!View.empty()) {
             key = L(key, Q(Y(Q("view"), Y("String", BuildQuotedAtom(Pos, View)))));
@@ -151,7 +151,7 @@ public:
         const TString& func, const TVector<TTableArg>& args)
         : ITableKeys(pos)
         , Service(service)
-        , Cluster(cluster)
+        , Cluster(cluster) 
         , Func(func)
         , Args(args)
     {
@@ -194,7 +194,7 @@ public:
                     if (!arg.View.empty()) {
                         key = L(key, Q(Y(Q("view"), Y("String", BuildQuotedAtom(Pos, arg.View)))));
                     }
-                }
+                } 
 
                 tuple = L(tuple, key);
             }
@@ -217,7 +217,7 @@ public:
                     if (!arg.View.empty()) {
                         key = L(key, Q(Y(Q("view"), Y("String", BuildQuotedAtom(Pos, arg.View)))));
                     }
-                }
+                } 
 
                 concat = L(concat, key);
             }
@@ -269,9 +269,9 @@ public:
             }
 
             auto path = ctx.GetPrefixedPath(Service, Cluster, Args[0].Id);
-            if (!path) {
-                return nullptr;
-            }
+            if (!path) { 
+                return nullptr; 
+            } 
             auto range = Y(func.EndsWith("_strict") ? "MrTableRangeStrict" : "MrTableRange", path);
             TNodePtr predicate;
             TDeferredAtom suffix;
@@ -576,7 +576,7 @@ public:
         if (!keys || !keys->Init(ctx, src)) {
             return false;
         }
-
+ 
         if (!Params.PkColumns.empty()
             || !Params.PartitionByColumns.empty()
             || !Params.OrderByColumns.empty()
@@ -585,15 +585,15 @@ public:
         {
             THashSet<TString> columnsSet;
             for (auto& col : Params.Columns) {
-                columnsSet.insert(col.Name);
-            }
-
+                columnsSet.insert(col.Name); 
+            } 
+ 
             for (auto& keyColumn : Params.PkColumns) {
                 if (!columnsSet.contains(keyColumn.Name)) {
-                    ctx.Error(keyColumn.Pos) << "Undefined column: " << keyColumn.Name;
-                    return false;
-                }
-            }
+                    ctx.Error(keyColumn.Pos) << "Undefined column: " << keyColumn.Name; 
+                    return false; 
+                } 
+            } 
             for (auto& keyColumn : Params.PartitionByColumns) {
                 if (!columnsSet.contains(keyColumn.Name)) {
                     ctx.Error(keyColumn.Pos) << "Undefined column: " << keyColumn.Name;
@@ -636,7 +636,7 @@ public:
                     return false;
                 }
             }
-        }
+        } 
         auto columns = Y();
         for (auto& col : Params.Columns) {
             auto columnDesc = Y();
@@ -683,7 +683,7 @@ public:
             for (auto& col : Params.PkColumns) {
                 primaryKey = L(primaryKey, BuildQuotedAtom(col.Pos, col.Name));
             }
-            opts = L(opts, Q(Y(Q("primarykey"), Q(primaryKey))));
+            opts = L(opts, Q(Y(Q("primarykey"), Q(primaryKey)))); 
             if (!Params.OrderByColumns.empty()) {
                 ctx.Error() << "PRIMARY KEY cannot be used with ORDER BY, use PARTITION BY instead";
                 return false;
@@ -705,7 +705,7 @@ public:
             }
             opts = L(opts, Q(Y(Q("orderby"), Q(orderBy))));
         }
-
+ 
         for (const auto& index : Params.Indexes) {
             const auto& desc = CreateIndexDesc(index, *this);
             opts = L(opts, Q(Y(Q("index"), Q(desc))));
@@ -812,7 +812,7 @@ private:
 };
 
 TNodePtr BuildCreateTable(TPosition pos, const TTableRef& tr, const TCreateTableParameters& params, TScopedStatePtr scoped)
-{
+{ 
     return new TCreateTableNode(pos, tr, params, scoped);
 }
 
@@ -1384,8 +1384,8 @@ TNodePtr BuildDropRoles(TPosition pos, const TString& service, const TDeferredAt
 
 static const TMap<EWriteColumnMode, TString> columnModeToStrMapMR {
     {EWriteColumnMode::Default, ""},
-    {EWriteColumnMode::Insert, "append"},
-    {EWriteColumnMode::Renew, "renew"}
+    {EWriteColumnMode::Insert, "append"}, 
+    {EWriteColumnMode::Renew, "renew"} 
 };
 
 static const TMap<EWriteColumnMode, TString> columnModeToStrMapStat {
@@ -1393,19 +1393,19 @@ static const TMap<EWriteColumnMode, TString> columnModeToStrMapStat {
 };
 
 static const TMap<EWriteColumnMode, TString> columnModeToStrMapKikimr {
-    {EWriteColumnMode::Default, ""},
-    {EWriteColumnMode::Insert, "insert_abort"},
-    {EWriteColumnMode::InsertOrAbort, "insert_abort"},
-    {EWriteColumnMode::InsertOrIgnore, "insert_ignore"},
-    {EWriteColumnMode::InsertOrRevert, "insert_revert"},
-    {EWriteColumnMode::Upsert, "upsert"},
-    {EWriteColumnMode::Replace, "replace"},
-    {EWriteColumnMode::Update, "update"},
-    {EWriteColumnMode::UpdateOn, "update_on"},
-    {EWriteColumnMode::Delete, "delete"},
-    {EWriteColumnMode::DeleteOn, "delete_on"},
-};
-
+    {EWriteColumnMode::Default, ""}, 
+    {EWriteColumnMode::Insert, "insert_abort"}, 
+    {EWriteColumnMode::InsertOrAbort, "insert_abort"}, 
+    {EWriteColumnMode::InsertOrIgnore, "insert_ignore"}, 
+    {EWriteColumnMode::InsertOrRevert, "insert_revert"}, 
+    {EWriteColumnMode::Upsert, "upsert"}, 
+    {EWriteColumnMode::Replace, "replace"}, 
+    {EWriteColumnMode::Update, "update"}, 
+    {EWriteColumnMode::UpdateOn, "update_on"}, 
+    {EWriteColumnMode::Delete, "delete"}, 
+    {EWriteColumnMode::DeleteOn, "delete_on"}, 
+}; 
+ 
 class TWriteTableNode final: public TAstListNode {
 public:
     TWriteTableNode(TPosition pos, const TString& label, const TTableRef& table, EWriteColumnMode mode,
@@ -1414,7 +1414,7 @@ public:
         , Label(label)
         , Table(table)
         , Mode(mode)
-        , Options(options)
+        , Options(options) 
         , Scoped(scoped)
     {
         scoped->UseCluster(Table.Service, Table.Cluster);
@@ -1425,18 +1425,18 @@ public:
         if (!keys || !keys->Init(ctx, src)) {
             return false;
         }
-
+ 
         auto getModesMap = [] (const TString& serviceName) -> const TMap<EWriteColumnMode, TString>& {
             if (serviceName == KikimrProviderName || serviceName == YdbProviderName) {
-                return columnModeToStrMapKikimr;
+                return columnModeToStrMapKikimr; 
             } else if (serviceName == StatProviderName) {
                 return columnModeToStrMapStat;
-            } else {
-                return columnModeToStrMapMR;
-            }
-        };
-
-        auto options = Y();
+            } else { 
+                return columnModeToStrMapMR; 
+            } 
+        }; 
+ 
+        auto options = Y(); 
         if (Options) {
             if (!Options->Init(ctx, src)) {
                 return false;
@@ -1445,12 +1445,12 @@ public:
             options = L(Options);
         }
 
-        if (Mode != EWriteColumnMode::Default) {
+        if (Mode != EWriteColumnMode::Default) { 
             auto modeStr = getModesMap(Table.Service).FindPtr(Mode);
-
-            options->Add(Q(Y(Q("mode"), Q(modeStr ? *modeStr : "unsupported"))));
-        }
-
+ 
+            options->Add(Q(Y(Q("mode"), Q(modeStr ? *modeStr : "unsupported")))); 
+        } 
+ 
         Add("block", Q((Y(
             Y("let", "sink", Y("DataSink", BuildQuotedAtom(Pos, Table.Service), Scoped->WrapCluster(Table.Cluster, ctx))),
             Y("let", "world", Y(TString(WriteName), "world", "sink", keys, Label, Q(options))),
@@ -1473,70 +1473,70 @@ private:
 
 TNodePtr BuildWriteTable(TPosition pos, const TString& label, const TTableRef& table, EWriteColumnMode mode, TNodePtr options,
     TScopedStatePtr scoped)
-{
+{ 
     return new TWriteTableNode(pos, label, table, mode, std::move(options), scoped);
 }
 
-class TClustersSinkOperationBase: public TAstListNode {
-protected:
+class TClustersSinkOperationBase: public TAstListNode { 
+protected: 
     TClustersSinkOperationBase(TPosition pos)
         : TAstListNode(pos)
     {}
 
     virtual TPtr ProduceOperation() = 0;
 
-    bool DoInit(TContext& ctx, ISource* src) override {
+    bool DoInit(TContext& ctx, ISource* src) override { 
         auto block(Y());
-
+ 
         auto op = ProduceOperation();
         if (!op) {
             return false;
         }
-
+ 
         block = L(block, op);
         block = L(block, Y("return", "world"));
         Add("block", Q(block));
-
+ 
         return TAstListNode::DoInit(ctx, src);
-     }
+     } 
 
     TPtr DoClone() const final {
         return {};
     }
 };
 
-class TCommitClustersNode: public TClustersSinkOperationBase {
-public:
+class TCommitClustersNode: public TClustersSinkOperationBase { 
+public: 
     TCommitClustersNode(TPosition pos)
         : TClustersSinkOperationBase(pos)
     {
     }
-
+ 
     TPtr ProduceOperation() override {
         return Y("let", "world", Y("CommitAll!", "world"));
-    }
-};
-
+    } 
+}; 
+ 
 TNodePtr BuildCommitClusters(TPosition pos) {
     return new TCommitClustersNode(pos);
 }
 
-class TRollbackClustersNode: public TClustersSinkOperationBase {
-public:
+class TRollbackClustersNode: public TClustersSinkOperationBase { 
+public: 
     TRollbackClustersNode(TPosition pos)
         : TClustersSinkOperationBase(pos)
     {
     }
-
+ 
     TPtr ProduceOperation() override {
         return Y("let", "world", Y("CommitAll!", "world", Q(Y(Q(Y(Q("mode"), Q("rollback")))))));
-    }
-};
-
+    } 
+}; 
+ 
 TNodePtr BuildRollbackClusters(TPosition pos) {
     return new TRollbackClustersNode(pos);
-}
-
+} 
+ 
 class TWriteResultNode final: public TAstListNode {
 public:
     TWriteResultNode(TPosition pos, const TString& label, TNodePtr settings)
diff --git a/ydb/library/yql/sql/v1/select.cpp b/ydb/library/yql/sql/v1/select.cpp
index 2841f05a5b..0f80f668d3 100644
--- a/ydb/library/yql/sql/v1/select.cpp
+++ b/ydb/library/yql/sql/v1/select.cpp
@@ -5,7 +5,7 @@
 
 #include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
 #include <ydb/library/yql/utils/yql_panic.h>
-
+ 
 #include <library/cpp/charset/ci_string.h>
 
 using namespace NYql;
@@ -252,44 +252,44 @@ TSourcePtr BuildFakeSource(TPosition pos, bool missingFrom) {
     return new TFakeSource(pos, missingFrom);
 }
 
-class TNodeSource: public ISource {
-public:
+class TNodeSource: public ISource { 
+public: 
     TNodeSource(TPosition pos, const TNodePtr& node, bool wrapToList)
-        : ISource(pos)
-        , Node(node)
+        : ISource(pos) 
+        , Node(node) 
         , WrapToList(wrapToList)
-    {
-        YQL_ENSURE(Node);
+    { 
+        YQL_ENSURE(Node); 
         FakeSource = BuildFakeSource(pos);
-    }
-
-    void AllColumns() final {
-        UseAllColumns = true;
-    }
-
+    } 
+ 
+    void AllColumns() final { 
+        UseAllColumns = true; 
+    } 
+ 
     bool ShouldUseSourceAsColumn(const TString& source) const final {
         return source && source != GetLabel();
     }
 
-    TMaybe<bool> AddColumn(TContext& ctx, TColumnNode& column) final {
+    TMaybe<bool> AddColumn(TContext& ctx, TColumnNode& column) final { 
         Y_UNUSED(ctx);
-        if (UseAllColumns) {
-            return true;
-        }
-
-        if (column.IsAsterisk()) {
-            AllColumns();
-        } else {
+        if (UseAllColumns) { 
+            return true; 
+        } 
+ 
+        if (column.IsAsterisk()) { 
+            AllColumns(); 
+        } else { 
             if (column.GetColumnName()) {
                 Columns.insert(*column.GetColumnName());
             } else {
                 AllColumns();
             }
-        }
-
-        return true;
-    }
-
+        } 
+ 
+        return true; 
+    } 
+ 
     bool DoInit(TContext& ctx, ISource* src) final {
         if (!Node->Init(ctx, FakeSource.Get())) {
             return false;
@@ -297,40 +297,40 @@ public:
         return ISource::DoInit(ctx, src);
     }
 
-    TNodePtr Build(TContext& ctx) final  {
+    TNodePtr Build(TContext& ctx) final  { 
         auto nodeAst = AstNode(Node);
         if (WrapToList) {
             nodeAst = Y("ToList", nodeAst);
         }
-
-        if (UseAllColumns) {
-            return nodeAst;
-        } else {
-            auto members = Y();
-            for (auto& column : Columns) {
-                members = L(members, BuildQuotedAtom(Pos, column));
-            }
-
+ 
+        if (UseAllColumns) { 
+            return nodeAst; 
+        } else { 
+            auto members = Y(); 
+            for (auto& column : Columns) { 
+                members = L(members, BuildQuotedAtom(Pos, column)); 
+            } 
+ 
             return Y(ctx.UseUnordered(*this) ? "OrderedMap" : "Map", nodeAst, BuildLambda(Pos, Y("row"), Y("SelectMembers", "row", Q(members))));
-        }
-    }
-
-    TPtr DoClone() const final {
+        } 
+    } 
+ 
+    TPtr DoClone() const final { 
         return new TNodeSource(Pos, SafeClone(Node), WrapToList);
-    }
-
-private:
-    TNodePtr Node;
+    } 
+ 
+private: 
+    TNodePtr Node; 
     bool WrapToList;
     TSourcePtr FakeSource;
     TSet<TString> Columns;
-    bool UseAllColumns = false;
-};
-
+    bool UseAllColumns = false; 
+}; 
+ 
 TSourcePtr BuildNodeSource(TPosition pos, const TNodePtr& node, bool wrapToList) {
     return new TNodeSource(pos, node, wrapToList);
-}
-
+} 
+ 
 class IProxySource: public ISource {
 protected:
     IProxySource(TPosition pos, ISource* src)
@@ -1402,7 +1402,7 @@ public:
         TWinSpecs& winSpecs,
         THoppingWindowSpecPtr hoppingWindowSpec,
         const TVector<TNodePtr>& terms,
-        bool distinct,
+        bool distinct, 
         const TVector<TNodePtr>& without,
         bool selectStream,
         const TWriteSettings& settings
@@ -2463,7 +2463,7 @@ TSourcePtr DoBuildSelectCore(
     TWinSpecs&& winSpecs,
     THoppingWindowSpecPtr hoppingWindowSpec,
     TVector<TNodePtr>&& terms,
-    bool distinct,
+    bool distinct, 
     TVector<TNodePtr>&& without,
     bool selectStream,
     const TWriteSettings& settings
diff --git a/ydb/library/yql/sql/v1/sql.cpp b/ydb/library/yql/sql/v1/sql.cpp
index ab5a864788..1c1c4c3aa8 100644
--- a/ydb/library/yql/sql/v1/sql.cpp
+++ b/ydb/library/yql/sql/v1/sql.cpp
@@ -1,6 +1,6 @@
 #include "sql.h"
-
-#include "context.h"
+ 
+#include "context.h" 
 #include "node.h"
 #include "sql_call_param.h"
 #include "ydb/library/yql/ast/yql_ast.h"
@@ -20,7 +20,7 @@
 #include <ydb/library/yql/core/yql_atom_enums.h>
 
 #include <library/cpp/charset/ci_string.h>
-
+ 
 #include <google/protobuf/repeated_field.h>
 
 #include <util/charset/wide.h>
@@ -50,10 +50,10 @@ using NALPDefault::SQLv1LexerTokens;
 
 using namespace NSQLv1Generated;
 
-static TPosition GetPos(const TToken& token) {
-    return TPosition(token.GetColumn(), token.GetLine());
-}
-
+static TPosition GetPos(const TToken& token) { 
+    return TPosition(token.GetColumn(), token.GetLine()); 
+} 
+ 
 template <typename TToken>
 TIdentifier GetIdentifier(TTranslation& ctx, const TToken& node) {
     auto token = node.GetToken1();
@@ -3481,7 +3481,7 @@ public:
     }
 
     TSourcePtr Build(const TRule_select_stmt& node, TPosition& selectPos);
-    TSourcePtr Build(const TRule_select_unparenthesized_stmt& node, TPosition& selectPos);
+    TSourcePtr Build(const TRule_select_unparenthesized_stmt& node, TPosition& selectPos); 
 
 private:
     bool SelectTerm(TVector<TNodePtr>& terms, const TRule_result_column& node);
@@ -5456,8 +5456,8 @@ TNodePtr TSqlExpression::SmartParenthesis(const TRule_smart_parenthesis& node) {
 }
 
 TNodePtr TSqlTranslation::NamedNode(const TRule_named_nodes_stmt& rule, TVector<TSymbolNameWithPos>& names) {
-    // named_nodes_stmt: bind_parameter_list EQUALS (expr | subselect_stmt);
-    // subselect_stmt: (LPAREN select_stmt RPAREN | select_unparenthesized_stmt);
+    // named_nodes_stmt: bind_parameter_list EQUALS (expr | subselect_stmt); 
+    // subselect_stmt: (LPAREN select_stmt RPAREN | select_unparenthesized_stmt); 
     if (!BindList(rule.GetRule_bind_parameter_list1(), names)) {
         return {};
     }
@@ -5470,31 +5470,31 @@ TNodePtr TSqlTranslation::NamedNode(const TRule_named_nodes_stmt& rule, TVector<
         return result;
     }
 
-    case TRule_named_nodes_stmt::TBlock3::kAlt2:{
-        const auto& subselect_rule = rule.GetBlock3().GetAlt2().GetRule_subselect_stmt1();
-
+    case TRule_named_nodes_stmt::TBlock3::kAlt2:{ 
+        const auto& subselect_rule = rule.GetBlock3().GetAlt2().GetRule_subselect_stmt1(); 
+ 
         TSqlSelect expr(Ctx, Mode);
         TPosition pos;
-        TSourcePtr source = nullptr;
-        switch (subselect_rule.GetBlock1().Alt_case()) {
-            case TRule_subselect_stmt::TBlock1::kAlt1:
-                source = expr.Build(subselect_rule.GetBlock1().GetAlt1().GetRule_select_stmt2(), pos);
-                break;
-
-            case TRule_subselect_stmt::TBlock1::kAlt2:
-                source = expr.Build(subselect_rule.GetBlock1().GetAlt2().GetRule_select_unparenthesized_stmt1(), pos);
-                break;
-
-            default:
-                AltNotImplemented("subselect_stmt", subselect_rule.GetBlock1());
-                Ctx.IncrementMonCounter("sql_errors", "UnknownNamedNode");
-                return nullptr;
-        }
-
+        TSourcePtr source = nullptr; 
+        switch (subselect_rule.GetBlock1().Alt_case()) { 
+            case TRule_subselect_stmt::TBlock1::kAlt1: 
+                source = expr.Build(subselect_rule.GetBlock1().GetAlt1().GetRule_select_stmt2(), pos); 
+                break; 
+ 
+            case TRule_subselect_stmt::TBlock1::kAlt2: 
+                source = expr.Build(subselect_rule.GetBlock1().GetAlt2().GetRule_select_unparenthesized_stmt1(), pos); 
+                break; 
+ 
+            default: 
+                AltNotImplemented("subselect_stmt", subselect_rule.GetBlock1()); 
+                Ctx.IncrementMonCounter("sql_errors", "UnknownNamedNode"); 
+                return nullptr; 
+        } 
+ 
         if (!source) {
             return {};
         }
-
+ 
         return BuildSourceNode(pos, std::move(source));
     }
 
@@ -5979,21 +5979,21 @@ TSourcePtr TSqlSelect::SingleSource(const TRule_single_source& node, const TVect
     switch (node.Alt_case()) {
         case TRule_single_source::kAltSingleSource1: {
             const auto& alt = node.GetAlt_single_source1();
-            const auto& table_ref = alt.GetRule_table_ref1();
-
+            const auto& table_ref = alt.GetRule_table_ref1(); 
+ 
             if (auto maybeSource = AsTableImpl(table_ref)) {
-                auto source = *maybeSource;
-                if (!source) {
-                    return nullptr;
-                }
-
-                return source;
-            } else {
+                auto source = *maybeSource; 
+                if (!source) { 
+                    return nullptr; 
+                } 
+ 
+                return source; 
+            } else { 
                 TTableRef table;
                 if (!TableRefImpl(alt.GetRule_table_ref1(), table, unorderedSubquery)) {
-                    return nullptr;
-                }
-
+                    return nullptr; 
+                } 
+ 
                 if (table.Source) {
                     return table.Source;
                 }
@@ -6373,7 +6373,7 @@ TSourcePtr TSqlSelect::ProcessCore(const TRule_process_core& node, const TWriteS
         return nullptr;
     }
 
-    bool listCall = false;
+    bool listCall = false; 
     TSqlCallExpr call(Ctx, Mode);
     bool initRet = call.Init(block5.GetRule_using_call_expr2());
     if (initRet) {
@@ -6383,18 +6383,18 @@ TSourcePtr TSqlSelect::ProcessCore(const TRule_process_core& node, const TWriteS
     if (!initRet) {
         return nullptr;
     }
-
-    auto args = call.GetArgs();
+ 
+    auto args = call.GetArgs(); 
     for (auto& arg: args) {
         if (auto placeholder = dynamic_cast<TTableRows*>(arg.Get())) {
             if (listCall) {
                 Ctx.Error() << "Only one TableRows() argument is allowed.";
                 return nullptr;
-            }
+            } 
             listCall = true;
-        }
-    }
-
+        } 
+    } 
+ 
     if (!call.IsExternal() && block5.HasBlock4()) {
         Ctx.Error() << "PROCESS without USING EXTERNAL FUNCTION doesn't allow WITH block";
         return nullptr;
@@ -6407,7 +6407,7 @@ TSourcePtr TSqlSelect::ProcessCore(const TRule_process_core& node, const TWriteS
         }
     }
 
-    TSqlCallExpr finalCall(call, args);
+    TSqlCallExpr finalCall(call, args); 
     TNodePtr with(finalCall.IsExternal() ? finalCall.BuildCall() : finalCall.BuildUdf(/* forReduce = */ false));
     if (!with) {
         return {};
@@ -7628,9 +7628,9 @@ TSqlSelect::TSelectKindResult TSqlSelect::SelectKind(const TRule_select_kind_par
     }
 }
 
-template<typename TRule>
+template<typename TRule> 
 TSourcePtr TSqlSelect::Build(const TRule& node, TPosition pos, TSelectKindResult&& first) {
-    TPosition unionPos = pos; // Position of first select
+    TPosition unionPos = pos; // Position of first select 
     TVector<TSourcePtr> sources;
     sources.emplace_back(std::move(first.Source));
 
@@ -7710,7 +7710,7 @@ TSourcePtr TSqlSelect::Build(const TRule& node, TPosition pos, TSelectKindResult
     return result;
 }
 
-TSourcePtr TSqlSelect::Build(const TRule_select_stmt& node, TPosition& selectPos) {
+TSourcePtr TSqlSelect::Build(const TRule_select_stmt& node, TPosition& selectPos) { 
     TMaybe<TSelectKindPlacement> placement;
     if (!node.GetBlock2().empty()) {
         placement.ConstructInPlace();
@@ -7718,14 +7718,14 @@ TSourcePtr TSqlSelect::Build(const TRule_select_stmt& node, TPosition& selectPos
     }
 
     auto res = SelectKind(node.GetRule_select_kind_parenthesis1(), selectPos, placement);
-    if (!res) {
-        return nullptr;
-    }
-
-    return Build(node, selectPos, std::move(res));
-}
-
-TSourcePtr TSqlSelect::Build(const TRule_select_unparenthesized_stmt& node, TPosition& selectPos) {
+    if (!res) { 
+        return nullptr; 
+    } 
+ 
+    return Build(node, selectPos, std::move(res)); 
+} 
+ 
+TSourcePtr TSqlSelect::Build(const TRule_select_unparenthesized_stmt& node, TPosition& selectPos) { 
     TMaybe<TSelectKindPlacement> placement;
     if (!node.GetBlock2().empty()) {
         placement.ConstructInPlace();
@@ -7733,13 +7733,13 @@ TSourcePtr TSqlSelect::Build(const TRule_select_unparenthesized_stmt& node, TPos
     }
 
     auto res = SelectKind(node.GetRule_select_kind_partial1(), selectPos, placement);
-    if (!res) {
-        return nullptr;
-    }
-
-    return Build(node, selectPos, std::move(res));
-}
-
+    if (!res) { 
+        return nullptr; 
+    } 
+ 
+    return Build(node, selectPos, std::move(res)); 
+} 
+ 
 TSourcePtr TSqlValues::Build(const TRule_values_stmt& node, TPosition& valuesPos, const TVector<TString>& derivedColumns, TPosition derivedColumnsPos) {
     Token(node.GetToken1());
     valuesPos = Ctx.Pos();
@@ -7822,33 +7822,33 @@ public:
     {
     }
 
-    TSourcePtr Build(const TRule_into_values_source& node, const TString& operationName);
+    TSourcePtr Build(const TRule_into_values_source& node, const TString& operationName); 
 
 private:
-    TSourcePtr ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint,
-        const TString& operationName);
+    TSourcePtr ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint, 
+        const TString& operationName); 
 };
 
-TSourcePtr TSqlIntoValues::Build(const TRule_into_values_source& node, const TString& operationName) {
-    switch (node.Alt_case()) {
-        case TRule_into_values_source::kAltIntoValuesSource1: {
-            auto alt = node.GetAlt_into_values_source1();
-            TVector<TString> columnsHint;
-            if (alt.HasBlock1()) {
-                PureColumnListStr(alt.GetBlock1().GetRule_pure_column_list1(), *this, columnsHint);
-            }
-            return ValuesSource(alt.GetRule_values_source2(), columnsHint, operationName);
-        }
-        default:
-            Ctx.IncrementMonCounter("sql_errors", "DefaultValuesOrOther");
-            AltNotImplemented("into_values_source", node);
-            return nullptr;
-    }
-}
-
-TSourcePtr TSqlIntoValues::ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint,
-    const TString& operationName)
-{
+TSourcePtr TSqlIntoValues::Build(const TRule_into_values_source& node, const TString& operationName) { 
+    switch (node.Alt_case()) { 
+        case TRule_into_values_source::kAltIntoValuesSource1: { 
+            auto alt = node.GetAlt_into_values_source1(); 
+            TVector<TString> columnsHint; 
+            if (alt.HasBlock1()) { 
+                PureColumnListStr(alt.GetBlock1().GetRule_pure_column_list1(), *this, columnsHint); 
+            } 
+            return ValuesSource(alt.GetRule_values_source2(), columnsHint, operationName); 
+        } 
+        default: 
+            Ctx.IncrementMonCounter("sql_errors", "DefaultValuesOrOther"); 
+            AltNotImplemented("into_values_source", node); 
+            return nullptr; 
+    } 
+} 
+
+TSourcePtr TSqlIntoValues::ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint, 
+    const TString& operationName) 
+{ 
     Ctx.IncrementMonCounter("sql_features", "ValuesSource");
     TPosition pos(Ctx.Pos());
     switch (node.Alt_case()) {
@@ -7858,7 +7858,7 @@ TSourcePtr TSqlIntoValues::ValuesSource(const TRule_values_source& node, TVector
             if (!BuildRows(rowList, rows)) {
                 return nullptr;
             }
-            return BuildWriteValues(pos, operationName, columnsHint, rows);
+            return BuildWriteValues(pos, operationName, columnsHint, rows); 
         }
         case TRule_values_source::kAltValuesSource2: {
             TSqlSelect select(Ctx, Mode);
@@ -7876,99 +7876,99 @@ TSourcePtr TSqlIntoValues::ValuesSource(const TRule_values_source& node, TVector
     }
 }
 
-class TSqlIntoTable: public TSqlTranslation {
-public:
+class TSqlIntoTable: public TSqlTranslation { 
+public: 
     TSqlIntoTable(TContext& ctx, NSQLTranslation::ESqlMode mode)
-        : TSqlTranslation(ctx, mode)
-    {
-    }
-
-    TNodePtr Build(const TRule_into_table_stmt& node);
-
-private:
-    //bool BuildValuesRow(const TRule_values_source_row& inRow, TVector<TNodePtr>& outRow);
-    //TSourcePtr ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint);
-    //TSourcePtr IntoValuesSource(const TRule_into_values_source& node);
-
-    bool ValidateServiceName(const TRule_into_table_stmt& node, const TTableRef& table, ESQLWriteColumnMode mode,
-        const TPosition& pos);
-    TString SqlIntoModeStr;
-    TString SqlIntoUserModeStr;
-};
-
+        : TSqlTranslation(ctx, mode) 
+    { 
+    } 
+ 
+    TNodePtr Build(const TRule_into_table_stmt& node); 
+ 
+private: 
+    //bool BuildValuesRow(const TRule_values_source_row& inRow, TVector<TNodePtr>& outRow); 
+    //TSourcePtr ValuesSource(const TRule_values_source& node, TVector<TString>& columnsHint); 
+    //TSourcePtr IntoValuesSource(const TRule_into_values_source& node); 
+ 
+    bool ValidateServiceName(const TRule_into_table_stmt& node, const TTableRef& table, ESQLWriteColumnMode mode, 
+        const TPosition& pos); 
+    TString SqlIntoModeStr; 
+    TString SqlIntoUserModeStr; 
+}; 
+ 
 TNodePtr TSqlIntoTable::Build(const TRule_into_table_stmt& node) {
     static const TMap<TString, ESQLWriteColumnMode> str2Mode = {
         {"InsertInto", ESQLWriteColumnMode::InsertInto},
-        {"InsertOrAbortInto", ESQLWriteColumnMode::InsertOrAbortInto},
-        {"InsertOrIgnoreInto", ESQLWriteColumnMode::InsertOrIgnoreInto},
-        {"InsertOrRevertInto", ESQLWriteColumnMode::InsertOrRevertInto},
+        {"InsertOrAbortInto", ESQLWriteColumnMode::InsertOrAbortInto}, 
+        {"InsertOrIgnoreInto", ESQLWriteColumnMode::InsertOrIgnoreInto}, 
+        {"InsertOrRevertInto", ESQLWriteColumnMode::InsertOrRevertInto}, 
         {"UpsertInto", ESQLWriteColumnMode::UpsertInto},
         {"ReplaceInto", ESQLWriteColumnMode::ReplaceInto},
-        {"InsertIntoWithTruncate", ESQLWriteColumnMode::InsertIntoWithTruncate}
+        {"InsertIntoWithTruncate", ESQLWriteColumnMode::InsertIntoWithTruncate} 
     };
 
-    auto& modeBlock = node.GetBlock1();
-
-    TVector<TToken> modeTokens;
-    switch (modeBlock.Alt_case()) {
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt1:
-            modeTokens = {modeBlock.GetAlt1().GetToken1()};
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt2:
-            modeTokens = {
-                modeBlock.GetAlt2().GetToken1(),
-                modeBlock.GetAlt2().GetToken2(),
-                modeBlock.GetAlt2().GetToken3()
-            };
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt3:
-            modeTokens = {
-                modeBlock.GetAlt3().GetToken1(),
-                modeBlock.GetAlt3().GetToken2(),
-                modeBlock.GetAlt3().GetToken3()
-            };
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt4:
-            modeTokens = {
-                modeBlock.GetAlt4().GetToken1(),
-                modeBlock.GetAlt4().GetToken2(),
-                modeBlock.GetAlt4().GetToken3()
-            };
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt5:
-            modeTokens = {modeBlock.GetAlt5().GetToken1()};
-            break;
-        case TRule_into_table_stmt_TBlock1::AltCase::kAlt6:
-            modeTokens = {modeBlock.GetAlt6().GetToken1()};
-            break;
+    auto& modeBlock = node.GetBlock1(); 
+ 
+    TVector<TToken> modeTokens; 
+    switch (modeBlock.Alt_case()) { 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt1: 
+            modeTokens = {modeBlock.GetAlt1().GetToken1()}; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt2: 
+            modeTokens = { 
+                modeBlock.GetAlt2().GetToken1(), 
+                modeBlock.GetAlt2().GetToken2(), 
+                modeBlock.GetAlt2().GetToken3() 
+            }; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt3: 
+            modeTokens = { 
+                modeBlock.GetAlt3().GetToken1(), 
+                modeBlock.GetAlt3().GetToken2(), 
+                modeBlock.GetAlt3().GetToken3() 
+            }; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt4: 
+            modeTokens = { 
+                modeBlock.GetAlt4().GetToken1(), 
+                modeBlock.GetAlt4().GetToken2(), 
+                modeBlock.GetAlt4().GetToken3() 
+            }; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt5: 
+            modeTokens = {modeBlock.GetAlt5().GetToken1()}; 
+            break; 
+        case TRule_into_table_stmt_TBlock1::AltCase::kAlt6: 
+            modeTokens = {modeBlock.GetAlt6().GetToken1()}; 
+            break; 
         default:
             Y_FAIL("You should change implementation according to grammar changes");
-    }
-
-    TVector<TString> modeStrings;
-    modeStrings.reserve(modeTokens.size());
-    TVector<TString> userModeStrings;
-    userModeStrings.reserve(modeTokens.size());
-
-    for (auto& token : modeTokens) {
-        auto tokenStr = Token(token);
-
-        auto modeStr = tokenStr;
-        modeStr.to_lower();
-        modeStr.to_upper(0, 1);
-        modeStrings.push_back(modeStr);
-
-        auto userModeStr = tokenStr;
-        userModeStr.to_upper();
-        userModeStrings.push_back(userModeStr);
-    }
-
-    modeStrings.push_back("Into");
-    userModeStrings.push_back("INTO");
-
-    SqlIntoModeStr = JoinRange("", modeStrings.begin(), modeStrings.end());
-    SqlIntoUserModeStr = JoinRange(" ", userModeStrings.begin(), userModeStrings.end());
-
+    } 
+ 
+    TVector<TString> modeStrings; 
+    modeStrings.reserve(modeTokens.size()); 
+    TVector<TString> userModeStrings; 
+    userModeStrings.reserve(modeTokens.size()); 
+ 
+    for (auto& token : modeTokens) { 
+        auto tokenStr = Token(token); 
+ 
+        auto modeStr = tokenStr; 
+        modeStr.to_lower(); 
+        modeStr.to_upper(0, 1); 
+        modeStrings.push_back(modeStr); 
+ 
+        auto userModeStr = tokenStr; 
+        userModeStr.to_upper(); 
+        userModeStrings.push_back(userModeStr); 
+    } 
+ 
+    modeStrings.push_back("Into"); 
+    userModeStrings.push_back("INTO"); 
+ 
+    SqlIntoModeStr = JoinRange("", modeStrings.begin(), modeStrings.end()); 
+    SqlIntoUserModeStr = JoinRange(" ", userModeStrings.begin(), userModeStrings.end()); 
+ 
     auto intoTableRef = node.GetRule_into_simple_table_ref3();
     auto tableRef = intoTableRef.GetRule_simple_table_ref1();
 
@@ -8063,15 +8063,15 @@ TNodePtr TSqlIntoTable::Build(const TRule_into_table_stmt& node) {
 
     TPosition pos(Ctx.Pos());
     TNodePtr tableKey = BuildTableKey(pos, service, cluster, nameOrAt.second, nameOrAt.first ? "@" : "");
-
+ 
     TTableRef table(Ctx.MakeName("table"), service, cluster, tableKey);
     Ctx.IncrementMonCounter("sql_insert_clusters", table.Cluster.GetLiteral() ? *table.Cluster.GetLiteral() : "unknown");
 
-    auto values = TSqlIntoValues(Ctx, Mode).Build(node.GetRule_into_values_source4(), SqlIntoUserModeStr);
+    auto values = TSqlIntoValues(Ctx, Mode).Build(node.GetRule_into_values_source4(), SqlIntoUserModeStr); 
     if (!values) {
         return nullptr;
     }
-    if (!ValidateServiceName(node, table, SqlIntoMode, GetPos(modeTokens[0]))) {
+    if (!ValidateServiceName(node, table, SqlIntoMode, GetPos(modeTokens[0]))) { 
         return nullptr;
     }
     Ctx.IncrementMonCounter("sql_features", SqlIntoModeStr);
@@ -8084,27 +8084,27 @@ TNodePtr TSqlIntoTable::Build(const TRule_into_table_stmt& node) {
     return BuildWriteColumns(pos, Ctx.Scoped, table, ToWriteColumnsMode(SqlIntoMode), std::move(values), std::move(options));
 }
 
-bool TSqlIntoTable::ValidateServiceName(const TRule_into_table_stmt& node, const TTableRef& table,
-    ESQLWriteColumnMode mode, const TPosition& pos) {
+bool TSqlIntoTable::ValidateServiceName(const TRule_into_table_stmt& node, const TTableRef& table, 
+    ESQLWriteColumnMode mode, const TPosition& pos) { 
     Y_UNUSED(node);
     auto serviceName = table.Service;
     const bool isMapReduce = serviceName == YtProviderName;
     const bool isKikimr = serviceName == KikimrProviderName || serviceName == YdbProviderName;
     const bool isRtmr = serviceName == RtmrProviderName;
     const bool isStat = serviceName == StatProviderName;
-
-    if (!isKikimr) {
-        if (mode == ESQLWriteColumnMode::InsertOrAbortInto ||
-            mode == ESQLWriteColumnMode::InsertOrIgnoreInto ||
-            mode == ESQLWriteColumnMode::InsertOrRevertInto ||
+ 
+    if (!isKikimr) { 
+        if (mode == ESQLWriteColumnMode::InsertOrAbortInto || 
+            mode == ESQLWriteColumnMode::InsertOrIgnoreInto || 
+            mode == ESQLWriteColumnMode::InsertOrRevertInto || 
             mode == ESQLWriteColumnMode::UpsertInto && !isStat)
-        {
-            Ctx.Error(pos) << SqlIntoUserModeStr << " is not supported for " << serviceName << " tables";
-            Ctx.IncrementMonCounter("sql_errors", TStringBuilder() << SqlIntoUserModeStr << "UnsupportedFor" << serviceName);
-            return false;
-        }
-    }
-
+        { 
+            Ctx.Error(pos) << SqlIntoUserModeStr << " is not supported for " << serviceName << " tables"; 
+            Ctx.IncrementMonCounter("sql_errors", TStringBuilder() << SqlIntoUserModeStr << "UnsupportedFor" << serviceName); 
+            return false; 
+        } 
+    } 
+ 
     if (isMapReduce) {
         if (mode == ESQLWriteColumnMode::ReplaceInto) {
             Ctx.Error(pos) << "Meaning of REPLACE INTO has been changed, now you should use INSERT INTO <table> WITH TRUNCATE ... for " << serviceName;
@@ -8112,8 +8112,8 @@ bool TSqlIntoTable::ValidateServiceName(const TRule_into_table_stmt& node, const
             return false;
         }
     } else if (isKikimr) {
-        if (mode == ESQLWriteColumnMode::InsertIntoWithTruncate) {
-            Ctx.Error(pos) << "INSERT INTO WITH TRUNCATE is not supported for " << serviceName << " tables";
+        if (mode == ESQLWriteColumnMode::InsertIntoWithTruncate) { 
+            Ctx.Error(pos) << "INSERT INTO WITH TRUNCATE is not supported for " << serviceName << " tables"; 
             Ctx.IncrementMonCounter("sql_errors", TStringBuilder() << SqlIntoUserModeStr << "UnsupportedFor" << serviceName);
             return false;
         }
@@ -8130,7 +8130,7 @@ bool TSqlIntoTable::ValidateServiceName(const TRule_into_table_stmt& node, const
             return false;
         }
     }
-
+ 
     return true;
 }
 
@@ -8404,11 +8404,11 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
         case TRule_sql_stmt_core::kAltSqlStmtCore5: {
             Ctx.BodyPart();
             const auto& rule = core.GetAlt_sql_stmt_core5().GetRule_drop_table_stmt1();
-            if (rule.HasBlock3()) {
+            if (rule.HasBlock3()) { 
                 Context().Error(GetPos(rule.GetToken1())) << "IF EXISTS in " << humanStatementName
-                    << " is not supported.";
-                return false;
-            }
+                    << " is not supported."; 
+                return false; 
+            } 
             TTableRef tr;
             if (!SimpleTableRefImpl(rule.GetRule_simple_table_ref4(), tr)) {
                 return false;
@@ -8461,13 +8461,13 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             blocks.emplace_back(deleteNode);
             break;
         }
-        case TRule_sql_stmt_core::kAltSqlStmtCore11: {
+        case TRule_sql_stmt_core::kAltSqlStmtCore11: { 
             Ctx.BodyPart();
-            const auto& rule = core.GetAlt_sql_stmt_core11().GetRule_rollback_stmt1();
-            Token(rule.GetToken1());
+            const auto& rule = core.GetAlt_sql_stmt_core11().GetRule_rollback_stmt1(); 
+            Token(rule.GetToken1()); 
             blocks.emplace_back(BuildRollbackClusters(Ctx.Pos()));
-            break;
-        }
+            break; 
+        } 
         case TRule_sql_stmt_core::kAltSqlStmtCore12:
             if (!DeclareStatement(core.GetAlt_sql_stmt_core12().GetRule_declare_stmt1())) {
                 return false;
@@ -9685,46 +9685,46 @@ TNodePtr TSqlQuery::Build(const TRule_delete_stmt& stmt) {
     if (!SimpleTableRefImpl(stmt.GetRule_simple_table_ref3(), table)) {
         return nullptr;
     }
-
+ 
     const bool isKikimr = table.Service == KikimrProviderName;
-    if (!isKikimr) {
+    if (!isKikimr) { 
         Ctx.Error(GetPos(stmt.GetToken1())) << "DELETE is unsupported for " << table.Service;
         return nullptr;
     }
-
+ 
     TSourcePtr source = BuildTableSource(Ctx.Pos(), table);
-
+ 
     if (stmt.HasBlock4()) {
-        switch (stmt.GetBlock4().Alt_case()) {
-            case TRule_delete_stmt_TBlock4::kAlt1: {
-                const auto& alt = stmt.GetBlock4().GetAlt1();
-
+        switch (stmt.GetBlock4().Alt_case()) { 
+            case TRule_delete_stmt_TBlock4::kAlt1: { 
+                const auto& alt = stmt.GetBlock4().GetAlt1(); 
+ 
                 TColumnRefScope scope(Ctx, EColumnRefState::Allow);
-                TSqlExpression sqlExpr(Ctx, Mode);
-                auto whereExpr = sqlExpr.Build(alt.GetRule_expr2());
-                if (!whereExpr) {
-                    return nullptr;
-                }
-                source->AddFilter(Ctx, whereExpr);
-                break;
-            }
-
-            case TRule_delete_stmt_TBlock4::kAlt2: {
-                const auto& alt = stmt.GetBlock4().GetAlt2();
-
-                auto values = TSqlIntoValues(Ctx, Mode).Build(alt.GetRule_into_values_source2(), "DELETE ON");
-                if (!values) {
-                    return nullptr;
-                }
-
+                TSqlExpression sqlExpr(Ctx, Mode); 
+                auto whereExpr = sqlExpr.Build(alt.GetRule_expr2()); 
+                if (!whereExpr) { 
+                    return nullptr; 
+                } 
+                source->AddFilter(Ctx, whereExpr); 
+                break; 
+            } 
+ 
+            case TRule_delete_stmt_TBlock4::kAlt2: { 
+                const auto& alt = stmt.GetBlock4().GetAlt2(); 
+ 
+                auto values = TSqlIntoValues(Ctx, Mode).Build(alt.GetRule_into_values_source2(), "DELETE ON"); 
+                if (!values) { 
+                    return nullptr; 
+                } 
+ 
                 return BuildWriteColumns(Ctx.Pos(), Ctx.Scoped, table, EWriteColumnMode::DeleteOn, std::move(values));
-            }
-
-            default:
-                return nullptr;
+            } 
+ 
+            default: 
+                return nullptr; 
         }
     }
-
+ 
     return BuildDelete(Ctx.Pos(), Ctx.Scoped, table, std::move(source));
 }
 
@@ -9733,45 +9733,45 @@ TNodePtr TSqlQuery::Build(const TRule_update_stmt& stmt) {
     if (!SimpleTableRefImpl(stmt.GetRule_simple_table_ref2(), table)) {
         return nullptr;
     }
-
+ 
     const bool isKikimr = table.Service == KikimrProviderName;
-
-    if (!isKikimr) {
+ 
+    if (!isKikimr) { 
         Ctx.Error(GetPos(stmt.GetToken1())) << "UPDATE is unsupported for " << table.Service;
         return nullptr;
     }
-
-    switch (stmt.GetBlock3().Alt_case()) {
-        case TRule_update_stmt_TBlock3::kAlt1: {
-            const auto& alt = stmt.GetBlock3().GetAlt1();
-            TSourcePtr values = Build(alt.GetRule_set_clause_choice2());
+ 
+    switch (stmt.GetBlock3().Alt_case()) { 
+        case TRule_update_stmt_TBlock3::kAlt1: { 
+            const auto& alt = stmt.GetBlock3().GetAlt1(); 
+            TSourcePtr values = Build(alt.GetRule_set_clause_choice2()); 
             auto source = BuildTableSource(Ctx.Pos(), table);
-
-            if (alt.HasBlock3()) {
+ 
+            if (alt.HasBlock3()) { 
                 TColumnRefScope scope(Ctx, EColumnRefState::Allow);
-                TSqlExpression sqlExpr(Ctx, Mode);
-                auto whereExpr = sqlExpr.Build(alt.GetBlock3().GetRule_expr2());
-                if (!whereExpr) {
-                    return nullptr;
-                }
-                source->AddFilter(Ctx, whereExpr);
-            }
-
+                TSqlExpression sqlExpr(Ctx, Mode); 
+                auto whereExpr = sqlExpr.Build(alt.GetBlock3().GetRule_expr2()); 
+                if (!whereExpr) { 
+                    return nullptr; 
+                } 
+                source->AddFilter(Ctx, whereExpr); 
+            } 
+ 
             return BuildUpdateColumns(Ctx.Pos(), Ctx.Scoped, table, std::move(values), std::move(source));
-        }
-
-        case TRule_update_stmt_TBlock3::kAlt2: {
-            const auto& alt = stmt.GetBlock3().GetAlt2();
-
-            auto values = TSqlIntoValues(Ctx, Mode).Build(alt.GetRule_into_values_source2(), "UPDATE ON");
-            if (!values) {
-                return nullptr;
-            }
-
+        } 
+ 
+        case TRule_update_stmt_TBlock3::kAlt2: { 
+            const auto& alt = stmt.GetBlock3().GetAlt2(); 
+ 
+            auto values = TSqlIntoValues(Ctx, Mode).Build(alt.GetRule_into_values_source2(), "UPDATE ON"); 
+            if (!values) { 
+                return nullptr; 
+            } 
+ 
             return BuildWriteColumns(Ctx.Pos(), Ctx.Scoped, table, EWriteColumnMode::UpdateOn, std::move(values));
-        }
-
-        default:
+        } 
+ 
+        default: 
             return nullptr;
     }
 }
@@ -10055,8 +10055,8 @@ google::protobuf::Message* SqlAST(const TString& query, const TString& queryName
         NProtoAST::TProtoASTBuilder<NALPDefault::SQLv1Parser, NALPDefault::SQLv1Lexer> builder(query, queryName, arena);
         return builder.BuildAST(collector);
     }
-}
-
+} 
+ 
 google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NProtoAST::IErrorCollector& err, bool ansiLexer, google::protobuf::Arena* arena) {
     YQL_ENSURE(arena);
 #if defined(_tsan_enabled_)
@@ -10071,7 +10071,7 @@ google::protobuf::Message* SqlAST(const TString& query, const TString& queryName
     }
 }
 
-TAstNode* SqlASTToYql(const google::protobuf::Message& protoAst, TContext& ctx) {
+TAstNode* SqlASTToYql(const google::protobuf::Message& protoAst, TContext& ctx) { 
     const google::protobuf::Descriptor* d = protoAst.GetDescriptor();
     if (d && d->name() != "TSQLv1ParserAST") {
         ctx.Error() << "Invalid AST structure: " << d->name() << ", expected TSQLv1ParserAST";
@@ -10108,20 +10108,20 @@ void SqlASTToYqlImpl(NYql::TAstParseResult& res, const google::protobuf::Message
 
 NYql::TAstParseResult SqlASTToYql(const google::protobuf::Message& protoAst,
     const NSQLTranslation::TTranslationSettings& settings)
-{
+{ 
     YQL_ENSURE(IsQueryMode(settings.Mode));
-    TAstParseResult res;
+    TAstParseResult res; 
     TContext ctx(settings, res.Issues);
     SqlASTToYqlImpl(res, protoAst, ctx);
-    return res;
-}
-
+    return res; 
+} 
+ 
 NYql::TAstParseResult SqlToYql(const TString& query, const NSQLTranslation::TTranslationSettings& settings, NYql::TWarningRules* warningRules)
-{
-    TAstParseResult res;
+{ 
+    TAstParseResult res; 
     TContext ctx(settings, res.Issues);
     NSQLTranslation::TErrorCollectorOverIssues collector(res.Issues, settings.MaxErrors, settings.File);
-
+ 
     google::protobuf::Message* ast(SqlAST(query, "query", collector, settings.AnsiLexer, settings.Arena));
     if (ast) {
         SqlASTToYqlImpl(res, *ast, ctx);
diff --git a/ydb/library/yql/sql/v1/sql.h b/ydb/library/yql/sql/v1/sql.h
index 9c7dc676c6..fbec0a59dc 100644
--- a/ydb/library/yql/sql/v1/sql.h
+++ b/ydb/library/yql/sql/v1/sql.h
@@ -17,5 +17,5 @@ namespace NSQLTranslationV1 {
     NYql::TAstParseResult SqlToYql(const TString& query, const NSQLTranslation::TTranslationSettings& settings, NYql::TWarningRules* warningRules = nullptr);
     google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NYql::TIssues& err, size_t maxErrors, bool ansiLexer, google::protobuf::Arena* arena = nullptr);
     NYql::TAstParseResult SqlASTToYql(const google::protobuf::Message& protoAst, const NSQLTranslation::TTranslationSettings& settings);
-
+ 
 }  // namespace NSQLTranslationV1
diff --git a/ydb/library/yql/sql/v1/sql_ut.cpp b/ydb/library/yql/sql/v1/sql_ut.cpp
index 85b6e0dfcd..a46fe9b128 100644
--- a/ydb/library/yql/sql/v1/sql_ut.cpp
+++ b/ydb/library/yql/sql/v1/sql_ut.cpp
@@ -1,10 +1,10 @@
-
+ 
 #include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
 #include <ydb/library/yql/sql/sql.h>
 #include <util/generic/map.h>
-
+ 
 #include <library/cpp/testing/unittest/registar.h>
-
+ 
 #include <util/string/split.h>
 
 using namespace NSQLTranslation;
@@ -32,7 +32,7 @@ NYql::TAstParseResult SqlToYqlWithMode(const TString& query, NSQLTranslation::ES
     const TString cluster = "plato";
     settings.ClusterMapping[cluster] = service;
     settings.ClusterMapping["hahn"] = NYql::YtProviderName;
-    settings.MaxErrors = maxErrors;
+    settings.MaxErrors = maxErrors; 
     settings.Mode = mode;
     settings.Arena = &arena;
     settings.AnsiLexer = ansiLexer;
@@ -557,7 +557,7 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
         NYql::TAstParseResult res = SqlToYql("select in, s.check from (select 1 as in, \"test\" as check) as s;");
         UNIT_ASSERT(res.Root);
     }
-
+ 
     Y_UNIT_TEST(SelectAllGroupBy) {
         NYql::TAstParseResult res = SqlToYql("select * from plato.Input group by subkey;");
         UNIT_ASSERT(res.Root);
@@ -565,21 +565,21 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
 
     Y_UNIT_TEST(PrimaryKeyParseCorrect) {
         NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE tableName (Key Uint32, Subkey Int64, Value String, PRIMARY KEY (Key, Subkey));");
-        UNIT_ASSERT(res.Root);
-
+        UNIT_ASSERT(res.Root); 
+ 
         TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
+            if (word == "Write") { 
                 UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"Key\""));
                 UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"Subkey\""));
-            }
-        };
-
+            } 
+        }; 
+ 
         TWordCountHive elementStat = {{TString("Write"), 0}, {TString("primarykey"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["primarykey"]);
-    }
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["primarykey"]); 
+    } 
 
     Y_UNIT_TEST(DeleteFromTableByKey) {
         NYql::TAstParseResult res = SqlToYql("delete from plato.Input where key = 200;", 10, "kikimr");
@@ -614,39 +614,39 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
     }
 
     Y_UNIT_TEST(DeleteFromTableOnValues) {
-        NYql::TAstParseResult res = SqlToYql("delete from plato.Input on (key) values (1);",
-            10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
-        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
-                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)"));
-            }
-        };
-
-        TWordCountHive elementStat = {{TString("Write"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-    }
-
+        NYql::TAstParseResult res = SqlToYql("delete from plato.Input on (key) values (1);", 
+            10, "kikimr"); 
+        UNIT_ASSERT(res.Root); 
+ 
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) { 
+            if (word == "Write") { 
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)")); 
+            } 
+        }; 
+ 
+        TWordCountHive elementStat = {{TString("Write"), 0}}; 
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+    } 
+ 
     Y_UNIT_TEST(DeleteFromTableOnSelect) {
-        NYql::TAstParseResult res = SqlToYql(
-            "delete from plato.Input on select key from plato.Input where value > 0;", 10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
-        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
-                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)"));
-            }
-        };
-
-        TWordCountHive elementStat = {{TString("Write"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-    }
-
+        NYql::TAstParseResult res = SqlToYql( 
+            "delete from plato.Input on select key from plato.Input where value > 0;", 10, "kikimr"); 
+        UNIT_ASSERT(res.Root); 
+ 
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) { 
+            if (word == "Write") { 
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)")); 
+            } 
+        }; 
+ 
+        TWordCountHive elementStat = {{TString("Write"), 0}}; 
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+    } 
+ 
     Y_UNIT_TEST(UpdateByValues) {
         NYql::TAstParseResult res = SqlToYql("update plato.Input set key = 777, value = 'cool' where key = 200;", 10, "kikimr");
         UNIT_ASSERT(res.Root);
@@ -685,7 +685,7 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
                 const bool isSubkey = line.find("subkey") != TString::npos;
                 const bool isValue = line.find("value") != TString::npos;
                 UNIT_ASSERT(isKey || isSubkey || isValue);
-                if (isKey && !isSubkey) {
+                if (isKey && !isSubkey) { 
                     UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("2")));
                 } else if (isSubkey) {
                     UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote(":")));
@@ -751,38 +751,38 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
     }
 
     Y_UNIT_TEST(UpdateOnValues) {
-        NYql::TAstParseResult res = SqlToYql("update plato.Input on (key, value) values (5, 'cool')", 10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
-        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
-                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)"));
-            }
-        };
-
-        TWordCountHive elementStat = {{TString("Write"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-    }
-
+        NYql::TAstParseResult res = SqlToYql("update plato.Input on (key, value) values (5, 'cool')", 10, "kikimr"); 
+        UNIT_ASSERT(res.Root); 
+ 
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) { 
+            if (word == "Write") { 
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)")); 
+            } 
+        }; 
+ 
+        TWordCountHive elementStat = {{TString("Write"), 0}}; 
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+    } 
+ 
     Y_UNIT_TEST(UpdateOnSelect) {
-        NYql::TAstParseResult res = SqlToYql(
-            "update plato.Input on select key, value + 1 as value from plato.Input", 10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
-        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
-            if (word == "Write") {
-                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)"));
-            }
-        };
-
-        TWordCountHive elementStat = {{TString("Write"), 0}};
-        VerifyProgram(res, elementStat, verifyLine);
-
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
-    }
-
+        NYql::TAstParseResult res = SqlToYql( 
+            "update plato.Input on select key, value + 1 as value from plato.Input", 10, "kikimr"); 
+        UNIT_ASSERT(res.Root); 
+ 
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) { 
+            if (word == "Write") { 
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)")); 
+            } 
+        }; 
+ 
+        TWordCountHive elementStat = {{TString("Write"), 0}}; 
+        VerifyProgram(res, elementStat, verifyLine); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]); 
+    } 
+ 
     Y_UNIT_TEST(UnionAllTest) {
         NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input UNION ALL select subkey FROM plato.Input;");
         UNIT_ASSERT(res.Root);
@@ -808,15 +808,15 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
         /// Verify that parsed well without crash
         UNIT_ASSERT(res.Root);
     }
-
+ 
     Y_UNIT_TEST(KikimrRollback) {
         NYql::TAstParseResult res = SqlToYql("use plato; select * from Input; rollback;", 10, "kikimr");
-        UNIT_ASSERT(res.Root);
-
+        UNIT_ASSERT(res.Root); 
+ 
         TWordCountHive elementStat = {{TString("rollback"), 0}};
-        VerifyProgram(res, elementStat);
-        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["rollback"]);
-    }
+        VerifyProgram(res, elementStat); 
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["rollback"]); 
+    } 
 
     Y_UNIT_TEST(PragmaFile) {
         NYql::TAstParseResult res = SqlToYql(R"(pragma file("HW", "sbr:181041334");)");
@@ -912,7 +912,7 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
         )", 10, TString(NYql::RtmrProviderName));
         UNIT_ASSERT(res.Root);
     }
-
+ 
     Y_UNIT_TEST(GroupByHopRtmrSubquery) {
         // 'use plato' intentially avoided
         NYql::TAstParseResult res = SqlToYql(R"(
@@ -944,72 +944,72 @@ Y_UNIT_TEST_SUITE(SqlParsingOnly) {
     }
 
     Y_UNIT_TEST(KikimrInserts) {
-         NYql::TAstParseResult res = SqlToYql(R"(
-            USE plato;
-            INSERT INTO Output SELECT key, value FROM Input;
-            INSERT OR ABORT INTO Output SELECT key, value FROM Input;
-            INSERT OR IGNORE INTO Output SELECT key, value FROM Input;
-            INSERT OR REVERT INTO Output SELECT key, value FROM Input;
-        )", 10, TString(NYql::KikimrProviderName));
-        UNIT_ASSERT(res.Root);
-    }
+         NYql::TAstParseResult res = SqlToYql(R"( 
+            USE plato; 
+            INSERT INTO Output SELECT key, value FROM Input; 
+            INSERT OR ABORT INTO Output SELECT key, value FROM Input; 
+            INSERT OR IGNORE INTO Output SELECT key, value FROM Input; 
+            INSERT OR REVERT INTO Output SELECT key, value FROM Input; 
+        )", 10, TString(NYql::KikimrProviderName)); 
+        UNIT_ASSERT(res.Root); 
+    } 
 
     Y_UNIT_TEST(WarnMissingIsBeforeNotNull) {
         NYql::TAstParseResult res = SqlToYql("select 1 NOT NULL");
         UNIT_ASSERT(res.Root);
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Warning: Missing IS keyword before NOT NULL, code: 4507\n");
     }
-
-    Y_UNIT_TEST(Subqueries) {
-        NYql::TAstParseResult res = SqlToYql(R"(
-            USE plato;
-            $sq1 = (SELECT * FROM plato.Input);
-
-            $sq2 = SELECT * FROM plato.Input;
-
-            $squ1 = (
-                SELECT * FROM plato.Input
-                UNION ALL
-                SELECT * FROM plato.Input
-            );
-
-            $squ2 =
-                SELECT * FROM plato.Input
-                UNION ALL
-                SELECT * FROM plato.Input;
-
-            $squ3 = (
-                (SELECT * FROM plato.Input)
-                UNION ALL
-                (SELECT * FROM plato.Input)
-            );
-
-            SELECT * FROM $sq1;
-            SELECT * FROM $sq2;
-            SELECT * FROM $squ1;
-            SELECT * FROM $squ2;
-            SELECT * FROM $squ3;
-        )");
-
-        Cerr << Err2Str(res) << Endl;
-        UNIT_ASSERT(res.Root);
-    }
-
-    Y_UNIT_TEST(SubqueriesJoin) {
-        NYql::TAstParseResult res = SqlToYql(R"(
-            USE plato;
-
-            $left = SELECT * FROM plato.Input1 WHERE value != "BadValue";
-            $right = SELECT * FROM plato.Input2;
-
-            SELECT * FROM $left AS l
-            JOIN $right AS r
-            ON l.key == r.key;
-        )");
-
-        Cerr << Err2Str(res) << Endl;
-        UNIT_ASSERT(res.Root);
-    }
+ 
+    Y_UNIT_TEST(Subqueries) { 
+        NYql::TAstParseResult res = SqlToYql(R"( 
+            USE plato; 
+            $sq1 = (SELECT * FROM plato.Input); 
+ 
+            $sq2 = SELECT * FROM plato.Input; 
+ 
+            $squ1 = ( 
+                SELECT * FROM plato.Input 
+                UNION ALL 
+                SELECT * FROM plato.Input 
+            ); 
+ 
+            $squ2 = 
+                SELECT * FROM plato.Input 
+                UNION ALL 
+                SELECT * FROM plato.Input; 
+ 
+            $squ3 = ( 
+                (SELECT * FROM plato.Input) 
+                UNION ALL 
+                (SELECT * FROM plato.Input) 
+            ); 
+ 
+            SELECT * FROM $sq1; 
+            SELECT * FROM $sq2; 
+            SELECT * FROM $squ1; 
+            SELECT * FROM $squ2; 
+            SELECT * FROM $squ3; 
+        )"); 
+ 
+        Cerr << Err2Str(res) << Endl; 
+        UNIT_ASSERT(res.Root); 
+    } 
+ 
+    Y_UNIT_TEST(SubqueriesJoin) { 
+        NYql::TAstParseResult res = SqlToYql(R"( 
+            USE plato; 
+ 
+            $left = SELECT * FROM plato.Input1 WHERE value != "BadValue"; 
+            $right = SELECT * FROM plato.Input2; 
+ 
+            SELECT * FROM $left AS l 
+            JOIN $right AS r 
+            ON l.key == r.key; 
+        )"); 
+ 
+        Cerr << Err2Str(res) << Endl; 
+        UNIT_ASSERT(res.Root); 
+    } 
 
     Y_UNIT_TEST(AnyInBackticksAsTableName) {
         NYql::TAstParseResult res = SqlToYql("use plato; select * from `any`;");
@@ -2090,16 +2090,16 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
 
     Y_UNIT_TEST(UpsertValuesNoLabelsKikimr) {
         NYql::TAstParseResult res = SqlToYql("upsert into plato.Output values (1)", 10, TString(NYql::KikimrProviderName));
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:19: Error: UPSERT INTO ... VALUES requires specification of table columns\n");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(ReplaceValuesNoLabelsKikimr) {
         NYql::TAstParseResult res = SqlToYql("replace into plato.Output values (1)", 10, TString(NYql::KikimrProviderName));
-        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:20: Error: REPLACE INTO ... VALUES requires specification of table columns\n");
-    }
-
+    } 
+ 
     Y_UNIT_TEST(InsertValuesInvalidLabels) {
         NYql::TAstParseResult res = SqlToYql("insert into plato.Output (foo) values (1, 2)");
         UNIT_ASSERT(!res.Root);
@@ -2129,7 +2129,7 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
         UNIT_ASSERT(!res.Root);
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:43: Error: DISTINCT can not be used in PROCESS/REDUCE\n");
     }
-
+ 
     Y_UNIT_TEST(CreateTableWithView) {
         NYql::TAstParseResult res = SqlToYql("CREATE TABLE plato.foo:bar (key INT);");
         UNIT_ASSERT(!res.Root);
@@ -2314,11 +2314,11 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
     }
 
     Y_UNIT_TEST(InsertAbortMapReduce) {
-        NYql::TAstParseResult res = SqlToYql("INSERT OR ABORT INTO plato.Output SELECT key FROM plato.Input");
-        UNIT_ASSERT(!res.Root);
-        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: INSERT OR ABORT INTO is not supported for yt tables\n");
-    }
-
+        NYql::TAstParseResult res = SqlToYql("INSERT OR ABORT INTO plato.Output SELECT key FROM plato.Input"); 
+        UNIT_ASSERT(!res.Root); 
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: INSERT OR ABORT INTO is not supported for yt tables\n"); 
+    } 
+ 
     Y_UNIT_TEST(ReplaceIntoMapReduce) {
         NYql::TAstParseResult res = SqlToYql("REPLACE INTO plato.Output SELECT key FROM plato.Input");
         UNIT_ASSERT(!res.Root);
@@ -2471,7 +2471,7 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
         UNIT_ASSERT(!res.Root);
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:43: Error: Column name can not be empty\n");
     }
-
+ 
     Y_UNIT_TEST(ConvertNumberOutOfBase) {
         NYql::TAstParseResult res = SqlToYql("select 0o80l;");
         UNIT_ASSERT(!res.Root);
@@ -2518,12 +2518,12 @@ Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
         UNIT_ASSERT(!res.Root);
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Failed to use window function Lead without window specification\n");
     }
-
+ 
     Y_UNIT_TEST(DropTableWithIfExists) {
-        NYql::TAstParseResult res = SqlToYql("DROP TABLE IF EXISTS plato.foo;");
-        UNIT_ASSERT(!res.Root);
+        NYql::TAstParseResult res = SqlToYql("DROP TABLE IF EXISTS plato.foo;"); 
+        UNIT_ASSERT(!res.Root); 
         UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: IF EXISTS in DROP TABLE is not supported.\n");
-    }
+    } 
 
     Y_UNIT_TEST(TooManyErrors) {
         const char* q = R"(
diff --git a/ydb/library/yql/udfs/logs/dsv/dsv_udf.cpp b/ydb/library/yql/udfs/logs/dsv/dsv_udf.cpp
index b74bf80b18..0bf5bfbded 100644
--- a/ydb/library/yql/udfs/logs/dsv/dsv_udf.cpp
+++ b/ydb/library/yql/udfs/logs/dsv/dsv_udf.cpp
@@ -268,7 +268,7 @@ public:
                 builder.SetError("Only one argument is expected " + ToString(argsTypeInspector.GetElementsCount()));
                 return;
             }
-
+ 
             TVector<TDataTypeId> typeIds;
             const auto structType = argsTypeInspector.GetElementType(0);
             THolder<TStructTypeInspector> structInspector(new TStructTypeInspector(*typeHelper, structType));
diff --git a/ydb/library/yql/utils/actor_log/log.cpp b/ydb/library/yql/utils/actor_log/log.cpp
index 3b3002208c..abd1bc84c8 100644
--- a/ydb/library/yql/utils/actor_log/log.cpp
+++ b/ydb/library/yql/utils/actor_log/log.cpp
@@ -1,61 +1,61 @@
 #include "log.h"
-
+ 
 #include <library/cpp/actors/core/log.h>
-
+ 
 namespace NYql {
 namespace NDq {
-
+ 
 using namespace NActors;
 
-namespace {
-
+namespace { 
+ 
 NActors::NLog::EPriority GetActorLogPriority(ELogPriority priority) {
-    switch (priority) {
-        case TLOG_EMERG:
-            return NActors::NLog::PRI_EMERG;
-        case TLOG_ALERT:
-            return NActors::NLog::PRI_ALERT;
-        case TLOG_CRIT:
-            return NActors::NLog::PRI_CRIT;
-        case TLOG_ERR:
-            return NActors::NLog::PRI_ERROR;
-        case TLOG_WARNING:
-            return NActors::NLog::PRI_WARN;
-        case TLOG_NOTICE:
-            return NActors::NLog::PRI_NOTICE;
-        case TLOG_INFO:
-            return NActors::NLog::PRI_INFO;
-        case TLOG_DEBUG:
-            return NActors::NLog::PRI_DEBUG;
-        default:
-            return NActors::NLog::PRI_TRACE;
-    }
-}
-
-NYql::NLog::ELevel GetYqlLogLevel(NActors::NLog::EPriority priority) {
-    switch (priority) {
-        case NActors::NLog::PRI_EMERG:
-        case NActors::NLog::PRI_ALERT:
-        case NActors::NLog::PRI_CRIT:
-            return NYql::NLog::ELevel::FATAL;
-        case NActors::NLog::PRI_ERROR:
-            return NYql::NLog::ELevel::ERROR;
-        case NActors::NLog::PRI_WARN:
-            return NYql::NLog::ELevel::WARN;
-        case NActors::NLog::PRI_NOTICE:
-        case NActors::NLog::PRI_INFO:
-            return NYql::NLog::ELevel::INFO;
-        case NActors::NLog::PRI_DEBUG:
-            return NYql::NLog::ELevel::DEBUG;
-        case NActors::NLog::PRI_TRACE:
-            return NYql::NLog::ELevel::TRACE;
-        default:
-            return NYql::NLog::ELevel::TRACE;
-    }
-}
-
-} // namespace
-
+    switch (priority) { 
+        case TLOG_EMERG: 
+            return NActors::NLog::PRI_EMERG; 
+        case TLOG_ALERT: 
+            return NActors::NLog::PRI_ALERT; 
+        case TLOG_CRIT: 
+            return NActors::NLog::PRI_CRIT; 
+        case TLOG_ERR: 
+            return NActors::NLog::PRI_ERROR; 
+        case TLOG_WARNING: 
+            return NActors::NLog::PRI_WARN; 
+        case TLOG_NOTICE: 
+            return NActors::NLog::PRI_NOTICE; 
+        case TLOG_INFO: 
+            return NActors::NLog::PRI_INFO; 
+        case TLOG_DEBUG: 
+            return NActors::NLog::PRI_DEBUG; 
+        default: 
+            return NActors::NLog::PRI_TRACE; 
+    } 
+} 
+ 
+NYql::NLog::ELevel GetYqlLogLevel(NActors::NLog::EPriority priority) { 
+    switch (priority) { 
+        case NActors::NLog::PRI_EMERG: 
+        case NActors::NLog::PRI_ALERT: 
+        case NActors::NLog::PRI_CRIT: 
+            return NYql::NLog::ELevel::FATAL; 
+        case NActors::NLog::PRI_ERROR: 
+            return NYql::NLog::ELevel::ERROR; 
+        case NActors::NLog::PRI_WARN: 
+            return NYql::NLog::ELevel::WARN; 
+        case NActors::NLog::PRI_NOTICE: 
+        case NActors::NLog::PRI_INFO: 
+            return NYql::NLog::ELevel::INFO; 
+        case NActors::NLog::PRI_DEBUG: 
+            return NYql::NLog::ELevel::DEBUG; 
+        case NActors::NLog::PRI_TRACE: 
+            return NYql::NLog::ELevel::TRACE; 
+        default: 
+            return NYql::NLog::ELevel::TRACE; 
+    } 
+} 
+ 
+} // namespace 
+ 
 void TActorYqlLogBackend::WriteData(const TLogRecord& rec) {
     std::visit([&](const auto* actorCtxOrSystem){
         Y_VERIFY(actorCtxOrSystem);
@@ -67,15 +67,15 @@ void TActorYqlLogBackend::WriteData(const TLogRecord& rec) {
                 "TraceId: %s, SessionId: %s %.*s", TraceId.c_str(), SessionId.c_str(), (int)rec.Len, rec.Data);
         }
     }, ActorCtxOrSystem);
-}
-
-void SetYqlLogLevels(const NActors::NLog::EPriority& priority) {
-    auto logLevel = GetYqlLogLevel(priority);
-
-    NYql::NLog::EComponentHelpers::ForEach([logLevel] (NYql::NLog::EComponent component) {
-        NYql::NLog::YqlLogger().SetComponentLevel(component, logLevel);
-    });
-}
-
+} 
+ 
+void SetYqlLogLevels(const NActors::NLog::EPriority& priority) { 
+    auto logLevel = GetYqlLogLevel(priority); 
+ 
+    NYql::NLog::EComponentHelpers::ForEach([logLevel] (NYql::NLog::EComponent component) { 
+        NYql::NLog::YqlLogger().SetComponentLevel(component, logLevel); 
+    }); 
+} 
+ 
 } // namespace NDq
 } // namespace NYql
diff --git a/ydb/library/yql/utils/log/log.cpp b/ydb/library/yql/utils/log/log.cpp
index b62bfeb907..9ccc76b5d3 100644
--- a/ydb/library/yql/utils/log/log.cpp
+++ b/ydb/library/yql/utils/log/log.cpp
@@ -7,14 +7,14 @@
 #include <util/generic/strbuf.h>
 #include <util/stream/format.h>
 #include <util/system/getpid.h>
-#include <util/system/mutex.h>
+#include <util/system/mutex.h> 
 #include <util/system/progname.h>
 #include <util/system/thread.i>
 
 #include <stdio.h>
 #include <time.h>
 
-static TMutex g_InitLoggerMutex;
+static TMutex g_InitLoggerMutex; 
 static int g_LoggerInitialized = 0;
 
 namespace {
@@ -89,21 +89,21 @@ public:
     }
 };
 
-TYqlLog::TYqlLog()
-    : TLog()
-    , ProcName_()
-    , ProcId_()
-    , WriteTruncMsg_(0) {}
-
+TYqlLog::TYqlLog() 
+    : TLog() 
+    , ProcName_() 
+    , ProcId_() 
+    , WriteTruncMsg_(0) {} 
+ 
 TYqlLog::TYqlLog(const TString& logType, const TComponentLevels& levels)
     : TLog(logType)
     , ProcName_(GetProgramName())
     , ProcId_(GetPID())
     , WriteTruncMsg_(0)
 {
-    for (size_t component = 0; component < levels.size(); ++component) {
-        SetComponentLevel(EComponentHelpers::FromInt(component), levels[component]);
-    }
+    for (size_t component = 0; component < levels.size(); ++component) { 
+        SetComponentLevel(EComponentHelpers::FromInt(component), levels[component]); 
+    } 
 }
 
 TYqlLog::TYqlLog(TAutoPtr<TLogBackend> backend, const TComponentLevels& levels)
@@ -112,9 +112,9 @@ TYqlLog::TYqlLog(TAutoPtr<TLogBackend> backend, const TComponentLevels& levels)
     , ProcId_(GetPID())
     , WriteTruncMsg_(0)
 {
-    for (size_t component = 0; component < levels.size(); ++component) {
-        SetComponentLevel(EComponentHelpers::FromInt(component), levels[component]);
-    }
+    for (size_t component = 0; component < levels.size(); ++component) { 
+        SetComponentLevel(EComponentHelpers::FromInt(component), levels[component]); 
+    } 
 }
 
 void TYqlLog::UpdateProcInfo(const TString& procName) {
@@ -164,63 +164,63 @@ void TYqlLog::SetMaxLogLimit(ui64 limit) {
 }
 
 void InitLogger(const TString& logType, bool startAsDaemon) {
-    with_lock(g_InitLoggerMutex) {
+    with_lock(g_InitLoggerMutex) { 
         ++g_LoggerInitialized;
         if (g_LoggerInitialized > 1) {
-            return;
-        }
+            return; 
+        } 
 
-        TComponentLevels levels;
-        levels.fill(ELevel::INFO);
+        TComponentLevels levels; 
+        levels.fill(ELevel::INFO); 
 
-        if (startAsDaemon && (
+        if (startAsDaemon && ( 
                 TStringBuf("console") == logType ||
                 TStringBuf("cout") == logType ||
                 TStringBuf("cerr") == logType))
-        {
-            TLoggerOperator<TYqlLog>::Set(new TYqlLog("null", levels));
-            return;
-        }
-
+        { 
+            TLoggerOperator<TYqlLog>::Set(new TYqlLog("null", levels)); 
+            return; 
+        } 
+ 
         if (TStringBuf("syslog") == logType) {
-            auto backend = MakeHolder<TSysLogBackend>(
-                        GetProgramName().data(), TSysLogBackend::TSYSLOG_LOCAL1);
-            auto& logger = TLoggerOperator<TYqlLog>::Log();
+            auto backend = MakeHolder<TSysLogBackend>( 
+                        GetProgramName().data(), TSysLogBackend::TSYSLOG_LOCAL1); 
+            auto& logger = TLoggerOperator<TYqlLog>::Log(); 
             logger.ResetBackend(THolder(backend.Release()));
-        } else {
-            TLoggerOperator<TYqlLog>::Set(new TYqlLog(logType, levels));
-        }
+        } else { 
+            TLoggerOperator<TYqlLog>::Set(new TYqlLog(logType, levels)); 
+        } 
     }
 }
 
 void InitLogger(TAutoPtr<TLogBackend> backend) {
-    with_lock(g_InitLoggerMutex) {
+    with_lock(g_InitLoggerMutex) { 
         ++g_LoggerInitialized;
         if (g_LoggerInitialized > 1) {
-            return;
-        }
-
-        TComponentLevels levels;
-        levels.fill(ELevel::INFO);
-        TLoggerOperator<TYqlLog>::Set(new TYqlLog(backend, levels));
-    }
+            return; 
+        } 
+ 
+        TComponentLevels levels; 
+        levels.fill(ELevel::INFO); 
+        TLoggerOperator<TYqlLog>::Set(new TYqlLog(backend, levels)); 
+    } 
 }
 
 void InitLogger(IOutputStream* out) {
     InitLogger(new TStreamLogBackend(out));
 }
 
-void CleanupLogger() {
-    with_lock(g_InitLoggerMutex) {
+void CleanupLogger() { 
+    with_lock(g_InitLoggerMutex) { 
         --g_LoggerInitialized;
         if (g_LoggerInitialized > 0) {
-            return;
-        }
-
-        TLoggerOperator<TYqlLog>::Set(new TYqlLog());
-    }
-}
-
+            return; 
+        } 
+ 
+        TLoggerOperator<TYqlLog>::Set(new TYqlLog()); 
+    } 
+} 
+ 
 } // namespace NLog
 } // namespace NYql
 
diff --git a/ydb/library/yql/utils/log/log.h b/ydb/library/yql/utils/log/log.h
index 8095fdd495..fb2b5ef4c7 100644
--- a/ydb/library/yql/utils/log/log.h
+++ b/ydb/library/yql/utils/log/log.h
@@ -38,22 +38,22 @@
     ::NYql::NLog::EComponent::component, \
     ::NYql::NLog::ELevel::level)
 
-// with component/level values logger
-
-#define YQL_CVLOG_PREP(level, component, preprocessor) YQL_LOG_IMPL(\
-    ::NYql::NLog::YqlLogger(), \
-    component, \
-    level, \
-    preprocessor, \
-    __FILE__, __LINE__)
-
-#define YQL_CVLOG(level, component) \
-    YQL_CVLOG_PREP(level, component, ::NYql::NLog::TContextPreprocessor)
-
-#define YQL_CVLOG_ACTIVE(level, component) ::NYql::NLog::YqlLogger().NeedToLog( \
-    component, \
-    level)
-
+// with component/level values logger 
+ 
+#define YQL_CVLOG_PREP(level, component, preprocessor) YQL_LOG_IMPL(\ 
+    ::NYql::NLog::YqlLogger(), \ 
+    component, \ 
+    level, \ 
+    preprocessor, \ 
+    __FILE__, __LINE__) 
+ 
+#define YQL_CVLOG(level, component) \ 
+    YQL_CVLOG_PREP(level, component, ::NYql::NLog::TContextPreprocessor) 
+ 
+#define YQL_CVLOG_ACTIVE(level, component) ::NYql::NLog::YqlLogger().NeedToLog( \ 
+    component, \ 
+    level) 
+ 
 // default logger
 
 #define YQL_LOG_PREP(level, preprocessor) \
@@ -95,7 +95,7 @@ using TComponentLevels =
  */
 class TYqlLog: public TLog {
 public:
-    TYqlLog();
+    TYqlLog(); 
     TYqlLog(const TString& logType, const TComponentLevels& levels);
     TYqlLog(TAutoPtr<TLogBackend> backend, const TComponentLevels& levels);
 
@@ -103,11 +103,11 @@ public:
     void UpdateProcInfo(const TString& procName);
 
     ELevel GetComponentLevel(EComponent component) const {
-        return ELevelHelpers::FromInt(AtomicGet(ComponentLevels_[EComponentHelpers::ToInt(component)]));
+        return ELevelHelpers::FromInt(AtomicGet(ComponentLevels_[EComponentHelpers::ToInt(component)])); 
     }
 
     void SetComponentLevel(EComponent component, ELevel level) {
-        AtomicSet(ComponentLevels_[EComponentHelpers::ToInt(component)], ELevelHelpers::ToInt(level));
+        AtomicSet(ComponentLevels_[EComponentHelpers::ToInt(component)], ELevelHelpers::ToInt(level)); 
     }
 
     bool NeedToLog(EComponent component, ELevel level) const {
@@ -123,7 +123,7 @@ public:
 private:
     TString ProcName_;
     pid_t ProcId_;
-    std::array<TAtomic, EComponentHelpers::ToInt(EComponent::MaxValue)> ComponentLevels_{0};
+    std::array<TAtomic, EComponentHelpers::ToInt(EComponent::MaxValue)> ComponentLevels_{0}; 
     mutable TAtomic WriteTruncMsg_;
 };
 
@@ -163,17 +163,17 @@ void InitLogger(TAutoPtr<TLogBackend> backend);
  */
 void InitLogger(IOutputStream* out);
 
-void CleanupLogger();
-
-class YqlLoggerScope {
-public:
-    YqlLoggerScope(const TString& log, bool startAsDaemon = false) { InitLogger(log, startAsDaemon); }
-    YqlLoggerScope(TAutoPtr<TLogBackend> backend) { InitLogger(backend); }
-    YqlLoggerScope(IOutputStream* out) { InitLogger(out); }
-
-    ~YqlLoggerScope() { CleanupLogger(); }
-};
-
+void CleanupLogger(); 
+ 
+class YqlLoggerScope { 
+public: 
+    YqlLoggerScope(const TString& log, bool startAsDaemon = false) { InitLogger(log, startAsDaemon); } 
+    YqlLoggerScope(TAutoPtr<TLogBackend> backend) { InitLogger(backend); } 
+    YqlLoggerScope(IOutputStream* out) { InitLogger(out); } 
+ 
+    ~YqlLoggerScope() { CleanupLogger(); } 
+}; 
+ 
 } // namespace NLog
 } // namespace NYql
 
diff --git a/ydb/library/yql/utils/log/log_ut.cpp b/ydb/library/yql/utils/log/log_ut.cpp
index bf8b71476c..8b04967ad1 100644
--- a/ydb/library/yql/utils/log/log_ut.cpp
+++ b/ydb/library/yql/utils/log/log_ut.cpp
@@ -23,7 +23,7 @@ Y_UNIT_TEST_SUITE(TLogTest)
 {
     Y_UNIT_TEST(Format) {
         TStringStream out;
-        YqlLoggerScope logger(&out);
+        YqlLoggerScope logger(&out); 
         YqlLogger().UpdateProcInfo("my_proc");
 
         TString message = "some performance info";
@@ -47,7 +47,7 @@ Y_UNIT_TEST_SUITE(TLogTest)
 
     Y_UNIT_TEST(Levels) {
         TStringStream out;
-        YqlLoggerScope logger(&out); // default log level INFO
+        YqlLoggerScope logger(&out); // default log level INFO 
 
         YQL_LOG(FATAL) << "fatal message";
         YQL_LOG(ERROR) << "error message";
@@ -87,7 +87,7 @@ Y_UNIT_TEST_SUITE(TLogTest)
 
     Y_UNIT_TEST(Components) {
         TStringStream out;
-        YqlLoggerScope logger(&out);
+        YqlLoggerScope logger(&out); 
 
         YQL_CLOG(INFO, Default) << "default message";
         YQL_CLOG(INFO, Core) << "core message";
@@ -166,7 +166,7 @@ Y_UNIT_TEST_SUITE(TLogTest)
 
     Y_UNIT_TEST(Conditional) {
         TStringStream out;
-        YqlLoggerScope logger(&out);
+        YqlLoggerScope logger(&out); 
 
         YQL_LOG_IF(INFO, true) << "default info message";
         YQL_LOG_IF(INFO, false) << "must not be logged";
@@ -193,7 +193,7 @@ Y_UNIT_TEST_SUITE(TLogTest)
 
     Y_UNIT_TEST(Contexts) {
         TStringStream out;
-        YqlLoggerScope logger(&out);
+        YqlLoggerScope logger(&out); 
 
         UNIT_ASSERT_STRINGS_EQUAL(CurrentLogContextPath(), "");
         YQL_LOG(INFO) << "level0 - begin";
@@ -282,7 +282,7 @@ Y_UNIT_TEST_SUITE(TLogTest)
 
     Y_UNIT_TEST(ContextOverride) {
         TStringStream out;
-        YqlLoggerScope logger(&out);
+        YqlLoggerScope logger(&out); 
 
         UNIT_ASSERT_STRINGS_EQUAL(CurrentLogContextPath(), "");
         {
@@ -346,7 +346,7 @@ Y_UNIT_TEST_SUITE(TLogTest)
 
     Y_UNIT_TEST(Profiling) {
         TStringStream out;
-        YqlLoggerScope logger(&out);
+        YqlLoggerScope logger(&out); 
 
         {
             YQL_PROFILE_SCOPE(INFO, "scope1");
@@ -411,7 +411,7 @@ Y_UNIT_TEST_SUITE(TLogTest)
 
     Y_UNIT_TEST(ProfilingFuncs) {
         TStringStream out;
-        YqlLoggerScope logger(&out);
+        YqlLoggerScope logger(&out); 
 
         Func1(1, 2);
         Func2(1, 2);
@@ -451,14 +451,14 @@ Y_UNIT_TEST_SUITE(TLogTest)
         size_t limit = 0;
         {
             TStringStream out;
-            YqlLoggerScope logger(&out);
+            YqlLoggerScope logger(&out); 
             YqlLogger().UpdateProcInfo("proc");
             YQL_CLOG(INFO, Core) << "message1";
             limit = out.Str().length() * 2 - 7; // Not more than 2 log lines
         }
 
         TStringStream out;
-        YqlLoggerScope logger(&out);
+        YqlLoggerScope logger(&out); 
         YqlLogger().UpdateProcInfo("proc");
         YqlLogger().SetMaxLogLimit(limit);
 
@@ -493,14 +493,14 @@ Y_UNIT_TEST_SUITE(TLogTest)
         size_t limit = 0;
         {
             TStringStream out;
-            YqlLoggerScope logger(&out);
+            YqlLoggerScope logger(&out); 
             YqlLogger().UpdateProcInfo("proc");
             YQL_CLOG(INFO, Core) << "message1";
             limit = out.Str().length() * 2 - 7; // Not more than 2 log lines
         }
 
         TStringStream out;
-        YqlLoggerScope logger(&out);
+        YqlLoggerScope logger(&out); 
         YqlLogger().UpdateProcInfo("proc");
         YqlLogger().SetMaxLogLimit(limit);
 
diff --git a/ydb/library/yql/utils/log/tls_backend.h b/ydb/library/yql/utils/log/tls_backend.h
index 69a0955432..0313f5b70d 100644
--- a/ydb/library/yql/utils/log/tls_backend.h
+++ b/ydb/library/yql/utils/log/tls_backend.h
@@ -49,7 +49,7 @@ template <typename TBackend>
 class TScopedBackend: public TBackend {
 public:
     template <typename... TArgs>
-    TScopedBackend(TArgs&&... args)
+    TScopedBackend(TArgs&&... args) 
         : TBackend(std::forward<TArgs>(args)...)
         , PrevBacked_(SetLogBackendForCurrentThread(this))
     {
diff --git a/ydb/library/yql/utils/log/tls_backend_ut.cpp b/ydb/library/yql/utils/log/tls_backend_ut.cpp
index 6f4147fed6..eef5d58efb 100644
--- a/ydb/library/yql/utils/log/tls_backend_ut.cpp
+++ b/ydb/library/yql/utils/log/tls_backend_ut.cpp
@@ -51,7 +51,7 @@ private:
 Y_UNIT_TEST_SUITE(TTlsLogBackendTest)
 {
     Y_UNIT_TEST(CaptureOutputs) {
-        YqlLoggerScope logger(new TTlsLogBackend(new TNullLogBackend));
+        YqlLoggerScope logger(new TTlsLogBackend(new TNullLogBackend)); 
 
         YQL_LOG(INFO) << "this message will be missed";
 
diff --git a/ydb/public/api/grpc/draft/dummy.proto b/ydb/public/api/grpc/draft/dummy.proto
index 9a2a17f0d8..523ab5e9ad 100644
--- a/ydb/public/api/grpc/draft/dummy.proto
+++ b/ydb/public/api/grpc/draft/dummy.proto
@@ -2,7 +2,7 @@ syntax = "proto3";
 option cc_enable_arenas = true;
 
 import "ydb/public/api/protos/ydb_operation.proto";
-
+ 
 package Draft.Dummy;
 
 message PingRequest {
@@ -14,17 +14,17 @@ message PingResponse {
     bytes payload = 1;
 }
 
-message InfiniteRequest {
-    Ydb.Operations.OperationParams operation_params = 1;
-}
-
-message InfiniteResponse {
-    Ydb.Operations.Operation operation = 1;
-}
-
+message InfiniteRequest { 
+    Ydb.Operations.OperationParams operation_params = 1; 
+} 
+ 
+message InfiniteResponse { 
+    Ydb.Operations.Operation operation = 1; 
+} 
+ 
 service DummyService {
     rpc Ping(PingRequest) returns (PingResponse);
-    rpc Infinite(InfiniteRequest) returns (InfiniteResponse);
+    rpc Infinite(InfiniteRequest) returns (InfiniteResponse); 
     rpc BiStreamPing(stream PingRequest) returns (stream PingResponse);
 }
 
diff --git a/ydb/public/api/grpc/draft/ydb_experimental_v1.proto b/ydb/public/api/grpc/draft/ydb_experimental_v1.proto
index 003ab6d671..fe3f1c75f4 100644
--- a/ydb/public/api/grpc/draft/ydb_experimental_v1.proto
+++ b/ydb/public/api/grpc/draft/ydb_experimental_v1.proto
@@ -6,6 +6,6 @@ option java_package = "com.yandex.ydb.experimental.v1";
 import "ydb/public/api/protos/ydb_experimental.proto";
 
 service ExperimentalService {
-    rpc ExecuteStreamQuery(Experimental.ExecuteStreamQueryRequest) returns (stream Experimental.ExecuteStreamQueryResponse);
+    rpc ExecuteStreamQuery(Experimental.ExecuteStreamQueryRequest) returns (stream Experimental.ExecuteStreamQueryResponse); 
 }
 
diff --git a/ydb/public/api/grpc/ya.make b/ydb/public/api/grpc/ya.make
index 24173a0264..3157b200ce 100644
--- a/ydb/public/api/grpc/ya.make
+++ b/ydb/public/api/grpc/ya.make
@@ -22,7 +22,7 @@ SRCS(
     ydb_cms_v1.proto
     ydb_rate_limiter_v1.proto
     ydb_scheme_v1.proto
-    ydb_scripting_v1.proto
+    ydb_scripting_v1.proto 
     ydb_table_v1.proto
     yq_v1.proto
 )
diff --git a/ydb/public/api/grpc/ydb_operation_v1.proto b/ydb/public/api/grpc/ydb_operation_v1.proto
index 8202d08484..bc44db76b2 100644
--- a/ydb/public/api/grpc/ydb_operation_v1.proto
+++ b/ydb/public/api/grpc/ydb_operation_v1.proto
@@ -16,7 +16,7 @@ import "ydb/public/api/protos/ydb_operation.proto";
 // operation id provided in 'id' field of Operation.
 //
 // Note: Currently some operations have synchronous implementation and their result
-// is available when response is obtained. But a client must not make any
+// is available when response is obtained. But a client must not make any 
 // assumptions about synchronous or asynchronous nature of any operation and
 // be ready to poll operation status.
 
diff --git a/ydb/public/api/grpc/ydb_scripting_v1.proto b/ydb/public/api/grpc/ydb_scripting_v1.proto
index c8743a07de..74b032b5e7 100644
--- a/ydb/public/api/grpc/ydb_scripting_v1.proto
+++ b/ydb/public/api/grpc/ydb_scripting_v1.proto
@@ -1,15 +1,15 @@
-syntax = "proto3";
-
-package Ydb.Scripting.V1;
+syntax = "proto3"; 
+ 
+package Ydb.Scripting.V1; 
 option java_package = "com.yandex.ydb.scripting.v1";
-
+ 
 import "ydb/public/api/protos/ydb_scripting.proto";
-
-service ScriptingService {
-    rpc ExecuteYql(Scripting.ExecuteYqlRequest) returns (Scripting.ExecuteYqlResponse);
+ 
+service ScriptingService { 
+    rpc ExecuteYql(Scripting.ExecuteYqlRequest) returns (Scripting.ExecuteYqlResponse); 
 
     // Executes yql request with streaming result.
     rpc StreamExecuteYql(Scripting.ExecuteYqlRequest) returns (stream Scripting.ExecuteYqlPartialResponse);
 
     rpc ExplainYql(Scripting.ExplainYqlRequest) returns (Scripting.ExplainYqlResponse);
-}
+} 
diff --git a/ydb/public/api/grpc/ydb_table_v1.proto b/ydb/public/api/grpc/ydb_table_v1.proto
index dbbf62c5c8..27c00b9ae2 100644
--- a/ydb/public/api/grpc/ydb_table_v1.proto
+++ b/ydb/public/api/grpc/ydb_table_v1.proto
@@ -27,7 +27,7 @@ service TableService {
 
     // Drop table.
     rpc DropTable(Table.DropTableRequest) returns (Table.DropTableResponse);
-
+ 
     // Modifies schema of given table.
     rpc AlterTable(Table.AlterTableRequest) returns (Table.AlterTableResponse);
 
@@ -46,26 +46,26 @@ service TableService {
     // Explains data query.
     // SessionId of previously created session must be provided.
     rpc ExplainDataQuery(Table.ExplainDataQueryRequest) returns (Table.ExplainDataQueryResponse);
-
-    // Prepares data query, returns query id.
+ 
+    // Prepares data query, returns query id. 
     // SessionId of previously created session must be provided.
     rpc PrepareDataQuery(Table.PrepareDataQueryRequest) returns (Table.PrepareDataQueryResponse);
-
+ 
     // Executes data query.
-    // SessionId of previously created session must be provided.
+    // SessionId of previously created session must be provided. 
     rpc ExecuteDataQuery(Table.ExecuteDataQueryRequest) returns (Table.ExecuteDataQueryResponse);
-
+ 
     // Executes scheme query.
-    // SessionId of previously created session must be provided.
+    // SessionId of previously created session must be provided. 
     rpc ExecuteSchemeQuery(Table.ExecuteSchemeQueryRequest) returns (Table.ExecuteSchemeQueryResponse);
-
-    // Begins new transaction.
+ 
+    // Begins new transaction. 
     rpc BeginTransaction(Table.BeginTransactionRequest) returns (Table.BeginTransactionResponse);
-
-    // Commits specified active transaction.
+ 
+    // Commits specified active transaction. 
     rpc CommitTransaction(Table.CommitTransactionRequest) returns (Table.CommitTransactionResponse);
-
-    // Performs a rollback of the specified active transaction.
+ 
+    // Performs a rollback of the specified active transaction. 
     rpc RollbackTransaction(Table.RollbackTransactionRequest) returns (Table.RollbackTransactionResponse);
 
     // Describe supported table options.
@@ -78,7 +78,7 @@ service TableService {
     // Returns success only when all rows were successfully upserted. In case of an error some rows might
     // be upserted and some might not.
     rpc BulkUpsert(Table.BulkUpsertRequest) returns (Table.BulkUpsertResponse);
-
-    // Executes scan query with streaming result.
-    rpc StreamExecuteScanQuery(Table.ExecuteScanQueryRequest) returns (stream Table.ExecuteScanQueryPartialResponse);
+ 
+    // Executes scan query with streaming result. 
+    rpc StreamExecuteScanQuery(Table.ExecuteScanQueryRequest) returns (stream Table.ExecuteScanQueryPartialResponse); 
 }
diff --git a/ydb/public/api/protos/ya.make b/ydb/public/api/protos/ya.make
index 8a156403a3..d88f12cb0e 100644
--- a/ydb/public/api/protos/ya.make
+++ b/ydb/public/api/protos/ya.make
@@ -26,7 +26,7 @@ SRCS(
     ydb_persqueue_cluster_discovery.proto
     ydb_clickhouse_internal.proto
     ydb_cms.proto
-    ydb_common.proto
+    ydb_common.proto 
     ydb_coordination.proto
     ydb_discovery.proto
     ydb_experimental.proto
@@ -39,10 +39,10 @@ SRCS(
     ydb_query_stats.proto
     ydb_rate_limiter.proto
     ydb_scheme.proto
-    ydb_scripting.proto
-    ydb_status_codes.proto
+    ydb_scripting.proto 
+    ydb_status_codes.proto 
     ydb_table.proto
-    ydb_value.proto
+    ydb_value.proto 
     ydb_s3_internal.proto
     yq.proto
 )
diff --git a/ydb/public/api/protos/ydb_cms.proto b/ydb/public/api/protos/ydb_cms.proto
index 1a569c7081..34b68c5e51 100644
--- a/ydb/public/api/protos/ydb_cms.proto
+++ b/ydb/public/api/protos/ydb_cms.proto
@@ -131,8 +131,8 @@ message CreateDatabaseResponse {
 message GetDatabaseStatusRequest {
     // Required. Full path to database's home dir.
     string path = 1;
-    // Operation parameters
-    Ydb.Operations.OperationParams operation_params = 2;
+    // Operation parameters 
+    Ydb.Operations.OperationParams operation_params = 2; 
 }
 
 message GetDatabaseStatusResponse {
@@ -188,7 +188,7 @@ message AlterDatabaseRequest {
     // Externally allocated computational units to deregister.
     repeated AllocatedComputationalUnit computational_units_to_deregister = 6;
     // Operation parameters.
-    Ydb.Operations.OperationParams operation_params = 7;
+    Ydb.Operations.OperationParams operation_params = 7; 
     // Current generation of altered database.
     uint64 generation = 8;
     // Change quotas for schema operations
@@ -207,8 +207,8 @@ message AlterDatabaseResponse {
 
 // List all databases known by CMS.
 message ListDatabasesRequest {
-    // Operation parameters
-    Ydb.Operations.OperationParams operation_params = 1;
+    // Operation parameters 
+    Ydb.Operations.OperationParams operation_params = 1; 
 }
 
 message ListDatabasesResponse {
@@ -249,8 +249,8 @@ message ComputationalUnitDescription {
 }
 
 message DescribeDatabaseOptionsRequest {
-    // Operation parameters
-    Ydb.Operations.OperationParams operation_params = 1;
+    // Operation parameters 
+    Ydb.Operations.OperationParams operation_params = 1; 
 }
 
 message DescribeDatabaseOptionsResponse {
diff --git a/ydb/public/api/protos/ydb_common.proto b/ydb/public/api/protos/ydb_common.proto
index a63e202f82..462757f71c 100644
--- a/ydb/public/api/protos/ydb_common.proto
+++ b/ydb/public/api/protos/ydb_common.proto
@@ -1,19 +1,19 @@
-syntax = "proto3";
-option cc_enable_arenas = true;
-
+syntax = "proto3"; 
+option cc_enable_arenas = true; 
+ 
 package Ydb;
 option java_package = "com.yandex.ydb.common";
-option java_outer_classname = "CommonProtos";
-
-message FeatureFlag {
-    enum Status {
-        STATUS_UNSPECIFIED = 0;
-        ENABLED = 1;
-        DISABLED = 2;
-    }
-}
-
-message CostInfo {
-    // Total amount of request units (RU), consumed by the operation.
-    double consumed_units = 1;
+option java_outer_classname = "CommonProtos"; 
+ 
+message FeatureFlag { 
+    enum Status { 
+        STATUS_UNSPECIFIED = 0; 
+        ENABLED = 1; 
+        DISABLED = 2; 
+    } 
 }
+ 
+message CostInfo { 
+    // Total amount of request units (RU), consumed by the operation. 
+    double consumed_units = 1; 
+} 
diff --git a/ydb/public/api/protos/ydb_coordination.proto b/ydb/public/api/protos/ydb_coordination.proto
index 378045e78e..0726480b18 100644
--- a/ydb/public/api/protos/ydb_coordination.proto
+++ b/ydb/public/api/protos/ydb_coordination.proto
@@ -455,7 +455,7 @@ message SessionResponse {
 message CreateNodeRequest {
     string path = 1;
     Config config = 2;
-    Ydb.Operations.OperationParams operation_params = 3;
+    Ydb.Operations.OperationParams operation_params = 3; 
 }
 
 message CreateNodeResponse {
@@ -465,7 +465,7 @@ message CreateNodeResponse {
 message AlterNodeRequest {
     string path = 1;
     Config config = 2;
-    Ydb.Operations.OperationParams operation_params = 3;
+    Ydb.Operations.OperationParams operation_params = 3; 
 }
 
 message AlterNodeResponse {
@@ -474,7 +474,7 @@ message AlterNodeResponse {
 
 message DropNodeRequest {
     string path = 1;
-    Ydb.Operations.OperationParams operation_params = 2;
+    Ydb.Operations.OperationParams operation_params = 2; 
 }
 
 message DropNodeResponse {
@@ -483,7 +483,7 @@ message DropNodeResponse {
 
 message DescribeNodeRequest {
     string path = 1;
-    Ydb.Operations.OperationParams operation_params = 2;
+    Ydb.Operations.OperationParams operation_params = 2; 
 }
 
 message DescribeNodeResponse {
diff --git a/ydb/public/api/protos/ydb_experimental.proto b/ydb/public/api/protos/ydb_experimental.proto
index 94eed9671b..d8b1208b52 100644
--- a/ydb/public/api/protos/ydb_experimental.proto
+++ b/ydb/public/api/protos/ydb_experimental.proto
@@ -10,31 +10,31 @@ import "ydb/public/api/protos/ydb_status_codes.proto";
 import "ydb/public/api/protos/ydb_value.proto";
 
 
-message ExecuteStreamQueryRequest {
-    string yql_text = 1;
-    map<string, TypedValue> parameters = 2;
+message ExecuteStreamQueryRequest { 
+    string yql_text = 1; 
+    map<string, TypedValue> parameters = 2; 
 
     enum ProfileMode {
         PROFILE_MODE_UNSPECIFIED = 0;
         NONE = 1;
-        BASIC = 2;
-        FULL = 3;
+        BASIC = 2; 
+        FULL = 3; 
     }
 
     ProfileMode profile_mode = 3;
     bool explain = 4;
 }
-
-message ExecuteStreamQueryResponse {
-    StatusIds.StatusCode status = 1;
-    repeated Ydb.Issue.IssueMessage issues = 2;
-    ExecuteStreamQueryResult result = 3;
+ 
+message ExecuteStreamQueryResponse { 
+    StatusIds.StatusCode status = 1; 
+    repeated Ydb.Issue.IssueMessage issues = 2; 
+    ExecuteStreamQueryResult result = 3; 
 }
-
+ 
 message StreamQueryProgress {
 }
 
-message ExecuteStreamQueryResult {
+message ExecuteStreamQueryResult { 
     oneof result {
         Ydb.ResultSet result_set = 1;
         string profile = 2;
diff --git a/ydb/public/api/protos/ydb_operation.proto b/ydb/public/api/protos/ydb_operation.proto
index 30ddd002a2..ef219dd0c4 100644
--- a/ydb/public/api/protos/ydb_operation.proto
+++ b/ydb/public/api/protos/ydb_operation.proto
@@ -2,7 +2,7 @@ syntax = "proto3";
 option cc_enable_arenas = true;
 
 import "google/protobuf/any.proto";
-import "google/protobuf/duration.proto";
+import "google/protobuf/duration.proto"; 
 
 import "ydb/public/api/protos/annotations/validation.proto";
 import "ydb/public/api/protos/ydb_common.proto";
@@ -17,37 +17,37 @@ option java_outer_classname = "OperationProtos";
 message OperationParams {
     enum OperationMode {
         OPERATION_MODE_UNSPECIFIED = 0;
-
-        // Server will only reply once operation is finished (ready=true), and operation object won't be
-        // accessible after the reply. This is a basic request-response mode.
-        SYNC = 1;
+ 
+        // Server will only reply once operation is finished (ready=true), and operation object won't be 
+        // accessible after the reply. This is a basic request-response mode. 
+        SYNC = 1; 
 
         ASYNC = 2;
     }
 
     OperationMode operation_mode = 1;
-
-    // Indicates that client is no longer interested in the result of operation after the specified duration
-    // starting from the time operation arrives at the server.
-    // Server will try to stop the execution of operation and if no result is currently available the operation
-    // will receive TIMEOUT status code, which will be sent back to client if it was waiting for the operation result.
-    // Timeout of operation does not tell anything about its result, it might be completed successfully
-    // or cancelled on server.
-    google.protobuf.Duration operation_timeout = 2;
-
-    // Server will try to cancel the operation after the specified duration starting from the time
-    // the operation arrives at server.
-    // In case of successful cancellation operation will receive CANCELLED status code, which will be
-    // sent back to client if it was waiting for the operation result.
-    // In case when cancellation isn't possible, no action will be performed.
-    google.protobuf.Duration cancel_after = 3;
+ 
+    // Indicates that client is no longer interested in the result of operation after the specified duration 
+    // starting from the time operation arrives at the server. 
+    // Server will try to stop the execution of operation and if no result is currently available the operation 
+    // will receive TIMEOUT status code, which will be sent back to client if it was waiting for the operation result. 
+    // Timeout of operation does not tell anything about its result, it might be completed successfully 
+    // or cancelled on server. 
+    google.protobuf.Duration operation_timeout = 2; 
+ 
+    // Server will try to cancel the operation after the specified duration starting from the time 
+    // the operation arrives at server. 
+    // In case of successful cancellation operation will receive CANCELLED status code, which will be 
+    // sent back to client if it was waiting for the operation result. 
+    // In case when cancellation isn't possible, no action will be performed. 
+    google.protobuf.Duration cancel_after = 3; 
 
     // User-defined labels of operation.
     map<string, string> labels = 4 [(map_key).length.le = 128, (length).le = 128];
-
-    // If enabled, server will report cost information, if supported by the operation.
-    // This flag is mostly useful for SYNC operations, to get the cost information in the response.
-    Ydb.FeatureFlag.Status report_cost_info = 5;
+ 
+    // If enabled, server will report cost information, if supported by the operation. 
+    // This flag is mostly useful for SYNC operations, to get the cost information in the response. 
+    Ydb.FeatureFlag.Status report_cost_info = 5; 
 }
 
 message GetOperationRequest {
@@ -90,8 +90,8 @@ message ListOperationsResponse {
 }
 
 message Operation {
-    // Identifier of the operation, empty value means no active operation object is present (it was forgotten or
-    // not created in the first place, as in SYNC operation mode).
+    // Identifier of the operation, empty value means no active operation object is present (it was forgotten or 
+    // not created in the first place, as in SYNC operation mode). 
     string id = 1;
 
     // true - this operation has beed finished (doesn't matter successful or not),
@@ -106,10 +106,10 @@ message Operation {
     google.protobuf.Any result = 5;
 
     google.protobuf.Any metadata = 6;
-
-    // Contains information about the cost of the operation.
-    // For completed operations, it shows the final cost of the operation.
-    // For operations in progress, it might indicate the current cost of the operation (if supported).
-    CostInfo cost_info = 7;
+ 
+    // Contains information about the cost of the operation. 
+    // For completed operations, it shows the final cost of the operation. 
+    // For operations in progress, it might indicate the current cost of the operation (if supported). 
+    CostInfo cost_info = 7; 
 }
 
diff --git a/ydb/public/api/protos/ydb_query_stats.proto b/ydb/public/api/protos/ydb_query_stats.proto
index 300d5d9837..39e50bb0f7 100644
--- a/ydb/public/api/protos/ydb_query_stats.proto
+++ b/ydb/public/api/protos/ydb_query_stats.proto
@@ -23,22 +23,22 @@ message TableAccessStats {
 message QueryPhaseStats {
     uint64 duration_us = 1;
     repeated TableAccessStats table_access = 2;
-    uint64 cpu_time_us = 3;
+    uint64 cpu_time_us = 3; 
     uint64 affected_shards = 4;
     bool literal_phase = 5;
 }
 
-message CompilationStats {
-    bool from_cache = 1;
-    uint64 duration_us = 2;
-    uint64 cpu_time_us = 3;
-}
-
+message CompilationStats { 
+    bool from_cache = 1; 
+    uint64 duration_us = 2; 
+    uint64 cpu_time_us = 3; 
+} 
+ 
 message QueryStats {
     // A query might have one or more execution phases
     repeated QueryPhaseStats query_phases = 1;
-    CompilationStats compilation = 2;
-    uint64 process_cpu_time_us = 3;
+    CompilationStats compilation = 2; 
+    uint64 process_cpu_time_us = 3; 
     string query_plan = 4;
     string query_ast = 5;
     uint64 total_duration_us = 6;
diff --git a/ydb/public/api/protos/ydb_s3_internal.proto b/ydb/public/api/protos/ydb_s3_internal.proto
index 0f12fe6302..d460492e29 100644
--- a/ydb/public/api/protos/ydb_s3_internal.proto
+++ b/ydb/public/api/protos/ydb_s3_internal.proto
@@ -25,7 +25,7 @@ message S3ListingResponse {
 }
 
 message S3ListingResult {
-    Ydb.ResultSet common_prefixes = 1;    // Every Contents row starts with key suffix with KeySuffixSize columns
-    Ydb.ResultSet contents = 2;           // Every Contents row starts with key suffix with KeySuffixSize columns
-    uint32 key_suffix_size = 3;           // Number of key columns starting from path and up to the end
+    Ydb.ResultSet common_prefixes = 1;    // Every Contents row starts with key suffix with KeySuffixSize columns 
+    Ydb.ResultSet contents = 2;           // Every Contents row starts with key suffix with KeySuffixSize columns 
+    uint32 key_suffix_size = 3;           // Number of key columns starting from path and up to the end 
 }
diff --git a/ydb/public/api/protos/ydb_scripting.proto b/ydb/public/api/protos/ydb_scripting.proto
index 4c1a295418..8f302905fe 100644
--- a/ydb/public/api/protos/ydb_scripting.proto
+++ b/ydb/public/api/protos/ydb_scripting.proto
@@ -1,33 +1,33 @@
-syntax = "proto3";
-option cc_enable_arenas = true;
-
-package Ydb.Scripting;
+syntax = "proto3"; 
+option cc_enable_arenas = true; 
+ 
+package Ydb.Scripting; 
 option java_package = "com.yandex.ydb.scripting";
-option java_outer_classname = "ScriptingProtos";
-
+option java_outer_classname = "ScriptingProtos"; 
+ 
 import "ydb/public/api/protos/ydb_operation.proto";
 import "ydb/public/api/protos/ydb_value.proto";
-
-// TODO: Refactor to ydb_query usage.
+ 
+// TODO: Refactor to ydb_query usage. 
 import "ydb/public/api/protos/ydb_table.proto";
 import "ydb/public/api/protos/ydb_query_stats.proto";
 import "ydb/public/api/protos/ydb_issue_message.proto";
 import "ydb/public/api/protos/ydb_status_codes.proto";
-
-message ExecuteYqlRequest {
-    Ydb.Operations.OperationParams operation_params = 1;
-    string script = 2;
-    map<string, TypedValue> parameters = 3;
-    Ydb.Table.QueryStatsCollection.Mode collect_stats = 4;
+ 
+message ExecuteYqlRequest { 
+    Ydb.Operations.OperationParams operation_params = 1; 
+    string script = 2; 
+    map<string, TypedValue> parameters = 3; 
+    Ydb.Table.QueryStatsCollection.Mode collect_stats = 4; 
 }
-
-message ExecuteYqlResponse {
-    Ydb.Operations.Operation operation = 1;
+ 
+message ExecuteYqlResponse { 
+    Ydb.Operations.Operation operation = 1; 
 }
-
-message ExecuteYqlResult {
-    repeated Ydb.ResultSet result_sets = 1;
-    Ydb.TableStats.QueryStats query_stats = 2;
+ 
+message ExecuteYqlResult { 
+    repeated Ydb.ResultSet result_sets = 1; 
+    Ydb.TableStats.QueryStats query_stats = 2; 
 }
 
 // Response for StreamExecuteYql is a stream of ExecuteYqlPartialResponse messages.
diff --git a/ydb/public/api/protos/ydb_status_codes.proto b/ydb/public/api/protos/ydb_status_codes.proto
index 4c500dc43a..fabb36a641 100644
--- a/ydb/public/api/protos/ydb_status_codes.proto
+++ b/ydb/public/api/protos/ydb_status_codes.proto
@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-package Ydb;
+package Ydb; 
 option java_package = "com.yandex.ydb";
 option java_outer_classname = "StatusCodesProtos";
 
@@ -8,25 +8,25 @@ message StatusIds {
     // reserved range [400000, 400999]
     enum StatusCode {
         STATUS_CODE_UNSPECIFIED =    0;
-        SUCCESS =             400000;
-        BAD_REQUEST =         400010;
-        UNAUTHORIZED =        400020;
-        INTERNAL_ERROR =      400030;
-        ABORTED =             400040;
-        UNAVAILABLE =         400050;
-        OVERLOADED =          400060;
-        SCHEME_ERROR =        400070;
-        GENERIC_ERROR =       400080;
-        TIMEOUT =             400090;
-        BAD_SESSION =         400100;
-        PRECONDITION_FAILED = 400120;
+        SUCCESS =             400000; 
+        BAD_REQUEST =         400010; 
+        UNAUTHORIZED =        400020; 
+        INTERNAL_ERROR =      400030; 
+        ABORTED =             400040; 
+        UNAVAILABLE =         400050; 
+        OVERLOADED =          400060; 
+        SCHEME_ERROR =        400070; 
+        GENERIC_ERROR =       400080; 
+        TIMEOUT =             400090; 
+        BAD_SESSION =         400100; 
+        PRECONDITION_FAILED = 400120; 
         ALREADY_EXISTS      = 400130;
         NOT_FOUND =           400140;
         SESSION_EXPIRED =     400150;
-        CANCELLED =           400160;
-        UNDETERMINED =        400170;
+        CANCELLED =           400160; 
+        UNDETERMINED =        400170; 
         UNSUPPORTED =         400180;
-        SESSION_BUSY =        400190;
+        SESSION_BUSY =        400190; 
     }
     // reserved range [401000, 402999] for internal client status
 }
diff --git a/ydb/public/api/protos/ydb_table.proto b/ydb/public/api/protos/ydb_table.proto
index c8063d9475..480076906b 100644
--- a/ydb/public/api/protos/ydb_table.proto
+++ b/ydb/public/api/protos/ydb_table.proto
@@ -19,7 +19,7 @@ option java_package = "com.yandex.ydb.table";
 
 // Create new session
 message CreateSessionRequest {
-    Ydb.Operations.OperationParams operation_params = 1;
+    Ydb.Operations.OperationParams operation_params = 1; 
 }
 
 // Create new session
@@ -37,7 +37,7 @@ message CreateSessionResult {
 message DeleteSessionRequest {
     // Session identifier
     string session_id = 1;
-    Ydb.Operations.OperationParams operation_params = 2;
+    Ydb.Operations.OperationParams operation_params = 2; 
 }
 
 message DeleteSessionResponse {
@@ -241,15 +241,15 @@ message TableProfile {
     CachingPolicy caching_policy = 7;
 }
 
-message ColumnMeta {
-    // Name of column
-    string name = 1;
-    // Type of column
-    Type type = 2;
+message ColumnMeta { 
+    // Name of column 
+    string name = 1; 
+    // Type of column 
+    Type type = 2; 
     // Column family name of the column
     string family = 3;
 }
-
+ 
 message DateTypeColumnModeSettings {
     // The row will be considered as expired at the moment of time, when the value
     // stored in <column_name> is less than or equal to the current time (in epoch
@@ -388,7 +388,7 @@ message ReadReplicasSettings {
         // Set total replicas count between all AZs
         uint64 any_az_read_replicas_count = 2;
     }
-
+ 
     // Specify read replicas count for each AZ in cluster
     reserved 3; // cluster_replicas_settings (part of oneof settings)
 }
@@ -399,12 +399,12 @@ message CreateTableRequest {
     // Full path
     string path = 2;
     // Columns (name, type)
-    repeated ColumnMeta columns = 3;
+    repeated ColumnMeta columns = 3; 
     // List of columns used as primary key
     repeated string primary_key = 4;
     // Table profile
     TableProfile profile = 5;
-    Ydb.Operations.OperationParams operation_params = 6;
+    Ydb.Operations.OperationParams operation_params = 6; 
     // List of secondary indexes
     repeated TableIndex indexes = 7;
     // Table rows time to live settings
@@ -444,7 +444,7 @@ message DropTableRequest {
     // Full path
     string path = 2;
     reserved 3;
-    Ydb.Operations.OperationParams operation_params = 4;
+    Ydb.Operations.OperationParams operation_params = 4; 
 }
 
 message DropTableResponse {
@@ -458,10 +458,10 @@ message AlterTableRequest {
     // Full path
     string path = 2;
     // Columns (name, type) to add
-    repeated ColumnMeta add_columns = 3;
+    repeated ColumnMeta add_columns = 3; 
     // Columns to remove
     repeated string drop_columns = 4;
-    Ydb.Operations.OperationParams operation_params = 5;
+    Ydb.Operations.OperationParams operation_params = 5; 
     // Columns to alter
     repeated ColumnMeta alter_columns = 6;
     // Setup or remove time to live settings
@@ -504,7 +504,7 @@ message CopyTableRequest {
     string source_path = 2;
     // Copy to path
     string destination_path = 3;
-    Ydb.Operations.OperationParams operation_params = 4;
+    Ydb.Operations.OperationParams operation_params = 4; 
 }
 
 message CopyTableResponse {
@@ -561,7 +561,7 @@ message DescribeTableRequest {
     string session_id = 1;
     // Full path
     string path = 2;
-    Ydb.Operations.OperationParams operation_params = 4;
+    Ydb.Operations.OperationParams operation_params = 4; 
     // Includes shard key distribution info
     bool include_shard_key_bounds = 5;
     // Includes table statistics
@@ -579,7 +579,7 @@ message DescribeTableResult {
     // Description of scheme object
     Ydb.Scheme.Entry self = 1;
     // List of columns
-    repeated ColumnMeta columns = 2;
+    repeated ColumnMeta columns = 2; 
     // List of primary key columns
     repeated string primary_key = 3;
     // List of key ranges for shard
@@ -606,144 +606,144 @@ message DescribeTableResult {
     ReadReplicasSettings read_replicas_settings = 14;
 }
 
-message Query {
+message Query { 
     // Text of query or id prepared query
-    oneof query {
+    oneof query { 
         // SQL program
-        string yql_text = 1;
+        string yql_text = 1; 
         // Prepared query id
-        string id = 2;
-    }
-}
-
-message SerializableModeSettings {
-}
-
-message OnlineModeSettings {
-    bool allow_inconsistent_reads = 1;
-}
-
-message StaleModeSettings {
-}
-
-message TransactionSettings {
-    oneof tx_mode {
-        SerializableModeSettings serializable_read_write = 1;
-        OnlineModeSettings online_read_only = 2;
-        StaleModeSettings stale_read_only = 3;
-    }
-}
-
-message TransactionControl {
-    oneof tx_selector {
-        string tx_id = 1;
-        TransactionSettings begin_tx = 2;
-    }
-
-    bool commit_tx = 10;
-}
-
-message QueryCachePolicy {
-    bool keep_in_cache = 1;
-}
-
-// Collect and return query execution stats
-message QueryStatsCollection {
-    enum Mode {
-        STATS_COLLECTION_UNSPECIFIED = 0;
-        STATS_COLLECTION_NONE = 1;       // Stats collection is disabled
-        STATS_COLLECTION_BASIC = 2;      // Aggregated stats of reads, updates and deletes per table
+        string id = 2; 
+    } 
+} 
+ 
+message SerializableModeSettings { 
+}
+ 
+message OnlineModeSettings { 
+    bool allow_inconsistent_reads = 1; 
+}
+ 
+message StaleModeSettings { 
+} 
+ 
+message TransactionSettings { 
+    oneof tx_mode { 
+        SerializableModeSettings serializable_read_write = 1; 
+        OnlineModeSettings online_read_only = 2; 
+        StaleModeSettings stale_read_only = 3; 
+    } 
+} 
+ 
+message TransactionControl { 
+    oneof tx_selector { 
+        string tx_id = 1; 
+        TransactionSettings begin_tx = 2; 
+    } 
+ 
+    bool commit_tx = 10; 
+} 
+ 
+message QueryCachePolicy { 
+    bool keep_in_cache = 1; 
+}
+ 
+// Collect and return query execution stats 
+message QueryStatsCollection { 
+    enum Mode { 
+        STATS_COLLECTION_UNSPECIFIED = 0; 
+        STATS_COLLECTION_NONE = 1;       // Stats collection is disabled 
+        STATS_COLLECTION_BASIC = 2;      // Aggregated stats of reads, updates and deletes per table 
         STATS_COLLECTION_FULL = 3;       // Add execution stats and plan on top of STATS_COLLECTION_BASIC
-    }
-}
-
-message ExecuteDataQueryRequest {
+    } 
+} 
+ 
+message ExecuteDataQueryRequest { 
     // Session identifier
-    string session_id = 1;
-    TransactionControl tx_control = 2;
-    Query query = 3;
+    string session_id = 1; 
+    TransactionControl tx_control = 2; 
+    Query query = 3; 
     // Map of query parameters (optional)
     map<string, TypedValue> parameters = 4;
-    QueryCachePolicy query_cache_policy = 5;
-    Ydb.Operations.OperationParams operation_params = 6;
-    QueryStatsCollection.Mode collect_stats = 7;
+    QueryCachePolicy query_cache_policy = 5; 
+    Ydb.Operations.OperationParams operation_params = 6; 
+    QueryStatsCollection.Mode collect_stats = 7; 
 }
-
-message ExecuteDataQueryResponse {
+ 
+message ExecuteDataQueryResponse { 
     Ydb.Operations.Operation operation = 1;
 }
-
-message ExecuteSchemeQueryRequest {
+ 
+message ExecuteSchemeQueryRequest { 
     // Session identifier
-    string session_id = 1;
+    string session_id = 1; 
     // SQL text
-    string yql_text = 2;
-    Ydb.Operations.OperationParams operation_params = 3;
+    string yql_text = 2; 
+    Ydb.Operations.OperationParams operation_params = 3; 
 }
-
-message ExecuteSchemeQueryResponse {
+ 
+message ExecuteSchemeQueryResponse { 
     Ydb.Operations.Operation operation = 1;
 }
-
+ 
 // Holds transaction id
-message TransactionMeta {
+message TransactionMeta { 
     // Transaction identifier
-    string id = 1;
-}
-
+    string id = 1; 
+} 
+ 
 // Holds query id and type of parameters
-message QueryMeta {
+message QueryMeta { 
     // Query identifier
-    string id = 1;
+    string id = 1; 
     // Type of parameters
-    map<string, Type> parameters_types = 2;
-}
-
+    map<string, Type> parameters_types = 2; 
+} 
+ 
 // One QueryResult can contain multiple tables
 message ExecuteQueryResult {
     // Result rets (for each table)
-    repeated Ydb.ResultSet result_sets = 1;
+    repeated Ydb.ResultSet result_sets = 1; 
     // Transaction metadata
-    TransactionMeta tx_meta = 2;
+    TransactionMeta tx_meta = 2; 
     // Query metadata
-    QueryMeta query_meta = 3;
+    QueryMeta query_meta = 3; 
     // Query execution statistics
     Ydb.TableStats.QueryStats query_stats = 4;
 }
 
 // Explain data query
-message ExplainDataQueryRequest {
+message ExplainDataQueryRequest { 
     // Session identifier
-    string session_id = 1;
+    string session_id = 1; 
     // SQL text to explain
-    string yql_text = 2;
-    Ydb.Operations.OperationParams operation_params = 3;
+    string yql_text = 2; 
+    Ydb.Operations.OperationParams operation_params = 3; 
 }
-
-message ExplainDataQueryResponse {
+ 
+message ExplainDataQueryResponse { 
     // Holds ExplainQueryResult in case of successful call
     Ydb.Operations.Operation operation = 1;
 }
-
+ 
 message ExplainQueryResult {
     string query_ast = 1;
     string query_plan = 2;
 }
 
 // Prepare given program to execute
-message PrepareDataQueryRequest {
+message PrepareDataQueryRequest { 
     // Session identifier
-    string session_id = 1;
+    string session_id = 1; 
     // SQL text
-    string yql_text = 2;
-    Ydb.Operations.OperationParams operation_params = 3;
+    string yql_text = 2; 
+    Ydb.Operations.OperationParams operation_params = 3; 
 }
-
-message PrepareDataQueryResponse {
+ 
+message PrepareDataQueryResponse { 
     // Holds PrepareQueryResult in case of successful call
     Ydb.Operations.Operation operation = 1;
 }
-
+ 
 message PrepareQueryResult {
     // Query id, used to perform ExecuteDataQuery
     string query_id = 1;
@@ -755,71 +755,71 @@ message PrepareQueryResult {
 message KeepAliveRequest {
     // Session identifier
     string session_id = 1;
-    Ydb.Operations.OperationParams operation_params = 2;
+    Ydb.Operations.OperationParams operation_params = 2; 
 }
 
 message KeepAliveResponse {
     Ydb.Operations.Operation operation = 1;
 }
 
-message KeepAliveResult {
-    enum SessionStatus {
-        SESSION_STATUS_UNSPECIFIED = 0;
-        SESSION_STATUS_READY = 1;
-        SESSION_STATUS_BUSY = 2;
-    }
-
-    SessionStatus session_status = 1;
+message KeepAliveResult { 
+    enum SessionStatus { 
+        SESSION_STATUS_UNSPECIFIED = 0; 
+        SESSION_STATUS_READY = 1; 
+        SESSION_STATUS_BUSY = 2; 
+    } 
+ 
+    SessionStatus session_status = 1; 
 }
-
+ 
 // Begin transaction on given session with given settings
-message BeginTransactionRequest {
+message BeginTransactionRequest { 
     // Session identifier
-    string session_id = 1;
-    TransactionSettings tx_settings = 2;
-    Ydb.Operations.OperationParams operation_params = 3;
+    string session_id = 1; 
+    TransactionSettings tx_settings = 2; 
+    Ydb.Operations.OperationParams operation_params = 3; 
 }
-
-message BeginTransactionResponse {
+ 
+message BeginTransactionResponse { 
     // Holds BeginTransactionResult in case of successful call
     Ydb.Operations.Operation operation = 1;
 }
-
-message BeginTransactionResult {
-    TransactionMeta tx_meta = 1;
+ 
+message BeginTransactionResult { 
+    TransactionMeta tx_meta = 1; 
 }
-
+ 
 // Commit transaction with given session and tx id
-message CommitTransactionRequest {
+message CommitTransactionRequest { 
     // Session identifier
-    string session_id = 1;
+    string session_id = 1; 
     // Transaction identifier
-    string tx_id = 2;
-    Ydb.Operations.OperationParams operation_params = 3;
-    QueryStatsCollection.Mode collect_stats = 4;
+    string tx_id = 2; 
+    Ydb.Operations.OperationParams operation_params = 3; 
+    QueryStatsCollection.Mode collect_stats = 4; 
 }
-
-message CommitTransactionResponse {
+ 
+message CommitTransactionResponse { 
     Ydb.Operations.Operation operation = 1;
 }
-
-message CommitTransactionResult {
-    Ydb.TableStats.QueryStats query_stats = 1;
-}
-
+ 
+message CommitTransactionResult { 
+    Ydb.TableStats.QueryStats query_stats = 1; 
+} 
+ 
 // Rollback transaction with given session and tx id
-message RollbackTransactionRequest {
+message RollbackTransactionRequest { 
     // Session identifier
-    string session_id = 1;
+    string session_id = 1; 
     // Transaction identifier
-    string tx_id = 2;
-    Ydb.Operations.OperationParams operation_params = 3;
+    string tx_id = 2; 
+    Ydb.Operations.OperationParams operation_params = 3; 
 }
-
-message RollbackTransactionResponse {
+ 
+message RollbackTransactionResponse { 
     Ydb.Operations.Operation operation = 1;
 }
-
+ 
 message StoragePolicyDescription {
     string name = 1;
     map<string, string> labels = 2;
@@ -868,7 +868,7 @@ message TableProfileDescription {
 }
 
 message DescribeTableOptionsRequest {
-    Ydb.Operations.OperationParams operation_params = 1;
+    Ydb.Operations.OperationParams operation_params = 1; 
 }
 
 message DescribeTableOptionsResponse {
@@ -891,7 +891,7 @@ message DescribeTableOptionsResult {
 message KeyRange {
     // Left border
     oneof from_bound {
-        // Specify if we don't want to include given key
+        // Specify if we don't want to include given key 
         TypedValue greater = 1;
         // Specify if we want to include given key
         TypedValue greater_or_equal = 2;
@@ -899,7 +899,7 @@ message KeyRange {
 
     // Right border
     oneof to_bound {
-        // Specify if we don't want to include given key
+        // Specify if we don't want to include given key 
         TypedValue less = 3;
         // Specify if we want to include given key
         TypedValue less_or_equal = 4;
@@ -937,7 +937,7 @@ message ReadTableResponse {
 // Result of read table request
 message ReadTableResult {
     // Result set (same as result of sql request)
-    Ydb.ResultSet result_set = 1;
+    Ydb.ResultSet result_set = 1; 
 }
 
 message BulkUpsertRequest {
@@ -965,36 +965,36 @@ message BulkUpsertResponse {
 message BulkUpsertResult {
 }
 
-message ExecuteScanQueryRequest {
-    enum Mode {
-        MODE_UNSPECIFIED = 0;
+message ExecuteScanQueryRequest { 
+    enum Mode { 
+        MODE_UNSPECIFIED = 0; 
         MODE_EXPLAIN = 1;
-        // MODE_PREPARE = 2;
-        MODE_EXEC = 3;
-    }
-
-    reserved 1; // session_id
-    reserved 2; // tx_control
-    Query query = 3;
-    map<string, TypedValue> parameters = 4;
-    reserved 5; // query_cache_policy
-    Mode mode = 6;
-    reserved 7; // report_progress
+        // MODE_PREPARE = 2; 
+        MODE_EXEC = 3; 
+    } 
+ 
+    reserved 1; // session_id 
+    reserved 2; // tx_control 
+    Query query = 3; 
+    map<string, TypedValue> parameters = 4; 
+    reserved 5; // query_cache_policy 
+    Mode mode = 6; 
+    reserved 7; // report_progress 
     QueryStatsCollection.Mode collect_stats = 8;
-}
-
-message ExecuteScanQueryPartialResponse {
-    StatusIds.StatusCode status = 1;
-    repeated Ydb.Issue.IssueMessage issues = 2;
-    ExecuteScanQueryPartialResult result = 3;
-}
-
-message ExecuteScanQueryPartialResult {
-    Ydb.ResultSet result_set = 1;
-    reserved 2; // tx_meta
-    reserved 3; // query_meta
-    reserved 4; // query_progress
-    reserved 5; // query_plan
+} 
+ 
+message ExecuteScanQueryPartialResponse { 
+    StatusIds.StatusCode status = 1; 
+    repeated Ydb.Issue.IssueMessage issues = 2; 
+    ExecuteScanQueryPartialResult result = 3; 
+} 
+ 
+message ExecuteScanQueryPartialResult { 
+    Ydb.ResultSet result_set = 1; 
+    reserved 2; // tx_meta 
+    reserved 3; // query_meta 
+    reserved 4; // query_progress 
+    reserved 5; // query_plan 
     Ydb.TableStats.QueryStats query_stats = 6;
-}
-
+} 
+ 
diff --git a/ydb/public/api/protos/ydb_value.proto b/ydb/public/api/protos/ydb_value.proto
index d885d73f8e..4cca0653bd 100644
--- a/ydb/public/api/protos/ydb_value.proto
+++ b/ydb/public/api/protos/ydb_value.proto
@@ -3,13 +3,13 @@ option cc_enable_arenas = true;
 
 import "google/protobuf/struct.proto";
 
-package Ydb;
+package Ydb; 
 option java_package = "com.yandex.ydb";
 option java_outer_classname = "ValueProtos";
 
-message DecimalType {
-    uint32 precision = 1;
-    uint32 scale = 2;
+message DecimalType { 
+    uint32 precision = 1; 
+    uint32 scale = 2; 
 }
 
 message OptionalType {
@@ -20,7 +20,7 @@ message ListType {
     Type item = 1;
 }
 
-message VariantType {
+message VariantType { 
     oneof type {
         TupleType tuple_items = 1;
         StructType struct_items = 2;
@@ -31,13 +31,13 @@ message TupleType {
     repeated Type elements = 1;
 }
 
-message StructMember {
+message StructMember { 
     string name = 1;
     Type type = 2;
 }
 
 message StructType {
-    repeated StructMember members = 1;
+    repeated StructMember members = 1; 
 }
 
 message DictType {
@@ -51,7 +51,7 @@ message TaggedType {
 }
 
 message Type {
-    enum PrimitiveTypeId {
+    enum PrimitiveTypeId { 
         PRIMITIVE_TYPE_ID_UNSPECIFIED = 0x0000;
         BOOL           = 0x0006;
         INT8           = 0x0007;
@@ -79,27 +79,27 @@ message Type {
         JSON_DOCUMENT  = 0x1204;
         DYNUMBER       = 0x1302;
     }
-
-    oneof type {
-        /* Data types */
-        PrimitiveTypeId type_id = 1;
-        DecimalType decimal_type = 2;
-
-        /* Container types */
-        OptionalType optional_type = 101;
-        ListType list_type = 102;
-        TupleType tuple_type = 103;
-        StructType struct_type = 104;
-        DictType dict_type = 105;
-        VariantType variant_type = 106;
+ 
+    oneof type { 
+        /* Data types */ 
+        PrimitiveTypeId type_id = 1; 
+        DecimalType decimal_type = 2; 
+ 
+        /* Container types */ 
+        OptionalType optional_type = 101; 
+        ListType list_type = 102; 
+        TupleType tuple_type = 103; 
+        StructType struct_type = 104; 
+        DictType dict_type = 105; 
+        VariantType variant_type = 106; 
         TaggedType tagged_type = 107;
-
-        /* Special types */
-        google.protobuf.NullValue void_type = 201;
+ 
+        /* Special types */ 
+        google.protobuf.NullValue void_type = 201; 
         google.protobuf.NullValue null_type = 202;
         google.protobuf.NullValue empty_list_type = 203;
         google.protobuf.NullValue empty_dict_type = 204;
-    }
+    } 
 }
 
 /**
@@ -124,7 +124,7 @@ message ValuePair {
  */
 
 message Value {
-    oneof value {
+    oneof value { 
         bool bool_value = 1;
         sfixed32 int32_value = 2;
         fixed32 uint32_value = 3;
@@ -138,7 +138,7 @@ message Value {
         Value nested_value = 11; // Represents nested TValue for Optional<Optional<T>>(Null), or Variant<T> types
         fixed64 low_128 = 15;
     }
-
+ 
     repeated Value items = 12; // Used for List, Tuple, Struct types
     repeated ValuePair pairs = 13; // Used for Dict type
     uint32 variant_index = 14; // Used for Variant type
@@ -150,19 +150,19 @@ message TypedValue {
     Value value = 2;
 }
 
-message Column {
-    // Name of column
-    string name = 1;
-    // Type of column
-    Type type = 2;
+message Column { 
+    // Name of column 
+    string name = 1; 
+    // Type of column 
+    Type type = 2; 
 }
-
-// Represents table-like structure with ordered set of rows and columns
-message ResultSet {
-    // Metadata of columns
-    repeated Column columns = 1;
-    // Rows of table
-    repeated Value rows = 2;
-    // Flag indicates the result was truncated
-    bool truncated = 3;
+ 
+// Represents table-like structure with ordered set of rows and columns 
+message ResultSet { 
+    // Metadata of columns 
+    repeated Column columns = 1; 
+    // Rows of table 
+    repeated Value rows = 2; 
+    // Flag indicates the result was truncated 
+    bool truncated = 3; 
 }
diff --git a/ydb/public/lib/base/defs.h b/ydb/public/lib/base/defs.h
index 97e933c93a..08a81ba77b 100644
--- a/ydb/public/lib/base/defs.h
+++ b/ydb/public/lib/base/defs.h
@@ -69,8 +69,8 @@ namespace NTxProxy {
     XX(ExecError, 52) \
     XX(ExecInProgress, 53) \
     XX(ExecResponseData, 54) \
-    XX(ExecResultUnavailable, 55) \
-    XX(ExecCancelled, 56) \
+    XX(ExecResultUnavailable, 55) \ 
+    XX(ExecCancelled, 56) \ 
     \
     XX(SynthBackendError, 64) \
     XX(SynthNoProxy, 65) \
diff --git a/ydb/public/lib/base/msgbus.cpp b/ydb/public/lib/base/msgbus.cpp
index 3de1861098..c29d5b4583 100644
--- a/ydb/public/lib/base/msgbus.cpp
+++ b/ydb/public/lib/base/msgbus.cpp
@@ -1,45 +1,45 @@
 #include "msgbus.h"
-#include "msgbus_status.h"
+#include "msgbus_status.h" 
 
 namespace NKikimr {
 namespace NMsgBusProxy {
 
 void ExplainProposeTransactionStatus(ui32 status, TString& name, TString& description) {
-    name = ToString(status);
-    description = "Unknown status";
-
+    name = ToString(status); 
+    description = "Unknown status"; 
+ 
     auto field = NKikimrClient::TResponse::descriptor()->FindFieldByNumber(
         NKikimrClient::TResponse::kProxyErrorCodeFieldNumber);
-
+ 
     auto extension = field->options().GetExtension(NKikimrClient::EnumValueHint);
-
-    for (auto item : extension.GetHints()) {
-        if (status == item.GetValue()) {
-            name = item.GetName();
-            description = item.GetMan();
-            break;
-        }
-    }
-}
-
+ 
+    for (auto item : extension.GetHints()) { 
+        if (status == item.GetValue()) { 
+            name = item.GetName(); 
+            description = item.GetMan(); 
+            break; 
+        } 
+    } 
+} 
+ 
 void ExplainExecutionEngineStatus(ui32 status, TString& name, TString& description) {
-    name = ToString(status);
-    description = "Unknown status";
-
+    name = ToString(status); 
+    description = "Unknown status"; 
+ 
     auto field = NKikimrClient::TResponse::descriptor()->FindFieldByNumber(
         NKikimrClient::TResponse::kExecutionEngineStatusFieldNumber);
-
+ 
     auto extension = field->options().GetExtension(NKikimrClient::EnumValueHint);
-
-    for (auto item : extension.GetHints()) {
-        if (status == item.GetValue()) {
-            name = item.GetName();
-            description = item.GetMan();
-            break;
-        }
-    }
-}
-
+ 
+    for (auto item : extension.GetHints()) { 
+        if (status == item.GetValue()) { 
+            name = item.GetName(); 
+            description = item.GetMan(); 
+            break; 
+        } 
+    } 
+} 
+ 
 void ExplainResponseStatus(ui32 status, TString& name, TString& description) {
     name = ToString(status);
     description = "Unknown status";
diff --git a/ydb/public/lib/base/msgbus_status.h b/ydb/public/lib/base/msgbus_status.h
index 15876b170d..50c414092b 100644
--- a/ydb/public/lib/base/msgbus_status.h
+++ b/ydb/public/lib/base/msgbus_status.h
@@ -26,5 +26,5 @@ ENUM_TO_STRING(EResponseStatus, RESPONSE_STATUS_MAP)
 void ExplainProposeTransactionStatus(ui32 status, TString& name, TString& description);
 void ExplainExecutionEngineStatus(ui32 status, TString& name, TString& description);
 void ExplainResponseStatus(ui32 status, TString& name, TString& description);
-
+ 
 }}
diff --git a/ydb/public/lib/deprecated/kicli/cpp_ut.cpp b/ydb/public/lib/deprecated/kicli/cpp_ut.cpp
index cb7dc3ed6d..09d432721c 100644
--- a/ydb/public/lib/deprecated/kicli/cpp_ut.cpp
+++ b/ydb/public/lib/deprecated/kicli/cpp_ut.cpp
@@ -5,55 +5,55 @@
 #include <ydb/core/tx/datashard/datashard_failpoints.h>
 #include <ydb/library/aclib/aclib.h>
 
-#include <util/string/subst.h>
+#include <util/string/subst.h> 
 #include <util/system/valgrind.h>
-
+ 
 #include "kicli.h"
 
 using namespace NKikimr;
 
-namespace {
+namespace { 
 
-Tests::TServer StartupKikimr(NMsgBusProxy::TMsgBusClientConfig& clientConfig,
-    const TAutoPtr<TLogBackend> logBackend = {})
-{
-    TPortManager pm;
-    const ui32 port = pm.GetPort(12001);
+Tests::TServer StartupKikimr(NMsgBusProxy::TMsgBusClientConfig& clientConfig, 
+    const TAutoPtr<TLogBackend> logBackend = {}) 
+{ 
+    TPortManager pm; 
+    const ui32 port = pm.GetPort(12001); 
     auto settings = Tests::TServerSettings(port);
     settings.SetLogBackend(logBackend);
     settings.SetEnableSystemViews(false);
     Tests::TServer Server(settings);
     Tests::TClient Client(settings);
     Client.InitRootScheme();
-    clientConfig = Client.GetClientConfig();
-    return Server;
-}
+    clientConfig = Client.GetClientConfig(); 
+    return Server; 
+} 
 
-Tests::TServer StartupKikimr(NGRpcProxy::TGRpcClientConfig& clientConfig,
+Tests::TServer StartupKikimr(NGRpcProxy::TGRpcClientConfig& clientConfig, 
                              const TAutoPtr<TLogBackend> logBackend = {},
                              const NKikimrConfig::TAppConfig &config = {})
-{
-    TPortManager pm;
-    const ui32 msgbusPort = pm.GetPort(12001);
-    const ui32 grpcPort = pm.GetPort(12002);
-
+{ 
+    TPortManager pm; 
+    const ui32 msgbusPort = pm.GetPort(12001); 
+    const ui32 grpcPort = pm.GetPort(12002); 
+ 
     auto settings = Tests::TServerSettings(msgbusPort);
     settings.SetLogBackend(logBackend);
     settings.AppConfig.CopyFrom(config);
     settings.SetEnableSystemViews(false);
     settings.SetEnableMvcc(false);
-
+ 
     Tests::TServer Server(settings);
-    Server.EnableGRpc(grpcPort);
-
+    Server.EnableGRpc(grpcPort); 
+ 
     Tests::TClient Client(settings);
     Client.InitRootScheme();
 
     clientConfig.Locator = "[::1]:" + ToString(grpcPort);
-
-    return Server;
-}
-
+ 
+    return Server; 
+} 
+ 
 struct TTestEnvironment {
     NMsgBusProxy::TMsgBusClientConfig ClientConfig;
     Tests::TServer Server;
@@ -61,7 +61,7 @@ struct TTestEnvironment {
     NKikimr::NClient::TSchemaObject DC;
     NKikimr::NClient::TSchemaObject Zoo;
     NKikimr::NClient::TSchemaObject Animals;
-
+ 
     TTestEnvironment(const std::initializer_list<NKikimr::NClient::TColumn>& columns = {
                 NClient::TKeyColumn("Id", NClient::TType::Uint64),
                 NClient::TColumn("Species", NClient::TType::Utf8),
@@ -591,12 +591,12 @@ Y_UNIT_TEST_SUITE(ClientLib) {
 
         auto updateQuery = kikimr.Query(
                         "("
-                        "(let id (Parameter 'ID (DataType 'Uint64)))"
+                        "(let id (Parameter 'ID (DataType 'Uint64)))" 
                         "(let row '('('Id id)))"
                         "(let sp (Parameter 'SPECIES (DataType 'Utf8)))"
                         "(let nm (Parameter 'NAME (DataType 'Utf8)))"
                         "(let ds (Parameter 'DESCRIPTION (DataType 'Utf8)))"
-                        "(let wt (Parameter 'WEIGHT (DataType 'Int64)))"
+                        "(let wt (Parameter 'WEIGHT (DataType 'Int64)))" 
                         "(let myUpd '("
                         "  '('Species sp)"
                         "  '('Name nm)"
@@ -609,11 +609,11 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                         ")").SyncPrepare().GetQuery();
         auto selectQuery = kikimr.Query(
                     "("
-                    "(let il (Parameter 'ITEMSLIMIT (DataType 'Uint64)))"
-                    "(let bl (Parameter 'BYTESLIMIT (DataType 'Uint64)))"
+                    "(let il (Parameter 'ITEMSLIMIT (DataType 'Uint64)))" 
+                    "(let bl (Parameter 'BYTESLIMIT (DataType 'Uint64)))" 
                     "(let range '('IncFrom '('Id (Uint64 '1) (Void))))"
                     "(let select '('Species 'Name 'Weight 'Description))"
-                    "(let options '('('ItemsLimit il) '('BytesLimit bl)))"
+                    "(let options '('('ItemsLimit il) '('BytesLimit bl)))" 
                     "(let pgmReturn (AsList"
                     "    (SetResult 'myRes (Member (SelectRange '/dc-1/Zoo/Animals range select options) 'List))"
                     "))"
@@ -635,10 +635,10 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                                 TParameter("WEIGHT", (i64)500)
                             );
 
-        auto result = selectQuery.SyncExecute(
-                                TParameter("ITEMSLIMIT", (ui64)10),
-                                TParameter("BYTESLIMIT", (ui64)10000)
-                            );
+        auto result = selectQuery.SyncExecute( 
+                                TParameter("ITEMSLIMIT", (ui64)10), 
+                                TParameter("BYTESLIMIT", (ui64)10000) 
+                            ); 
         auto value = result.GetValue();
 
         UNIT_ASSERT_VALUES_EQUAL(value["myRes"].Size(), 2);
@@ -659,11 +659,11 @@ Y_UNIT_TEST_SUITE(ClientLib) {
 
         auto updateQuery = kikimr.Query(
                         "("
-                        "(let id (Parameter 'ID (DataType 'Uint64)))"
+                        "(let id (Parameter 'ID (DataType 'Uint64)))" 
                         "(let row '('('Id id)))"
                         "(let sp (Parameter 'SPECIES (DataType 'Utf8)))"
                         "(let nm (Parameter 'NAME (DataType 'Utf8)))"
-                        "(let wt (Parameter 'WEIGHT (DataType 'Int64)))"
+                        "(let wt (Parameter 'WEIGHT (DataType 'Int64)))" 
                         "(let myUpd '("
                         "  '('Species sp)"
                         "  '('Name nm)"
@@ -870,7 +870,7 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                         "(let row '('('Id (Uint64 '1))))"
                         "(let s (Parameter 'SPECIES (DataType 'String)))"
                         "(let n (Parameter 'NAME (DataType 'String)))"
-                        "(let w (Parameter 'WEIGHT (DataType 'Int64)))"
+                        "(let w (Parameter 'WEIGHT (DataType 'Int64)))" 
                         "(let myUpd '("
                         "  '('Species s)"
                         "  '('Name n)"
@@ -893,7 +893,7 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                         "(let row '('('Id (Uint64 '2))))"
                         "(let s (Parameter 'SPECIES (DataType 'String)))"
                         "(let n (Parameter 'NAME (DataType 'String)))"
-                        "(let w (Parameter 'WEIGHT (DataType 'Int64)))"
+                        "(let w (Parameter 'WEIGHT (DataType 'Int64)))" 
                         "(let myUpd '("
                         "  '('Species s)"
                         "  '('Name n)"
@@ -993,7 +993,7 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                         "(let row '('('Id (Uint64 '1))))"
                         "(let s (Parameter 'SPECIES (DataType 'String)))"
                         "(let n (Parameter 'NAME (DataType 'String)))"
-                        "(let w (Parameter 'WEIGHT (DataType 'Int64)))"
+                        "(let w (Parameter 'WEIGHT (DataType 'Int64)))" 
                         "(let myUpd '("
                         "  '('Species s)"
                         "  '('Name n)"
@@ -1016,7 +1016,7 @@ Y_UNIT_TEST_SUITE(ClientLib) {
 
         auto updateQuery = kikimr.Query(
                     "(\n"
-                    "(let id (Parameter 'ID (DataType 'Uint64)))\n"
+                    "(let id (Parameter 'ID (DataType 'Uint64)))\n" 
                     "(let row '('('Id id)))\n"
                     "(let an_type (StructType '('SPECIES (DataType 'Utf8)) '('NAME (DataType 'Utf8)) '('WEIGHT (DataType 'Int64))))\n"
                     "(let an (Parameter 'ANIMAL an_type))\n"
@@ -1077,7 +1077,7 @@ Y_UNIT_TEST_SUITE(ClientLib) {
 
         auto updateQuery = kikimr.Query(
                     "(\n"
-                    "(let id (Parameter 'ID (DataType 'Uint64)))\n"
+                    "(let id (Parameter 'ID (DataType 'Uint64)))\n" 
                     "(let row '('('Id id)))\n"
                     "(let an_type (StructType '('SPECIES (DataType 'Utf8)) '('NAME (DataType 'Utf8)) '('WEIGHT (DataType 'Int64))))\n"
                     "(let an (Parameter 'ANIMAL an_type))\n"
@@ -1134,7 +1134,7 @@ Y_UNIT_TEST_SUITE(ClientLib) {
 
         auto updateQuery = kikimr.Query(R"___(
                                         (
-                                        (let id (Parameter 'ID (DataType 'Uint64)))
+                                        (let id (Parameter 'ID (DataType 'Uint64))) 
                                         (let row '('('Id id)))
                                         (let an_type (StructType '('SPECIES (DataType 'Utf8)) '('NAME (DataType 'Utf8)) '('WEIGHT (DataType 'Int64))))
                                         (let an_opt_type (OptionalType an_type))
@@ -1218,7 +1218,7 @@ Y_UNIT_TEST_SUITE(ClientLib) {
 
         auto updateQuery = kikimr.Query(R"___(
                                         (
-                                        (let id (Parameter 'ID (DataType 'Uint64)))
+                                        (let id (Parameter 'ID (DataType 'Uint64))) 
                                         (let row '('('Id id)))
                                         (let an_type (StructType '('SPECIES (DataType 'Utf8)) '('NAME (DataType 'Utf8)) '('WEIGHT (DataType 'Int64))))
                                         (let an_opt_type (OptionalType an_type))
@@ -1631,9 +1631,9 @@ Y_UNIT_TEST_SUITE(ClientLib) {
         auto query = kikimr.Query(R"___(
                                   # Check 3 tables and write if none of 3 rows already exists
                                   (
-                                  (let h1 (Parameter 'H1_PARAM (DataType 'Uint64)))
-                                  (let h2 (Parameter 'H2_PARAM (DataType 'Uint64)))
-                                  (let h3 (Parameter 'H3_PARAM (DataType 'Uint64)))
+                                  (let h1 (Parameter 'H1_PARAM (DataType 'Uint64))) 
+                                  (let h2 (Parameter 'H2_PARAM (DataType 'Uint64))) 
+                                  (let h3 (Parameter 'H3_PARAM (DataType 'Uint64))) 
                                   (let row1 '('('Hash h1)))
                                   (let row2 '('('Hash h2)))
                                   (let row3 '('('Hash h3)))
@@ -1646,19 +1646,19 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                                   (let keyH3Exists (Exists res3))
                                   (let anyExists (Or keyH1Exists (Or keyH2Exists keyH3Exists)))
                                   (let pgmReturn (If anyExists
-                                      (block '(
+                                      (block '( 
                                           (let list (List (ListType (VoidType))))
                                           (let list (Append list (SetResult 'anyExists anyExists)))
                                           (return list)
-                                      ))
-                                      (block '(
+                                      )) 
+                                      (block '( 
                                           (let list (List (ListType (VoidType))))
                                           (let list (Append list (UpdateRow '/dc-1/Example/Table1 row1 '())))
                                           (let list (Append list (UpdateRow '/dc-1/Example/Table2 row2 '())))
                                           (let list (Append list (UpdateRow '/dc-1/Example/Table3 row3 '())))
                                           (let list (Append list (SetResult 'anyExists anyExists)))
                                           (return list)
-                                      ))
+                                      )) 
                                   ))
                                   (return pgmReturn)
                                   )
@@ -1707,9 +1707,9 @@ Y_UNIT_TEST_SUITE(ClientLib) {
 
         auto readQuery = kikimr.Query(R"___(
                                       (
-                                      (let h1 (Parameter 'H1_PARAM (DataType 'Uint64)))
-                                      (let h2 (Parameter 'H2_PARAM (DataType 'Uint64)))
-                                      (let h3 (Parameter 'H3_PARAM (DataType 'Uint64)))
+                                      (let h1 (Parameter 'H1_PARAM (DataType 'Uint64))) 
+                                      (let h2 (Parameter 'H2_PARAM (DataType 'Uint64))) 
+                                      (let h3 (Parameter 'H3_PARAM (DataType 'Uint64))) 
 
                                       # Read data and versions from the DB
                                       (let row1 '('('Hash h1)))
@@ -1730,7 +1730,7 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                                       )___").SyncPrepare().GetQuery();
 
         auto updateQuery = kikimr.Query(R"___(
-                                        # Check 3 tables and write if none of 3 row versions have changed since they were read
+                                        # Check 3 tables and write if none of 3 row versions have changed since they were read 
                                         (
                                         # Helper function to extract column value and substitute non-existing
                                         # row or NULL value with the provided default value
@@ -1739,18 +1739,18 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                                                     (lambda '(r) (block '(
                                                        (return (Member r name))
                                                     )))
-                                                    (block '(
+                                                    (block '( 
                                                        (return (Just defaultVal))
-                                                    ))
+                                                    )) 
                                                 ))
                                                 (let e2 (Coalesce e1 defaultVal))
                                                 (return e2)
                                             ))
                                         ))
 
-                                        (let h1 (Parameter 'H1_PARAM (DataType 'Uint64)))
-                                        (let h2 (Parameter 'H2_PARAM (DataType 'Uint64)))
-                                        (let h3 (Parameter 'H3_PARAM (DataType 'Uint64)))
+                                        (let h1 (Parameter 'H1_PARAM (DataType 'Uint64))) 
+                                        (let h2 (Parameter 'H2_PARAM (DataType 'Uint64))) 
+                                        (let h3 (Parameter 'H3_PARAM (DataType 'Uint64))) 
 
                                         (let d1 (Parameter 'D1_PARAM (DataType 'Utf8)))
                                         (let d2 (Parameter 'D2_PARAM (DataType 'Utf8)))
@@ -1769,35 +1769,35 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                                         (let rv3 (Apply ExtractVal res3 'Version (Uint64 '0)))
 
                                         # Get old versions from the parameters
-                                        (let v1 (Parameter 'V1_PARAM (DataType 'Uint64)))
-                                        (let v2 (Parameter 'V2_PARAM (DataType 'Uint64)))
-                                        (let v3 (Parameter 'V3_PARAM (DataType 'Uint64)))
+                                        (let v1 (Parameter 'V1_PARAM (DataType 'Uint64))) 
+                                        (let v2 (Parameter 'V2_PARAM (DataType 'Uint64))) 
+                                        (let v3 (Parameter 'V3_PARAM (DataType 'Uint64))) 
                                         (let v1 (Coalesce v1 (Uint64 '0)))
                                         (let v2 (Coalesce v2 (Uint64 '0)))
                                         (let v3 (Coalesce v3 (Uint64 '0)))
 
                                         ### Check versions ###
                                         (let predicate (Bool 'True))
-                                        (let predicate (And predicate (Equal rv1 v1)))
-                                        (let predicate (And predicate (Equal rv2 v2)))
-                                        (let predicate (And predicate (Equal rv2 v3)))
+                                        (let predicate (And predicate (Equal rv1 v1))) 
+                                        (let predicate (And predicate (Equal rv2 v2))) 
+                                        (let predicate (And predicate (Equal rv2 v3))) 
 
 
                                         ### If versions are not changed -- do writes ###
                                         (let pgmReturn (If predicate
-                                            (block '(
+                                            (block '( 
                                             (let list (List (ListType (VoidType))))
                                                 (let list (Append list (UpdateRow '/dc-1/Example/Table1 row1 '('('Version (Increment v1))'('Data d1)))))
                                                 (let list (Append list (UpdateRow '/dc-1/Example/Table2 row2 '('('Version (Increment v2))'('Data d2)))))
                                                 (let list (Append list (UpdateRow '/dc-1/Example/Table3 row3 '('('Version (Increment v3))'('Data d3)))))
                                                 (let list (Append list (SetResult 'myRes (Utf8 '"Updated"))))
                                                 (return list)
-                                            ))
-                                            (block '(
+                                            )) 
+                                            (block '( 
                                                 (let emptyList (List (ListType (VoidType))))
                                                 (let emptyList (Append emptyList (SetResult 'myRes (Utf8 '"Version mismatch"))))
                                                 (return emptyList)
-                                            ))
+                                            )) 
                                         ))
                                         ######
 
@@ -1852,9 +1852,9 @@ Y_UNIT_TEST_SUITE(ClientLib) {
 
         auto readQuery = kikimr.Query(R"___(
                                       (
-                                      (let h1 (Parameter 'H1_PARAM (DataType 'Uint64)))
-                                      (let h2 (Parameter 'H2_PARAM (DataType 'Uint64)))
-                                      (let h3 (Parameter 'H3_PARAM (DataType 'Uint64)))
+                                      (let h1 (Parameter 'H1_PARAM (DataType 'Uint64))) 
+                                      (let h2 (Parameter 'H2_PARAM (DataType 'Uint64))) 
+                                      (let h3 (Parameter 'H3_PARAM (DataType 'Uint64))) 
 
                                       # Read data and versions from the DB
                                       (let row1 '('('Hash h1)))
@@ -1884,18 +1884,18 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                                                     (lambda '(r) (block '(
                                                        (return (Member r name))
                                                     )))
-                                                    (block '(
+                                                    (block '( 
                                                        (return (Just defaultVal))
-                                                    ))
+                                                    )) 
                                                 ))
                                                 (let e2 (Coalesce e1 defaultVal))
                                                 (return e2)
                                             ))
                                         ))
 
-                                        (let h1 (Parameter 'H1_PARAM (DataType 'Uint64)))
-                                        (let h2 (Parameter 'H2_PARAM (DataType 'Uint64)))
-                                        (let h3 (Parameter 'H3_PARAM (DataType 'Uint64)))
+                                        (let h1 (Parameter 'H1_PARAM (DataType 'Uint64))) 
+                                        (let h2 (Parameter 'H2_PARAM (DataType 'Uint64))) 
+                                        (let h3 (Parameter 'H3_PARAM (DataType 'Uint64))) 
 
                                         (let d1 (Parameter 'D1_PARAM (DataType 'String)))
                                         (let d2 (Parameter 'D2_PARAM (DataType 'String)))
@@ -1914,35 +1914,35 @@ Y_UNIT_TEST_SUITE(ClientLib) {
                                         (let rv3 (Apply ExtractVal res3 'Version (Uint64 '0)))
 
                                         # Get old versions from the parameters
-                                        (let v1 (Parameter 'V1_PARAM (DataType 'Uint64)))
-                                        (let v2 (Parameter 'V2_PARAM (DataType 'Uint64)))
-                                        (let v3 (Parameter 'V3_PARAM (DataType 'Uint64)))
+                                        (let v1 (Parameter 'V1_PARAM (DataType 'Uint64))) 
+                                        (let v2 (Parameter 'V2_PARAM (DataType 'Uint64))) 
+                                        (let v3 (Parameter 'V3_PARAM (DataType 'Uint64))) 
                                         (let v1 (Coalesce v1 (Uint64 '0)))
                                         (let v2 (Coalesce v2 (Uint64 '0)))
                                         (let v3 (Coalesce v3 (Uint64 '0)))
 
                                         ### Check versions ###
                                         (let predicate (Bool 'True))
-                                        (let predicate (And predicate (Equal rv1 v1)))
-                                        (let predicate (And predicate (Equal rv2 v2)))
-                                        (let predicate (And predicate (Equal rv2 v3)))
+                                        (let predicate (And predicate (Equal rv1 v1))) 
+                                        (let predicate (And predicate (Equal rv2 v2))) 
+                                        (let predicate (And predicate (Equal rv2 v3))) 
 
 
                                         ### If versions are not changed -- do writes ###
                                         (let pgmReturn (If predicate
-                                            (block '(
+                                            (block '( 
                                             (let list (List (ListType (VoidType))))
                                                 (let list (Append list (UpdateRow '/dc-1/Example/Table1 row1 '('('Version (Increment v1))'('Data d1)))))
                                                 (let list (Append list (UpdateRow '/dc-1/Example/Table2 row2 '('('Version (Increment v2))'('Data d2)))))
                                                 (let list (Append list (UpdateRow '/dc-1/Example/Table3 row3 '('('Version (Increment v3))'('Data d3)))))
                                                 (let list (Append list (SetResult 'myRes (Utf8 '"Updated"))))
                                                 (return list)
-                                            ))
-                                            (block '(
+                                            )) 
+                                            (block '( 
                                                 (let emptyList (List (ListType (VoidType))))
                                                 (let emptyList (Append emptyList (SetResult 'myRes (Utf8 '"Version mismatch"))))
                                                 (return emptyList)
-                                            ))
+                                            )) 
                                         ))
                                         ######
 
@@ -1984,66 +1984,66 @@ Y_UNIT_TEST_SUITE(ClientLib) {
     }
 
     Y_UNIT_TEST(TestParameterTypes) {
-        using namespace NClient;
-        NMsgBusProxy::TMsgBusClientConfig clientConfig;
-        Tests::TServer server = StartupKikimr(clientConfig);
-        NClient::TKikimr kikimr(clientConfig);
-
-        auto query = kikimr.Query(R"___(
-            (
-            (let pb (Parameter 'PB (DataType 'Bool)))
+        using namespace NClient; 
+        NMsgBusProxy::TMsgBusClientConfig clientConfig; 
+        Tests::TServer server = StartupKikimr(clientConfig); 
+        NClient::TKikimr kikimr(clientConfig); 
+ 
+        auto query = kikimr.Query(R"___( 
+            ( 
+            (let pb (Parameter 'PB (DataType 'Bool))) 
             (let pui8 (Parameter 'PUI8 (DataType 'Uint8)))
-            (let pi32 (Parameter 'PI32 (DataType 'Int32)))
-            (let pui32 (Parameter 'PUI32 (DataType 'Uint32)))
-            (let pi64 (Parameter 'PI64 (DataType 'Int64)))
-            (let pui64 (Parameter 'PUI64 (DataType 'Uint64)))
-            (let pf (Parameter 'PF (DataType 'Float)))
-            (let pd (Parameter 'PD (DataType 'Double)))
+            (let pi32 (Parameter 'PI32 (DataType 'Int32))) 
+            (let pui32 (Parameter 'PUI32 (DataType 'Uint32))) 
+            (let pi64 (Parameter 'PI64 (DataType 'Int64))) 
+            (let pui64 (Parameter 'PUI64 (DataType 'Uint64))) 
+            (let pf (Parameter 'PF (DataType 'Float))) 
+            (let pd (Parameter 'PD (DataType 'Double))) 
             (let ps (Parameter 'PS (DataType 'String)))
             (let pu (Parameter 'PU (DataType 'Utf8)))
-            (return (AsList
-                (SetResult 'rb pb)
-                (SetResult 'rui8 pui8)
-                (SetResult 'ri32 pi32)
-                (SetResult 'rui32 pui32)
-                (SetResult 'ri64 pi64)
-                (SetResult 'rui64 pui64)
-                (SetResult 'rf pf)
-                (SetResult 'rd pd)
-                (SetResult 'rs ps)
-                (SetResult 'ru pu)
-            ))
-            )
-        )___").SyncPrepare().GetQuery();
-
-        TParameters parameters;
-
-        parameters["PB"] = true;
-        parameters["PUI8"] = (ui8)1;
-        parameters["PI32"] = (i32)-2;
-        parameters["PUI32"] = (ui32)3;
-        parameters["PI64"] = (i64)-4;
-        parameters["PUI64"] = (ui64)5;
-        parameters["PF"] = (float)6.5;
-        parameters["PD"] = (double)7.5;
-        parameters["PS"].Bytes("Str1");
-        parameters["PU"] = "Str2";
-
-        auto result = query.SyncExecute(parameters);
-        UNIT_ASSERT_EQUAL(result.GetStatus(), NMsgBusProxy::MSTATUS_OK);
-        auto value = result.GetValue();
-        UNIT_ASSERT_EQUAL((bool)value["rb"], true);
-        UNIT_ASSERT_EQUAL((ui8)value["rui8"], 1);
-        UNIT_ASSERT_EQUAL((i32)value["ri32"], -2);
-        UNIT_ASSERT_EQUAL((ui32)value["rui32"], 3);
-        UNIT_ASSERT_EQUAL((i64)value["ri64"], -4);
-        UNIT_ASSERT_EQUAL((ui64)value["rui64"], 5);
-        UNIT_ASSERT_EQUAL((float)value["rf"], 6.5);
-        UNIT_ASSERT_EQUAL((double)value["rd"], 7.5);
+            (return (AsList 
+                (SetResult 'rb pb) 
+                (SetResult 'rui8 pui8) 
+                (SetResult 'ri32 pi32) 
+                (SetResult 'rui32 pui32) 
+                (SetResult 'ri64 pi64) 
+                (SetResult 'rui64 pui64) 
+                (SetResult 'rf pf) 
+                (SetResult 'rd pd) 
+                (SetResult 'rs ps) 
+                (SetResult 'ru pu) 
+            )) 
+            ) 
+        )___").SyncPrepare().GetQuery(); 
+ 
+        TParameters parameters; 
+ 
+        parameters["PB"] = true; 
+        parameters["PUI8"] = (ui8)1; 
+        parameters["PI32"] = (i32)-2; 
+        parameters["PUI32"] = (ui32)3; 
+        parameters["PI64"] = (i64)-4; 
+        parameters["PUI64"] = (ui64)5; 
+        parameters["PF"] = (float)6.5; 
+        parameters["PD"] = (double)7.5; 
+        parameters["PS"].Bytes("Str1"); 
+        parameters["PU"] = "Str2"; 
+ 
+        auto result = query.SyncExecute(parameters); 
+        UNIT_ASSERT_EQUAL(result.GetStatus(), NMsgBusProxy::MSTATUS_OK); 
+        auto value = result.GetValue(); 
+        UNIT_ASSERT_EQUAL((bool)value["rb"], true); 
+        UNIT_ASSERT_EQUAL((ui8)value["rui8"], 1); 
+        UNIT_ASSERT_EQUAL((i32)value["ri32"], -2); 
+        UNIT_ASSERT_EQUAL((ui32)value["rui32"], 3); 
+        UNIT_ASSERT_EQUAL((i64)value["ri64"], -4); 
+        UNIT_ASSERT_EQUAL((ui64)value["rui64"], 5); 
+        UNIT_ASSERT_EQUAL((float)value["rf"], 6.5); 
+        UNIT_ASSERT_EQUAL((double)value["rd"], 7.5); 
         UNIT_ASSERT_EQUAL((TString)value["rs"], "Str1");
         UNIT_ASSERT_EQUAL((TString)value["ru"], "Str2");
-    }
-
+    } 
+ 
 //    Y_UNIT_TEST(Wrongdoing1) {
 //        using namespace NClient;
 //        TString type = R"___(
@@ -2136,7 +2136,7 @@ Y_UNIT_TEST_SUITE(ClientLib) {
 //        Y_UNUSED(result);
 //    }
 }
-
+ 
 NKikimrTxUserProxy::TKeyRange MakeRange(const TVector<TString> from, const TVector<TString> to,
                                         bool fromInclusive, bool toInclusive)
 {
diff --git a/ydb/public/lib/deprecated/kicli/error.cpp b/ydb/public/lib/deprecated/kicli/error.cpp
index 473a981f60..bfcbe97fb9 100644
--- a/ydb/public/lib/deprecated/kicli/error.cpp
+++ b/ydb/public/lib/deprecated/kicli/error.cpp
@@ -262,8 +262,8 @@ TString TError::GetMessage() const {
             return "Execution failed";
         case NTxProxy::TResultStatus::EStatus::ExecInProgress:
             return "Request accepted and now runs";
-        case NTxProxy::TResultStatus::EStatus::ExecResultUnavailable:
-            return "Execution result unavailable.";
+        case NTxProxy::TResultStatus::EStatus::ExecResultUnavailable: 
+            return "Execution result unavailable."; 
         };
         break;
     case EFacility::FacilityMsgBusProxy:
@@ -331,7 +331,7 @@ TError::EFacility TError::GetFacility() const {
     return Facility;
 }
 
-Ydb::StatusIds::StatusCode TError::GetYdbStatus() const {
+Ydb::StatusIds::StatusCode TError::GetYdbStatus() const { 
     return YdbStatus;
 }
 
diff --git a/ydb/public/lib/deprecated/kicli/kicli.h b/ydb/public/lib/deprecated/kicli/kicli.h
index 9dc472d231..9bf8821686 100644
--- a/ydb/public/lib/deprecated/kicli/kicli.h
+++ b/ydb/public/lib/deprecated/kicli/kicli.h
@@ -270,7 +270,7 @@ public:
         FacilityMessageBus,
         FacilityExecutionEngine,
         FacilityTxProxy,
-        FacilityMsgBusProxy,
+        FacilityMsgBusProxy, 
     };
 
     TError() = default;
@@ -290,7 +290,7 @@ public:
     void Throw() const;
     EFacility GetFacility() const;
     // Returns YDB status
-    Ydb::StatusIds::StatusCode GetYdbStatus() const;
+    Ydb::StatusIds::StatusCode GetYdbStatus() const; 
 
 protected:
     TError(const TResult& result);
@@ -299,7 +299,7 @@ protected:
     TString Message;
     EFacility Facility;
     ui16 Code;
-    Ydb::StatusIds::StatusCode YdbStatus;
+    Ydb::StatusIds::StatusCode YdbStatus; 
 };
 
 /// Owns query result data
@@ -380,7 +380,7 @@ public:
     TReadTableResult& operator=(TReadTableResult&&) = default;
     TReadTableResult& operator=(const TReadTableResult&) = default;
 
-    const YdbOld::ResultSet &GetResultSet() const;
+    const YdbOld::ResultSet &GetResultSet() const; 
 
     template<typename TFormat>
     TString GetTypeText(const TFormat &format) const;
@@ -391,11 +391,11 @@ protected:
     TReadTableResult(const TResult& result);
 
     template<typename TFormat>
-    static TString ValueToString(const YdbOld::Value &value, const YdbOld::DataType &type);
+    static TString ValueToString(const YdbOld::Value &value, const YdbOld::DataType &type); 
     template<typename TFormat>
-    static TString ValueToString(const YdbOld::Value &value, const YdbOld::Type &type);
+    static TString ValueToString(const YdbOld::Value &value, const YdbOld::Type &type); 
 
-    mutable YdbOld::ResultSet Result;
+    mutable YdbOld::ResultSet Result; 
     mutable bool Parsed = false;
 };
 
@@ -434,8 +434,8 @@ public:
         structValue.StoreValue(value);
     }
 
-    static void ParseTextParameters(NKikimrMiniKQL::TParams& params, const TString& parameters);
-
+    static void ParseTextParameters(NKikimrMiniKQL::TParams& params, const TString& parameters); 
+ 
 protected:
     TQuery(const TQuery&) = default;
     TQuery(TKikimr& kikimr);
@@ -486,9 +486,9 @@ public:
     TQueryResult SyncExecute(const NKikimrMiniKQL::TParams& parameters) const;
     NThreading::TFuture<TQueryResult> AsyncExecute(const NKikimrMiniKQL::TParams& parameters) const;
 
-protected:
-    TTextQuery(TKikimr& kikimr, const TString& program);
-
+protected: 
+    TTextQuery(TKikimr& kikimr, const TString& program); 
+ 
     TString TextProgram;
 };
 
@@ -544,9 +544,9 @@ public:
     TQueryResult SyncExecute(const TString& parameters) const;
     NThreading::TFuture<TQueryResult> AsyncExecute(const TString& parameters) const;
 
-    TQueryResult SyncExecute(const NKikimrMiniKQL::TParams& parameters) const;
-    NThreading::TFuture<TQueryResult> AsyncExecute(const NKikimrMiniKQL::TParams& parameters) const;
-
+    TQueryResult SyncExecute(const NKikimrMiniKQL::TParams& parameters) const; 
+    NThreading::TFuture<TQueryResult> AsyncExecute(const NKikimrMiniKQL::TParams& parameters) const; 
+ 
     TUnbindedQuery Unbind() const;
 
 protected:
diff --git a/ydb/public/lib/deprecated/kicli/kikimr.cpp b/ydb/public/lib/deprecated/kicli/kikimr.cpp
index 4156d72d4b..3545ebe2e6 100644
--- a/ydb/public/lib/deprecated/kicli/kikimr.cpp
+++ b/ydb/public/lib/deprecated/kicli/kikimr.cpp
@@ -567,7 +567,7 @@ TKikimr::TKikimr(TKikimr&& kikimr)
 TNodeRegistrant TKikimr::GetNodeRegistrant()
 {
     return TNodeRegistrant(*this);
-}
+} 
 
 TNodeConfigurator TKikimr::GetNodeConfigurator()
 {
@@ -592,7 +592,7 @@ NThreading::TFuture<TResult> TKikimr::RegisterNode(const TString& domainPath, co
         request->Record.SetPath(*path);
     }
     return ExecuteRequest(request.Release());
-}
+} 
 
 NThreading::TFuture<TResult> TKikimr::GetNodeConfig(ui32 nodeId,
                                                     const TString &host,
diff --git a/ydb/public/lib/deprecated/kicli/result.cpp b/ydb/public/lib/deprecated/kicli/result.cpp
index 0f86ba4340..29c7728e34 100644
--- a/ydb/public/lib/deprecated/kicli/result.cpp
+++ b/ydb/public/lib/deprecated/kicli/result.cpp
@@ -66,7 +66,7 @@ NMsgBusProxy::EResponseStatus TResult::GetStatus() const {
     } else
     if (GetType() == NMsgBusProxy::MTYPE_CLIENT_RESPONSE) {
         return static_cast<NMsgBusProxy::EResponseStatus>(GetResult<NKikimrClient::TResponse>().GetStatus());
-    } else
+    } else 
     return NMsgBusProxy::MSTATUS_INTERNALERROR;
 }
 
@@ -90,7 +90,7 @@ TReadTableResult::TReadTableResult(const TResult& result)
     : TResult(result)
 {}
 
-const YdbOld::ResultSet &TReadTableResult::GetResultSet() const {
+const YdbOld::ResultSet &TReadTableResult::GetResultSet() const { 
     if (!Parsed) {
         const NKikimrClient::TResponse& response = GetResult<NKikimrClient::TResponse>();
         const auto& result = response.GetSerializedReadTableResponse();
@@ -99,8 +99,8 @@ const YdbOld::ResultSet &TReadTableResult::GetResultSet() const {
     return Result;
 }
 
-template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Value &value,
-                                                                const YdbOld::DataType &type) {
+template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Value &value, 
+                                                                const YdbOld::DataType &type) { 
     switch (type.id()) {
     case NYql::NProto::Bool:
         return value.bool_value() ? "true" : "false";
@@ -166,12 +166,12 @@ template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Va
     }
 }
 
-template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Value &value,
-                                                                const YdbOld::Type &type) {
+template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Value &value, 
+                                                                const YdbOld::Type &type) { 
     switch (type.type_type_case()) {
-    case YdbOld::Type::kDataType:
+    case YdbOld::Type::kDataType: 
         return ValueToString<TFormatCSV>(value, type.data_type());
-    case YdbOld::Type::kOptionalType:
+    case YdbOld::Type::kOptionalType: 
         if (value.Hasnull_flag_value())
             return "NULL";
         // If we have Value field for optional type then it is always
@@ -179,7 +179,7 @@ template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Va
         if (value.Hasnested_value())
             return ValueToString<TFormatCSV>(value.nested_value(), type.optional_type().item());
         return ValueToString<TFormatCSV>(value, type.optional_type().item());
-    case YdbOld::Type::kListType:
+    case YdbOld::Type::kListType: 
         {
             TString res = "[";
             const auto &items = value.items();
@@ -192,7 +192,7 @@ template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Va
             res += "]";
             return res;
         }
-    case YdbOld::Type::kTupleType:
+    case YdbOld::Type::kTupleType: 
         {
             TString res = "[";
             const auto &items = value.items();
@@ -205,7 +205,7 @@ template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Va
             res += "]";
             return res;
         }
-    case YdbOld::Type::kStructType:
+    case YdbOld::Type::kStructType: 
         {
             TString res = "{";
             const auto &items = value.items();
@@ -218,7 +218,7 @@ template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Va
             res += "}";
             return res;
         }
-    case YdbOld::Type::kDictType:
+    case YdbOld::Type::kDictType: 
         {
             TString res = "[";
             const auto &pairs = value.pairs();
@@ -233,7 +233,7 @@ template <> TString TReadTableResult::ValueToString<TFormatCSV>(const YdbOld::Va
             res += "]";
             return res;
         }
-    case YdbOld::Type::kVariantType:
+    case YdbOld::Type::kVariantType: 
         return "<VARIANT IS NOT SUPPORTED>";
     default:
         return "";
@@ -299,5 +299,5 @@ TPreparedQuery TPrepareResult::GetQuery() const {
     return TPreparedQuery(*Query, compileResult.GetCompiledProgram());
 }
 
-}
-}
+} 
+} 
diff --git a/ydb/public/lib/deprecated/kicli/schema.cpp b/ydb/public/lib/deprecated/kicli/schema.cpp
index d1ee0384f8..537616a6e2 100644
--- a/ydb/public/lib/deprecated/kicli/schema.cpp
+++ b/ydb/public/lib/deprecated/kicli/schema.cpp
@@ -230,26 +230,26 @@ TVector<TColumn> TSchemaObject::GetColumns() const {
     result.GetError().Throw();
     const NKikimrClient::TResponse& objects = result.GetResult<NKikimrClient::TResponse>();
     Y_VERIFY(objects.GetPathDescription().HasTable());
-    const auto& table = objects.GetPathDescription().GetTable();
-
+    const auto& table = objects.GetPathDescription().GetTable(); 
+ 
     TMap<ui32, NKikimrSchemeOp::TColumnDescription> columnsMap;
-    for (const auto& column : table.GetColumns()) {
-        columnsMap[column.GetId()] = column;
-    }
-
+    for (const auto& column : table.GetColumns()) { 
+        columnsMap[column.GetId()] = column; 
+    } 
+ 
     TVector<TColumn> columns;
-    columns.reserve(table.ColumnsSize());
-    for (ui32 keyColumnId : table.GetKeyColumnIds()) {
-        auto column = columnsMap.FindPtr(keyColumnId);
-        Y_VERIFY(column);
-        columns.push_back(TKeyColumn(column->GetName(), TType(column->GetType(), column->GetTypeId())));
-        columnsMap.erase(keyColumnId);
+    columns.reserve(table.ColumnsSize()); 
+    for (ui32 keyColumnId : table.GetKeyColumnIds()) { 
+        auto column = columnsMap.FindPtr(keyColumnId); 
+        Y_VERIFY(column); 
+        columns.push_back(TKeyColumn(column->GetName(), TType(column->GetType(), column->GetTypeId()))); 
+        columnsMap.erase(keyColumnId); 
     }
-    for (const auto& pair : columnsMap) {
-        auto& column = pair.second;
-        columns.push_back(TColumn(column.GetName(), TType(column.GetType(), column.GetTypeId())));
-    }
-
+    for (const auto& pair : columnsMap) { 
+        auto& column = pair.second; 
+        columns.push_back(TColumn(column.GetName(), TType(column.GetType(), column.GetTypeId()))); 
+    } 
+ 
     return columns;
 }
 
diff --git a/ydb/public/lib/experimental/ydb_clickhouse_internal.cpp b/ydb/public/lib/experimental/ydb_clickhouse_internal.cpp
index 2984f680b7..6be4770896 100644
--- a/ydb/public/lib/experimental/ydb_clickhouse_internal.cpp
+++ b/ydb/public/lib/experimental/ydb_clickhouse_internal.cpp
@@ -14,8 +14,8 @@
 namespace NYdb {
 namespace NClickhouseInternal {
 
-using namespace NThreading;
-
+using namespace NThreading; 
+ 
 ///////////////////////////////////////////////////////////////////////////
 class TScanResult::TResultImpl {
 public:
@@ -108,7 +108,7 @@ public:
                     &Ydb::ClickhouseInternal::V1::ClickhouseInternalService::Stub::AsyncScan,
                     DbDriverState_,
                     INITIAL_DEFERRED_CALL_DELAY,
-                    TRpcRequestSettings::Make(settings),
+                    TRpcRequestSettings::Make(settings), 
                     settings.ClientTimeout_,
                     settings.Endpoint_);
 
@@ -375,7 +375,7 @@ public:
                     &Ydb::ClickhouseInternal::V1::ClickhouseInternalService::Stub::AsyncGetShardLocations,
                     DbDriverState_,
                     INITIAL_DEFERRED_CALL_DELAY,
-                    TRpcRequestSettings::Make(settings),
+                    TRpcRequestSettings::Make(settings), 
                     settings.ClientTimeout_);
 
         return promise.GetFuture();
@@ -411,7 +411,7 @@ public:
                     &Ydb::ClickhouseInternal::V1::ClickhouseInternalService::Stub::AsyncDescribeTable,
                     DbDriverState_,
                     INITIAL_DEFERRED_CALL_DELAY,
-                    TRpcRequestSettings::Make(settings),
+                    TRpcRequestSettings::Make(settings), 
                     settings.ClientTimeout_);
 
         return promise.GetFuture();
@@ -462,7 +462,7 @@ public:
                 &Ydb::ClickhouseInternal::V1::ClickhouseInternalService::Stub::AsyncCreateSnapshot,
                 DbDriverState_,
                 INITIAL_DEFERRED_CALL_DELAY,
-                TRpcRequestSettings::Make(settings),
+                TRpcRequestSettings::Make(settings), 
                 settings.ClientTimeout_);
 
         return future;
@@ -498,7 +498,7 @@ public:
                 &Ydb::ClickhouseInternal::V1::ClickhouseInternalService::Stub::AsyncRefreshSnapshot,
                 DbDriverState_,
                 INITIAL_DEFERRED_CALL_DELAY,
-                TRpcRequestSettings::Make(settings),
+                TRpcRequestSettings::Make(settings), 
                 settings.ClientTimeout_);
 
         return future;
@@ -534,7 +534,7 @@ public:
                 &Ydb::ClickhouseInternal::V1::ClickhouseInternalService::Stub::AsyncDiscardSnapshot,
                 DbDriverState_,
                 INITIAL_DEFERRED_CALL_DELAY,
-                TRpcRequestSettings::Make(settings),
+                TRpcRequestSettings::Make(settings), 
                 settings.ClientTimeout_);
 
         return future;
@@ -910,4 +910,4 @@ TAsyncCreateSnapshotHandleResult TMetaClient::CreateSnapshotHandle(
 }
 
 } // namespace NClickhouseInternal
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/lib/experimental/ydb_clickhouse_internal.h b/ydb/public/lib/experimental/ydb_clickhouse_internal.h
index d2a846ca8f..9a5719c57b 100644
--- a/ydb/public/lib/experimental/ydb_clickhouse_internal.h
+++ b/ydb/public/lib/experimental/ydb_clickhouse_internal.h
@@ -272,4 +272,4 @@ private:
 };
 
 } // namespace NClickhouseInternal
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/lib/experimental/ydb_experimental.cpp b/ydb/public/lib/experimental/ydb_experimental.cpp
index 8765c0c750..3326cd00ad 100644
--- a/ydb/public/lib/experimental/ydb_experimental.cpp
+++ b/ydb/public/lib/experimental/ydb_experimental.cpp
@@ -12,51 +12,51 @@
 namespace NYdb {
 namespace NExperimental {
 
-using namespace NThreading;
-
-
-TStreamPartStatus::TStreamPartStatus(TStatus&& status)
-    : TStatus(std::move(status))
-{}
-
-bool TStreamPartStatus::EOS() const {
-    return GetStatus() == EStatus::CLIENT_OUT_OF_RANGE;
-}
-
-class TStreamPartIterator::TReaderImpl {
-public:
-    using TSelf = TStreamPartIterator::TReaderImpl;
-    using TResponse = Ydb::Experimental::ExecuteStreamQueryResponse;
-    using TStreamProcessorPtr = NGrpc::IStreamRequestReadProcessor<TResponse>::TPtr;
-    using TReadCallback = NGrpc::IStreamRequestReadProcessor<TResponse>::TReadCallback;
-    using TGRpcStatus = NGrpc::TGrpcStatus;
-    using TBatchReadResult = std::pair<TResponse, TGRpcStatus>;
-
+using namespace NThreading; 
+ 
+
+TStreamPartStatus::TStreamPartStatus(TStatus&& status) 
+    : TStatus(std::move(status)) 
+{} 
+ 
+bool TStreamPartStatus::EOS() const { 
+    return GetStatus() == EStatus::CLIENT_OUT_OF_RANGE; 
+} 
+ 
+class TStreamPartIterator::TReaderImpl { 
+public: 
+    using TSelf = TStreamPartIterator::TReaderImpl; 
+    using TResponse = Ydb::Experimental::ExecuteStreamQueryResponse; 
+    using TStreamProcessorPtr = NGrpc::IStreamRequestReadProcessor<TResponse>::TPtr; 
+    using TReadCallback = NGrpc::IStreamRequestReadProcessor<TResponse>::TReadCallback; 
+    using TGRpcStatus = NGrpc::TGrpcStatus; 
+    using TBatchReadResult = std::pair<TResponse, TGRpcStatus>; 
+ 
     TReaderImpl(TStreamProcessorPtr streamProcessor, const TString& endpoint)
-        : StreamProcessor_(streamProcessor)
-        , Finished_(false)
+        : StreamProcessor_(streamProcessor) 
+        , Finished_(false) 
         , Endpoint_(endpoint)
-    {}
-
-    ~TReaderImpl() {
-        StreamProcessor_->Cancel();
-    }
-
+    {} 
+ 
+    ~TReaderImpl() { 
+        StreamProcessor_->Cancel(); 
+    } 
+ 
     bool IsFinished() const {
-        return Finished_;
-    }
-
+        return Finished_; 
+    } 
+ 
     TAsyncStreamPart ReadNext(std::shared_ptr<TSelf> self) {
         auto promise = NThreading::NewPromise<TStreamPart>();
-        // Capture self - guarantee no dtor call during the read
-        auto readCb = [self, promise](TGRpcStatus&& grpcStatus) mutable {
-            if (!grpcStatus.Ok()) {
-                self->Finished_ = true;
+        // Capture self - guarantee no dtor call during the read 
+        auto readCb = [self, promise](TGRpcStatus&& grpcStatus) mutable { 
+            if (!grpcStatus.Ok()) { 
+                self->Finished_ = true; 
                 promise.SetValue({TStatus(TPlainStatus(grpcStatus, self->Endpoint_))});
-            } else {
-                NYql::TIssues issues;
-                NYql::IssuesFromMessage(self->Response_.issues(), issues);
-                EStatus clientStatus = static_cast<EStatus>(self->Response_.status());
+            } else { 
+                NYql::TIssues issues; 
+                NYql::IssuesFromMessage(self->Response_.issues(), issues); 
+                EStatus clientStatus = static_cast<EStatus>(self->Response_.status()); 
                 TPlainStatus plainStatus{clientStatus, std::move(issues), self->Endpoint_, {}};
                 TStatus status{std::move(plainStatus)};
 
@@ -74,47 +74,47 @@ public:
                 } else {
                     promise.SetValue(std::move(status));
                 }
-            }
-        };
-        StreamProcessor_->Read(&Response_, readCb);
-        return promise.GetFuture();
-    }
-private:
-    TStreamProcessorPtr StreamProcessor_;
-    TResponse Response_;
-    bool Finished_;
+            } 
+        }; 
+        StreamProcessor_->Read(&Response_, readCb); 
+        return promise.GetFuture(); 
+    } 
+private: 
+    TStreamProcessorPtr StreamProcessor_; 
+    TResponse Response_; 
+    bool Finished_; 
     TString Endpoint_;
-};
-
-TStreamPartIterator::TStreamPartIterator(
-    std::shared_ptr<TReaderImpl> impl,
+}; 
+ 
+TStreamPartIterator::TStreamPartIterator( 
+    std::shared_ptr<TReaderImpl> impl, 
     TPlainStatus&& status)
     : TStatus(std::move(status))
-    , ReaderImpl_(impl)
-{}
-
+    , ReaderImpl_(impl) 
+{} 
+ 
 TAsyncStreamPart TStreamPartIterator::ReadNext() {
-    if (ReaderImpl_->IsFinished())
-        RaiseError("Attempt to perform read on invalid or finished stream");
-    return ReaderImpl_->ReadNext(ReaderImpl_);
-}
-
-class TStreamQueryClient::TImpl : public TClientImplCommon<TStreamQueryClient::TImpl> {
-public:
-    using TStreamProcessorPtr = TStreamPartIterator::TReaderImpl::TStreamProcessorPtr;
-
-    TImpl(std::shared_ptr<TGRpcConnectionsImpl>&& connections, const TCommonClientSettings& settings)
+    if (ReaderImpl_->IsFinished()) 
+        RaiseError("Attempt to perform read on invalid or finished stream"); 
+    return ReaderImpl_->ReadNext(ReaderImpl_); 
+} 
+ 
+class TStreamQueryClient::TImpl : public TClientImplCommon<TStreamQueryClient::TImpl> { 
+public: 
+    using TStreamProcessorPtr = TStreamPartIterator::TReaderImpl::TStreamProcessorPtr; 
+ 
+    TImpl(std::shared_ptr<TGRpcConnectionsImpl>&& connections, const TCommonClientSettings& settings) 
         : TClientImplCommon(std::move(connections), settings) {}
-
-    TFuture<std::pair<TPlainStatus, TStreamProcessorPtr>> ExecuteStreamQueryInternal(const TString& query,
-        const TParams* params, const TExecuteStreamQuerySettings& settings)
-    {
-        auto request = MakeRequest<Ydb::Experimental::ExecuteStreamQueryRequest>();
-        request.set_yql_text(query);
-        if (params) {
+ 
+    TFuture<std::pair<TPlainStatus, TStreamProcessorPtr>> ExecuteStreamQueryInternal(const TString& query, 
+        const TParams* params, const TExecuteStreamQuerySettings& settings) 
+    { 
+        auto request = MakeRequest<Ydb::Experimental::ExecuteStreamQueryRequest>(); 
+        request.set_yql_text(query); 
+        if (params) { 
             *request.mutable_parameters() = params->GetProtoMap();
-        }
-
+        } 
+ 
         switch (settings.ProfileMode_) {
             case EStreamQueryProfileMode::None:
                 request.set_profile_mode(Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_NONE);
@@ -122,73 +122,73 @@ public:
             case EStreamQueryProfileMode::Basic:
                 request.set_profile_mode(Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_BASIC);
                 break;
-            case EStreamQueryProfileMode::Full:
-                request.set_profile_mode(Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_FULL);
-                break;
+            case EStreamQueryProfileMode::Full: 
+                request.set_profile_mode(Ydb::Experimental::ExecuteStreamQueryRequest_ProfileMode_FULL); 
+                break; 
         }
 
         request.set_explain(settings.Explain_);
 
-        auto promise = NewPromise<std::pair<TPlainStatus, TStreamProcessorPtr>>();
-
-        Connections_->StartReadStream<
-            Ydb::Experimental::V1::ExperimentalService,
-            Ydb::Experimental::ExecuteStreamQueryRequest,
-            Ydb::Experimental::ExecuteStreamQueryResponse>
-        (
-            std::move(request),
-            [promise] (TPlainStatus status, TStreamProcessorPtr processor) mutable {
-                promise.SetValue(std::make_pair(status, processor));
-            },
-            &Ydb::Experimental::V1::ExperimentalService::Stub::AsyncExecuteStreamQuery,
-            DbDriverState_,
-            TRpcRequestSettings::Make(settings)
-        );
-
-        return promise.GetFuture();
-    }
-
-    TAsyncStreamPartIterator ExecuteStreamQuery(const TString& query, const TParams* params,
-        const TExecuteStreamQuerySettings& settings)
-    {
-        auto promise = NewPromise<TStreamPartIterator>();
-
+        auto promise = NewPromise<std::pair<TPlainStatus, TStreamProcessorPtr>>(); 
+ 
+        Connections_->StartReadStream< 
+            Ydb::Experimental::V1::ExperimentalService, 
+            Ydb::Experimental::ExecuteStreamQueryRequest, 
+            Ydb::Experimental::ExecuteStreamQueryResponse> 
+        ( 
+            std::move(request), 
+            [promise] (TPlainStatus status, TStreamProcessorPtr processor) mutable { 
+                promise.SetValue(std::make_pair(status, processor)); 
+            }, 
+            &Ydb::Experimental::V1::ExperimentalService::Stub::AsyncExecuteStreamQuery, 
+            DbDriverState_, 
+            TRpcRequestSettings::Make(settings) 
+        ); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
+    TAsyncStreamPartIterator ExecuteStreamQuery(const TString& query, const TParams* params, 
+        const TExecuteStreamQuerySettings& settings) 
+    { 
+        auto promise = NewPromise<TStreamPartIterator>(); 
+ 
         auto iteratorCallback = [promise](TFuture<std::pair<TPlainStatus,
-            TStreamQueryClient::TImpl::TStreamProcessorPtr>> future) mutable
-        {
-            Y_ASSERT(future.HasValue());
-            auto pair = future.ExtractValue();
+            TStreamQueryClient::TImpl::TStreamProcessorPtr>> future) mutable 
+        { 
+            Y_ASSERT(future.HasValue()); 
+            auto pair = future.ExtractValue(); 
             promise.SetValue(TStreamPartIterator(
                 pair.second
                     ? std::make_shared<TStreamPartIterator::TReaderImpl>(pair.second, pair.first.Endpoint)
                     : nullptr,
                 std::move(pair.first))
             );
-        };
-
-        ExecuteStreamQueryInternal(query, params, settings).Subscribe(iteratorCallback);
-        return promise.GetFuture();
-    }
-};
-
-TStreamQueryClient::TStreamQueryClient(const TDriver& driver, const TCommonClientSettings& settings)
-    : Impl_(new TImpl(CreateInternalInterface(driver), settings)) {}
-
-TParamsBuilder TStreamQueryClient::GetParamsBuilder() {
+        }; 
+ 
+        ExecuteStreamQueryInternal(query, params, settings).Subscribe(iteratorCallback); 
+        return promise.GetFuture(); 
+    } 
+}; 
+ 
+TStreamQueryClient::TStreamQueryClient(const TDriver& driver, const TCommonClientSettings& settings) 
+    : Impl_(new TImpl(CreateInternalInterface(driver), settings)) {} 
+ 
+TParamsBuilder TStreamQueryClient::GetParamsBuilder() { 
     return TParamsBuilder();
-}
-
-TAsyncStreamPartIterator TStreamQueryClient::ExecuteStreamQuery(const TString& query,
-    const TExecuteStreamQuerySettings& settings)
-{
-    return Impl_->ExecuteStreamQuery(query, nullptr, settings);
-}
-
-TAsyncStreamPartIterator TStreamQueryClient::ExecuteStreamQuery(const TString& query, const TParams& params,
-    const TExecuteStreamQuerySettings& settings)
-{
-    return Impl_->ExecuteStreamQuery(query, &params, settings);
-}
-
-} // namespace NExperimental
-} // namespace NYdb
+} 
+ 
+TAsyncStreamPartIterator TStreamQueryClient::ExecuteStreamQuery(const TString& query, 
+    const TExecuteStreamQuerySettings& settings) 
+{ 
+    return Impl_->ExecuteStreamQuery(query, nullptr, settings); 
+} 
+ 
+TAsyncStreamPartIterator TStreamQueryClient::ExecuteStreamQuery(const TString& query, const TParams& params, 
+    const TExecuteStreamQuerySettings& settings) 
+{ 
+    return Impl_->ExecuteStreamQuery(query, &params, settings); 
+} 
+ 
+} // namespace NExperimental 
+} // namespace NYdb 
diff --git a/ydb/public/lib/experimental/ydb_experimental.h b/ydb/public/lib/experimental/ydb_experimental.h
index 3cdd8f6dc8..3cdf07343d 100644
--- a/ydb/public/lib/experimental/ydb_experimental.h
+++ b/ydb/public/lib/experimental/ydb_experimental.h
@@ -7,34 +7,34 @@ namespace NExperimental {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TStreamPartIterator;
-
-using TAsyncStreamPartIterator = NThreading::TFuture<TStreamPartIterator>;
-
-class TStreamPartStatus : public TStatus {
-public:
-    TStreamPartStatus(TStatus&& status);
-    bool EOS() const;
-};
-
-class TStreamPart : public TStreamPartStatus {
-public:
+class TStreamPartIterator; 
+ 
+using TAsyncStreamPartIterator = NThreading::TFuture<TStreamPartIterator>; 
+ 
+class TStreamPartStatus : public TStatus { 
+public: 
+    TStreamPartStatus(TStatus&& status); 
+    bool EOS() const; 
+}; 
+ 
+class TStreamPart : public TStreamPartStatus { 
+public: 
     bool HasResultSet() const { return ResultSet_.Defined(); }
     const TResultSet& GetResultSet() const { return *ResultSet_; }
     TResultSet ExtractResultSet() { return std::move(*ResultSet_); }
-
+ 
     bool HasProfile() const { return Profile_.Defined(); }
     const TString& GetProfile() const { return *Profile_; }
     TString ExtractProfile() { return std::move(*Profile_); }
-
+ 
     bool HasPlan() const { return Plan_.Defined(); }
     const TString& GetPlan() const { return *Plan_; }
     TString ExtractPlan() { return std::move(*Plan_); }
 
     TStreamPart(TStatus&& status)
-        : TStreamPartStatus(std::move(status))
-    {}
-
+        : TStreamPartStatus(std::move(status)) 
+    {} 
+ 
     TStreamPart(TResultSet&& resultSet, TStatus&& status)
         : TStreamPartStatus(std::move(status))
         , ResultSet_(std::move(resultSet))
@@ -50,57 +50,57 @@ public:
         , Plan_(plan)
     {}
 
-private:
+private: 
     TMaybe<TResultSet> ResultSet_;
     TMaybe<TString> Profile_;
     TMaybe<TString> Plan_;
-};
-
+}; 
+ 
 using TAsyncStreamPart = NThreading::TFuture<TStreamPart>;
-
-class TStreamPartIterator : public TStatus {
-    friend class TStreamQueryClient;
-public:
+ 
+class TStreamPartIterator : public TStatus { 
+    friend class TStreamQueryClient; 
+public: 
     TAsyncStreamPart ReadNext();
-    class TReaderImpl;
-private:
-    TStreamPartIterator(
-        std::shared_ptr<TReaderImpl> impl,
+    class TReaderImpl; 
+private: 
+    TStreamPartIterator( 
+        std::shared_ptr<TReaderImpl> impl, 
         TPlainStatus&& status
-    );
-    std::shared_ptr<TReaderImpl> ReaderImpl_;
-};
-
+    ); 
+    std::shared_ptr<TReaderImpl> ReaderImpl_; 
+}; 
+ 
 enum class EStreamQueryProfileMode {
     None,
-    Basic,
-    Full
+    Basic, 
+    Full 
 };
 
-struct TExecuteStreamQuerySettings : public TRequestSettings<TExecuteStreamQuerySettings> {
-    using TSelf = TExecuteStreamQuerySettings;
+struct TExecuteStreamQuerySettings : public TRequestSettings<TExecuteStreamQuerySettings> { 
+    using TSelf = TExecuteStreamQuerySettings; 
 
     FLUENT_SETTING_DEFAULT(EStreamQueryProfileMode, ProfileMode, EStreamQueryProfileMode::None);
     FLUENT_SETTING_DEFAULT(bool, Explain, false);
-};
-
-class TStreamQueryClient {
-    class TImpl;
-
-public:
-    TStreamQueryClient(const TDriver& driver, const TCommonClientSettings& settings = TCommonClientSettings());
-
-    TParamsBuilder GetParamsBuilder();
-
-    TAsyncStreamPartIterator ExecuteStreamQuery(const TString& query,
-        const TExecuteStreamQuerySettings& settings = TExecuteStreamQuerySettings());
-
-    TAsyncStreamPartIterator ExecuteStreamQuery(const TString& query, const TParams& params,
-        const TExecuteStreamQuerySettings& settings = TExecuteStreamQuerySettings());
-
-private:
-    std::shared_ptr<TImpl> Impl_;
-};
-
-} // namespace NExperimental
-} // namespace NYdb
+}; 
+ 
+class TStreamQueryClient { 
+    class TImpl; 
+ 
+public: 
+    TStreamQueryClient(const TDriver& driver, const TCommonClientSettings& settings = TCommonClientSettings()); 
+ 
+    TParamsBuilder GetParamsBuilder(); 
+ 
+    TAsyncStreamPartIterator ExecuteStreamQuery(const TString& query, 
+        const TExecuteStreamQuerySettings& settings = TExecuteStreamQuerySettings()); 
+ 
+    TAsyncStreamPartIterator ExecuteStreamQuery(const TString& query, const TParams& params, 
+        const TExecuteStreamQuerySettings& settings = TExecuteStreamQuerySettings()); 
+ 
+private: 
+    std::shared_ptr<TImpl> Impl_; 
+}; 
+ 
+} // namespace NExperimental 
+} // namespace NYdb 
diff --git a/ydb/public/lib/experimental/ydb_s3_internal.cpp b/ydb/public/lib/experimental/ydb_s3_internal.cpp
index ac1c5025ed..d5324cf2f3 100644
--- a/ydb/public/lib/experimental/ydb_s3_internal.cpp
+++ b/ydb/public/lib/experimental/ydb_s3_internal.cpp
@@ -15,18 +15,18 @@
 namespace NYdb {
 namespace NS3Internal {
 
-TS3ListingResult::TS3ListingResult(TResultSet&& commonPrefixes, TResultSet&& contents, ui32 keySuffixSize, TStatus&& status)
+TS3ListingResult::TS3ListingResult(TResultSet&& commonPrefixes, TResultSet&& contents, ui32 keySuffixSize, TStatus&& status) 
     : TStatus(std::move(status))
     , CommonPrefixes(std::move(commonPrefixes))
     , Contents(std::move(contents))
     , KeySuffixSize(keySuffixSize)
 {}
 
-const TResultSet& TS3ListingResult::GetCommonPrefixes() const {
+const TResultSet& TS3ListingResult::GetCommonPrefixes() const { 
     return CommonPrefixes;
 }
 
-const TResultSet& TS3ListingResult::GetContents() const {
+const TResultSet& TS3ListingResult::GetContents() const { 
     return Contents;
 }
 
@@ -73,8 +73,8 @@ public:
                 if (any) {
                     any->UnpackTo(&result);
                 }
-                TResultSet commonPrefixes(result.Getcommon_prefixes());
-                TResultSet contents(result.Getcontents());
+                TResultSet commonPrefixes(result.Getcommon_prefixes()); 
+                TResultSet contents(result.Getcontents()); 
 
                 TS3ListingResult val(std::move(commonPrefixes), std::move(contents), result.Getkey_suffix_size(),
                     TStatus(std::move(status)));
@@ -87,7 +87,7 @@ public:
             &Ydb::S3Internal::V1::S3InternalService::Stub::AsyncS3Listing,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_);
 
         return promise.GetFuture();
diff --git a/ydb/public/lib/experimental/ydb_s3_internal.h b/ydb/public/lib/experimental/ydb_s3_internal.h
index ee70f0dcdd..ea9b9ac213 100644
--- a/ydb/public/lib/experimental/ydb_s3_internal.h
+++ b/ydb/public/lib/experimental/ydb_s3_internal.h
@@ -12,16 +12,16 @@ struct TS3ListingSettings : public TOperationRequestSettings<TS3ListingSettings>
 class TS3ListingResult : public TStatus {
     friend class TS3InternalClient;
 private:
-    TS3ListingResult(TResultSet&& commonPrefixes, TResultSet&& contents, ui32 keySuffixSize, TStatus&& status);
+    TS3ListingResult(TResultSet&& commonPrefixes, TResultSet&& contents, ui32 keySuffixSize, TStatus&& status); 
 
 public:
-    const TResultSet& GetCommonPrefixes() const;
-    const TResultSet& GetContents() const;
+    const TResultSet& GetCommonPrefixes() const; 
+    const TResultSet& GetContents() const; 
     ui32 GetKeySuffixSize() const;
 
 private:
-    TResultSet CommonPrefixes;
-    TResultSet Contents;
+    TResultSet CommonPrefixes; 
+    TResultSet Contents; 
     const ui32 KeySuffixSize;
 };
 
diff --git a/ydb/public/lib/idx_test/idx_test_loader.cpp b/ydb/public/lib/idx_test/idx_test_loader.cpp
index 392604288e..64b04ba539 100644
--- a/ydb/public/lib/idx_test/idx_test_loader.cpp
+++ b/ydb/public/lib/idx_test/idx_test_loader.cpp
@@ -244,9 +244,9 @@ public:
                     const auto& status = result.Status;
                     if (status.GetStatus() == EStatus::PRECONDITION_FAILED) {
                         // Client emulated status
-                        return result.Tx->Commit().Apply([](const auto& future) {
-                            return NThreading::MakeFuture<TStatus>(future.GetValue());
-                        });
+                        return result.Tx->Commit().Apply([](const auto& future) { 
+                            return NThreading::MakeFuture<TStatus>(future.GetValue()); 
+                        }); 
                     } else if (status.GetStatus() == EStatus::SUCCESS) {
                         // start upsert
                         const auto& program = Programs_[0];
@@ -552,7 +552,7 @@ private:
 
             if (i == Programs_.size()) {
                 return in.GetTransaction()->Commit()
-                    .Apply([this, err](TAsyncCommitTransactionResult future) {
+                    .Apply([this, err](TAsyncCommitTransactionResult future) { 
                         auto result = future.ExtractValue();
                         if (err && (result.GetStatus() != EStatus::ABORTED)) {
                             with_lock(Mtx_) {
diff --git a/ydb/public/lib/operation_id/operation_id.cpp b/ydb/public/lib/operation_id/operation_id.cpp
index 725da690f4..a7bed67c60 100644
--- a/ydb/public/lib/operation_id/operation_id.cpp
+++ b/ydb/public/lib/operation_id/operation_id.cpp
@@ -13,24 +13,24 @@ namespace NOperationId {
 
 using namespace NUri;
 
-TString ProtoToString(const Ydb::TOperationId& proto) {
+TString ProtoToString(const Ydb::TOperationId& proto) { 
     using namespace ::google::protobuf;
     const Reflection& reflection = *proto.GetReflection();
     std::vector<const FieldDescriptor*> fields;
     reflection.ListFields(proto, &fields);
     TStringStream res;
     switch (proto.GetKind()) {
-        case Ydb::TOperationId::OPERATION_DDL:
-        case Ydb::TOperationId::OPERATION_DML:
+        case Ydb::TOperationId::OPERATION_DDL: 
+        case Ydb::TOperationId::OPERATION_DML: 
             res << "ydb://operation";
             break;
-        case Ydb::TOperationId::SESSION_YQL:
+        case Ydb::TOperationId::SESSION_YQL: 
             res << "ydb://session";
             break;
-        case Ydb::TOperationId::PREPARED_QUERY_ID:
+        case Ydb::TOperationId::PREPARED_QUERY_ID: 
             res << "ydb://preparedqueryid";
             break;
-        case Ydb::TOperationId::CMS_REQUEST:
+        case Ydb::TOperationId::CMS_REQUEST: 
             res << "ydb://cmsrequest";
             break;
         case Ydb::TOperationId::EXPORT:
@@ -58,7 +58,7 @@ TString ProtoToString(const Ydb::TOperationId& proto) {
                 }
                 for (int i = 0; i < size; i++) {
                     const auto& message = reflection.GetRepeatedMessage(proto, field, i);
-                    const auto& data = dynamic_cast<const Ydb::TOperationId::TData&>(message);
+                    const auto& data = dynamic_cast<const Ydb::TOperationId::TData&>(message); 
                     TUri::ReEncode(res, data.GetKey());
                     res << "=";
                     TUri::ReEncode(res, data.GetValue());
@@ -113,7 +113,7 @@ TOperationId::TOperationId(const TString &string, bool allowEmpty) {
         ythrow yexception() << "Invalid operation kind: " << kind;
     }
 
-    SetKind(static_cast<Ydb::TOperationId::EKind>(kind));
+    SetKind(static_cast<Ydb::TOperationId::EKind>(kind)); 
 
     const TString& query = uri.PrintS(TField::FlagQuery);
 
@@ -149,7 +149,7 @@ TString TOperationId::GetSubKind() const {
     return *it->second.at(0);
 }
 
-void AddOptionalValue(Ydb::TOperationId& proto, const TString& key, const TString& value) {
+void AddOptionalValue(Ydb::TOperationId& proto, const TString& key, const TString& value) { 
     auto data = proto.AddData();
     data->SetKey(key);
     data->SetValue(value);
diff --git a/ydb/public/lib/operation_id/operation_id.h b/ydb/public/lib/operation_id/operation_id.h
index 23f91140d1..3949a8a0fe 100644
--- a/ydb/public/lib/operation_id/operation_id.h
+++ b/ydb/public/lib/operation_id/operation_id.h
@@ -9,7 +9,7 @@
 namespace NKikimr {
 namespace NOperationId {
 
-class TOperationId : public Ydb::TOperationId {
+class TOperationId : public Ydb::TOperationId { 
 public:
     TOperationId();
     explicit TOperationId(const TString& string, bool allowEmpty = false);
@@ -20,9 +20,9 @@ private:
      THashMap<TString, TVector<const TString*>> Index_;
 };
 
-TString ProtoToString(const Ydb::TOperationId& proto);
-void AddOptionalValue(Ydb::TOperationId& proto, const TString& key, const TString& value);
-void AddOptionalValue(Ydb::TOperationId& proto, const TString& key, const char* value, size_t size);
+TString ProtoToString(const Ydb::TOperationId& proto); 
+void AddOptionalValue(Ydb::TOperationId& proto, const TString& key, const TString& value); 
+void AddOptionalValue(Ydb::TOperationId& proto, const TString& key, const char* value, size_t size); 
 Ydb::TOperationId::EKind ParseKind(const TStringBuf value);
 
 } // namespace NOperationId
diff --git a/ydb/public/lib/operation_id/operation_id_ut.cpp b/ydb/public/lib/operation_id/operation_id_ut.cpp
index 64fbedce4b..ff58d919c2 100644
--- a/ydb/public/lib/operation_id/operation_id_ut.cpp
+++ b/ydb/public/lib/operation_id/operation_id_ut.cpp
@@ -8,8 +8,8 @@ namespace NOperationId {
 
 Y_UNIT_TEST_SUITE(OperationIdTest) {
     Y_UNIT_TEST(ConvertKindOnly) {
-        Ydb::TOperationId proto;
-        proto.SetKind(Ydb::TOperationId::OPERATION_DDL);
+        Ydb::TOperationId proto; 
+        proto.SetKind(Ydb::TOperationId::OPERATION_DDL); 
         auto str = ProtoToString(proto);
         UNIT_ASSERT_EQUAL(str, "ydb://operation/1");
         auto newProto = TOperationId(str);
@@ -18,8 +18,8 @@ Y_UNIT_TEST_SUITE(OperationIdTest) {
     }
 
     Y_UNIT_TEST(ConvertKindAndValues) {
-        Ydb::TOperationId proto;
-        proto.SetKind(Ydb::TOperationId::OPERATION_DDL);
+        Ydb::TOperationId proto; 
+        proto.SetKind(Ydb::TOperationId::OPERATION_DDL); 
         {
             auto data = proto.AddData();
             data->SetKey("key1");
diff --git a/ydb/public/lib/operation_id/protos/operation_id.proto b/ydb/public/lib/operation_id/protos/operation_id.proto
index b6534e794b..ac20386f1f 100644
--- a/ydb/public/lib/operation_id/protos/operation_id.proto
+++ b/ydb/public/lib/operation_id/protos/operation_id.proto
@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-package Ydb;
+package Ydb; 
 
 message TOperationId {
     enum EKind {
diff --git a/ydb/public/lib/value/value.cpp b/ydb/public/lib/value/value.cpp
index 0ed8b82689..3217d4071c 100644
--- a/ydb/public/lib/value/value.cpp
+++ b/ydb/public/lib/value/value.cpp
@@ -167,46 +167,46 @@ TWriteValue TWriteValue::AddListItem() {
     return TWriteValue::Create(*Value.AddList(), *Type.MutableList()->MutableItem());
 }
 
-TWriteValue TWriteValue::AddTupleItem() {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Tuple);
-    NKikimrMiniKQL::TType* type = Type.MutableTuple()->AddElement();
-    NKikimrMiniKQL::TValue* value = Value.AddTuple();
-    return TWriteValue::Create(*value, *type);
-}
-
+TWriteValue TWriteValue::AddTupleItem() { 
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Tuple); 
+    NKikimrMiniKQL::TType* type = Type.MutableTuple()->AddElement(); 
+    NKikimrMiniKQL::TValue* value = Value.AddTuple(); 
+    return TWriteValue::Create(*value, *type); 
+} 
+ 
 TWriteValue& TWriteValue::Void() {
     Type.SetKind(NKikimrMiniKQL::ETypeKind::Void);
     return *this;
 }
 
-TWriteValue& TWriteValue::Bytes(const char* value) {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
+TWriteValue& TWriteValue::Bytes(const char* value) { 
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
     Type.MutableData()->SetScheme(NScheme::NTypeIds::String);
-    Value.SetBytes(value);
-    return *this;
-}
-
+    Value.SetBytes(value); 
+    return *this; 
+} 
+ 
 TWriteValue& TWriteValue::Bytes(const TString& value) {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
     Type.MutableData()->SetScheme(NScheme::NTypeIds::String);
-    Value.SetBytes(value);
-    return *this;
-}
-
-TWriteValue& TWriteValue::Yson(const char* value) {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-    Type.MutableData()->SetScheme(NScheme::NTypeIds::Yson);
-    Value.SetBytes(value);
-    return *this;
-}
-
+    Value.SetBytes(value); 
+    return *this; 
+} 
+ 
+TWriteValue& TWriteValue::Yson(const char* value) { 
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+    Type.MutableData()->SetScheme(NScheme::NTypeIds::Yson); 
+    Value.SetBytes(value); 
+    return *this; 
+} 
+ 
 TWriteValue& TWriteValue::Yson(const TString& value) {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-    Type.MutableData()->SetScheme(NScheme::NTypeIds::Yson);
-    Value.SetBytes(value);
-    return *this;
-}
-
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+    Type.MutableData()->SetScheme(NScheme::NTypeIds::Yson); 
+    Value.SetBytes(value); 
+    return *this; 
+} 
+ 
 TWriteValue& TWriteValue::Json(const char* value) {
     Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
     Type.MutableData()->SetScheme(NScheme::NTypeIds::Json);
@@ -221,34 +221,34 @@ TWriteValue& TWriteValue::Json(const TString& value) {
     return *this;
 }
 
-TWriteValue& TWriteValue::Date(ui16 value) {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-    Type.MutableData()->SetScheme(NScheme::NTypeIds::Date);
-    Value.SetUint32(value);
-    return *this;
-}
-
-TWriteValue& TWriteValue::Datetime(ui32 value) {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-    Type.MutableData()->SetScheme(NScheme::NTypeIds::Datetime);
-    Value.SetUint32(value);
-    return *this;
-}
-
-TWriteValue& TWriteValue::Timestamp(ui64 value) {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-    Type.MutableData()->SetScheme(NScheme::NTypeIds::Timestamp);
-    Value.SetUint64(value);
-    return *this;
-}
-
+TWriteValue& TWriteValue::Date(ui16 value) { 
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+    Type.MutableData()->SetScheme(NScheme::NTypeIds::Date); 
+    Value.SetUint32(value); 
+    return *this; 
+} 
+ 
+TWriteValue& TWriteValue::Datetime(ui32 value) { 
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+    Type.MutableData()->SetScheme(NScheme::NTypeIds::Datetime); 
+    Value.SetUint32(value); 
+    return *this; 
+} 
+ 
+TWriteValue& TWriteValue::Timestamp(ui64 value) { 
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+    Type.MutableData()->SetScheme(NScheme::NTypeIds::Timestamp); 
+    Value.SetUint64(value); 
+    return *this; 
+} 
+ 
 TWriteValue& TWriteValue::Interval(i64 value) {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-    Type.MutableData()->SetScheme(NScheme::NTypeIds::Interval);
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+    Type.MutableData()->SetScheme(NScheme::NTypeIds::Interval); 
     Value.SetInt64(value);
-    return *this;
-}
-
+    return *this; 
+} 
+ 
 TWriteValue& TWriteValue::operator =(bool value) {
     Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
     Type.MutableData()->SetScheme(NScheme::NTypeIds::Bool);
@@ -256,13 +256,13 @@ TWriteValue& TWriteValue::operator =(bool value) {
     return *this;
 }
 
-TWriteValue& TWriteValue::operator =(ui8 value) {
-    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
+TWriteValue& TWriteValue::operator =(ui8 value) { 
+    Type.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
     Type.MutableData()->SetScheme(NScheme::NTypeIds::Uint8);
-    Value.SetUint32(value);
-    return *this;
-}
-
+    Value.SetUint32(value); 
+    return *this; 
+} 
+ 
 TWriteValue& TWriteValue::operator =(i8 value) {
     Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
     Type.MutableData()->SetScheme(NScheme::NTypeIds::Int8);
@@ -307,7 +307,7 @@ TWriteValue& TWriteValue::operator =(ui32 value) {
 
 TWriteValue& TWriteValue::operator =(i32 value) {
     Type.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-    Type.MutableData()->SetScheme(NScheme::NTypeIds::Int32);
+    Type.MutableData()->SetScheme(NScheme::NTypeIds::Int32); 
     Value.SetInt32(value);
     return *this;
 }
@@ -340,24 +340,24 @@ TWriteValue& TWriteValue::operator =(const char* value) {
     return *this;
 }
 
-TWriteValue& TWriteValue::operator =(const TValue& value) {
-    Type.CopyFrom(value.GetType());
-    Value.CopyFrom(value.GetValue());
-    return *this;
-}
-
-ui32 TWriteValue::GetValueBytesSize() const {
-    return (ui32)Value.ByteSize();
-}
-
-ui32 TWriteValue::GetTypeBytesSize() const {
-    return (ui32)Type.ByteSize();
-}
-
-ui32 TWriteValue::GetBytesSize() const {
-    return GetValueBytesSize() + GetTypeBytesSize();
-}
-
+TWriteValue& TWriteValue::operator =(const TValue& value) { 
+    Type.CopyFrom(value.GetType()); 
+    Value.CopyFrom(value.GetValue()); 
+    return *this; 
+} 
+ 
+ui32 TWriteValue::GetValueBytesSize() const { 
+    return (ui32)Value.ByteSize(); 
+} 
+ 
+ui32 TWriteValue::GetTypeBytesSize() const { 
+    return (ui32)Type.ByteSize(); 
+} 
+ 
+ui32 TWriteValue::GetBytesSize() const { 
+    return GetValueBytesSize() + GetTypeBytesSize(); 
+} 
+ 
 size_t TValue::Size() const {
     if (Type.HasList())
         return Value.ListSize();
@@ -915,12 +915,12 @@ TValue::operator bool() const {
     return Value.GetBool();
 }
 
-TValue::operator ui8() const {
+TValue::operator ui8() const { 
     Y_ASSERT(Type.GetData().GetScheme() == NScheme::NTypeIds::Uint8);
-    Y_ASSERT(Value.HasUint32());
-    return Value.GetUint32();
-}
-
+    Y_ASSERT(Value.HasUint32()); 
+    return Value.GetUint32(); 
+} 
+ 
 TValue::operator ui16() const {
     Y_ASSERT(Type.GetData().GetScheme() == NScheme::NTypeIds::Uint16);
     Y_ASSERT(Value.HasUint32());
diff --git a/ydb/public/lib/value/value.h b/ydb/public/lib/value/value.h
index 8ae368ac02..b6e9c7e18f 100644
--- a/ydb/public/lib/value/value.h
+++ b/ydb/public/lib/value/value.h
@@ -170,28 +170,28 @@ public:
         return *this;
     }
 
-    template <typename ItemType, NScheme::TTypeId SchemeType = SchemeMapper<ItemType>::SchemeType>
-    TWriteValue& EmptyOptional() {
-        Type.SetKind(NKikimrMiniKQL::ETypeKind::Optional);
-
-        auto& optionalType = *Type.MutableOptional()->MutableItem();
-        optionalType.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-        optionalType.MutableData()->SetScheme(SchemeType);
-
-        return *this;
-    }
-
-    template <typename ItemType, NScheme::TTypeId SchemeType = SchemeMapper<ItemType>::SchemeType>
-    TWriteValue& EmptyList() {
-        Type.SetKind(NKikimrMiniKQL::ETypeKind::List);
-
-        auto& itemType = *Type.MutableList()->MutableItem();
-        itemType.SetKind(NKikimrMiniKQL::ETypeKind::Data);
-        itemType.MutableData()->SetScheme(SchemeType);
-
-        return *this;
-    }
-
+    template <typename ItemType, NScheme::TTypeId SchemeType = SchemeMapper<ItemType>::SchemeType> 
+    TWriteValue& EmptyOptional() { 
+        Type.SetKind(NKikimrMiniKQL::ETypeKind::Optional); 
+ 
+        auto& optionalType = *Type.MutableOptional()->MutableItem(); 
+        optionalType.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+        optionalType.MutableData()->SetScheme(SchemeType); 
+ 
+        return *this; 
+    } 
+ 
+    template <typename ItemType, NScheme::TTypeId SchemeType = SchemeMapper<ItemType>::SchemeType> 
+    TWriteValue& EmptyList() { 
+        Type.SetKind(NKikimrMiniKQL::ETypeKind::List); 
+ 
+        auto& itemType = *Type.MutableList()->MutableItem(); 
+        itemType.SetKind(NKikimrMiniKQL::ETypeKind::Data); 
+        itemType.MutableData()->SetScheme(SchemeType); 
+ 
+        return *this; 
+    } 
+ 
     ui32 GetValueBytesSize() const;
     ui32 GetTypeBytesSize() const;
     ui32 GetBytesSize() const;
diff --git a/ydb/public/lib/ya.make b/ydb/public/lib/ya.make
index a4f529b44b..4096d94368 100644
--- a/ydb/public/lib/ya.make
+++ b/ydb/public/lib/ya.make
@@ -12,5 +12,5 @@ RECURSE(
     value
     ydb_cli
     yq
-    yson_value
+    yson_value 
 )
diff --git a/ydb/public/lib/ydb_cli/commands/ydb_service_scripting.cpp b/ydb/public/lib/ydb_cli/commands/ydb_service_scripting.cpp
index 4a25c372ce..568345fec5 100644
--- a/ydb/public/lib/ydb_cli/commands/ydb_service_scripting.cpp
+++ b/ydb/public/lib/ydb_cli/commands/ydb_service_scripting.cpp
@@ -22,8 +22,8 @@ TCommandExecuteYqlScript::TCommandExecuteYqlScript()
 void TCommandExecuteYqlScript::Config(TConfig& config) {
     AddExamplesOption(config);
     TYdbOperationCommand::Config(config);
-    config.Opts->AddLongOption("stats", "Collect statistics mode [none, basic, full]")
-        .RequiredArgument("[String]").StoreResult(&CollectStatsMode);
+    config.Opts->AddLongOption("stats", "Collect statistics mode [none, basic, full]") 
+        .RequiredArgument("[String]").StoreResult(&CollectStatsMode); 
     config.Opts->AddLongOption('s', "script", "Text of script to execute").RequiredArgument("[String]").StoreResult(&Script);
     config.Opts->AddLongOption('f', "file", "[Required] Script file").RequiredArgument("PATH").StoreResult(&ScriptFile);
     config.Opts->AddLongOption("explain", "Explain query").Optional().StoreTrue(&Explain);
@@ -81,11 +81,11 @@ int TCommandExecuteYqlScript::Run(TConfig& config) {
         Script = ReadFromFile(ScriptFile, "script");
     }
     NScripting::TScriptingClient client(CreateDriver(config));
-
+ 
     if (Explain) {
         NScripting::TExplainYqlRequestSettings settings;
         settings.Mode(NScripting::ExplainYqlRequestMode::Plan);
-
+ 
         auto result = client.ExplainYqlScript(Script, settings).GetValueSync();
 
         ThrowOnError(result);
@@ -114,7 +114,7 @@ int TCommandExecuteYqlScript::Run(TConfig& config) {
         PrintResponseHeader(result);
         PrintResponse(result);
     }
-
+ 
     return EXIT_SUCCESS;
 }
 
@@ -129,11 +129,11 @@ void TCommandExecuteYqlScript::PrintResponse(NScripting::TExecuteYqlResult& resu
             printer.Print(*resultSetIt);
         }
     } // TResultSetPrinter destructor should be called before printing stats
-
-    const TMaybe<NTable::TQueryStats>& stats = result.GetStats();
-    if (stats.Defined()) {
-        Cout << Endl << "Statistics:" << Endl << stats->ToString();
-    }
+ 
+    const TMaybe<NTable::TQueryStats>& stats = result.GetStats(); 
+    if (stats.Defined()) { 
+        Cout << Endl << "Statistics:" << Endl << stats->ToString(); 
+    } 
 }
 
 void TCommandExecuteYqlScript::PrintExplainResult(NScripting::TExplainYqlResult& result) {
diff --git a/ydb/public/lib/ydb_cli/commands/ydb_service_scripting.h b/ydb/public/lib/ydb_cli/commands/ydb_service_scripting.h
index 9911c6a744..2a0690d0ab 100644
--- a/ydb/public/lib/ydb_cli/commands/ydb_service_scripting.h
+++ b/ydb/public/lib/ydb_cli/commands/ydb_service_scripting.h
@@ -27,7 +27,7 @@ public:
     void PrintExplainResult(NScripting::TExplainYqlResult& result);
 
 private:
-    TString CollectStatsMode;
+    TString CollectStatsMode; 
     TString Script;
     TString ScriptFile;
     bool Explain = false;
diff --git a/ydb/public/lib/ydb_cli/commands/ydb_service_table.cpp b/ydb/public/lib/ydb_cli/commands/ydb_service_table.cpp
index 2f94b2fc03..159cb03c2f 100644
--- a/ydb/public/lib/ydb_cli/commands/ydb_service_table.cpp
+++ b/ydb/public/lib/ydb_cli/commands/ydb_service_table.cpp
@@ -13,8 +13,8 @@
 #include <util/folder/path.h>
 #include <util/folder/dirut.h>
 
-#include <math.h>
-
+#include <math.h> 
+ 
 namespace NYdb {
 namespace NConsoleClient {
 
@@ -406,10 +406,10 @@ int TCommandExecuteQuery::Run(TConfig& config) {
 }
 
 int TCommandExecuteQuery::ExecuteDataQuery(TConfig& config) {
-    auto defaultStatsMode = BasicStats ? NTable::ECollectQueryStatsMode::Basic : NTable::ECollectQueryStatsMode::None;
+    auto defaultStatsMode = BasicStats ? NTable::ECollectQueryStatsMode::Basic : NTable::ECollectQueryStatsMode::None; 
     NTable::TExecDataQuerySettings settings;
-    settings.CollectQueryStats(ParseQueryStatsMode(CollectStatsMode, defaultStatsMode));
-
+    settings.CollectQueryStats(ParseQueryStatsMode(CollectStatsMode, defaultStatsMode)); 
+ 
     NTable::TTxSettings txSettings;
     if (TxMode) {
         if (TxMode == "serializable-rw") {
@@ -478,10 +478,10 @@ int TCommandExecuteQuery::ExecuteSchemeQuery(TConfig& config) {
 
 int TCommandExecuteQuery::ExecuteScanQuery(TConfig& config) {
     NTable::TTableClient client(CreateDriver(config));
-
-    auto defaultStatsMode = BasicStats ? NTable::ECollectQueryStatsMode::Basic : NTable::ECollectQueryStatsMode::None;
+ 
+    auto defaultStatsMode = BasicStats ? NTable::ECollectQueryStatsMode::Basic : NTable::ECollectQueryStatsMode::None; 
     NTable::TStreamExecScanQuerySettings settings;
-    settings.CollectQueryStats(ParseQueryStatsMode(CollectStatsMode, defaultStatsMode));
+    settings.CollectQueryStats(ParseQueryStatsMode(CollectStatsMode, defaultStatsMode)); 
 
     NTable::TAsyncScanQueryPartIterator asyncResult;
     if (Parameters.size()) {
@@ -515,7 +515,7 @@ void TCommandExecuteQuery::PrintScanQueryResponse(NTable::TScanQueryPartIterator
                 }
                 ThrowOnError(streamPart);
             }
-
+ 
             if (streamPart.HasResultSet()) {
                 printer.Print(streamPart.GetResultSet());
             }
@@ -523,12 +523,12 @@ void TCommandExecuteQuery::PrintScanQueryResponse(NTable::TScanQueryPartIterator
             if (streamPart.HasQueryStats()) {
                 const auto& queryStats = streamPart.GetQueryStats();
                 statsStr << Endl << queryStats.ToString(false) << Endl;
-
+ 
                 auto plan = queryStats.GetPlan();
                 if (plan) {
                     statsStr << "Full statistics:" << Endl << *plan << Endl;
                 }
-            }
+            } 
         }
     } // TResultSetPrinter destructor should be called before printing stats
 
@@ -551,8 +551,8 @@ void TCommandExplain::Config(TConfig& config) {
     config.Opts->AddLongOption('q', "query", "Text of query to explain").RequiredArgument("[String]").StoreResult(&Query);
     config.Opts->AddLongOption('f', "file", "Path to file with query text to explain")
         .RequiredArgument("PATH").StoreResult(&QueryFile);
-    config.Opts->AddLongOption("ast", "Print query AST")
-        .StoreTrue(&PrintAst);
+    config.Opts->AddLongOption("ast", "Print query AST") 
+        .StoreTrue(&PrintAst); 
 
     config.Opts->AddLongOption('t', "type", "Query type [data, scan]")
         .RequiredArgument("[String]").DefaultValue("data").StoreResult(&QueryType);
@@ -576,13 +576,13 @@ void TCommandExplain::Parse(TConfig& config) {
 
 int TCommandExplain::Run(TConfig& config) {
     CheckQueryFile();
-
+ 
     TString planJson;
     TString ast;
     if (QueryType == "scan") {
         NTable::TTableClient client(CreateDriver(config));
         NTable::TStreamExecScanQuerySettings settings;
-
+ 
         if (Analyze) {
             settings.CollectQueryStats(NTable::ECollectQueryStatsMode::Full);
         } else {
@@ -640,7 +640,7 @@ int TCommandExplain::Run(TConfig& config) {
         throw TMissUseException() << "Unknown query type for explain.";
     }
 
-    if (PrintAst) {
+    if (PrintAst) { 
         Cout << "Query AST:" << Endl << ast << Endl;
     } else {
         Cout << "Query Plan:" << Endl;
diff --git a/ydb/public/lib/ydb_cli/commands/ydb_service_table.h b/ydb/public/lib/ydb_cli/commands/ydb_service_table.h
index 5cd2514aa0..439b686d3d 100644
--- a/ydb/public/lib/ydb_cli/commands/ydb_service_table.h
+++ b/ydb/public/lib/ydb_cli/commands/ydb_service_table.h
@@ -121,10 +121,10 @@ public:
     virtual void Config(TConfig& config) override;
     virtual void Parse(TConfig& config) override;
     virtual int Run(TConfig& config) override;
+ 
+private: 
 
-private:
-
-    bool PrintAst = false;
+    bool PrintAst = false; 
     TString QueryType;
     bool Analyze = false;
 };
diff --git a/ydb/public/lib/ydb_cli/common/query_stats.cpp b/ydb/public/lib/ydb_cli/common/query_stats.cpp
index cab9dfaa2b..378d5f5f84 100644
--- a/ydb/public/lib/ydb_cli/common/query_stats.cpp
+++ b/ydb/public/lib/ydb_cli/common/query_stats.cpp
@@ -1,27 +1,27 @@
-#include "query_stats.h"
-
-#include "common.h"
-
-namespace NYdb {
-namespace NConsoleClient {
-
-NTable::ECollectQueryStatsMode ParseQueryStatsMode(const TString& statsMode,
-    NTable::ECollectQueryStatsMode defaultMode)
-{
-    if (statsMode) {
-        if (statsMode == "none") {
-            return NTable::ECollectQueryStatsMode::None;
-        } else if (statsMode == "basic") {
-            return NTable::ECollectQueryStatsMode::Basic;
-        } else if (statsMode == "full") {
-            return NTable::ECollectQueryStatsMode::Full;
-        } else {
-            throw TMissUseException() << "Unknown stats collection mode.";
-        }
-    }
-
-    return defaultMode;
-}
-
-} // namespace NConsoleClient
-} // namespace NYdb
+#include "query_stats.h" 
+ 
+#include "common.h" 
+ 
+namespace NYdb { 
+namespace NConsoleClient { 
+ 
+NTable::ECollectQueryStatsMode ParseQueryStatsMode(const TString& statsMode, 
+    NTable::ECollectQueryStatsMode defaultMode) 
+{ 
+    if (statsMode) { 
+        if (statsMode == "none") { 
+            return NTable::ECollectQueryStatsMode::None; 
+        } else if (statsMode == "basic") { 
+            return NTable::ECollectQueryStatsMode::Basic; 
+        } else if (statsMode == "full") { 
+            return NTable::ECollectQueryStatsMode::Full; 
+        } else { 
+            throw TMissUseException() << "Unknown stats collection mode."; 
+        } 
+    } 
+ 
+    return defaultMode; 
+} 
+ 
+} // namespace NConsoleClient 
+} // namespace NYdb 
diff --git a/ydb/public/lib/ydb_cli/common/query_stats.h b/ydb/public/lib/ydb_cli/common/query_stats.h
index f2aa214e18..240f984d9d 100644
--- a/ydb/public/lib/ydb_cli/common/query_stats.h
+++ b/ydb/public/lib/ydb_cli/common/query_stats.h
@@ -1,12 +1,12 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.h>
-
-namespace NYdb {
-namespace NConsoleClient {
-
-NTable::ECollectQueryStatsMode ParseQueryStatsMode(const TString& statsMode,
-    NTable::ECollectQueryStatsMode defaultMode);
-
-} // namespace NConsoleClient
-} // namespace NYdb
+ 
+namespace NYdb { 
+namespace NConsoleClient { 
+ 
+NTable::ECollectQueryStatsMode ParseQueryStatsMode(const TString& statsMode, 
+    NTable::ECollectQueryStatsMode defaultMode); 
+ 
+} // namespace NConsoleClient 
+} // namespace NYdb 
diff --git a/ydb/public/lib/ydb_cli/common/ya.make b/ydb/public/lib/ydb_cli/common/ya.make
index 35523bfb4c..466267469a 100644
--- a/ydb/public/lib/ydb_cli/common/ya.make
+++ b/ydb/public/lib/ydb_cli/common/ya.make
@@ -15,7 +15,7 @@ SRCS(
     print_operation.cpp
     print_utils.cpp
     profile_manager.cpp
-    query_stats.cpp
+    query_stats.cpp 
     recursive_list.cpp
     root.cpp
     tabbed_table.cpp
diff --git a/ydb/public/lib/yson_value/ya.make b/ydb/public/lib/yson_value/ya.make
index 21ab4f98d0..cc53bc2385 100644
--- a/ydb/public/lib/yson_value/ya.make
+++ b/ydb/public/lib/yson_value/ya.make
@@ -1,16 +1,16 @@
-LIBRARY()
-
-OWNER(g:kikimr)
-
-SRCS(
-    ydb_yson_value.cpp
-)
-
-PEERDIR(
+LIBRARY() 
+ 
+OWNER(g:kikimr) 
+ 
+SRCS( 
+    ydb_yson_value.cpp 
+) 
+ 
+PEERDIR( 
     library/cpp/yson
     library/cpp/yson/node
     ydb/public/sdk/cpp/client/ydb_result
     ydb/public/sdk/cpp/client/ydb_value
-)
-
-END()
+) 
+ 
+END() 
diff --git a/ydb/public/lib/yson_value/ydb_yson_value.cpp b/ydb/public/lib/yson_value/ydb_yson_value.cpp
index c855acf0a7..6b23a7ca94 100644
--- a/ydb/public/lib/yson_value/ydb_yson_value.cpp
+++ b/ydb/public/lib/yson_value/ydb_yson_value.cpp
@@ -1,233 +1,233 @@
-#include "ydb_yson_value.h"
-
+#include "ydb_yson_value.h" 
+ 
 #include <ydb/public/sdk/cpp/client/ydb_value/value.h>
 #include <ydb/public/sdk/cpp/client/ydb_result/result.h>
-
-#include <util/string/builder.h>
-
-namespace NYdb {
-
+ 
+#include <util/string/builder.h> 
+ 
+namespace NYdb { 
+ 
 static void PrimitiveValueToYson(EPrimitiveType type, TValueParser& parser, NYson::TYsonWriter& writer)
-{
-    switch (type) {
-        case EPrimitiveType::Bool:
-            writer.OnBooleanScalar(parser.GetBool());
-            break;
-        case EPrimitiveType::Int8:
-            writer.OnInt64Scalar(parser.GetInt8());
-            break;
-        case EPrimitiveType::Uint8:
-            writer.OnUint64Scalar(parser.GetUint8());
-            break;
-        case EPrimitiveType::Int16:
-            writer.OnInt64Scalar(parser.GetInt16());
-            break;
-        case EPrimitiveType::Uint16:
-            writer.OnUint64Scalar(parser.GetUint16());
-            break;
-        case EPrimitiveType::Int32:
-            writer.OnInt64Scalar(parser.GetInt32());
-            break;
-        case EPrimitiveType::Uint32:
-            writer.OnUint64Scalar(parser.GetUint32());
-            break;
-        case EPrimitiveType::Int64:
-            writer.OnInt64Scalar(parser.GetInt64());
-            break;
-        case EPrimitiveType::Uint64:
-            writer.OnUint64Scalar(parser.GetUint64());
-            break;
-        case EPrimitiveType::Float:
-            writer.OnDoubleScalar(parser.GetFloat());
-            break;
-        case EPrimitiveType::Double:
-            writer.OnDoubleScalar(parser.GetDouble());
-            break;
-        case EPrimitiveType::Date:
-            writer.OnUint64Scalar(parser.GetDate().Days());
-            break;
-        case EPrimitiveType::Datetime:
-            writer.OnUint64Scalar(parser.GetDatetime().Seconds());
-            break;
-        case EPrimitiveType::Timestamp:
-            writer.OnUint64Scalar(parser.GetTimestamp().MicroSeconds());
-            break;
-        case EPrimitiveType::Interval:
-            writer.OnInt64Scalar(parser.GetInterval());
-            break;
-        case EPrimitiveType::TzDate:
-            writer.OnStringScalar(parser.GetTzDate());
-            break;
-        case EPrimitiveType::TzDatetime:
-            writer.OnStringScalar(parser.GetTzDatetime());
-            break;
-        case EPrimitiveType::TzTimestamp:
-            writer.OnStringScalar(parser.GetTzTimestamp());
-            break;
-        case EPrimitiveType::String:
-            writer.OnStringScalar(parser.GetString());
-            break;
-        case EPrimitiveType::Utf8:
-            writer.OnStringScalar(parser.GetUtf8());
-            break;
-        case EPrimitiveType::Yson:
-            writer.OnStringScalar(parser.GetYson());
-            break;
-        case EPrimitiveType::Json:
-            writer.OnStringScalar(parser.GetJson());
-            break;
+{ 
+    switch (type) { 
+        case EPrimitiveType::Bool: 
+            writer.OnBooleanScalar(parser.GetBool()); 
+            break; 
+        case EPrimitiveType::Int8: 
+            writer.OnInt64Scalar(parser.GetInt8()); 
+            break; 
+        case EPrimitiveType::Uint8: 
+            writer.OnUint64Scalar(parser.GetUint8()); 
+            break; 
+        case EPrimitiveType::Int16: 
+            writer.OnInt64Scalar(parser.GetInt16()); 
+            break; 
+        case EPrimitiveType::Uint16: 
+            writer.OnUint64Scalar(parser.GetUint16()); 
+            break; 
+        case EPrimitiveType::Int32: 
+            writer.OnInt64Scalar(parser.GetInt32()); 
+            break; 
+        case EPrimitiveType::Uint32: 
+            writer.OnUint64Scalar(parser.GetUint32()); 
+            break; 
+        case EPrimitiveType::Int64: 
+            writer.OnInt64Scalar(parser.GetInt64()); 
+            break; 
+        case EPrimitiveType::Uint64: 
+            writer.OnUint64Scalar(parser.GetUint64()); 
+            break; 
+        case EPrimitiveType::Float: 
+            writer.OnDoubleScalar(parser.GetFloat()); 
+            break; 
+        case EPrimitiveType::Double: 
+            writer.OnDoubleScalar(parser.GetDouble()); 
+            break; 
+        case EPrimitiveType::Date: 
+            writer.OnUint64Scalar(parser.GetDate().Days()); 
+            break; 
+        case EPrimitiveType::Datetime: 
+            writer.OnUint64Scalar(parser.GetDatetime().Seconds()); 
+            break; 
+        case EPrimitiveType::Timestamp: 
+            writer.OnUint64Scalar(parser.GetTimestamp().MicroSeconds()); 
+            break; 
+        case EPrimitiveType::Interval: 
+            writer.OnInt64Scalar(parser.GetInterval()); 
+            break; 
+        case EPrimitiveType::TzDate: 
+            writer.OnStringScalar(parser.GetTzDate()); 
+            break; 
+        case EPrimitiveType::TzDatetime: 
+            writer.OnStringScalar(parser.GetTzDatetime()); 
+            break; 
+        case EPrimitiveType::TzTimestamp: 
+            writer.OnStringScalar(parser.GetTzTimestamp()); 
+            break; 
+        case EPrimitiveType::String: 
+            writer.OnStringScalar(parser.GetString()); 
+            break; 
+        case EPrimitiveType::Utf8: 
+            writer.OnStringScalar(parser.GetUtf8()); 
+            break; 
+        case EPrimitiveType::Yson: 
+            writer.OnStringScalar(parser.GetYson()); 
+            break; 
+        case EPrimitiveType::Json: 
+            writer.OnStringScalar(parser.GetJson()); 
+            break; 
         case EPrimitiveType::JsonDocument:
             writer.OnStringScalar(parser.GetJsonDocument());
             break;
         case EPrimitiveType::DyNumber:
             writer.OnStringScalar(parser.GetDyNumber());
             break;
-        default:
+        default: 
             ThrowFatalError(TStringBuilder() << "Unsupported primitive type: " << type);
-    }
-}
-
+    } 
+} 
+ 
 static void FormatValueYsonInternal(TValueParser& parser, NYson::TYsonWriter& writer)
-{
-    switch (parser.GetKind()) {
-        case TTypeParser::ETypeKind::Primitive:
+{ 
+    switch (parser.GetKind()) { 
+        case TTypeParser::ETypeKind::Primitive: 
             PrimitiveValueToYson(parser.GetPrimitiveType(), parser, writer);
-            break;
-
+            break; 
+ 
         case TTypeParser::ETypeKind::Decimal:
             writer.OnStringScalar(parser.GetDecimal().ToString());
             break;
 
-        case TTypeParser::ETypeKind::Optional:
-            parser.OpenOptional();
-            if (parser.IsNull()) {
-                writer.OnEntity();
-            } else {
-                writer.OnBeginList();
-                writer.OnListItem();
+        case TTypeParser::ETypeKind::Optional: 
+            parser.OpenOptional(); 
+            if (parser.IsNull()) { 
+                writer.OnEntity(); 
+            } else { 
+                writer.OnBeginList(); 
+                writer.OnListItem(); 
                 FormatValueYsonInternal(parser, writer);
-                writer.OnEndList();
-            }
-            parser.CloseOptional();
-            break;
-
-        case TTypeParser::ETypeKind::List:
-            parser.OpenList();
-            writer.OnBeginList();
-
-            while (parser.TryNextListItem()) {
-                writer.OnListItem();
+                writer.OnEndList(); 
+            } 
+            parser.CloseOptional(); 
+            break; 
+ 
+        case TTypeParser::ETypeKind::List: 
+            parser.OpenList(); 
+            writer.OnBeginList(); 
+ 
+            while (parser.TryNextListItem()) { 
+                writer.OnListItem(); 
                 FormatValueYsonInternal(parser, writer);
-            }
-
-            writer.OnEndList();
-            parser.CloseList();
-            break;
-
-        case TTypeParser::ETypeKind::Struct:
-            parser.OpenStruct();
-            writer.OnBeginList();
-
-            while (parser.TryNextMember()) {
-                writer.OnListItem();
+            } 
+ 
+            writer.OnEndList(); 
+            parser.CloseList(); 
+            break; 
+ 
+        case TTypeParser::ETypeKind::Struct: 
+            parser.OpenStruct(); 
+            writer.OnBeginList(); 
+ 
+            while (parser.TryNextMember()) { 
+                writer.OnListItem(); 
                 FormatValueYsonInternal(parser, writer);
-            }
-
-            writer.OnEndList();
-            parser.CloseStruct();
-            break;
-
-        case TTypeParser::ETypeKind::Tuple:
-            parser.OpenTuple();
-            writer.OnBeginList();
-
-            while (parser.TryNextElement()) {
-                writer.OnListItem();
+            } 
+ 
+            writer.OnEndList(); 
+            parser.CloseStruct(); 
+            break; 
+ 
+        case TTypeParser::ETypeKind::Tuple: 
+            parser.OpenTuple(); 
+            writer.OnBeginList(); 
+ 
+            while (parser.TryNextElement()) { 
+                writer.OnListItem(); 
                 FormatValueYsonInternal(parser, writer);
-            }
-
-            writer.OnEndList();
-            parser.CloseTuple();
-            break;
-
-        case TTypeParser::ETypeKind::Dict:
-            parser.OpenDict();
-            writer.OnBeginList();
-            while (parser.TryNextDictItem()) {
-                writer.OnListItem();
-                writer.OnBeginList();
-
-                writer.OnListItem();
-                parser.DictKey();
+            } 
+ 
+            writer.OnEndList(); 
+            parser.CloseTuple(); 
+            break; 
+ 
+        case TTypeParser::ETypeKind::Dict: 
+            parser.OpenDict(); 
+            writer.OnBeginList(); 
+            while (parser.TryNextDictItem()) { 
+                writer.OnListItem(); 
+                writer.OnBeginList(); 
+ 
+                writer.OnListItem(); 
+                parser.DictKey(); 
                 FormatValueYsonInternal(parser, writer);
-
-                writer.OnListItem();
-                parser.DictPayload();
+ 
+                writer.OnListItem(); 
+                parser.DictPayload(); 
                 FormatValueYsonInternal(parser, writer);
-
-                writer.OnEndList();
-            }
-            writer.OnEndList();
-            parser.CloseDict();
-            break;
-
-        case TTypeParser::ETypeKind::Void:
-            writer.OnStringScalar("Void");
-            break;
-
+ 
+                writer.OnEndList(); 
+            } 
+            writer.OnEndList(); 
+            parser.CloseDict(); 
+            break; 
+ 
+        case TTypeParser::ETypeKind::Void: 
+            writer.OnStringScalar("Void"); 
+            break; 
+ 
         case TTypeParser::ETypeKind::Null:
             writer.OnEntity();
             break;
 
-        default:
+        default: 
             ThrowFatalError(TStringBuilder() << "Unsupported type kind: " << parser.GetKind());
-    }
-}
-
+    } 
+} 
+ 
 void FormatValueYson(const TValue& value, NYson::TYsonWriter& writer)
-{
-    TValueParser parser(value);
+{ 
+    TValueParser parser(value); 
     FormatValueYsonInternal(parser, writer);
-}
-
+} 
+ 
 TString FormatValueYson(const TValue& value, NYson::EYsonFormat ysonFormat)
-{
-    TStringStream out;
+{ 
+    TStringStream out; 
     NYson::TYsonWriter writer(&out, ysonFormat, ::NYson::EYsonType::Node, true);
-
+ 
     FormatValueYson(value, writer);
-
-    return out.Str();
-}
-
+ 
+    return out.Str(); 
+} 
+ 
 void FormatResultSetYson(const TResultSet& result, NYson::TYsonWriter& writer)
-{
-    auto columns = result.GetColumnsMeta();
-
-    TResultSetParser parser(result);
-    writer.OnBeginList();
-
-    while (parser.TryNextRow()) {
-        writer.OnListItem();
-        writer.OnBeginList();
-        for (ui32 i = 0; i < columns.size(); ++i) {
-            writer.OnListItem();
+{ 
+    auto columns = result.GetColumnsMeta(); 
+ 
+    TResultSetParser parser(result); 
+    writer.OnBeginList(); 
+ 
+    while (parser.TryNextRow()) { 
+        writer.OnListItem(); 
+        writer.OnBeginList(); 
+        for (ui32 i = 0; i < columns.size(); ++i) { 
+            writer.OnListItem(); 
             FormatValueYsonInternal(parser.ColumnParser(i), writer);
-        }
-        writer.OnEndList();
-    }
-
-    writer.OnEndList();
-}
-
+        } 
+        writer.OnEndList(); 
+    } 
+ 
+    writer.OnEndList(); 
+} 
+ 
 TString FormatResultSetYson(const TResultSet& result, NYson::EYsonFormat ysonFormat)
-{
-    TStringStream out;
+{ 
+    TStringStream out; 
     NYson::TYsonWriter writer(&out, ysonFormat, ::NYson::EYsonType::Node, true);
-
+ 
     FormatResultSetYson(result, writer);
-
-    return out.Str();
-}
-
-} // namespace NYdb
+ 
+    return out.Str(); 
+} 
+ 
+} // namespace NYdb 
diff --git a/ydb/public/lib/yson_value/ydb_yson_value.h b/ydb/public/lib/yson_value/ydb_yson_value.h
index c20bdf35e7..a808cb7183 100644
--- a/ydb/public/lib/yson_value/ydb_yson_value.h
+++ b/ydb/public/lib/yson_value/ydb_yson_value.h
@@ -1,21 +1,21 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/public/sdk/cpp/client/ydb_result/result.h>
 #include <ydb/public/sdk/cpp/client/ydb_value/value.h>
 #include <ydb/public/sdk/cpp/client/ydb_types/fatal_error_handlers/handlers.h>
-
+ 
 #include <library/cpp/yson/node/node_io.h>
-
+ 
 #include <library/cpp/yson/writer.h>
-
-namespace NYdb {
-
+ 
+namespace NYdb { 
+ 
 void FormatValueYson(const TValue& value, NYson::TYsonWriter& writer);
-
+ 
 TString FormatValueYson(const TValue& value, NYson::EYsonFormat ysonFormat = NYson::EYsonFormat::Text);
-
+ 
 void FormatResultSetYson(const TResultSet& result, NYson::TYsonWriter& writer);
-
+ 
 TString FormatResultSetYson(const TResultSet& result, NYson::EYsonFormat ysonFormat = NYson::EYsonFormat::Text);
-
-} // namespace NYdb
+ 
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/draft/ydb_scripting.cpp b/ydb/public/sdk/cpp/client/draft/ydb_scripting.cpp
index 38b8c8123d..4b30284077 100644
--- a/ydb/public/sdk/cpp/client/draft/ydb_scripting.cpp
+++ b/ydb/public/sdk/cpp/client/draft/ydb_scripting.cpp
@@ -14,32 +14,32 @@ namespace NScripting {
 
 using namespace NThreading;
 
-TExecuteYqlResult::TExecuteYqlResult(TStatus&& status, TVector<TResultSet>&& resultSets,
-    const TMaybe<NTable::TQueryStats>& queryStats)
-    : TStatus(std::move(status))
-    , ResultSets_(std::move(resultSets))
-    , QueryStats_(queryStats) {}
-
-const TVector<TResultSet>& TExecuteYqlResult::GetResultSets() const {
-    return ResultSets_;
-}
-
-TResultSet TExecuteYqlResult::GetResultSet(size_t resultIndex) const {
-    if (resultIndex >= ResultSets_.size()) {
-        RaiseError(TString("Requested index out of range\n"));
-    }
-
-    return ResultSets_[resultIndex];
-}
-
-TResultSetParser TExecuteYqlResult::GetResultSetParser(size_t resultIndex) const {
-    return TResultSetParser(GetResultSet(resultIndex));
-}
-
-const TMaybe<NTable::TQueryStats>& TExecuteYqlResult::GetStats() const {
-    return QueryStats_;
-}
-
+TExecuteYqlResult::TExecuteYqlResult(TStatus&& status, TVector<TResultSet>&& resultSets, 
+    const TMaybe<NTable::TQueryStats>& queryStats) 
+    : TStatus(std::move(status)) 
+    , ResultSets_(std::move(resultSets)) 
+    , QueryStats_(queryStats) {} 
+ 
+const TVector<TResultSet>& TExecuteYqlResult::GetResultSets() const { 
+    return ResultSets_; 
+} 
+ 
+TResultSet TExecuteYqlResult::GetResultSet(size_t resultIndex) const { 
+    if (resultIndex >= ResultSets_.size()) { 
+        RaiseError(TString("Requested index out of range\n")); 
+    } 
+ 
+    return ResultSets_[resultIndex]; 
+} 
+ 
+TResultSetParser TExecuteYqlResult::GetResultSetParser(size_t resultIndex) const { 
+    return TResultSetParser(GetResultSet(resultIndex)); 
+} 
+ 
+const TMaybe<NTable::TQueryStats>& TExecuteYqlResult::GetStats() const { 
+    return QueryStats_; 
+} 
+ 
 ////////////////////////////////////////////////////////////////////////////////
 
 class TYqlResultPartIterator::TReaderImpl {
@@ -150,20 +150,20 @@ public:
         : TClientImplCommon(std::move(connections), settings) {}
 
     template<typename TParamsType>
-    TAsyncExecuteYqlResult ExecuteYqlScript(const TString& script, TParamsType params,
-        const TExecuteYqlRequestSettings& settings)
-    {
+    TAsyncExecuteYqlResult ExecuteYqlScript(const TString& script, TParamsType params, 
+        const TExecuteYqlRequestSettings& settings) 
+    { 
         auto request = MakeOperationRequest<Ydb::Scripting::ExecuteYqlRequest>(settings);
         request.set_script(script);
         SetParams(params, &request);
-        request.set_collect_stats(GetStatsCollectionMode(settings.CollectQueryStats_));
+        request.set_collect_stats(GetStatsCollectionMode(settings.CollectQueryStats_)); 
 
-        auto promise = NewPromise<TExecuteYqlResult>();
+        auto promise = NewPromise<TExecuteYqlResult>(); 
 
         auto extractor = [promise]
             (google::protobuf::Any* any, TPlainStatus status) mutable {
                 TVector<TResultSet> res;
-                TMaybe<NTable::TQueryStats> queryStats;
+                TMaybe<NTable::TQueryStats> queryStats; 
                 if (any) {
                     Ydb::Scripting::ExecuteYqlResult result;
                     any->UnpackTo(&result);
@@ -171,26 +171,26 @@ public:
                     for (size_t i = 0; i < result.result_setsSize(); i++) {
                         res.push_back(TResultSet(*result.mutable_result_sets(i)));
                     }
-
-                    if (result.has_query_stats()) {
-                        queryStats = NTable::TQueryStats(result.query_stats());
-                    }
+ 
+                    if (result.has_query_stats()) { 
+                        queryStats = NTable::TQueryStats(result.query_stats()); 
+                    } 
                 }
 
                 TExecuteYqlResult executeResult(TStatus(std::move(status)), std::move(res),
-                    queryStats);
-                promise.SetValue(std::move(executeResult));
+                    queryStats); 
+                promise.SetValue(std::move(executeResult)); 
             };
 
-        Connections_->RunDeferred<Ydb::Scripting::V1::ScriptingService, Ydb::Scripting::ExecuteYqlRequest,
-            Ydb::Scripting::ExecuteYqlResponse>(
-                std::move(request),
-                extractor,
-                &Ydb::Scripting::V1::ScriptingService::Stub::AsyncExecuteYql,
-                DbDriverState_,
+        Connections_->RunDeferred<Ydb::Scripting::V1::ScriptingService, Ydb::Scripting::ExecuteYqlRequest, 
+            Ydb::Scripting::ExecuteYqlResponse>( 
+                std::move(request), 
+                extractor, 
+                &Ydb::Scripting::V1::ScriptingService::Stub::AsyncExecuteYql, 
+                DbDriverState_, 
                 INITIAL_DEFERRED_CALL_DELAY,
-                TRpcRequestSettings::Make(settings),
-                settings.ClientTimeout_);
+                TRpcRequestSettings::Make(settings), 
+                settings.ClientTimeout_); 
 
         return promise.GetFuture();
     }
@@ -315,28 +315,28 @@ TScriptingClient::TScriptingClient(const TDriver& driver, const TCommonClientSet
     : Impl_(new TImpl(CreateInternalInterface(driver), settings))
 {}
 
-TParamsBuilder TScriptingClient::GetParamsBuilder() {
+TParamsBuilder TScriptingClient::GetParamsBuilder() { 
     return TParamsBuilder();
-}
-
-TAsyncExecuteYqlResult TScriptingClient::ExecuteYqlScript(const TString &query, NYdb::TParams&& params,
-    const TExecuteYqlRequestSettings &settings)
-{
+} 
+ 
+TAsyncExecuteYqlResult TScriptingClient::ExecuteYqlScript(const TString &query, NYdb::TParams&& params, 
+    const TExecuteYqlRequestSettings &settings) 
+{ 
     auto paramsPtr = params.Empty() ? nullptr : params.GetProtoMapPtr();
-    return Impl_->ExecuteYqlScript(query, paramsPtr, settings);
+    return Impl_->ExecuteYqlScript(query, paramsPtr, settings); 
 }
 
-TAsyncExecuteYqlResult TScriptingClient::ExecuteYqlScript(const TString &query, const NYdb::TParams& params,
-    const TExecuteYqlRequestSettings &settings)
-{
+TAsyncExecuteYqlResult TScriptingClient::ExecuteYqlScript(const TString &query, const NYdb::TParams& params, 
+    const TExecuteYqlRequestSettings &settings) 
+{ 
     if (params.Empty()) {
-        return Impl_->ExecuteYqlScript(
+        return Impl_->ExecuteYqlScript( 
             query,
             nullptr,
             settings);
     } else {
         using TProtoParamsType = const ::google::protobuf::Map<TString, Ydb::TypedValue>;
-        return Impl_->ExecuteYqlScript<TProtoParamsType&>(
+        return Impl_->ExecuteYqlScript<TProtoParamsType&>( 
             query,
             params.GetProtoMap(),
             settings);
@@ -344,8 +344,8 @@ TAsyncExecuteYqlResult TScriptingClient::ExecuteYqlScript(const TString &query,
 }
 
 TAsyncExecuteYqlResult TScriptingClient::ExecuteYqlScript(const TString &script,
-    const TExecuteYqlRequestSettings &settings)
-{
+    const TExecuteYqlRequestSettings &settings) 
+{ 
     return Impl_->ExecuteYqlScript(script, nullptr, settings);
 }
 
diff --git a/ydb/public/sdk/cpp/client/draft/ydb_scripting.h b/ydb/public/sdk/cpp/client/draft/ydb_scripting.h
index e99f05daa2..7e399f818f 100644
--- a/ydb/public/sdk/cpp/client/draft/ydb_scripting.h
+++ b/ydb/public/sdk/cpp/client/draft/ydb_scripting.h
@@ -6,23 +6,23 @@
 namespace NYdb {
 namespace NScripting {
 
-class TExecuteYqlResult : public TStatus {
-public:
-    TExecuteYqlResult(TStatus&& status, TVector<TResultSet>&& resultSets,
-        const TMaybe<NTable::TQueryStats>& queryStats);
-
-    const TVector<TResultSet>& GetResultSets() const;
-    TResultSet GetResultSet(size_t resultIndex) const;
-
-    TResultSetParser GetResultSetParser(size_t resultIndex) const;
-
-    const TMaybe<NTable::TQueryStats>& GetStats() const;
-
-private:
-    TVector<TResultSet> ResultSets_;
-    TMaybe<NTable::TQueryStats> QueryStats_;
-};
-
+class TExecuteYqlResult : public TStatus { 
+public: 
+    TExecuteYqlResult(TStatus&& status, TVector<TResultSet>&& resultSets, 
+        const TMaybe<NTable::TQueryStats>& queryStats); 
+
+    const TVector<TResultSet>& GetResultSets() const; 
+    TResultSet GetResultSet(size_t resultIndex) const; 
+ 
+    TResultSetParser GetResultSetParser(size_t resultIndex) const; 
+ 
+    const TMaybe<NTable::TQueryStats>& GetStats() const; 
+ 
+private: 
+    TVector<TResultSet> ResultSets_; 
+    TMaybe<NTable::TQueryStats> QueryStats_; 
+}; 
+ 
 class TYqlPartialResult {
 public:
     TYqlPartialResult(ui32 resultSetIndex, TResultSet&& resultSet)
@@ -94,15 +94,15 @@ private:
     TString Plan_;
 };
 
-using TAsyncExecuteYqlResult = NThreading::TFuture<TExecuteYqlResult>;
+using TAsyncExecuteYqlResult = NThreading::TFuture<TExecuteYqlResult>; 
 using TAsyncYqlResultPartIterator = NThreading::TFuture<TYqlResultPartIterator>;
 using TAsyncExplainYqlResult = NThreading::TFuture<TExplainYqlResult>;
-
+ 
 ////////////////////////////////////////////////////////////////////////////////
 
-struct TExecuteYqlRequestSettings : public TOperationRequestSettings<TExecuteYqlRequestSettings> {
+struct TExecuteYqlRequestSettings : public TOperationRequestSettings<TExecuteYqlRequestSettings> { 
     FLUENT_SETTING_DEFAULT(NTable::ECollectQueryStatsMode, CollectQueryStats, NTable::ECollectQueryStatsMode::None);
-};
+}; 
 
 enum class ExplainYqlRequestMode {
     // Parse = 1,
@@ -122,17 +122,17 @@ class TScriptingClient {
 public:
     TScriptingClient(const TDriver& driver, const TCommonClientSettings& settings = TCommonClientSettings());
 
-    //! Returns new params builder
-    TParamsBuilder GetParamsBuilder();
+    //! Returns new params builder 
+    TParamsBuilder GetParamsBuilder(); 
+ 
+    TAsyncExecuteYqlResult ExecuteYqlScript(const TString& script, 
+        const TExecuteYqlRequestSettings& settings = TExecuteYqlRequestSettings()); 
 
-    TAsyncExecuteYqlResult ExecuteYqlScript(const TString& script,
-        const TExecuteYqlRequestSettings& settings = TExecuteYqlRequestSettings());
+    TAsyncExecuteYqlResult ExecuteYqlScript(const TString& script, const TParams& params, 
+        const TExecuteYqlRequestSettings& settings = TExecuteYqlRequestSettings()); 
 
-    TAsyncExecuteYqlResult ExecuteYqlScript(const TString& script, const TParams& params,
-        const TExecuteYqlRequestSettings& settings = TExecuteYqlRequestSettings());
-
-    TAsyncExecuteYqlResult ExecuteYqlScript(const TString& script, TParams&& params,
-        const TExecuteYqlRequestSettings& settings = TExecuteYqlRequestSettings());
+    TAsyncExecuteYqlResult ExecuteYqlScript(const TString& script, TParams&& params, 
+        const TExecuteYqlRequestSettings& settings = TExecuteYqlRequestSettings()); 
 
     TAsyncYqlResultPartIterator StreamExecuteYqlScript(const TString& script,
         const TExecuteYqlRequestSettings& settings = TExecuteYqlRequestSettings());
diff --git a/ydb/public/sdk/cpp/client/resources/ydb_resources.cpp b/ydb/public/sdk/cpp/client/resources/ydb_resources.cpp
index 079e8a59a2..06855507bb 100644
--- a/ydb/public/sdk/cpp/client/resources/ydb_resources.cpp
+++ b/ydb/public/sdk/cpp/client/resources/ydb_resources.cpp
@@ -8,8 +8,8 @@ const char* YDB_AUTH_TICKET_HEADER = "x-ydb-auth-ticket";
 const char* YDB_DATABASE_HEADER = "x-ydb-database";
 const char* YDB_TRACE_ID_HEADER = "x-ydb-trace-id";
 const char* YDB_SDK_BUILD_INFO_HEADER = "x-ydb-sdk-build-info";
-const char* YDB_REQUEST_TYPE_HEADER = "x-ydb-request-type";
-const char* YDB_CONSUMED_UNITS_HEADER = "x-ydb-consumed-units";
+const char* YDB_REQUEST_TYPE_HEADER = "x-ydb-request-type"; 
+const char* YDB_CONSUMED_UNITS_HEADER = "x-ydb-consumed-units"; 
 
 // The x-ydb-server-hints header.
 // This header can be sent in the trailing metadata with response.
diff --git a/ydb/public/sdk/cpp/client/resources/ydb_resources.h b/ydb/public/sdk/cpp/client/resources/ydb_resources.h
index 61dee0d2f4..325727a3b5 100644
--- a/ydb/public/sdk/cpp/client/resources/ydb_resources.h
+++ b/ydb/public/sdk/cpp/client/resources/ydb_resources.h
@@ -8,8 +8,8 @@ extern const char* YDB_AUTH_TICKET_HEADER;
 extern const char* YDB_DATABASE_HEADER;
 extern const char* YDB_TRACE_ID_HEADER;
 extern const char* YDB_SDK_BUILD_INFO_HEADER;
-extern const char* YDB_REQUEST_TYPE_HEADER;
-extern const char* YDB_CONSUMED_UNITS_HEADER;
+extern const char* YDB_REQUEST_TYPE_HEADER; 
+extern const char* YDB_CONSUMED_UNITS_HEADER; 
 extern const char* YDB_SERVER_HINTS;
 extern const char* YDB_CLIENT_CAPABILITIES;
 extern const char* YDB_SESSION_CLOSE;
diff --git a/ydb/public/sdk/cpp/client/ydb_common_client/impl/client.h b/ydb/public/sdk/cpp/client/ydb_common_client/impl/client.h
index c43e9aab69..e97f0fbe02 100644
--- a/ydb/public/sdk/cpp/client/ydb_common_client/impl/client.h
+++ b/ydb/public/sdk/cpp/client/ydb_common_client/impl/client.h
@@ -8,11 +8,11 @@
 
 #include <memory>
 
-namespace NYdb {
+namespace NYdb { 
 
 template<typename T>
 class TClientImplCommon : public std::enable_shared_from_this<T> {
-public:
+public: 
     TClientImplCommon(
         std::shared_ptr<TGRpcConnectionsImpl>&& connections,
         const TMaybe<TString>& database,
@@ -25,7 +25,7 @@ public:
     {
         Y_VERIFY(DbDriverState_);
     }
-
+ 
     TClientImplCommon(
         std::shared_ptr<TGRpcConnectionsImpl>&& connections,
         const TCommonClientSettings& settings)
@@ -43,47 +43,47 @@ public:
         Y_VERIFY(DbDriverState_);
     }
 
-protected:
-    template<typename TService, typename TRequest, typename TResponse>
+protected: 
+    template<typename TService, typename TRequest, typename TResponse> 
     using TAsyncRequest = typename NGrpc::TSimpleRequestProcessor<
-        typename TService::Stub,
-        TRequest,
-        TResponse>::TAsyncRequest;
-
-    template<typename TService, typename TRequest, typename TResponse>
-    NThreading::TFuture<TStatus> RunSimple(
+        typename TService::Stub, 
+        TRequest, 
+        TResponse>::TAsyncRequest; 
+ 
+    template<typename TService, typename TRequest, typename TResponse> 
+    NThreading::TFuture<TStatus> RunSimple( 
         TRequest&& request,
-        TAsyncRequest<TService, TRequest, TResponse> rpc,
-        const TRpcRequestSettings& requestSettings = {},
+        TAsyncRequest<TService, TRequest, TResponse> rpc, 
+        const TRpcRequestSettings& requestSettings = {}, 
         TDuration timeout = TDuration::Zero(),
         const TString& preferredEndpoint = TString())
-    {
-        auto promise = NThreading::NewPromise<TStatus>();
-
+    { 
+        auto promise = NThreading::NewPromise<TStatus>(); 
+ 
         auto extractor = [promise]
             (google::protobuf::Any*, TPlainStatus status) mutable {
                 TStatus st(std::move(status));
-                promise.SetValue(std::move(st));
-            };
-
+                promise.SetValue(std::move(st)); 
+            }; 
+ 
         Connections_->RunDeferred<TService, TRequest, TResponse>(
             std::move(request),
-            extractor,
-            rpc,
+            extractor, 
+            rpc, 
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            requestSettings,
+            requestSettings, 
             timeout,
             preferredEndpoint);
-
-        return promise.GetFuture();
-    }
-
+ 
+        return promise.GetFuture(); 
+    } 
+ 
     template<typename TService, typename TRequest, typename TResponse, typename TOp>
     NThreading::TFuture<TOp> RunOperation(
         TRequest&& request,
         TAsyncRequest<TService, TRequest, TResponse> rpc,
-        const TRpcRequestSettings& requestSettings = {},
+        const TRpcRequestSettings& requestSettings = {}, 
         TDuration timeout = TDuration::Zero())
     {
         auto promise = NThreading::NewPromise<TOp>();
@@ -104,15 +104,15 @@ protected:
             rpc,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            requestSettings,
+            requestSettings, 
             timeout);
 
         return promise.GetFuture();
     }
 
-protected:
-    std::shared_ptr<TGRpcConnectionsImpl> Connections_;
+protected: 
+    std::shared_ptr<TGRpcConnectionsImpl> Connections_; 
     TDbDriverStatePtr DbDriverState_;
-};
-
-} // namespace NYdb
+}; 
+ 
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_coordination/coordination.cpp b/ydb/public/sdk/cpp/client/ydb_coordination/coordination.cpp
index 7a99c95214..c30973e789 100644
--- a/ydb/public/sdk/cpp/client/ydb_coordination/coordination.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_coordination/coordination.cpp
@@ -640,7 +640,7 @@ private:
             },
             &TService::Stub::AsyncSession,
             DbDriverState_,
-            TRpcRequestSettings::Make(Settings_),
+            TRpcRequestSettings::Make(Settings_), 
             std::move(connectContext));
 
         if (connectTimeoutContext) {
@@ -1812,46 +1812,46 @@ public:
 
     TAsyncStatus CreateNode(
         Ydb::Coordination::CreateNodeRequest&& request,
-        const TCreateNodeSettings& settings)
+        const TCreateNodeSettings& settings) 
     {
         return RunSimple<Ydb::Coordination::V1::CoordinationService,
                         Ydb::Coordination::CreateNodeRequest,
                         Ydb::Coordination::CreateNodeResponse>(
             std::move(request),
-            &Ydb::Coordination::V1::CoordinationService::Stub::AsyncCreateNode,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
+            &Ydb::Coordination::V1::CoordinationService::Stub::AsyncCreateNode, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
     }
 
     TAsyncStatus AlterNode(
         Ydb::Coordination::AlterNodeRequest&& request,
-        const TAlterNodeSettings& settings)
+        const TAlterNodeSettings& settings) 
     {
         return RunSimple<Ydb::Coordination::V1::CoordinationService,
                         Ydb::Coordination::AlterNodeRequest,
                         Ydb::Coordination::AlterNodeResponse>(
             std::move(request),
-            &Ydb::Coordination::V1::CoordinationService::Stub::AsyncAlterNode,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
+            &Ydb::Coordination::V1::CoordinationService::Stub::AsyncAlterNode, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
     }
 
     TAsyncStatus DropNode(
         Ydb::Coordination::DropNodeRequest&& request,
-        const TDropNodeSettings& settings)
+        const TDropNodeSettings& settings) 
     {
         return RunSimple<Ydb::Coordination::V1::CoordinationService,
                         Ydb::Coordination::DropNodeRequest,
                         Ydb::Coordination::DropNodeResponse>(
             std::move(request),
-            &Ydb::Coordination::V1::CoordinationService::Stub::AsyncDropNode,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
+            &Ydb::Coordination::V1::CoordinationService::Stub::AsyncDropNode, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
     }
 
     TAsyncDescribeNodeResult DescribeNode(
         Ydb::Coordination::DescribeNodeRequest&& request,
-        const TDescribeNodeSettings& settings)
+        const TDescribeNodeSettings& settings) 
     {
         auto promise = NewPromise<TDescribeNodeResult>();
 
@@ -1875,8 +1875,8 @@ public:
             &Ydb::Coordination::V1::CoordinationService::Stub::AsyncDescribeNode,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
 
         return promise.GetFuture();
     }
@@ -1901,38 +1901,38 @@ TAsyncStatus TClient::CreateNode(
     const TString& path,
     const TCreateNodeSettings& settings)
 {
-    auto request = MakeOperationRequest<Ydb::Coordination::CreateNodeRequest>(settings);
+    auto request = MakeOperationRequest<Ydb::Coordination::CreateNodeRequest>(settings); 
     request.set_path(path);
     ConvertSettingsToProtoConfig(settings, request.mutable_config());
-    return Impl_->CreateNode(std::move(request), settings);
+    return Impl_->CreateNode(std::move(request), settings); 
 }
 
 TAsyncStatus TClient::AlterNode(
     const TString& path,
     const TAlterNodeSettings& settings)
 {
-    auto request = MakeOperationRequest<Ydb::Coordination::AlterNodeRequest>(settings);
+    auto request = MakeOperationRequest<Ydb::Coordination::AlterNodeRequest>(settings); 
     request.set_path(path);
     ConvertSettingsToProtoConfig(settings, request.mutable_config());
-    return Impl_->AlterNode(std::move(request), settings);
+    return Impl_->AlterNode(std::move(request), settings); 
 }
 
 TAsyncStatus TClient::DropNode(
     const TString& path,
     const TDropNodeSettings& settings)
 {
-    auto request = MakeOperationRequest<Ydb::Coordination::DropNodeRequest>(settings);
+    auto request = MakeOperationRequest<Ydb::Coordination::DropNodeRequest>(settings); 
     request.set_path(path);
-    return Impl_->DropNode(std::move(request), settings);
+    return Impl_->DropNode(std::move(request), settings); 
 }
 
 TAsyncDescribeNodeResult TClient::DescribeNode(
     const TString& path,
     const TDescribeNodeSettings& settings)
 {
-    auto request = MakeOperationRequest<Ydb::Coordination::DescribeNodeRequest>(settings);
+    auto request = MakeOperationRequest<Ydb::Coordination::DescribeNodeRequest>(settings); 
     request.set_path(path);
-    return Impl_->DescribeNode(std::move(request), settings);
+    return Impl_->DescribeNode(std::move(request), settings); 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/ydb/public/sdk/cpp/client/ydb_coordination/coordination.h b/ydb/public/sdk/cpp/client/ydb_coordination/coordination.h
index fa8ab572d0..e6a9bd7dd2 100644
--- a/ydb/public/sdk/cpp/client/ydb_coordination/coordination.h
+++ b/ydb/public/sdk/cpp/client/ydb_coordination/coordination.h
@@ -176,7 +176,7 @@ using TAsyncDescribeSemaphoreResult = NThreading::TFuture<TDescribeSemaphoreResu
 ////////////////////////////////////////////////////////////////////////////////
 
 template<class TDerived>
-struct TNodeSettings : public TOperationRequestSettings<TDerived> {
+struct TNodeSettings : public TOperationRequestSettings<TDerived> { 
     using TSelf = TDerived;
 
     FLUENT_SETTING_OPTIONAL(TDuration, SelfCheckPeriod);
@@ -192,8 +192,8 @@ struct TNodeSettings : public TOperationRequestSettings<TDerived> {
 
 struct TCreateNodeSettings : public TNodeSettings<TCreateNodeSettings> { };
 struct TAlterNodeSettings : public TNodeSettings<TAlterNodeSettings> { };
-struct TDropNodeSettings : public TOperationRequestSettings<TDropNodeSettings> { };
-struct TDescribeNodeSettings : public TOperationRequestSettings<TDescribeNodeSettings> { };
+struct TDropNodeSettings : public TOperationRequestSettings<TDropNodeSettings> { }; 
+struct TDescribeNodeSettings : public TOperationRequestSettings<TDescribeNodeSettings> { }; 
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/ydb/public/sdk/cpp/client/ydb_discovery/discovery.cpp b/ydb/public/sdk/cpp/client/ydb_discovery/discovery.cpp
index 6957a558ec..b5938152a7 100644
--- a/ydb/public/sdk/cpp/client/ydb_discovery/discovery.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_discovery/discovery.cpp
@@ -84,7 +84,7 @@ public:
             &Ydb::Discovery::V1::DiscoveryService::Stub::AsyncListEndpoints,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_);
 
         return promise.GetFuture();
@@ -114,7 +114,7 @@ public:
             &Ydb::Discovery::V1::DiscoveryService::Stub::AsyncWhoAmI,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_);
 
         return promise.GetFuture();
diff --git a/ydb/public/sdk/cpp/client/ydb_driver/driver.cpp b/ydb/public/sdk/cpp/client/ydb_driver/driver.cpp
index de17c6e679..4e8ac9fbd7 100644
--- a/ydb/public/sdk/cpp/client/ydb_driver/driver.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_driver/driver.cpp
@@ -12,7 +12,7 @@
 #include <util/stream/file.h>
 #include <ydb/public/sdk/cpp/client/resources/ydb_ca.h>
 
-namespace NYdb {
+namespace NYdb { 
 
 using NGrpc::TGRpcClientLow;
 using NGrpc::TServiceConnection;
@@ -22,11 +22,11 @@ using NGrpc::TResponseCallback;
 using NGrpc::TGrpcStatus;
 using NGrpc::TTcpKeepAliveSettings;
 
-using Ydb::StatusIds;
+using Ydb::StatusIds; 
 
 using namespace NThreading;
 
-class TDriverConfig::TImpl : public IConnectionsParams {
+class TDriverConfig::TImpl : public IConnectionsParams { 
 public:
     TStringType GetEndpoint() const override { return Endpoint; }
     size_t GetNetworkThreadsNum() const override { return NetworkThreadsNum; }
@@ -88,12 +88,12 @@ TDriverConfig& TDriverConfig::SetEndpoint(const TStringType& endpoint) {
     return *this;
 }
 
-TDriverConfig& TDriverConfig::SetNetworkThreadsNum(size_t sz) {
+TDriverConfig& TDriverConfig::SetNetworkThreadsNum(size_t sz) { 
     Impl_->NetworkThreadsNum = sz;
     return *this;
 }
 
-TDriverConfig& TDriverConfig::SetClientThreadsNum(size_t sz) {
+TDriverConfig& TDriverConfig::SetClientThreadsNum(size_t sz) { 
     Impl_->ClientThreadsNum = sz;
     return *this;
 }
@@ -124,12 +124,12 @@ TDriverConfig& TDriverConfig::SetCredentialsProviderFactory(std::shared_ptr<ICre
     return *this;
 }
 
-TDriverConfig& TDriverConfig::SetDiscoveryMode(EDiscoveryMode discoveryMode) {
+TDriverConfig& TDriverConfig::SetDiscoveryMode(EDiscoveryMode discoveryMode) { 
     Impl_->DiscoveryMode = discoveryMode;
     return *this;
 }
 
-TDriverConfig& TDriverConfig::SetMaxQueuedRequests(size_t sz) {
+TDriverConfig& TDriverConfig::SetMaxQueuedRequests(size_t sz) { 
     Impl_->MaxQueuedRequests = sz;
     return *this;
 }
@@ -185,16 +185,16 @@ std::shared_ptr<TGRpcConnectionsImpl> CreateInternalInterface(const TDriver conn
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TDriver::TDriver(const TDriverConfig& config) {
-    if (!config.Impl_) {
-        ythrow yexception() << "Invalid config object";
+TDriver::TDriver(const TDriverConfig& config) { 
+    if (!config.Impl_) { 
+        ythrow yexception() << "Invalid config object"; 
     }
-
-    Impl_.reset(new TGRpcConnectionsImpl(config.Impl_));
+ 
+    Impl_.reset(new TGRpcConnectionsImpl(config.Impl_)); 
 }
 
 void TDriver::Stop(bool wait) {
     Impl_->Stop(wait);
 }
 
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_driver/driver.h b/ydb/public/sdk/cpp/client/ydb_driver/driver.h
index 39c91d8852..0053113a88 100644
--- a/ydb/public/sdk/cpp/client/ydb_driver/driver.h
+++ b/ydb/public/sdk/cpp/client/ydb_driver/driver.h
@@ -9,34 +9,34 @@
 
 #include <library/cpp/logger/backend.h>
 
-////////////////////////////////////////////////////////////////////////////////
-
-namespace NYdb {
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+namespace NYdb { 
 
 class TDriver;
 class TGRpcConnectionsImpl;
 
 ////////////////////////////////////////////////////////////////////////////////
 
-//! Represents configuration of YDB driver
-class TDriverConfig {
+//! Represents configuration of YDB driver 
+class TDriverConfig { 
     friend class TDriver;
-
+ 
 public:
     //! Connection string format: "<protocol>://<hostname:port>/?database=<database-path>",
     //! where "<protocol>://" can be "grpc://" or "grpcs://" or be absent, "<hostname:port>" is endpoint,
     //! "/?database=<database-path>" is optional
     TDriverConfig(const TStringType& connectionString = "");
-    //! Endpoint to initiate connections with Ydb cluster,
+    //! Endpoint to initiate connections with Ydb cluster, 
     //! client will connect to others nodes according to client loadbalancing
     TDriverConfig& SetEndpoint(const TStringType& endpoint);
     //! Set number of network threads, default: 2
-    TDriverConfig& SetNetworkThreadsNum(size_t sz);
+    TDriverConfig& SetNetworkThreadsNum(size_t sz); 
     //! Set number of client pool threads, if 0 adaptive thread pool will be used.
     //! NOTE: in case of no zero value it is possible to get deadlock if all threads
     //! of this pool is blocked somewhere in user code.
     //! default: 0
-    TDriverConfig& SetClientThreadsNum(size_t sz);
+    TDriverConfig& SetClientThreadsNum(size_t sz); 
     //! Warning: not recommended to change
     //! Set max number of queued responses. 0 - no limit
     //! There is a queue to perform async calls to user code,
@@ -46,7 +46,7 @@ public:
     //! Note: set of this limit can cause deadlock in some case of using async interface
     //! This value doesn't make sense if SetClientThreadsNum is 0
     //! default: 0
-    TDriverConfig& SetMaxClientQueueSize(size_t sz);
+    TDriverConfig& SetMaxClientQueueSize(size_t sz); 
     //! Enable Ssl.
     //! caCerts  - The buffer containing the PEM encoding of the server root certificates.
     //!            If this parameter is empty, the default roots will be used.
@@ -60,10 +60,10 @@ public:
     //! Set behaviour of discovery routine
     //! See EDiscoveryMode enum comments
     //! default: EDiscoveryMode::Sync
-    TDriverConfig& SetDiscoveryMode(EDiscoveryMode discoveryMode);
+    TDriverConfig& SetDiscoveryMode(EDiscoveryMode discoveryMode); 
     //! Max number of requests in queue waiting for discovery if "Async" mode chosen
     //! default: 100
-    TDriverConfig& SetMaxQueuedRequests(size_t sz);
+    TDriverConfig& SetMaxQueuedRequests(size_t sz); 
     //! Limit using of memory for grpc buffer pool. 0 means disabled.
     //! If enabled the size must be greater than size of recieved message.
     //! default: 0
@@ -116,9 +116,9 @@ private:
 //! Represents connection pool to the database
 class TDriver {
     friend std::shared_ptr<TGRpcConnectionsImpl> CreateInternalInterface(const TDriver);
-
+ 
 public:
-    TDriver(const TDriverConfig& config);
+    TDriver(const TDriverConfig& config); 
 
     //! Cancel all currently running and future requests
     //! This method is useful to make sure there are no new asynchronous
@@ -134,4 +134,4 @@ private:
     std::shared_ptr<TGRpcConnectionsImpl> Impl_;
 };
 
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_export/export.cpp b/ydb/public/sdk/cpp/client/ydb_export/export.cpp
index c391c033e1..92fa7fc1b9 100644
--- a/ydb/public/sdk/cpp/client/ydb_export/export.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_export/export.cpp
@@ -114,23 +114,23 @@ public:
     }
 
     TFuture<TExportToYtResponse> ExportToYt(ExportToYtRequest&& request,
-        const TExportToYtSettings& settings)
+        const TExportToYtSettings& settings) 
     {
         return RunOperation<V1::ExportService, ExportToYtRequest, ExportToYtResponse, TExportToYtResponse>(
             std::move(request),
             &V1::ExportService::Stub::AsyncExportToYt,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
     }
 
     TFuture<TExportToS3Response> ExportToS3(ExportToS3Request&& request,
-        const TExportToS3Settings& settings)
+        const TExportToS3Settings& settings) 
     {
         return RunOperation<V1::ExportService, ExportToS3Request, ExportToS3Response, TExportToS3Response>(
             std::move(request),
             &V1::ExportService::Stub::AsyncExportToS3,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
     }
 
 };
@@ -165,7 +165,7 @@ TFuture<TExportToYtResponse> TExportClient::ExportToYt(const TExportToYtSettings
 
     request.mutable_settings()->set_use_type_v3(settings.UseTypeV3_);
 
-    return Impl_->ExportToYt(std::move(request), settings);
+    return Impl_->ExportToYt(std::move(request), settings); 
 }
 
 TFuture<TExportToS3Response> TExportClient::ExportToS3(const TExportToS3Settings& settings) {
@@ -192,7 +192,7 @@ TFuture<TExportToS3Response> TExportClient::ExportToS3(const TExportToS3Settings
         request.mutable_settings()->set_number_of_retries(settings.NumberOfRetries_.GetRef());
     }
 
-    return Impl_->ExportToS3(std::move(request), settings);
+    return Impl_->ExportToS3(std::move(request), settings); 
 }
 
 } // namespace NExport
diff --git a/ydb/public/sdk/cpp/client/ydb_operation/operation.cpp b/ydb/public/sdk/cpp/client/ydb_operation/operation.cpp
index fac441c505..06a8645238 100644
--- a/ydb/public/sdk/cpp/client/ydb_operation/operation.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_operation/operation.cpp
@@ -48,7 +48,7 @@ class TOperationClient::TImpl : public TClientImplCommon<TOperationClient::TImpl
             extractor,
             rpc,
             DbDriverState_,
-            TRpcRequestSettings(),
+            TRpcRequestSettings(), 
             OPERATION_CLIENT_TIMEOUT,
             TString());
 
@@ -110,7 +110,7 @@ public:
             extractor,
             &V1::OperationService::Stub::AsyncListOperations,
             DbDriverState_,
-            TRpcRequestSettings(),
+            TRpcRequestSettings(), 
             OPERATION_CLIENT_TIMEOUT,
             TString());
 
diff --git a/ydb/public/sdk/cpp/client/ydb_params/params.cpp b/ydb/public/sdk/cpp/client/ydb_params/params.cpp
index a69d29b2f6..7953df6dd5 100644
--- a/ydb/public/sdk/cpp/client/ydb_params/params.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_params/params.cpp
@@ -1,18 +1,18 @@
 #include "params.h"
 #include "impl.h"
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
 #include <ydb/public/sdk/cpp/client/ydb_types/fatal_error_handlers/handlers.h>
 
-#include <util/generic/map.h>
-#include <util/string/builder.h>
+#include <util/generic/map.h> 
+#include <util/string/builder.h> 
 
-namespace NYdb {
+namespace NYdb { 
 
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////// 
 
 TParams::TParams(::google::protobuf::Map<TString, Ydb::TypedValue>&& protoMap)
-    : Impl_(new TImpl(std::move(protoMap))) {}
+    : Impl_(new TImpl(std::move(protoMap))) {} 
 
 ::google::protobuf::Map<TString, Ydb::TypedValue>* TParams::GetProtoMapPtr() {
     return Impl_->GetProtoMapPtr();
@@ -22,157 +22,157 @@ const ::google::protobuf::Map<TString, Ydb::TypedValue>& TParams::GetProtoMap()
     return Impl_->GetProtoMap();
 }
 
-bool TParams::Empty() const {
-    return Impl_->Empty();
-}
+bool TParams::Empty() const { 
+    return Impl_->Empty(); 
+} 
 
-TMap<TString, TValue> TParams::GetValues() const {
-    return Impl_->GetValues();
-}
+TMap<TString, TValue> TParams::GetValues() const { 
+    return Impl_->GetValues(); 
+} 
 
-TMaybe<TValue> TParams::GetValue(const TString& name) const {
-    return Impl_->GetValue(name);
-}
+TMaybe<TValue> TParams::GetValue(const TString& name) const { 
+    return Impl_->GetValue(name); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
 
-////////////////////////////////////////////////////////////////////////////////
-
-class TParamsBuilder::TImpl {
-public:
+class TParamsBuilder::TImpl { 
+public: 
     TImpl() = default;
 
     TImpl(const ::google::protobuf::Map<TString, Ydb::Type>& typeInfo)
         : HasTypeInfo_(true)
-    {
-        for (const auto& pair : typeInfo) {
-            ParamsMap_[pair.first].mutable_type()->CopyFrom(pair.second);
-        }
+    { 
+        for (const auto& pair : typeInfo) { 
+            ParamsMap_[pair.first].mutable_type()->CopyFrom(pair.second); 
+        } 
     }
 
     TImpl(const TMap<TString, TType>& typeInfo)
         : HasTypeInfo_(true)
-    {
-        for (const auto& pair : typeInfo) {
-            ParamsMap_[pair.first].mutable_type()->CopyFrom(TProtoAccessor::GetProto(pair.second));
-        }
+    { 
+        for (const auto& pair : typeInfo) { 
+            ParamsMap_[pair.first].mutable_type()->CopyFrom(TProtoAccessor::GetProto(pair.second)); 
+        } 
     }
 
-    bool HasTypeInfo() const {
-        return HasTypeInfo_;
+    bool HasTypeInfo() const { 
+        return HasTypeInfo_; 
     }
 
-    TParamValueBuilder& AddParam(TParamsBuilder& owner, const TString& name) {
-        auto param = GetParam(name);
-        Y_VERIFY(param);
+    TParamValueBuilder& AddParam(TParamsBuilder& owner, const TString& name) { 
+        auto param = GetParam(name); 
+        Y_VERIFY(param); 
 
-        auto result = ValueBuildersMap_.emplace(name, TParamValueBuilder(owner, *param->mutable_type(),
+        auto result = ValueBuildersMap_.emplace(name, TParamValueBuilder(owner, *param->mutable_type(), 
             *param->mutable_value()));
 
-        return result.first->second;
+        return result.first->second; 
     }
 
-    void AddParam(const TString& name, const TValue& value) {
-        auto param = GetParam(name);
-        Y_VERIFY(param);
+    void AddParam(const TString& name, const TValue& value) { 
+        auto param = GetParam(name); 
+        Y_VERIFY(param); 
 
-        if (HasTypeInfo()) {
-            if (!TypesEqual(param->type(), TProtoAccessor::GetProto(value.GetType()))) {
-                FatalError(TStringBuilder() << "Type mismatch for parameter: " << name << ", expected: "
-                    << FormatType(TType(param->type())) << ", actual: " << FormatType(value.GetType()));
-            }
-        } else {
-            param->mutable_type()->CopyFrom(TProtoAccessor::GetProto(value.GetType()));
-        }
+        if (HasTypeInfo()) { 
+            if (!TypesEqual(param->type(), TProtoAccessor::GetProto(value.GetType()))) { 
+                FatalError(TStringBuilder() << "Type mismatch for parameter: " << name << ", expected: " 
+                    << FormatType(TType(param->type())) << ", actual: " << FormatType(value.GetType())); 
+            } 
+        } else { 
+            param->mutable_type()->CopyFrom(TProtoAccessor::GetProto(value.GetType())); 
+        } 
 
-        param->mutable_value()->CopyFrom(TProtoAccessor::GetProto(value));
+        param->mutable_value()->CopyFrom(TProtoAccessor::GetProto(value)); 
     }
 
-    TParams Build() {
-        for (auto& pair : ValueBuildersMap_) {
-            if (!pair.second.Finished()) {
-                FatalError(TStringBuilder() << "Incomplete value for parameter: " << pair.first
-                    << ", call Build() on parameter value builder");
-            }
-        }
+    TParams Build() { 
+        for (auto& pair : ValueBuildersMap_) { 
+            if (!pair.second.Finished()) { 
+                FatalError(TStringBuilder() << "Incomplete value for parameter: " << pair.first 
+                    << ", call Build() on parameter value builder"); 
+            } 
+        } 
 
-        ValueBuildersMap_.clear();
+        ValueBuildersMap_.clear(); 
 
         ::google::protobuf::Map<TString, Ydb::TypedValue> paramsMap;
-        paramsMap.swap(ParamsMap_);
-        return TParams(std::move(paramsMap));
+        paramsMap.swap(ParamsMap_); 
+        return TParams(std::move(paramsMap)); 
     }
 
-private:
+private: 
     Ydb::TypedValue* GetParam(const TString& name) {
-        if (HasTypeInfo()) {
-            auto it = ParamsMap_.find(name);
-            if (it == ParamsMap_.end()) {
-                FatalError(TStringBuilder() << "Parameter not found: " << name);
-                return nullptr;
-            }
-
-            return &it->second;
+        if (HasTypeInfo()) { 
+            auto it = ParamsMap_.find(name); 
+            if (it == ParamsMap_.end()) { 
+                FatalError(TStringBuilder() << "Parameter not found: " << name); 
+                return nullptr; 
+            } 
+
+            return &it->second; 
         } else {
-            return &ParamsMap_[name];
+            return &ParamsMap_[name]; 
         }
     }
 
-    void FatalError(const TString& msg) const {
+    void FatalError(const TString& msg) const { 
         ThrowFatalError(TStringBuilder() << "TParamsBuilder: " << msg);
-    }
-
+    } 
+ 
 private:
-    bool HasTypeInfo_ = false;
+    bool HasTypeInfo_ = false; 
     ::google::protobuf::Map<TString, Ydb::TypedValue> ParamsMap_;
-    TMap<TString, TParamValueBuilder> ValueBuildersMap_;
+    TMap<TString, TParamValueBuilder> ValueBuildersMap_; 
 };
 
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////// 
 
 TParamValueBuilder::TParamValueBuilder(TParamsBuilder& owner, Ydb::Type& typeProto, Ydb::Value& valueProto)
     : TValueBuilderBase(typeProto, valueProto)
-    , Owner_(owner)
-    , Finished_(false) {}
+    , Owner_(owner) 
+    , Finished_(false) {} 
 
-bool TParamValueBuilder::Finished() {
-    return Finished_;
+bool TParamValueBuilder::Finished() { 
+    return Finished_; 
 }
 
-TParamsBuilder& TParamValueBuilder::Build() {
-    CheckValue();
+TParamsBuilder& TParamValueBuilder::Build() { 
+    CheckValue(); 
 
-    Finished_ = true;
-    return Owner_;
+    Finished_ = true; 
+    return Owner_; 
 }
 
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////// 
 
-TParamsBuilder::TParamsBuilder(TParamsBuilder&&) = default;
-TParamsBuilder::~TParamsBuilder() = default;
+TParamsBuilder::TParamsBuilder(TParamsBuilder&&) = default; 
+TParamsBuilder::~TParamsBuilder() = default; 
 
-TParamsBuilder::TParamsBuilder()
+TParamsBuilder::TParamsBuilder() 
     : Impl_(new TImpl()) {}
 
-TParamsBuilder::TParamsBuilder(const TMap<TString, TType>& typeInfo)
+TParamsBuilder::TParamsBuilder(const TMap<TString, TType>& typeInfo) 
     : Impl_(new TImpl(typeInfo)) {}
 
 TParamsBuilder::TParamsBuilder(const ::google::protobuf::Map<TString, Ydb::Type>& typeInfo)
     : Impl_(new TImpl(typeInfo)) {}
 
-bool TParamsBuilder::HasTypeInfo() const {
-    return Impl_->HasTypeInfo();
+bool TParamsBuilder::HasTypeInfo() const { 
+    return Impl_->HasTypeInfo(); 
 }
 
-TParamValueBuilder& TParamsBuilder::AddParam(const TString& name) {
-    return Impl_->AddParam(*this, name);
+TParamValueBuilder& TParamsBuilder::AddParam(const TString& name) { 
+    return Impl_->AddParam(*this, name); 
 }
 
-TParamsBuilder& TParamsBuilder::AddParam(const TString& name, const TValue& value) {
-    Impl_->AddParam(name, value);
+TParamsBuilder& TParamsBuilder::AddParam(const TString& name, const TValue& value) { 
+    Impl_->AddParam(name, value); 
     return *this;
 }
 
 TParams TParamsBuilder::Build() {
-    return Impl_->Build();
+    return Impl_->Build(); 
 }
 
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_params/params.h b/ydb/public/sdk/cpp/client/ydb_params/params.h
index 0f85f18329..1fc971ff5e 100644
--- a/ydb/public/sdk/cpp/client/ydb_params/params.h
+++ b/ydb/public/sdk/cpp/client/ydb_params/params.h
@@ -4,85 +4,85 @@
 
 #include <google/protobuf/map.h>
 
-namespace Ydb {
+namespace Ydb { 
     class TypedValue;
 }
 
-namespace NYdb {
+namespace NYdb { 
 
 namespace NScripting {
     class TScriptingClient;
 }
 
-namespace NTable {
-    class TTableClient;
-    class TSession;
-    class TDataQuery;
-}
-
-namespace NExperimental {
-    class TStreamQueryClient;
-}
+namespace NTable { 
+    class TTableClient; 
+    class TSession; 
+    class TDataQuery; 
+} 
 
-class TParamsBuilder;
+namespace NExperimental { 
+    class TStreamQueryClient; 
+} 
+ 
+class TParamsBuilder; 
 
 class TParams {
-    friend class TParamsBuilder;
-    friend class NTable::TTableClient;
-    friend class NTable::TSession;
-    friend class NTable::TDataQuery;
-    friend class NScripting::TScriptingClient;
-    friend class NExperimental::TStreamQueryClient;
-public:
-    bool Empty() const;
-
-    TMap<TString, TValue> GetValues() const;
-    TMaybe<TValue> GetValue(const TString& name) const;
-
-private:
+    friend class TParamsBuilder; 
+    friend class NTable::TTableClient; 
+    friend class NTable::TSession; 
+    friend class NTable::TDataQuery; 
+    friend class NScripting::TScriptingClient; 
+    friend class NExperimental::TStreamQueryClient; 
+public: 
+    bool Empty() const; 
+
+    TMap<TString, TValue> GetValues() const; 
+    TMaybe<TValue> GetValue(const TString& name) const; 
+ 
+private: 
     TParams(::google::protobuf::Map<TString, Ydb::TypedValue>&& protoMap);
-
+ 
     ::google::protobuf::Map<TString, Ydb::TypedValue>* GetProtoMapPtr();
     const ::google::protobuf::Map<TString, Ydb::TypedValue>& GetProtoMap() const;
 
-    class TImpl;
+    class TImpl; 
     std::shared_ptr<TImpl> Impl_;
-};
-
-class TParamValueBuilder : public TValueBuilderBase<TParamValueBuilder> {
+}; 
+ 
+class TParamValueBuilder : public TValueBuilderBase<TParamValueBuilder> { 
     friend class TParamsBuilder;
 public:
-    TParamsBuilder& Build();
-    bool Finished();
-
+    TParamsBuilder& Build(); 
+    bool Finished(); 
+ 
 private:
     TParamValueBuilder(TParamsBuilder& owner, Ydb::Type& typeProto, Ydb::Value& valueProto);
-
-    TParamsBuilder& Owner_;
-    bool Finished_;
+ 
+    TParamsBuilder& Owner_; 
+    bool Finished_; 
 };
 
-class TParamsBuilder : public TMoveOnly {
-    friend class NTable::TDataQuery;
+class TParamsBuilder : public TMoveOnly { 
+    friend class NTable::TDataQuery; 
 public:
-    TParamsBuilder(TParamsBuilder&&);
+    TParamsBuilder(TParamsBuilder&&); 
     TParamsBuilder();
-    TParamsBuilder(const TMap<TString, TType>& typeInfo);
-
-    ~TParamsBuilder();
-
-    TParamValueBuilder& AddParam(const TString& name);
-    TParamsBuilder& AddParam(const TString& name, const TValue& value);
-
-    bool HasTypeInfo() const;
-
+    TParamsBuilder(const TMap<TString, TType>& typeInfo); 
+
+    ~TParamsBuilder(); 
+ 
+    TParamValueBuilder& AddParam(const TString& name); 
+    TParamsBuilder& AddParam(const TString& name, const TValue& value); 
+ 
+    bool HasTypeInfo() const; 
+ 
     TParams Build();
 
 private:
     TParamsBuilder(const ::google::protobuf::Map<TString, Ydb::Type>& typeInfo);
-
+ 
     class TImpl;
-    std::unique_ptr<TImpl> Impl_;
+    std::unique_ptr<TImpl> Impl_; 
 };
 
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_params/params_ut.cpp b/ydb/public/sdk/cpp/client/ydb_params/params_ut.cpp
index 1b516de577..b72d4efee6 100644
--- a/ydb/public/sdk/cpp/client/ydb_params/params_ut.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_params/params_ut.cpp
@@ -4,240 +4,240 @@
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/testing/unittest/tests_data.h>
 
-using namespace NYdb;
+using namespace NYdb; 
 
 using TExpectedErrorException = yexception;
-
-Y_UNIT_TEST_SUITE(ParamsBuilder) {
-    Y_UNIT_TEST(Build) {
-        auto params = TParamsBuilder()
-            .AddParam("$param1")
-                .BeginList()
-                .AddListItem()
-                    .BeginOptional()
-                        .Uint64(10)
-                    .EndOptional()
-                .AddListItem()
-                    .EmptyOptional()
-                .EndList()
-                .Build()
-            .AddParam("$param2")
-                .String("test")
-                .Build()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()),
-            R"(List<Uint64?>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param1")),
-            R"([[10u];#])");
-
-        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()),
-            R"(String)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param2")),
-            R"("test")");
+ 
+Y_UNIT_TEST_SUITE(ParamsBuilder) { 
+    Y_UNIT_TEST(Build) { 
+        auto params = TParamsBuilder() 
+            .AddParam("$param1") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginOptional() 
+                        .Uint64(10) 
+                    .EndOptional() 
+                .AddListItem() 
+                    .EmptyOptional() 
+                .EndList() 
+                .Build() 
+            .AddParam("$param2") 
+                .String("test") 
+                .Build() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), 
+            R"(List<Uint64?>)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param1")), 
+            R"([[10u];#])"); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), 
+            R"(String)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param2")), 
+            R"("test")"); 
     }
 
-    Y_UNIT_TEST(BuildFromValue) {
-        auto value2 = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .BeginOptional()
-                    .BeginTuple()
-                    .AddElement()
-                        .Int32(-11)
-                    .AddElement()
-                        .String("test2")
-                    .EndTuple()
-                .EndOptional()
-            .AddListItem()
-                .EmptyOptional()
-            .EndList()
-            .Build();
-
-        auto params = TParamsBuilder()
-            .AddParam("$param1")
-                .Utf8("test1")
-                .Build()
-            .AddParam("$param2", value2)
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()),
-            R"(Utf8)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param1")),
-            R"("test1")");
-
-        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()),
-            R"(List<Tuple<Int32,String>?>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param2")),
-            R"([[[-11;"test2"]];#])");
+    Y_UNIT_TEST(BuildFromValue) { 
+        auto value2 = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .BeginOptional() 
+                    .BeginTuple() 
+                    .AddElement() 
+                        .Int32(-11) 
+                    .AddElement() 
+                        .String("test2") 
+                    .EndTuple() 
+                .EndOptional() 
+            .AddListItem() 
+                .EmptyOptional() 
+            .EndList() 
+            .Build(); 
+ 
+        auto params = TParamsBuilder() 
+            .AddParam("$param1") 
+                .Utf8("test1") 
+                .Build() 
+            .AddParam("$param2", value2) 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), 
+            R"(Utf8)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param1")), 
+            R"("test1")"); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), 
+            R"(List<Tuple<Int32,String>?>)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param2")), 
+            R"([[[-11;"test2"]];#])"); 
     }
-
-    Y_UNIT_TEST(BuildWithTypeInfo) {
-        auto param1Type = TTypeBuilder()
-            .BeginList()
-                .Primitive(EPrimitiveType::String)
-            .EndList()
-            .Build();
-
-        auto param2Type = TTypeBuilder()
-            .BeginOptional()
-                .Primitive(EPrimitiveType::Uint32)
-            .EndOptional()
-            .Build();
-
-        TMap<TString, TType> paramsMap;
-        paramsMap.emplace("$param1", param1Type);
-        paramsMap.emplace("$param2", param2Type);
-
-        auto value1 = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .String("str1")
-            .AddListItem()
-                .String("str2")
-            .EndList()
-            .Build();
-
-        auto params = TParamsBuilder(paramsMap)
-            .AddParam("$param1", value1)
-            .AddParam("$param2")
-                .EmptyOptional()
-                .Build()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()),
-            R"(List<String>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param1")),
-            R"(["str1";"str2"])");
-
-        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()),
-            R"(Uint32?)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param2")),
-            R"(#)");
+ 
+    Y_UNIT_TEST(BuildWithTypeInfo) { 
+        auto param1Type = TTypeBuilder() 
+            .BeginList() 
+                .Primitive(EPrimitiveType::String) 
+            .EndList() 
+            .Build(); 
+ 
+        auto param2Type = TTypeBuilder() 
+            .BeginOptional() 
+                .Primitive(EPrimitiveType::Uint32) 
+            .EndOptional() 
+            .Build(); 
+ 
+        TMap<TString, TType> paramsMap; 
+        paramsMap.emplace("$param1", param1Type); 
+        paramsMap.emplace("$param2", param2Type); 
+ 
+        auto value1 = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .String("str1") 
+            .AddListItem() 
+                .String("str2") 
+            .EndList() 
+            .Build(); 
+ 
+        auto params = TParamsBuilder(paramsMap) 
+            .AddParam("$param1", value1) 
+            .AddParam("$param2") 
+                .EmptyOptional() 
+                .Build() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), 
+            R"(List<String>)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param1")), 
+            R"(["str1";"str2"])"); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), 
+            R"(Uint32?)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param2")), 
+            R"(#)"); 
     }
-
-    Y_UNIT_TEST(MissingParam) {
-        auto param1Type = TTypeBuilder()
-            .BeginList()
-                .Primitive(EPrimitiveType::String)
-            .EndList()
-            .Build();
-
-        auto param2Type = TTypeBuilder()
-            .BeginOptional()
-                .Primitive(EPrimitiveType::Uint32)
-            .EndOptional()
-            .Build();
-
-        TMap<TString, TType> paramsMap;
-        paramsMap.emplace("$param1", param1Type);
-        paramsMap.emplace("$param2", param2Type);
-
-        try {
+ 
+    Y_UNIT_TEST(MissingParam) { 
+        auto param1Type = TTypeBuilder() 
+            .BeginList() 
+                .Primitive(EPrimitiveType::String) 
+            .EndList() 
+            .Build(); 
+ 
+        auto param2Type = TTypeBuilder() 
+            .BeginOptional() 
+                .Primitive(EPrimitiveType::Uint32) 
+            .EndOptional() 
+            .Build(); 
+ 
+        TMap<TString, TType> paramsMap; 
+        paramsMap.emplace("$param1", param1Type); 
+        paramsMap.emplace("$param2", param2Type); 
+ 
+        try { 
             auto params = TParamsBuilder(paramsMap)
-                .AddParam("$param3")
-                    .EmptyOptional()
-                    .Build()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
+                .AddParam("$param3") 
+                    .EmptyOptional() 
+                    .Build() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
     }
 
-    Y_UNIT_TEST(IncompleteParam) {
+    Y_UNIT_TEST(IncompleteParam) { 
         auto paramsBuilder = TParamsBuilder();
-
-        auto& param1Builder = paramsBuilder.AddParam("$param1");
-        auto& param2Builder = paramsBuilder.AddParam("$param2");
-
-        param1Builder
-            .BeginList()
-            .AddListItem()
-                .BeginOptional()
-                    .Uint64(10)
-                .EndOptional()
-            .AddListItem()
-                .EmptyOptional()
-            .EndList()
-            .Build();
-
-        param2Builder.String("test");
-
-        try {
-            paramsBuilder.Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
+ 
+        auto& param1Builder = paramsBuilder.AddParam("$param1"); 
+        auto& param2Builder = paramsBuilder.AddParam("$param2"); 
+ 
+        param1Builder 
+            .BeginList() 
+            .AddListItem() 
+                .BeginOptional() 
+                    .Uint64(10) 
+                .EndOptional() 
+            .AddListItem() 
+                .EmptyOptional() 
+            .EndList() 
+            .Build(); 
+ 
+        param2Builder.String("test"); 
+ 
+        try { 
+            paramsBuilder.Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
     }
-
-    Y_UNIT_TEST(TypeMismatch) {
-        auto param1Type = TTypeBuilder()
-            .BeginList()
-                .Primitive(EPrimitiveType::String)
-            .EndList()
-            .Build();
-
-        auto param2Type = TTypeBuilder()
-            .BeginOptional()
-                .Primitive(EPrimitiveType::Uint32)
-            .EndOptional()
-            .Build();
-
-        TMap<TString, TType> paramsMap;
-        paramsMap.emplace("$param1", param1Type);
-        paramsMap.emplace("$param2", param2Type);
-
-        try {
+ 
+    Y_UNIT_TEST(TypeMismatch) { 
+        auto param1Type = TTypeBuilder() 
+            .BeginList() 
+                .Primitive(EPrimitiveType::String) 
+            .EndList() 
+            .Build(); 
+ 
+        auto param2Type = TTypeBuilder() 
+            .BeginOptional() 
+                .Primitive(EPrimitiveType::Uint32) 
+            .EndOptional() 
+            .Build(); 
+ 
+        TMap<TString, TType> paramsMap; 
+        paramsMap.emplace("$param1", param1Type); 
+        paramsMap.emplace("$param2", param2Type); 
+ 
+        try { 
             auto params = TParamsBuilder(paramsMap)
-                .AddParam("$param1")
-                    .EmptyOptional()
-                    .Build()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
+                .AddParam("$param1") 
+                    .EmptyOptional() 
+                    .Build() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
     }
-
-    Y_UNIT_TEST(TypeMismatchFromValue) {
-        auto param1Type = TTypeBuilder()
-            .BeginList()
-                .Primitive(EPrimitiveType::String)
-            .EndList()
-            .Build();
-
-        auto param2Type = TTypeBuilder()
-            .BeginOptional()
-                .Primitive(EPrimitiveType::Uint32)
-            .EndOptional()
-            .Build();
-
-        TMap<TString, TType> paramsMap;
-        paramsMap.emplace("$param1", param1Type);
-        paramsMap.emplace("$param2", param2Type);
-
-        auto value1 = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .String("str1")
-            .AddListItem()
-                .String("str2")
-            .EndList()
-            .Build();
-
-        try {
+ 
+    Y_UNIT_TEST(TypeMismatchFromValue) { 
+        auto param1Type = TTypeBuilder() 
+            .BeginList() 
+                .Primitive(EPrimitiveType::String) 
+            .EndList() 
+            .Build(); 
+ 
+        auto param2Type = TTypeBuilder() 
+            .BeginOptional() 
+                .Primitive(EPrimitiveType::Uint32) 
+            .EndOptional() 
+            .Build(); 
+ 
+        TMap<TString, TType> paramsMap; 
+        paramsMap.emplace("$param1", param1Type); 
+        paramsMap.emplace("$param2", param2Type); 
+ 
+        auto value1 = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .String("str1") 
+            .AddListItem() 
+                .String("str2") 
+            .EndList() 
+            .Build(); 
+ 
+        try { 
             auto params = TParamsBuilder(paramsMap)
-                .AddParam("$param2", value1)
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
+                .AddParam("$param2", value1) 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
     }
 }
diff --git a/ydb/public/sdk/cpp/client/ydb_proto/accessor.cpp b/ydb/public/sdk/cpp/client/ydb_proto/accessor.cpp
index dd02fb89db..a3e006b56d 100644
--- a/ydb/public/sdk/cpp/client/ydb_proto/accessor.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_proto/accessor.cpp
@@ -1,17 +1,17 @@
 #include "accessor.h"
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_value/value.h>
 
-namespace NYdb {
-
-const Ydb::Type& TProtoAccessor::GetProto(const TType& type) {
-    return type.GetProto();
-}
-
-const Ydb::Value& TProtoAccessor::GetProto(const TValue& value) {
-    return value.GetProto();
-}
-
+namespace NYdb { 
+ 
+const Ydb::Type& TProtoAccessor::GetProto(const TType& type) { 
+    return type.GetProto(); 
+} 
+ 
+const Ydb::Value& TProtoAccessor::GetProto(const TValue& value) { 
+    return value.GetProto(); 
+} 
+ 
 // exports & imports
 template <typename TProtoSettings>
 typename TProtoSettings::Scheme TProtoAccessor::GetProto(ES3Scheme value) {
@@ -127,4 +127,4 @@ NImport::EImportProgress TProtoAccessor::FromProto(Ydb::Import::ImportProgress::
     }
 }
 
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_proto/accessor.h b/ydb/public/sdk/cpp/client/ydb_proto/accessor.h
index be0165d74b..fc98cdc0dd 100644
--- a/ydb/public/sdk/cpp/client/ydb_proto/accessor.h
+++ b/ydb/public/sdk/cpp/client/ydb_proto/accessor.h
@@ -1,19 +1,19 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/public/api/protos/ydb_value.pb.h>
 #include <ydb/public/api/protos/ydb_query_stats.pb.h>
 #include <ydb/public/api/protos/ydb_table.pb.h>
 #include <ydb/public/api/protos/ydb_export.pb.h>
 #include <ydb/public/api/protos/ydb_import.pb.h>
 #include <ydb/public/api/grpc/draft/ydb_persqueue_v1.grpc.pb.h>
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_export/export.h>
 #include <ydb/public/sdk/cpp/client/ydb_import/import.h>
 #include <ydb/public/sdk/cpp/client/ydb_table/table.h>
 #include <ydb/public/sdk/cpp/client/ydb_persqueue_public/persqueue.h>
 
-namespace NYdb {
-
+namespace NYdb { 
+ 
 class TResultSet;
 class TValue;
 class TType;
@@ -24,14 +24,14 @@ class TTableDescription;
 class TIndexDescription;
 }
 
-//! Provides access to raw protobuf values of YDB API entities. It is not recommended to use this
-//! class in client applications as it add dependency on API protobuf format which is subject to
-//! change. Use functionality provided by YDB SDK classes.
-class TProtoAccessor {
-public:
-    static const Ydb::Type& GetProto(const TType& type);
-    static const Ydb::Value& GetProto(const TValue& value);
-    static const Ydb::ResultSet& GetProto(const TResultSet& resultSet);
+//! Provides access to raw protobuf values of YDB API entities. It is not recommended to use this 
+//! class in client applications as it add dependency on API protobuf format which is subject to 
+//! change. Use functionality provided by YDB SDK classes. 
+class TProtoAccessor { 
+public: 
+    static const Ydb::Type& GetProto(const TType& type); 
+    static const Ydb::Value& GetProto(const TValue& value); 
+    static const Ydb::ResultSet& GetProto(const TResultSet& resultSet); 
     static const Ydb::TableStats::QueryStats& GetProto(const NTable::TQueryStats& queryStats);
     static const Ydb::Table::DescribeTableResult& GetProto(const NTable::TTableDescription& tableDescription);
     static const Ydb::PersQueue::V1::DescribeTopicResult& GetProto(const NYdb::NPersQueue::TDescribeTopicResult& topicDescription);
@@ -51,6 +51,6 @@ public:
     static NExport::TExportToS3Settings::EStorageClass FromProto(Ydb::Export::ExportToS3Settings::StorageClass value);
     static NExport::EExportProgress FromProto(Ydb::Export::ExportProgress::Progress value);
     static NImport::EImportProgress FromProto(Ydb::Import::ImportProgress::Progress value);
-};
-
-} // namespace NYdb
+}; 
+ 
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_rate_limiter/rate_limiter.cpp b/ydb/public/sdk/cpp/client/ydb_rate_limiter/rate_limiter.cpp
index bea557812c..5f12ec400d 100644
--- a/ydb/public/sdk/cpp/client/ydb_rate_limiter/rate_limiter.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_rate_limiter/rate_limiter.cpp
@@ -78,7 +78,7 @@ public:
         return RunSimple<Ydb::RateLimiter::V1::RateLimiterService, Ydb::RateLimiter::CreateResourceRequest, Ydb::RateLimiter::CreateResourceResponse>(
             std::move(request),
             &Ydb::RateLimiter::V1::RateLimiterService::Stub::AsyncCreateResource,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_);
     }
 
@@ -88,7 +88,7 @@ public:
         return RunSimple<Ydb::RateLimiter::V1::RateLimiterService, Ydb::RateLimiter::AlterResourceRequest, Ydb::RateLimiter::AlterResourceResponse>(
             std::move(request),
             &Ydb::RateLimiter::V1::RateLimiterService::Stub::AsyncAlterResource,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_);
     }
 
@@ -100,7 +100,7 @@ public:
         return RunSimple<Ydb::RateLimiter::V1::RateLimiterService, Ydb::RateLimiter::DropResourceRequest, Ydb::RateLimiter::DropResourceResponse>(
             std::move(request),
             &Ydb::RateLimiter::V1::RateLimiterService::Stub::AsyncDropResource,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_);
     }
 
@@ -134,7 +134,7 @@ public:
             &Ydb::RateLimiter::V1::RateLimiterService::Stub::AsyncListResources,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_);
 
         return promise.GetFuture();
@@ -164,7 +164,7 @@ public:
             &Ydb::RateLimiter::V1::RateLimiterService::Stub::AsyncDescribeResource,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_);
 
         return promise.GetFuture();
diff --git a/ydb/public/sdk/cpp/client/ydb_result/result.cpp b/ydb/public/sdk/cpp/client/ydb_result/result.cpp
index dc7eb09c0a..999398ba08 100644
--- a/ydb/public/sdk/cpp/client/ydb_result/result.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_result/result.cpp
@@ -6,11 +6,11 @@
 #include <ydb/public/api/protos/ydb_value.pb.h>
 
 #include <util/generic/map.h>
-#include <util/string/builder.h>
-
+#include <util/string/builder.h> 
+ 
 #include <google/protobuf/text_format.h>
 
-namespace NYdb {
+namespace NYdb { 
 
 TString TColumn::ToString() const {
     TString result;
@@ -35,95 +35,95 @@ bool operator!=(const TColumn& col1, const TColumn& col2) {
 
 class TResultSet::TImpl {
 public:
-    TImpl(const Ydb::ResultSet& proto)
-        : ProtoResultSet_(proto)
+    TImpl(const Ydb::ResultSet& proto) 
+        : ProtoResultSet_(proto) 
     {
-        Init();
+        Init(); 
     }
 
-    TImpl(Ydb::ResultSet&& proto)
-        : ProtoResultSet_(std::move(proto))
-    {
-        Init();
+    TImpl(Ydb::ResultSet&& proto) 
+        : ProtoResultSet_(std::move(proto)) 
+    { 
+        Init(); 
     }
 
-    void Init() {
-        ColumnsMeta_.reserve(ProtoResultSet_.columns_size());
-        for (auto& meta : ProtoResultSet_.columns()) {
-            ColumnsMeta_.push_back(TColumn(meta.name(), TType(meta.type())));
+    void Init() { 
+        ColumnsMeta_.reserve(ProtoResultSet_.columns_size()); 
+        for (auto& meta : ProtoResultSet_.columns()) { 
+            ColumnsMeta_.push_back(TColumn(meta.name(), TType(meta.type()))); 
         }
     }
 
-public:
-    const Ydb::ResultSet ProtoResultSet_;
-    TVector<TColumn> ColumnsMeta_;
-};
+public: 
+    const Ydb::ResultSet ProtoResultSet_; 
+    TVector<TColumn> ColumnsMeta_; 
+}; 
 
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////// 
 
-TResultSet::TResultSet(const Ydb::ResultSet& proto)
-    : Impl_(new TResultSet::TImpl(proto)) {}
-
-TResultSet::TResultSet(Ydb::ResultSet&& proto)
-    : Impl_(new TResultSet::TImpl(std::move(proto))) {}
-
-size_t TResultSet::ColumnsCount() const {
-    return Impl_->ColumnsMeta_.size();
-}
+TResultSet::TResultSet(const Ydb::ResultSet& proto) 
+    : Impl_(new TResultSet::TImpl(proto)) {} 
 
-size_t TResultSet::RowsCount() const {
-    return Impl_->ProtoResultSet_.rows_size();
-}
+TResultSet::TResultSet(Ydb::ResultSet&& proto) 
+    : Impl_(new TResultSet::TImpl(std::move(proto))) {} 
 
-bool TResultSet::Truncated() const {
-    return Impl_->ProtoResultSet_.truncated();
-}
+size_t TResultSet::ColumnsCount() const { 
+    return Impl_->ColumnsMeta_.size(); 
+} 
 
-const TVector<TColumn>& TResultSet::GetColumnsMeta() const {
-    return Impl_->ColumnsMeta_;
-}
+size_t TResultSet::RowsCount() const { 
+    return Impl_->ProtoResultSet_.rows_size(); 
+} 
+ 
+bool TResultSet::Truncated() const { 
+    return Impl_->ProtoResultSet_.truncated(); 
+} 
+ 
+const TVector<TColumn>& TResultSet::GetColumnsMeta() const { 
+    return Impl_->ColumnsMeta_; 
+} 
 
-const Ydb::ResultSet& TResultSet::GetProto() const {
-    return Impl_->ProtoResultSet_;
-}
+const Ydb::ResultSet& TResultSet::GetProto() const { 
+    return Impl_->ProtoResultSet_; 
+} 
 
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////// 
 
-class TResultSetParser::TImpl {
-public:
+class TResultSetParser::TImpl { 
+public: 
     TImpl(const TResultSet& resultSet)
-        : ResultSet_(resultSet)
-    {
-        ColumnParsers.reserve(resultSet.ColumnsCount());
-
-        auto& columnsMeta = resultSet.GetColumnsMeta();
-        for (size_t i = 0; i < columnsMeta.size(); ++i) {
-            auto& column = columnsMeta[i];
-            ColumnIndexMap[column.Name] = i;
-            ColumnParsers.emplace_back<TValueParser>(column.Type);
+        : ResultSet_(resultSet) 
+    { 
+        ColumnParsers.reserve(resultSet.ColumnsCount()); 
+ 
+        auto& columnsMeta = resultSet.GetColumnsMeta(); 
+        for (size_t i = 0; i < columnsMeta.size(); ++i) { 
+            auto& column = columnsMeta[i]; 
+            ColumnIndexMap[column.Name] = i; 
+            ColumnParsers.emplace_back<TValueParser>(column.Type); 
         }
     }
 
-    size_t ColumnsCount() const {
-        return ResultSet_.ColumnsCount();
+    size_t ColumnsCount() const { 
+        return ResultSet_.ColumnsCount(); 
     }
 
     size_t RowsCount() const {
         return ResultSet_.RowsCount();
     }
 
-    bool TryNextRow() {
-        if (RowIndex_ == ResultSet_.RowsCount()) {
-            return false;
+    bool TryNextRow() { 
+        if (RowIndex_ == ResultSet_.RowsCount()) { 
+            return false; 
         }
 
-        auto& row = ResultSet_.GetProto().rows()[RowIndex_];
-        for (size_t i = 0; i < ColumnsCount(); ++i) {
-            ColumnParsers[i].Reset(row.items(i));
+        auto& row = ResultSet_.GetProto().rows()[RowIndex_]; 
+        for (size_t i = 0; i < ColumnsCount(); ++i) { 
+            ColumnParsers[i].Reset(row.items(i)); 
         }
 
-        RowIndex_++;
-        return true;
+        RowIndex_++; 
+        return true; 
     }
 
     ssize_t ColumnIndex(const TString& columnName) {
@@ -131,23 +131,23 @@ public:
         return idx ? static_cast<ssize_t>(*idx) : -1;
     }
 
-    TValueParser& ColumnParser(size_t columnIndex) {
-        if (columnIndex >= ColumnParsers.size()) {
-            FatalError(TStringBuilder() << "Column index out of bounds: " << columnIndex);
+    TValueParser& ColumnParser(size_t columnIndex) { 
+        if (columnIndex >= ColumnParsers.size()) { 
+            FatalError(TStringBuilder() << "Column index out of bounds: " << columnIndex); 
         }
 
-        return ColumnParsers[columnIndex];
-    }
-
-    TValueParser& ColumnParser(const TString& columnName) {
-        auto idx = ColumnIndexMap.FindPtr(columnName);
-        if (!idx) {
-            FatalError(TStringBuilder() << "Unknown column: " << columnName);
-        }
-
-        return ColumnParser(*idx);
+        return ColumnParsers[columnIndex]; 
     }
 
+    TValueParser& ColumnParser(const TString& columnName) { 
+        auto idx = ColumnIndexMap.FindPtr(columnName); 
+        if (!idx) { 
+            FatalError(TStringBuilder() << "Unknown column: " << columnName); 
+        } 
+ 
+        return ColumnParser(*idx); 
+    } 
+ 
     TValue GetValue(size_t columnIndex) const {
         if (columnIndex >= ColumnParsers.size()) {
             FatalError(TStringBuilder() << "Column index out of bounds: " << columnIndex);
@@ -172,50 +172,50 @@ public:
         return GetValue(*idx);
     }
 
-private:
-    void FatalError(const TString& msg) const {
+private: 
+    void FatalError(const TString& msg) const { 
         ThrowFatalError(TStringBuilder() << "TResultSetParser: " << msg);
     }
 
 private:
-    TResultSet ResultSet_;
-    TMap<TString, size_t> ColumnIndexMap;
-    TVector<TValueParser> ColumnParsers;
-    size_t RowIndex_ = 0;
+    TResultSet ResultSet_; 
+    TMap<TString, size_t> ColumnIndexMap; 
+    TVector<TValueParser> ColumnParsers; 
+    size_t RowIndex_ = 0; 
 };
 
-////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////// 
 
-TResultSetParser::TResultSetParser(TResultSetParser&&) = default;
-TResultSetParser::~TResultSetParser() = default;
-
-TResultSetParser::TResultSetParser(const TResultSet& resultSet)
+TResultSetParser::TResultSetParser(TResultSetParser&&) = default; 
+TResultSetParser::~TResultSetParser() = default; 
+ 
+TResultSetParser::TResultSetParser(const TResultSet& resultSet) 
     : Impl_(new TImpl(resultSet)) {}
 
-size_t TResultSetParser::ColumnsCount() const {
-    return Impl_->ColumnsCount();
+size_t TResultSetParser::ColumnsCount() const { 
+    return Impl_->ColumnsCount(); 
 }
 
 size_t TResultSetParser::RowsCount() const {
     return Impl_->RowsCount();
 }
 
-bool TResultSetParser::TryNextRow() {
-    return Impl_->TryNextRow();
+bool TResultSetParser::TryNextRow() { 
+    return Impl_->TryNextRow(); 
 }
 
 ssize_t TResultSetParser::ColumnIndex(const TString& columnName) {
     return Impl_->ColumnIndex(columnName);
 }
 
-TValueParser& TResultSetParser::ColumnParser(size_t columnIndex) {
-    return Impl_->ColumnParser(columnIndex);
-}
-
-TValueParser& TResultSetParser::ColumnParser(const TString& columnName) {
-    return Impl_->ColumnParser(columnName);
+TValueParser& TResultSetParser::ColumnParser(size_t columnIndex) { 
+    return Impl_->ColumnParser(columnIndex); 
 }
 
+TValueParser& TResultSetParser::ColumnParser(const TString& columnName) { 
+    return Impl_->ColumnParser(columnName); 
+} 
+ 
 TValue TResultSetParser::GetValue(size_t columnIndex) const {
     return Impl_->GetValue(columnIndex);
 }
@@ -224,4 +224,4 @@ TValue TResultSetParser::GetValue(const TString& columnName) const {
     return Impl_->GetValue(columnName);
 }
 
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_result/result.h b/ydb/public/sdk/cpp/client/ydb_result/result.h
index 287c8078be..ec8d380a13 100644
--- a/ydb/public/sdk/cpp/client/ydb_result/result.h
+++ b/ydb/public/sdk/cpp/client/ydb_result/result.h
@@ -5,21 +5,21 @@
 #include <util/generic/vector.h>
 #include <util/generic/string.h>
 
-namespace Ydb {
+namespace Ydb { 
     class ResultSet;
 }
 
-namespace NYdb {
-
-class TProtoAccessor;
-
+namespace NYdb { 
+ 
+class TProtoAccessor; 
+ 
 struct TColumn {
     TString Name;
     TType Type;
-
-    TColumn(const TString& name, const TType& type)
-        : Name(name)
-        , Type(type) {}
+ 
+    TColumn(const TString& name, const TType& type) 
+        : Name(name) 
+        , Type(type) {} 
 
     TString ToString() const;
     void Out(IOutputStream& o) const;
@@ -28,65 +28,65 @@ struct TColumn {
 bool operator==(const TColumn& col1, const TColumn& col2);
 bool operator!=(const TColumn& col1, const TColumn& col2);
 
-//! Collection of rows, represents result of query or part of the result in case of stream operations
-class TResultSet {
-    friend class TResultSetParser;
-    friend class NYdb::TProtoAccessor;
-public:
-    TResultSet(const Ydb::ResultSet& proto);
-    TResultSet(Ydb::ResultSet&& proto);
-
-    //! Returns number of columns
-    size_t ColumnsCount() const;
-
-    //! Returns number of rows in result set (which is partial in case of stream operations)
-    size_t RowsCount() const;
-
-    //! Returns true if result set was truncated
-    bool Truncated() const;
-
-    //! Returns meta information (name, type) for columns
-    const TVector<TColumn>& GetColumnsMeta() const;
-
-private:
-    const Ydb::ResultSet& GetProto() const;
-
-private:
-    class TImpl;
-    std::shared_ptr<TImpl> Impl_;
-};
-
-//! Note: TResultSetParser - mutable object, iteration thougth it changes internal state
-class TResultSetParser : public TMoveOnly {
+//! Collection of rows, represents result of query or part of the result in case of stream operations 
+class TResultSet { 
+    friend class TResultSetParser; 
+    friend class NYdb::TProtoAccessor; 
 public:
-    TResultSetParser(TResultSetParser&&);
-    TResultSetParser(const TResultSet& resultSet);
-
-    ~TResultSetParser();
-
-    //! Returns number of columns
-    size_t ColumnsCount() const;
+    TResultSet(const Ydb::ResultSet& proto); 
+    TResultSet(Ydb::ResultSet&& proto); 
+
+    //! Returns number of columns 
+    size_t ColumnsCount() const; 
+
+    //! Returns number of rows in result set (which is partial in case of stream operations) 
+    size_t RowsCount() const; 
+ 
+    //! Returns true if result set was truncated 
+    bool Truncated() const; 
+ 
+    //! Returns meta information (name, type) for columns 
+    const TVector<TColumn>& GetColumnsMeta() const; 
+
+private: 
+    const Ydb::ResultSet& GetProto() const; 
+
+private: 
+    class TImpl; 
+    std::shared_ptr<TImpl> Impl_; 
+}; 
+
+//! Note: TResultSetParser - mutable object, iteration thougth it changes internal state 
+class TResultSetParser : public TMoveOnly { 
+public: 
+    TResultSetParser(TResultSetParser&&); 
+    TResultSetParser(const TResultSet& resultSet); 
+
+    ~TResultSetParser(); 
+ 
+    //! Returns number of columns 
+    size_t ColumnsCount() const; 
 
     //! Returns number of rows
     size_t RowsCount() const;
 
-    //! Set iterator to the next result row.
-    //! On success TryNextRow will reset all column parsers to the values in next row.
-    //! Column parsers are invalid before the first TryNextRow call.
-    bool TryNextRow();
+    //! Set iterator to the next result row. 
+    //! On success TryNextRow will reset all column parsers to the values in next row. 
+    //! Column parsers are invalid before the first TryNextRow call. 
+    bool TryNextRow(); 
 
     //! Returns index for column with specified name.
     //! If there is no column with such name, then -1 is returned.
     ssize_t ColumnIndex(const TString& columnName);
 
-    //! Returns column value parser for column with specified index.
-    //! State of the parser is preserved until next TryNextRow call.
-    TValueParser& ColumnParser(size_t columnIndex);
-
-    //! Returns column value parser for column with specified name.
-    //! State of the parser is preserved until next TryNextRow call.
-    TValueParser& ColumnParser(const TString& columnName);
+    //! Returns column value parser for column with specified index. 
+    //! State of the parser is preserved until next TryNextRow call. 
+    TValueParser& ColumnParser(size_t columnIndex); 
 
+    //! Returns column value parser for column with specified name. 
+    //! State of the parser is preserved until next TryNextRow call. 
+    TValueParser& ColumnParser(const TString& columnName); 
+ 
     //! Returns TValue for column with specified index.
     //! TValue will have copy of coresponding data so this method
     //! is less effective compare with
@@ -100,13 +100,13 @@ public:
     TValue GetValue(const TString& columnName) const;
 
 private:
-    class TImpl;
-    std::unique_ptr<TImpl> Impl_;
+    class TImpl; 
+    std::unique_ptr<TImpl> Impl_; 
 };
 
 using TResultSets = TVector<TResultSet>;
 
-} // namespace NYdb
+} // namespace NYdb 
 
 Y_DECLARE_OUT_SPEC(inline, NYdb::TColumn, o, x) {
     return x.Out(o);
diff --git a/ydb/public/sdk/cpp/client/ydb_scheme/scheme.cpp b/ydb/public/sdk/cpp/client/ydb_scheme/scheme.cpp
index 31f5535b96..33e3796b0d 100644
--- a/ydb/public/sdk/cpp/client/ydb_scheme/scheme.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_scheme/scheme.cpp
@@ -1,5 +1,5 @@
 #include "scheme.h"
-
+ 
 #define INCLUDE_YDB_INTERNAL_H
 #include <ydb/public/sdk/cpp/client/impl/ydb_internal/make_request/make.h>
 #include <ydb/public/sdk/cpp/client/impl/ydb_internal/table_helpers/helpers.h>
@@ -9,12 +9,12 @@
 #include <ydb/public/api/protos/ydb_scheme.pb.h>
 #include <ydb/public/sdk/cpp/client/ydb_common_client/impl/client.h>
 
-namespace NYdb {
-namespace NScheme {
-
-using namespace NThreading;
+namespace NYdb { 
+namespace NScheme { 
+ 
+using namespace NThreading; 
 using namespace Ydb::Scheme;
-
+ 
 static ESchemeEntryType ConvertProtoEntryType(::Ydb::Scheme::Entry::Type entry) {
     switch (entry) {
     case ::Ydb::Scheme::Entry::DIRECTORY:
@@ -41,112 +41,112 @@ static ESchemeEntryType ConvertProtoEntryType(::Ydb::Scheme::Entry::Type entry)
 }
 
 class TSchemeClient::TImpl : public TClientImplCommon<TSchemeClient::TImpl> {
-public:
+public: 
     TImpl(std::shared_ptr<TGRpcConnectionsImpl>&& connections, const TCommonClientSettings& settings)
         : TClientImplCommon(std::move(connections), settings) {}
-
-    TAsyncStatus MakeDirectory(const TString& path, const TMakeDirectorySettings& settings) {
-        auto request = MakeOperationRequest<Ydb::Scheme::MakeDirectoryRequest>(settings);
-        request.set_path(path);
-
+ 
+    TAsyncStatus MakeDirectory(const TString& path, const TMakeDirectorySettings& settings) { 
+        auto request = MakeOperationRequest<Ydb::Scheme::MakeDirectoryRequest>(settings); 
+        request.set_path(path); 
+ 
         return RunSimple<Ydb::Scheme::V1::SchemeService, MakeDirectoryRequest, MakeDirectoryResponse>(
             std::move(request),
-            &Ydb::Scheme::V1::SchemeService::Stub::AsyncMakeDirectory,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-    }
-
-    TAsyncStatus RemoveDirectory(const TString& path, const TRemoveDirectorySettings& settings) {
-        auto request = MakeOperationRequest<Ydb::Scheme::RemoveDirectoryRequest>(settings);
-        request.set_path(path);
-
+            &Ydb::Scheme::V1::SchemeService::Stub::AsyncMakeDirectory, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+    } 
+ 
+    TAsyncStatus RemoveDirectory(const TString& path, const TRemoveDirectorySettings& settings) { 
+        auto request = MakeOperationRequest<Ydb::Scheme::RemoveDirectoryRequest>(settings); 
+        request.set_path(path); 
+ 
         return RunSimple<Ydb::Scheme::V1::SchemeService, RemoveDirectoryRequest, RemoveDirectoryResponse>(
             std::move(request),
-            &Ydb::Scheme::V1::SchemeService::Stub::AsyncRemoveDirectory,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-    }
-
-    TAsyncDescribePathResult DescribePath(const TString& path, const TDescribePathSettings& settings) {
-        auto request = MakeOperationRequest<Ydb::Scheme::DescribePathRequest>(settings);
-        request.set_path(path);
-
-        auto promise = NThreading::NewPromise<TDescribePathResult>();
-
+            &Ydb::Scheme::V1::SchemeService::Stub::AsyncRemoveDirectory, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+    } 
+ 
+    TAsyncDescribePathResult DescribePath(const TString& path, const TDescribePathSettings& settings) { 
+        auto request = MakeOperationRequest<Ydb::Scheme::DescribePathRequest>(settings); 
+        request.set_path(path); 
+ 
+        auto promise = NThreading::NewPromise<TDescribePathResult>(); 
+ 
         auto extractor = [promise]
             (google::protobuf::Any* any, TPlainStatus status) mutable {
-                TSchemeEntry entry;
-                if (any) {
+                TSchemeEntry entry; 
+                if (any) { 
                     DescribePathResult result;
-                    any->UnpackTo(&result);
-                    entry.Name = result.self().name();
-                    entry.Owner = result.self().owner();
+                    any->UnpackTo(&result); 
+                    entry.Name = result.self().name(); 
+                    entry.Owner = result.self().owner(); 
                     entry.Type = ConvertProtoEntryType(result.self().type());
                     entry.SizeBytes = result.self().size_bytes();
                     PermissionToSchemeEntry(result.self().effective_permissions(), &entry.EffectivePermissions);
                     PermissionToSchemeEntry(result.self().permissions(), &entry.Permissions);
-                }
-
-                TDescribePathResult val(std::move(entry),
+                } 
+ 
+                TDescribePathResult val(std::move(entry), 
                     TStatus(std::move(status)));
-                promise.SetValue(std::move(val));
-            };
-
+                promise.SetValue(std::move(val)); 
+            }; 
+ 
         Connections_->RunDeferred<Ydb::Scheme::V1::SchemeService, DescribePathRequest, DescribePathResponse>(
             std::move(request),
-            extractor,
+            extractor, 
             &Ydb::Scheme::V1::SchemeService::Stub::AsyncDescribePath,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-
-        return promise.GetFuture();
-    }
-
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
     TAsyncListDirectoryResult ListDirectory(const TString& path, const TListDirectorySettings& settings) {
-        auto request = MakeOperationRequest<Ydb::Scheme::ListDirectoryRequest>(settings);
-        request.set_path(path);
-
+        auto request = MakeOperationRequest<Ydb::Scheme::ListDirectoryRequest>(settings); 
+        request.set_path(path); 
+ 
         auto promise = NThreading::NewPromise<TListDirectoryResult>();
-
+ 
         auto extractor = [promise]
             (google::protobuf::Any* any, TPlainStatus status) mutable {
-                TSchemeEntry entry;
-                TVector<TSchemeEntry> children;
-                if (any) {
+                TSchemeEntry entry; 
+                TVector<TSchemeEntry> children; 
+                if (any) { 
                     ListDirectoryResult result;
-                    any->UnpackTo(&result);
-                    entry.Name = result.self().name();
-                    entry.Owner = result.self().owner();
+                    any->UnpackTo(&result); 
+                    entry.Name = result.self().name(); 
+                    entry.Owner = result.self().owner(); 
                     entry.Type = ConvertProtoEntryType(result.self().type());
-
-                    for (const auto& child : result.children()) {
-                        TSchemeEntry tmp;
-                        tmp.Name = child.name();
-                        tmp.Owner = child.owner();
+ 
+                    for (const auto& child : result.children()) { 
+                        TSchemeEntry tmp; 
+                        tmp.Name = child.name(); 
+                        tmp.Owner = child.owner(); 
                         tmp.Type = ConvertProtoEntryType(child.type());
-                        children.push_back(tmp);
-                    }
-                }
-
+                        children.push_back(tmp); 
+                    } 
+                } 
+ 
                 TListDirectoryResult val(std::move(children), std::move(entry),
                     TStatus(std::move(status)));
-                promise.SetValue(std::move(val));
-            };
-
+                promise.SetValue(std::move(val)); 
+            }; 
+ 
         Connections_->RunDeferred<Ydb::Scheme::V1::SchemeService, ListDirectoryRequest, ListDirectoryResponse>(
             std::move(request),
-            extractor,
+            extractor, 
             &Ydb::Scheme::V1::SchemeService::Stub::AsyncListDirectory,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-
-        return promise.GetFuture();
-
-    }
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+ 
+        return promise.GetFuture(); 
+ 
+    } 
 
     void PermissionsToRequest(const TPermissions& permissions, Permissions* to) {
         to->set_subject(permissions.Subject);
@@ -155,14 +155,14 @@ public:
         }
     }
 
-    TAsyncStatus ModifyPermissions(const TString& path, const TModifyPermissionsSettings& settings) {
-        auto request = MakeOperationRequest<Ydb::Scheme::ModifyPermissionsRequest>(settings);
+    TAsyncStatus ModifyPermissions(const TString& path, const TModifyPermissionsSettings& settings) { 
+        auto request = MakeOperationRequest<Ydb::Scheme::ModifyPermissionsRequest>(settings); 
         request.set_path(path);
-        if (settings.ClearAcl_) {
+        if (settings.ClearAcl_) { 
             request.set_clear_permissions(true);
         }
 
-        for (const auto& action : settings.Actions_) {
+        for (const auto& action : settings.Actions_) { 
             auto protoAction = request.add_actions();
             switch (action.first) {
                 case EModifyPermissionsAction::Chown: {
@@ -186,65 +186,65 @@ public:
 
         return RunSimple<Ydb::Scheme::V1::SchemeService, ModifyPermissionsRequest, ModifyPermissionsResponse>(
             std::move(request),
-            &Ydb::Scheme::V1::SchemeService::Stub::AsyncModifyPermissions,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
+            &Ydb::Scheme::V1::SchemeService::Stub::AsyncModifyPermissions, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
     }
 
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-TDescribePathResult::TDescribePathResult(TSchemeEntry&& entry, TStatus&& status)
-    : TStatus(std::move(status))
-    , Entry_(std::move(entry)) {}
-
-TSchemeEntry TDescribePathResult::GetEntry() const {
-    CheckStatusOk("TDescribePathResult::GetEntry");
-    return Entry_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TDescribePathResult::TDescribePathResult(TSchemeEntry&& entry, TStatus&& status) 
+    : TStatus(std::move(status)) 
+    , Entry_(std::move(entry)) {} 
+ 
+TSchemeEntry TDescribePathResult::GetEntry() const { 
+    CheckStatusOk("TDescribePathResult::GetEntry"); 
+    return Entry_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 TListDirectoryResult::TListDirectoryResult(TVector<TSchemeEntry>&& children, TSchemeEntry&& self,
-    TStatus&& status)
-    : TDescribePathResult(std::move(self), std::move(status))
-    , Children_(std::move(children)) {}
-
+    TStatus&& status) 
+    : TDescribePathResult(std::move(self), std::move(status)) 
+    , Children_(std::move(children)) {} 
+ 
 TVector<TSchemeEntry> TListDirectoryResult::GetChildren() const {
     CheckStatusOk("TListDirectoryResult::GetChildren");
-    return Children_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
+    return Children_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 TSchemeClient::TSchemeClient(const TDriver& driver, const TCommonClientSettings& settings)
     : Impl_(new TImpl(CreateInternalInterface(driver), settings))
-{}
-
-TAsyncStatus TSchemeClient::MakeDirectory(const TString& path, const TMakeDirectorySettings& settings) {
-    return Impl_->MakeDirectory(path, settings);
-}
-
-TAsyncStatus TSchemeClient::RemoveDirectory(const TString &path, const TRemoveDirectorySettings& settings) {
-    return Impl_->RemoveDirectory(path, settings);
-}
-
-TAsyncDescribePathResult TSchemeClient::DescribePath(const TString& path, const TDescribePathSettings& settings) {
-    return Impl_->DescribePath(path, settings);
-}
-
-TAsyncListDirectoryResult TSchemeClient::ListDirectory(const TString& path,
+{} 
+ 
+TAsyncStatus TSchemeClient::MakeDirectory(const TString& path, const TMakeDirectorySettings& settings) { 
+    return Impl_->MakeDirectory(path, settings); 
+} 
+ 
+TAsyncStatus TSchemeClient::RemoveDirectory(const TString &path, const TRemoveDirectorySettings& settings) { 
+    return Impl_->RemoveDirectory(path, settings); 
+} 
+ 
+TAsyncDescribePathResult TSchemeClient::DescribePath(const TString& path, const TDescribePathSettings& settings) { 
+    return Impl_->DescribePath(path, settings); 
+} 
+ 
+TAsyncListDirectoryResult TSchemeClient::ListDirectory(const TString& path, 
     const TListDirectorySettings& settings)
-{
+{ 
     return Impl_->ListDirectory(path, settings);
-}
-
-TAsyncStatus TSchemeClient::ModifyPermissions(const TString& path,
+} 
+ 
+TAsyncStatus TSchemeClient::ModifyPermissions(const TString& path, 
     const TModifyPermissionsSettings& data)
 {
     return Impl_->ModifyPermissions(path, data);
 }
 
-} // namespace NScheme
-} // namespace NYdb
+} // namespace NScheme 
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_scheme/scheme.h b/ydb/public/sdk/cpp/client/ydb_scheme/scheme.h
index 9d762b14c6..74e88619c1 100644
--- a/ydb/public/sdk/cpp/client/ydb_scheme/scheme.h
+++ b/ydb/public/sdk/cpp/client/ydb_scheme/scheme.h
@@ -1,10 +1,10 @@
-#pragma once
-
+#pragma once 
+ 
 #include <ydb/public/sdk/cpp/client/ydb_driver/driver.h>
-
-namespace NYdb {
-namespace NScheme {
-
+ 
+namespace NYdb { 
+namespace NScheme { 
+ 
 ////////////////////////////////////////////////////////////////////////////////
 
 struct TPermissions {
@@ -32,33 +32,33 @@ enum class ESchemeEntryType : i32 {
     Replication = 16,
 };
 
-struct TSchemeEntry {
-    TString Name;
-    TString Owner;
+struct TSchemeEntry { 
+    TString Name; 
+    TString Owner; 
     ESchemeEntryType Type;
     TVector<TPermissions> EffectivePermissions;
     TVector<TPermissions> Permissions;
     ui64 SizeBytes = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TDescribePathResult;
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+class TDescribePathResult; 
 class TListDirectoryResult;
-
-using TAsyncDescribePathResult = NThreading::TFuture<TDescribePathResult>;
+ 
+using TAsyncDescribePathResult = NThreading::TFuture<TDescribePathResult>; 
 using TAsyncListDirectoryResult = NThreading::TFuture<TListDirectoryResult>;
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct TMakeDirectorySettings : public TOperationRequestSettings<TMakeDirectorySettings> {};
-
-struct TRemoveDirectorySettings : public TOperationRequestSettings<TRemoveDirectorySettings> {};
-
-struct TDescribePathSettings : public TOperationRequestSettings<TDescribePathSettings> {};
-
-struct TListDirectorySettings : public TOperationRequestSettings<TListDirectorySettings> {};
-
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+struct TMakeDirectorySettings : public TOperationRequestSettings<TMakeDirectorySettings> {}; 
+ 
+struct TRemoveDirectorySettings : public TOperationRequestSettings<TRemoveDirectorySettings> {}; 
+ 
+struct TDescribePathSettings : public TOperationRequestSettings<TDescribePathSettings> {}; 
+ 
+struct TListDirectorySettings : public TOperationRequestSettings<TListDirectorySettings> {}; 
+ 
 enum class EModifyPermissionsAction {
     Grant,
     Revoke,
@@ -66,7 +66,7 @@ enum class EModifyPermissionsAction {
     Chown
 };
 
-struct TModifyPermissionsSettings : public TOperationRequestSettings<TModifyPermissionsSettings> {
+struct TModifyPermissionsSettings : public TOperationRequestSettings<TModifyPermissionsSettings> { 
     TModifyPermissionsSettings& AddGrantPermissions(const TPermissions& permissions) {
         AddAction(EModifyPermissionsAction::Grant, permissions);
         return *this;
@@ -95,50 +95,50 @@ struct TModifyPermissionsSettings : public TOperationRequestSettings<TModifyPerm
     }
 };
 
-class TSchemeClient {
-    class TImpl;
-
-public:
+class TSchemeClient { 
+    class TImpl; 
+ 
+public: 
     TSchemeClient(const TDriver& driver, const TCommonClientSettings& settings = TCommonClientSettings());
-
-    TAsyncStatus MakeDirectory(const TString& path,
-        const TMakeDirectorySettings& settings = TMakeDirectorySettings());
-
-    TAsyncStatus RemoveDirectory(const TString& path,
-        const TRemoveDirectorySettings& settings = TRemoveDirectorySettings());
-
-    TAsyncDescribePathResult DescribePath(const TString& path,
-        const TDescribePathSettings& settings = TDescribePathSettings());
-
+ 
+    TAsyncStatus MakeDirectory(const TString& path, 
+        const TMakeDirectorySettings& settings = TMakeDirectorySettings()); 
+ 
+    TAsyncStatus RemoveDirectory(const TString& path, 
+        const TRemoveDirectorySettings& settings = TRemoveDirectorySettings()); 
+ 
+    TAsyncDescribePathResult DescribePath(const TString& path, 
+        const TDescribePathSettings& settings = TDescribePathSettings()); 
+ 
     TAsyncListDirectoryResult ListDirectory(const TString& path,
         const TListDirectorySettings& settings = TListDirectorySettings());
-
+ 
     TAsyncStatus ModifyPermissions(const TString& path,
         const TModifyPermissionsSettings& data);
 
-private:
-    std::shared_ptr<TImpl> Impl_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TDescribePathResult : public TStatus {
-public:
-    TDescribePathResult(TSchemeEntry&& entry, TStatus&& status);
-    TSchemeEntry GetEntry() const;
-
-private:
-    TSchemeEntry Entry_;
-};
-
+private: 
+    std::shared_ptr<TImpl> Impl_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+class TDescribePathResult : public TStatus { 
+public: 
+    TDescribePathResult(TSchemeEntry&& entry, TStatus&& status); 
+    TSchemeEntry GetEntry() const; 
+ 
+private: 
+    TSchemeEntry Entry_; 
+}; 
+ 
 class TListDirectoryResult : public TDescribePathResult {
-public:
+public: 
     TListDirectoryResult(TVector<TSchemeEntry>&& children, TSchemeEntry&& self, TStatus&& status);
-    TVector<TSchemeEntry> GetChildren() const;
-
-private:
-    TVector<TSchemeEntry> Children_;
-};
-
-} // namespace NScheme
-} // namespace NYdb
+    TVector<TSchemeEntry> GetChildren() const; 
+ 
+private: 
+    TVector<TSchemeEntry> Children_; 
+}; 
+ 
+} // namespace NScheme 
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_table/impl/client_session.h b/ydb/public/sdk/cpp/client/ydb_table/impl/client_session.h
index 1c33edc333..1069ad9755 100644
--- a/ydb/public/sdk/cpp/client/ydb_table/impl/client_session.h
+++ b/ydb/public/sdk/cpp/client/ydb_table/impl/client_session.h
@@ -1,5 +1,5 @@
 #pragma once
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_table/table.h>
 #include <ydb/public/sdk/cpp/client/impl/ydb_endpoints/endpoints.h>
 
@@ -8,24 +8,24 @@
 #include <library/cpp/cache/cache.h>
 
 #include <util/datetime/base.h>
-
+ 
 #include <functional>
 
-namespace NYdb {
-namespace NTable {
-
-////////////////////////////////////////////////////////////////////////////////
-
+namespace NYdb { 
+namespace NTable { 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 using TSessionInspectorFn = std::function<void(TAsyncCreateSessionResult future)>;
 
 class TSession::TImpl : public TEndpointObj {
-    friend class TTableClient;
-    friend class TSession;
-
+    friend class TTableClient; 
+    friend class TSession; 
+ 
 #ifdef YDB_IMPL_TABLE_CLIENT_SESSION_UT
 public:
 #endif
-    TImpl(const TString& sessionId, const TString& endpoint, bool useQueryCache, ui32 queryCacheSize);
+    TImpl(const TString& sessionId, const TString& endpoint, bool useQueryCache, ui32 queryCacheSize); 
 public:
     enum EState {
         S_STANDALONE,
@@ -35,19 +35,19 @@ public:
         S_DISCONNECTED,
         S_CLOSING
     };
-
-    struct TDataQueryInfo {
-        TString QueryId;
-        ::google::protobuf::Map<TString, Ydb::Type> ParameterTypes;
-
-        TDataQueryInfo() {}
-
-        TDataQueryInfo(const TString& queryId,
-            const ::google::protobuf::Map<TString, Ydb::Type>& parameterTypes)
-            : QueryId(queryId)
-            , ParameterTypes(parameterTypes) {}
-    };
-public:
+ 
+    struct TDataQueryInfo { 
+        TString QueryId; 
+        ::google::protobuf::Map<TString, Ydb::Type> ParameterTypes; 
+ 
+        TDataQueryInfo() {} 
+ 
+        TDataQueryInfo(const TString& queryId, 
+            const ::google::protobuf::Map<TString, Ydb::Type>& parameterTypes) 
+            : QueryId(queryId) 
+            , ParameterTypes(parameterTypes) {} 
+    }; 
+public: 
     ~TImpl();
 
     const TString& GetId() const;
@@ -69,15 +69,15 @@ public:
     void ScheduleTimeToTouchFast(TDuration interval, bool updateTimeInPast);
     TInstant GetTimeToTouchFast() const;
     TInstant GetTimeInPastFast() const;
-
+ 
     // SetTimeInterval/GetTimeInterval, are not atomic!
     void SetTimeInterval(TDuration interval);
     TDuration GetTimeInterval() const;
 
     const TLRUCache<TString, TDataQueryInfo>& GetQueryCacheUnsafe() const;
 
-    static std::function<void(TSession::TImpl*)> GetSmartDeleter(std::shared_ptr<TTableClient::TImpl> client);
-
+    static std::function<void(TSession::TImpl*)> GetSmartDeleter(std::shared_ptr<TTableClient::TImpl> client); 
+ 
     static TSessionInspectorFn GetSessionInspector(
         NThreading::TPromise<TCreateSessionResult>& promise,
         std::shared_ptr<TTableClient::TImpl> client,
@@ -88,8 +88,8 @@ private:
     const TString SessionId_;
     const TString Endpoint_;
     EState State_;
-    bool UseQueryCache_;
-    TLRUCache<TString, TDataQueryInfo> QueryCache_;
+    bool UseQueryCache_; 
+    TLRUCache<TString, TDataQueryInfo> QueryCache_; 
     TAdaptiveLock Lock_;
     TInstant TimeToTouch_;
     TInstant TimeInPast_;
@@ -101,5 +101,5 @@ private:
     bool NeedUpdateActiveCounter_;
 };
 
-} // namespace NTable
-} // namespace NYdb
+} // namespace NTable 
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_table/impl/request_migrator_ut.cpp b/ydb/public/sdk/cpp/client/ydb_table/impl/request_migrator_ut.cpp
index 714890a324..c565fe02e4 100644
--- a/ydb/public/sdk/cpp/client/ydb_table/impl/request_migrator_ut.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_table/impl/request_migrator_ut.cpp
@@ -46,7 +46,7 @@ public:
 
     void Exec() {
        while (Cont_.load()) {
-           auto rowSession = new TSession::TImpl("someSessionId", Hostname_, true, 100);
+           auto rowSession = new TSession::TImpl("someSessionId", Hostname_, true, 100); 
            if (Cb_(rowSession)) {
                Processed_++;
            }
@@ -148,7 +148,7 @@ Y_UNIT_TEST_SUITE(RequestMigratorTest) {
 
             migrator.SetHost("host1");
 
-            auto session = new TSession::TImpl("someSessionId", "host1", true, 100);
+            auto session = new TSession::TImpl("someSessionId", "host1", true, 100); 
             UNIT_ASSERT(migrator.DoCheckAndMigrate(session, client));
             delete session;
 
diff --git a/ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.cpp b/ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.cpp
index 106b848c83..641c96949e 100644
--- a/ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.cpp
@@ -19,29 +19,29 @@ TQueryStats::TQueryStats(const Ydb::TableStats::QueryStats& proto) {
     Impl_->Proto = proto;
 }
 
-TString TQueryStats::ToString(bool withPlan) const {
-    auto proto = Impl_->Proto;
-
-    if (!withPlan) {
-        proto.clear_query_plan();
-        proto.clear_query_ast();
-    }
-
+TString TQueryStats::ToString(bool withPlan) const { 
+    auto proto = Impl_->Proto; 
+ 
+    if (!withPlan) { 
+        proto.clear_query_plan(); 
+        proto.clear_query_ast(); 
+    } 
+ 
     TString res;
-    ::google::protobuf::TextFormat::PrintToString(proto, &res);
+    ::google::protobuf::TextFormat::PrintToString(proto, &res); 
     return res;
 }
 
-TMaybe<TString> TQueryStats::GetPlan() const {
-    auto proto = Impl_->Proto;
-
-    if (proto.query_plan().empty()) {
-        return {};
-    }
-
-    return proto.query_plan();
-}
-
+TMaybe<TString> TQueryStats::GetPlan() const { 
+    auto proto = Impl_->Proto; 
+ 
+    if (proto.query_plan().empty()) { 
+        return {}; 
+    } 
+ 
+    return proto.query_plan(); 
+} 
+ 
 TDuration TQueryStats::GetTotalDuration() const {
     return TDuration::MicroSeconds(Impl_->Proto.total_duration_us());
 }
diff --git a/ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.h b/ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.h
index 355c271dc2..7e9ee21315 100644
--- a/ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.h
+++ b/ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <util/generic/maybe.h>
+#include <util/generic/maybe.h> 
 #include <util/generic/string.h>
 
 #include <memory>
@@ -8,44 +8,44 @@
 class TDuration;
 
 namespace Ydb {
-    namespace TableStats {
-        class QueryStats;
-    }
+    namespace TableStats { 
+        class QueryStats; 
+    } 
 
-    namespace Table {
-        class QueryStatsCollection;
-    }
+    namespace Table { 
+        class QueryStatsCollection; 
+    } 
 }
 
 namespace NYdb {
 
 class TProtoAccessor;
 
-namespace NScripting {
-
-class TScriptingClient;
+namespace NScripting { 
+ 
+class TScriptingClient; 
 class TYqlResultPartIterator;
-
-} // namespace NScripting
-
+ 
+} // namespace NScripting 
+ 
 namespace NTable {
 
-enum class ECollectQueryStatsMode {
+enum class ECollectQueryStatsMode { 
     None = 0,  // Stats collection is disabled
     Basic = 1, // Aggregated stats of reads, updates and deletes per table
     Full = 2   // Add per-stage execution profile and query plan on top of Basic mode
-};
-
+}; 
+ 
 class TQueryStats {
     friend class TTableClient;
     friend class NYdb::TProtoAccessor;
-    friend class NYdb::NScripting::TScriptingClient;
+    friend class NYdb::NScripting::TScriptingClient; 
     friend class NYdb::NScripting::TYqlResultPartIterator;
     friend class TScanQueryPartIterator;
 
 public:
-    TString ToString(bool withPlan = false) const;
-    TMaybe<TString> GetPlan() const;
+    TString ToString(bool withPlan = false) const; 
+    TMaybe<TString> GetPlan() const; 
     TDuration GetTotalDuration() const;
     TDuration GetTotalCpuTime() const;
 
diff --git a/ydb/public/sdk/cpp/client/ydb_table/table.cpp b/ydb/public/sdk/cpp/client/ydb_table/table.cpp
index 610fec3884..fbf12c8027 100644
--- a/ydb/public/sdk/cpp/client/ydb_table/table.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_table/table.cpp
@@ -1,5 +1,5 @@
 #include "table.h"
-
+ 
 #define INCLUDE_YDB_INTERNAL_H
 #include <ydb/public/sdk/cpp/client/impl/ydb_internal/table_helpers/helpers.h>
 #include <ydb/public/sdk/cpp/client/impl/ydb_internal/make_request/make.h>
@@ -16,18 +16,18 @@
 #include <ydb/public/sdk/cpp/client/ydb_table/impl/request_migrator.h>
 
 #include <library/cpp/cache/cache.h>
-
+ 
 #include <util/generic/map.h>
 #include <util/random/random.h>
 #include <util/string/join.h>
-
+ 
 #include <unordered_map>
 
-namespace NYdb {
-namespace NTable {
-
-using namespace NThreading;
-
+namespace NYdb { 
+namespace NTable { 
+ 
+using namespace NThreading; 
+ 
 //How often run session pool keep alive check
 constexpr TDuration PERIODIC_ACTION_INTERVAL = TDuration::Seconds(5);
 //How often run settler keep alive check
@@ -38,7 +38,7 @@ constexpr TDuration MIGRATION_GET_SESSION_CLIENT_TIMEOUT = TDuration::Seconds(2)
 constexpr ui64 KEEP_ALIVE_RANDOM_FRACTION = 4;
 constexpr TDuration KEEP_ALIVE_CLIENT_TIMEOUT = TDuration::Seconds(5);
 constexpr ui64 PERIODIC_ACTION_BATCH_SIZE = 10; //Max number of tasks to perform during one interval
-constexpr ui32 MAX_BACKOFF_DURATION_MS = TDuration::Hours(1).MilliSeconds();
+constexpr ui32 MAX_BACKOFF_DURATION_MS = TDuration::Hours(1).MilliSeconds(); 
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -247,7 +247,7 @@ static TInstant ProtobufTimestampToTInstant(const NProtoBuf::Timestamp& timestam
     return TInstant::MicroSeconds(lastModificationUs);
 }
 
-class TTableDescription::TImpl {
+class TTableDescription::TImpl { 
     using EUnit = TValueSinceUnixEpochModeSettings::EUnit;
 
     template <typename TProto>
@@ -259,13 +259,13 @@ class TTableDescription::TImpl {
     {
         // primary key
         for (const auto& pk : proto.primary_key()) {
-            PrimaryKey_.push_back(pk);
-        }
+            PrimaryKey_.push_back(pk); 
+        } 
 
         // columns
         for (const auto& col : proto.columns()) {
             Columns_.emplace_back(col.name(), col.type(), col.family());
-        }
+        } 
 
         // indexes
         Indexes_.reserve(proto.indexesSize());
@@ -346,11 +346,11 @@ public:
         PermissionToSchemeEntry(Proto_.self().permissions(), &Permissions_);
         PermissionToSchemeEntry(Proto_.self().effective_permissions(), &EffectivePermissions_);
 
-        TMaybe<TValue> leftValue;
+        TMaybe<TValue> leftValue; 
         for (const auto& bound : Proto_.shard_key_bounds()) {
-            TMaybe<TKeyBound> fromBound = leftValue
-                ? TKeyBound::Inclusive(*leftValue)
-                : TMaybe<TKeyBound>();
+            TMaybe<TKeyBound> fromBound = leftValue 
+                ? TKeyBound::Inclusive(*leftValue) 
+                : TMaybe<TKeyBound>(); 
 
             TValue value(TType(bound.type()), bound.value());
             const TKeyBound& toBound = TKeyBound::Exclusive(value);
@@ -358,7 +358,7 @@ public:
             Ranges_.emplace_back(TKeyRange(fromBound, toBound));
             leftValue = value;
         }
-
+ 
         for (const auto& shardStats : Proto_.table_stats().partition_stats()) {
             PartitionStats_.emplace_back(
                 TPartitionStats{shardStats.rows_estimate(), shardStats.store_size()}
@@ -372,11 +372,11 @@ public:
         TableStats.ModificationTime = ProtobufTimestampToTInstant(Proto_.table_stats().modification_time());
         TableStats.CreationTime = ProtobufTimestampToTInstant(Proto_.table_stats().creation_time());
 
-        if (describeSettings.WithKeyShardBoundary_) {
-            Ranges_.emplace_back(TKeyRange(
-                leftValue ? TKeyBound::Inclusive(*leftValue) : TMaybe<TKeyBound>(),
-                TMaybe<TKeyBound>()));
-        }
+        if (describeSettings.WithKeyShardBoundary_) { 
+            Ranges_.emplace_back(TKeyRange( 
+                leftValue ? TKeyBound::Inclusive(*leftValue) : TMaybe<TKeyBound>(), 
+                TMaybe<TKeyBound>())); 
+        } 
     }
 
     struct TCreateTableRequestTag {}; // to avoid delegation cycle
@@ -407,22 +407,22 @@ public:
             default:
                 break;
         }
-    }
-
-    TImpl() = default;
-
+    } 
+ 
+    TImpl() = default; 
+ 
     const Ydb::Table::DescribeTableResult& GetProto() const {
         return Proto_;
     }
 
     void AddColumn(const TString& name, const Ydb::Type& type, const TString& family) {
         Columns_.emplace_back(name, type, family);
-    }
-
-    void SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns) {
-        PrimaryKey_ = primaryKeyColumns;
-    }
-
+    } 
+ 
+    void SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns) { 
+        PrimaryKey_ = primaryKeyColumns; 
+    } 
+ 
     void AddSecondaryIndex(const TString& indexName, EIndexType type, const TVector<TString>& indexColumns) {
         Indexes_.emplace_back(TIndexDescription(indexName, type, indexColumns));
     }
@@ -485,14 +485,14 @@ public:
         ReadReplicasSettings_ = TReadReplicasSettings(mode, readReplicasCount);
     }
 
-    const TVector<TString>& GetPrimaryKeyColumns() const {
-        return PrimaryKey_;
-    }
-
+    const TVector<TString>& GetPrimaryKeyColumns() const { 
+        return PrimaryKey_; 
+    } 
+ 
     const TVector<TTableColumn>& GetColumns() const {
-        return Columns_;
-    }
-
+        return Columns_; 
+    } 
+ 
     const TVector<TIndexDescription>& GetIndexDescriptions() const {
         return Indexes_;
     }
@@ -569,10 +569,10 @@ public:
         return ReadReplicasSettings_;
     }
 
-private:
+private: 
     Ydb::Table::DescribeTableResult Proto_;
     TStorageSettings StorageSettings_;
-    TVector<TString> PrimaryKey_;
+    TVector<TString> PrimaryKey_; 
     TVector<TTableColumn> Columns_;
     TVector<TIndexDescription> Indexes_;
     TMaybe<TTtlSettings> TtlSettings_;
@@ -592,29 +592,29 @@ private:
     TMaybe<TReadReplicasSettings> ReadReplicasSettings_;
     bool HasStorageSettings_ = false;
     bool HasPartitioningSettings_ = false;
-};
-
-TTableDescription::TTableDescription()
-    : Impl_(new TImpl)
-{
-}
-
-TTableDescription::TTableDescription(Ydb::Table::DescribeTableResult&& desc,
-    const TDescribeTableSettings& describeSettings)
-    : Impl_(new TImpl(std::move(desc), describeSettings))
-{
-}
-
+}; 
+ 
+TTableDescription::TTableDescription() 
+    : Impl_(new TImpl) 
+{ 
+} 
+ 
+TTableDescription::TTableDescription(Ydb::Table::DescribeTableResult&& desc, 
+    const TDescribeTableSettings& describeSettings) 
+    : Impl_(new TImpl(std::move(desc), describeSettings)) 
+{ 
+} 
+ 
 TTableDescription::TTableDescription(const Ydb::Table::CreateTableRequest& request)
     : Impl_(new TImpl(request, TImpl::TCreateTableRequestTag()))
 {
 }
 
-const TVector<TString>& TTableDescription::GetPrimaryKeyColumns() const {
-    return Impl_->GetPrimaryKeyColumns();
-}
-
-TVector<TColumn> TTableDescription::GetColumns() const {
+const TVector<TString>& TTableDescription::GetPrimaryKeyColumns() const { 
+    return Impl_->GetPrimaryKeyColumns(); 
+} 
+ 
+TVector<TColumn> TTableDescription::GetColumns() const { 
     // Conversion to TColumn for API compatibility
     const auto& columns = Impl_->GetColumns();
     TVector<TColumn> legacy(Reserve(columns.size()));
@@ -625,9 +625,9 @@ TVector<TColumn> TTableDescription::GetColumns() const {
 }
 
 TVector<TTableColumn> TTableDescription::GetTableColumns() const {
-    return Impl_->GetColumns();
-}
-
+    return Impl_->GetColumns(); 
+} 
+ 
 TVector<TIndexDescription> TTableDescription::GetIndexDescriptions() const {
     return Impl_->GetIndexDescriptions();
 }
@@ -636,7 +636,7 @@ TMaybe<TTtlSettings> TTableDescription::GetTtlSettings() const {
     return Impl_->GetTtlSettings();
 }
 
-const TString& TTableDescription::GetOwner() const {
+const TString& TTableDescription::GetOwner() const { 
     return Impl_->GetOwner();
 }
 
@@ -644,7 +644,7 @@ const TVector<NScheme::TPermissions>& TTableDescription::GetPermissions() const
     return Impl_->GetPermissions();
 }
 
-const TVector<NScheme::TPermissions>& TTableDescription::GetEffectivePermissions() const {
+const TVector<NScheme::TPermissions>& TTableDescription::GetEffectivePermissions() const { 
     return Impl_->GetEffectivePermissions();
 }
 
@@ -654,12 +654,12 @@ const TVector<TKeyRange>& TTableDescription::GetKeyRanges() const {
 
 void TTableDescription::AddColumn(const TString& name, const Ydb::Type& type, const TString& family) {
     Impl_->AddColumn(name, type, family);
-}
-
-void TTableDescription::SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns) {
-    Impl_->SetPrimaryKeyColumns(primaryKeyColumns);
-}
-
+} 
+ 
+void TTableDescription::SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns) { 
+    Impl_->SetPrimaryKeyColumns(primaryKeyColumns); 
+} 
+ 
 void TTableDescription::AddSecondaryIndex(const TString& indexName, EIndexType type, const TVector<TString>& indexColumns) {
     Impl_->AddSecondaryIndex(indexName, type, indexColumns);
 }
@@ -874,8 +874,8 @@ void TTableDescription::SerializeTo(Ydb::Table::CreateTableRequest& request) con
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 class TStorageSettingsBuilder::TImpl {
 public:
     Ydb::Table::StorageSettings Proto;
@@ -995,16 +995,16 @@ TColumnFamilyDescription TColumnFamilyBuilder::Build() const {
 ////////////////////////////////////////////////////////////////////////////////
 
 TTableBuilder& TTableBuilder::AddNullableColumn(const TString& name, const EPrimitiveType& type, const TString& family) {
-    auto columnType = TTypeBuilder()
-        .BeginOptional()
-            .Primitive(type)
-        .EndOptional()
-        .Build();
-
+    auto columnType = TTypeBuilder() 
+        .BeginOptional() 
+            .Primitive(type) 
+        .EndOptional() 
+        .Build(); 
+ 
     TableDescription_.AddColumn(name, TProtoAccessor::GetProto(columnType), family);
-    return *this;
-}
-
+    return *this; 
+} 
+ 
 TTableBuilder& TTableBuilder::AddNullableColumn(const TString& name, const TDecimalType& type, const TString& family) {
     auto columnType = TTypeBuilder()
         .BeginOptional()
@@ -1033,16 +1033,16 @@ TTableBuilder& TTableBuilder::AddNonNullableColumn(const TString& name, const TD
     return *this;
 }
 
-TTableBuilder& TTableBuilder::SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns) {
-    TableDescription_.SetPrimaryKeyColumns(primaryKeyColumns);
-    return *this;
-}
-
-TTableBuilder& TTableBuilder::SetPrimaryKeyColumn(const TString& primaryKeyColumn) {
-    TableDescription_.SetPrimaryKeyColumns(TVector<TString>{primaryKeyColumn});
-    return *this;
-}
-
+TTableBuilder& TTableBuilder::SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns) { 
+    TableDescription_.SetPrimaryKeyColumns(primaryKeyColumns); 
+    return *this; 
+} 
+ 
+TTableBuilder& TTableBuilder::SetPrimaryKeyColumn(const TString& primaryKeyColumn) { 
+    TableDescription_.SetPrimaryKeyColumns(TVector<TString>{primaryKeyColumn}); 
+    return *this; 
+} 
+ 
 TTableBuilder& TTableBuilder::AddSecondaryIndex(const TString& indexName, EIndexType type, const TVector<TString>& indexColumns, const TVector<TString>& dataColumns) {
     TableDescription_.AddSecondaryIndex(indexName, type, indexColumns, dataColumns);
     return *this;
@@ -1167,12 +1167,12 @@ TTableBuilder& TTableBuilder::SetReadReplicasSettings(TReadReplicasSettings::EMo
     return *this;
 }
 
-TTableDescription TTableBuilder::Build() {
-    return TableDescription_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
+TTableDescription TTableBuilder::Build() { 
+    return TableDescription_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 class TTablePartIterator::TReaderImpl {
 public:
     using TSelf = TTablePartIterator::TReaderImpl;
@@ -1196,8 +1196,8 @@ public:
         return Finished_;
     }
 
-    TAsyncSimpleStreamPart<TResultSet> ReadNext(std::shared_ptr<TSelf> self) {
-        auto promise = NThreading::NewPromise<TSimpleStreamPart<TResultSet>>();
+    TAsyncSimpleStreamPart<TResultSet> ReadNext(std::shared_ptr<TSelf> self) { 
+        auto promise = NThreading::NewPromise<TSimpleStreamPart<TResultSet>>(); 
         // Capture self - guarantee no dtor call during the read
         auto readCb = [self, promise](TGRpcStatus&& grpcStatus) mutable {
             if (!grpcStatus.Ok()) {
@@ -1229,7 +1229,7 @@ TTablePartIterator::TTablePartIterator(
     , ReaderImpl_(impl)
 {}
 
-TAsyncSimpleStreamPart<TResultSet> TTablePartIterator::ReadNext() {
+TAsyncSimpleStreamPart<TResultSet> TTablePartIterator::ReadNext() { 
     if (ReaderImpl_->IsFinished())
         RaiseError("Attempt to perform read on invalid or finished stream");
     return ReaderImpl_->ReadNext(ReaderImpl_);
@@ -1237,40 +1237,40 @@ TAsyncSimpleStreamPart<TResultSet> TTablePartIterator::ReadNext() {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TScanQueryPartIterator::TReaderImpl {
-public:
-    using TSelf = TScanQueryPartIterator::TReaderImpl;
-    using TResponse = Ydb::Table::ExecuteScanQueryPartialResponse;
-    using TStreamProcessorPtr = NGrpc::IStreamRequestReadProcessor<TResponse>::TPtr;
-    using TReadCallback = NGrpc::IStreamRequestReadProcessor<TResponse>::TReadCallback;
-    using TGRpcStatus = NGrpc::TGrpcStatus;
-    using TBatchReadResult = std::pair<TResponse, TGRpcStatus>;
-
+class TScanQueryPartIterator::TReaderImpl { 
+public: 
+    using TSelf = TScanQueryPartIterator::TReaderImpl; 
+    using TResponse = Ydb::Table::ExecuteScanQueryPartialResponse; 
+    using TStreamProcessorPtr = NGrpc::IStreamRequestReadProcessor<TResponse>::TPtr; 
+    using TReadCallback = NGrpc::IStreamRequestReadProcessor<TResponse>::TReadCallback; 
+    using TGRpcStatus = NGrpc::TGrpcStatus; 
+    using TBatchReadResult = std::pair<TResponse, TGRpcStatus>; 
+ 
     TReaderImpl(TStreamProcessorPtr streamProcessor, const TString& endpoint)
-        : StreamProcessor_(streamProcessor)
-        , Finished_(false)
-        , Endpoint_(endpoint)
-    {}
-
-    ~TReaderImpl() {
-        StreamProcessor_->Cancel();
-    }
-
-    bool IsFinished() const {
-        return Finished_;
-    }
-
-    TAsyncScanQueryPart ReadNext(std::shared_ptr<TSelf> self) {
-        auto promise = NThreading::NewPromise<TScanQueryPart>();
-        // Capture self - guarantee no dtor call during the read
-        auto readCb = [self, promise](TGRpcStatus&& grpcStatus) mutable {
-            if (!grpcStatus.Ok()) {
-                self->Finished_ = true;
+        : StreamProcessor_(streamProcessor) 
+        , Finished_(false) 
+        , Endpoint_(endpoint) 
+    {} 
+ 
+    ~TReaderImpl() { 
+        StreamProcessor_->Cancel(); 
+    } 
+ 
+    bool IsFinished() const { 
+        return Finished_; 
+    } 
+ 
+    TAsyncScanQueryPart ReadNext(std::shared_ptr<TSelf> self) { 
+        auto promise = NThreading::NewPromise<TScanQueryPart>(); 
+        // Capture self - guarantee no dtor call during the read 
+        auto readCb = [self, promise](TGRpcStatus&& grpcStatus) mutable { 
+            if (!grpcStatus.Ok()) { 
+                self->Finished_ = true; 
                 promise.SetValue({TStatus(TPlainStatus(grpcStatus, self->Endpoint_))});
-            } else {
-                NYql::TIssues issues;
-                NYql::IssuesFromMessage(self->Response_.issues(), issues);
-                EStatus clientStatus = static_cast<EStatus>(self->Response_.status());
+            } else { 
+                NYql::TIssues issues; 
+                NYql::IssuesFromMessage(self->Response_.issues(), issues); 
+                EStatus clientStatus = static_cast<EStatus>(self->Response_.status()); 
                 // TODO: Add headers for streaming calls.
                 TPlainStatus plainStatus{clientStatus, std::move(issues), self->Endpoint_, {}};
                 TStatus status{std::move(plainStatus)};
@@ -1280,39 +1280,39 @@ public:
                     queryStats = TQueryStats(self->Response_.result().query_stats());
                 }
 
-                if (self->Response_.result().has_result_set()) {
+                if (self->Response_.result().has_result_set()) { 
                     promise.SetValue({std::move(status),
                         TResultSet(std::move(*self->Response_.mutable_result()->mutable_result_set())), queryStats});
-                } else {
+                } else { 
                     promise.SetValue({std::move(status), queryStats});
-                }
-            }
-        };
-        StreamProcessor_->Read(&Response_, readCb);
-        return promise.GetFuture();
-    }
-private:
-    TStreamProcessorPtr StreamProcessor_;
-    TResponse Response_;
-    bool Finished_;
-    TString Endpoint_;
-};
-
-TScanQueryPartIterator::TScanQueryPartIterator(
-    std::shared_ptr<TReaderImpl> impl,
+                } 
+            } 
+        }; 
+        StreamProcessor_->Read(&Response_, readCb); 
+        return promise.GetFuture(); 
+    } 
+private: 
+    TStreamProcessorPtr StreamProcessor_; 
+    TResponse Response_; 
+    bool Finished_; 
+    TString Endpoint_; 
+}; 
+ 
+TScanQueryPartIterator::TScanQueryPartIterator( 
+    std::shared_ptr<TReaderImpl> impl, 
     TPlainStatus&& status)
     : TStatus(std::move(status))
-    , ReaderImpl_(impl)
-{}
-
-TAsyncScanQueryPart TScanQueryPartIterator::ReadNext() {
-    if (ReaderImpl_->IsFinished())
-        RaiseError("Attempt to perform read on invalid or finished stream");
-    return ReaderImpl_->ReadNext(ReaderImpl_);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
+    , ReaderImpl_(impl) 
+{} 
+ 
+TAsyncScanQueryPart TScanQueryPartIterator::ReadNext() { 
+    if (ReaderImpl_->IsFinished()) 
+        RaiseError("Attempt to perform read on invalid or finished stream"); 
+    return ReaderImpl_->ReadNext(ReaderImpl_); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 class TSessionPoolImpl {
     typedef TAsyncCreateSessionResult
         (*TAwareSessonProvider)
@@ -1397,16 +1397,16 @@ static bool IsSessionCloseRequested(const TStatus& status) {
     return false;
 }
 
-template<typename TResponse>
-NThreading::TFuture<TResponse> InjectSessionStatusInterception(
-        std::shared_ptr<TSession::TImpl>& impl, NThreading::TFuture<TResponse> asyncResponse,
+template<typename TResponse> 
+NThreading::TFuture<TResponse> InjectSessionStatusInterception( 
+        std::shared_ptr<TSession::TImpl>& impl, NThreading::TFuture<TResponse> asyncResponse, 
         bool updateTimeout,
         TDuration timeout,
-        std::function<void(const TResponse&, TSession::TImpl&)> cb = {})
-{
-    auto promise = NThreading::NewPromise<TResponse>();
+        std::function<void(const TResponse&, TSession::TImpl&)> cb = {}) 
+{ 
+    auto promise = NThreading::NewPromise<TResponse>(); 
     asyncResponse.Subscribe([impl, promise, cb, updateTimeout, timeout](NThreading::TFuture<TResponse> future) mutable {
-        Y_VERIFY(future.HasValue());
+        Y_VERIFY(future.HasValue()); 
 
         // TResponse can hold refcounted user provided data (TSession for example)
         // and we do not want to have copy of it (for example it can cause delay dtor call)
@@ -1424,7 +1424,7 @@ NThreading::TFuture<TResponse> InjectSessionStatusInterception(
         } else if (status.GetStatus() == EStatus::SESSION_BUSY) {
             impl->MarkDisconnected();
         } else if (status.GetStatus() == EStatus::BAD_SESSION) {
-            impl->MarkBroken();
+            impl->MarkBroken(); 
         } else if (IsSessionCloseRequested(status)) {
             impl->MarkAsClosing();
         } else {
@@ -1437,38 +1437,38 @@ NThreading::TFuture<TResponse> InjectSessionStatusInterception(
             if (updateTimeout && status.GetStatus() != EStatus::CLIENT_RESOURCE_EXHAUSTED) {
                 impl->ScheduleTimeToTouch(RandomizeThreshold(timeout), impl->GetState() == TSession::TImpl::EState::S_ACTIVE);
             }
-        }
-        if (cb) {
-            cb(value, *impl);
-        }
+        } 
+        if (cb) { 
+            cb(value, *impl); 
+        } 
         impl.reset();
         promise.SetValue(std::move(value));
-    });
-    return promise.GetFuture();
-}
-
+    }); 
+    return promise.GetFuture(); 
+} 
+ 
 static ui32 CalcBackoffTime(const TBackoffSettings& settings, ui32 retryNumber) {
     ui32 backoffSlots = 1 << std::min(retryNumber, settings.Ceiling_);
-    TDuration maxDuration = settings.SlotDuration_ * backoffSlots;
-
-    double uncertaintyRatio = std::max(std::min(settings.UncertainRatio_, 1.0), 0.0);
-    double uncertaintyMultiplier = RandomNumber<double>() * uncertaintyRatio - uncertaintyRatio + 1.0;
-
-    double durationMs = round(maxDuration.MilliSeconds() * uncertaintyMultiplier);
-
-    return std::max(std::min(durationMs, (double)MAX_BACKOFF_DURATION_MS), 0.0);
+    TDuration maxDuration = settings.SlotDuration_ * backoffSlots; 
+ 
+    double uncertaintyRatio = std::max(std::min(settings.UncertainRatio_, 1.0), 0.0); 
+    double uncertaintyMultiplier = RandomNumber<double>() * uncertaintyRatio - uncertaintyRatio + 1.0; 
+ 
+    double durationMs = round(maxDuration.MilliSeconds() * uncertaintyMultiplier); 
+ 
+    return std::max(std::min(durationMs, (double)MAX_BACKOFF_DURATION_MS), 0.0); 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class TTableClient::TImpl: public TClientImplCommon<TTableClient::TImpl>, public IMigratorClient {
-public:
+public: 
     using TReadTableStreamProcessorPtr = TTablePartIterator::TReaderImpl::TStreamProcessorPtr;
-    using TScanQueryProcessorPtr = TScanQueryPartIterator::TReaderImpl::TStreamProcessorPtr;
-
-    TImpl(std::shared_ptr<TGRpcConnectionsImpl>&& connections, const TClientSettings& settings)
+    using TScanQueryProcessorPtr = TScanQueryPartIterator::TReaderImpl::TStreamProcessorPtr; 
+ 
+    TImpl(std::shared_ptr<TGRpcConnectionsImpl>&& connections, const TClientSettings& settings) 
         : TClientImplCommon(std::move(connections), settings)
-        , Settings_(settings)
+        , Settings_(settings) 
         , SessionPool_(Settings_.SessionPoolSettings_.MaxActiveSessions_)
         , SettlerPool_(0)
     {
@@ -1484,7 +1484,7 @@ public:
             NSdkStats::TStatCollector::TSessionPoolStatCollector::EStatCollectorType::SETTLERPOOL
         ));
     }
-
+ 
     ~TImpl() {
         RequestMigrator_.Wait();
 
@@ -1939,17 +1939,17 @@ public:
     TAsyncCreateSessionResult CreateSession(const TCreateSessionSettings& settings, bool standalone,
         TString preferedLocation = TString())
     {
-        auto request = MakeOperationRequest<Ydb::Table::CreateSessionRequest>(settings);
-
-        auto createSessionPromise = NewPromise<TCreateSessionResult>();
+        auto request = MakeOperationRequest<Ydb::Table::CreateSessionRequest>(settings); 
+ 
+        auto createSessionPromise = NewPromise<TCreateSessionResult>(); 
         auto self = shared_from_this();
-
+ 
         auto createSessionExtractor = [createSessionPromise, self, standalone]
             (google::protobuf::Any* any, TPlainStatus status) mutable {
                 Ydb::Table::CreateSessionResult result;
-                if (any) {
-                    any->UnpackTo(&result);
-                }
+                if (any) { 
+                    any->UnpackTo(&result); 
+                } 
                 auto session = TSession(self, result.session_id(), status.Endpoint);
                 if (status.Ok()) {
                     if (standalone) {
@@ -1963,26 +1963,26 @@ public:
                     session.SessionImpl_->MarkBroken();
                 }
                 TCreateSessionResult val(TStatus(std::move(status)), std::move(session));
-                createSessionPromise.SetValue(std::move(val));
-            };
-
+                createSessionPromise.SetValue(std::move(val)); 
+            }; 
+ 
         Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::CreateSessionRequest, Ydb::Table::CreateSessionResponse>(
             std::move(request),
-            createSessionExtractor,
+            createSessionExtractor, 
             &Ydb::Table::V1::TableService::Stub::AsyncCreateSession,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_,
             preferedLocation);
-
+ 
         std::weak_ptr<TDbDriverState> state = DbDriverState_;
 
         return createSessionPromise.GetFuture();
-    }
-
+    } 
+ 
     TAsyncKeepAliveResult KeepAlive(const TSession::TImpl* session, const TKeepAliveSettings& settings) {
-        auto request = MakeOperationRequest<Ydb::Table::KeepAliveRequest>(settings);
+        auto request = MakeOperationRequest<Ydb::Table::KeepAliveRequest>(settings); 
         request.set_session_id(session->GetId());
 
         auto keepAliveResultPromise = NewPromise<TKeepAliveResult>();
@@ -2013,34 +2013,34 @@ public:
         Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::KeepAliveRequest, Ydb::Table::KeepAliveResponse>(
             std::move(request),
             keepAliveExtractor,
-            &Ydb::Table::V1::TableService::Stub::AsyncKeepAlive,
+            &Ydb::Table::V1::TableService::Stub::AsyncKeepAlive, 
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_,
             session->GetEndpoint());
 
         return keepAliveResultPromise.GetFuture();
     }
 
-    TFuture<TStatus> CreateTable(Ydb::Table::CreateTableRequest&& request, const TCreateTableSettings& settings)
-    {
-        return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::CreateTableRequest,Ydb::Table::CreateTableResponse>(
+    TFuture<TStatus> CreateTable(Ydb::Table::CreateTableRequest&& request, const TCreateTableSettings& settings) 
+    { 
+        return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::CreateTableRequest,Ydb::Table::CreateTableResponse>( 
             std::move(request),
-            &Ydb::Table::V1::TableService::Stub::AsyncCreateTable,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-    }
-
-    TFuture<TStatus> AlterTable(Ydb::Table::AlterTableRequest&& request, const TAlterTableSettings& settings)
-    {
-        return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::AlterTableRequest, Ydb::Table::AlterTableResponse>(
+            &Ydb::Table::V1::TableService::Stub::AsyncCreateTable, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+    } 
+ 
+    TFuture<TStatus> AlterTable(Ydb::Table::AlterTableRequest&& request, const TAlterTableSettings& settings) 
+    { 
+        return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::AlterTableRequest, Ydb::Table::AlterTableResponse>( 
             std::move(request),
-            &Ydb::Table::V1::TableService::Stub::AsyncAlterTable,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-    }
-
+            &Ydb::Table::V1::TableService::Stub::AsyncAlterTable, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+    } 
+ 
     TAsyncOperation AlterTableLong(Ydb::Table::AlterTableRequest&& request, const TAlterTableSettings& settings)
     {
         using Ydb::Table::V1::TableService;
@@ -2053,28 +2053,28 @@ public:
             settings.ClientTimeout_);
     }
 
-    TFuture<TStatus> CopyTable(const TString& sessionId, const TString& src, const TString& dst,
-        const TCopyTableSettings& settings)
-    {
-        auto request = MakeOperationRequest<Ydb::Table::CopyTableRequest>(settings);
-        request.set_session_id(sessionId);
-        request.set_source_path(src);
-        request.set_destination_path(dst);
-
-        return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::CopyTableRequest, Ydb::Table::CopyTableResponse>(
+    TFuture<TStatus> CopyTable(const TString& sessionId, const TString& src, const TString& dst, 
+        const TCopyTableSettings& settings) 
+    { 
+        auto request = MakeOperationRequest<Ydb::Table::CopyTableRequest>(settings); 
+        request.set_session_id(sessionId); 
+        request.set_source_path(src); 
+        request.set_destination_path(dst); 
+ 
+        return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::CopyTableRequest, Ydb::Table::CopyTableResponse>( 
             std::move(request),
-            &Ydb::Table::V1::TableService::Stub::AsyncCopyTable,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-    }
-
-    TFuture<TStatus> CopyTables(Ydb::Table::CopyTablesRequest&& request, const TCopyTablesSettings& settings)
+            &Ydb::Table::V1::TableService::Stub::AsyncCopyTable, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+    } 
+ 
+    TFuture<TStatus> CopyTables(Ydb::Table::CopyTablesRequest&& request, const TCopyTablesSettings& settings) 
     {
         return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::CopyTablesRequest, Ydb::Table::CopyTablesResponse>(
             std::move(request),
             &Ydb::Table::V1::TableService::Stub::AsyncCopyTables,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
     }
 
     TFuture<TStatus> RenameTables(Ydb::Table::RenameTablesRequest&& request, const TRenameTablesSettings& settings)
@@ -2086,26 +2086,26 @@ public:
             settings.ClientTimeout_);
     }
 
-    TFuture<TStatus> DropTable(const TString& sessionId, const TString& path, const TDropTableSettings& settings) {
-        auto request = MakeOperationRequest<Ydb::Table::DropTableRequest>(settings);
-        request.set_session_id(sessionId);
-        request.set_path(path);
-
-        return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::DropTableRequest, Ydb::Table::DropTableResponse>(
+    TFuture<TStatus> DropTable(const TString& sessionId, const TString& path, const TDropTableSettings& settings) { 
+        auto request = MakeOperationRequest<Ydb::Table::DropTableRequest>(settings); 
+        request.set_session_id(sessionId); 
+        request.set_path(path); 
+ 
+        return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::DropTableRequest, Ydb::Table::DropTableResponse>( 
             std::move(request),
-            &Ydb::Table::V1::TableService::Stub::AsyncDropTable,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-    }
-
+            &Ydb::Table::V1::TableService::Stub::AsyncDropTable, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+    } 
+ 
     TAsyncDescribeTableResult DescribeTable(const TString& sessionId, const TString& path, const TDescribeTableSettings& settings) {
-        auto request = MakeOperationRequest<Ydb::Table::DescribeTableRequest>(settings);
-        request.set_session_id(sessionId);
-        request.set_path(path);
+        auto request = MakeOperationRequest<Ydb::Table::DescribeTableRequest>(settings); 
+        request.set_session_id(sessionId); 
+        request.set_path(path); 
         if (settings.WithKeyShardBoundary_) {
             request.set_include_shard_key_bounds(true);
         }
-
+ 
         if (settings.WithTableStatistics_) {
             request.set_include_table_stats(true);
         }
@@ -2114,266 +2114,266 @@ public:
             request.set_include_partition_stats(true);
         }
 
-        auto promise = NewPromise<TDescribeTableResult>();
-
+        auto promise = NewPromise<TDescribeTableResult>(); 
+ 
         auto extractor = [promise, settings]
             (google::protobuf::Any* any, TPlainStatus status) mutable {
                 Ydb::Table::DescribeTableResult result;
-                if (any) {
-                    any->UnpackTo(&result);
-                }
+                if (any) { 
+                    any->UnpackTo(&result); 
+                } 
                 TDescribeTableResult describeTableResult(TStatus(std::move(status)),
-                    std::move(result), settings);
-                promise.SetValue(std::move(describeTableResult));
-            };
-
+                    std::move(result), settings); 
+                promise.SetValue(std::move(describeTableResult)); 
+            }; 
+ 
         Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::DescribeTableRequest, Ydb::Table::DescribeTableResponse>(
             std::move(request),
-            extractor,
+            extractor, 
             &Ydb::Table::V1::TableService::Stub::AsyncDescribeTable,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-
-        return promise.GetFuture();
-    }
-
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
     template<typename TParamsType>
-    TAsyncDataQueryResult ExecuteDataQuery(TSession& session, const TString& query, const TTxControl& txControl,
+    TAsyncDataQueryResult ExecuteDataQuery(TSession& session, const TString& query, const TTxControl& txControl, 
         TParamsType params, const TExecDataQuerySettings& settings)
-    {
+    { 
         auto maybeQuery = session.SessionImpl_->GetQueryFromCache(query, Settings_.AllowRequestMigration_);
-        if (maybeQuery) {
-            TDataQuery dataQuery(session, query, maybeQuery->QueryId, maybeQuery->ParameterTypes);
-            return ExecuteDataQuery(session, dataQuery, txControl, params, settings, true);
-        }
-
+        if (maybeQuery) { 
+            TDataQuery dataQuery(session, query, maybeQuery->QueryId, maybeQuery->ParameterTypes); 
+            return ExecuteDataQuery(session, dataQuery, txControl, params, settings, true); 
+        } 
+ 
         CacheMissCounter.Inc();
 
-        return InjectSessionStatusInterception(session.SessionImpl_,
+        return InjectSessionStatusInterception(session.SessionImpl_, 
             ExecuteDataQueryInternal(session, query, txControl, params, settings, false),
             true, GetMinTimeToTouch(Settings_.SessionPoolSettings_));
-    }
-
+    } 
+ 
     template<typename TParamsType>
-    TAsyncDataQueryResult ExecuteDataQuery(TSession& session, const TDataQuery& dataQuery, const TTxControl& txControl,
+    TAsyncDataQueryResult ExecuteDataQuery(TSession& session, const TDataQuery& dataQuery, const TTxControl& txControl, 
         TParamsType params, const TExecDataQuerySettings& settings,
-        bool fromCache)
-    {
+        bool fromCache) 
+    { 
         TString queryKey = dataQuery.Impl_->GetTextHash();
         auto cb = [queryKey](const TDataQueryResult& result, TSession::TImpl& session) {
-            if (result.GetStatus() == EStatus::NOT_FOUND) {
+            if (result.GetStatus() == EStatus::NOT_FOUND) { 
                 session.InvalidateQueryInCache(queryKey);
-            }
-        };
-
+            } 
+        }; 
+ 
         return InjectSessionStatusInterception<TDataQueryResult>(
-            session.SessionImpl_,
-            session.Client_->ExecuteDataQueryInternal(session, dataQuery, txControl, params, settings, fromCache),
+            session.SessionImpl_, 
+            session.Client_->ExecuteDataQueryInternal(session, dataQuery, txControl, params, settings, fromCache), 
             true,
             GetMinTimeToTouch(session.Client_->Settings_.SessionPoolSettings_),
-            cb);
-    }
-
-    TAsyncPrepareQueryResult PrepareDataQuery(const TSession& session, const TString& query,
-        const TPrepareDataQuerySettings& settings)
-    {
-        auto request = MakeOperationRequest<Ydb::Table::PrepareDataQueryRequest>(settings);
+            cb); 
+    } 
+ 
+    TAsyncPrepareQueryResult PrepareDataQuery(const TSession& session, const TString& query, 
+        const TPrepareDataQuerySettings& settings) 
+    { 
+        auto request = MakeOperationRequest<Ydb::Table::PrepareDataQueryRequest>(settings); 
         request.set_session_id(session.GetId());
-        request.set_yql_text(query);
-
-        auto promise = NewPromise<TPrepareQueryResult>();
-
+        request.set_yql_text(query); 
+ 
+        auto promise = NewPromise<TPrepareQueryResult>(); 
+ 
         //See ExecuteDataQueryInternal for explanation
         auto sessionPtr = new TSession(session);
         auto extractor = [promise, sessionPtr, query]
             (google::protobuf::Any* any, TPlainStatus status) mutable {
-                TDataQuery dataQuery(*sessionPtr, query, "");
-
-                if (any) {
+                TDataQuery dataQuery(*sessionPtr, query, ""); 
+ 
+                if (any) { 
                     Ydb::Table::PrepareQueryResult result;
-                    any->UnpackTo(&result);
-
+                    any->UnpackTo(&result); 
+ 
                     if (status.Ok()) {
-                        dataQuery = TDataQuery(*sessionPtr, query, result.query_id(), result.parameters_types());
+                        dataQuery = TDataQuery(*sessionPtr, query, result.query_id(), result.parameters_types()); 
                         sessionPtr->SessionImpl_->AddQueryToCache(dataQuery);
-                    }
-                }
-
+                    } 
+                } 
+ 
                 TPrepareQueryResult prepareQueryResult(TStatus(std::move(status)),
-                    dataQuery, false);
-                delete sessionPtr;
-                promise.SetValue(std::move(prepareQueryResult));
-            };
-
+                    dataQuery, false); 
+                delete sessionPtr; 
+                promise.SetValue(std::move(prepareQueryResult)); 
+            }; 
+ 
         CollectQuerySize(query, QuerySizeHistogram);
 
         Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::PrepareDataQueryRequest, Ydb::Table::PrepareDataQueryResponse>(
             std::move(request),
-            extractor,
+            extractor, 
             &Ydb::Table::V1::TableService::Stub::AsyncPrepareDataQuery,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_,
             session.SessionImpl_->Endpoint_);
-
-        return promise.GetFuture();
-    }
-
-    TAsyncStatus ExecuteSchemeQuery(const TString& sessionId, const TString& query,
-        const TExecSchemeQuerySettings& settings)
-    {
-        auto request = MakeOperationRequest<Ydb::Table::ExecuteSchemeQueryRequest>(settings);
-        request.set_session_id(sessionId);
-        request.set_yql_text(query);
-
+ 
+        return promise.GetFuture(); 
+    } 
+ 
+    TAsyncStatus ExecuteSchemeQuery(const TString& sessionId, const TString& query, 
+        const TExecSchemeQuerySettings& settings) 
+    { 
+        auto request = MakeOperationRequest<Ydb::Table::ExecuteSchemeQueryRequest>(settings); 
+        request.set_session_id(sessionId); 
+        request.set_yql_text(query); 
+ 
         return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::ExecuteSchemeQueryRequest, Ydb::Table::ExecuteSchemeQueryResponse>(
             std::move(request),
-            &Ydb::Table::V1::TableService::Stub::AsyncExecuteSchemeQuery,
-            TRpcRequestSettings::Make(settings),
-            settings.ClientTimeout_);
-    }
-
-    TAsyncBeginTransactionResult BeginTransaction(const TSession& session, const TTxSettings& txSettings,
-        const TBeginTxSettings& settings)
-    {
-        auto request = MakeOperationRequest<Ydb::Table::BeginTransactionRequest>(settings);
+            &Ydb::Table::V1::TableService::Stub::AsyncExecuteSchemeQuery, 
+            TRpcRequestSettings::Make(settings), 
+            settings.ClientTimeout_); 
+    } 
+ 
+    TAsyncBeginTransactionResult BeginTransaction(const TSession& session, const TTxSettings& txSettings, 
+        const TBeginTxSettings& settings) 
+    { 
+        auto request = MakeOperationRequest<Ydb::Table::BeginTransactionRequest>(settings); 
         request.set_session_id(session.GetId());
         SetTxSettings(txSettings, request.mutable_tx_settings());
-
-        auto promise = NewPromise<TBeginTransactionResult>();
-
+ 
+        auto promise = NewPromise<TBeginTransactionResult>(); 
+ 
         auto extractor = [promise, session]
             (google::protobuf::Any* any, TPlainStatus status) mutable {
-                TString txId;
-                if (any) {
+                TString txId; 
+                if (any) { 
                     Ydb::Table::BeginTransactionResult result;
-                    any->UnpackTo(&result);
-                    txId = result.tx_meta().id();
-                }
-
+                    any->UnpackTo(&result); 
+                    txId = result.tx_meta().id(); 
+                } 
+ 
                 TBeginTransactionResult beginTxResult(TStatus(std::move(status)),
-                    TTransaction(session, txId));
-                promise.SetValue(std::move(beginTxResult));
-            };
-
+                    TTransaction(session, txId)); 
+                promise.SetValue(std::move(beginTxResult)); 
+            }; 
+ 
         Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::BeginTransactionRequest, Ydb::Table::BeginTransactionResponse>(
             std::move(request),
-            extractor,
+            extractor, 
             &Ydb::Table::V1::TableService::Stub::AsyncBeginTransaction,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_,
             session.SessionImpl_->GetEndpoint());
-
-        return promise.GetFuture();
-    }
-
+ 
+        return promise.GetFuture(); 
+    } 
+ 
     TAsyncCommitTransactionResult CommitTransaction(const TSession& session, const TTransaction& tx,
-        const TCommitTxSettings& settings)
-    {
-        auto request = MakeOperationRequest<Ydb::Table::CommitTransactionRequest>(settings);
+        const TCommitTxSettings& settings) 
+    { 
+        auto request = MakeOperationRequest<Ydb::Table::CommitTransactionRequest>(settings); 
         request.set_session_id(session.GetId());
-        request.set_tx_id(tx.GetId());
-        request.set_collect_stats(GetStatsCollectionMode(settings.CollectQueryStats_));
-
-        auto promise = NewPromise<TCommitTransactionResult>();
-
+        request.set_tx_id(tx.GetId()); 
+        request.set_collect_stats(GetStatsCollectionMode(settings.CollectQueryStats_)); 
+ 
+        auto promise = NewPromise<TCommitTransactionResult>(); 
+ 
         auto extractor = [promise]
-            (google::protobuf::Any* any, TPlainStatus status) mutable {
-                TMaybe<TQueryStats> queryStats;
-                if (any) {
-                    Ydb::Table::CommitTransactionResult result;
-                    any->UnpackTo(&result);
-
-                    if (result.has_query_stats()) {
-                        queryStats = TQueryStats(result.query_stats());
-                    }
-                }
-
+            (google::protobuf::Any* any, TPlainStatus status) mutable { 
+                TMaybe<TQueryStats> queryStats; 
+                if (any) { 
+                    Ydb::Table::CommitTransactionResult result; 
+                    any->UnpackTo(&result); 
+ 
+                    if (result.has_query_stats()) { 
+                        queryStats = TQueryStats(result.query_stats()); 
+                    } 
+                } 
+ 
                 TCommitTransactionResult commitTxResult(TStatus(std::move(status)), queryStats);
-                promise.SetValue(std::move(commitTxResult));
-            };
-
-        Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::CommitTransactionRequest, Ydb::Table::CommitTransactionResponse>(
+                promise.SetValue(std::move(commitTxResult)); 
+            }; 
+ 
+        Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::CommitTransactionRequest, Ydb::Table::CommitTransactionResponse>( 
             std::move(request),
-            extractor,
-            &Ydb::Table::V1::TableService::Stub::AsyncCommitTransaction,
-            DbDriverState_,
-            INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            extractor, 
+            &Ydb::Table::V1::TableService::Stub::AsyncCommitTransaction, 
+            DbDriverState_, 
+            INITIAL_DEFERRED_CALL_DELAY, 
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_,
             session.SessionImpl_->GetEndpoint());
-
-        return promise.GetFuture();
-    }
-
+ 
+        return promise.GetFuture(); 
+    } 
+ 
     TAsyncStatus RollbackTransaction(const TSession& session, const TTransaction& tx,
-        const TRollbackTxSettings& settings)
-    {
-        auto request = MakeOperationRequest<Ydb::Table::RollbackTransactionRequest>(settings);
+        const TRollbackTxSettings& settings) 
+    { 
+        auto request = MakeOperationRequest<Ydb::Table::RollbackTransactionRequest>(settings); 
         request.set_session_id(session.GetId());
-        request.set_tx_id(tx.GetId());
-
+        request.set_tx_id(tx.GetId()); 
+ 
         return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::RollbackTransactionRequest, Ydb::Table::RollbackTransactionResponse>(
             std::move(request),
-            &Ydb::Table::V1::TableService::Stub::AsyncRollbackTransaction,
-            TRpcRequestSettings::Make(settings),
+            &Ydb::Table::V1::TableService::Stub::AsyncRollbackTransaction, 
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_,
             session.SessionImpl_->GetEndpoint());
-    }
-
+    } 
+ 
     TAsyncExplainDataQueryResult ExplainDataQuery(const TSession& session, const TString& query,
-        const TExplainDataQuerySettings& settings)
-    {
-        auto request = MakeOperationRequest<Ydb::Table::ExplainDataQueryRequest>(settings);
+        const TExplainDataQuerySettings& settings) 
+    { 
+        auto request = MakeOperationRequest<Ydb::Table::ExplainDataQueryRequest>(settings); 
         request.set_session_id(session.GetId());
-        request.set_yql_text(query);
-
-        auto promise = NewPromise<TExplainQueryResult>();
-
+        request.set_yql_text(query); 
+ 
+        auto promise = NewPromise<TExplainQueryResult>(); 
+ 
         auto extractor = [promise]
             (google::protobuf::Any* any, TPlainStatus status) mutable {
-                TString ast;
-                TString plan;
-                if (any) {
+                TString ast; 
+                TString plan; 
+                if (any) { 
                     Ydb::Table::ExplainQueryResult result;
-                    any->UnpackTo(&result);
-                    ast = result.query_ast();
-                    plan = result.query_plan();
-                }
+                    any->UnpackTo(&result); 
+                    ast = result.query_ast(); 
+                    plan = result.query_plan(); 
+                } 
                 TExplainQueryResult val(TStatus(std::move(status)),
-                    std::move(plan), std::move(ast));
-                promise.SetValue(std::move(val));
-            };
-
+                    std::move(plan), std::move(ast)); 
+                promise.SetValue(std::move(val)); 
+            }; 
+ 
         Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::ExplainDataQueryRequest, Ydb::Table::ExplainDataQueryResponse>(
             std::move(request),
-            extractor,
+            extractor, 
             &Ydb::Table::V1::TableService::Stub::AsyncExplainDataQuery,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_,
             session.SessionImpl_->GetEndpoint());
-
-        return promise.GetFuture();
-    }
-
-    static void SetTypedValue(Ydb::TypedValue* protoValue, const TValue& value) {
-        protoValue->mutable_type()->CopyFrom(TProtoAccessor::GetProto(value.GetType()));
-        protoValue->mutable_value()->CopyFrom(TProtoAccessor::GetProto(value));
-    }
-
+ 
+        return promise.GetFuture(); 
+    } 
+ 
+    static void SetTypedValue(Ydb::TypedValue* protoValue, const TValue& value) { 
+        protoValue->mutable_type()->CopyFrom(TProtoAccessor::GetProto(value.GetType())); 
+        protoValue->mutable_value()->CopyFrom(TProtoAccessor::GetProto(value)); 
+    } 
+ 
     NThreading::TFuture<std::pair<TPlainStatus, TReadTableStreamProcessorPtr>> ReadTable(
         const TString& sessionId,
         const TString& path,
         const TReadTableSettings& settings)
     {
-        auto request = MakeRequest<Ydb::Table::ReadTableRequest>();
+        auto request = MakeRequest<Ydb::Table::ReadTableRequest>(); 
         request.set_session_id(sessionId);
         request.set_path(path);
         request.set_ordered(settings.Ordered_);
@@ -2417,23 +2417,23 @@ public:
             },
             &Ydb::Table::V1::TableService::Stub::AsyncStreamReadTable,
             DbDriverState_,
-            TRpcRequestSettings::Make(settings));
+            TRpcRequestSettings::Make(settings)); 
 
         return promise.GetFuture();
 
     }
 
     TAsyncStatus Close(const TSession::TImpl* sessionImpl, const TCloseSessionSettings& settings) {
-        auto request = MakeOperationRequest<Ydb::Table::DeleteSessionRequest>(settings);
+        auto request = MakeOperationRequest<Ydb::Table::DeleteSessionRequest>(settings); 
         request.set_session_id(sessionImpl->GetId());
         return RunSimple<Ydb::Table::V1::TableService, Ydb::Table::DeleteSessionRequest, Ydb::Table::DeleteSessionResponse>(
             std::move(request),
-            &Ydb::Table::V1::TableService::Stub::AsyncDeleteSession,
-            TRpcRequestSettings::Make(settings),
+            &Ydb::Table::V1::TableService::Stub::AsyncDeleteSession, 
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_,
             sessionImpl->GetEndpoint());
-    }
-
+    } 
+ 
     TAsyncStatus CloseInternal(const TSession::TImpl* sessionImpl) {
         static const auto internalCloseSessionSettings = TCloseSessionSettings()
                 .ClientTimeout(TDuration::Seconds(2));
@@ -2545,7 +2545,7 @@ public:
             &Ydb::Table::V1::TableService::Stub::AsyncBulkUpsert,
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_);
 
         return promise.GetFuture();
@@ -2591,74 +2591,74 @@ public:
         return promise.GetFuture();
     }
 
-    TFuture<std::pair<TPlainStatus, TScanQueryProcessorPtr>> StreamExecuteScanQueryInternal(const TString& query,
-        const ::google::protobuf::Map<TString, Ydb::TypedValue>* params,
-        const TStreamExecScanQuerySettings& settings)
-    {
-        auto request = MakeRequest<Ydb::Table::ExecuteScanQueryRequest>();
-        request.mutable_query()->set_yql_text(query);
-
-        if (params) {
-            *request.mutable_parameters() = *params;
-        }
-
+    TFuture<std::pair<TPlainStatus, TScanQueryProcessorPtr>> StreamExecuteScanQueryInternal(const TString& query, 
+        const ::google::protobuf::Map<TString, Ydb::TypedValue>* params, 
+        const TStreamExecScanQuerySettings& settings) 
+    { 
+        auto request = MakeRequest<Ydb::Table::ExecuteScanQueryRequest>(); 
+        request.mutable_query()->set_yql_text(query); 
+ 
+        if (params) { 
+            *request.mutable_parameters() = *params; 
+        } 
+ 
         if (settings.Explain_) {
             request.set_mode(Ydb::Table::ExecuteScanQueryRequest::MODE_EXPLAIN);
         } else {
             request.set_mode(Ydb::Table::ExecuteScanQueryRequest::MODE_EXEC);
         }
-
+ 
         request.set_collect_stats(GetStatsCollectionMode(settings.CollectQueryStats_));
 
-        auto promise = NewPromise<std::pair<TPlainStatus, TScanQueryProcessorPtr>>();
-
-        Connections_->StartReadStream<
-            Ydb::Table::V1::TableService,
-            Ydb::Table::ExecuteScanQueryRequest,
-            Ydb::Table::ExecuteScanQueryPartialResponse>
-        (
-            std::move(request),
-            [promise] (TPlainStatus status, TScanQueryProcessorPtr processor) mutable {
-                promise.SetValue(std::make_pair(status, processor));
-            },
-            &Ydb::Table::V1::TableService::Stub::AsyncStreamExecuteScanQuery,
-            DbDriverState_,
-            TRpcRequestSettings::Make(settings)
-        );
-
-        return promise.GetFuture();
-    }
-
-    TAsyncScanQueryPartIterator StreamExecuteScanQuery(const TString& query,
-        const ::google::protobuf::Map<TString, Ydb::TypedValue>* params,
-        const TStreamExecScanQuerySettings& settings)
-    {
-        auto promise = NewPromise<TScanQueryPartIterator>();
-
+        auto promise = NewPromise<std::pair<TPlainStatus, TScanQueryProcessorPtr>>(); 
+ 
+        Connections_->StartReadStream< 
+            Ydb::Table::V1::TableService, 
+            Ydb::Table::ExecuteScanQueryRequest, 
+            Ydb::Table::ExecuteScanQueryPartialResponse> 
+        ( 
+            std::move(request), 
+            [promise] (TPlainStatus status, TScanQueryProcessorPtr processor) mutable { 
+                promise.SetValue(std::make_pair(status, processor)); 
+            }, 
+            &Ydb::Table::V1::TableService::Stub::AsyncStreamExecuteScanQuery, 
+            DbDriverState_, 
+            TRpcRequestSettings::Make(settings) 
+        ); 
+ 
+        return promise.GetFuture(); 
+    } 
+ 
+    TAsyncScanQueryPartIterator StreamExecuteScanQuery(const TString& query, 
+        const ::google::protobuf::Map<TString, Ydb::TypedValue>* params, 
+        const TStreamExecScanQuerySettings& settings) 
+    { 
+        auto promise = NewPromise<TScanQueryPartIterator>(); 
+ 
         auto iteratorCallback = [promise](TFuture<std::pair<TPlainStatus,
-            TTableClient::TImpl::TScanQueryProcessorPtr>> future) mutable
-        {
-            Y_ASSERT(future.HasValue());
-            auto pair = future.ExtractValue();
-            promise.SetValue(TScanQueryPartIterator(
-                pair.second
+            TTableClient::TImpl::TScanQueryProcessorPtr>> future) mutable 
+        { 
+            Y_ASSERT(future.HasValue()); 
+            auto pair = future.ExtractValue(); 
+            promise.SetValue(TScanQueryPartIterator( 
+                pair.second 
                     ? std::make_shared<TScanQueryPartIterator::TReaderImpl>(pair.second, pair.first.Endpoint)
-                    : nullptr,
+                    : nullptr, 
                 std::move(pair.first))
-            );
-        };
-
-        StreamExecuteScanQueryInternal(query, params, settings).Subscribe(iteratorCallback);
-        return promise.GetFuture();
-    }
-
+            ); 
+        }; 
+ 
+        StreamExecuteScanQueryInternal(query, params, settings).Subscribe(iteratorCallback); 
+        return promise.GetFuture(); 
+    } 
+ 
     static void CloseAndDeleteSession(
         std::unique_ptr<TSession::TImpl>&& impl,
         std::shared_ptr<TTableClient::TImpl> client);
-public:
-    TClientSettings Settings_;
-
-private:
+public: 
+    TClientSettings Settings_; 
+ 
+private: 
     static void SetParams(
         ::google::protobuf::Map<TString, Ydb::TypedValue>* params,
         Ydb::Table::ExecuteDataQueryRequest* request)
@@ -2712,33 +2712,33 @@ private:
     static void CollectQuerySize(const TDataQuery&, NSdkStats::TAtomicHistogram<NMonitoring::THistogram>&) {}
 
     template <typename TQueryType, typename TParamsType>
-    TAsyncDataQueryResult ExecuteDataQueryInternal(const TSession& session, const TQueryType& query,
+    TAsyncDataQueryResult ExecuteDataQueryInternal(const TSession& session, const TQueryType& query, 
         const TTxControl& txControl, TParamsType params,
-        const TExecDataQuerySettings& settings, bool fromCache)
-    {
-        auto request = MakeOperationRequest<Ydb::Table::ExecuteDataQueryRequest>(settings);
-        request.set_session_id(session.GetId());
-        auto txControlProto = request.mutable_tx_control();
-        txControlProto->set_commit_tx(txControl.CommitTx_);
-        if (txControl.TxId_) {
-            txControlProto->set_tx_id(*txControl.TxId_);
-        } else {
+        const TExecDataQuerySettings& settings, bool fromCache) 
+    { 
+        auto request = MakeOperationRequest<Ydb::Table::ExecuteDataQueryRequest>(settings); 
+        request.set_session_id(session.GetId()); 
+        auto txControlProto = request.mutable_tx_control(); 
+        txControlProto->set_commit_tx(txControl.CommitTx_); 
+        if (txControl.TxId_) { 
+            txControlProto->set_tx_id(*txControl.TxId_); 
+        } else { 
             SetTxSettings(txControl.BeginTx_, txControlProto->mutable_begin_tx());
-        }
+        } 
+ 
+        request.set_collect_stats(GetStatsCollectionMode(settings.CollectQueryStats_)); 
 
-        request.set_collect_stats(GetStatsCollectionMode(settings.CollectQueryStats_));
-
-        SetQuery(query, request.mutable_query());
+        SetQuery(query, request.mutable_query()); 
         CollectQuerySize(query, QuerySizeHistogram);
-
+ 
         SetParams(params, &request);
         CollectParams(params, ParamsSizeHistogram);
-
-        SetQueryCachePolicy(query, settings, request.mutable_query_cache_policy());
-
-        auto promise = NewPromise<TDataQueryResult>();
-        bool keepInCache = settings.KeepInQueryCache_ && settings.KeepInQueryCache_.GetRef();
-
+ 
+        SetQueryCachePolicy(query, settings, request.mutable_query_cache_policy()); 
+ 
+        auto promise = NewPromise<TDataQueryResult>(); 
+        bool keepInCache = settings.KeepInQueryCache_ && settings.KeepInQueryCache_.GetRef(); 
+ 
         // We don't want to delay call of TSession dtor, so we can't capture it by copy
         // otherwise we break session pool and other clients logic.
         // Same problem with TDataQuery and TTransaction
@@ -2750,107 +2750,107 @@ private:
         auto sessionPtr = new TSession(session);
         auto extractor = [promise, sessionPtr, query, fromCache, keepInCache]
             (google::protobuf::Any* any, TPlainStatus status) mutable {
-                TVector<TResultSet> res;
-                TMaybe<TTransaction> tx;
-                TMaybe<TDataQuery> dataQuery;
+                TVector<TResultSet> res; 
+                TMaybe<TTransaction> tx; 
+                TMaybe<TDataQuery> dataQuery; 
                 TMaybe<TQueryStats> queryStats;
-
-                auto queryText = GetQueryText(query);
-                if (any) {
-                    Ydb::Table::ExecuteQueryResult result;
-                    any->UnpackTo(&result);
-
-                    for (size_t i = 0; i < result.result_setsSize(); i++) {
-                        res.push_back(TResultSet(*result.mutable_result_sets(i)));
-                    }
-
-                    if (result.has_tx_meta()) {
+ 
+                auto queryText = GetQueryText(query); 
+                if (any) { 
+                    Ydb::Table::ExecuteQueryResult result; 
+                    any->UnpackTo(&result); 
+ 
+                    for (size_t i = 0; i < result.result_setsSize(); i++) { 
+                        res.push_back(TResultSet(*result.mutable_result_sets(i))); 
+                    } 
+ 
+                    if (result.has_tx_meta()) { 
                         tx = TTransaction(*sessionPtr, result.tx_meta().id());
-                    }
-
-                    if (result.has_query_meta()) {
-                        if (queryText) {
-                            auto& query_meta = result.query_meta();
+                    } 
+ 
+                    if (result.has_query_meta()) { 
+                        if (queryText) { 
+                            auto& query_meta = result.query_meta(); 
                             dataQuery = TDataQuery(*sessionPtr, *queryText, query_meta.id(), query_meta.parameters_types());
-                        }
-                    }
+                        } 
+                    } 
 
                     if (result.has_query_stats()) {
                         queryStats = TQueryStats(result.query_stats());
                     }
-                }
-
-                if (keepInCache && dataQuery && queryText) {
-                    sessionPtr->SessionImpl_->AddQueryToCache(*dataQuery);
-                }
-
+                } 
+ 
+                if (keepInCache && dataQuery && queryText) { 
+                    sessionPtr->SessionImpl_->AddQueryToCache(*dataQuery); 
+                } 
+ 
                 TDataQueryResult dataQueryResult(TStatus(std::move(status)),
                     std::move(res), tx, dataQuery, fromCache, queryStats);
 
                 delete sessionPtr;
                 tx.Clear();
                 dataQuery.Clear();
-                promise.SetValue(std::move(dataQueryResult));
-            };
-
-        Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::ExecuteDataQueryRequest, Ydb::Table::ExecuteDataQueryResponse>(
+                promise.SetValue(std::move(dataQueryResult)); 
+            }; 
+ 
+        Connections_->RunDeferred<Ydb::Table::V1::TableService, Ydb::Table::ExecuteDataQueryRequest, Ydb::Table::ExecuteDataQueryResponse>( 
             std::move(request),
-            extractor,
-            &Ydb::Table::V1::TableService::Stub::AsyncExecuteDataQuery,
+            extractor, 
+            &Ydb::Table::V1::TableService::Stub::AsyncExecuteDataQuery, 
             DbDriverState_,
             INITIAL_DEFERRED_CALL_DELAY,
-            TRpcRequestSettings::Make(settings),
+            TRpcRequestSettings::Make(settings), 
             settings.ClientTimeout_,
             session.SessionImpl_->Endpoint_);
-
-        return promise.GetFuture();
-    }
-
+ 
+        return promise.GetFuture(); 
+    } 
+ 
     static void SetTxSettings(const TTxSettings& txSettings, Ydb::Table::TransactionSettings* proto)
-    {
-        switch (txSettings.Mode_) {
-            case TTxSettings::TS_SERIALIZABLE_RW:
-                proto->mutable_serializable_read_write();
-                break;
-            case TTxSettings::TS_ONLINE_RO:
-                proto->mutable_online_read_only()->set_allow_inconsistent_reads(
-                    txSettings.OnlineSettings_.AllowInconsistentReads_);
-                break;
-            case TTxSettings::TS_STALE_RO:
-                proto->mutable_stale_read_only();
-                break;
-            default:
+    { 
+        switch (txSettings.Mode_) { 
+            case TTxSettings::TS_SERIALIZABLE_RW: 
+                proto->mutable_serializable_read_write(); 
+                break; 
+            case TTxSettings::TS_ONLINE_RO: 
+                proto->mutable_online_read_only()->set_allow_inconsistent_reads( 
+                    txSettings.OnlineSettings_.AllowInconsistentReads_); 
+                break; 
+            case TTxSettings::TS_STALE_RO: 
+                proto->mutable_stale_read_only(); 
+                break; 
+            default: 
                 throw TContractViolation("Unexpected transaction mode.");
-        }
-    }
-
+        } 
+    } 
+ 
     static void SetQuery(const TString& queryText, Ydb::Table::Query* query) {
-        query->set_yql_text(queryText);
-    }
-
+        query->set_yql_text(queryText); 
+    } 
+ 
     static void SetQuery(const TDataQuery& queryData, Ydb::Table::Query* query) {
-        query->set_id(queryData.GetId());
-    }
-
-    static void SetQueryCachePolicy(const TString&, const TExecDataQuerySettings& settings,
-        Ydb::Table::QueryCachePolicy* queryCachePolicy)
-    {
-        queryCachePolicy->set_keep_in_cache(settings.KeepInQueryCache_ ? settings.KeepInQueryCache_.GetRef() : false);
-    }
-
-    static void SetQueryCachePolicy(const TDataQuery&, const TExecDataQuerySettings& settings,
-        Ydb::Table::QueryCachePolicy* queryCachePolicy) {
-        queryCachePolicy->set_keep_in_cache(settings.KeepInQueryCache_ ? settings.KeepInQueryCache_.GetRef() : true);
-    }
-
-    static TMaybe<TString> GetQueryText(const TString& queryText) {
-        return queryText;
-    }
-
-    static TMaybe<TString> GetQueryText(const TDataQuery& queryData) {
-        return queryData.GetText();
-    }
-
+        query->set_id(queryData.GetId()); 
+    } 
+
+    static void SetQueryCachePolicy(const TString&, const TExecDataQuerySettings& settings, 
+        Ydb::Table::QueryCachePolicy* queryCachePolicy) 
+    { 
+        queryCachePolicy->set_keep_in_cache(settings.KeepInQueryCache_ ? settings.KeepInQueryCache_.GetRef() : false); 
+    } 
+ 
+    static void SetQueryCachePolicy(const TDataQuery&, const TExecDataQuerySettings& settings, 
+        Ydb::Table::QueryCachePolicy* queryCachePolicy) { 
+        queryCachePolicy->set_keep_in_cache(settings.KeepInQueryCache_ ? settings.KeepInQueryCache_.GetRef() : true); 
+    } 
+ 
+    static TMaybe<TString> GetQueryText(const TString& queryText) { 
+        return queryText; 
+    } 
+ 
+    static TMaybe<TString> GetQueryText(const TDataQuery& queryData) { 
+        return queryData.GetText(); 
+    } 
+ 
     static TAsyncCreateSessionResult SettlerAwareSessonProvider(
         std::shared_ptr<TTableClient::TImpl> client,
         const TCreateSessionSettings& settings);
@@ -2863,13 +2863,13 @@ public:
     NSdkStats::TAtomicCounter<NMonitoring::TRate> SessionRemovedDueBalancing;
     NSdkStats::TAtomicCounter<NMonitoring::TRate> RequestMigrated;
 
-private:
+private: 
     TSessionPoolImpl SessionPool_;
     TSessionPoolImpl SettlerPool_;
     TRequestMigrator RequestMigrator_;
     static const TKeepAliveSettings KeepAliveSettings;
-};
-
+}; 
+ 
 const TKeepAliveSettings TTableClient::TImpl::KeepAliveSettings = TKeepAliveSettings().ClientTimeout(KEEP_ALIVE_CLIENT_TIMEOUT);
 
 TSessionPoolImpl::TSessionPoolImpl(ui32 maxActiveSessions)
@@ -2980,9 +2980,9 @@ TAsyncCreateSessionResult TSessionPoolImpl::GetSession(
         sessionImpl->SetNeedUpdateActiveCounter(true);
 
         TCreateSessionResult val(TStatus(TPlainStatus()),
-            TSession(client, std::shared_ptr<TSession::TImpl>(
-                sessionImpl.release(),
-                TSession::TImpl::GetSmartDeleter(client))));
+            TSession(client, std::shared_ptr<TSession::TImpl>( 
+                sessionImpl.release(), 
+                TSession::TImpl::GetSmartDeleter(client)))); 
 
         client->ScheduleTaskUnsafe([createSessionPromise, val{std::move(val)}]() mutable {
             createSessionPromise.SetValue(std::move(val));
@@ -3182,20 +3182,20 @@ void TSessionPoolImpl::UpdateStats() {
     InPoolSessionsCounter_.Apply(Sessions_.size());
 }
 
-TTableClient::TTableClient(const TDriver& driver, const TClientSettings& settings)
+TTableClient::TTableClient(const TDriver& driver, const TClientSettings& settings) 
     : Impl_(new TImpl(CreateInternalInterface(driver), settings)) {
     Impl_->StartPeriodicSessionPoolTask();
     Impl_->StartPeriodicSettlerTask();
     Impl_->StartPeriodicHostScanTask();
     Impl_->InitStopper();
 }
-
-TAsyncCreateSessionResult TTableClient::CreateSession(const TCreateSessionSettings& settings) {
+ 
+TAsyncCreateSessionResult TTableClient::CreateSession(const TCreateSessionSettings& settings) { 
     // Returns standalone session
     return Impl_->CreateSession(settings, true);
-}
-
-TAsyncCreateSessionResult TTableClient::GetSession(const TCreateSessionSettings& settings) {
+} 
+ 
+TAsyncCreateSessionResult TTableClient::GetSession(const TCreateSessionSettings& settings) { 
     // Returns session from session pool
     return Impl_->GetSession(settings);
 }
@@ -3212,51 +3212,51 @@ i64 TTableClient::GetCurrentPoolSize() const {
     return Impl_->GetCurrentPoolSize();
 }
 
-TTableBuilder TTableClient::GetTableBuilder() {
-    return TTableBuilder();
-}
-
-TParamsBuilder TTableClient::GetParamsBuilder() {
+TTableBuilder TTableClient::GetTableBuilder() { 
+    return TTableBuilder(); 
+} 
+ 
+TParamsBuilder TTableClient::GetParamsBuilder() { 
     return TParamsBuilder();
-}
-
-TTypeBuilder TTableClient::GetTypeBuilder() {
+} 
+ 
+TTypeBuilder TTableClient::GetTypeBuilder() { 
     return TTypeBuilder();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct TRetryState {
-    using TAsyncFunc = std::function<TAsyncStatus()>;
-    using THandleStatusFunc = std::function<TAsyncStatus(const std::shared_ptr<TRetryState>& state,
-        const TStatus& status, const TAsyncFunc& func, ui32 retryNumber)>;
-
-    TMaybe<TSession> Session;
-    THandleStatusFunc HandleStatusFunc;
-};
-
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+struct TRetryState { 
+    using TAsyncFunc = std::function<TAsyncStatus()>; 
+    using THandleStatusFunc = std::function<TAsyncStatus(const std::shared_ptr<TRetryState>& state, 
+        const TStatus& status, const TAsyncFunc& func, ui32 retryNumber)>; 
+ 
+    TMaybe<TSession> Session; 
+    THandleStatusFunc HandleStatusFunc; 
+}; 
+ 
 static void Backoff(const TBackoffSettings& settings, ui32 retryNumber) {
     auto durationMs = CalcBackoffTime(settings, retryNumber);
-    Sleep(TDuration::MilliSeconds(durationMs));
-}
-
+    Sleep(TDuration::MilliSeconds(durationMs)); 
+} 
+ 
 class TRetryOperationContext : public TThrRefBase, TNonCopyable {
 public:
     using TRetryContextPtr = TIntrusivePtr<TRetryOperationContext>;
-
+ 
 protected:
     TRetryOperationSettings Settings;
     TTableClient TableClient;
     NThreading::TPromise<TStatus> Promise;
     ui32 RetryNumber;
-
+ 
 public:
     virtual void Execute() = 0;
 
     TAsyncStatus GetFuture() {
         return Promise.GetFuture();
     }
-
+ 
 protected:
     TRetryOperationContext(const TRetryOperationSettings& settings,
                            const TTableClient& tableClient)
@@ -3269,9 +3269,9 @@ protected:
     static void RunOp(TRetryContextPtr self) {
         self->Execute();
     }
-
+ 
     virtual void Reset() {}
-
+ 
     static void DoRetry(TRetryContextPtr self, bool fast) {
         self->TableClient.Impl_->AsyncBackoff(
                     fast ? self->Settings.FastBackoffSettings_ : self->Settings.SlowBackoffSettings_,
@@ -3281,7 +3281,7 @@ protected:
                     }
         );
     }
-
+ 
     static void HandleStatus(TRetryContextPtr self, const TStatus& status) {
         if (status.IsSuccess()) {
             return self->Promise.SetValue(status);
@@ -3290,31 +3290,31 @@ protected:
         if (self->RetryNumber >= self->Settings.MaxRetries_) {
             return self->Promise.SetValue(status);
         }
-
+ 
         self->RetryNumber++;
         self->TableClient.Impl_->RetryOperationStatCollector.IncAsyncRetryOperation(status.GetStatus());
-
+ 
         switch (status.GetStatus()) {
             case EStatus::ABORTED:
                 return RunOp(self);
-
+ 
             case EStatus::OVERLOADED:
             case EStatus::CLIENT_RESOURCE_EXHAUSTED:
                 return DoRetry(self, false);
-
+ 
             case EStatus::UNAVAILABLE:
                 return DoRetry(self, true);
-
+ 
             case EStatus::BAD_SESSION:
             case EStatus::SESSION_BUSY:
                 self->Reset();
                 return RunOp(self);
-
+ 
             case EStatus::NOT_FOUND:
                 return self->Settings.RetryNotFound_
                     ? RunOp(self)
                     : self->Promise.SetValue(status);
-
+ 
             case EStatus::UNDETERMINED:
                 return self->Settings.Idempotent_
                     ? DoRetry(self, true)
@@ -3330,14 +3330,14 @@ protected:
 
             default:
                 return self->Promise.SetValue(status);
-        }
+        } 
     }
 
     static void HandleException(TRetryContextPtr self, std::exception_ptr e) {
         self->Promise.SetException(e);
     }
 };
-
+ 
 class TRetryOperationWithSession : public TRetryOperationContext {
     using TFunc = TTableClient::TOperationFunc;
 
@@ -3396,8 +3396,8 @@ TAsyncStatus TTableClient::RetryOperation(TOperationFunc&& operation, const TRet
     TRetryOperationContext::TRetryContextPtr ctx(new TRetryOperationWithSession(std::move(operation), settings, *this));
     ctx->Execute();
     return ctx->GetFuture();
-}
-
+} 
+ 
 class TRetryOperationWithoutSession : public TRetryOperationContext {
     using TFunc = TTableClient::TOperationWithoutSessionFunc;
 
@@ -3430,70 +3430,70 @@ TAsyncStatus TTableClient::RetryOperation(TOperationWithoutSessionFunc&& operati
 }
 
 TStatus TTableClient::RetryOperationSyncHelper(const TOperationWrapperSyncFunc& operationWrapper, const TRetryOperationSettings& settings) {
-    TRetryState retryState;
-    TMaybe<NYdb::TStatus> status;
+    TRetryState retryState; 
+    TMaybe<NYdb::TStatus> status; 
 
-    for (ui32 retryNumber = 0; retryNumber <= settings.MaxRetries_; ++retryNumber) {
+    for (ui32 retryNumber = 0; retryNumber <= settings.MaxRetries_; ++retryNumber) { 
         status = operationWrapper(retryState);
-
+ 
         if (status->IsSuccess()) {
             return *status;
-        }
-
-        if (retryNumber == settings.MaxRetries_) {
-            break;
-        }
-
-        switch (status->GetStatus()) {
-            case EStatus::ABORTED:
-                break;
-
-            case EStatus::OVERLOADED:
-            case EStatus::CLIENT_RESOURCE_EXHAUSTED: {
+        } 
+ 
+        if (retryNumber == settings.MaxRetries_) { 
+            break; 
+        } 
+ 
+        switch (status->GetStatus()) { 
+            case EStatus::ABORTED: 
+                break; 
+ 
+            case EStatus::OVERLOADED: 
+            case EStatus::CLIENT_RESOURCE_EXHAUSTED: { 
                 Backoff(settings.SlowBackoffSettings_, retryNumber);
-                break;
-            }
-
+                break; 
+            } 
+ 
             case EStatus::UNAVAILABLE:{
                 Backoff(settings.FastBackoffSettings_, retryNumber);
                 break;
             }
 
-            case EStatus::BAD_SESSION:
+            case EStatus::BAD_SESSION: 
             case EStatus::SESSION_BUSY:
-                retryState.Session.Clear();
-                break;
-
-            case EStatus::NOT_FOUND:
-                if (!settings.RetryNotFound_) {
-                    return *status;
-                }
-                break;
-
-            case EStatus::UNDETERMINED:
-                if (!settings.Idempotent_) {
-                    return *status;
-                }
-                Backoff(settings.FastBackoffSettings_, retryNumber);
-                break;
-
-            case EStatus::TRANSPORT_UNAVAILABLE:
-                if (!settings.Idempotent_) {
-                    return *status;
-                }
-                retryState.Session.Clear();
-                Backoff(settings.FastBackoffSettings_, retryNumber);
-                break;
-
-            default:
-                return *status;
-        }
+                retryState.Session.Clear(); 
+                break; 
+ 
+            case EStatus::NOT_FOUND: 
+                if (!settings.RetryNotFound_) { 
+                    return *status; 
+                } 
+                break; 
+ 
+            case EStatus::UNDETERMINED: 
+                if (!settings.Idempotent_) { 
+                    return *status; 
+                } 
+                Backoff(settings.FastBackoffSettings_, retryNumber); 
+                break; 
+ 
+            case EStatus::TRANSPORT_UNAVAILABLE: 
+                if (!settings.Idempotent_) { 
+                    return *status; 
+                } 
+                retryState.Session.Clear(); 
+                Backoff(settings.FastBackoffSettings_, retryNumber); 
+                break; 
+ 
+            default: 
+                return *status; 
+        } 
         Impl_->RetryOperationStatCollector.IncSyncRetryOperation(status->GetStatus());
-    }
-
-    return *status;
-}
-
+    } 
+ 
+    return *status; 
+} 
+ 
 TStatus TTableClient::RetryOperationSync(const TOperationWithoutSessionSyncFunc& operation, const TRetryOperationSettings& settings) {
     auto operationWrapper = [this, &operation] (TRetryState&) {
         return operation(*this);
@@ -3534,9 +3534,9 @@ NThreading::TFuture<void> TTableClient::Stop() {
     return Impl_->Stop();
 }
 
-TAsyncBulkUpsertResult TTableClient::BulkUpsert(const TString& table, TValue&& rows,
-    const TBulkUpsertSettings& settings)
-{
+TAsyncBulkUpsertResult TTableClient::BulkUpsert(const TString& table, TValue&& rows, 
+    const TBulkUpsertSettings& settings) 
+{ 
     return Impl_->BulkUpsert(table, std::move(rows), settings);
 }
 
@@ -3546,20 +3546,20 @@ TAsyncBulkUpsertResult TTableClient::BulkUpsert(const TString& table, EDataForma
     return Impl_->BulkUpsert(table, format, data, schema, settings);
 }
 
-TAsyncScanQueryPartIterator TTableClient::StreamExecuteScanQuery(const TString& query, const TParams& params,
-    const TStreamExecScanQuerySettings& settings)
-{
+TAsyncScanQueryPartIterator TTableClient::StreamExecuteScanQuery(const TString& query, const TParams& params, 
+    const TStreamExecScanQuerySettings& settings) 
+{ 
     return Impl_->StreamExecuteScanQuery(query, &params.GetProtoMap(), settings);
-}
-
-TAsyncScanQueryPartIterator TTableClient::StreamExecuteScanQuery(const TString& query,
-    const TStreamExecScanQuerySettings& settings)
-{
-    return Impl_->StreamExecuteScanQuery(query, nullptr, settings);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
+} 
+ 
+TAsyncScanQueryPartIterator TTableClient::StreamExecuteScanQuery(const TString& query, 
+    const TStreamExecScanQuerySettings& settings) 
+{ 
+    return Impl_->StreamExecuteScanQuery(query, nullptr, settings); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 static void ConvertCreateTableSettingsToProto(const TCreateTableSettings& settings, Ydb::Table::TableProfile* proto) {
     if (settings.PresetName_) {
         proto->set_preset_name(settings.PresetName_.GetRef());
@@ -3660,11 +3660,11 @@ static void ConvertCreateTableSettingsToProto(const TCreateTableSettings& settin
 ////////////////////////////////////////////////////////////////////////////////
 
 TSession::TSession(std::shared_ptr<TTableClient::TImpl> client, const TString& sessionId, const TString& endpointId)
-    : Client_(client)
+    : Client_(client) 
     , SessionImpl_(new TSession::TImpl(
             sessionId,
             endpointId,
-            client->Settings_.UseQueryCache_,
+            client->Settings_.UseQueryCache_, 
             client->Settings_.QueryCacheSize_),
         TSession::TImpl::GetSmartDeleter(client))
 {
@@ -3673,54 +3673,54 @@ TSession::TSession(std::shared_ptr<TTableClient::TImpl> client, const TString& s
     }
 }
 
-TSession::TSession(std::shared_ptr<TTableClient::TImpl> client, std::shared_ptr<TImpl> sessionid)
-    : Client_(client)
-    , SessionImpl_(sessionid) {}
-
-TFuture<TStatus> TSession::CreateTable(const TString& path, TTableDescription&& tableDesc,
+TSession::TSession(std::shared_ptr<TTableClient::TImpl> client, std::shared_ptr<TImpl> sessionid) 
+    : Client_(client) 
+    , SessionImpl_(sessionid) {} 
+ 
+TFuture<TStatus> TSession::CreateTable(const TString& path, TTableDescription&& tableDesc, 
         const TCreateTableSettings& settings)
-{
-    auto request = MakeOperationRequest<Ydb::Table::CreateTableRequest>(settings);
-    request.set_session_id(SessionImpl_->GetId());
-    request.set_path(path);
-
+{ 
+    auto request = MakeOperationRequest<Ydb::Table::CreateTableRequest>(settings); 
+    request.set_session_id(SessionImpl_->GetId()); 
+    request.set_path(path); 
+ 
     tableDesc.SerializeTo(request);
-
-    ConvertCreateTableSettingsToProto(settings, request.mutable_profile());
-
+ 
+    ConvertCreateTableSettingsToProto(settings, request.mutable_profile()); 
+ 
     return InjectSessionStatusInterception(
-        SessionImpl_,
-        Client_->CreateTable(std::move(request), settings),
+        SessionImpl_, 
+        Client_->CreateTable(std::move(request), settings), 
         false,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
-}
-
-TFuture<TStatus> TSession::DropTable(const TString& path, const TDropTableSettings& settings) {
+} 
+ 
+TFuture<TStatus> TSession::DropTable(const TString& path, const TDropTableSettings& settings) { 
     return InjectSessionStatusInterception(
-        SessionImpl_,
-        Client_->DropTable(SessionImpl_->GetId(), path, settings),
+        SessionImpl_, 
+        Client_->DropTable(SessionImpl_->GetId(), path, settings), 
         false,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
-}
-
+} 
+ 
 static Ydb::Table::AlterTableRequest MakeAlterTableProtoRequest(
     const TString& path, const TAlterTableSettings& settings, const TString& sessionId)
 {
-    auto request = MakeOperationRequest<Ydb::Table::AlterTableRequest>(settings);
+    auto request = MakeOperationRequest<Ydb::Table::AlterTableRequest>(settings); 
     request.set_session_id(sessionId);
-    request.set_path(path);
-
-    for (const auto& column : settings.AddColumns_) {
-        auto& protoColumn = *request.add_add_columns();
-        protoColumn.set_name(column.Name);
-        protoColumn.mutable_type()->CopyFrom(TProtoAccessor::GetProto(column.Type));
+    request.set_path(path); 
+ 
+    for (const auto& column : settings.AddColumns_) { 
+        auto& protoColumn = *request.add_add_columns(); 
+        protoColumn.set_name(column.Name); 
+        protoColumn.mutable_type()->CopyFrom(TProtoAccessor::GetProto(column.Type)); 
         protoColumn.set_family(column.Family);
-    }
-
-    for (const auto& columnName : settings.DropColumns_) {
-        request.add_drop_columns(columnName);
-    }
-
+    } 
+ 
+    for (const auto& columnName : settings.DropColumns_) { 
+        request.add_drop_columns(columnName); 
+    } 
+ 
     for (const auto& alter : settings.AlterColumns_) {
         auto& protoAlter = *request.add_alter_columns();
         protoAlter.set_name(alter.Name);
@@ -3798,12 +3798,12 @@ TAsyncStatus TSession::AlterTable(const TString& path, const TAlterTableSettings
     auto request = MakeAlterTableProtoRequest(path, settings, SessionImpl_->GetId());
 
     return InjectSessionStatusInterception(
-        SessionImpl_,
-        Client_->AlterTable(std::move(request), settings),
+        SessionImpl_, 
+        Client_->AlterTable(std::move(request), settings), 
         false,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
-}
-
+} 
+ 
 TAsyncOperation TSession::AlterTableLong(const TString& path, const TAlterTableSettings& settings) {
     auto request = MakeAlterTableProtoRequest(path, settings, SessionImpl_->GetId());
 
@@ -3845,103 +3845,103 @@ TAsyncStatus TSession::CopyTables(const TVector<TCopyItem>& copyItems, const TCo
 
     return InjectSessionStatusInterception(
         SessionImpl_,
-        Client_->CopyTables(std::move(request), settings),
+        Client_->CopyTables(std::move(request), settings), 
         false,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
 }
 
-TFuture<TStatus> TSession::CopyTable(const TString& src, const TString& dst, const TCopyTableSettings& settings) {
+TFuture<TStatus> TSession::CopyTable(const TString& src, const TString& dst, const TCopyTableSettings& settings) { 
     return InjectSessionStatusInterception(
-        SessionImpl_,
-        Client_->CopyTable(SessionImpl_->GetId(), src, dst, settings),
+        SessionImpl_, 
+        Client_->CopyTable(SessionImpl_->GetId(), src, dst, settings), 
         false,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
-}
-
-TAsyncDescribeTableResult TSession::DescribeTable(const TString& path, const TDescribeTableSettings& settings) {
+} 
+ 
+TAsyncDescribeTableResult TSession::DescribeTable(const TString& path, const TDescribeTableSettings& settings) { 
     return Client_->DescribeTable(SessionImpl_->GetId(), path, settings);
-}
-
-TAsyncDataQueryResult TSession::ExecuteDataQuery(const TString& query, const TTxControl& txControl,
-    const TExecDataQuerySettings& settings)
-{
-    return Client_->ExecuteDataQuery(*this, query, txControl, nullptr, settings);
-}
-
-TAsyncDataQueryResult TSession::ExecuteDataQuery(const TString& query, const TTxControl& txControl,
-    TParams&& params, const TExecDataQuerySettings& settings)
-{
+} 
+ 
+TAsyncDataQueryResult TSession::ExecuteDataQuery(const TString& query, const TTxControl& txControl, 
+    const TExecDataQuerySettings& settings) 
+{ 
+    return Client_->ExecuteDataQuery(*this, query, txControl, nullptr, settings); 
+} 
+ 
+TAsyncDataQueryResult TSession::ExecuteDataQuery(const TString& query, const TTxControl& txControl, 
+    TParams&& params, const TExecDataQuerySettings& settings) 
+{ 
     auto paramsPtr = params.Empty() ? nullptr : params.GetProtoMapPtr();
-    return Client_->ExecuteDataQuery(*this, query, txControl, paramsPtr, settings);
-}
-
-TAsyncDataQueryResult TSession::ExecuteDataQuery(const TString& query, const TTxControl& txControl,
-    const TParams& params, const TExecDataQuerySettings& settings)
-{
-    if (params.Empty()) {
-        return Client_->ExecuteDataQuery(
-            *this,
-            query,
-            txControl,
-            nullptr,
-            settings);
-    } else {
-        using TProtoParamsType = const ::google::protobuf::Map<TString, Ydb::TypedValue>;
-        return Client_->ExecuteDataQuery<TProtoParamsType&>(
-            *this,
-            query,
-            txControl,
+    return Client_->ExecuteDataQuery(*this, query, txControl, paramsPtr, settings); 
+} 
+ 
+TAsyncDataQueryResult TSession::ExecuteDataQuery(const TString& query, const TTxControl& txControl, 
+    const TParams& params, const TExecDataQuerySettings& settings) 
+{ 
+    if (params.Empty()) { 
+        return Client_->ExecuteDataQuery( 
+            *this, 
+            query, 
+            txControl, 
+            nullptr, 
+            settings); 
+    } else { 
+        using TProtoParamsType = const ::google::protobuf::Map<TString, Ydb::TypedValue>; 
+        return Client_->ExecuteDataQuery<TProtoParamsType&>( 
+            *this, 
+            query, 
+            txControl, 
             params.GetProtoMap(),
-            settings);
-    }
-}
-
-TAsyncPrepareQueryResult TSession::PrepareDataQuery(const TString& query, const TPrepareDataQuerySettings& settings) {
+            settings); 
+    } 
+} 
+ 
+TAsyncPrepareQueryResult TSession::PrepareDataQuery(const TString& query, const TPrepareDataQuerySettings& settings) { 
     auto maybeQuery = SessionImpl_->GetQueryFromCache(query, Client_->Settings_.AllowRequestMigration_);
-    if (maybeQuery) {
+    if (maybeQuery) { 
         TStatus status(EStatus::SUCCESS, NYql::TIssues());
-        TDataQuery dataQuery(*this, query, maybeQuery->QueryId, maybeQuery->ParameterTypes);
-        TPrepareQueryResult result(std::move(status), dataQuery, true);
-        return MakeFuture(result);
-    }
-
+        TDataQuery dataQuery(*this, query, maybeQuery->QueryId, maybeQuery->ParameterTypes); 
+        TPrepareQueryResult result(std::move(status), dataQuery, true); 
+        return MakeFuture(result); 
+    } 
+ 
     Client_->CacheMissCounter.Inc();
 
     return InjectSessionStatusInterception(
-        SessionImpl_,
+        SessionImpl_, 
         Client_->PrepareDataQuery(*this, query, settings),
         true,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
-}
-
-TAsyncStatus TSession::ExecuteSchemeQuery(const TString& query, const TExecSchemeQuerySettings& settings) {
+} 
+ 
+TAsyncStatus TSession::ExecuteSchemeQuery(const TString& query, const TExecSchemeQuerySettings& settings) { 
     return InjectSessionStatusInterception(
-        SessionImpl_,
-        Client_->ExecuteSchemeQuery(SessionImpl_->GetId(), query, settings),
+        SessionImpl_, 
+        Client_->ExecuteSchemeQuery(SessionImpl_->GetId(), query, settings), 
         true,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
-}
-
-TAsyncBeginTransactionResult TSession::BeginTransaction(const TTxSettings& txSettings,
-    const TBeginTxSettings& settings)
-{
+} 
+ 
+TAsyncBeginTransactionResult TSession::BeginTransaction(const TTxSettings& txSettings, 
+    const TBeginTxSettings& settings) 
+{ 
     return InjectSessionStatusInterception(
-        SessionImpl_,
+        SessionImpl_, 
         Client_->BeginTransaction(*this, txSettings, settings),
         true,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
-}
-
-TAsyncExplainDataQueryResult TSession::ExplainDataQuery(const TString& query,
-    const TExplainDataQuerySettings& settings)
-{
+} 
+ 
+TAsyncExplainDataQueryResult TSession::ExplainDataQuery(const TString& query, 
+    const TExplainDataQuerySettings& settings) 
+{ 
     return InjectSessionStatusInterception(
-        SessionImpl_,
+        SessionImpl_, 
         Client_->ExplainDataQuery(*this, query, settings),
         true,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
-}
-
+} 
+ 
 TAsyncTablePartIterator TSession::ReadTable(const TString& path,
     const TReadTableSettings& settings)
 {
@@ -3954,7 +3954,7 @@ TAsyncTablePartIterator TSession::ReadTable(const TString& path,
                 pair.second, pair.first.Endpoint) : nullptr, std::move(pair.first))
             );
     };
-    Client_->ReadTable(SessionImpl_->GetId(), path, settings).Subscribe(readTableIteratorBuilder);
+    Client_->ReadTable(SessionImpl_->GetId(), path, settings).Subscribe(readTableIteratorBuilder); 
     return InjectSessionStatusInterception(
         SessionImpl_,
         promise.GetFuture(),
@@ -3962,92 +3962,92 @@ TAsyncTablePartIterator TSession::ReadTable(const TString& path,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
 }
 
-void TSession::InvalidateQueryCache() {
-    SessionImpl_->InvalidateQueryCache();
-}
-
-TAsyncStatus TSession::Close(const TCloseSessionSettings& settings) {
+void TSession::InvalidateQueryCache() { 
+    SessionImpl_->InvalidateQueryCache(); 
+} 
+ 
+TAsyncStatus TSession::Close(const TCloseSessionSettings& settings) { 
     return Client_->Close(SessionImpl_.get(), settings);
-}
-
+} 
+ 
 TAsyncKeepAliveResult TSession::KeepAlive(const TKeepAliveSettings &settings) {
     return InjectSessionStatusInterception(
-        SessionImpl_,
+        SessionImpl_, 
         Client_->KeepAlive(SessionImpl_.get(), settings),
         true,
         GetMinTimeToTouch(Client_->Settings_.SessionPoolSettings_));
 }
 
-TTableBuilder TSession::GetTableBuilder() {
-    return TTableBuilder();
-}
-
-TParamsBuilder TSession::GetParamsBuilder() {
+TTableBuilder TSession::GetTableBuilder() { 
+    return TTableBuilder(); 
+} 
+ 
+TParamsBuilder TSession::GetParamsBuilder() { 
     return TParamsBuilder();
-}
-
-TTypeBuilder TSession::GetTypeBuilder() {
+} 
+ 
+TTypeBuilder TSession::GetTypeBuilder() { 
     return TTypeBuilder();
-}
-
-const TString& TSession::GetId() const {
-    return SessionImpl_->GetId();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-TTxControl::TTxControl(const TTransaction& tx)
-    : TxId_(tx.GetId()) {}
-
-TTxControl::TTxControl(const TTxSettings& begin)
-    : BeginTx_(begin) {}
-
-////////////////////////////////////////////////////////////////////////////////
-
-TTransaction::TTransaction(const TSession& session, const TString& txId)
-    : Session_(session)
-    , TxId_(txId) {}
-
-TAsyncCommitTransactionResult TTransaction::Commit(const TCommitTxSettings& settings) {
+} 
+ 
+const TString& TSession::GetId() const { 
+    return SessionImpl_->GetId(); 
+}
+
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TTxControl::TTxControl(const TTransaction& tx) 
+    : TxId_(tx.GetId()) {} 
+ 
+TTxControl::TTxControl(const TTxSettings& begin) 
+    : BeginTx_(begin) {} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TTransaction::TTransaction(const TSession& session, const TString& txId) 
+    : Session_(session) 
+    , TxId_(txId) {} 
+ 
+TAsyncCommitTransactionResult TTransaction::Commit(const TCommitTxSettings& settings) { 
     return Session_.Client_->CommitTransaction(Session_, *this, settings);
-}
-
-TAsyncStatus TTransaction::Rollback(const TRollbackTxSettings& settings) {
+} 
+ 
+TAsyncStatus TTransaction::Rollback(const TRollbackTxSettings& settings) { 
     return Session_.Client_->RollbackTransaction(Session_, *this, settings);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-TDataQuery::TDataQuery(const TSession& session, const TString& text, const TString& id)
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TDataQuery::TDataQuery(const TSession& session, const TString& text, const TString& id) 
     : Impl_(new TImpl(session, text, session.Client_->Settings_.KeepDataQueryText_, id,
                       session.Client_->Settings_.AllowRequestMigration_)) {}
-
-TDataQuery::TDataQuery(const TSession& session, const TString& text, const TString& id,
-    const ::google::protobuf::Map<TString, Ydb::Type>& types)
+ 
+TDataQuery::TDataQuery(const TSession& session, const TString& text, const TString& id, 
+    const ::google::protobuf::Map<TString, Ydb::Type>& types) 
     : Impl_(new TImpl(session, text, session.Client_->Settings_.KeepDataQueryText_, id,
                       session.Client_->Settings_.AllowRequestMigration_, types)) {}
-
-const TString& TDataQuery::GetId() const {
-    return Impl_->GetId();
-}
-
-const TMaybe<TString>& TDataQuery::GetText() const {
-    return Impl_->GetText();
-}
-
-TParamsBuilder TDataQuery::GetParamsBuilder() const {
+ 
+const TString& TDataQuery::GetId() const { 
+    return Impl_->GetId(); 
+} 
+ 
+const TMaybe<TString>& TDataQuery::GetText() const { 
+    return Impl_->GetText(); 
+} 
+ 
+TParamsBuilder TDataQuery::GetParamsBuilder() const { 
     return TParamsBuilder(Impl_->ParameterTypes_);
-}
-
-TAsyncDataQueryResult TDataQuery::Execute(const TTxControl& txControl,
-    const TExecDataQuerySettings& settings)
-{
-    return Impl_->Session_.Client_->ExecuteDataQuery(Impl_->Session_, *this, txControl, nullptr, settings, false);
-}
-
-TAsyncDataQueryResult TDataQuery::Execute(const TTxControl& txControl, TParams&& params,
-    const TExecDataQuerySettings& settings)
-{
+} 
+ 
+TAsyncDataQueryResult TDataQuery::Execute(const TTxControl& txControl, 
+    const TExecDataQuerySettings& settings) 
+{ 
+    return Impl_->Session_.Client_->ExecuteDataQuery(Impl_->Session_, *this, txControl, nullptr, settings, false); 
+} 
+ 
+TAsyncDataQueryResult TDataQuery::Execute(const TTxControl& txControl, TParams&& params, 
+    const TExecDataQuerySettings& settings) 
+{ 
     auto paramsPtr = params.Empty() ? nullptr : params.GetProtoMapPtr();
     return Impl_->Session_.Client_->ExecuteDataQuery(
         Impl_->Session_,
@@ -4056,8 +4056,8 @@ TAsyncDataQueryResult TDataQuery::Execute(const TTxControl& txControl, TParams&&
         paramsPtr,
         settings,
         false);
-}
-
+} 
+ 
 TAsyncDataQueryResult TDataQuery::Execute(const TTxControl& txControl, const TParams& params,
     const TExecDataQuerySettings& settings)
 {
@@ -4081,19 +4081,19 @@ TAsyncDataQueryResult TDataQuery::Execute(const TTxControl& txControl, const TPa
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-TCreateSessionResult::TCreateSessionResult(TStatus&& status, TSession&& session)
-    : TStatus(std::move(status))
-    , Session_(std::move(session)) {}
-
-TSession TCreateSessionResult::GetSession() const {
-    CheckStatusOk("TCreateSessionResult::GetSession");
-    return Session_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TCreateSessionResult::TCreateSessionResult(TStatus&& status, TSession&& session) 
+    : TStatus(std::move(status)) 
+    , Session_(std::move(session)) {} 
+ 
+TSession TCreateSessionResult::GetSession() const { 
+    CheckStatusOk("TCreateSessionResult::GetSession"); 
+    return Session_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 TKeepAliveResult::TKeepAliveResult(TStatus&& status, ESessionStatus sessionStatus)
     : TStatus(std::move(status))
     , SessionStatus(sessionStatus) {}
@@ -4104,90 +4104,90 @@ ESessionStatus TKeepAliveResult::GetSessionStatus() const {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TPrepareQueryResult::TPrepareQueryResult(TStatus&& status, const TDataQuery& query, bool fromCache)
-    : TStatus(std::move(status))
-    , PreparedQuery_(query)
-    , FromCache_(fromCache) {}
-
-TDataQuery TPrepareQueryResult::GetQuery() const {
-    CheckStatusOk("TPrepareQueryResult");
-    return PreparedQuery_;
-}
-
-bool TPrepareQueryResult::IsQueryFromCache() const {
-    CheckStatusOk("TPrepareQueryResult");
-    return FromCache_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-TExplainQueryResult::TExplainQueryResult(TStatus&& status, TString&& plan, TString&& ast)
-    : TStatus(std::move(status))
-    , Plan_(plan)
-    , Ast_(ast) {}
-
-const TString& TExplainQueryResult::GetPlan() const {
-    CheckStatusOk("TExplainQueryResult::GetPlan");
-    return Plan_;
-}
-
-const TString& TExplainQueryResult::GetAst() const {
-    CheckStatusOk("TExplainQueryResult::GetAst");
-    return Ast_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-TDescribeTableResult::TDescribeTableResult(TStatus&& status, Ydb::Table::DescribeTableResult&& desc,
-    const TDescribeTableSettings& describeSettings)
-    : TStatus(std::move(status))
-    , TableDescription_(std::move(desc), describeSettings) {}
-
-TTableDescription TDescribeTableResult::GetTableDescription() const {
-    CheckStatusOk("TDescribeTableResult::GetTableDescription");
-    return TableDescription_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-TDataQueryResult::TDataQueryResult(TStatus&& status, TVector<TResultSet>&& resultSets,
+TPrepareQueryResult::TPrepareQueryResult(TStatus&& status, const TDataQuery& query, bool fromCache) 
+    : TStatus(std::move(status)) 
+    , PreparedQuery_(query) 
+    , FromCache_(fromCache) {} 
+ 
+TDataQuery TPrepareQueryResult::GetQuery() const { 
+    CheckStatusOk("TPrepareQueryResult"); 
+    return PreparedQuery_; 
+} 
+ 
+bool TPrepareQueryResult::IsQueryFromCache() const { 
+    CheckStatusOk("TPrepareQueryResult"); 
+    return FromCache_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TExplainQueryResult::TExplainQueryResult(TStatus&& status, TString&& plan, TString&& ast) 
+    : TStatus(std::move(status)) 
+    , Plan_(plan) 
+    , Ast_(ast) {} 
+ 
+const TString& TExplainQueryResult::GetPlan() const { 
+    CheckStatusOk("TExplainQueryResult::GetPlan"); 
+    return Plan_; 
+} 
+ 
+const TString& TExplainQueryResult::GetAst() const { 
+    CheckStatusOk("TExplainQueryResult::GetAst"); 
+    return Ast_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TDescribeTableResult::TDescribeTableResult(TStatus&& status, Ydb::Table::DescribeTableResult&& desc, 
+    const TDescribeTableSettings& describeSettings) 
+    : TStatus(std::move(status)) 
+    , TableDescription_(std::move(desc), describeSettings) {} 
+ 
+TTableDescription TDescribeTableResult::GetTableDescription() const { 
+    CheckStatusOk("TDescribeTableResult::GetTableDescription"); 
+    return TableDescription_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TDataQueryResult::TDataQueryResult(TStatus&& status, TVector<TResultSet>&& resultSets, 
     const TMaybe<TTransaction>& transaction, const TMaybe<TDataQuery>& dataQuery, bool fromCache, const TMaybe<TQueryStats> &queryStats)
-    : TStatus(std::move(status))
-    , Transaction_(transaction)
-    , ResultSets_(std::move(resultSets))
-    , DataQuery_(dataQuery)
+    : TStatus(std::move(status)) 
+    , Transaction_(transaction) 
+    , ResultSets_(std::move(resultSets)) 
+    , DataQuery_(dataQuery) 
     , FromCache_(fromCache)
     , QueryStats_(queryStats)
 {}
-
-const TVector<TResultSet>& TDataQueryResult::GetResultSets() const {
-    return ResultSets_;
-}
-
-TResultSet TDataQueryResult::GetResultSet(size_t resultIndex) const {
-    if (resultIndex >= ResultSets_.size()) {
-        RaiseError(TString("Requested index out of range\n"));
-    }
-
-    return ResultSets_[resultIndex];
-}
-
-TResultSetParser TDataQueryResult::GetResultSetParser(size_t resultIndex) const {
-    return TResultSetParser(GetResultSet(resultIndex));
-}
-
+ 
+const TVector<TResultSet>& TDataQueryResult::GetResultSets() const { 
+    return ResultSets_; 
+} 
+ 
+TResultSet TDataQueryResult::GetResultSet(size_t resultIndex) const { 
+    if (resultIndex >= ResultSets_.size()) { 
+        RaiseError(TString("Requested index out of range\n")); 
+    } 
+ 
+    return ResultSets_[resultIndex]; 
+} 
+ 
+TResultSetParser TDataQueryResult::GetResultSetParser(size_t resultIndex) const { 
+    return TResultSetParser(GetResultSet(resultIndex)); 
+} 
+ 
 TMaybe<TTransaction> TDataQueryResult::GetTransaction() const {
-    return Transaction_;
-}
-
-TMaybe<TDataQuery> TDataQueryResult::GetQuery() const {
-    return DataQuery_;
-}
-
-bool TDataQueryResult::IsQueryFromCache() const {
-    return FromCache_;
-}
-
+    return Transaction_; 
+} 
+ 
+TMaybe<TDataQuery> TDataQueryResult::GetQuery() const { 
+    return DataQuery_; 
+} 
+ 
+bool TDataQueryResult::IsQueryFromCache() const { 
+    return FromCache_; 
+} 
+ 
 const TMaybe<TQueryStats>& TDataQueryResult::GetStats() const {
     return QueryStats_;
 }
@@ -4200,30 +4200,30 @@ const TString TDataQueryResult::GetQueryPlan() const {
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-TBeginTransactionResult::TBeginTransactionResult(TStatus&& status, TTransaction transaction)
-    : TStatus(std::move(status))
-    , Transaction_(transaction) {}
-
-const TTransaction& TBeginTransactionResult::GetTransaction() const {
-    CheckStatusOk("TDataQueryResult::GetTransaction");
-    return Transaction_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-TCommitTransactionResult::TCommitTransactionResult(TStatus&& status, const TMaybe<TQueryStats>& queryStats)
-    : TStatus(std::move(status))
-    , QueryStats_(queryStats) {}
-
-const TMaybe<TQueryStats>& TCommitTransactionResult::GetStats() const {
-    return QueryStats_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-std::function<void(TSession::TImpl*)> TSession::TImpl::GetSmartDeleter(std::shared_ptr<TTableClient::TImpl> client) {
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TBeginTransactionResult::TBeginTransactionResult(TStatus&& status, TTransaction transaction) 
+    : TStatus(std::move(status)) 
+    , Transaction_(transaction) {} 
+ 
+const TTransaction& TBeginTransactionResult::GetTransaction() const { 
+    CheckStatusOk("TDataQueryResult::GetTransaction"); 
+    return Transaction_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TCommitTransactionResult::TCommitTransactionResult(TStatus&& status, const TMaybe<TQueryStats>& queryStats) 
+    : TStatus(std::move(status)) 
+    , QueryStats_(queryStats) {} 
+ 
+const TMaybe<TQueryStats>& TCommitTransactionResult::GetStats() const { 
+    return QueryStats_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+std::function<void(TSession::TImpl*)> TSession::TImpl::GetSmartDeleter(std::shared_ptr<TTableClient::TImpl> client) { 
     return [client](TSession::TImpl* sessionImpl) {
         switch (sessionImpl->GetState()) {
             case TSession::TImpl::S_STANDALONE:
@@ -4672,5 +4672,5 @@ TBulkUpsertResult::TBulkUpsertResult(TStatus&& status)
     : TStatus(std::move(status))
 {}
 
-} // namespace NTable
-} // namespace NYdb
+} // namespace NTable 
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_table/table.h b/ydb/public/sdk/cpp/client/ydb_table/table.h
index 42d21d2fec..97bd5eb354 100644
--- a/ydb/public/sdk/cpp/client/ydb_table/table.h
+++ b/ydb/public/sdk/cpp/client/ydb_table/table.h
@@ -1,7 +1,7 @@
-#pragma once
-
+#pragma once 
+ 
 #include "table_enum.h"
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_driver/driver.h>
 #include <ydb/public/sdk/cpp/client/ydb_result/result.h>
 #include <ydb/public/sdk/cpp/client/ydb_table/query_stats/stats.h>
@@ -9,9 +9,9 @@
 #include <ydb/public/sdk/cpp/client/ydb_types/operation/operation.h>
 
 #include <util/generic/hash.h>
-#include <util/generic/maybe.h>
+#include <util/generic/maybe.h> 
 #include <util/generic/variant.h>
-
+ 
 namespace Ydb {
 namespace Table {
 
@@ -29,14 +29,14 @@ class ValueSinceUnixEpochModeSettings;
 }
 }
 
-namespace NYdb {
+namespace NYdb { 
 
 namespace NScheme {
 struct TPermissions;
 }
 
-namespace NTable {
-
+namespace NTable { 
+ 
 ////////////////////////////////////////////////////////////////////////////////
 
 class TKeyBound {
@@ -67,9 +67,9 @@ private:
 
 class TKeyRange {
 public:
-    TKeyRange(const TMaybe<TKeyBound>& from, const TMaybe<TKeyBound>& to)
-        : From_(from)
-        , To_(to) {}
+    TKeyRange(const TMaybe<TKeyBound>& from, const TMaybe<TKeyBound>& to) 
+        : From_(from) 
+        , To_(to) {} 
 
     const TMaybe<TKeyBound>& From() const {
         return From_;
@@ -380,28 +380,28 @@ private:
 };
 
 struct TExplicitPartitions;
-struct TDescribeTableSettings;
+struct TDescribeTableSettings; 
 
-//! Represents table description
-class TTableDescription {
-    friend class TTableBuilder;
+//! Represents table description 
+class TTableDescription { 
+    friend class TTableBuilder; 
     friend class NYdb::TProtoAccessor;
-
+ 
     using EUnit = TValueSinceUnixEpochModeSettings::EUnit;
 
-public:
-    TTableDescription(Ydb::Table::DescribeTableResult&& desc, const TDescribeTableSettings& describeSettings);
-
-    const TVector<TString>& GetPrimaryKeyColumns() const;
+public: 
+    TTableDescription(Ydb::Table::DescribeTableResult&& desc, const TDescribeTableSettings& describeSettings); 
+ 
+    const TVector<TString>& GetPrimaryKeyColumns() const; 
     // DEPRECATED: use GetTableColumns()
-    TVector<TColumn> GetColumns() const;
+    TVector<TColumn> GetColumns() const; 
     TVector<TTableColumn> GetTableColumns() const;
     TVector<TIndexDescription> GetIndexDescriptions() const;
     TMaybe<TTtlSettings> GetTtlSettings() const;
-
-    const TString& GetOwner() const;
+ 
+    const TString& GetOwner() const; 
     const TVector<NScheme::TPermissions>& GetPermissions() const;
-    const TVector<NScheme::TPermissions>& GetEffectivePermissions() const;
+    const TVector<NScheme::TPermissions>& GetEffectivePermissions() const; 
     const TVector<TKeyRange>& GetKeyRanges() const;
 
     // Folow options related to table statistics
@@ -443,12 +443,12 @@ public:
     // Fills CreateTableRequest proto from this description
     void SerializeTo(Ydb::Table::CreateTableRequest& request) const;
 
-private:
-    TTableDescription();
+private: 
+    TTableDescription(); 
     explicit TTableDescription(const Ydb::Table::CreateTableRequest& request);
-
+ 
     void AddColumn(const TString& name, const Ydb::Type& type, const TString& family);
-    void SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns);
+    void SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns); 
 
     // common
     void AddSecondaryIndex(const TString& indexName, EIndexType type, const TVector<TString>& indexColumns);
@@ -480,11 +480,11 @@ private:
     const Ydb::Table::DescribeTableResult& GetProto() const;
 
     class TImpl;
-    std::shared_ptr<TImpl> Impl_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
+    std::shared_ptr<TImpl> Impl_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 class TStorageSettingsBuilder {
 public:
     TStorageSettingsBuilder();
@@ -640,19 +640,19 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TTableBuilder {
+class TTableBuilder { 
     using EUnit = TValueSinceUnixEpochModeSettings::EUnit;
 
-public:
-    TTableBuilder() = default;
-
+public: 
+    TTableBuilder() = default; 
+ 
     TTableBuilder& AddNullableColumn(const TString& name, const EPrimitiveType& type, const TString& family = TString());
     TTableBuilder& AddNullableColumn(const TString& name, const TDecimalType& type, const TString& family = TString());
     TTableBuilder& AddNonNullableColumn(const TString& name, const EPrimitiveType& type, const TString& family = TString());
     TTableBuilder& AddNonNullableColumn(const TString& name, const TDecimalType& type, const TString& family = TString());
-    TTableBuilder& SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns);
-    TTableBuilder& SetPrimaryKeyColumn(const TString& primaryKeyColumn);
-
+    TTableBuilder& SetPrimaryKeyColumns(const TVector<TString>& primaryKeyColumns); 
+    TTableBuilder& SetPrimaryKeyColumn(const TString& primaryKeyColumn); 
+ 
     // common
     TTableBuilder& AddSecondaryIndex(const TString& indexName, EIndexType type, const TVector<TString>& indexColumns, const TVector<TString>& dataColumns);
     TTableBuilder& AddSecondaryIndex(const TString& indexName, EIndexType type, const TVector<TString>& indexColumns);
@@ -710,12 +710,12 @@ public:
         return TTablePartitioningSettingsBuilder(*this);
     }
 
-    TTableDescription Build();
-
-private:
-    TTableDescription TableDescription_;
-};
-
+    TTableDescription Build(); 
+ 
+private: 
+    TTableDescription TableDescription_; 
+}; 
+ 
 inline TTableBuilder& TTableStorageSettingsBuilder::EndStorageSettings() {
     return Parent_.SetStorageSettings(Builder_.Build());
 }
@@ -728,8 +728,8 @@ inline TTableBuilder& TTablePartitioningSettingsBuilder::EndPartitioningSettings
     return Parent_.SetPartitioningSettings(Builder_.Build());
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 class TCopyItem {
 public:
     TCopyItem(const TString& source, const TString& destination);
@@ -764,35 +764,35 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TCreateSessionResult;
-class TDataQueryResult;
+class TCreateSessionResult; 
+class TDataQueryResult; 
 class TTablePartIterator;
-class TPrepareQueryResult;
-class TExplainQueryResult;
-class TDescribeTableResult;
-class TBeginTransactionResult;
-class TCommitTransactionResult;
+class TPrepareQueryResult; 
+class TExplainQueryResult; 
+class TDescribeTableResult; 
+class TBeginTransactionResult; 
+class TCommitTransactionResult; 
 class TKeepAliveResult;
 class TSessionPoolImpl;
 class TBulkUpsertResult;
-class TScanQueryPartIterator;
-
-using TAsyncCreateSessionResult = NThreading::TFuture<TCreateSessionResult>;
-using TAsyncDataQueryResult = NThreading::TFuture<TDataQueryResult>;
-using TAsyncPrepareQueryResult = NThreading::TFuture<TPrepareQueryResult>;
-using TAsyncExplainDataQueryResult = NThreading::TFuture<TExplainQueryResult>;
-using TAsyncDescribeTableResult = NThreading::TFuture<TDescribeTableResult>;
-using TAsyncBeginTransactionResult = NThreading::TFuture<TBeginTransactionResult>;
-using TAsyncCommitTransactionResult = NThreading::TFuture<TCommitTransactionResult>;
+class TScanQueryPartIterator; 
+ 
+using TAsyncCreateSessionResult = NThreading::TFuture<TCreateSessionResult>; 
+using TAsyncDataQueryResult = NThreading::TFuture<TDataQueryResult>; 
+using TAsyncPrepareQueryResult = NThreading::TFuture<TPrepareQueryResult>; 
+using TAsyncExplainDataQueryResult = NThreading::TFuture<TExplainQueryResult>; 
+using TAsyncDescribeTableResult = NThreading::TFuture<TDescribeTableResult>; 
+using TAsyncBeginTransactionResult = NThreading::TFuture<TBeginTransactionResult>; 
+using TAsyncCommitTransactionResult = NThreading::TFuture<TCommitTransactionResult>; 
 using TAsyncTablePartIterator = NThreading::TFuture<TTablePartIterator>;
 using TAsyncKeepAliveResult = NThreading::TFuture<TKeepAliveResult>;
 using TAsyncBulkUpsertResult = NThreading::TFuture<TBulkUpsertResult>;
-using TAsyncScanQueryPartIterator = NThreading::TFuture<TScanQueryPartIterator>;
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct TCreateSessionSettings : public TOperationRequestSettings<TCreateSessionSettings> {};
-
+using TAsyncScanQueryPartIterator = NThreading::TFuture<TScanQueryPartIterator>; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+struct TCreateSessionSettings : public TOperationRequestSettings<TCreateSessionSettings> {}; 
+ 
 struct TBackoffSettings {
     using TSelf = TBackoffSettings;
 
@@ -801,15 +801,15 @@ struct TBackoffSettings {
     FLUENT_SETTING_DEFAULT(double, UncertainRatio, 0.5);
 };
 
-struct TRetryOperationSettings {
-    using TSelf = TRetryOperationSettings;
-
-    FLUENT_SETTING_DEFAULT(ui32, MaxRetries, 10);
-    FLUENT_SETTING_DEFAULT(bool, RetryNotFound, true);
+struct TRetryOperationSettings { 
+    using TSelf = TRetryOperationSettings; 
+ 
+    FLUENT_SETTING_DEFAULT(ui32, MaxRetries, 10); 
+    FLUENT_SETTING_DEFAULT(bool, RetryNotFound, true); 
     FLUENT_SETTING_DEFAULT(TDuration, GetSessionClientTimeout, TDuration::Seconds(5));
     FLUENT_SETTING_DEFAULT(TBackoffSettings, FastBackoffSettings, DefaultFastBackoffSettings());
     FLUENT_SETTING_DEFAULT(TBackoffSettings, SlowBackoffSettings, DefaultSlowBackoffSettings());
-    FLUENT_SETTING_FLAG(Idempotent);
+    FLUENT_SETTING_FLAG(Idempotent); 
 
     static TBackoffSettings DefaultFastBackoffSettings() {
         return TBackoffSettings()
@@ -824,8 +824,8 @@ struct TRetryOperationSettings {
             .SlotDuration(TDuration::Seconds(1))
             .UncertainRatio(0.5);
     }
-};
-
+}; 
+ 
 struct TSessionPoolSettings {
     using TSelf = TSessionPoolSettings;
 
@@ -849,18 +849,18 @@ struct TSessionPoolSettings {
 };
 
 struct TClientSettings : public TCommonClientSettingsBase<TClientSettings> {
-    using TSelf = TClientSettings;
-
-    // Enable client query cache. Client query cache is used to map query text to
-    // prepared query id for ExecuteDataQuery calls on client side.
-    // Starting from YDB 20-4, server query cache is enabled by default, which
-    // make use of client cache unnecessary. Use of server cache is preferred
-    // as it doesn't require client-server synchronization and can recompile
-    // query on demand without client interaction.
-    // The recommended value is False.
-    FLUENT_SETTING_DEFAULT(bool, UseQueryCache, true);
-    FLUENT_SETTING_DEFAULT(ui32, QueryCacheSize, 1000);
-    FLUENT_SETTING_DEFAULT(bool, KeepDataQueryText, true);
+    using TSelf = TClientSettings; 
+ 
+    // Enable client query cache. Client query cache is used to map query text to 
+    // prepared query id for ExecuteDataQuery calls on client side. 
+    // Starting from YDB 20-4, server query cache is enabled by default, which 
+    // make use of client cache unnecessary. Use of server cache is preferred 
+    // as it doesn't require client-server synchronization and can recompile 
+    // query on demand without client interaction. 
+    // The recommended value is False. 
+    FLUENT_SETTING_DEFAULT(bool, UseQueryCache, true); 
+    FLUENT_SETTING_DEFAULT(ui32, QueryCacheSize, 1000); 
+    FLUENT_SETTING_DEFAULT(bool, KeepDataQueryText, true); 
 
     // Min allowed session variation coefficient (%) to start session balancing.
     // Variation coefficient is a ratio of the standard deviation sigma to the mean
@@ -883,8 +883,8 @@ struct TClientSettings : public TCommonClientSettingsBase<TClientSettings> {
     FLUENT_SETTING_DEFAULT(ui32, SettlerSessionPoolTTL, 100);
     // Settings of session pool
     FLUENT_SETTING(TSessionPoolSettings, SessionPoolSettings);
-};
-
+}; 
+ 
 struct TBulkUpsertSettings : public TOperationRequestSettings<TBulkUpsertSettings> {
     // Format setting proto serialized into string. If not set format defaults are used.
     // I.e. it's Ydb.Table.CsvSettings for CSV.
@@ -894,37 +894,37 @@ struct TBulkUpsertSettings : public TOperationRequestSettings<TBulkUpsertSetting
 struct TStreamExecScanQuerySettings : public TRequestSettings<TStreamExecScanQuerySettings> {
     // Return query plan without actual query execution
     FLUENT_SETTING_DEFAULT(bool, Explain, false);
-
+ 
     // Collect runtime statistics with a given detalization mode
     FLUENT_SETTING_DEFAULT(ECollectQueryStatsMode, CollectQueryStats, ECollectQueryStatsMode::None);
 };
 
-class TSession;
+class TSession; 
 struct TRetryState;
-
+ 
 enum class EDataFormat {
     ApacheArrow = 1,
     CSV = 2,
 };
 
-class TTableClient {
-    friend class TSession;
-    friend class TTransaction;
+class TTableClient { 
+    friend class TSession; 
+    friend class TTransaction; 
     friend class TSessionPoolImpl;
     friend class TRetryOperationContext;
-
-public:
-    using TOperationFunc = std::function<TAsyncStatus(TSession session)>;
-    using TOperationSyncFunc = std::function<TStatus(TSession session)>;
+ 
+public: 
+    using TOperationFunc = std::function<TAsyncStatus(TSession session)>; 
+    using TOperationSyncFunc = std::function<TStatus(TSession session)>; 
     using TOperationWithoutSessionFunc = std::function<TAsyncStatus(TTableClient& tableClient)>;
     using TOperationWithoutSessionSyncFunc = std::function<TStatus(TTableClient& tableClient)>;
-
-public:
-    TTableClient(const TDriver& driver, const TClientSettings& settings = TClientSettings());
-
+ 
+public: 
+    TTableClient(const TDriver& driver, const TClientSettings& settings = TClientSettings()); 
+ 
     //! Creates new session
-    TAsyncCreateSessionResult CreateSession(const TCreateSessionSettings& settings = TCreateSessionSettings());
-
+    TAsyncCreateSessionResult CreateSession(const TCreateSessionSettings& settings = TCreateSessionSettings()); 
+ 
     //! Returns session from session pool,
     //! if all sessions are occupied will be generated session with CLIENT_RESOURCE_EXHAUSTED status.
     TAsyncCreateSessionResult GetSession(const TCreateSessionSettings& settings = TCreateSessionSettings());
@@ -938,27 +938,27 @@ public:
     //! Returns the size of session pool
     i64 GetCurrentPoolSize() const;
 
-    //! Returns new table builder
-    TTableBuilder GetTableBuilder();
-    //! Returns new params builder
-    TParamsBuilder GetParamsBuilder();
-    //! Returns new type builder
-    TTypeBuilder GetTypeBuilder();
-
+    //! Returns new table builder 
+    TTableBuilder GetTableBuilder(); 
+    //! Returns new params builder 
+    TParamsBuilder GetParamsBuilder(); 
+    //! Returns new type builder 
+    TTypeBuilder GetTypeBuilder(); 
+ 
     TAsyncStatus RetryOperation(TOperationFunc&& operation,
-        const TRetryOperationSettings& settings = TRetryOperationSettings());
-
-    template<typename TResult>
+        const TRetryOperationSettings& settings = TRetryOperationSettings()); 
+ 
+    template<typename TResult> 
     TAsyncStatus RetryOperation(std::function<NThreading::TFuture<TResult>(TSession session)>&& operation,
         const TRetryOperationSettings& settings = TRetryOperationSettings());
 
     template<typename TResult>
-    TAsyncStatus RetryOperation(const std::function<NThreading::TFuture<TResult>(TSession session)>& operation,
-        const TRetryOperationSettings& settings = TRetryOperationSettings());
-
-    TStatus RetryOperationSync(const TOperationSyncFunc& operation,
-        const TRetryOperationSettings& settings = TRetryOperationSettings());
-
+    TAsyncStatus RetryOperation(const std::function<NThreading::TFuture<TResult>(TSession session)>& operation, 
+        const TRetryOperationSettings& settings = TRetryOperationSettings()); 
+ 
+    TStatus RetryOperationSync(const TOperationSyncFunc& operation, 
+        const TRetryOperationSettings& settings = TRetryOperationSettings()); 
+ 
     TAsyncStatus RetryOperation(TOperationWithoutSessionFunc&& operation,
         const TRetryOperationSettings& settings = TRetryOperationSettings());
 
@@ -988,54 +988,54 @@ public:
     TAsyncBulkUpsertResult BulkUpsert(const TString& table, EDataFormat format,
         const TString& data, const TString& schema = {}, const TBulkUpsertSettings& settings = TBulkUpsertSettings());
 
-    TAsyncScanQueryPartIterator StreamExecuteScanQuery(const TString& query,
-        const TStreamExecScanQuerySettings& settings = TStreamExecScanQuerySettings());
-
-    TAsyncScanQueryPartIterator StreamExecuteScanQuery(const TString& query, const TParams& params,
-        const TStreamExecScanQuerySettings& settings = TStreamExecScanQuerySettings());
-
-private:
+    TAsyncScanQueryPartIterator StreamExecuteScanQuery(const TString& query, 
+        const TStreamExecScanQuerySettings& settings = TStreamExecScanQuerySettings()); 
+ 
+    TAsyncScanQueryPartIterator StreamExecuteScanQuery(const TString& query, const TParams& params, 
+        const TStreamExecScanQuerySettings& settings = TStreamExecScanQuerySettings()); 
+ 
+private: 
     using TOperationWrapperSyncFunc = std::function<TStatus(TRetryState& retryState)>;
     TStatus RetryOperationSyncHelper(const TOperationWrapperSyncFunc& operationWrapper, const TRetryOperationSettings& settings);
 
 private:
-    class TImpl;
-    std::shared_ptr<TImpl> Impl_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TTransaction;
-
-struct TTxOnlineSettings {
-    using TSelf = TTxOnlineSettings;
-
-    TTxOnlineSettings() {}
-
-    FLUENT_SETTING_DEFAULT(bool, AllowInconsistentReads, false);
-};
-
-class TTxSettings {
-    friend class TTableClient;
-
-public:
-    using TSelf = TTxSettings;
-
-    TTxSettings()
-        : Mode_(TS_SERIALIZABLE_RW) {}
-
-    static TTxSettings SerializableRW() {
-        return TTxSettings(TS_SERIALIZABLE_RW);
-    }
-
-    static TTxSettings OnlineRO(const TTxOnlineSettings& settings = TTxOnlineSettings()) {
-        return TTxSettings(TS_ONLINE_RO).OnlineSettings(settings);
-    }
-
-    static TTxSettings StaleRO() {
-        return TTxSettings(TS_STALE_RO);
-    }
-
+    class TImpl; 
+    std::shared_ptr<TImpl> Impl_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+class TTransaction; 
+ 
+struct TTxOnlineSettings { 
+    using TSelf = TTxOnlineSettings; 
+ 
+    TTxOnlineSettings() {} 
+ 
+    FLUENT_SETTING_DEFAULT(bool, AllowInconsistentReads, false); 
+}; 
+ 
+class TTxSettings { 
+    friend class TTableClient; 
+ 
+public: 
+    using TSelf = TTxSettings; 
+ 
+    TTxSettings() 
+        : Mode_(TS_SERIALIZABLE_RW) {} 
+ 
+    static TTxSettings SerializableRW() { 
+        return TTxSettings(TS_SERIALIZABLE_RW); 
+    } 
+ 
+    static TTxSettings OnlineRO(const TTxOnlineSettings& settings = TTxOnlineSettings()) { 
+        return TTxSettings(TS_ONLINE_RO).OnlineSettings(settings); 
+    } 
+ 
+    static TTxSettings StaleRO() { 
+        return TTxSettings(TS_STALE_RO); 
+    } 
+ 
     void Out(IOutputStream& out) const {
         switch (Mode_) {
         case TS_SERIALIZABLE_RW:
@@ -1053,55 +1053,55 @@ public:
         }
     }
 
-private:
-    enum ETransactionMode {
-        TS_SERIALIZABLE_RW,
-        TS_ONLINE_RO,
-        TS_STALE_RO
-    };
-
-    FLUENT_SETTING(TTxOnlineSettings, OnlineSettings);
-
-private:
-    TTxSettings(ETransactionMode mode)
-        : Mode_(mode) {}
-
-    ETransactionMode Mode_;
-};
-
-class TTxControl {
-    friend class TTableClient;
-
-public:
-    using TSelf = TTxControl;
-
-    static TTxControl Tx(const TTransaction& tx) {
-        return TTxControl(tx);
-    }
-
-    static TTxControl BeginTx(const TTxSettings& settings = TTxSettings()) {
-        return TTxControl(settings);
-    }
-
-    FLUENT_SETTING_FLAG(CommitTx);
-
-private:
-    TTxControl(const TTransaction& tx);
-    TTxControl(const TTxSettings& begin);
-
-private:
-    TMaybe<TString> TxId_;
-    TTxSettings BeginTx_;
-};
-
+private: 
+    enum ETransactionMode { 
+        TS_SERIALIZABLE_RW, 
+        TS_ONLINE_RO, 
+        TS_STALE_RO 
+    }; 
+ 
+    FLUENT_SETTING(TTxOnlineSettings, OnlineSettings); 
+ 
+private: 
+    TTxSettings(ETransactionMode mode) 
+        : Mode_(mode) {} 
+ 
+    ETransactionMode Mode_; 
+}; 
+ 
+class TTxControl { 
+    friend class TTableClient; 
+ 
+public: 
+    using TSelf = TTxControl; 
+ 
+    static TTxControl Tx(const TTransaction& tx) { 
+        return TTxControl(tx); 
+    } 
+ 
+    static TTxControl BeginTx(const TTxSettings& settings = TTxSettings()) { 
+        return TTxControl(settings); 
+    } 
+ 
+    FLUENT_SETTING_FLAG(CommitTx); 
+ 
+private: 
+    TTxControl(const TTransaction& tx); 
+    TTxControl(const TTxSettings& begin); 
+ 
+private: 
+    TMaybe<TString> TxId_; 
+    TTxSettings BeginTx_; 
+}; 
+ 
 enum class EAutoPartitioningPolicy {
     Disabled = 1,
     AutoSplit = 2,
     AutoSplitMerge = 3
 };
 
-////////////////////////////////////////////////////////////////////////////////
-
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 struct TColumnFamilyPolicy {
     using TSelf = TColumnFamilyPolicy;
 
@@ -1118,7 +1118,7 @@ struct TColumnFamilyPolicy {
 
 struct TStoragePolicy {
     using TSelf = TStoragePolicy;
-
+ 
     FLUENT_SETTING_OPTIONAL(TString, PresetName);
 
     FLUENT_SETTING_OPTIONAL(TString, SysLog);
@@ -1164,7 +1164,7 @@ struct TReplicationPolicy {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-struct TCreateTableSettings : public TOperationRequestSettings<TCreateTableSettings> {
+struct TCreateTableSettings : public TOperationRequestSettings<TCreateTableSettings> { 
     using TSelf = TCreateTableSettings;
 
     FLUENT_SETTING_OPTIONAL(TString, PresetName);
@@ -1183,7 +1183,7 @@ struct TCreateTableSettings : public TOperationRequestSettings<TCreateTableSetti
 ////////////////////////////////////////////////////////////////////////////////
 
 struct TDropTableSettings : public TOperationRequestSettings<TDropTableSettings> {};
-
+ 
 ////////////////////////////////////////////////////////////////////////////////
 
 struct TAlterTableSettings;
@@ -1331,15 +1331,15 @@ private:
     TPartitioningSettingsBuilder Builder_;
 };
 
-struct TAlterTableSettings : public TOperationRequestSettings<TAlterTableSettings> {
-    using TSelf = TAlterTableSettings;
+struct TAlterTableSettings : public TOperationRequestSettings<TAlterTableSettings> { 
+    using TSelf = TAlterTableSettings; 
     using TAlterAttributes = THashMap<TString, TString>;
-
+ 
     TAlterTableSettings();
 
     FLUENT_SETTING_VECTOR(TTableColumn, AddColumns);
-
-    FLUENT_SETTING_VECTOR(TString, DropColumns);
+ 
+    FLUENT_SETTING_VECTOR(TString, DropColumns); 
 
     FLUENT_SETTING_VECTOR(TAlterTableColumn, AlterColumns);
 
@@ -1402,8 +1402,8 @@ struct TAlterTableSettings : public TOperationRequestSettings<TAlterTableSetting
 private:
     class TImpl;
     std::shared_ptr<TImpl> Impl_;
-};
-
+}; 
+ 
 inline TAlterTableSettings& TAlterStorageSettingsBuilder::EndAlterStorageSettings() {
     return Parent_.AlterStorageSettings(Builder_.Build());
 }
@@ -1426,41 +1426,41 @@ inline TAlterTableSettings& TAlterPartitioningSettingsBuilder::EndAlterPartition
 
 ////////////////////////////////////////////////////////////////////////////////
 
-struct TCopyTableSettings : public TOperationRequestSettings<TCopyTableSettings> {};
-
+struct TCopyTableSettings : public TOperationRequestSettings<TCopyTableSettings> {}; 
+ 
 struct TCopyTablesSettings : public TOperationRequestSettings<TCopyTablesSettings> {};
 
 struct TRenameTablesSettings : public TOperationRequestSettings<TRenameTablesSettings> {};
 
-struct TDescribeTableSettings : public TOperationRequestSettings<TDescribeTableSettings> {
+struct TDescribeTableSettings : public TOperationRequestSettings<TDescribeTableSettings> { 
     FLUENT_SETTING_DEFAULT(bool, WithKeyShardBoundary, false);
     FLUENT_SETTING_DEFAULT(bool, WithTableStatistics, false);
     FLUENT_SETTING_DEFAULT(bool, WithPartitionStatistics, false);
 };
-
-struct TExplainDataQuerySettings : public TOperationRequestSettings<TExplainDataQuerySettings> {};
-
+ 
+struct TExplainDataQuerySettings : public TOperationRequestSettings<TExplainDataQuerySettings> {}; 
+ 
 struct TPrepareDataQuerySettings : public TOperationRequestSettings<TPrepareDataQuerySettings> {};
-
-struct TExecDataQuerySettings : public TOperationRequestSettings<TExecDataQuerySettings> {
-    FLUENT_SETTING_OPTIONAL(bool, KeepInQueryCache);
+ 
+struct TExecDataQuerySettings : public TOperationRequestSettings<TExecDataQuerySettings> { 
+    FLUENT_SETTING_OPTIONAL(bool, KeepInQueryCache); 
 
     FLUENT_SETTING_OPTIONAL(ECollectQueryStatsMode, CollectQueryStats);
-};
-
-struct TExecSchemeQuerySettings : public TOperationRequestSettings<TExecSchemeQuerySettings> {};
-
-struct TBeginTxSettings : public TOperationRequestSettings<TBeginTxSettings> {};
-
-struct TCommitTxSettings : public TOperationRequestSettings<TCommitTxSettings> {
-    FLUENT_SETTING_OPTIONAL(ECollectQueryStatsMode, CollectQueryStats);
-};
-
-struct TRollbackTxSettings : public TOperationRequestSettings<TRollbackTxSettings> {};
-
-struct TCloseSessionSettings : public TOperationRequestSettings<TCloseSessionSettings> {};
-
-struct TKeepAliveSettings : public TOperationRequestSettings<TKeepAliveSettings> {};
+}; 
+ 
+struct TExecSchemeQuerySettings : public TOperationRequestSettings<TExecSchemeQuerySettings> {}; 
+ 
+struct TBeginTxSettings : public TOperationRequestSettings<TBeginTxSettings> {}; 
+ 
+struct TCommitTxSettings : public TOperationRequestSettings<TCommitTxSettings> { 
+    FLUENT_SETTING_OPTIONAL(ECollectQueryStatsMode, CollectQueryStats); 
+}; 
+ 
+struct TRollbackTxSettings : public TOperationRequestSettings<TRollbackTxSettings> {}; 
+ 
+struct TCloseSessionSettings : public TOperationRequestSettings<TCloseSessionSettings> {}; 
+ 
+struct TKeepAliveSettings : public TOperationRequestSettings<TKeepAliveSettings> {}; 
 
 struct TReadTableSettings : public TRequestSettings<TReadTableSettings> {
 
@@ -1479,91 +1479,91 @@ struct TReadTableSettings : public TRequestSettings<TReadTableSettings> {
     FLUENT_SETTING_OPTIONAL(bool, UseSnapshot);
 };
 
-//! Represents all session operations
-//! Session is transparent logic representation of connection
-class TSession {
-    friend class TTableClient;
-    friend class TDataQuery;
-    friend class TTransaction;
+//! Represents all session operations 
+//! Session is transparent logic representation of connection 
+class TSession { 
+    friend class TTableClient; 
+    friend class TDataQuery; 
+    friend class TTransaction; 
     friend class TSessionPoolImpl;
-
-public:
-    //! The following methods perform corresponding calls.
-    //! Results are NThreading::TFuture<T> where T is corresponding result.
-    TAsyncStatus CreateTable(const TString& path, TTableDescription&& tableDesc,
+ 
+public: 
+    //! The following methods perform corresponding calls. 
+    //! Results are NThreading::TFuture<T> where T is corresponding result. 
+    TAsyncStatus CreateTable(const TString& path, TTableDescription&& tableDesc, 
         const TCreateTableSettings& settings = TCreateTableSettings());
-
-    TAsyncStatus DropTable(const TString& path, const TDropTableSettings& settings = TDropTableSettings());
-
-    TAsyncStatus AlterTable(const TString& path, const TAlterTableSettings& settings = TAlterTableSettings());
-
+ 
+    TAsyncStatus DropTable(const TString& path, const TDropTableSettings& settings = TDropTableSettings()); 
+ 
+    TAsyncStatus AlterTable(const TString& path, const TAlterTableSettings& settings = TAlterTableSettings()); 
+ 
     // Same as AlterTable but may return operation in case of long running
     TAsyncOperation AlterTableLong(const TString& path, const TAlterTableSettings& settings = TAlterTableSettings());
 
-    TAsyncStatus CopyTable(const TString& src, const TString& dst,
-        const TCopyTableSettings& settings = TCopyTableSettings());
-
+    TAsyncStatus CopyTable(const TString& src, const TString& dst, 
+        const TCopyTableSettings& settings = TCopyTableSettings()); 
+ 
     TAsyncStatus CopyTables(const TVector<TCopyItem>& copyItems,
         const TCopyTablesSettings& settings = TCopyTablesSettings());
 
     TAsyncStatus RenameTables(const TVector<TRenameItem>& renameItems,
         const TRenameTablesSettings& settings = TRenameTablesSettings());
 
-    TAsyncDescribeTableResult DescribeTable(const TString& path,
-        const TDescribeTableSettings& settings = TDescribeTableSettings());
-
-    TAsyncBeginTransactionResult BeginTransaction(const TTxSettings& txSettings = TTxSettings(),
-        const TBeginTxSettings& settings = TBeginTxSettings());
-
-    TAsyncExplainDataQueryResult ExplainDataQuery(const TString& query,
-        const TExplainDataQuerySettings& settings = TExplainDataQuerySettings());
-
-    TAsyncPrepareQueryResult PrepareDataQuery(const TString& query,
-        const TPrepareDataQuerySettings& settings = TPrepareDataQuerySettings());
-
-    TAsyncDataQueryResult ExecuteDataQuery(const TString& query, const TTxControl& txControl,
-        const TExecDataQuerySettings& settings = TExecDataQuerySettings());
-
-    TAsyncDataQueryResult ExecuteDataQuery(const TString& query, const TTxControl& txControl,
-        const TParams& params, const TExecDataQuerySettings& settings = TExecDataQuerySettings());
-
-    TAsyncDataQueryResult ExecuteDataQuery(const TString& query, const TTxControl& txControl,
-        TParams&& params, const TExecDataQuerySettings& settings = TExecDataQuerySettings());
-
-    TAsyncStatus ExecuteSchemeQuery(const TString& query,
-        const TExecSchemeQuerySettings& settings = TExecSchemeQuerySettings());
-
+    TAsyncDescribeTableResult DescribeTable(const TString& path, 
+        const TDescribeTableSettings& settings = TDescribeTableSettings()); 
+ 
+    TAsyncBeginTransactionResult BeginTransaction(const TTxSettings& txSettings = TTxSettings(), 
+        const TBeginTxSettings& settings = TBeginTxSettings()); 
+ 
+    TAsyncExplainDataQueryResult ExplainDataQuery(const TString& query, 
+        const TExplainDataQuerySettings& settings = TExplainDataQuerySettings()); 
+ 
+    TAsyncPrepareQueryResult PrepareDataQuery(const TString& query, 
+        const TPrepareDataQuerySettings& settings = TPrepareDataQuerySettings()); 
+ 
+    TAsyncDataQueryResult ExecuteDataQuery(const TString& query, const TTxControl& txControl, 
+        const TExecDataQuerySettings& settings = TExecDataQuerySettings()); 
+ 
+    TAsyncDataQueryResult ExecuteDataQuery(const TString& query, const TTxControl& txControl, 
+        const TParams& params, const TExecDataQuerySettings& settings = TExecDataQuerySettings()); 
+ 
+    TAsyncDataQueryResult ExecuteDataQuery(const TString& query, const TTxControl& txControl, 
+        TParams&& params, const TExecDataQuerySettings& settings = TExecDataQuerySettings()); 
+ 
+    TAsyncStatus ExecuteSchemeQuery(const TString& query, 
+        const TExecSchemeQuerySettings& settings = TExecSchemeQuerySettings()); 
+ 
     TAsyncTablePartIterator ReadTable(const TString& path,
         const TReadTableSettings& settings = TReadTableSettings());
 
-    TAsyncStatus Close(const TCloseSessionSettings& settings = TCloseSessionSettings());
-
+    TAsyncStatus Close(const TCloseSessionSettings& settings = TCloseSessionSettings()); 
+ 
     TAsyncKeepAliveResult KeepAlive(const TKeepAliveSettings& settings = TKeepAliveSettings());
 
-    void InvalidateQueryCache();
-
-    //! Returns new table builder
-    TTableBuilder GetTableBuilder();
-    //! Returns new params builder
-    TParamsBuilder GetParamsBuilder();
-    //! Returns new type builder
-    TTypeBuilder GetTypeBuilder();
+    void InvalidateQueryCache(); 
+ 
+    //! Returns new table builder 
+    TTableBuilder GetTableBuilder(); 
+    //! Returns new params builder 
+    TParamsBuilder GetParamsBuilder(); 
+    //! Returns new type builder 
+    TTypeBuilder GetTypeBuilder(); 
     //! Returns session id
-    const TString& GetId() const;
-
+    const TString& GetId() const; 
+ 
     class TImpl;
-private:
+private: 
     TSession(std::shared_ptr<TTableClient::TImpl> client, const TString& sessionId, const TString& endpointId);
-    TSession(std::shared_ptr<TTableClient::TImpl> client, std::shared_ptr<TSession::TImpl> SessionImpl_);
-
-    std::shared_ptr<TTableClient::TImpl> Client_;
-    std::shared_ptr<TSession::TImpl> SessionImpl_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-template<typename TResult>
-TAsyncStatus TTableClient::RetryOperation(
+    TSession(std::shared_ptr<TTableClient::TImpl> client, std::shared_ptr<TSession::TImpl> SessionImpl_); 
+ 
+    std::shared_ptr<TTableClient::TImpl> Client_; 
+    std::shared_ptr<TSession::TImpl> SessionImpl_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+template<typename TResult> 
+TAsyncStatus TTableClient::RetryOperation( 
     std::function<NThreading::TFuture<TResult>(TSession session)>&& operation,
     const TRetryOperationSettings& settings)
 {
@@ -1576,16 +1576,16 @@ TAsyncStatus TTableClient::RetryOperation(
 
 template<typename TResult>
 TAsyncStatus TTableClient::RetryOperation(
-    const std::function<NThreading::TFuture<TResult>(TSession session)>& operation,
-    const TRetryOperationSettings& settings)
-{
-    return RetryOperation([operation] (TSession session) {
-        return operation(session).Apply([] (const NThreading::TFuture<TResult>& result) {
-            return NThreading::MakeFuture<TStatus>(result.GetValue());
-        });
-    }, settings);
-}
-
+    const std::function<NThreading::TFuture<TResult>(TSession session)>& operation, 
+    const TRetryOperationSettings& settings) 
+{ 
+    return RetryOperation([operation] (TSession session) { 
+        return operation(session).Apply([] (const NThreading::TFuture<TResult>& result) { 
+            return NThreading::MakeFuture<TStatus>(result.GetValue()); 
+        }); 
+    }, settings); 
+} 
+ 
 template<typename TResult>
 TAsyncStatus TTableClient::RetryOperation(
     std::function<NThreading::TFuture<TResult>(TTableClient& tableClient)>&& operation,
@@ -1610,142 +1610,142 @@ TAsyncStatus TTableClient::RetryOperation(
     }, settings);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-//! Represents data transaction
-class TTransaction {
-    friend class TTableClient;
-public:
-    const TString& GetId() const {
-        return TxId_;
-    }
-
-    bool IsActive() const {
-        return !TxId_.empty();
-    }
-
-    TAsyncCommitTransactionResult Commit(const TCommitTxSettings& settings = TCommitTxSettings());
-    TAsyncStatus Rollback(const TRollbackTxSettings& settings = TRollbackTxSettings());
-
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//! Represents data transaction 
+class TTransaction { 
+    friend class TTableClient; 
+public: 
+    const TString& GetId() const { 
+        return TxId_; 
+    } 
+ 
+    bool IsActive() const { 
+        return !TxId_.empty(); 
+    } 
+ 
+    TAsyncCommitTransactionResult Commit(const TCommitTxSettings& settings = TCommitTxSettings()); 
+    TAsyncStatus Rollback(const TRollbackTxSettings& settings = TRollbackTxSettings()); 
+ 
     TSession GetSession() const {
         return Session_;
     }
 
-private:
-    TTransaction(const TSession& session, const TString& txId);
-
-    TSession Session_;
-    TString TxId_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-//! Represents query identificator (e.g. used for prepared query)
-class TDataQuery {
-    friend class TTableClient;
-    friend class TSession;
-
-public:
-    const TString& GetId() const;
-    const TMaybe<TString>& GetText() const;
-    TParamsBuilder GetParamsBuilder() const;
-
-    TAsyncDataQueryResult Execute(const TTxControl& txControl,
-        const TExecDataQuerySettings& settings = TExecDataQuerySettings());
-
-    TAsyncDataQueryResult Execute(const TTxControl& txControl, const TParams& params,
+private: 
+    TTransaction(const TSession& session, const TString& txId); 
+ 
+    TSession Session_; 
+    TString TxId_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//! Represents query identificator (e.g. used for prepared query) 
+class TDataQuery { 
+    friend class TTableClient; 
+    friend class TSession; 
+ 
+public: 
+    const TString& GetId() const; 
+    const TMaybe<TString>& GetText() const; 
+    TParamsBuilder GetParamsBuilder() const; 
+ 
+    TAsyncDataQueryResult Execute(const TTxControl& txControl, 
+        const TExecDataQuerySettings& settings = TExecDataQuerySettings()); 
+ 
+    TAsyncDataQueryResult Execute(const TTxControl& txControl, const TParams& params, 
+        const TExecDataQuerySettings& settings = TExecDataQuerySettings()); 
+ 
+    TAsyncDataQueryResult Execute(const TTxControl& txControl, TParams&& params, 
         const TExecDataQuerySettings& settings = TExecDataQuerySettings());
 
-    TAsyncDataQueryResult Execute(const TTxControl& txControl, TParams&& params,
-        const TExecDataQuerySettings& settings = TExecDataQuerySettings());
-
-private:
-    TDataQuery(const TSession& session, const TString& text, const TString& id);
-    TDataQuery(const TSession& session, const TString& text, const TString& id,
-        const ::google::protobuf::Map<TString, Ydb::Type>& types);
-
-    class TImpl;
-    std::shared_ptr<TImpl> Impl_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-//! Represents result of PrepareDataQuery call.
-//! If result is successful TDataQuery should be used for next
-//! ExecuteDataQuery calls
-class TPrepareQueryResult : public TStatus {
-public:
-    TPrepareQueryResult(TStatus&& status, const TDataQuery& query, bool fromCache);
-
-    TDataQuery GetQuery() const;
-    bool IsQueryFromCache() const;
-
-private:
-    TDataQuery PreparedQuery_;
-    bool FromCache_;
-};
-
-//! Represents result of ExplainDataQuery call
-class TExplainQueryResult : public TStatus {
-public:
-    TExplainQueryResult(TStatus&& status, TString&& plan, TString&& ast);
-
-    const TString& GetPlan() const;
-    const TString& GetAst() const;
-
-private:
-    TString Plan_;
-    TString Ast_;
-};
-
-//! Represents result of DescribeTable call
-class TDescribeTableResult : public TStatus {
-public:
-    TDescribeTableResult(TStatus&& status, Ydb::Table::DescribeTableResult&& desc,
-        const TDescribeTableSettings& describeSettings);
-
-    TTableDescription GetTableDescription() const;
-
-private:
-    TTableDescription TableDescription_;
-
-};
-
-class TDataQueryResult : public TStatus {
-public:
-    TDataQueryResult(TStatus&& status, TVector<TResultSet>&& resultSets, const TMaybe<TTransaction>& transaction,
+private: 
+    TDataQuery(const TSession& session, const TString& text, const TString& id); 
+    TDataQuery(const TSession& session, const TString& text, const TString& id, 
+        const ::google::protobuf::Map<TString, Ydb::Type>& types); 
+ 
+    class TImpl; 
+    std::shared_ptr<TImpl> Impl_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//! Represents result of PrepareDataQuery call. 
+//! If result is successful TDataQuery should be used for next 
+//! ExecuteDataQuery calls 
+class TPrepareQueryResult : public TStatus { 
+public: 
+    TPrepareQueryResult(TStatus&& status, const TDataQuery& query, bool fromCache); 
+ 
+    TDataQuery GetQuery() const; 
+    bool IsQueryFromCache() const; 
+ 
+private: 
+    TDataQuery PreparedQuery_; 
+    bool FromCache_; 
+}; 
+ 
+//! Represents result of ExplainDataQuery call 
+class TExplainQueryResult : public TStatus { 
+public: 
+    TExplainQueryResult(TStatus&& status, TString&& plan, TString&& ast); 
+ 
+    const TString& GetPlan() const; 
+    const TString& GetAst() const; 
+ 
+private: 
+    TString Plan_; 
+    TString Ast_; 
+}; 
+ 
+//! Represents result of DescribeTable call 
+class TDescribeTableResult : public TStatus { 
+public: 
+    TDescribeTableResult(TStatus&& status, Ydb::Table::DescribeTableResult&& desc, 
+        const TDescribeTableSettings& describeSettings); 
+ 
+    TTableDescription GetTableDescription() const; 
+ 
+private: 
+    TTableDescription TableDescription_; 
+
+}; 
+ 
+class TDataQueryResult : public TStatus { 
+public: 
+    TDataQueryResult(TStatus&& status, TVector<TResultSet>&& resultSets, const TMaybe<TTransaction>& transaction, 
         const TMaybe<TDataQuery>& dataQuery, bool fromCache, const TMaybe<TQueryStats>& queryStats);
-
-    const TVector<TResultSet>& GetResultSets() const;
-    TResultSet GetResultSet(size_t resultIndex) const;
-
-    TResultSetParser GetResultSetParser(size_t resultIndex) const;
-
+ 
+    const TVector<TResultSet>& GetResultSets() const; 
+    TResultSet GetResultSet(size_t resultIndex) const; 
+ 
+    TResultSetParser GetResultSetParser(size_t resultIndex) const; 
+ 
     TMaybe<TTransaction> GetTransaction() const;
-
-    TMaybe<TDataQuery> GetQuery() const;
-    bool IsQueryFromCache() const;
-
+ 
+    TMaybe<TDataQuery> GetQuery() const; 
+    bool IsQueryFromCache() const; 
+ 
     const TMaybe<TQueryStats>& GetStats() const;
 
     const TString GetQueryPlan() const;
 
-private:
-    TMaybe<TTransaction> Transaction_;
-    TVector<TResultSet> ResultSets_;
-    TMaybe<TDataQuery> DataQuery_;
-    bool FromCache_;
+private: 
+    TMaybe<TTransaction> Transaction_; 
+    TVector<TResultSet> ResultSets_; 
+    TMaybe<TDataQuery> DataQuery_; 
+    bool FromCache_; 
     TMaybe<TQueryStats> QueryStats_;
-};
-
+}; 
+ 
 template<typename TPart>
-class TSimpleStreamPart : public TStreamPartStatus {
+class TSimpleStreamPart : public TStreamPartStatus { 
 public:
     const TPart& GetPart() const { return Part_; }
 
     TPart ExtractPart() { return std::move(Part_); }
 
-    TSimpleStreamPart(TPart&& part, TStatus&& status)
+    TSimpleStreamPart(TPart&& part, TStatus&& status) 
         : TStreamPartStatus(std::move(status))
         , Part_(std::move(part))
     {}
@@ -1755,12 +1755,12 @@ private:
 };
 
 template<typename TPart>
-using TAsyncSimpleStreamPart = NThreading::TFuture<TSimpleStreamPart<TPart>>;
+using TAsyncSimpleStreamPart = NThreading::TFuture<TSimpleStreamPart<TPart>>; 
 
 class TTablePartIterator : public TStatus {
     friend class TSession;
 public:
-    TAsyncSimpleStreamPart<TResultSet> ReadNext();
+    TAsyncSimpleStreamPart<TResultSet> ReadNext(); 
     class TReaderImpl;
 private:
     TTablePartIterator(
@@ -1770,83 +1770,83 @@ private:
     std::shared_ptr<TReaderImpl> ReaderImpl_;
 };
 
-using TReadTableResultPart = TSimpleStreamPart<TResultSet>;
-
-class TScanQueryPart : public TStreamPartStatus {
-public:
-    bool HasResultSet() const { return ResultSet_.Defined(); }
-    const TResultSet& GetResultSet() const { return *ResultSet_; }
-    TResultSet ExtractResultSet() { return std::move(*ResultSet_); }
-
+using TReadTableResultPart = TSimpleStreamPart<TResultSet>; 
+ 
+class TScanQueryPart : public TStreamPartStatus { 
+public: 
+    bool HasResultSet() const { return ResultSet_.Defined(); } 
+    const TResultSet& GetResultSet() const { return *ResultSet_; } 
+    TResultSet ExtractResultSet() { return std::move(*ResultSet_); } 
+ 
     bool HasQueryStats() const { return QueryStats_.Defined(); }
     const TQueryStats& GetQueryStats() const { return *QueryStats_; }
     TQueryStats ExtractQueryStats() { return std::move(*QueryStats_); }
 
-    TScanQueryPart(TStatus&& status)
-        : TStreamPartStatus(std::move(status))
-    {}
-
+    TScanQueryPart(TStatus&& status) 
+        : TStreamPartStatus(std::move(status)) 
+    {} 
+ 
     TScanQueryPart(TStatus&& status, const TMaybe<TQueryStats> &queryStats)
-        : TStreamPartStatus(std::move(status))
+        : TStreamPartStatus(std::move(status)) 
         , QueryStats_(queryStats)
     {}
 
     TScanQueryPart(TStatus&& status, TResultSet&& resultSet, const TMaybe<TQueryStats> &queryStats)
         : TStreamPartStatus(std::move(status))
-        , ResultSet_(std::move(resultSet))
+        , ResultSet_(std::move(resultSet)) 
         , QueryStats_(queryStats)
-    {}
-
-private:
-    TMaybe<TResultSet> ResultSet_;
+    {} 
+ 
+private: 
+    TMaybe<TResultSet> ResultSet_; 
     TMaybe<TQueryStats> QueryStats_;
-};
-
-using TAsyncScanQueryPart = NThreading::TFuture<TScanQueryPart>;
-
-class TScanQueryPartIterator : public TStatus {
-    friend class TTableClient;
-public:
-    TAsyncScanQueryPart ReadNext();
-    class TReaderImpl;
-private:
-    TScanQueryPartIterator(
-        std::shared_ptr<TReaderImpl> impl,
+}; 
+ 
+using TAsyncScanQueryPart = NThreading::TFuture<TScanQueryPart>; 
+ 
+class TScanQueryPartIterator : public TStatus { 
+    friend class TTableClient; 
+public: 
+    TAsyncScanQueryPart ReadNext(); 
+    class TReaderImpl; 
+private: 
+    TScanQueryPartIterator( 
+        std::shared_ptr<TReaderImpl> impl, 
         TPlainStatus&& status
-    );
-    std::shared_ptr<TReaderImpl> ReaderImpl_;
-};
-
-class TBeginTransactionResult : public TStatus {
-public:
-    TBeginTransactionResult(TStatus&& status, TTransaction transaction);
-
-    const TTransaction& GetTransaction() const;
-
-private:
-    TTransaction Transaction_;
-};
-
-class TCommitTransactionResult : public TStatus {
-public:
-    TCommitTransactionResult(TStatus&& status, const TMaybe<TQueryStats>& queryStats);
-
-    const TMaybe<TQueryStats>& GetStats() const;
-
-private:
-    TMaybe<TQueryStats> QueryStats_;
-};
-
-class TCreateSessionResult: public TStatus {
+    ); 
+    std::shared_ptr<TReaderImpl> ReaderImpl_; 
+}; 
+ 
+class TBeginTransactionResult : public TStatus { 
+public: 
+    TBeginTransactionResult(TStatus&& status, TTransaction transaction); 
+ 
+    const TTransaction& GetTransaction() const; 
+ 
+private: 
+    TTransaction Transaction_; 
+}; 
+ 
+class TCommitTransactionResult : public TStatus { 
+public: 
+    TCommitTransactionResult(TStatus&& status, const TMaybe<TQueryStats>& queryStats); 
+ 
+    const TMaybe<TQueryStats>& GetStats() const; 
+ 
+private: 
+    TMaybe<TQueryStats> QueryStats_; 
+}; 
+ 
+class TCreateSessionResult: public TStatus { 
     friend class TSession::TImpl;
-public:
-    TCreateSessionResult(TStatus&& status, TSession&& session);
-    TSession GetSession() const;
-
-private:
-    TSession Session_;
-};
-
+public: 
+    TCreateSessionResult(TStatus&& status, TSession&& session); 
+    TSession GetSession() const; 
+ 
+private: 
+    TSession Session_; 
+}; 
+ 
 enum class ESessionStatus {
     Unspecified = 0,
     Ready = 1,
@@ -1866,8 +1866,8 @@ public:
     explicit TBulkUpsertResult(TStatus&& status);
 };
 
-} // namespace NTable
-} // namespace NYdb
+} // namespace NTable 
+} // namespace NYdb 
 
 Y_DECLARE_OUT_SPEC(inline, NYdb::NTable::TIndexDescription, o, x) {
     return x.Out(o);
diff --git a/ydb/public/sdk/cpp/client/ydb_types/exceptions/exceptions.cpp b/ydb/public/sdk/cpp/client/ydb_types/exceptions/exceptions.cpp
index f103a88ecc..267c2e594b 100644
--- a/ydb/public/sdk/cpp/client/ydb_types/exceptions/exceptions.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_types/exceptions/exceptions.cpp
@@ -1,12 +1,12 @@
 #include "exceptions.h"
 
-namespace NYdb {
+namespace NYdb { 
 
-TYdbException::TYdbException(const TString& reason) {
+TYdbException::TYdbException(const TString& reason) { 
     Append(reason);
 }
 
 TContractViolation::TContractViolation(const TString& reason)
-    : TYdbException(reason) {}
+    : TYdbException(reason) {} 
 
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_types/exceptions/exceptions.h b/ydb/public/sdk/cpp/client/ydb_types/exceptions/exceptions.h
index 38c94b168a..b3cba63e0a 100644
--- a/ydb/public/sdk/cpp/client/ydb_types/exceptions/exceptions.h
+++ b/ydb/public/sdk/cpp/client/ydb_types/exceptions/exceptions.h
@@ -2,17 +2,17 @@
 
 #include <util/generic/yexception.h>
 
-namespace NYdb {
+namespace NYdb { 
 
-class TYdbException : public yexception {
+class TYdbException : public yexception { 
 public:
     using yexception::yexception;
-    TYdbException(const TString& reason);
+    TYdbException(const TString& reason); 
 };
 
-class TContractViolation : public TYdbException {
+class TContractViolation : public TYdbException { 
 public:
     TContractViolation(const TString& reason);
 };
 
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_types/status_codes.h b/ydb/public/sdk/cpp/client/ydb_types/status_codes.h
index 9bc239c057..d6156b00ac 100644
--- a/ydb/public/sdk/cpp/client/ydb_types/status_codes.h
+++ b/ydb/public/sdk/cpp/client/ydb_types/status_codes.h
@@ -2,7 +2,7 @@
 
 #include <util/system/types.h>
 
-namespace NYdb {
+namespace NYdb { 
 
 constexpr size_t TRANSPORT_STATUSES_FIRST = 401000;
 constexpr size_t TRANSPORT_STATUSES_LAST  = 401999;
@@ -10,7 +10,7 @@ constexpr size_t INTERNAL_CLIENT_FIRST = 402000;
 
 enum class EStatus : size_t {
     // Server statuses
-    STATUS_UNDEFINED =    0,
+    STATUS_UNDEFINED =    0, 
     SUCCESS =             400000,
     BAD_REQUEST =         400010,
     UNAUTHORIZED =        400020,
@@ -24,12 +24,12 @@ enum class EStatus : size_t {
     BAD_SESSION =         400100,
     PRECONDITION_FAILED = 400120,
     ALREADY_EXISTS      = 400130,
-    NOT_FOUND =           400140,
-    SESSION_EXPIRED =     400150,
-    CANCELLED =           400160,
-    UNDETERMINED =        400170,
-    UNSUPPORTED =         400180,
-    SESSION_BUSY =        400190,
+    NOT_FOUND =           400140, 
+    SESSION_EXPIRED =     400150, 
+    CANCELLED =           400160, 
+    UNDETERMINED =        400170, 
+    UNSUPPORTED =         400180, 
+    SESSION_BUSY =        400190, 
 
     // Client statuses
     // Cannot connect or unrecoverable network error. (map from gRPC UNAVAILABLE)
@@ -50,4 +50,4 @@ enum class EStatus : size_t {
     CLIENT_LIMITS_REACHED =      INTERNAL_CLIENT_FIRST    + 20
 };
 
-} // namespace NYdb
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_value/value.cpp b/ydb/public/sdk/cpp/client/ydb_value/value.cpp
index 8c18d4d50f..206a14bb49 100644
--- a/ydb/public/sdk/cpp/client/ydb_value/value.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_value/value.cpp
@@ -3,53 +3,53 @@
 #define INCLUDE_YDB_INTERNAL_H
 #include <ydb/public/sdk/cpp/client/impl/ydb_internal/value_helpers/helpers.h>
 #undef INCLUDE_YDB_INTERNAL_H
-
+ 
 #include <ydb/public/sdk/cpp/client/ydb_params/params.h>
 #include <ydb/public/sdk/cpp/client/ydb_proto/accessor.h>
 #include <ydb/public/sdk/cpp/client/ydb_types/fatal_error_handlers/handlers.h>
 
 #include <ydb/public/api/protos/ydb_value.pb.h>
-
+ 
 #include <library/cpp/containers/stack_vector/stack_vec.h>
-
+ 
 #include <ydb/library/yql/public/decimal/yql_decimal.h>
 
 #include <util/generic/bitmap.h>
 #include <util/generic/map.h>
-#include <util/string/builder.h>
-
-namespace NYdb {
-
+#include <util/string/builder.h> 
+ 
+namespace NYdb { 
+ 
 static void CheckKind(TTypeParser::ETypeKind actual, TTypeParser::ETypeKind expected, const TString& method)
-{
-    if (expected != actual) {
+{ 
+    if (expected != actual) { 
         ThrowFatalError(TStringBuilder() << method << "(): invalid state, expected type: "
-            << expected << ", actual: " << actual);
-    }
-}
-
+            << expected << ", actual: " << actual); 
+    } 
+} 
+ 
 static TTypeParser::ETypeKind GetKind(const Ydb::Type& type) {
-    using ETypeKind = TTypeParser::ETypeKind;
-
-    switch (type.type_case()) {
-        case Ydb::Type::kTypeId:
-            return ETypeKind::Primitive;
-        case Ydb::Type::kDecimalType:
-            return ETypeKind::Decimal;
-        case Ydb::Type::kOptionalType:
-            return ETypeKind::Optional;
-        case Ydb::Type::kListType:
-            return ETypeKind::List;
-        case Ydb::Type::kTupleType:
-            return ETypeKind::Tuple;
-        case Ydb::Type::kStructType:
-            return ETypeKind::Struct;
-        case Ydb::Type::kDictType:
-            return ETypeKind::Dict;
-        case Ydb::Type::kVariantType:
-            return ETypeKind::Variant;
-        case Ydb::Type::kVoidType:
-            return ETypeKind::Void;
+    using ETypeKind = TTypeParser::ETypeKind; 
+ 
+    switch (type.type_case()) { 
+        case Ydb::Type::kTypeId: 
+            return ETypeKind::Primitive; 
+        case Ydb::Type::kDecimalType: 
+            return ETypeKind::Decimal; 
+        case Ydb::Type::kOptionalType: 
+            return ETypeKind::Optional; 
+        case Ydb::Type::kListType: 
+            return ETypeKind::List; 
+        case Ydb::Type::kTupleType: 
+            return ETypeKind::Tuple; 
+        case Ydb::Type::kStructType: 
+            return ETypeKind::Struct; 
+        case Ydb::Type::kDictType: 
+            return ETypeKind::Dict; 
+        case Ydb::Type::kVariantType: 
+            return ETypeKind::Variant; 
+        case Ydb::Type::kVoidType: 
+            return ETypeKind::Void; 
         case Ydb::Type::kNullType:
             return ETypeKind::Null;
         case Ydb::Type::kEmptyListType:
@@ -58,39 +58,39 @@ static TTypeParser::ETypeKind GetKind(const Ydb::Type& type) {
             return ETypeKind::EmptyDict;
         case Ydb::Type::kTaggedType:
             return ETypeKind::Tagged;
-        default:
-            break;
-    }
-
+        default: 
+            break; 
+    } 
+ 
     ThrowFatalError(TStringBuilder() << "Unexpected proto type kind: " << (ui32) type.type_case());
-    return ETypeKind::Void;
-}
-
+    return ETypeKind::Void; 
+} 
+ 
 bool TypesEqual(const TType& t1, const TType& t2) {
-    return TypesEqual(TProtoAccessor::GetProto(t1), TProtoAccessor::GetProto(t2));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TType::TImpl {
-public:
-    TImpl(const Ydb::Type& typeProto)
-        : ProtoType_(typeProto) {}
-
-    TImpl(Ydb::Type&& typeProto)
-        : ProtoType_(std::move(typeProto)) {}
-
-    const Ydb::Type ProtoType_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-TType::TType(const Ydb::Type& typeProto)
-    : Impl_(new TImpl(typeProto)) {}
-
-TType::TType(Ydb::Type&& typeProto)
-    : Impl_(new TImpl(std::move(typeProto))) {}
-
+    return TypesEqual(TProtoAccessor::GetProto(t1), TProtoAccessor::GetProto(t2)); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+class TType::TImpl { 
+public: 
+    TImpl(const Ydb::Type& typeProto) 
+        : ProtoType_(typeProto) {} 
+ 
+    TImpl(Ydb::Type&& typeProto) 
+        : ProtoType_(std::move(typeProto)) {} 
+ 
+    const Ydb::Type ProtoType_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TType::TType(const Ydb::Type& typeProto) 
+    : Impl_(new TImpl(typeProto)) {} 
+ 
+TType::TType(Ydb::Type&& typeProto) 
+    : Impl_(new TImpl(std::move(typeProto))) {} 
+ 
 TString TType::ToString() const {
     return FormatType(*this);
 }
@@ -99,47 +99,47 @@ void TType::Out(IOutputStream& o) const {
     o << FormatType(*this);
 }
 
-const Ydb::Type& TType::GetProto() const {
-    return Impl_->ProtoType_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TTypeParser::TImpl {
-public:
+const Ydb::Type& TType::GetProto() const { 
+    return Impl_->ProtoType_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+class TTypeParser::TImpl { 
+public: 
     TImpl(const TType& type)
-        : Type_(type)
-    {
-        Reset();
-    }
-
-    void Reset() {
-        Path_.clear();
-        Path_.emplace_back(TProtoPosition{&TProtoAccessor::GetProto(Type_), -1});
-    }
-
-    ETypeKind GetKind(ui32 offset = 0) const {
+        : Type_(type) 
+    { 
+        Reset(); 
+    } 
+ 
+    void Reset() { 
+        Path_.clear(); 
+        Path_.emplace_back(TProtoPosition{&TProtoAccessor::GetProto(Type_), -1}); 
+    } 
+ 
+    ETypeKind GetKind(ui32 offset = 0) const { 
         return NYdb::GetKind(GetProto(offset));
-    }
-
-    EPrimitiveType GetPrimitive() const {
-        CheckKind(ETypeKind::Primitive, "GetPrimitive");
-        return EPrimitiveType(GetProto().type_id());
-    }
-
-    TDecimalType GetDecimal() const {
-        CheckKind(ETypeKind::Decimal, "GetDecimal");
-        return TDecimalType(
-            GetProto().decimal_type().precision(),
-            GetProto().decimal_type().scale());
-    }
-
-    template<ETypeKind kind>
-    void Open() {
-        CheckKind(kind, "Open");
-        ForwardStep();
-    }
-
+    } 
+ 
+    EPrimitiveType GetPrimitive() const { 
+        CheckKind(ETypeKind::Primitive, "GetPrimitive"); 
+        return EPrimitiveType(GetProto().type_id()); 
+    } 
+ 
+    TDecimalType GetDecimal() const { 
+        CheckKind(ETypeKind::Decimal, "GetDecimal"); 
+        return TDecimalType( 
+            GetProto().decimal_type().precision(), 
+            GetProto().decimal_type().scale()); 
+    } 
+ 
+    template<ETypeKind kind> 
+    void Open() { 
+        CheckKind(kind, "Open"); 
+        ForwardStep(); 
+    } 
+ 
     void OpenVariant(int index) {
         CheckKind(ETypeKind::Variant, "Open");
         const Ydb::VariantType& variantType = GetProto().variant_type();
@@ -168,103 +168,103 @@ public:
         Path_.emplace_back(TProtoPosition{nextPtr, -1});
     }
 
-    template<ETypeKind kind>
-    void Close() {
-        CheckPreviousKind(kind, "Close");
-        BackwardStep();
-        Path_.back().Idx = -1;
-    }
-
-    const TString& GetMemberName() {
-        CheckPreviousKind(ETypeKind::Struct, "GetMemberName");
-        return GetProto(1).struct_type().members(Path_[Path_.size() - 2].Idx).name();
-    }
-
-    template<ETypeKind kind>
-    bool TryNext() {
-        CheckPreviousKind(kind, "TryNext");
-
-        BackwardStep();
-        Path_.back().Idx++;
-        return ForwardStep();
-    }
-
-    void DictKey() {
-        CheckPreviousKind(ETypeKind::Dict, "DictKey");
-        BackwardStep();
-        Path_.back().Idx = 0;
-        ForwardStep();
-    }
-
-    void DictPayload() {
-        CheckPreviousKind(ETypeKind::Dict, "DictPayload");
-        BackwardStep();
-        Path_.back().Idx = 1;
-        ForwardStep();
-    }
-
+    template<ETypeKind kind> 
+    void Close() { 
+        CheckPreviousKind(kind, "Close"); 
+        BackwardStep(); 
+        Path_.back().Idx = -1; 
+    } 
+ 
+    const TString& GetMemberName() { 
+        CheckPreviousKind(ETypeKind::Struct, "GetMemberName"); 
+        return GetProto(1).struct_type().members(Path_[Path_.size() - 2].Idx).name(); 
+    } 
+ 
+    template<ETypeKind kind> 
+    bool TryNext() { 
+        CheckPreviousKind(kind, "TryNext"); 
+ 
+        BackwardStep(); 
+        Path_.back().Idx++; 
+        return ForwardStep(); 
+    } 
+ 
+    void DictKey() { 
+        CheckPreviousKind(ETypeKind::Dict, "DictKey"); 
+        BackwardStep(); 
+        Path_.back().Idx = 0; 
+        ForwardStep(); 
+    } 
+ 
+    void DictPayload() { 
+        CheckPreviousKind(ETypeKind::Dict, "DictPayload"); 
+        BackwardStep(); 
+        Path_.back().Idx = 1; 
+        ForwardStep(); 
+    } 
+ 
     const TString& GetTag() {
         CheckPreviousKind(ETypeKind::Tagged, "GetTag");
         return GetProto(1).tagged_type().tag();
     }
 
-    bool ForwardStep() {
-        auto& idx = Path_.back().Idx;
-        const google::protobuf::Message* nextPtr = nullptr;
-        bool hasIdx = true;
-
-        switch (GetKind()) {
-            case ETypeKind::Optional:
-                nextPtr = &GetProto().optional_type().item();
-                break;
-
-            case ETypeKind::List:
-                nextPtr = &GetProto().list_type().item();
-                break;
-
-            case ETypeKind::Struct: {
-                if (idx >= 0) {
-                    auto& structType = GetProto().struct_type();
-                    if (idx >= structType.members_size()) {
-                        idx = structType.members_size() - 1;
-                        hasIdx = false;
-                    }
+    bool ForwardStep() { 
+        auto& idx = Path_.back().Idx; 
+        const google::protobuf::Message* nextPtr = nullptr; 
+        bool hasIdx = true; 
+ 
+        switch (GetKind()) { 
+            case ETypeKind::Optional: 
+                nextPtr = &GetProto().optional_type().item(); 
+                break; 
+ 
+            case ETypeKind::List: 
+                nextPtr = &GetProto().list_type().item(); 
+                break; 
+ 
+            case ETypeKind::Struct: { 
+                if (idx >= 0) { 
+                    auto& structType = GetProto().struct_type(); 
+                    if (idx >= structType.members_size()) { 
+                        idx = structType.members_size() - 1; 
+                        hasIdx = false; 
+                    } 
                     if (idx >= 0) {
                         nextPtr = &structType.members(idx).type();
                     }
-                } else {
-                    nextPtr = &GetProto();
-                }
-                break;
-            }
-
-            case ETypeKind::Tuple: {
-                if (idx >= 0) {
-                    auto& tupleType = GetProto().tuple_type();
-                    if (idx >= tupleType.elements_size()) {
-                        idx = tupleType.elements_size() - 1;
-                        hasIdx = false;
-                    }
+                } else { 
+                    nextPtr = &GetProto(); 
+                } 
+                break; 
+            } 
+ 
+            case ETypeKind::Tuple: { 
+                if (idx >= 0) { 
+                    auto& tupleType = GetProto().tuple_type(); 
+                    if (idx >= tupleType.elements_size()) { 
+                        idx = tupleType.elements_size() - 1; 
+                        hasIdx = false; 
+                    } 
                     if (idx >= 0) {
                         nextPtr = &tupleType.elements(idx);
                     }
-                } else {
-                    nextPtr = &GetProto();
-                }
-                break;
-            }
-
-            case ETypeKind::Dict: {
-                if (idx == 0) {
-                    nextPtr = &GetProto().dict_type().key();
-                } else if (idx == 1) {
-                    nextPtr = &GetProto().dict_type().payload();
-                } else {
-                    nextPtr = &GetProto();
-                }
-                break;
-            }
-
+                } else { 
+                    nextPtr = &GetProto(); 
+                } 
+                break; 
+            } 
+ 
+            case ETypeKind::Dict: { 
+                if (idx == 0) { 
+                    nextPtr = &GetProto().dict_type().key(); 
+                } else if (idx == 1) { 
+                    nextPtr = &GetProto().dict_type().payload(); 
+                } else { 
+                    nextPtr = &GetProto(); 
+                } 
+                break; 
+            } 
+ 
             case ETypeKind::Variant: {
                 const Ydb::VariantType& variantType = GetProto().variant_type();
                 auto wrappedVariant = std::make_unique<Ydb::Type>();
@@ -292,137 +292,137 @@ public:
                 break;
             }
 
-            default:
-                FatalError(TStringBuilder() << "Unexpected type kind: " << GetKind());
-                break;
-        }
-
-        Path_.emplace_back(TProtoPosition{nextPtr, -1});
-        return hasIdx;
-    }
-
-private:
-    void CheckKind(ETypeKind kind, const TString& method) const {
+            default: 
+                FatalError(TStringBuilder() << "Unexpected type kind: " << GetKind()); 
+                break; 
+        } 
+ 
+        Path_.emplace_back(TProtoPosition{nextPtr, -1}); 
+        return hasIdx; 
+    } 
+ 
+private: 
+    void CheckKind(ETypeKind kind, const TString& method) const { 
         NYdb::CheckKind(GetKind(), kind, method);
-    }
-
-    void CheckPreviousKind(ETypeKind kind, const TString method) const {
-        if (Path_.size() < 2) {
-            FatalError("Expected container type.");
-            return;
-        }
-
+    } 
+ 
+    void CheckPreviousKind(ETypeKind kind, const TString method) const { 
+        if (Path_.size() < 2) { 
+            FatalError("Expected container type."); 
+            return; 
+        } 
+ 
         NYdb::CheckKind(GetKind(1), kind, method);
-    }
-
-    const Ydb::Type& GetProto(ui32 offset = 0) const {
-        return *static_cast<const Ydb::Type*>(Path_[Path_.size() - (offset + 1)].Ptr);
-    }
-
-    void BackwardStep() {
-        Path_.pop_back();
-    }
-
-    void FatalError(const TString& msg) const {
+    } 
+ 
+    const Ydb::Type& GetProto(ui32 offset = 0) const { 
+        return *static_cast<const Ydb::Type*>(Path_[Path_.size() - (offset + 1)].Ptr); 
+    } 
+ 
+    void BackwardStep() { 
+        Path_.pop_back(); 
+    } 
+ 
+    void FatalError(const TString& msg) const { 
         ThrowFatalError(TStringBuilder() << "TTypeParser: " << msg);
-    }
-
-private:
-    struct TProtoPosition {
-        const google::protobuf::Message* Ptr;
-        i32 Idx;
-    };
-
-private:
-    TType Type_;
-    TStackVec<TProtoPosition, 8> Path_;
+    } 
+ 
+private: 
+    struct TProtoPosition { 
+        const google::protobuf::Message* Ptr; 
+        i32 Idx; 
+    }; 
+ 
+private: 
+    TType Type_; 
+    TStackVec<TProtoPosition, 8> Path_; 
     TStackVec<std::unique_ptr<Ydb::Type>, 8> WrappedVariants_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-TTypeParser::TTypeParser(TTypeParser&&) = default;
-TTypeParser::~TTypeParser() = default;
-
-TTypeParser::TTypeParser(const TType& type)
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TTypeParser::TTypeParser(TTypeParser&&) = default; 
+TTypeParser::~TTypeParser() = default; 
+ 
+TTypeParser::TTypeParser(const TType& type) 
     : Impl_(new TImpl(type)) {}
-
-TTypeParser::ETypeKind TTypeParser::GetKind() const {
-    return Impl_->GetKind();
-}
-
-EPrimitiveType TTypeParser::GetPrimitive() const {
-    return Impl_->GetPrimitive();
-}
-
-TDecimalType TTypeParser::GetDecimal() const {
-    return Impl_->GetDecimal();
-}
-
-void TTypeParser::OpenOptional() {
-    Impl_->Open<ETypeKind::Optional>();
-}
-
-void TTypeParser::CloseOptional() {
-    Impl_->Close<ETypeKind::Optional>();
-}
-
-void TTypeParser::OpenList() {
-    Impl_->Open<ETypeKind::List>();
-}
-
-void TTypeParser::CloseList() {
-    Impl_->Close<ETypeKind::List>();
-}
-
-void TTypeParser::OpenStruct() {
-    Impl_->Open<ETypeKind::Struct>();
-}
-
-void TTypeParser::CloseStruct() {
-    Impl_->Close<ETypeKind::Struct>();
-}
-
-const TString& TTypeParser::GetMemberName() {
-    return Impl_->GetMemberName();
-}
-
-bool TTypeParser::TryNextMember() {
-    return Impl_->TryNext<ETypeKind::Struct>();
-}
-
-void TTypeParser::OpenTuple() {
-    Impl_->Open<ETypeKind::Tuple>();
-}
-
-void TTypeParser::CloseTuple() {
-    Impl_->Close<ETypeKind::Tuple>();
-}
-
-bool TTypeParser::TryNextElement() {
-    return Impl_->TryNext<ETypeKind::Tuple>();
-}
-
-void TTypeParser::OpenDict() {
-    Impl_->Open<ETypeKind::Dict>();
-}
-
-void TTypeParser::CloseDict() {
-    Impl_->Close<ETypeKind::Dict>();
-}
-
-void TTypeParser::DictKey() {
-    Impl_->DictKey();
-}
-
-void TTypeParser::DictPayload() {
-    Impl_->DictPayload();
-}
-
+ 
+TTypeParser::ETypeKind TTypeParser::GetKind() const { 
+    return Impl_->GetKind(); 
+} 
+ 
+EPrimitiveType TTypeParser::GetPrimitive() const { 
+    return Impl_->GetPrimitive(); 
+} 
+ 
+TDecimalType TTypeParser::GetDecimal() const { 
+    return Impl_->GetDecimal(); 
+} 
+ 
+void TTypeParser::OpenOptional() { 
+    Impl_->Open<ETypeKind::Optional>(); 
+} 
+ 
+void TTypeParser::CloseOptional() { 
+    Impl_->Close<ETypeKind::Optional>(); 
+} 
+ 
+void TTypeParser::OpenList() { 
+    Impl_->Open<ETypeKind::List>(); 
+} 
+ 
+void TTypeParser::CloseList() { 
+    Impl_->Close<ETypeKind::List>(); 
+} 
+ 
+void TTypeParser::OpenStruct() { 
+    Impl_->Open<ETypeKind::Struct>(); 
+} 
+ 
+void TTypeParser::CloseStruct() { 
+    Impl_->Close<ETypeKind::Struct>(); 
+} 
+ 
+const TString& TTypeParser::GetMemberName() { 
+    return Impl_->GetMemberName(); 
+} 
+ 
+bool TTypeParser::TryNextMember() { 
+    return Impl_->TryNext<ETypeKind::Struct>(); 
+} 
+ 
+void TTypeParser::OpenTuple() { 
+    Impl_->Open<ETypeKind::Tuple>(); 
+} 
+ 
+void TTypeParser::CloseTuple() { 
+    Impl_->Close<ETypeKind::Tuple>(); 
+} 
+ 
+bool TTypeParser::TryNextElement() { 
+    return Impl_->TryNext<ETypeKind::Tuple>(); 
+} 
+ 
+void TTypeParser::OpenDict() { 
+    Impl_->Open<ETypeKind::Dict>(); 
+} 
+ 
+void TTypeParser::CloseDict() { 
+    Impl_->Close<ETypeKind::Dict>(); 
+} 
+ 
+void TTypeParser::DictKey() { 
+    Impl_->DictKey(); 
+} 
+ 
+void TTypeParser::DictPayload() { 
+    Impl_->DictPayload(); 
+}
+ 
 void TTypeParser::OpenVariant(size_t index) {
     Impl_->OpenVariant(index);
-}
-
+} 
+ 
 void TTypeParser::OpenVariant() {
     Impl_->Open<ETypeKind::Variant>();
 }
@@ -443,426 +443,426 @@ void TTypeParser::CloseTagged() {
     Impl_->Close<ETypeKind::Tagged>();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-void FormatTypeInternal(TTypeParser& parser, IOutputStream& out) {
-    switch (parser.GetKind()) {
-        case TTypeParser::ETypeKind::Primitive:
-            out << parser.GetPrimitive();
-            break;
-
-        case TTypeParser::ETypeKind::Decimal: {
-            auto decimal = parser.GetDecimal();
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+void FormatTypeInternal(TTypeParser& parser, IOutputStream& out) { 
+    switch (parser.GetKind()) { 
+        case TTypeParser::ETypeKind::Primitive: 
+            out << parser.GetPrimitive(); 
+            break; 
+ 
+        case TTypeParser::ETypeKind::Decimal: { 
+            auto decimal = parser.GetDecimal(); 
             out << "Decimal(" << (ui32)decimal.Precision << ',' << (ui32)decimal.Scale << ")";
-            //out << "Decimal";
-            break;
-        }
-
-        case TTypeParser::ETypeKind::Optional:
-            parser.OpenOptional();
-            FormatTypeInternal(parser, out);
-            parser.CloseOptional();
-            out << '?';
-            break;
-
-        case TTypeParser::ETypeKind::List:
-            out << "List<";
-            parser.OpenList();
-            FormatTypeInternal(parser, out);
-            parser.CloseList();
-            out << '>';
-            break;
-
-        case TTypeParser::ETypeKind::Tuple: {
-            out << "Tuple<";
-            parser.OpenTuple();
-            bool needsComma = false;
-            while (parser.TryNextElement()) {
-                if (needsComma) {
-                    out << ',';
-                }
-                FormatTypeInternal(parser, out);
-                needsComma = true;
-            }
-            parser.CloseTuple();
-            out << '>';
-            break;
-        }
-
-        case TTypeParser::ETypeKind::Struct: {
-            out << "Struct<";
-            parser.OpenStruct();
-            bool needsComma = false;
-            while (parser.TryNextMember()) {
-                if (needsComma) {
-                    out << ',';
-                }
-                out << '\'' << parser.GetMemberName() << "\':";
-                FormatTypeInternal(parser, out);
-                needsComma = true;
-            }
-            parser.CloseStruct();
-            out << '>';
-            break;
-        }
-
-        case TTypeParser::ETypeKind::Dict:
-            out << "Dict<";
-            parser.OpenDict();
-            parser.DictKey();
-            FormatTypeInternal(parser, out);
-            out << ',';
-            parser.DictPayload();
-            FormatTypeInternal(parser, out);
-            parser.CloseDict();
-            out << '>';
-            break;
-
-        case TTypeParser::ETypeKind::Variant:
-            // TODO: Variant
-            break;
-
-        case TTypeParser::ETypeKind::Void:
+            //out << "Decimal"; 
+            break; 
+        } 
+ 
+        case TTypeParser::ETypeKind::Optional: 
+            parser.OpenOptional(); 
+            FormatTypeInternal(parser, out); 
+            parser.CloseOptional(); 
+            out << '?'; 
+            break; 
+ 
+        case TTypeParser::ETypeKind::List: 
+            out << "List<"; 
+            parser.OpenList(); 
+            FormatTypeInternal(parser, out); 
+            parser.CloseList(); 
+            out << '>'; 
+            break; 
+ 
+        case TTypeParser::ETypeKind::Tuple: { 
+            out << "Tuple<"; 
+            parser.OpenTuple(); 
+            bool needsComma = false; 
+            while (parser.TryNextElement()) { 
+                if (needsComma) { 
+                    out << ','; 
+                } 
+                FormatTypeInternal(parser, out); 
+                needsComma = true; 
+            } 
+            parser.CloseTuple(); 
+            out << '>'; 
+            break; 
+        } 
+ 
+        case TTypeParser::ETypeKind::Struct: { 
+            out << "Struct<"; 
+            parser.OpenStruct(); 
+            bool needsComma = false; 
+            while (parser.TryNextMember()) { 
+                if (needsComma) { 
+                    out << ','; 
+                } 
+                out << '\'' << parser.GetMemberName() << "\':"; 
+                FormatTypeInternal(parser, out); 
+                needsComma = true; 
+            } 
+            parser.CloseStruct(); 
+            out << '>'; 
+            break; 
+        } 
+ 
+        case TTypeParser::ETypeKind::Dict: 
+            out << "Dict<"; 
+            parser.OpenDict(); 
+            parser.DictKey(); 
+            FormatTypeInternal(parser, out); 
+            out << ','; 
+            parser.DictPayload(); 
+            FormatTypeInternal(parser, out); 
+            parser.CloseDict(); 
+            out << '>'; 
+            break; 
+ 
+        case TTypeParser::ETypeKind::Variant: 
+            // TODO: Variant 
+            break; 
+ 
+        case TTypeParser::ETypeKind::Void: 
             out << "Void"sv;
-            break;
-
-        default:
+            break; 
+ 
+        default: 
             ThrowFatalError(TStringBuilder()
-                << "Unexpected type kind: " << parser.GetKind());
-    }
-}
-
-TString FormatType(const TType& type) {
-    TTypeParser parser(type);
-    TStringStream out;
-    FormatTypeInternal(parser, out);
-    return out.Str();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TTypeBuilder::TImpl {
-    using ETypeKind = TTypeParser::ETypeKind;
-
-public:
+                << "Unexpected type kind: " << parser.GetKind()); 
+    } 
+} 
+ 
+TString FormatType(const TType& type) { 
+    TTypeParser parser(type); 
+    TStringStream out; 
+    FormatTypeInternal(parser, out); 
+    return out.Str(); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+class TTypeBuilder::TImpl { 
+    using ETypeKind = TTypeParser::ETypeKind; 
+ 
+public: 
     TImpl()
-    {
-        Path_.emplace_back(TProtoPosition{&ProtoType_});
-    }
-
+    { 
+        Path_.emplace_back(TProtoPosition{&ProtoType_}); 
+    } 
+ 
     TImpl(Ydb::Type& type)
-    {
-        Path_.emplace_back(TProtoPosition{&type});
-    }
-
-    TType Build() {
-        if (Path_.size() > 1) {
-            FatalError("Invalid Build() call, type is incomplete.");
-        }
-
-        Ydb::Type type;
-        type.Swap(&ProtoType_);
-        return TType(std::move(type));
-    }
-
-    void Primitive(const EPrimitiveType& primitiveType) {
-        GetProto().set_type_id(Ydb::Type::PrimitiveTypeId(primitiveType));
-    }
-
-    void Decimal(const TDecimalType& decimalType) {
-        auto& decimal = *GetProto().mutable_decimal_type();
-        decimal.set_precision(decimalType.Precision);
-        decimal.set_scale(decimalType.Scale);
-    }
-
-    void BeginOptional() {
-        AddPosition(GetProto().mutable_optional_type()->mutable_item());
-    }
-
-    void EndOptional() {
-        CloseContainer<ETypeKind::Optional>();
-    }
-
-    void Optional(const TType& itemType) {
-        GetProto().mutable_optional_type()->mutable_item()->CopyFrom(TProtoAccessor::GetProto(itemType));
-    }
-
-    void BeginList() {
-        AddPosition(GetProto().mutable_list_type()->mutable_item());
-    }
-
-    void EndList() {
-        CloseContainer<ETypeKind::List>();
-    }
-
-    void List(const TType& itemType) {
-        GetProto().mutable_list_type()->mutable_item()->CopyFrom(TProtoAccessor::GetProto(itemType));
-    }
-
-    void BeginStruct() {
-        GetProto().mutable_struct_type();
-        AddPosition(&GetProto());
-    }
-
-    void EndStruct() {
-        CloseContainer<ETypeKind::Struct>();
-    }
-
-    void AddMember(const TString& memberName) {
-        CheckPreviousKind(ETypeKind::Struct, "AddMember");
-        PopPosition();
-        auto member = GetProto().mutable_struct_type()->add_members();
-        member->set_name(memberName);
-        AddPosition(member->mutable_type());
-    }
-
-    void AddMember(const TString& memberName, const TType& memberType) {
-        AddMember(memberName);
-        GetProto().CopyFrom(TProtoAccessor::GetProto(memberType));
-    }
-
-    void SelectMember(size_t index) {
-        CheckPreviousKind(ETypeKind::Struct, "SelectMember");
-        PopPosition();
-        auto member = GetProto().mutable_struct_type()->mutable_members(index);
-        AddPosition(member->mutable_type());
-    }
-
-    void BeginTuple() {
-        GetProto().mutable_tuple_type();
-        AddPosition(&GetProto());
-    }
-
-    void EndTuple() {
-        CloseContainer<ETypeKind::Tuple>();
-    }
-
-    void AddElement() {
-        CheckPreviousKind(ETypeKind::Tuple, "AddElement");
-        PopPosition();
-        AddPosition(GetProto().mutable_tuple_type()->add_elements());
-    }
-
-    void AddElement(const TType& elementType) {
-        AddElement();
-        GetProto().CopyFrom(TProtoAccessor::GetProto(elementType));
-    }
-
-    void SelectElement(size_t index) {
-        CheckPreviousKind(ETypeKind::Tuple, "SelectElement");
-        PopPosition();
-        AddPosition(GetProto().mutable_tuple_type()->mutable_elements(index));
-    }
-
-    void BeginDict() {
-        GetProto().mutable_dict_type();
-        AddPosition(&GetProto());
-    }
-
-    void EndDict() {
-        CloseContainer<ETypeKind::Dict>();
-    }
-
-    void DictKey() {
-        CheckPreviousKind(ETypeKind::Dict, "DictKey");
-        PopPosition();
-        AddPosition(GetProto().mutable_dict_type()->mutable_key());
-    }
-
-    void DictKey(const TType& keyType) {
-        DictKey();
-        GetProto().CopyFrom(TProtoAccessor::GetProto(keyType));
-    }
-
-    void DictPayload() {
-        CheckPreviousKind(ETypeKind::Dict, "DictPayload");
-        PopPosition();
-        AddPosition(GetProto().mutable_dict_type()->mutable_payload());
-    }
-
-    void DictPayload(const TType& payloadType) {
-        DictPayload();
-        GetProto().CopyFrom(TProtoAccessor::GetProto(payloadType));
-    }
-
-    Ydb::Type& GetProto(ui32 offset = 0) {
-        return *static_cast<Ydb::Type*>(Path_[Path_.size() - (offset + 1)].Ptr);
-    }
-
-    void SetType(const TType& type) {
-        GetProto().CopyFrom(TProtoAccessor::GetProto(type));
-    }
-
-private:
-    void AddPosition(Ydb::Type* type) {
-        Path_.emplace_back(TProtoPosition{type});
-    }
-
-    void PopPosition() {
-        Path_.pop_back();
-    }
-
-    void FatalError(const TString& msg) const {
+    { 
+        Path_.emplace_back(TProtoPosition{&type}); 
+    } 
+ 
+    TType Build() { 
+        if (Path_.size() > 1) { 
+            FatalError("Invalid Build() call, type is incomplete."); 
+        } 
+ 
+        Ydb::Type type; 
+        type.Swap(&ProtoType_); 
+        return TType(std::move(type)); 
+    } 
+ 
+    void Primitive(const EPrimitiveType& primitiveType) { 
+        GetProto().set_type_id(Ydb::Type::PrimitiveTypeId(primitiveType)); 
+    } 
+ 
+    void Decimal(const TDecimalType& decimalType) { 
+        auto& decimal = *GetProto().mutable_decimal_type(); 
+        decimal.set_precision(decimalType.Precision); 
+        decimal.set_scale(decimalType.Scale); 
+    } 
+ 
+    void BeginOptional() { 
+        AddPosition(GetProto().mutable_optional_type()->mutable_item()); 
+    } 
+ 
+    void EndOptional() { 
+        CloseContainer<ETypeKind::Optional>(); 
+    } 
+ 
+    void Optional(const TType& itemType) { 
+        GetProto().mutable_optional_type()->mutable_item()->CopyFrom(TProtoAccessor::GetProto(itemType)); 
+    } 
+ 
+    void BeginList() { 
+        AddPosition(GetProto().mutable_list_type()->mutable_item()); 
+    } 
+ 
+    void EndList() { 
+        CloseContainer<ETypeKind::List>(); 
+    } 
+ 
+    void List(const TType& itemType) { 
+        GetProto().mutable_list_type()->mutable_item()->CopyFrom(TProtoAccessor::GetProto(itemType)); 
+    } 
+ 
+    void BeginStruct() { 
+        GetProto().mutable_struct_type(); 
+        AddPosition(&GetProto()); 
+    } 
+ 
+    void EndStruct() { 
+        CloseContainer<ETypeKind::Struct>(); 
+    } 
+ 
+    void AddMember(const TString& memberName) { 
+        CheckPreviousKind(ETypeKind::Struct, "AddMember"); 
+        PopPosition(); 
+        auto member = GetProto().mutable_struct_type()->add_members(); 
+        member->set_name(memberName); 
+        AddPosition(member->mutable_type()); 
+    } 
+ 
+    void AddMember(const TString& memberName, const TType& memberType) { 
+        AddMember(memberName); 
+        GetProto().CopyFrom(TProtoAccessor::GetProto(memberType)); 
+    } 
+ 
+    void SelectMember(size_t index) { 
+        CheckPreviousKind(ETypeKind::Struct, "SelectMember"); 
+        PopPosition(); 
+        auto member = GetProto().mutable_struct_type()->mutable_members(index); 
+        AddPosition(member->mutable_type()); 
+    } 
+ 
+    void BeginTuple() { 
+        GetProto().mutable_tuple_type(); 
+        AddPosition(&GetProto()); 
+    } 
+ 
+    void EndTuple() { 
+        CloseContainer<ETypeKind::Tuple>(); 
+    } 
+ 
+    void AddElement() { 
+        CheckPreviousKind(ETypeKind::Tuple, "AddElement"); 
+        PopPosition(); 
+        AddPosition(GetProto().mutable_tuple_type()->add_elements()); 
+    } 
+ 
+    void AddElement(const TType& elementType) { 
+        AddElement(); 
+        GetProto().CopyFrom(TProtoAccessor::GetProto(elementType)); 
+    } 
+ 
+    void SelectElement(size_t index) { 
+        CheckPreviousKind(ETypeKind::Tuple, "SelectElement"); 
+        PopPosition(); 
+        AddPosition(GetProto().mutable_tuple_type()->mutable_elements(index)); 
+    } 
+ 
+    void BeginDict() { 
+        GetProto().mutable_dict_type(); 
+        AddPosition(&GetProto()); 
+    } 
+ 
+    void EndDict() { 
+        CloseContainer<ETypeKind::Dict>(); 
+    } 
+ 
+    void DictKey() { 
+        CheckPreviousKind(ETypeKind::Dict, "DictKey"); 
+        PopPosition(); 
+        AddPosition(GetProto().mutable_dict_type()->mutable_key()); 
+    } 
+ 
+    void DictKey(const TType& keyType) { 
+        DictKey(); 
+        GetProto().CopyFrom(TProtoAccessor::GetProto(keyType)); 
+    } 
+ 
+    void DictPayload() { 
+        CheckPreviousKind(ETypeKind::Dict, "DictPayload"); 
+        PopPosition(); 
+        AddPosition(GetProto().mutable_dict_type()->mutable_payload()); 
+    } 
+ 
+    void DictPayload(const TType& payloadType) { 
+        DictPayload(); 
+        GetProto().CopyFrom(TProtoAccessor::GetProto(payloadType)); 
+    } 
+ 
+    Ydb::Type& GetProto(ui32 offset = 0) { 
+        return *static_cast<Ydb::Type*>(Path_[Path_.size() - (offset + 1)].Ptr); 
+    } 
+ 
+    void SetType(const TType& type) { 
+        GetProto().CopyFrom(TProtoAccessor::GetProto(type)); 
+    } 
+ 
+private: 
+    void AddPosition(Ydb::Type* type) { 
+        Path_.emplace_back(TProtoPosition{type}); 
+    } 
+ 
+    void PopPosition() { 
+        Path_.pop_back(); 
+    } 
+ 
+    void FatalError(const TString& msg) const { 
         ThrowFatalError(TStringBuilder() << "TTypeBuilder: " << msg);
-    }
-
-    void CheckKind(ETypeKind kind, const TString& method) {
+    } 
+ 
+    void CheckKind(ETypeKind kind, const TString& method) { 
         NYdb::CheckKind(GetKind(), kind, method);
-    }
-
-    void CheckPreviousKind(ETypeKind kind, const TString& method) {
+    } 
+ 
+    void CheckPreviousKind(ETypeKind kind, const TString& method) { 
         NYdb::CheckKind(GetKind(1), kind, method);
-    }
-
-    ETypeKind GetKind(ui32 offset = 0) {
+    } 
+ 
+    ETypeKind GetKind(ui32 offset = 0) { 
         return NYdb::GetKind(GetProto(offset));
-    }
-
-    template<ETypeKind kind>
-    void CloseContainer() {
-        auto sz = Path_.size();
-        if (sz < 2) {
-            FatalError("No opened container to close");
-            return;
-        }
-        CheckPreviousKind(kind, "End");
-        PopPosition();
-    }
-
-private:
-    struct TProtoPosition {
-        google::protobuf::Message* Ptr;
-    };
-
-private:
-    Ydb::Type ProtoType_;
-    TStackVec<TProtoPosition, 8> Path_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-TTypeBuilder::TTypeBuilder(TTypeBuilder&&) = default;
-TTypeBuilder::~TTypeBuilder() = default;
-
-TTypeBuilder::TTypeBuilder()
+    } 
+ 
+    template<ETypeKind kind> 
+    void CloseContainer() { 
+        auto sz = Path_.size(); 
+        if (sz < 2) { 
+            FatalError("No opened container to close"); 
+            return; 
+        } 
+        CheckPreviousKind(kind, "End"); 
+        PopPosition(); 
+    } 
+ 
+private: 
+    struct TProtoPosition { 
+        google::protobuf::Message* Ptr; 
+    }; 
+ 
+private: 
+    Ydb::Type ProtoType_; 
+    TStackVec<TProtoPosition, 8> Path_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TTypeBuilder::TTypeBuilder(TTypeBuilder&&) = default; 
+TTypeBuilder::~TTypeBuilder() = default; 
+ 
+TTypeBuilder::TTypeBuilder() 
     : Impl_(new TImpl()) {}
-
-TType TTypeBuilder::Build() {
-    return Impl_->Build();
-}
-
-TTypeBuilder& TTypeBuilder::Primitive(const EPrimitiveType& primitiveType) {
-    Impl_->Primitive(primitiveType);
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::Decimal(const TDecimalType& decimalType) {
-    Impl_->Decimal(decimalType);
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::BeginOptional() {
-    Impl_->BeginOptional();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::EndOptional() {
-    Impl_->EndOptional();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::Optional(const TType& itemType) {
-    Impl_->Optional(itemType);
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::BeginList() {
-    Impl_->BeginList();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::EndList() {
-    Impl_->EndList();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::List(const TType& itemType) {
-    Impl_->List(itemType);
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::BeginStruct() {
-    Impl_->BeginStruct();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::EndStruct() {
-    Impl_->EndStruct();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::AddMember(const TString& memberName) {
-    Impl_->AddMember(memberName);
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::AddMember(const TString& memberName, const TType& memberType) {
-    Impl_->AddMember(memberName, memberType);
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::BeginTuple() {
-    Impl_->BeginTuple();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::EndTuple() {
-    Impl_->EndTuple();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::AddElement() {
-    Impl_->AddElement();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::AddElement(const TType& elementType) {
-    Impl_->AddElement(elementType);
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::BeginDict() {
-    Impl_->BeginDict();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::DictKey() {
-    Impl_->DictKey();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::DictKey(const TType& keyType) {
-    Impl_->DictKey(keyType);
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::DictPayload() {
-    Impl_->DictPayload();
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::DictPayload(const TType& payloadType) {
-    Impl_->DictPayload(payloadType);
-    return *this;
-}
-
-TTypeBuilder& TTypeBuilder::EndDict() {
-    Impl_->EndDict();
-    return *this;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
+ 
+TType TTypeBuilder::Build() { 
+    return Impl_->Build(); 
+} 
+ 
+TTypeBuilder& TTypeBuilder::Primitive(const EPrimitiveType& primitiveType) { 
+    Impl_->Primitive(primitiveType); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::Decimal(const TDecimalType& decimalType) { 
+    Impl_->Decimal(decimalType); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::BeginOptional() { 
+    Impl_->BeginOptional(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::EndOptional() { 
+    Impl_->EndOptional(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::Optional(const TType& itemType) { 
+    Impl_->Optional(itemType); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::BeginList() { 
+    Impl_->BeginList(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::EndList() { 
+    Impl_->EndList(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::List(const TType& itemType) { 
+    Impl_->List(itemType); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::BeginStruct() { 
+    Impl_->BeginStruct(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::EndStruct() { 
+    Impl_->EndStruct(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::AddMember(const TString& memberName) { 
+    Impl_->AddMember(memberName); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::AddMember(const TString& memberName, const TType& memberType) { 
+    Impl_->AddMember(memberName, memberType); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::BeginTuple() { 
+    Impl_->BeginTuple(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::EndTuple() { 
+    Impl_->EndTuple(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::AddElement() { 
+    Impl_->AddElement(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::AddElement(const TType& elementType) { 
+    Impl_->AddElement(elementType); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::BeginDict() { 
+    Impl_->BeginDict(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::DictKey() { 
+    Impl_->DictKey(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::DictKey(const TType& keyType) { 
+    Impl_->DictKey(keyType); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::DictPayload() { 
+    Impl_->DictPayload(); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::DictPayload(const TType& payloadType) { 
+    Impl_->DictPayload(payloadType); 
+    return *this; 
+} 
+ 
+TTypeBuilder& TTypeBuilder::EndDict() { 
+    Impl_->EndDict(); 
+    return *this; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 TDecimalValue::TDecimalValue(const Ydb::Value& valueProto, const TDecimalType& decimalType)
     : DecimalType_(decimalType)
     , Low_(valueProto.low_128())
@@ -886,191 +886,191 @@ TString TDecimalValue::ToString() const {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TValue::TImpl {
-public:
-    TImpl(const TType& type, const Ydb::Value& valueProto)
-        : Type_(type)
-        , ProtoValue_(valueProto) {}
-
-    TImpl(const TType& type, Ydb::Value&& valueProto)
-        : Type_(type)
-        , ProtoValue_(std::move(valueProto)) {}
-
-    const TType Type_;
-    const Ydb::Value ProtoValue_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-TValue::TValue(const TType& type, const Ydb::Value& valueProto)
-    : Impl_(new TImpl(type, valueProto)) {}
-
-TValue::TValue(const TType& type, Ydb::Value&& valueProto)
-    : Impl_(new TImpl(type, std::move(valueProto))) {}
-
-const TType& TValue::GetType() const {
-    return Impl_->Type_;
-}
-
-const Ydb::Value& TValue::GetProto() const {
-    return Impl_->ProtoValue_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TValueParser::TImpl {
-    using ETypeKind = TTypeParser::ETypeKind;
-
-    enum class EParseKind {
-        Value,
-        Null,
-        Items,
-        Pairs,
-        Pair
-    };
-
-    struct TProtoPosition {
-        EParseKind Kind;
-        const google::protobuf::Message* Ptr;
-        i32 Idx;
-    };
-
-public:
+class TValue::TImpl { 
+public: 
+    TImpl(const TType& type, const Ydb::Value& valueProto) 
+        : Type_(type) 
+        , ProtoValue_(valueProto) {} 
+ 
+    TImpl(const TType& type, Ydb::Value&& valueProto) 
+        : Type_(type) 
+        , ProtoValue_(std::move(valueProto)) {} 
+ 
+    const TType Type_; 
+    const Ydb::Value ProtoValue_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TValue::TValue(const TType& type, const Ydb::Value& valueProto) 
+    : Impl_(new TImpl(type, valueProto)) {} 
+ 
+TValue::TValue(const TType& type, Ydb::Value&& valueProto) 
+    : Impl_(new TImpl(type, std::move(valueProto))) {} 
+ 
+const TType& TValue::GetType() const { 
+    return Impl_->Type_; 
+} 
+ 
+const Ydb::Value& TValue::GetProto() const { 
+    return Impl_->ProtoValue_; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+class TValueParser::TImpl { 
+    using ETypeKind = TTypeParser::ETypeKind; 
+ 
+    enum class EParseKind { 
+        Value, 
+        Null, 
+        Items, 
+        Pairs, 
+        Pair 
+    }; 
+ 
+    struct TProtoPosition { 
+        EParseKind Kind; 
+        const google::protobuf::Message* Ptr; 
+        i32 Idx; 
+    }; 
+ 
+public: 
     TImpl(const TValue& value)
-        : Value_(value.Impl_)
-        , TypeParser_(value.GetType())
-    {
-        Reset(Value_->ProtoValue_);
-    }
-
+        : Value_(value.Impl_) 
+        , TypeParser_(value.GetType()) 
+    { 
+        Reset(Value_->ProtoValue_); 
+    } 
+ 
     TImpl(const TType& type)
         : TypeParser_(type) {}
-
-    void Reset(const Ydb::Value& value) {
-        TypeParser_.Impl_->Reset();
-        Path_.clear();
-        AddPath(EParseKind::Value, &value);
-    }
-
-    ETypeKind GetKind() const {
-        return TypeParser_.GetKind();
-    }
-
-    EPrimitiveType GetPrimitiveType() const {
-        CheckKind(ETypeKind::Primitive, "GetPrimitiveType");
-        return TypeParser_.GetPrimitive();
-    }
-
-    bool GetBool() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Bool);
-        return GetProto().bool_value();
-    }
-
-    i8 GetInt8() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Int8);
-        return GetProto().int32_value();
-    }
-
-    ui8 GetUint8() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Uint8);
-        return GetProto().uint32_value();
-    }
-
-    i16 GetInt16() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Int16);
-        return GetProto().int32_value();
-    }
-
-    ui16 GetUint16() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Uint16);
-        return GetProto().uint32_value();
-    }
-
-    i32 GetInt32() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Int32);
-        return GetProto().int32_value();
-    }
-
-    ui32 GetUint32() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Uint32);
-        return GetProto().uint32_value();
-    }
-
-    i64 GetInt64() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Int64);
-        return GetProto().int64_value();
-    }
-
-    ui64 GetUint64() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Uint64);
-        return GetProto().uint64_value();
-    }
-
-    float GetFloat() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Float);
-        return GetProto().float_value();
-    }
-
-    double GetDouble() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Double);
-        return GetProto().double_value();
-    }
-
-    TInstant GetDate() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Date);
-        return TInstant::Days(GetProto().uint32_value());
-    }
-
-    TInstant GetDatetime() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Datetime);
-        return TInstant::Seconds(GetProto().uint32_value());
-    }
-
-    TInstant GetTimestamp() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Timestamp);
-        return TInstant::MicroSeconds(GetProto().uint64_value());
-    }
-
-    i64 GetInterval() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Interval);
-        return GetProto().int64_value();
-    }
-
-    const TString& GetTzDate() const {
-        CheckPrimitive(NYdb::EPrimitiveType::TzDate);
-        return GetProto().text_value();
-    }
-
-    const TString& GetTzDatetime() const {
-        CheckPrimitive(NYdb::EPrimitiveType::TzDatetime);
-        return GetProto().text_value();
-    }
-
-    const TString& GetTzTimestamp() const {
-        CheckPrimitive(NYdb::EPrimitiveType::TzTimestamp);
-        return GetProto().text_value();
-    }
-
-    const TString& GetString() const {
-        CheckPrimitive(NYdb::EPrimitiveType::String);
-        return GetProto().bytes_value();
-    }
-
-    const TString& GetUtf8() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Utf8);
-        return GetProto().text_value();
-    }
-
-    const TString& GetYson() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Yson);
-        return GetProto().bytes_value();
-    }
-
-    const TString& GetJson() const {
-        CheckPrimitive(NYdb::EPrimitiveType::Json);
-        return GetProto().text_value();
-    }
-
+ 
+    void Reset(const Ydb::Value& value) { 
+        TypeParser_.Impl_->Reset(); 
+        Path_.clear(); 
+        AddPath(EParseKind::Value, &value); 
+    } 
+ 
+    ETypeKind GetKind() const { 
+        return TypeParser_.GetKind(); 
+    } 
+ 
+    EPrimitiveType GetPrimitiveType() const { 
+        CheckKind(ETypeKind::Primitive, "GetPrimitiveType"); 
+        return TypeParser_.GetPrimitive(); 
+    } 
+ 
+    bool GetBool() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Bool); 
+        return GetProto().bool_value(); 
+    } 
+ 
+    i8 GetInt8() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Int8); 
+        return GetProto().int32_value(); 
+    } 
+ 
+    ui8 GetUint8() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Uint8); 
+        return GetProto().uint32_value(); 
+    } 
+ 
+    i16 GetInt16() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Int16); 
+        return GetProto().int32_value(); 
+    } 
+ 
+    ui16 GetUint16() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Uint16); 
+        return GetProto().uint32_value(); 
+    } 
+ 
+    i32 GetInt32() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Int32); 
+        return GetProto().int32_value(); 
+    } 
+ 
+    ui32 GetUint32() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Uint32); 
+        return GetProto().uint32_value(); 
+    } 
+ 
+    i64 GetInt64() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Int64); 
+        return GetProto().int64_value(); 
+    } 
+ 
+    ui64 GetUint64() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Uint64); 
+        return GetProto().uint64_value(); 
+    } 
+ 
+    float GetFloat() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Float); 
+        return GetProto().float_value(); 
+    } 
+ 
+    double GetDouble() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Double); 
+        return GetProto().double_value(); 
+    } 
+ 
+    TInstant GetDate() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Date); 
+        return TInstant::Days(GetProto().uint32_value()); 
+    } 
+ 
+    TInstant GetDatetime() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Datetime); 
+        return TInstant::Seconds(GetProto().uint32_value()); 
+    } 
+ 
+    TInstant GetTimestamp() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Timestamp); 
+        return TInstant::MicroSeconds(GetProto().uint64_value()); 
+    } 
+ 
+    i64 GetInterval() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Interval); 
+        return GetProto().int64_value(); 
+    } 
+ 
+    const TString& GetTzDate() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::TzDate); 
+        return GetProto().text_value(); 
+    } 
+ 
+    const TString& GetTzDatetime() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::TzDatetime); 
+        return GetProto().text_value(); 
+    } 
+ 
+    const TString& GetTzTimestamp() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::TzTimestamp); 
+        return GetProto().text_value(); 
+    } 
+ 
+    const TString& GetString() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::String); 
+        return GetProto().bytes_value(); 
+    } 
+ 
+    const TString& GetUtf8() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Utf8); 
+        return GetProto().text_value(); 
+    } 
+ 
+    const TString& GetYson() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Yson); 
+        return GetProto().bytes_value(); 
+    } 
+ 
+    const TString& GetJson() const { 
+        CheckPrimitive(NYdb::EPrimitiveType::Json); 
+        return GetProto().text_value(); 
+    } 
+ 
     const TString& GetJsonDocument() const {
         CheckPrimitive(NYdb::EPrimitiveType::JsonDocument);
         return GetProto().text_value();
@@ -1086,123 +1086,123 @@ public:
         return TDecimalValue(GetProto(), TypeParser_.GetDecimal());
     }
 
-    void OpenOptional() {
-        TypeParser_.OpenOptional();
-
-        if (GetProto().value_case() == Ydb::Value::kNestedValue) {
-            AddPath(EParseKind::Value, &GetProto().nested_value());
-        } else if (GetProto().value_case() == Ydb::Value::kNullFlagValue) {
-            AddPath(EParseKind::Null, &GetProto());
-        } else {
-            AddPath(EParseKind::Value, &GetProto());
-        }
-    }
-
-    bool IsNull() const {
-        return GetPathBack().Kind == EParseKind::Null;
-    }
-
-    void CloseOptional() {
-        PopPath();
-        TypeParser_.CloseOptional();
-    }
-
-    void OpenList() {
-        TypeParser_.OpenList();
-        OpenItems();
-    }
-
-    bool TryNextListItem() {
-        return NextItems();
-    }
-
-    void CloseList() {
-        CloseItems();
-        TypeParser_.CloseList();
-    }
-
-    void OpenStruct() {
-        TypeParser_.OpenStruct();
-        OpenItems();
-    }
-
-    bool TryNextMember() {
-        if (TypeParser_.TryNextMember()) {
-            if (NextItems()) {
-                return true;
-            }
-
-            FatalError(TStringBuilder() << "Missing struct 'items' value at index: " << GetPathBack().Idx);
-        }
-
-        return false;
-    }
-
-    const TString& GetMemberName() {
-        return TypeParser_.GetMemberName();
-    }
-
-    void CloseStruct() {
-        CloseItems();
-        TypeParser_.CloseStruct();
-    }
-
-    void OpenTuple() {
-        TypeParser_.OpenTuple();
-        OpenItems();
-    }
-
-    bool TryNextElement() {
-        if (TypeParser_.TryNextElement()) {
-            if (NextItems()) {
-                return true;
-            }
-
-            FatalError(TStringBuilder() << "Missing tuple 'items' value at index: " << GetPathBack().Idx);
-        }
-
-        return false;
-    }
-
-    void CloseTuple() {
-        CloseItems();
-        TypeParser_.CloseTuple();
-    }
-
-    void OpenDict() {
-        TypeParser_.OpenDict();
-        OpenPairs();
-    }
-
-    bool TryNextDictItem() {
-        return NextPairs();
-    }
-
-    void DictKey() {
-        TypeParser_.DictKey();
-
-        if (GetPathBack().Kind != EParseKind::Pair) {
-            PopPath();
-        }
-
-        AddPath(EParseKind::Value, &GetProtoPair().key());
-    }
-
-    void DictPayload() {
-        TypeParser_.DictPayload();
-
-        if (GetPathBack().Kind != EParseKind::Pair) {
-            PopPath();
-        }
-
-        AddPath(EParseKind::Value, &GetProtoPair().payload());
-    }
-
-    void CloseDict() {
-        ClosePairs();
-        TypeParser_.CloseDict();
-    }
-
+    void OpenOptional() { 
+        TypeParser_.OpenOptional(); 
+ 
+        if (GetProto().value_case() == Ydb::Value::kNestedValue) { 
+            AddPath(EParseKind::Value, &GetProto().nested_value()); 
+        } else if (GetProto().value_case() == Ydb::Value::kNullFlagValue) { 
+            AddPath(EParseKind::Null, &GetProto()); 
+        } else { 
+            AddPath(EParseKind::Value, &GetProto()); 
+        } 
+    } 
+ 
+    bool IsNull() const { 
+        return GetPathBack().Kind == EParseKind::Null; 
+    } 
+ 
+    void CloseOptional() { 
+        PopPath(); 
+        TypeParser_.CloseOptional(); 
+    } 
+ 
+    void OpenList() { 
+        TypeParser_.OpenList(); 
+        OpenItems(); 
+    } 
+ 
+    bool TryNextListItem() { 
+        return NextItems(); 
+    } 
+ 
+    void CloseList() { 
+        CloseItems(); 
+        TypeParser_.CloseList(); 
+    } 
+ 
+    void OpenStruct() { 
+        TypeParser_.OpenStruct(); 
+        OpenItems(); 
+    } 
+ 
+    bool TryNextMember() { 
+        if (TypeParser_.TryNextMember()) { 
+            if (NextItems()) { 
+                return true; 
+            } 
+ 
+            FatalError(TStringBuilder() << "Missing struct 'items' value at index: " << GetPathBack().Idx); 
+        } 
+ 
+        return false; 
+    } 
+ 
+    const TString& GetMemberName() { 
+        return TypeParser_.GetMemberName(); 
+    } 
+ 
+    void CloseStruct() { 
+        CloseItems(); 
+        TypeParser_.CloseStruct(); 
+    } 
+ 
+    void OpenTuple() { 
+        TypeParser_.OpenTuple(); 
+        OpenItems(); 
+    } 
+ 
+    bool TryNextElement() { 
+        if (TypeParser_.TryNextElement()) { 
+            if (NextItems()) { 
+                return true; 
+            } 
+ 
+            FatalError(TStringBuilder() << "Missing tuple 'items' value at index: " << GetPathBack().Idx); 
+        } 
+ 
+        return false; 
+    } 
+ 
+    void CloseTuple() { 
+        CloseItems(); 
+        TypeParser_.CloseTuple(); 
+    } 
+ 
+    void OpenDict() { 
+        TypeParser_.OpenDict(); 
+        OpenPairs(); 
+    } 
+ 
+    bool TryNextDictItem() { 
+        return NextPairs(); 
+    } 
+ 
+    void DictKey() { 
+        TypeParser_.DictKey(); 
+ 
+        if (GetPathBack().Kind != EParseKind::Pair) { 
+            PopPath(); 
+        } 
+ 
+        AddPath(EParseKind::Value, &GetProtoPair().key()); 
+    } 
+ 
+    void DictPayload() { 
+        TypeParser_.DictPayload(); 
+ 
+        if (GetPathBack().Kind != EParseKind::Pair) { 
+            PopPath(); 
+        } 
+ 
+        AddPath(EParseKind::Value, &GetProtoPair().payload()); 
+    } 
+ 
+    void CloseDict() { 
+        ClosePairs(); 
+        TypeParser_.CloseDict(); 
+    } 
+ 
     void OpenVariant() {
         auto variantIndex = GetProto().variant_index();
         TypeParser_.OpenVariant(variantIndex);
@@ -1230,323 +1230,323 @@ public:
         TypeParser_.CloseTagged();
     }
 
-private:
-    const TProtoPosition& GetPathBack() const {
-        if (Path_.empty()) {
-            FatalError(TStringBuilder() << "Bad parser state, no open value.");
-        }
-
-        return Path_.back();
-    }
-
-    void PopPath() {
-        Path_.pop_back();
-    }
-
-    void AddPath(EParseKind kind, const google::protobuf::Message* message, i32 idx = -1) {
-        if (!Path_.empty()) {
-            if (Path_.back().Kind == EParseKind::Null) {
-                FatalError(TStringBuilder() << "Can't parse inside NULL value");
-                return;
-            }
-
-            switch (Path_.back().Kind) {
-                case EParseKind::Value:
-                    break;
-
-                case EParseKind::Pair:
-                    if (kind != EParseKind::Value) {
-                        FatalError(TStringBuilder() << "Bad parser state, expected dict pair.");
-                        return;
-                    }
-                    break;
-
-                default:
-                    FatalError(TStringBuilder() << "Bad parser state, no value to parse.");
-                    return;
-            }
-        }
-
-        Path_.emplace_back(TProtoPosition{kind, message, idx});
-    }
-
-    void OpenItems(i32 idx = -1) {
-        if (idx < 0) {
-            AddPath(EParseKind::Items, &GetProto(), idx);
-        } else {
-            AddPath(EParseKind::Value, &GetProto().items(idx), idx);
-        }
-    }
-
-    void CloseItems() {
-        PopPath();
-    }
-
-    bool NextItems() {
-        auto idx = GetPathBack().Idx;
-        idx++;
-
-        PopPath();
-
-        bool isEnd = (idx == static_cast<i32>(GetProto().itemsSize()));
-        if (isEnd) {
-            idx--;
-        }
-
-        OpenItems(idx);
-
-        return !isEnd;
-    }
-
-    void OpenPairs(i32 idx = -1) {
-        if (idx < 0) {
-            AddPath(EParseKind::Pairs, &GetProto(), idx);
-        } else {
-            AddPath(EParseKind::Pair, &GetProto().pairs(idx), idx);
-        }
-    }
-
-    bool NextPairs() {
-        if (GetPathBack().Kind != EParseKind::Pairs && GetPathBack().Kind != EParseKind::Pair) {
-            PopPath();
-        }
-
-        auto idx = GetPathBack().Idx;
-        idx++;
-
-        PopPath();
-
-        bool isEnd = (idx == static_cast<i32>(GetProto().pairsSize()));
-        if (isEnd) {
-            idx--;
-        }
-
-        OpenPairs(idx);
-
-        return !isEnd;
-    }
-
-    void ClosePairs() {
-        if (GetPathBack().Kind != EParseKind::Pairs && GetPathBack().Kind != EParseKind::Pair) {
-            PopPath();
-        }
-
-        PopPath();
-    }
-
-    void CheckKind(ETypeKind kind, const TString& method) const {
+private: 
+    const TProtoPosition& GetPathBack() const { 
+        if (Path_.empty()) { 
+            FatalError(TStringBuilder() << "Bad parser state, no open value."); 
+        } 
+ 
+        return Path_.back(); 
+    } 
+ 
+    void PopPath() { 
+        Path_.pop_back(); 
+    } 
+ 
+    void AddPath(EParseKind kind, const google::protobuf::Message* message, i32 idx = -1) { 
+        if (!Path_.empty()) { 
+            if (Path_.back().Kind == EParseKind::Null) { 
+                FatalError(TStringBuilder() << "Can't parse inside NULL value"); 
+                return; 
+            } 
+ 
+            switch (Path_.back().Kind) { 
+                case EParseKind::Value: 
+                    break; 
+ 
+                case EParseKind::Pair: 
+                    if (kind != EParseKind::Value) { 
+                        FatalError(TStringBuilder() << "Bad parser state, expected dict pair."); 
+                        return; 
+                    } 
+                    break; 
+ 
+                default: 
+                    FatalError(TStringBuilder() << "Bad parser state, no value to parse."); 
+                    return; 
+            } 
+        } 
+ 
+        Path_.emplace_back(TProtoPosition{kind, message, idx}); 
+    } 
+ 
+    void OpenItems(i32 idx = -1) { 
+        if (idx < 0) { 
+            AddPath(EParseKind::Items, &GetProto(), idx); 
+        } else { 
+            AddPath(EParseKind::Value, &GetProto().items(idx), idx); 
+        } 
+    } 
+ 
+    void CloseItems() { 
+        PopPath(); 
+    } 
+ 
+    bool NextItems() { 
+        auto idx = GetPathBack().Idx; 
+        idx++; 
+ 
+        PopPath(); 
+ 
+        bool isEnd = (idx == static_cast<i32>(GetProto().itemsSize())); 
+        if (isEnd) { 
+            idx--; 
+        } 
+ 
+        OpenItems(idx); 
+ 
+        return !isEnd; 
+    } 
+ 
+    void OpenPairs(i32 idx = -1) { 
+        if (idx < 0) { 
+            AddPath(EParseKind::Pairs, &GetProto(), idx); 
+        } else { 
+            AddPath(EParseKind::Pair, &GetProto().pairs(idx), idx); 
+        } 
+    } 
+ 
+    bool NextPairs() { 
+        if (GetPathBack().Kind != EParseKind::Pairs && GetPathBack().Kind != EParseKind::Pair) { 
+            PopPath(); 
+        } 
+ 
+        auto idx = GetPathBack().Idx; 
+        idx++; 
+ 
+        PopPath(); 
+ 
+        bool isEnd = (idx == static_cast<i32>(GetProto().pairsSize())); 
+        if (isEnd) { 
+            idx--; 
+        } 
+ 
+        OpenPairs(idx); 
+ 
+        return !isEnd; 
+    } 
+ 
+    void ClosePairs() { 
+        if (GetPathBack().Kind != EParseKind::Pairs && GetPathBack().Kind != EParseKind::Pair) { 
+            PopPath(); 
+        } 
+ 
+        PopPath(); 
+    } 
+ 
+    void CheckKind(ETypeKind kind, const TString& method) const { 
         NYdb::CheckKind(TypeParser_.GetKind(), kind, method);
-    }
-
-    void CheckTransportKind(Ydb::Value::ValueCase expectedCase) const {
-        if (expectedCase != GetProto().value_case()) {
-            FatalError(TStringBuilder() << "Transport value case mismatch, requested: " << (ui32)expectedCase
-                << ", actual: " << (ui32)GetProto().value_case());
-        }
-    }
-
-    void CheckPrimitive(EPrimitiveType primitiveType) const {
-        CheckKind(ETypeKind::Primitive, "Get");
-
-        if (primitiveType != TypeParser_.GetPrimitive()) {
-            FatalError(TStringBuilder() << "Type mismatch, requested: " << primitiveType
-                << ", actual: " << TypeParser_.GetPrimitive());
-        }
-
-        CheckTransportKind(GetPrimitiveValueCase(primitiveType));
-    }
-
+    } 
+ 
+    void CheckTransportKind(Ydb::Value::ValueCase expectedCase) const { 
+        if (expectedCase != GetProto().value_case()) { 
+            FatalError(TStringBuilder() << "Transport value case mismatch, requested: " << (ui32)expectedCase 
+                << ", actual: " << (ui32)GetProto().value_case()); 
+        } 
+    } 
+ 
+    void CheckPrimitive(EPrimitiveType primitiveType) const { 
+        CheckKind(ETypeKind::Primitive, "Get"); 
+ 
+        if (primitiveType != TypeParser_.GetPrimitive()) { 
+            FatalError(TStringBuilder() << "Type mismatch, requested: " << primitiveType 
+                << ", actual: " << TypeParser_.GetPrimitive()); 
+        } 
+ 
+        CheckTransportKind(GetPrimitiveValueCase(primitiveType)); 
+    } 
+ 
     void CheckDecimal() const {
         CheckKind(ETypeKind::Decimal, "Get");
         CheckTransportKind(Ydb::Value::kLow128);
     }
 
-    const Ydb::Value& GetProto() const {
-        return *static_cast<const Ydb::Value*>(GetPathBack().Ptr);
-    }
-
-    const Ydb::ValuePair& GetProtoPair() const {
-        if (GetPathBack().Kind != EParseKind::Pair) {
-            FatalError(TStringBuilder() << "Bad parser state, expected dict pair");
-        }
-
-        return *static_cast<const Ydb::ValuePair*>(GetPathBack().Ptr);
-    }
-
-    Ydb::Value::ValueCase GetPrimitiveValueCase(NYdb::EPrimitiveType primitiveTypeId) const {
-        switch (primitiveTypeId) {
-            case NYdb::EPrimitiveType::Bool:
-                return Ydb::Value::kBoolValue;
-            case NYdb::EPrimitiveType::Int8:
-                return Ydb::Value::kInt32Value;
-            case NYdb::EPrimitiveType::Uint8:
-                return Ydb::Value::kUint32Value;
-            case NYdb::EPrimitiveType::Int16:
-                return Ydb::Value::kInt32Value;
-            case NYdb::EPrimitiveType::Uint16:
-                return Ydb::Value::kUint32Value;
-            case NYdb::EPrimitiveType::Int32:
-                return Ydb::Value::kInt32Value;
-            case NYdb::EPrimitiveType::Uint32:
-                return Ydb::Value::kUint32Value;
-            case NYdb::EPrimitiveType::Int64:
-                return Ydb::Value::kInt64Value;
-            case NYdb::EPrimitiveType::Uint64:
-                return Ydb::Value::kUint64Value;
-            case NYdb::EPrimitiveType::Float:
-                return Ydb::Value::kFloatValue;
-            case NYdb::EPrimitiveType::Double:
-                return Ydb::Value::kDoubleValue;
-            case NYdb::EPrimitiveType::Date:
-            case NYdb::EPrimitiveType::Datetime:
-                return Ydb::Value::kUint32Value;
-            case NYdb::EPrimitiveType::Timestamp:
-                return Ydb::Value::kUint64Value;
-            case NYdb::EPrimitiveType::Interval:
-                return Ydb::Value::kInt64Value;
-            case NYdb::EPrimitiveType::TzDate:
-            case NYdb::EPrimitiveType::TzDatetime:
-            case NYdb::EPrimitiveType::TzTimestamp:
-                return Ydb::Value::kTextValue;
-            case NYdb::EPrimitiveType::String:
-                return Ydb::Value::kBytesValue;
-            case NYdb::EPrimitiveType::Utf8:
-                return Ydb::Value::kTextValue;
-            case NYdb::EPrimitiveType::Yson:
-                return Ydb::Value::kBytesValue;
-            case NYdb::EPrimitiveType::Json:
+    const Ydb::Value& GetProto() const { 
+        return *static_cast<const Ydb::Value*>(GetPathBack().Ptr); 
+    } 
+ 
+    const Ydb::ValuePair& GetProtoPair() const { 
+        if (GetPathBack().Kind != EParseKind::Pair) { 
+            FatalError(TStringBuilder() << "Bad parser state, expected dict pair"); 
+        } 
+ 
+        return *static_cast<const Ydb::ValuePair*>(GetPathBack().Ptr); 
+    } 
+ 
+    Ydb::Value::ValueCase GetPrimitiveValueCase(NYdb::EPrimitiveType primitiveTypeId) const { 
+        switch (primitiveTypeId) { 
+            case NYdb::EPrimitiveType::Bool: 
+                return Ydb::Value::kBoolValue; 
+            case NYdb::EPrimitiveType::Int8: 
+                return Ydb::Value::kInt32Value; 
+            case NYdb::EPrimitiveType::Uint8: 
+                return Ydb::Value::kUint32Value; 
+            case NYdb::EPrimitiveType::Int16: 
+                return Ydb::Value::kInt32Value; 
+            case NYdb::EPrimitiveType::Uint16: 
+                return Ydb::Value::kUint32Value; 
+            case NYdb::EPrimitiveType::Int32: 
+                return Ydb::Value::kInt32Value; 
+            case NYdb::EPrimitiveType::Uint32: 
+                return Ydb::Value::kUint32Value; 
+            case NYdb::EPrimitiveType::Int64: 
+                return Ydb::Value::kInt64Value; 
+            case NYdb::EPrimitiveType::Uint64: 
+                return Ydb::Value::kUint64Value; 
+            case NYdb::EPrimitiveType::Float: 
+                return Ydb::Value::kFloatValue; 
+            case NYdb::EPrimitiveType::Double: 
+                return Ydb::Value::kDoubleValue; 
+            case NYdb::EPrimitiveType::Date: 
+            case NYdb::EPrimitiveType::Datetime: 
+                return Ydb::Value::kUint32Value; 
+            case NYdb::EPrimitiveType::Timestamp: 
+                return Ydb::Value::kUint64Value; 
+            case NYdb::EPrimitiveType::Interval: 
+                return Ydb::Value::kInt64Value; 
+            case NYdb::EPrimitiveType::TzDate: 
+            case NYdb::EPrimitiveType::TzDatetime: 
+            case NYdb::EPrimitiveType::TzTimestamp: 
+                return Ydb::Value::kTextValue; 
+            case NYdb::EPrimitiveType::String: 
+                return Ydb::Value::kBytesValue; 
+            case NYdb::EPrimitiveType::Utf8: 
+                return Ydb::Value::kTextValue; 
+            case NYdb::EPrimitiveType::Yson: 
+                return Ydb::Value::kBytesValue; 
+            case NYdb::EPrimitiveType::Json: 
             case NYdb::EPrimitiveType::JsonDocument:
             case NYdb::EPrimitiveType::DyNumber:
-                return Ydb::Value::kTextValue;
-            default:
-                FatalError(TStringBuilder() << "Unexpected primitive type: " << primitiveTypeId);
-                return Ydb::Value::kBytesValue;
-        }
-    }
-
-    void FatalError(const TString& msg) const {
+                return Ydb::Value::kTextValue; 
+            default: 
+                FatalError(TStringBuilder() << "Unexpected primitive type: " << primitiveTypeId); 
+                return Ydb::Value::kBytesValue; 
+        } 
+    } 
+ 
+    void FatalError(const TString& msg) const { 
         ThrowFatalError(TStringBuilder() << "TValueParser: " << msg);
-    }
-
-private:
-    std::shared_ptr<TValue::TImpl> Value_;
-    TTypeParser TypeParser_;
-    TStackVec<TProtoPosition, 8> Path_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-TValueParser::TValueParser(TValueParser&&) = default;
-TValueParser::~TValueParser() = default;
-
-TValueParser::TValueParser(const TValue& value)
+    } 
+ 
+private: 
+    std::shared_ptr<TValue::TImpl> Value_; 
+    TTypeParser TypeParser_; 
+    TStackVec<TProtoPosition, 8> Path_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TValueParser::TValueParser(TValueParser&&) = default; 
+TValueParser::~TValueParser() = default; 
+ 
+TValueParser::TValueParser(const TValue& value) 
     : Impl_(new TImpl(value)) {}
-
-TValueParser::TValueParser(const TType& type)
+ 
+TValueParser::TValueParser(const TType& type) 
     : Impl_(new TImpl(type)) {}
-
-void TValueParser::Reset(const Ydb::Value& value) {
-    Impl_->Reset(value);
-}
-
-TTypeParser::ETypeKind TValueParser::GetKind() const {
-    return Impl_->GetKind();
-}
-
-EPrimitiveType TValueParser::GetPrimitiveType() const {
-    return Impl_->GetPrimitiveType();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-bool TValueParser::GetBool() const {
-    return Impl_->GetBool();
-}
-
-i8 TValueParser::GetInt8() const {
-    return Impl_->GetInt8();
-}
-
-ui8 TValueParser::GetUint8() const {
-    return Impl_->GetUint8();
-}
-
-i16 TValueParser::GetInt16() const {
-    return Impl_->GetInt16();
-}
-
-ui16 TValueParser::GetUint16() const {
-    return Impl_->GetUint16();
-}
-
-i32 TValueParser::GetInt32() const {
-    return Impl_->GetInt32();
-}
-
-ui32 TValueParser::GetUint32() const {
-    return Impl_->GetUint32();
-}
-
-i64 TValueParser::GetInt64() const {
-    return Impl_->GetInt64();
-}
-
-ui64 TValueParser::GetUint64() const {
-    return Impl_->GetUint64();
-}
-
-float TValueParser::GetFloat() const {
-    return Impl_->GetFloat();
-}
-
-double TValueParser::GetDouble() const {
-    return Impl_->GetDouble();
-}
-
-TInstant TValueParser::GetDate() const {
-    return Impl_->GetDate();
-}
-
-TInstant TValueParser::GetDatetime() const {
-    return Impl_->GetDatetime();
-}
-
-TInstant TValueParser::GetTimestamp() const {
-    return Impl_->GetTimestamp();
-}
-
-i64 TValueParser::GetInterval() const {
-    return Impl_->GetInterval();
-}
-
-const TString& TValueParser::GetTzDate() const {
-    return Impl_->GetTzDate();
-}
-
-const TString& TValueParser::GetTzDatetime() const {
-    return Impl_->GetTzDatetime();
-}
-
-const TString& TValueParser::GetTzTimestamp() const {
-    return Impl_->GetTzTimestamp();
-}
-
-const TString& TValueParser::GetString() const {
-    return Impl_->GetString();
-}
-
-const TString& TValueParser::GetUtf8() const {
-    return Impl_->GetUtf8();
-}
-
-const TString& TValueParser::GetYson() const {
-    return Impl_->GetYson();
-}
-
-const TString& TValueParser::GetJson() const {
-    return Impl_->GetJson();
-}
-
+ 
+void TValueParser::Reset(const Ydb::Value& value) { 
+    Impl_->Reset(value); 
+} 
+ 
+TTypeParser::ETypeKind TValueParser::GetKind() const { 
+    return Impl_->GetKind(); 
+} 
+ 
+EPrimitiveType TValueParser::GetPrimitiveType() const { 
+    return Impl_->GetPrimitiveType(); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+bool TValueParser::GetBool() const { 
+    return Impl_->GetBool(); 
+} 
+ 
+i8 TValueParser::GetInt8() const { 
+    return Impl_->GetInt8(); 
+} 
+ 
+ui8 TValueParser::GetUint8() const { 
+    return Impl_->GetUint8(); 
+} 
+ 
+i16 TValueParser::GetInt16() const { 
+    return Impl_->GetInt16(); 
+} 
+ 
+ui16 TValueParser::GetUint16() const { 
+    return Impl_->GetUint16(); 
+} 
+ 
+i32 TValueParser::GetInt32() const { 
+    return Impl_->GetInt32(); 
+} 
+ 
+ui32 TValueParser::GetUint32() const { 
+    return Impl_->GetUint32(); 
+} 
+ 
+i64 TValueParser::GetInt64() const { 
+    return Impl_->GetInt64(); 
+} 
+ 
+ui64 TValueParser::GetUint64() const { 
+    return Impl_->GetUint64(); 
+} 
+ 
+float TValueParser::GetFloat() const { 
+    return Impl_->GetFloat(); 
+} 
+ 
+double TValueParser::GetDouble() const { 
+    return Impl_->GetDouble(); 
+} 
+ 
+TInstant TValueParser::GetDate() const { 
+    return Impl_->GetDate(); 
+} 
+ 
+TInstant TValueParser::GetDatetime() const { 
+    return Impl_->GetDatetime(); 
+} 
+ 
+TInstant TValueParser::GetTimestamp() const { 
+    return Impl_->GetTimestamp(); 
+} 
+ 
+i64 TValueParser::GetInterval() const { 
+    return Impl_->GetInterval(); 
+} 
+ 
+const TString& TValueParser::GetTzDate() const { 
+    return Impl_->GetTzDate(); 
+} 
+ 
+const TString& TValueParser::GetTzDatetime() const { 
+    return Impl_->GetTzDatetime(); 
+} 
+ 
+const TString& TValueParser::GetTzTimestamp() const { 
+    return Impl_->GetTzTimestamp(); 
+} 
+ 
+const TString& TValueParser::GetString() const { 
+    return Impl_->GetString(); 
+} 
+ 
+const TString& TValueParser::GetUtf8() const { 
+    return Impl_->GetUtf8(); 
+} 
+ 
+const TString& TValueParser::GetYson() const { 
+    return Impl_->GetYson(); 
+} 
+ 
+const TString& TValueParser::GetJson() const { 
+    return Impl_->GetJson(); 
+} 
+ 
 const TString& TValueParser::GetJsonDocument() const {
     return Impl_->GetJsonDocument();
 }
@@ -1559,102 +1559,102 @@ TDecimalValue TValueParser::GetDecimal() const {
     return Impl_->GetDecimal();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-#define RET_OPT_VALUE(Type, Name) \
-    Impl_->OpenOptional(); \
-    auto value = Impl_->IsNull() ? TMaybe<Type>() : Impl_->Get##Name(); \
-    Impl_->CloseOptional(); \
-    return value;
-
-TMaybe<bool> TValueParser::GetOptionalBool() const {
-    RET_OPT_VALUE(bool, Bool);
-}
-
-TMaybe<i8> TValueParser::GetOptionalInt8() const {
-    RET_OPT_VALUE(i8, Int8);
-}
-
-TMaybe<ui8> TValueParser::GetOptionalUint8() const {
-    RET_OPT_VALUE(ui8, Uint8);
-}
-
-TMaybe<i16> TValueParser::GetOptionalInt16() const {
-    RET_OPT_VALUE(i16, Int16);
-}
-
-TMaybe<ui16> TValueParser::GetOptionalUint16() const {
-    RET_OPT_VALUE(ui16, Uint16);
-}
-
-TMaybe<i32> TValueParser::GetOptionalInt32() const {
-    RET_OPT_VALUE(i32, Int32);
-}
-
-TMaybe<ui32> TValueParser::GetOptionalUint32() const {
-    RET_OPT_VALUE(ui32, Uint32);
-}
-
-TMaybe<i64> TValueParser::GetOptionalInt64() const {
-    RET_OPT_VALUE(i64, Int64);
-}
-
-TMaybe<ui64> TValueParser::GetOptionalUint64() const {
-    RET_OPT_VALUE(ui64, Uint64);
-}
-
-TMaybe<float> TValueParser::GetOptionalFloat() const {
-    RET_OPT_VALUE(float, Float);
-}
-
-TMaybe<double> TValueParser::GetOptionalDouble() const {
-    RET_OPT_VALUE(double, Double);
-}
-
-TMaybe<TInstant> TValueParser::GetOptionalDate() const {
-    RET_OPT_VALUE(TInstant, Date);
-}
-
-TMaybe<TInstant> TValueParser::GetOptionalDatetime() const {
-    RET_OPT_VALUE(TInstant, Datetime);
-}
-
-TMaybe<TInstant> TValueParser::GetOptionalTimestamp() const {
-    RET_OPT_VALUE(TInstant, Timestamp);
-}
-
-TMaybe<i64> TValueParser::GetOptionalInterval() const {
-    RET_OPT_VALUE(i64, Interval);
-}
-
-TMaybe<TString> TValueParser::GetOptionalTzDate() const {
-    RET_OPT_VALUE(TString, TzDate);
-}
-
-TMaybe<TString> TValueParser::GetOptionalTzDatetime() const {
-    RET_OPT_VALUE(TString, TzDatetime);
-}
-
-TMaybe<TString> TValueParser::GetOptionalTzTimestamp() const {
-    RET_OPT_VALUE(TString, TzTimestamp);
-}
-
-TMaybe<TString> TValueParser::GetOptionalString() const {
-    RET_OPT_VALUE(TString, String);
-}
-
-TMaybe<TString> TValueParser::GetOptionalUtf8() const {
-    RET_OPT_VALUE(TString, Utf8);
-}
-
-TMaybe<TString> TValueParser::GetOptionalYson() const {
-    RET_OPT_VALUE(TString, Yson);
-}
-
-TMaybe<TString> TValueParser::GetOptionalJson() const {
-    RET_OPT_VALUE(TString, Json);
-}
-
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+#define RET_OPT_VALUE(Type, Name) \ 
+    Impl_->OpenOptional(); \ 
+    auto value = Impl_->IsNull() ? TMaybe<Type>() : Impl_->Get##Name(); \ 
+    Impl_->CloseOptional(); \ 
+    return value; 
+ 
+TMaybe<bool> TValueParser::GetOptionalBool() const { 
+    RET_OPT_VALUE(bool, Bool); 
+} 
+ 
+TMaybe<i8> TValueParser::GetOptionalInt8() const { 
+    RET_OPT_VALUE(i8, Int8); 
+} 
+ 
+TMaybe<ui8> TValueParser::GetOptionalUint8() const { 
+    RET_OPT_VALUE(ui8, Uint8); 
+} 
+ 
+TMaybe<i16> TValueParser::GetOptionalInt16() const { 
+    RET_OPT_VALUE(i16, Int16); 
+} 
+ 
+TMaybe<ui16> TValueParser::GetOptionalUint16() const { 
+    RET_OPT_VALUE(ui16, Uint16); 
+} 
+ 
+TMaybe<i32> TValueParser::GetOptionalInt32() const { 
+    RET_OPT_VALUE(i32, Int32); 
+} 
+ 
+TMaybe<ui32> TValueParser::GetOptionalUint32() const { 
+    RET_OPT_VALUE(ui32, Uint32); 
+} 
+ 
+TMaybe<i64> TValueParser::GetOptionalInt64() const { 
+    RET_OPT_VALUE(i64, Int64); 
+} 
+ 
+TMaybe<ui64> TValueParser::GetOptionalUint64() const { 
+    RET_OPT_VALUE(ui64, Uint64); 
+} 
+ 
+TMaybe<float> TValueParser::GetOptionalFloat() const { 
+    RET_OPT_VALUE(float, Float); 
+} 
+ 
+TMaybe<double> TValueParser::GetOptionalDouble() const { 
+    RET_OPT_VALUE(double, Double); 
+} 
+ 
+TMaybe<TInstant> TValueParser::GetOptionalDate() const { 
+    RET_OPT_VALUE(TInstant, Date); 
+} 
+ 
+TMaybe<TInstant> TValueParser::GetOptionalDatetime() const { 
+    RET_OPT_VALUE(TInstant, Datetime); 
+} 
+ 
+TMaybe<TInstant> TValueParser::GetOptionalTimestamp() const { 
+    RET_OPT_VALUE(TInstant, Timestamp); 
+} 
+ 
+TMaybe<i64> TValueParser::GetOptionalInterval() const { 
+    RET_OPT_VALUE(i64, Interval); 
+} 
+ 
+TMaybe<TString> TValueParser::GetOptionalTzDate() const { 
+    RET_OPT_VALUE(TString, TzDate); 
+} 
+ 
+TMaybe<TString> TValueParser::GetOptionalTzDatetime() const { 
+    RET_OPT_VALUE(TString, TzDatetime); 
+} 
+ 
+TMaybe<TString> TValueParser::GetOptionalTzTimestamp() const { 
+    RET_OPT_VALUE(TString, TzTimestamp); 
+} 
+ 
+TMaybe<TString> TValueParser::GetOptionalString() const { 
+    RET_OPT_VALUE(TString, String); 
+} 
+ 
+TMaybe<TString> TValueParser::GetOptionalUtf8() const { 
+    RET_OPT_VALUE(TString, Utf8); 
+} 
+ 
+TMaybe<TString> TValueParser::GetOptionalYson() const { 
+    RET_OPT_VALUE(TString, Yson); 
+} 
+ 
+TMaybe<TString> TValueParser::GetOptionalJson() const { 
+    RET_OPT_VALUE(TString, Json); 
+} 
+ 
 TMaybe<TString> TValueParser::GetOptionalJsonDocument() const {
     RET_OPT_VALUE(TString, JsonDocument);
 }
@@ -1667,80 +1667,80 @@ TMaybe<TDecimalValue> TValueParser::GetOptionalDecimal() const {
     RET_OPT_VALUE(TDecimalValue, Decimal);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-void TValueParser::OpenOptional() {
-    Impl_->OpenOptional();
-}
-
-bool TValueParser::IsNull() const {
-    return Impl_->IsNull();
-}
-
-void TValueParser::CloseOptional() {
-    Impl_->CloseOptional();
-}
-
-void TValueParser::OpenList() {
-    Impl_->OpenList();
-}
-
-bool TValueParser::TryNextListItem() {
-    return Impl_->TryNextListItem();
-}
-
-void TValueParser::CloseList() {
-    Impl_->CloseList();
-}
-
-void TValueParser::OpenStruct() {
-    Impl_->OpenStruct();
-}
-
-bool TValueParser::TryNextMember() {
-    return Impl_->TryNextMember();
-}
-
-const TString& TValueParser::GetMemberName() const {
-    return Impl_->GetMemberName();
-}
-
-void TValueParser::CloseStruct() {
-    Impl_->CloseStruct();
-}
-
-void TValueParser::OpenTuple() {
-    Impl_->OpenTuple();
-}
-
-bool TValueParser::TryNextElement() {
-    return Impl_->TryNextElement();
-}
-
-void TValueParser::CloseTuple() {
-    Impl_->CloseTuple();
-}
-
-void TValueParser::OpenDict() {
-    Impl_->OpenDict();
-}
-
-bool TValueParser::TryNextDictItem() {
-    return Impl_->TryNextDictItem();
-}
-
-void TValueParser::DictKey() {
-    Impl_->DictKey();
-}
-
-void TValueParser::DictPayload() {
-    Impl_->DictPayload();
-}
-
-void TValueParser::CloseDict() {
-    Impl_->CloseDict();
-}
-
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+void TValueParser::OpenOptional() { 
+    Impl_->OpenOptional(); 
+} 
+ 
+bool TValueParser::IsNull() const { 
+    return Impl_->IsNull(); 
+} 
+ 
+void TValueParser::CloseOptional() { 
+    Impl_->CloseOptional(); 
+} 
+ 
+void TValueParser::OpenList() { 
+    Impl_->OpenList(); 
+} 
+ 
+bool TValueParser::TryNextListItem() { 
+    return Impl_->TryNextListItem(); 
+} 
+ 
+void TValueParser::CloseList() { 
+    Impl_->CloseList(); 
+} 
+ 
+void TValueParser::OpenStruct() { 
+    Impl_->OpenStruct(); 
+} 
+ 
+bool TValueParser::TryNextMember() { 
+    return Impl_->TryNextMember(); 
+} 
+ 
+const TString& TValueParser::GetMemberName() const { 
+    return Impl_->GetMemberName(); 
+} 
+ 
+void TValueParser::CloseStruct() { 
+    Impl_->CloseStruct(); 
+} 
+ 
+void TValueParser::OpenTuple() { 
+    Impl_->OpenTuple(); 
+} 
+ 
+bool TValueParser::TryNextElement() { 
+    return Impl_->TryNextElement(); 
+} 
+ 
+void TValueParser::CloseTuple() { 
+    Impl_->CloseTuple(); 
+} 
+ 
+void TValueParser::OpenDict() { 
+    Impl_->OpenDict(); 
+} 
+ 
+bool TValueParser::TryNextDictItem() { 
+    return Impl_->TryNextDictItem(); 
+} 
+ 
+void TValueParser::DictKey() { 
+    Impl_->DictKey(); 
+} 
+ 
+void TValueParser::DictPayload() { 
+    Impl_->DictPayload(); 
+} 
+ 
+void TValueParser::CloseDict() { 
+    Impl_->CloseDict(); 
+} 
+ 
 void TValueParser::OpenVariant() {
     Impl_->OpenVariant();
 }
@@ -1761,176 +1761,176 @@ void TValueParser::CloseTagged() {
     Impl_->CloseTagged();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-class TValueBuilderImpl {
-    using ETypeKind = TTypeParser::ETypeKind;
-    using TMembersMap = TMap<TString, size_t>;
-
-    struct TProtoPosition {
-        Ydb::Value& Value;
-        bool BuildType = false;
-        ui32 OptLevel = 0;
-
-       TProtoPosition(Ydb::Value& value)
-            : Value(value) {}
-    };
-
-    struct TStructPosition {
-        const TMembersMap* MembersMap = nullptr;
-        TDynBitMap FilledMembers;
-
-        TStructPosition(const TMembersMap* membersMap)
-            : MembersMap(membersMap)
-            , FilledMembers() {}
-    };
-
-public:
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+class TValueBuilderImpl { 
+    using ETypeKind = TTypeParser::ETypeKind; 
+    using TMembersMap = TMap<TString, size_t>; 
+ 
+    struct TProtoPosition { 
+        Ydb::Value& Value; 
+        bool BuildType = false; 
+        ui32 OptLevel = 0; 
+ 
+       TProtoPosition(Ydb::Value& value) 
+            : Value(value) {} 
+    }; 
+ 
+    struct TStructPosition { 
+        const TMembersMap* MembersMap = nullptr; 
+        TDynBitMap FilledMembers; 
+ 
+        TStructPosition(const TMembersMap* membersMap) 
+            : MembersMap(membersMap) 
+            , FilledMembers() {} 
+    }; 
+ 
+public: 
     TValueBuilderImpl()
         : TypeBuilder_()
-    {
-        PushPath(ProtoValue_);
-    }
-
+    { 
+        PushPath(ProtoValue_); 
+    } 
+ 
     TValueBuilderImpl(const TType& type)
         : TypeBuilder_()
-    {
-        PushPath(ProtoValue_);
-        GetType().CopyFrom(TProtoAccessor::GetProto(type));
-    }
-
+    { 
+        PushPath(ProtoValue_); 
+        GetType().CopyFrom(TProtoAccessor::GetProto(type)); 
+    } 
+ 
     TValueBuilderImpl(Ydb::Type& type, Ydb::Value& value)
         : TypeBuilder_(type)
-    {
-        PushPath(value);
-    }
-
-    void CheckValue() {
-        if (Path_.size() > 1) {
-            FatalError("Invalid Build() call, value is incomplete.");
-            return;
-        }
-    }
-
-    TValue BuildValue() {
-        CheckValue();
-
-        Ydb::Value value;
-        value.Swap(&ProtoValue_);
-
-        return TValue(TypeBuilder_.Build(), std::move(value));
-    }
-
-    void Bool(bool value) {
-        FillPrimitiveType(EPrimitiveType::Bool);
-        GetValue().set_bool_value(value);
-    }
-
-    void Int8(i8 value) {
-        FillPrimitiveType(EPrimitiveType::Int8);
-        GetValue().set_int32_value(value);
-    }
-
-    void Uint8(ui8 value) {
-        FillPrimitiveType(EPrimitiveType::Uint8);
-        GetValue().set_uint32_value(value);
-    }
-
-    void Int16(i16 value) {
-        FillPrimitiveType(EPrimitiveType::Int16);
-        GetValue().set_int32_value(value);
-    }
-
-    void Uint16(ui16 value) {
-        FillPrimitiveType(EPrimitiveType::Uint16);
-        GetValue().set_uint32_value(value);
-    }
-
-    void Int32(i32 value) {
-        FillPrimitiveType(EPrimitiveType::Int32);
-        GetValue().set_int32_value(value);
-    }
-
-    void Uint32(ui32 value) {
-        FillPrimitiveType(EPrimitiveType::Uint32);
-        GetValue().set_uint32_value(value);
-    }
-
-    void Int64(i64 value) {
-        FillPrimitiveType(EPrimitiveType::Int64);
-        GetValue().set_int64_value(value);
-    }
-
-    void Uint64(ui64 value) {
-        FillPrimitiveType(EPrimitiveType::Uint64);
-        GetValue().set_uint64_value(value);
-    }
-
-    void Float(float value) {
-        FillPrimitiveType(EPrimitiveType::Float);
-        GetValue().set_float_value(value);
-    }
-
-    void Double(double value) {
-        FillPrimitiveType(EPrimitiveType::Double);
-        GetValue().set_double_value(value);
-    }
-
-    void Date(const TInstant& value) {
-        FillPrimitiveType(EPrimitiveType::Date);
-        GetValue().set_uint32_value(value.Days());
-    }
-
-    void Datetime(const TInstant& value) {
-        FillPrimitiveType(EPrimitiveType::Datetime);
-        GetValue().set_uint32_value(value.Seconds());
-    }
-
-    void Timestamp(const TInstant& value) {
-        FillPrimitiveType(EPrimitiveType::Timestamp);
-        GetValue().set_uint64_value(value.MicroSeconds());
-    }
-
-    void Interval(i64 value) {
-        FillPrimitiveType(EPrimitiveType::Interval);
-        GetValue().set_int64_value(value);
-    }
-
-    void TzDate(const TString& value) {
-        FillPrimitiveType(EPrimitiveType::TzDate);
-        GetValue().set_text_value(value);
-    }
-
-    void TzDatetime(const TString& value) {
-        FillPrimitiveType(EPrimitiveType::TzDatetime);
-        GetValue().set_text_value(value);
-    }
-
-    void TzTimestamp(const TString& value) {
-        FillPrimitiveType(EPrimitiveType::TzTimestamp);
-        GetValue().set_text_value(value);
-    }
-
-    void String(const TString& value) {
-        FillPrimitiveType(EPrimitiveType::String);
-        GetValue().set_bytes_value(value);
-    }
-
-    void Utf8(const TString& value) {
-        FillPrimitiveType(EPrimitiveType::Utf8);
-        GetValue().set_text_value(value);
-    }
-
-    void Yson(const TString& value) {
-        FillPrimitiveType(EPrimitiveType::Yson);
-        GetValue().set_bytes_value(value);
-    }
-
-    void Json(const TString& value) {
-        FillPrimitiveType(EPrimitiveType::Json);
-        GetValue().set_text_value(value);
-    }
-
+    { 
+        PushPath(value); 
+    } 
+ 
+    void CheckValue() { 
+        if (Path_.size() > 1) { 
+            FatalError("Invalid Build() call, value is incomplete."); 
+            return; 
+        } 
+    } 
+ 
+    TValue BuildValue() { 
+        CheckValue(); 
+ 
+        Ydb::Value value; 
+        value.Swap(&ProtoValue_); 
+ 
+        return TValue(TypeBuilder_.Build(), std::move(value)); 
+    } 
+ 
+    void Bool(bool value) { 
+        FillPrimitiveType(EPrimitiveType::Bool); 
+        GetValue().set_bool_value(value); 
+    } 
+ 
+    void Int8(i8 value) { 
+        FillPrimitiveType(EPrimitiveType::Int8); 
+        GetValue().set_int32_value(value); 
+    } 
+ 
+    void Uint8(ui8 value) { 
+        FillPrimitiveType(EPrimitiveType::Uint8); 
+        GetValue().set_uint32_value(value); 
+    } 
+ 
+    void Int16(i16 value) { 
+        FillPrimitiveType(EPrimitiveType::Int16); 
+        GetValue().set_int32_value(value); 
+    } 
+ 
+    void Uint16(ui16 value) { 
+        FillPrimitiveType(EPrimitiveType::Uint16); 
+        GetValue().set_uint32_value(value); 
+    } 
+ 
+    void Int32(i32 value) { 
+        FillPrimitiveType(EPrimitiveType::Int32); 
+        GetValue().set_int32_value(value); 
+    } 
+ 
+    void Uint32(ui32 value) { 
+        FillPrimitiveType(EPrimitiveType::Uint32); 
+        GetValue().set_uint32_value(value); 
+    } 
+ 
+    void Int64(i64 value) { 
+        FillPrimitiveType(EPrimitiveType::Int64); 
+        GetValue().set_int64_value(value); 
+    } 
+ 
+    void Uint64(ui64 value) { 
+        FillPrimitiveType(EPrimitiveType::Uint64); 
+        GetValue().set_uint64_value(value); 
+    } 
+ 
+    void Float(float value) { 
+        FillPrimitiveType(EPrimitiveType::Float); 
+        GetValue().set_float_value(value); 
+    } 
+ 
+    void Double(double value) { 
+        FillPrimitiveType(EPrimitiveType::Double); 
+        GetValue().set_double_value(value); 
+    } 
+ 
+    void Date(const TInstant& value) { 
+        FillPrimitiveType(EPrimitiveType::Date); 
+        GetValue().set_uint32_value(value.Days()); 
+    } 
+ 
+    void Datetime(const TInstant& value) { 
+        FillPrimitiveType(EPrimitiveType::Datetime); 
+        GetValue().set_uint32_value(value.Seconds()); 
+    } 
+ 
+    void Timestamp(const TInstant& value) { 
+        FillPrimitiveType(EPrimitiveType::Timestamp); 
+        GetValue().set_uint64_value(value.MicroSeconds()); 
+    } 
+ 
+    void Interval(i64 value) { 
+        FillPrimitiveType(EPrimitiveType::Interval); 
+        GetValue().set_int64_value(value); 
+    } 
+ 
+    void TzDate(const TString& value) { 
+        FillPrimitiveType(EPrimitiveType::TzDate); 
+        GetValue().set_text_value(value); 
+    } 
+ 
+    void TzDatetime(const TString& value) { 
+        FillPrimitiveType(EPrimitiveType::TzDatetime); 
+        GetValue().set_text_value(value); 
+    } 
+ 
+    void TzTimestamp(const TString& value) { 
+        FillPrimitiveType(EPrimitiveType::TzTimestamp); 
+        GetValue().set_text_value(value); 
+    } 
+ 
+    void String(const TString& value) { 
+        FillPrimitiveType(EPrimitiveType::String); 
+        GetValue().set_bytes_value(value); 
+    } 
+ 
+    void Utf8(const TString& value) { 
+        FillPrimitiveType(EPrimitiveType::Utf8); 
+        GetValue().set_text_value(value); 
+    } 
+ 
+    void Yson(const TString& value) { 
+        FillPrimitiveType(EPrimitiveType::Yson); 
+        GetValue().set_bytes_value(value); 
+    } 
+ 
+    void Json(const TString& value) { 
+        FillPrimitiveType(EPrimitiveType::Json); 
+        GetValue().set_text_value(value); 
+    } 
+ 
     void JsonDocument(const TString& value) {
         FillPrimitiveType(EPrimitiveType::JsonDocument);
         GetValue().set_text_value(value);
@@ -1947,430 +1947,430 @@ public:
         GetValue().set_high_128(value.Hi_);
     }
 
-    void BeginOptional() {
-        SetBuildType(!CheckType(ETypeKind::Optional));
-
-        auto optLevel = PathTop().OptLevel;
-        if (optLevel == 0) {
-            PushPath(GetValue());
-        }
-
-        TypeBuilder_.BeginOptional();
-
-        ++PathTop().OptLevel;
-    }
-
-    void EndOptional() {
-        CheckContainerKind(ETypeKind::Optional);
-
-        TypeBuilder_.EndOptional();
-
-        if (!PathTop().OptLevel) {
-            FatalError(TStringBuilder() << "No opened optional");
-        }
-
-        --PathTop().OptLevel;
-
-        if (!PathTop().OptLevel) {
-            PopPath();
-        }
-    }
-
-    void BeginOptional(const TType& itemType) {
-        BeginOptional();
-        if (!CheckType(itemType)) {
-            TypeBuilder_.SetType(itemType);
-        }
-    }
-
-    void EmptyOptional(const TType& itemType) {
-        BeginOptional(itemType);
-        NestEmptyOptional();
-        EndOptional();
-    }
-
-    void EmptyOptional(EPrimitiveType itemType) {
-        BeginOptional();
-        FillPrimitiveType(itemType);
-        NestEmptyOptional();
-        EndOptional();
-    }
-
-    void EmptyOptional() {
-        BeginOptional();
-        if (!CheckType()) {
-            FatalError(TStringBuilder() << "EmptyOptional: unknown item type");
-            return;
-        }
-        NestEmptyOptional();
-        EndOptional();
-    }
-
-    void BeginList(const TType& itemType) {
-        BeginList();
-
-        if (!CheckType(itemType)) {
-            TypeBuilder_.SetType(itemType);
-        }
-    }
-
-    void BeginList() {
-        SetBuildType(!CheckType(ETypeKind::List));
-
-        TypeBuilder_.BeginList();
-        PushPath(GetValue());
-    }
-
-    void EndList() {
-        CheckContainerKind(ETypeKind::List);
-
-        TypeBuilder_.EndList();
-        PopPath();
-    }
-
-    void AddListItem() {
-        CheckContainerKind(ETypeKind::List);
-        PopPath();
-        PushPath(*GetValue().add_items());
-    }
-
-    void AddListItem(const TValue& itemValue) {
-        CheckContainerKind(ETypeKind::List);
-        PopPath();
-        PushPath(*GetValue().add_items());
-
-        if (!CheckType(itemValue.GetType())) {
-            TypeBuilder_.SetType(itemValue.GetType());
-        }
-        SetProtoValue(itemValue);
-    }
-
-    void EmptyList(const TType& itemType) {
-        BeginList(itemType);
-        EndList();
-    }
-
-    void EmptyList() {
-        BeginList();
-        if (!CheckType()) {
-            FatalError(TStringBuilder() << "EmptyList: unknown item type");
-            return;
-        }
-        EndList();
-    }
-
-    void BeginStruct() {
-        SetBuildType(!CheckType(ETypeKind::Struct));
-        if (!GetBuildType()) {
-            auto& membersMap = GetMembersMap(GetType().mutable_struct_type());
-            GetValue().mutable_items()->Reserve(membersMap.size());
-            for (ui32 i = 0; i < membersMap.size(); ++i) {
-                GetValue().mutable_items()->Add();
-            }
-
-            PushStructsPath(&membersMap);
-        }
-
-        TypeBuilder_.BeginStruct();
-        PushPath(GetValue());
-    }
-
-    void AddMember(const TString& memberName) {
-        CheckContainerKind(ETypeKind::Struct);
-
-        PopPath();
-
-        if (GetBuildType()) {
-            TypeBuilder_.AddMember(memberName);
-            PushPath(*GetValue().add_items());
-        } else {
-            auto membersMap = StructsPathTop().MembersMap;
-            if (!membersMap) {
-                FatalError(TStringBuilder() << "Missing struct members info.");
-                return;
-            }
-
-            auto memberIndex = membersMap->FindPtr(memberName);
-            if (!memberIndex) {
-                FatalError(TStringBuilder() << "Struct member not found: " << memberName);
-                return;
-            }
-
-            TypeBuilder_.SelectMember(*memberIndex);
-            PushPath(*GetValue().mutable_items(*memberIndex));
-
-            StructsPathTop().FilledMembers.Set(*memberIndex);
-        }
-    }
-
-    void AddMember(const TString& memberName, const TValue& memberValue) {
-        AddMember(memberName);
-
-        if (!CheckType(memberValue.GetType())) {
-            TypeBuilder_.SetType(memberValue.GetType());
-        }
-
-        SetProtoValue(memberValue);
-    }
-
-    void EndStruct() {
-        CheckContainerKind(ETypeKind::Struct);
-
-        PopPath();
-        TypeBuilder_.EndStruct();
-
-        if (!GetBuildType()) {
-            auto& membersMap = *StructsPathTop().MembersMap;
-            auto& filledMembers = StructsPathTop().FilledMembers;
-
-            if (filledMembers.Count() < membersMap.size()) {
-                filledMembers.Flip();
-                auto index = filledMembers.FirstNonZeroBit();
-                auto it = std::find_if(membersMap.begin(), membersMap.end(),
-                    [index](const auto& pair) { return pair.second == index; });
-
-                FatalError(TStringBuilder() << "No value given for struct member: " << it->first);
-            }
-
-            PopStructsPath();
-        }
-    }
-
-    void BeginTuple() {
-        SetBuildType(!CheckType(ETypeKind::Tuple));
-        TypeBuilder_.BeginTuple();
-        PushPath(GetValue());
-    }
-
-    void AddElement() {
-        CheckContainerKind(ETypeKind::Tuple);
-
-        PopPath();
-
-        if (GetBuildType()) {
-            TypeBuilder_.AddElement();
-        } else {
-            auto index = GetValue().items_size();
-            auto tuple_size = GetType(1).tuple_type().elements_size();
-            if (index >= tuple_size) {
-                FatalError(TStringBuilder() << "Tuple elements count mismatch, expected: "
-                    << tuple_size << ", actual: " << index + 1);
-                return;
-            }
-            TypeBuilder_.SelectElement(index);
-        }
-
-        PushPath(*GetValue().add_items());
-    }
-
-    void AddElement(const TValue& elementValue) {
-        AddElement();
-
-        if (!CheckType(elementValue.GetType())) {
-            TypeBuilder_.SetType(elementValue.GetType());
-        }
-
-        SetProtoValue(elementValue);
-    }
-
-    void EndTuple() {
-        CheckContainerKind(ETypeKind::Tuple);
-
-        PopPath();
-        TypeBuilder_.EndTuple();
-
-        if (!GetBuildType()) {
-            auto expectedElements = GetType().tuple_type().elements_size();
-            auto actualIElements = GetValue().items_size();
-            if (expectedElements != actualIElements) {
-                FatalError(TStringBuilder() << "Tuple elements count mismatch, expected: " << expectedElements
-                    << ", actual: " << actualIElements);
-            }
-        }
-    }
-
-    void BeginDict() {
-        SetBuildType(!CheckType(ETypeKind::Dict));
-        TypeBuilder_.BeginDict();
-        PushPath(GetValue());
-    }
-
-    void BeginDict(const TType& keyType, const TType& payloadType) {
-        BeginDict();
-
-        TypeBuilder_.DictKey();
-        if (!CheckType(keyType)) {
-            TypeBuilder_.SetType(keyType);
-        }
-
-        TypeBuilder_.DictPayload();
-        if (!CheckType(payloadType)) {
-            TypeBuilder_.SetType(payloadType);
-        }
-
-        TypeBuilder_.EndDict();
-        TypeBuilder_.BeginDict();
-    }
-
-    void AddDictItem() {
-        CheckContainerKind(ETypeKind::Dict);
-        PopPath();
-
-        GetValue().add_pairs();
-        PushPath(GetValue());
-    }
-
-    void DictKey() {
-        CheckContainerKind(ETypeKind::Dict);
-        PopPath();
-
-        TypeBuilder_.DictKey();
-        PushPath(*GetValue().mutable_pairs()->rbegin()->mutable_key());
-    }
-
-    void DictKey(const TValue& keyValue) {
-        DictKey();
-
-        if (!CheckType(keyValue.GetType())) {
-            TypeBuilder_.SetType(keyValue.GetType());
-        }
-
-        SetProtoValue(keyValue);
-    }
-
-    void DictPayload() {
-        CheckContainerKind(ETypeKind::Dict);
-        PopPath();
-
-        TypeBuilder_.DictPayload();
-        PushPath(*GetValue().mutable_pairs()->rbegin()->mutable_payload());
-    }
-
-    void DictPayload(const TValue& payloadValue) {
-        DictPayload();
-
-        if (!CheckType(payloadValue.GetType())) {
-            TypeBuilder_.SetType(payloadValue.GetType());
-        }
-
-        SetProtoValue(payloadValue);
-    }
-
-    void EndDict() {
-        CheckContainerKind(ETypeKind::Dict);
-
-        PopPath();
-        TypeBuilder_.EndDict();
-    }
-
-    void EmptyDict(const TType& keyType, const TType& payloadType) {
-        BeginDict(keyType, payloadType);
-        EndDict();
-    }
-
-    void EmptyDict() {
-        BeginDict();
-
-        TypeBuilder_.DictKey();
-        if (!CheckType()) {
-            FatalError(TStringBuilder() << "EmptyDict: unknown key type");
-            return;
-        }
-
-        TypeBuilder_.DictPayload();
-        if (!CheckType()) {
-            FatalError(TStringBuilder() << "EmptyDict: unknown payload type");
-            return;
-        }
-
-        EndDict();
-    }
-
-private:
-    Ydb::Type& GetType(size_t offset = 0) {
-        return TypeBuilder_.GetProto(offset);
-    }
-
-    Ydb::Value& GetValue() {
-        return PathTop().Value;
-    }
-
-    void SetProtoValue(const TValue& value) {
-        GetValue().CopyFrom(TProtoAccessor::GetProto(value));
-    }
-
-    bool GetBuildType() {
-        return PathTop().BuildType;
-    }
-
-    void SetBuildType(bool value) {
-        PathTop().BuildType = value;
-    }
-
-    void FillPrimitiveType(EPrimitiveType type) {
-        if (!CheckPrimitiveType(type)) {
-            TypeBuilder_.Primitive(type);
-        }
-    }
-
+    void BeginOptional() { 
+        SetBuildType(!CheckType(ETypeKind::Optional)); 
+ 
+        auto optLevel = PathTop().OptLevel; 
+        if (optLevel == 0) { 
+            PushPath(GetValue()); 
+        } 
+ 
+        TypeBuilder_.BeginOptional(); 
+ 
+        ++PathTop().OptLevel; 
+    } 
+ 
+    void EndOptional() { 
+        CheckContainerKind(ETypeKind::Optional); 
+ 
+        TypeBuilder_.EndOptional(); 
+ 
+        if (!PathTop().OptLevel) { 
+            FatalError(TStringBuilder() << "No opened optional"); 
+        } 
+ 
+        --PathTop().OptLevel; 
+ 
+        if (!PathTop().OptLevel) { 
+            PopPath(); 
+        } 
+    } 
+ 
+    void BeginOptional(const TType& itemType) { 
+        BeginOptional(); 
+        if (!CheckType(itemType)) { 
+            TypeBuilder_.SetType(itemType); 
+        } 
+    } 
+ 
+    void EmptyOptional(const TType& itemType) { 
+        BeginOptional(itemType); 
+        NestEmptyOptional(); 
+        EndOptional(); 
+    } 
+ 
+    void EmptyOptional(EPrimitiveType itemType) { 
+        BeginOptional(); 
+        FillPrimitiveType(itemType); 
+        NestEmptyOptional(); 
+        EndOptional(); 
+    } 
+ 
+    void EmptyOptional() { 
+        BeginOptional(); 
+        if (!CheckType()) { 
+            FatalError(TStringBuilder() << "EmptyOptional: unknown item type"); 
+            return; 
+        } 
+        NestEmptyOptional(); 
+        EndOptional(); 
+    } 
+ 
+    void BeginList(const TType& itemType) { 
+        BeginList(); 
+ 
+        if (!CheckType(itemType)) { 
+            TypeBuilder_.SetType(itemType); 
+        } 
+    } 
+ 
+    void BeginList() { 
+        SetBuildType(!CheckType(ETypeKind::List)); 
+ 
+        TypeBuilder_.BeginList(); 
+        PushPath(GetValue()); 
+    } 
+ 
+    void EndList() { 
+        CheckContainerKind(ETypeKind::List); 
+ 
+        TypeBuilder_.EndList(); 
+        PopPath(); 
+    } 
+ 
+    void AddListItem() { 
+        CheckContainerKind(ETypeKind::List); 
+        PopPath(); 
+        PushPath(*GetValue().add_items()); 
+    } 
+ 
+    void AddListItem(const TValue& itemValue) { 
+        CheckContainerKind(ETypeKind::List); 
+        PopPath(); 
+        PushPath(*GetValue().add_items()); 
+ 
+        if (!CheckType(itemValue.GetType())) { 
+            TypeBuilder_.SetType(itemValue.GetType()); 
+        } 
+        SetProtoValue(itemValue); 
+    } 
+ 
+    void EmptyList(const TType& itemType) { 
+        BeginList(itemType); 
+        EndList(); 
+    } 
+ 
+    void EmptyList() { 
+        BeginList(); 
+        if (!CheckType()) { 
+            FatalError(TStringBuilder() << "EmptyList: unknown item type"); 
+            return; 
+        } 
+        EndList(); 
+    } 
+ 
+    void BeginStruct() { 
+        SetBuildType(!CheckType(ETypeKind::Struct)); 
+        if (!GetBuildType()) { 
+            auto& membersMap = GetMembersMap(GetType().mutable_struct_type()); 
+            GetValue().mutable_items()->Reserve(membersMap.size()); 
+            for (ui32 i = 0; i < membersMap.size(); ++i) { 
+                GetValue().mutable_items()->Add(); 
+            } 
+ 
+            PushStructsPath(&membersMap); 
+        } 
+ 
+        TypeBuilder_.BeginStruct(); 
+        PushPath(GetValue()); 
+    } 
+ 
+    void AddMember(const TString& memberName) { 
+        CheckContainerKind(ETypeKind::Struct); 
+ 
+        PopPath(); 
+ 
+        if (GetBuildType()) { 
+            TypeBuilder_.AddMember(memberName); 
+            PushPath(*GetValue().add_items()); 
+        } else { 
+            auto membersMap = StructsPathTop().MembersMap; 
+            if (!membersMap) { 
+                FatalError(TStringBuilder() << "Missing struct members info."); 
+                return; 
+            } 
+ 
+            auto memberIndex = membersMap->FindPtr(memberName); 
+            if (!memberIndex) { 
+                FatalError(TStringBuilder() << "Struct member not found: " << memberName); 
+                return; 
+            } 
+ 
+            TypeBuilder_.SelectMember(*memberIndex); 
+            PushPath(*GetValue().mutable_items(*memberIndex)); 
+ 
+            StructsPathTop().FilledMembers.Set(*memberIndex); 
+        } 
+    } 
+ 
+    void AddMember(const TString& memberName, const TValue& memberValue) { 
+        AddMember(memberName); 
+ 
+        if (!CheckType(memberValue.GetType())) { 
+            TypeBuilder_.SetType(memberValue.GetType()); 
+        } 
+ 
+        SetProtoValue(memberValue); 
+    } 
+ 
+    void EndStruct() { 
+        CheckContainerKind(ETypeKind::Struct); 
+ 
+        PopPath(); 
+        TypeBuilder_.EndStruct(); 
+ 
+        if (!GetBuildType()) { 
+            auto& membersMap = *StructsPathTop().MembersMap; 
+            auto& filledMembers = StructsPathTop().FilledMembers; 
+ 
+            if (filledMembers.Count() < membersMap.size()) { 
+                filledMembers.Flip(); 
+                auto index = filledMembers.FirstNonZeroBit(); 
+                auto it = std::find_if(membersMap.begin(), membersMap.end(), 
+                    [index](const auto& pair) { return pair.second == index; }); 
+ 
+                FatalError(TStringBuilder() << "No value given for struct member: " << it->first); 
+            } 
+ 
+            PopStructsPath(); 
+        } 
+    } 
+ 
+    void BeginTuple() { 
+        SetBuildType(!CheckType(ETypeKind::Tuple)); 
+        TypeBuilder_.BeginTuple(); 
+        PushPath(GetValue()); 
+    } 
+ 
+    void AddElement() { 
+        CheckContainerKind(ETypeKind::Tuple); 
+ 
+        PopPath(); 
+ 
+        if (GetBuildType()) { 
+            TypeBuilder_.AddElement(); 
+        } else { 
+            auto index = GetValue().items_size(); 
+            auto tuple_size = GetType(1).tuple_type().elements_size(); 
+            if (index >= tuple_size) { 
+                FatalError(TStringBuilder() << "Tuple elements count mismatch, expected: " 
+                    << tuple_size << ", actual: " << index + 1); 
+                return; 
+            } 
+            TypeBuilder_.SelectElement(index); 
+        } 
+ 
+        PushPath(*GetValue().add_items()); 
+    } 
+ 
+    void AddElement(const TValue& elementValue) { 
+        AddElement(); 
+ 
+        if (!CheckType(elementValue.GetType())) { 
+            TypeBuilder_.SetType(elementValue.GetType()); 
+        } 
+ 
+        SetProtoValue(elementValue); 
+    } 
+ 
+    void EndTuple() { 
+        CheckContainerKind(ETypeKind::Tuple); 
+ 
+        PopPath(); 
+        TypeBuilder_.EndTuple(); 
+ 
+        if (!GetBuildType()) { 
+            auto expectedElements = GetType().tuple_type().elements_size(); 
+            auto actualIElements = GetValue().items_size(); 
+            if (expectedElements != actualIElements) { 
+                FatalError(TStringBuilder() << "Tuple elements count mismatch, expected: " << expectedElements 
+                    << ", actual: " << actualIElements); 
+            } 
+        } 
+    } 
+ 
+    void BeginDict() { 
+        SetBuildType(!CheckType(ETypeKind::Dict)); 
+        TypeBuilder_.BeginDict(); 
+        PushPath(GetValue()); 
+    } 
+ 
+    void BeginDict(const TType& keyType, const TType& payloadType) { 
+        BeginDict(); 
+ 
+        TypeBuilder_.DictKey(); 
+        if (!CheckType(keyType)) { 
+            TypeBuilder_.SetType(keyType); 
+        } 
+ 
+        TypeBuilder_.DictPayload(); 
+        if (!CheckType(payloadType)) { 
+            TypeBuilder_.SetType(payloadType); 
+        } 
+ 
+        TypeBuilder_.EndDict(); 
+        TypeBuilder_.BeginDict(); 
+    } 
+ 
+    void AddDictItem() { 
+        CheckContainerKind(ETypeKind::Dict); 
+        PopPath(); 
+ 
+        GetValue().add_pairs(); 
+        PushPath(GetValue()); 
+    } 
+ 
+    void DictKey() { 
+        CheckContainerKind(ETypeKind::Dict); 
+        PopPath(); 
+ 
+        TypeBuilder_.DictKey(); 
+        PushPath(*GetValue().mutable_pairs()->rbegin()->mutable_key()); 
+    } 
+ 
+    void DictKey(const TValue& keyValue) { 
+        DictKey(); 
+ 
+        if (!CheckType(keyValue.GetType())) { 
+            TypeBuilder_.SetType(keyValue.GetType()); 
+        } 
+ 
+        SetProtoValue(keyValue); 
+    } 
+ 
+    void DictPayload() { 
+        CheckContainerKind(ETypeKind::Dict); 
+        PopPath(); 
+ 
+        TypeBuilder_.DictPayload(); 
+        PushPath(*GetValue().mutable_pairs()->rbegin()->mutable_payload()); 
+    } 
+ 
+    void DictPayload(const TValue& payloadValue) { 
+        DictPayload(); 
+ 
+        if (!CheckType(payloadValue.GetType())) { 
+            TypeBuilder_.SetType(payloadValue.GetType()); 
+        } 
+ 
+        SetProtoValue(payloadValue); 
+    } 
+ 
+    void EndDict() { 
+        CheckContainerKind(ETypeKind::Dict); 
+ 
+        PopPath(); 
+        TypeBuilder_.EndDict(); 
+    } 
+ 
+    void EmptyDict(const TType& keyType, const TType& payloadType) { 
+        BeginDict(keyType, payloadType); 
+        EndDict(); 
+    } 
+ 
+    void EmptyDict() { 
+        BeginDict(); 
+ 
+        TypeBuilder_.DictKey(); 
+        if (!CheckType()) { 
+            FatalError(TStringBuilder() << "EmptyDict: unknown key type"); 
+            return; 
+        } 
+ 
+        TypeBuilder_.DictPayload(); 
+        if (!CheckType()) { 
+            FatalError(TStringBuilder() << "EmptyDict: unknown payload type"); 
+            return; 
+        } 
+ 
+        EndDict(); 
+    } 
+ 
+private: 
+    Ydb::Type& GetType(size_t offset = 0) { 
+        return TypeBuilder_.GetProto(offset); 
+    } 
+ 
+    Ydb::Value& GetValue() { 
+        return PathTop().Value; 
+    } 
+ 
+    void SetProtoValue(const TValue& value) { 
+        GetValue().CopyFrom(TProtoAccessor::GetProto(value)); 
+    } 
+ 
+    bool GetBuildType() { 
+        return PathTop().BuildType; 
+    } 
+ 
+    void SetBuildType(bool value) { 
+        PathTop().BuildType = value; 
+    } 
+ 
+    void FillPrimitiveType(EPrimitiveType type) { 
+        if (!CheckPrimitiveType(type)) { 
+            TypeBuilder_.Primitive(type); 
+        } 
+    } 
+ 
     void FillDecimalType(const TDecimalType& type) {
         if (!CheckDecimalType()) {
             TypeBuilder_.Decimal(type);
         }
     }
 
-    bool CheckType() {
-        if (!GetType().type_case()) {
-            return false;
-        }
-
-        return true;
-    }
-
-    bool CheckType(ETypeKind kind) {
-        if (!CheckType()) {
-            return false;
-        }
-
+    bool CheckType() { 
+        if (!GetType().type_case()) { 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+    bool CheckType(ETypeKind kind) { 
+        if (!CheckType()) { 
+            return false; 
+        } 
+ 
         auto expectedKind = GetKind(GetType());
-        if (expectedKind != kind) {
-            FatalError(TStringBuilder() << "Type mismatch, expected: " << expectedKind
-                << ", actual: " << kind);
-            return false;
-        }
-
-        return true;
-    }
-
-    bool CheckType(const TType& type) {
-        if (!CheckType()) {
-            return false;
-        }
-
-        if (!TypesEqual(GetType(), type)) {
-            FatalError(TStringBuilder() << "Type mismatch, expected: " << FormatType(GetType())
-                << ", actual: " << FormatType(type));
-            return false;
-        }
-
-        return true;
-    }
-
-    bool CheckPrimitiveType(EPrimitiveType type) {
-        if (!CheckType(ETypeKind::Primitive)) {
-            return false;
-        }
-
-        auto expectedType = EPrimitiveType(GetType().type_id());
-        if (expectedType != type) {
-            FatalError(TStringBuilder() << "Primitive type mismatch, expected: " << expectedType
-                << ", actual: " << type);
-            return false;
-        }
-
-        return true;
-    }
-
+        if (expectedKind != kind) { 
+            FatalError(TStringBuilder() << "Type mismatch, expected: " << expectedKind 
+                << ", actual: " << kind); 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+    bool CheckType(const TType& type) { 
+        if (!CheckType()) { 
+            return false; 
+        } 
+ 
+        if (!TypesEqual(GetType(), type)) { 
+            FatalError(TStringBuilder() << "Type mismatch, expected: " << FormatType(GetType()) 
+                << ", actual: " << FormatType(type)); 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+    bool CheckPrimitiveType(EPrimitiveType type) { 
+        if (!CheckType(ETypeKind::Primitive)) { 
+            return false; 
+        } 
+ 
+        auto expectedType = EPrimitiveType(GetType().type_id()); 
+        if (expectedType != type) { 
+            FatalError(TStringBuilder() << "Primitive type mismatch, expected: " << expectedType 
+                << ", actual: " << type); 
+            return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
     bool CheckDecimalType() {
         if (!CheckType(ETypeKind::Decimal)) {
             return false;
@@ -2379,241 +2379,241 @@ private:
         return true;
     }
 
-    void CheckContainerKind(ETypeKind kind) {
-        if (Path_.size() < 2) {
-            FatalError(TStringBuilder() << "No opened container");
-        }
-
+    void CheckContainerKind(ETypeKind kind) { 
+        if (Path_.size() < 2) { 
+            FatalError(TStringBuilder() << "No opened container"); 
+        } 
+ 
         auto actualKind = GetKind(GetType(1));
-        if (actualKind != kind) {
-            FatalError(TStringBuilder() << "Container type mismatch, expected: " << kind
-                << ", actual: " << actualKind);
-        }
-    }
-
-    void NestEmptyOptional() {
-        ui32 optLevel = PathTop().OptLevel - 1;
-        for (ui32 i = 0; i < optLevel; ++i) {
-            PushPath(*GetValue().mutable_nested_value());
-        }
-
-        GetValue().set_null_flag_value(::google::protobuf::NULL_VALUE);
-
-        for (ui32 i = 0; i < optLevel; ++i) {
-            PopPath();
-        }
-    }
-
-    TProtoPosition& PathTop() {
-        return Path_.back();
-    }
-
-    void PushPath(Ydb::Value& value) {
-        Path_.emplace_back(value);
-    }
-
-    void PopPath() {
-        Path_.pop_back();
-    }
-
-    void PushStructsPath(const TMembersMap* membersMap) {
-        StructsPath_.emplace_back(membersMap);
-    }
-
-    void PopStructsPath() {
-        StructsPath_.pop_back();
-    }
-
-    TStructPosition& StructsPathTop() {
-        return StructsPath_.back();
-    }
-
-    TMembersMap& GetMembersMap(const Ydb::StructType* structType) {
-        auto it = StructsMap_.find(structType);
-        if (it == StructsMap_.end()) {
-            TMembersMap membersMap;
-            for (size_t i = 0; i < (size_t)structType->members_size(); ++i) {
-                membersMap.emplace(std::make_pair(structType->members(i).name(), i));
-            }
-            auto result = StructsMap_.emplace(std::make_pair(structType, std::move(membersMap)));
-            it = result.first;
-        }
-
-        return it->second;
-    }
-
-    void FatalError(const TString& msg) const {
+        if (actualKind != kind) { 
+            FatalError(TStringBuilder() << "Container type mismatch, expected: " << kind 
+                << ", actual: " << actualKind); 
+        } 
+    } 
+ 
+    void NestEmptyOptional() { 
+        ui32 optLevel = PathTop().OptLevel - 1; 
+        for (ui32 i = 0; i < optLevel; ++i) { 
+            PushPath(*GetValue().mutable_nested_value()); 
+        } 
+ 
+        GetValue().set_null_flag_value(::google::protobuf::NULL_VALUE); 
+ 
+        for (ui32 i = 0; i < optLevel; ++i) { 
+            PopPath(); 
+        } 
+    } 
+ 
+    TProtoPosition& PathTop() { 
+        return Path_.back(); 
+    } 
+ 
+    void PushPath(Ydb::Value& value) { 
+        Path_.emplace_back(value); 
+    } 
+ 
+    void PopPath() { 
+        Path_.pop_back(); 
+    } 
+ 
+    void PushStructsPath(const TMembersMap* membersMap) { 
+        StructsPath_.emplace_back(membersMap); 
+    } 
+ 
+    void PopStructsPath() { 
+        StructsPath_.pop_back(); 
+    } 
+ 
+    TStructPosition& StructsPathTop() { 
+        return StructsPath_.back(); 
+    } 
+ 
+    TMembersMap& GetMembersMap(const Ydb::StructType* structType) { 
+        auto it = StructsMap_.find(structType); 
+        if (it == StructsMap_.end()) { 
+            TMembersMap membersMap; 
+            for (size_t i = 0; i < (size_t)structType->members_size(); ++i) { 
+                membersMap.emplace(std::make_pair(structType->members(i).name(), i)); 
+            } 
+            auto result = StructsMap_.emplace(std::make_pair(structType, std::move(membersMap))); 
+            it = result.first; 
+        } 
+ 
+        return it->second; 
+    } 
+ 
+    void FatalError(const TString& msg) const { 
         ThrowFatalError(TStringBuilder() << "TValueBuilder: " << msg);
-    }
-
-private:
-
-    //TTypeBuilder TypeBuilder_;
-    TTypeBuilder::TImpl TypeBuilder_;
-    Ydb::Value ProtoValue_;
-    TMap<const Ydb::StructType*, TMembersMap> StructsMap_;
-
-    TStackVec<TProtoPosition, 8> Path_;
-    TStackVec<TStructPosition, 8> StructsPath_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-template<typename TDerived>
-TValueBuilderBase<TDerived>::TValueBuilderBase(TValueBuilderBase&&) = default;
-
-template<typename TDerived>
-TValueBuilderBase<TDerived>::~TValueBuilderBase() = default;
-
-template<typename TDerived>
-TValueBuilderBase<TDerived>::TValueBuilderBase()
+    } 
+ 
+private: 
+ 
+    //TTypeBuilder TypeBuilder_; 
+    TTypeBuilder::TImpl TypeBuilder_; 
+    Ydb::Value ProtoValue_; 
+    TMap<const Ydb::StructType*, TMembersMap> StructsMap_; 
+ 
+    TStackVec<TProtoPosition, 8> Path_; 
+    TStackVec<TStructPosition, 8> StructsPath_; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+template<typename TDerived> 
+TValueBuilderBase<TDerived>::TValueBuilderBase(TValueBuilderBase&&) = default; 
+ 
+template<typename TDerived> 
+TValueBuilderBase<TDerived>::~TValueBuilderBase() = default; 
+ 
+template<typename TDerived> 
+TValueBuilderBase<TDerived>::TValueBuilderBase() 
     : Impl_(new TValueBuilderImpl()) {}
-
-template<typename TDerived>
-TValueBuilderBase<TDerived>::TValueBuilderBase(const TType& type)
+ 
+template<typename TDerived> 
+TValueBuilderBase<TDerived>::TValueBuilderBase(const TType& type) 
     : Impl_(new TValueBuilderImpl(type)) {}
-
-template<typename TDerived>
+ 
+template<typename TDerived> 
 TValueBuilderBase<TDerived>::TValueBuilderBase(Ydb::Type& type, Ydb::Value& value)
     : Impl_(new TValueBuilderImpl(type, value)) {}
-
-template<typename TDerived>
-void TValueBuilderBase<TDerived>::CheckValue() {
-    return Impl_->CheckValue();
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Bool(bool value) {
-    Impl_->Bool(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Int8(i8 value) {
-    Impl_->Int8(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Uint8(ui8 value) {
-    Impl_->Uint8(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Int16(i16 value) {
-    Impl_->Int16(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Uint16(ui16 value) {
-    Impl_->Uint16(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Int32(i32 value) {
-    Impl_->Int32(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Uint32(ui32 value) {
-    Impl_->Uint32(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Int64(i64 value) {
-    Impl_->Int64(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Uint64(ui64 value) {
-    Impl_->Uint64(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Float(float value) {
-    Impl_->Float(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Double(double value) {
-    Impl_->Double(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Date(const TInstant& value) {
-    Impl_->Date(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Datetime(const TInstant& value) {
-    Impl_->Datetime(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Timestamp(const TInstant& value) {
-    Impl_->Timestamp(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Interval(i64 value) {
-    Impl_->Interval(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::TzDate(const TString& value) {
-    Impl_->TzDate(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::TzDatetime(const TString& value) {
-    Impl_->TzDatetime(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::TzTimestamp(const TString& value) {
-    Impl_->TzTimestamp(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::String(const TString& value) {
-    Impl_->String(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Utf8(const TString& value) {
-    Impl_->Utf8(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Yson(const TString& value) {
-    Impl_->Yson(value);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::Json(const TString& value) {
-    Impl_->Json(value);
-    return static_cast<TDerived&>(*this);
-}
-
+ 
+template<typename TDerived> 
+void TValueBuilderBase<TDerived>::CheckValue() { 
+    return Impl_->CheckValue(); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Bool(bool value) { 
+    Impl_->Bool(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Int8(i8 value) { 
+    Impl_->Int8(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Uint8(ui8 value) { 
+    Impl_->Uint8(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Int16(i16 value) { 
+    Impl_->Int16(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Uint16(ui16 value) { 
+    Impl_->Uint16(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Int32(i32 value) { 
+    Impl_->Int32(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Uint32(ui32 value) { 
+    Impl_->Uint32(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Int64(i64 value) { 
+    Impl_->Int64(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Uint64(ui64 value) { 
+    Impl_->Uint64(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Float(float value) { 
+    Impl_->Float(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Double(double value) { 
+    Impl_->Double(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Date(const TInstant& value) { 
+    Impl_->Date(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Datetime(const TInstant& value) { 
+    Impl_->Datetime(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Timestamp(const TInstant& value) { 
+    Impl_->Timestamp(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Interval(i64 value) { 
+    Impl_->Interval(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::TzDate(const TString& value) { 
+    Impl_->TzDate(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::TzDatetime(const TString& value) { 
+    Impl_->TzDatetime(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::TzTimestamp(const TString& value) { 
+    Impl_->TzTimestamp(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::String(const TString& value) { 
+    Impl_->String(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Utf8(const TString& value) { 
+    Impl_->Utf8(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Yson(const TString& value) { 
+    Impl_->Yson(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::Json(const TString& value) { 
+    Impl_->Json(value); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
 template<typename TDerived>
 TDerived& TValueBuilderBase<TDerived>::JsonDocument(const TString& value) {
     Impl_->JsonDocument(value);
@@ -2632,326 +2632,326 @@ TDerived& TValueBuilderBase<TDerived>::Decimal(const TDecimalValue& value) {
     return static_cast<TDerived&>(*this);
 }
 
-#define SET_OPT_VALUE_MAYBE(Name) \
-    if (value) { \
-        Impl_->BeginOptional(); \
-        Impl_->Name(*value); \
-        Impl_->EndOptional(); \
-    } else { \
-        Impl_->EmptyOptional(EPrimitiveType::Name); \
-    } \
-    return static_cast<TDerived&>(*this);
-
-#define SET_OPT_VALUE(Name) \
-    Impl_->BeginOptional(); \
-    Impl_->Name(value); \
-    Impl_->EndOptional(); \
-    return static_cast<TDerived&>(*this);
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalBool(const TMaybe<bool>& value) {
-    SET_OPT_VALUE_MAYBE(Bool);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalInt8(const TMaybe<i8>& value) {
-    SET_OPT_VALUE_MAYBE(Int8);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalUint8(const TMaybe<ui8>& value) {
-    SET_OPT_VALUE_MAYBE(Uint8);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalInt16(const TMaybe<i16>& value) {
-    SET_OPT_VALUE_MAYBE(Int16);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalUint16(const TMaybe<ui16>& value) {
-    SET_OPT_VALUE_MAYBE(Uint16);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalInt32(const TMaybe<i32>& value) {
-    SET_OPT_VALUE_MAYBE(Int32);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalUint32(const TMaybe<ui32>& value) {
-    SET_OPT_VALUE_MAYBE(Uint32);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalInt64(const TMaybe<i64>& value) {
-    SET_OPT_VALUE_MAYBE(Int64);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalUint64(const TMaybe<ui64>& value) {
-    SET_OPT_VALUE_MAYBE(Uint64);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalFloat(const TMaybe<float>& value) {
-    SET_OPT_VALUE_MAYBE(Float);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalDouble(const TMaybe<double>& value) {
-    SET_OPT_VALUE_MAYBE(Double);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalDate(const TMaybe<TInstant>& value) {
-    SET_OPT_VALUE_MAYBE(Date);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalDatetime(const TMaybe<TInstant>& value) {
-    SET_OPT_VALUE_MAYBE(Datetime);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalTimestamp(const TMaybe<TInstant>& value) {
-    SET_OPT_VALUE_MAYBE(Timestamp);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalInterval(const TMaybe<i64>& value) {
-    SET_OPT_VALUE_MAYBE(Interval);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalTzDate(const TMaybe<TString>& value) {
-    SET_OPT_VALUE_MAYBE(TzDate);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalTzDatetime(const TMaybe<TString>& value) {
-    SET_OPT_VALUE_MAYBE(TzDatetime);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalTzTimestamp(const TMaybe<TString>& value) {
-    SET_OPT_VALUE_MAYBE(TzTimestamp);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalString(const TMaybe<TString>& value) {
-    SET_OPT_VALUE_MAYBE(String);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalUtf8(const TMaybe<TString>& value) {
-    SET_OPT_VALUE_MAYBE(Utf8);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalYson(const TMaybe<TString>& value) {
-    SET_OPT_VALUE_MAYBE(Yson);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::OptionalJson(const TMaybe<TString>& value) {
-    SET_OPT_VALUE_MAYBE(Json);
-}
-
+#define SET_OPT_VALUE_MAYBE(Name) \ 
+    if (value) { \ 
+        Impl_->BeginOptional(); \ 
+        Impl_->Name(*value); \ 
+        Impl_->EndOptional(); \ 
+    } else { \ 
+        Impl_->EmptyOptional(EPrimitiveType::Name); \ 
+    } \ 
+    return static_cast<TDerived&>(*this); 
+ 
+#define SET_OPT_VALUE(Name) \ 
+    Impl_->BeginOptional(); \ 
+    Impl_->Name(value); \ 
+    Impl_->EndOptional(); \ 
+    return static_cast<TDerived&>(*this); 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalBool(const TMaybe<bool>& value) { 
+    SET_OPT_VALUE_MAYBE(Bool); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalInt8(const TMaybe<i8>& value) { 
+    SET_OPT_VALUE_MAYBE(Int8); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalUint8(const TMaybe<ui8>& value) { 
+    SET_OPT_VALUE_MAYBE(Uint8); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalInt16(const TMaybe<i16>& value) { 
+    SET_OPT_VALUE_MAYBE(Int16); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalUint16(const TMaybe<ui16>& value) { 
+    SET_OPT_VALUE_MAYBE(Uint16); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalInt32(const TMaybe<i32>& value) { 
+    SET_OPT_VALUE_MAYBE(Int32); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalUint32(const TMaybe<ui32>& value) { 
+    SET_OPT_VALUE_MAYBE(Uint32); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalInt64(const TMaybe<i64>& value) { 
+    SET_OPT_VALUE_MAYBE(Int64); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalUint64(const TMaybe<ui64>& value) { 
+    SET_OPT_VALUE_MAYBE(Uint64); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalFloat(const TMaybe<float>& value) { 
+    SET_OPT_VALUE_MAYBE(Float); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalDouble(const TMaybe<double>& value) { 
+    SET_OPT_VALUE_MAYBE(Double); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalDate(const TMaybe<TInstant>& value) { 
+    SET_OPT_VALUE_MAYBE(Date); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalDatetime(const TMaybe<TInstant>& value) { 
+    SET_OPT_VALUE_MAYBE(Datetime); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalTimestamp(const TMaybe<TInstant>& value) { 
+    SET_OPT_VALUE_MAYBE(Timestamp); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalInterval(const TMaybe<i64>& value) { 
+    SET_OPT_VALUE_MAYBE(Interval); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalTzDate(const TMaybe<TString>& value) { 
+    SET_OPT_VALUE_MAYBE(TzDate); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalTzDatetime(const TMaybe<TString>& value) { 
+    SET_OPT_VALUE_MAYBE(TzDatetime); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalTzTimestamp(const TMaybe<TString>& value) { 
+    SET_OPT_VALUE_MAYBE(TzTimestamp); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalString(const TMaybe<TString>& value) { 
+    SET_OPT_VALUE_MAYBE(String); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalUtf8(const TMaybe<TString>& value) { 
+    SET_OPT_VALUE_MAYBE(Utf8); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalYson(const TMaybe<TString>& value) { 
+    SET_OPT_VALUE_MAYBE(Yson); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::OptionalJson(const TMaybe<TString>& value) { 
+    SET_OPT_VALUE_MAYBE(Json); 
+} 
+ 
 template<typename TDerived>
 TDerived& TValueBuilderBase<TDerived>::OptionalJsonDocument(const TMaybe<TString>& value) {
     SET_OPT_VALUE_MAYBE(JsonDocument);
 }
-
+ 
 template<typename TDerived>
 TDerived& TValueBuilderBase<TDerived>::OptionalDyNumber(const TMaybe<TString>& value) {
     SET_OPT_VALUE_MAYBE(DyNumber);
 }
 
 
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::BeginOptional() {
-    Impl_->BeginOptional();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EndOptional() {
-    Impl_->EndOptional();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EmptyOptional(const TType& itemType) {
-    Impl_->EmptyOptional(itemType);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::BeginOptional() { 
+    Impl_->BeginOptional(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EndOptional() { 
+    Impl_->EndOptional(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EmptyOptional(const TType& itemType) { 
+    Impl_->EmptyOptional(itemType); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
 TDerived& TValueBuilderBase<TDerived>::EmptyOptional(EPrimitiveType itemType) {
     Impl_->EmptyOptional(itemType);
     return static_cast<TDerived&>(*this);
 }
 
 template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EmptyOptional() {
-    Impl_->EmptyOptional();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::BeginList() {
-    Impl_->BeginList();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EndList() {
-    Impl_->EndList();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::AddListItem() {
-    Impl_->AddListItem();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::AddListItem(const TValue& itemValue) {
-    Impl_->AddListItem(itemValue);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EmptyList(const TType& itemType) {
-    Impl_->EmptyList(itemType);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EmptyList() {
-    Impl_->EmptyList();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::BeginStruct() {
-    Impl_->BeginStruct();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::AddMember(const TString& memberName) {
-    Impl_->AddMember(memberName);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::AddMember(const TString& memberName, const TValue& memberValue) {
-    Impl_->AddMember(memberName, memberValue);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EndStruct() {
-    Impl_->EndStruct();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::BeginTuple() {
-    Impl_->BeginTuple();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::AddElement() {
-    Impl_->AddElement();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::AddElement(const TValue& elementValue) {
-    Impl_->AddElement(elementValue);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EndTuple() {
-    Impl_->EndTuple();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::BeginDict() {
-    Impl_->BeginDict();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::AddDictItem() {
-    Impl_->AddDictItem();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::DictKey() {
-    Impl_->DictKey();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::DictKey(const TValue& keyValue) {
-    Impl_->DictKey(keyValue);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::DictPayload() {
-    Impl_->DictPayload();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::DictPayload(const TValue& payloadValue) {
-    Impl_->DictPayload(payloadValue);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EndDict() {
-    Impl_->EndDict();
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EmptyDict(const TType& keyType, const TType& payloadType) {
-    Impl_->EmptyDict(keyType, payloadType);
-    return static_cast<TDerived&>(*this);
-}
-
-template<typename TDerived>
-TDerived& TValueBuilderBase<TDerived>::EmptyDict() {
-    Impl_->EmptyDict();
-    return static_cast<TDerived&>(*this);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-template class TValueBuilderBase<TValueBuilder>;
-template class TValueBuilderBase<TParamValueBuilder>;
-
-////////////////////////////////////////////////////////////////////////////////
-
-TValueBuilder::TValueBuilder()
-    : TValueBuilderBase() {}
-
-TValueBuilder::TValueBuilder(const TType& type)
-    : TValueBuilderBase(type) {}
-
-TValue TValueBuilder::Build() {
-    return Impl_->BuildValue();
-}
-
-} // namespace NYdb
+TDerived& TValueBuilderBase<TDerived>::EmptyOptional() { 
+    Impl_->EmptyOptional(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::BeginList() { 
+    Impl_->BeginList(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EndList() { 
+    Impl_->EndList(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::AddListItem() { 
+    Impl_->AddListItem(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::AddListItem(const TValue& itemValue) { 
+    Impl_->AddListItem(itemValue); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EmptyList(const TType& itemType) { 
+    Impl_->EmptyList(itemType); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EmptyList() { 
+    Impl_->EmptyList(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::BeginStruct() { 
+    Impl_->BeginStruct(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::AddMember(const TString& memberName) { 
+    Impl_->AddMember(memberName); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::AddMember(const TString& memberName, const TValue& memberValue) { 
+    Impl_->AddMember(memberName, memberValue); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EndStruct() { 
+    Impl_->EndStruct(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::BeginTuple() { 
+    Impl_->BeginTuple(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::AddElement() { 
+    Impl_->AddElement(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::AddElement(const TValue& elementValue) { 
+    Impl_->AddElement(elementValue); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EndTuple() { 
+    Impl_->EndTuple(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::BeginDict() { 
+    Impl_->BeginDict(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::AddDictItem() { 
+    Impl_->AddDictItem(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::DictKey() { 
+    Impl_->DictKey(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::DictKey(const TValue& keyValue) { 
+    Impl_->DictKey(keyValue); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::DictPayload() { 
+    Impl_->DictPayload(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::DictPayload(const TValue& payloadValue) { 
+    Impl_->DictPayload(payloadValue); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EndDict() { 
+    Impl_->EndDict(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EmptyDict(const TType& keyType, const TType& payloadType) { 
+    Impl_->EmptyDict(keyType, payloadType); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+template<typename TDerived> 
+TDerived& TValueBuilderBase<TDerived>::EmptyDict() { 
+    Impl_->EmptyDict(); 
+    return static_cast<TDerived&>(*this); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+template class TValueBuilderBase<TValueBuilder>; 
+template class TValueBuilderBase<TParamValueBuilder>; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TValueBuilder::TValueBuilder() 
+    : TValueBuilderBase() {} 
+ 
+TValueBuilder::TValueBuilder(const TType& type) 
+    : TValueBuilderBase(type) {} 
+ 
+TValue TValueBuilder::Build() { 
+    return Impl_->BuildValue(); 
+} 
+ 
+} // namespace NYdb 
diff --git a/ydb/public/sdk/cpp/client/ydb_value/value.h b/ydb/public/sdk/cpp/client/ydb_value/value.h
index 4a163b9220..edd1046467 100644
--- a/ydb/public/sdk/cpp/client/ydb_value/value.h
+++ b/ydb/public/sdk/cpp/client/ydb_value/value.h
@@ -1,38 +1,38 @@
-#pragma once
-
+#pragma once 
+ 
 #include <util/datetime/base.h>
-#include <util/generic/maybe.h>
-
+#include <util/generic/maybe.h> 
+ 
 #include <memory>
 
-namespace Ydb {
-    class Type;
-    class Value;
-}
-
-namespace NYdb {
-
-class TResultSetParser;
-
-//! Representation of YDB type.
-class TType {
-    friend class TProtoAccessor;
-public:
-    TType(const Ydb::Type& typeProto);
-    TType(Ydb::Type&& typeProto);
-
+namespace Ydb { 
+    class Type; 
+    class Value; 
+} 
+ 
+namespace NYdb { 
+ 
+class TResultSetParser; 
+ 
+//! Representation of YDB type. 
+class TType { 
+    friend class TProtoAccessor; 
+public: 
+    TType(const Ydb::Type& typeProto); 
+    TType(Ydb::Type&& typeProto); 
+ 
     TString ToString() const;
     void Out(IOutputStream& o) const;
 
-private:
-    const Ydb::Type& GetProto() const;
-
-private:
-    class TImpl;
-    std::shared_ptr<TImpl> Impl_;
-};
-
-enum class EPrimitiveType {
+private: 
+    const Ydb::Type& GetProto() const; 
+ 
+private: 
+    class TImpl; 
+    std::shared_ptr<TImpl> Impl_; 
+}; 
+ 
+enum class EPrimitiveType { 
     Bool         = 0x0006,
     Int8         = 0x0007,
     Uint8        = 0x0005,
@@ -58,73 +58,73 @@ enum class EPrimitiveType {
     Uuid         = 0x1203,
     JsonDocument = 0x1204,
     DyNumber     = 0x1302,
-};
-
-struct TDecimalType {
-    ui8 Precision;
-    ui8 Scale;
-
+}; 
+ 
+struct TDecimalType { 
+    ui8 Precision; 
+    ui8 Scale; 
+ 
     TDecimalType(ui8 precision, ui8 scale)
-        : Precision(precision)
-        , Scale(scale) {}
-};
-
-//! Types can be complex, so TTypeParser allows to traverse through this hierarchies.
-class TTypeParser : public TMoveOnly {
-    friend class TValueParser;
-public:
-    enum class ETypeKind {
-        Primitive,
-        Decimal,
-        Optional,
-        List,
-        Tuple,
-        Struct,
-        Dict,
-        Variant,
+        : Precision(precision) 
+        , Scale(scale) {} 
+}; 
+ 
+//! Types can be complex, so TTypeParser allows to traverse through this hierarchies. 
+class TTypeParser : public TMoveOnly { 
+    friend class TValueParser; 
+public: 
+    enum class ETypeKind { 
+        Primitive, 
+        Decimal, 
+        Optional, 
+        List, 
+        Tuple, 
+        Struct, 
+        Dict, 
+        Variant, 
         Void,
         Null,
         EmptyList,
         EmptyDict,
         Tagged
-    };
-
-public:
-    TTypeParser(TTypeParser&&);
-    TTypeParser(const TType& type);
-
-    ~TTypeParser();
-
-    ETypeKind GetKind() const;
-
-    EPrimitiveType GetPrimitive() const;
-    TDecimalType GetDecimal() const;
-
-    // Optional
-    void OpenOptional();
-    void CloseOptional();
-
-    // List
-    void OpenList();
-    void CloseList();
-
-    // Struct
-    void OpenStruct();
-    bool TryNextMember();
-    const TString& GetMemberName();
-    void CloseStruct();
-
-    // Tuple
-    void OpenTuple();
-    bool TryNextElement();
-    void CloseTuple();
-
-    // Dict
-    void OpenDict();
-    void DictKey();
-    void DictPayload();
-    void CloseDict();
-
+    }; 
+ 
+public: 
+    TTypeParser(TTypeParser&&); 
+    TTypeParser(const TType& type); 
+ 
+    ~TTypeParser(); 
+ 
+    ETypeKind GetKind() const; 
+ 
+    EPrimitiveType GetPrimitive() const; 
+    TDecimalType GetDecimal() const; 
+ 
+    // Optional 
+    void OpenOptional(); 
+    void CloseOptional(); 
+ 
+    // List 
+    void OpenList(); 
+    void CloseList(); 
+ 
+    // Struct 
+    void OpenStruct(); 
+    bool TryNextMember(); 
+    const TString& GetMemberName(); 
+    void CloseStruct(); 
+ 
+    // Tuple 
+    void OpenTuple(); 
+    bool TryNextElement(); 
+    void CloseTuple(); 
+ 
+    // Dict 
+    void OpenDict(); 
+    void DictKey(); 
+    void DictPayload(); 
+    void CloseDict(); 
+ 
     // Variant
     void OpenVariant(size_t index);
     void OpenVariant();
@@ -135,66 +135,66 @@ public:
     const TString& GetTag();
     void CloseTagged();
 
-private:
-    class TImpl;
-    std::unique_ptr<TImpl> Impl_;
-};
-
+private: 
+    class TImpl; 
+    std::unique_ptr<TImpl> Impl_; 
+}; 
+ 
 bool TypesEqual(const TType& t1, const TType& t2);
 
-TString FormatType(const TType& type);
-
-//! Used to create arbitrary type.
-//! To create complex type, corresponding scope should be opened by Begin*/End* calls
-//! To create complex repeated type, Add* should be called at least once
-class TTypeBuilder : public TMoveOnly {
-    friend class TValueBuilderImpl;
-public:
-    TTypeBuilder(TTypeBuilder&&);
-    TTypeBuilder();
-
-    ~TTypeBuilder();
-
-    TTypeBuilder& Primitive(const EPrimitiveType& primitiveType);
-    TTypeBuilder& Decimal(const TDecimalType& decimalType);
-
-    // Optional
-    TTypeBuilder& BeginOptional();
-    TTypeBuilder& EndOptional();
-    TTypeBuilder& Optional(const TType& itemType);
-
-    // List
-    TTypeBuilder& BeginList();
-    TTypeBuilder& EndList();
-    TTypeBuilder& List(const TType& itemType);
-
-    // Struct
-    TTypeBuilder& BeginStruct();
-    TTypeBuilder& AddMember(const TString& memberName);
-    TTypeBuilder& AddMember(const TString& memberName, const TType& memberType);
-    TTypeBuilder& EndStruct();
-
-    // Tuple
-    TTypeBuilder& BeginTuple();
-    TTypeBuilder& AddElement();
-    TTypeBuilder& AddElement(const TType& elementType);
-    TTypeBuilder& EndTuple();
-
-    // Dict
-    TTypeBuilder& BeginDict();
-    TTypeBuilder& DictKey();
-    TTypeBuilder& DictKey(const TType& keyType);
-    TTypeBuilder& DictPayload();
-    TTypeBuilder& DictPayload(const TType& payloadType);
-    TTypeBuilder& EndDict();
-
-    TType Build();
-
-private:
-    class TImpl;
-    std::unique_ptr<TImpl> Impl_;
-};
-
+TString FormatType(const TType& type); 
+ 
+//! Used to create arbitrary type. 
+//! To create complex type, corresponding scope should be opened by Begin*/End* calls 
+//! To create complex repeated type, Add* should be called at least once 
+class TTypeBuilder : public TMoveOnly { 
+    friend class TValueBuilderImpl; 
+public: 
+    TTypeBuilder(TTypeBuilder&&); 
+    TTypeBuilder(); 
+ 
+    ~TTypeBuilder(); 
+ 
+    TTypeBuilder& Primitive(const EPrimitiveType& primitiveType); 
+    TTypeBuilder& Decimal(const TDecimalType& decimalType); 
+ 
+    // Optional 
+    TTypeBuilder& BeginOptional(); 
+    TTypeBuilder& EndOptional(); 
+    TTypeBuilder& Optional(const TType& itemType); 
+ 
+    // List 
+    TTypeBuilder& BeginList(); 
+    TTypeBuilder& EndList(); 
+    TTypeBuilder& List(const TType& itemType); 
+ 
+    // Struct 
+    TTypeBuilder& BeginStruct(); 
+    TTypeBuilder& AddMember(const TString& memberName); 
+    TTypeBuilder& AddMember(const TString& memberName, const TType& memberType); 
+    TTypeBuilder& EndStruct(); 
+ 
+    // Tuple 
+    TTypeBuilder& BeginTuple(); 
+    TTypeBuilder& AddElement(); 
+    TTypeBuilder& AddElement(const TType& elementType); 
+    TTypeBuilder& EndTuple(); 
+ 
+    // Dict 
+    TTypeBuilder& BeginDict(); 
+    TTypeBuilder& DictKey(); 
+    TTypeBuilder& DictKey(const TType& keyType); 
+    TTypeBuilder& DictPayload(); 
+    TTypeBuilder& DictPayload(const TType& payloadType); 
+    TTypeBuilder& EndDict(); 
+ 
+    TType Build(); 
+ 
+private: 
+    class TImpl; 
+    std::unique_ptr<TImpl> Impl_; 
+}; 
+ 
 struct TDecimalValue {
     TString ToString() const;
     TDecimalValue(const Ydb::Value& decimalValueProto, const TDecimalType& decimalType);
@@ -205,115 +205,115 @@ struct TDecimalValue {
     i64 Hi_;
 };
 
-//! Representation of YDB value.
-class TValue {
-    friend class TValueParser;
-    friend class TProtoAccessor;
-public:
-    TValue(const TType& type, const Ydb::Value& valueProto);
-    TValue(const TType& type, Ydb::Value&& valueProto);
-
-    const TType& GetType() const;
-
-private:
-    const Ydb::Value& GetProto() const;
-
-private:
-    class TImpl;
-    std::shared_ptr<TImpl> Impl_;
-};
-
-class TValueParser : public TMoveOnly {
-    friend class TResultSetParser;
-public:
-    TValueParser(TValueParser&&);
-    TValueParser(const TValue& value);
-
-    ~TValueParser();
-
-    TTypeParser::ETypeKind GetKind() const;
-    EPrimitiveType GetPrimitiveType() const;
-
-    bool GetBool() const;
-    i8 GetInt8() const;
-    ui8 GetUint8() const;
-    i16 GetInt16() const;
-    ui16 GetUint16() const;
-    i32 GetInt32() const;
-    ui32 GetUint32() const;
-    i64 GetInt64() const;
-    ui64 GetUint64() const;
-    float GetFloat() const;
-    double GetDouble() const;
-    TInstant GetDate() const;
-    TInstant GetDatetime() const;
-    TInstant GetTimestamp() const;
-    i64 GetInterval() const;
-    const TString& GetTzDate() const;
-    const TString& GetTzDatetime() const;
-    const TString& GetTzTimestamp() const;
-    const TString& GetString() const;
-    const TString& GetUtf8() const;
-    const TString& GetYson() const;
-    const TString& GetJson() const;
+//! Representation of YDB value. 
+class TValue { 
+    friend class TValueParser; 
+    friend class TProtoAccessor; 
+public: 
+    TValue(const TType& type, const Ydb::Value& valueProto); 
+    TValue(const TType& type, Ydb::Value&& valueProto); 
+ 
+    const TType& GetType() const; 
+ 
+private: 
+    const Ydb::Value& GetProto() const; 
+ 
+private: 
+    class TImpl; 
+    std::shared_ptr<TImpl> Impl_; 
+}; 
+ 
+class TValueParser : public TMoveOnly { 
+    friend class TResultSetParser; 
+public: 
+    TValueParser(TValueParser&&); 
+    TValueParser(const TValue& value); 
+ 
+    ~TValueParser(); 
+ 
+    TTypeParser::ETypeKind GetKind() const; 
+    EPrimitiveType GetPrimitiveType() const; 
+ 
+    bool GetBool() const; 
+    i8 GetInt8() const; 
+    ui8 GetUint8() const; 
+    i16 GetInt16() const; 
+    ui16 GetUint16() const; 
+    i32 GetInt32() const; 
+    ui32 GetUint32() const; 
+    i64 GetInt64() const; 
+    ui64 GetUint64() const; 
+    float GetFloat() const; 
+    double GetDouble() const; 
+    TInstant GetDate() const; 
+    TInstant GetDatetime() const; 
+    TInstant GetTimestamp() const; 
+    i64 GetInterval() const; 
+    const TString& GetTzDate() const; 
+    const TString& GetTzDatetime() const; 
+    const TString& GetTzTimestamp() const; 
+    const TString& GetString() const; 
+    const TString& GetUtf8() const; 
+    const TString& GetYson() const; 
+    const TString& GetJson() const; 
     TDecimalValue GetDecimal() const;
     const TString& GetJsonDocument() const;
     const TString& GetDyNumber() const;
-
-    TMaybe<bool> GetOptionalBool() const;
-    TMaybe<i8> GetOptionalInt8() const;
-    TMaybe<ui8> GetOptionalUint8() const;
-    TMaybe<i16> GetOptionalInt16() const;
-    TMaybe<ui16> GetOptionalUint16() const;
-    TMaybe<i32> GetOptionalInt32() const;
-    TMaybe<ui32> GetOptionalUint32() const;
-    TMaybe<i64> GetOptionalInt64() const;
-    TMaybe<ui64> GetOptionalUint64() const;
-    TMaybe<float> GetOptionalFloat() const;
-    TMaybe<double> GetOptionalDouble() const;
-    TMaybe<TInstant> GetOptionalDate() const;
-    TMaybe<TInstant> GetOptionalDatetime() const;
-    TMaybe<TInstant> GetOptionalTimestamp() const;
-    TMaybe<i64> GetOptionalInterval() const;
-    TMaybe<TString> GetOptionalTzDate() const;
-    TMaybe<TString> GetOptionalTzDatetime() const;
-    TMaybe<TString> GetOptionalTzTimestamp() const;
-    TMaybe<TString> GetOptionalString() const;
-    TMaybe<TString> GetOptionalUtf8() const;
-    TMaybe<TString> GetOptionalYson() const;
-    TMaybe<TString> GetOptionalJson() const;
+ 
+    TMaybe<bool> GetOptionalBool() const; 
+    TMaybe<i8> GetOptionalInt8() const; 
+    TMaybe<ui8> GetOptionalUint8() const; 
+    TMaybe<i16> GetOptionalInt16() const; 
+    TMaybe<ui16> GetOptionalUint16() const; 
+    TMaybe<i32> GetOptionalInt32() const; 
+    TMaybe<ui32> GetOptionalUint32() const; 
+    TMaybe<i64> GetOptionalInt64() const; 
+    TMaybe<ui64> GetOptionalUint64() const; 
+    TMaybe<float> GetOptionalFloat() const; 
+    TMaybe<double> GetOptionalDouble() const; 
+    TMaybe<TInstant> GetOptionalDate() const; 
+    TMaybe<TInstant> GetOptionalDatetime() const; 
+    TMaybe<TInstant> GetOptionalTimestamp() const; 
+    TMaybe<i64> GetOptionalInterval() const; 
+    TMaybe<TString> GetOptionalTzDate() const; 
+    TMaybe<TString> GetOptionalTzDatetime() const; 
+    TMaybe<TString> GetOptionalTzTimestamp() const; 
+    TMaybe<TString> GetOptionalString() const; 
+    TMaybe<TString> GetOptionalUtf8() const; 
+    TMaybe<TString> GetOptionalYson() const; 
+    TMaybe<TString> GetOptionalJson() const; 
     TMaybe<TDecimalValue> GetOptionalDecimal() const;
     TMaybe<TString> GetOptionalJsonDocument() const;
     TMaybe<TString> GetOptionalDyNumber() const;
-
-    // Optional
-    void OpenOptional();
-    bool IsNull() const;
-    void CloseOptional();
-
-    // List
-    void OpenList();
-    void CloseList();
-    bool TryNextListItem();
-
-    // Struct
-    void OpenStruct();
-    bool TryNextMember();
-    const TString& GetMemberName() const;
-    void CloseStruct();
-
-    // Tuple
-    void OpenTuple();
-    bool TryNextElement();
-    void CloseTuple();
-
-    // Dict
-    void OpenDict();
-    bool TryNextDictItem();
-    void DictKey();
-    void DictPayload();
-    void CloseDict();
-
+ 
+    // Optional 
+    void OpenOptional(); 
+    bool IsNull() const; 
+    void CloseOptional(); 
+ 
+    // List 
+    void OpenList(); 
+    void CloseList(); 
+    bool TryNextListItem(); 
+ 
+    // Struct 
+    void OpenStruct(); 
+    bool TryNextMember(); 
+    const TString& GetMemberName() const; 
+    void CloseStruct(); 
+ 
+    // Tuple 
+    void OpenTuple(); 
+    bool TryNextElement(); 
+    void CloseTuple(); 
+ 
+    // Dict 
+    void OpenDict(); 
+    bool TryNextDictItem(); 
+    void DictKey(); 
+    void DictPayload(); 
+    void CloseDict(); 
+ 
     // Variant
     void OpenVariant();
     void CloseVariant();
@@ -323,136 +323,136 @@ public:
     const TString& GetTag() const;
     void CloseTagged();
 
-private:
-    TValueParser(const TType& type);
-    void Reset(const Ydb::Value& value);
-
-    class TImpl;
-    std::unique_ptr<TImpl> Impl_;
-};
-
-class TValueBuilderImpl;
-
-template<typename TDerived>
-class TValueBuilderBase : public TMoveOnly {
-    friend TDerived;
-public:
-    TDerived& Bool(bool value);
-    TDerived& Int8(i8 value);
-    TDerived& Uint8(ui8 value);
-    TDerived& Int16(i16 value);
-    TDerived& Uint16(ui16 value);
-    TDerived& Int32(i32 value);
-    TDerived& Uint32(ui32 value);
-    TDerived& Int64(i64 value);
-    TDerived& Uint64(ui64 value);
-    TDerived& Float(float value);
-    TDerived& Double(double value);
-    TDerived& Date(const TInstant& value);
-    TDerived& Datetime(const TInstant& value);
-    TDerived& Timestamp(const TInstant& value);
-    TDerived& Interval(i64 value);
-    TDerived& TzDate(const TString& value);
-    TDerived& TzDatetime(const TString& value);
-    TDerived& TzTimestamp(const TString& value);
-    TDerived& String(const TString& value);
-    TDerived& Utf8(const TString& value);
-    TDerived& Yson(const TString& value);
-    TDerived& Json(const TString& value);
+private: 
+    TValueParser(const TType& type); 
+    void Reset(const Ydb::Value& value); 
+ 
+    class TImpl; 
+    std::unique_ptr<TImpl> Impl_; 
+}; 
+ 
+class TValueBuilderImpl; 
+ 
+template<typename TDerived> 
+class TValueBuilderBase : public TMoveOnly { 
+    friend TDerived; 
+public: 
+    TDerived& Bool(bool value); 
+    TDerived& Int8(i8 value); 
+    TDerived& Uint8(ui8 value); 
+    TDerived& Int16(i16 value); 
+    TDerived& Uint16(ui16 value); 
+    TDerived& Int32(i32 value); 
+    TDerived& Uint32(ui32 value); 
+    TDerived& Int64(i64 value); 
+    TDerived& Uint64(ui64 value); 
+    TDerived& Float(float value); 
+    TDerived& Double(double value); 
+    TDerived& Date(const TInstant& value); 
+    TDerived& Datetime(const TInstant& value); 
+    TDerived& Timestamp(const TInstant& value); 
+    TDerived& Interval(i64 value); 
+    TDerived& TzDate(const TString& value); 
+    TDerived& TzDatetime(const TString& value); 
+    TDerived& TzTimestamp(const TString& value); 
+    TDerived& String(const TString& value); 
+    TDerived& Utf8(const TString& value); 
+    TDerived& Yson(const TString& value); 
+    TDerived& Json(const TString& value); 
     TDerived& Decimal(const TDecimalValue& value);
     TDerived& JsonDocument(const TString& value);
     TDerived& DyNumber(const TString& value);
-
-    TDerived& OptionalBool(const TMaybe<bool>& value);
-    TDerived& OptionalInt8(const TMaybe<i8>& value);
-    TDerived& OptionalUint8(const TMaybe<ui8>& value);
-    TDerived& OptionalInt16(const TMaybe<i16>& value);
-    TDerived& OptionalUint16(const TMaybe<ui16>& value);
-    TDerived& OptionalInt32(const TMaybe<i32>& value);
-    TDerived& OptionalUint32(const TMaybe<ui32>& value);
-    TDerived& OptionalInt64(const TMaybe<i64>& value);
-    TDerived& OptionalUint64(const TMaybe<ui64>& value);
-    TDerived& OptionalFloat(const TMaybe<float>& value);
-    TDerived& OptionalDouble(const TMaybe<double>& value);
-    TDerived& OptionalDate(const TMaybe<TInstant>& value);
-    TDerived& OptionalDatetime(const TMaybe<TInstant>& value);
-    TDerived& OptionalTimestamp(const TMaybe<TInstant>& value);
-    TDerived& OptionalInterval(const TMaybe<i64>& value);
-    TDerived& OptionalTzDate(const TMaybe<TString>& value);
-    TDerived& OptionalTzDatetime(const TMaybe<TString>& value);
-    TDerived& OptionalTzTimestamp(const TMaybe<TString>& value);
-    TDerived& OptionalString(const TMaybe<TString>& value);
-    TDerived& OptionalUtf8(const TMaybe<TString>& value);
-    TDerived& OptionalYson(const TMaybe<TString>& value);
-    TDerived& OptionalJson(const TMaybe<TString>& value);
+ 
+    TDerived& OptionalBool(const TMaybe<bool>& value); 
+    TDerived& OptionalInt8(const TMaybe<i8>& value); 
+    TDerived& OptionalUint8(const TMaybe<ui8>& value); 
+    TDerived& OptionalInt16(const TMaybe<i16>& value); 
+    TDerived& OptionalUint16(const TMaybe<ui16>& value); 
+    TDerived& OptionalInt32(const TMaybe<i32>& value); 
+    TDerived& OptionalUint32(const TMaybe<ui32>& value); 
+    TDerived& OptionalInt64(const TMaybe<i64>& value); 
+    TDerived& OptionalUint64(const TMaybe<ui64>& value); 
+    TDerived& OptionalFloat(const TMaybe<float>& value); 
+    TDerived& OptionalDouble(const TMaybe<double>& value); 
+    TDerived& OptionalDate(const TMaybe<TInstant>& value); 
+    TDerived& OptionalDatetime(const TMaybe<TInstant>& value); 
+    TDerived& OptionalTimestamp(const TMaybe<TInstant>& value); 
+    TDerived& OptionalInterval(const TMaybe<i64>& value); 
+    TDerived& OptionalTzDate(const TMaybe<TString>& value); 
+    TDerived& OptionalTzDatetime(const TMaybe<TString>& value); 
+    TDerived& OptionalTzTimestamp(const TMaybe<TString>& value); 
+    TDerived& OptionalString(const TMaybe<TString>& value); 
+    TDerived& OptionalUtf8(const TMaybe<TString>& value); 
+    TDerived& OptionalYson(const TMaybe<TString>& value); 
+    TDerived& OptionalJson(const TMaybe<TString>& value); 
     TDerived& OptionalJsonDocument(const TMaybe<TString>& value);
     TDerived& OptionalDyNumber(const TMaybe<TString>& value);
-
-    // Optional
-    TDerived& BeginOptional();
-    TDerived& EndOptional();
-    TDerived& EmptyOptional(const TType& itemType);
+ 
+    // Optional 
+    TDerived& BeginOptional(); 
+    TDerived& EndOptional(); 
+    TDerived& EmptyOptional(const TType& itemType); 
     TDerived& EmptyOptional(EPrimitiveType itemType);
-    TDerived& EmptyOptional();
-
-    // List
-    TDerived& BeginList();
-    TDerived& AddListItem();
-    TDerived& AddListItem(const TValue& itemValue);
-    TDerived& EndList();
-    TDerived& EmptyList(const TType& itemType);
-    TDerived& EmptyList();
-
-    // Struct
-    TDerived& BeginStruct();
-    TDerived& AddMember(const TString& memberName);
-    TDerived& AddMember(const TString& memberName, const TValue& memberValue);
-    TDerived& EndStruct();
-
-    // Tuple
-    TDerived& BeginTuple();
-    TDerived& AddElement();
-    TDerived& AddElement(const TValue& elementValue);
-    TDerived& EndTuple();
-
-    // Dict
-    TDerived& BeginDict();
-    TDerived& AddDictItem();
-    TDerived& DictKey();
-    TDerived& DictKey(const TValue& keyValue);
-    TDerived& DictPayload();
-    TDerived& DictPayload(const TValue& payloadValue);
-    TDerived& EndDict();
-    TDerived& EmptyDict(const TType& keyType, const TType& payloadType);
-    TDerived& EmptyDict();
-
-protected:
-    TValueBuilderBase(TValueBuilderBase&&);
-
-    TValueBuilderBase();
-
-    TValueBuilderBase(const TType& type);
-
+    TDerived& EmptyOptional(); 
+ 
+    // List 
+    TDerived& BeginList(); 
+    TDerived& AddListItem(); 
+    TDerived& AddListItem(const TValue& itemValue); 
+    TDerived& EndList(); 
+    TDerived& EmptyList(const TType& itemType); 
+    TDerived& EmptyList(); 
+ 
+    // Struct 
+    TDerived& BeginStruct(); 
+    TDerived& AddMember(const TString& memberName); 
+    TDerived& AddMember(const TString& memberName, const TValue& memberValue); 
+    TDerived& EndStruct(); 
+ 
+    // Tuple 
+    TDerived& BeginTuple(); 
+    TDerived& AddElement(); 
+    TDerived& AddElement(const TValue& elementValue); 
+    TDerived& EndTuple(); 
+ 
+    // Dict 
+    TDerived& BeginDict(); 
+    TDerived& AddDictItem(); 
+    TDerived& DictKey(); 
+    TDerived& DictKey(const TValue& keyValue); 
+    TDerived& DictPayload(); 
+    TDerived& DictPayload(const TValue& payloadValue); 
+    TDerived& EndDict(); 
+    TDerived& EmptyDict(const TType& keyType, const TType& payloadType); 
+    TDerived& EmptyDict(); 
+ 
+protected: 
+    TValueBuilderBase(TValueBuilderBase&&); 
+ 
+    TValueBuilderBase(); 
+ 
+    TValueBuilderBase(const TType& type); 
+ 
     TValueBuilderBase(Ydb::Type& type, Ydb::Value& value);
-
-    ~TValueBuilderBase();
-
-    void CheckValue();
-
-private:
-    std::unique_ptr<TValueBuilderImpl> Impl_;
-};
-
-class TValueBuilder : public TValueBuilderBase<TValueBuilder> {
-public:
-    TValueBuilder();
-
-    TValueBuilder(const TType& type);
-
-    TValue Build();
-};
-
-} // namespace NYdb
+ 
+    ~TValueBuilderBase(); 
+ 
+    void CheckValue(); 
+ 
+private: 
+    std::unique_ptr<TValueBuilderImpl> Impl_; 
+}; 
+ 
+class TValueBuilder : public TValueBuilderBase<TValueBuilder> { 
+public: 
+    TValueBuilder(); 
+ 
+    TValueBuilder(const TType& type); 
+ 
+    TValue Build(); 
+}; 
+ 
+} // namespace NYdb 
 
 Y_DECLARE_OUT_SPEC(inline, NYdb::TType, o, x) {
     return x.Out(o);
diff --git a/ydb/public/sdk/cpp/client/ydb_value/value_ut.cpp b/ydb/public/sdk/cpp/client/ydb_value/value_ut.cpp
index d7508a5f9b..b326758ce2 100644
--- a/ydb/public/sdk/cpp/client/ydb_value/value_ut.cpp
+++ b/ydb/public/sdk/cpp/client/ydb_value/value_ut.cpp
@@ -3,353 +3,353 @@
 #include <ydb/public/sdk/cpp/client/ydb_value/value.h>
 #include <ydb/public/lib/json_value/ydb_json_value.h>
 #include <ydb/public/lib/yson_value/ydb_yson_value.h>
-
+ 
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/testing/unittest/tests_data.h>
 
 #include <google/protobuf/messagext.h>
-
-namespace NYdb {
-
+ 
+namespace NYdb { 
+ 
 using TExpectedErrorException = yexception;
-
-Y_UNIT_TEST_SUITE(YdbValue) {
-    Y_UNIT_TEST(ParseType1) {
-        auto protoTypeStr = R"(
-            struct_type {
-                members {
-                    name: "Member1"
-                    type {
+ 
+Y_UNIT_TEST_SUITE(YdbValue) { 
+    Y_UNIT_TEST(ParseType1) { 
+        auto protoTypeStr = R"( 
+            struct_type { 
+                members { 
+                    name: "Member1" 
+                    type { 
                         type_id: UINT32
-                    }
-                }
-                members {
-                    name: "Member2"
-                    type {
-                        list_type {
-                            item {
+                    } 
+                } 
+                members { 
+                    name: "Member2" 
+                    type { 
+                        list_type { 
+                            item { 
                                 type_id: STRING
-                            }
-                        }
-                    }
-                }
-                members {
-                    name: "Member3"
-                    type {
-                        tuple_type {
-                            elements {
-                                optional_type {
-                                    item {
+                            } 
+                        } 
+                    } 
+                } 
+                members { 
+                    name: "Member3" 
+                    type { 
+                        tuple_type { 
+                            elements { 
+                                optional_type { 
+                                    item { 
                                         type_id: UTF8
-                                    }
-                                }
-                            }
-                            elements {
-                                decimal_type {
-                                    precision: 8
-                                    scale: 13
-                                }
-                            }
-                            elements {
-                                void_type: NULL_VALUE
-                            }
-                        }
-                    }
-                }
-            }
-        )";
-
-        Ydb::Type protoType;
-        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType);
-
-        UNIT_ASSERT_NO_DIFF(FormatType(protoType),
+                                    } 
+                                } 
+                            } 
+                            elements { 
+                                decimal_type { 
+                                    precision: 8 
+                                    scale: 13 
+                                } 
+                            } 
+                            elements { 
+                                void_type: NULL_VALUE 
+                            } 
+                        } 
+                    } 
+                } 
+            } 
+        )"; 
+ 
+        Ydb::Type protoType; 
+        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(protoType), 
             R"(Struct<'Member1':Uint32,'Member2':List<String>,'Member3':Tuple<Utf8?,Decimal(8,13),Void>>)");
-    }
-
-    Y_UNIT_TEST(ParseType2) {
-        auto protoTypeStr = R"(
-            dict_type {
-                key {
+    } 
+ 
+    Y_UNIT_TEST(ParseType2) { 
+        auto protoTypeStr = R"( 
+            dict_type { 
+                key { 
                     type_id: UINT32
-                }
-                payload {
-                    struct_type {
-                        members {
-                            name: "Member1"
-                            type {
+                } 
+                payload { 
+                    struct_type { 
+                        members { 
+                            name: "Member1" 
+                            type { 
                                 type_id: DATE
-                            }
-                        }
-                    }
-                }
-            }
-        )";
-
-        Ydb::Type protoType;
-        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType);
-
-        UNIT_ASSERT_NO_DIFF(FormatType(protoType),
-            R"(Dict<Uint32,Struct<'Member1':Date>>)");
-    }
-
-    Y_UNIT_TEST(BuildType) {
-        auto type = TTypeBuilder()
-            .BeginStruct()
-            .AddMember("Member1")
-                .BeginList()
-                    .BeginOptional()
-                        .Primitive(EPrimitiveType::Uint32)
-                    .EndOptional()
-                .EndList()
-            .AddMember("Member2")
-                .BeginDict()
-                .DictKey().Primitive(EPrimitiveType::Int64)
-                .DictPayload()
-                    .BeginTuple()
-                    .AddElement()
-                        .Decimal(TDecimalType(8, 13))
-                    .AddElement()
-                        .BeginOptional()
-                            .Primitive(EPrimitiveType::Utf8)
-                        .EndOptional()
-                    .EndTuple()
-                .EndDict()
-            .EndStruct()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(type),
+                            } 
+                        } 
+                    } 
+                } 
+            } 
+        )"; 
+ 
+        Ydb::Type protoType; 
+        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(protoType), 
+            R"(Dict<Uint32,Struct<'Member1':Date>>)"); 
+    } 
+ 
+    Y_UNIT_TEST(BuildType) { 
+        auto type = TTypeBuilder() 
+            .BeginStruct() 
+            .AddMember("Member1") 
+                .BeginList() 
+                    .BeginOptional() 
+                        .Primitive(EPrimitiveType::Uint32) 
+                    .EndOptional() 
+                .EndList() 
+            .AddMember("Member2") 
+                .BeginDict() 
+                .DictKey().Primitive(EPrimitiveType::Int64) 
+                .DictPayload() 
+                    .BeginTuple() 
+                    .AddElement() 
+                        .Decimal(TDecimalType(8, 13)) 
+                    .AddElement() 
+                        .BeginOptional() 
+                            .Primitive(EPrimitiveType::Utf8) 
+                        .EndOptional() 
+                    .EndTuple() 
+                .EndDict() 
+            .EndStruct() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(type), 
             R"(Struct<'Member1':List<Uint32?>,'Member2':Dict<Int64,Tuple<Decimal(8,13),Utf8?>>>)");
-    }
-
-    Y_UNIT_TEST(BuildTypeReuse) {
-        auto intType = TTypeBuilder()
-            .Primitive(EPrimitiveType::Int32)
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(intType),
-            R"(Int32)");
-
-        auto optIntType = TTypeBuilder()
-            .Optional(intType)
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(optIntType),
-            R"(Int32?)");
-
-        auto structType = TTypeBuilder()
-            .BeginStruct()
-            .AddMember("Member1", intType)
-            .AddMember("Member2")
-                .List(optIntType)
-            .EndStruct()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(structType),
-            R"(Struct<'Member1':Int32,'Member2':List<Int32?>>)");
-
-        auto tupleType = TTypeBuilder()
-            .BeginTuple()
-            .AddElement(optIntType)
-            .AddElement()
-                .Primitive(EPrimitiveType::String)
-            .EndTuple()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(tupleType),
-            R"(Tuple<Int32?,String>)");
-
-        auto type = TTypeBuilder()
-            .BeginDict()
-            .DictKey(tupleType)
-            .DictPayload(structType)
-            .EndDict()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(type),
-            R"(Dict<Tuple<Int32?,String>,Struct<'Member1':Int32,'Member2':List<Int32?>>>)");
-    }
-
-    Y_UNIT_TEST(BuildTypeIncomplete) {
-        try {
+    } 
+ 
+    Y_UNIT_TEST(BuildTypeReuse) { 
+        auto intType = TTypeBuilder() 
+            .Primitive(EPrimitiveType::Int32) 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(intType), 
+            R"(Int32)"); 
+ 
+        auto optIntType = TTypeBuilder() 
+            .Optional(intType) 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(optIntType), 
+            R"(Int32?)"); 
+ 
+        auto structType = TTypeBuilder() 
+            .BeginStruct() 
+            .AddMember("Member1", intType) 
+            .AddMember("Member2") 
+                .List(optIntType) 
+            .EndStruct() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(structType), 
+            R"(Struct<'Member1':Int32,'Member2':List<Int32?>>)"); 
+ 
+        auto tupleType = TTypeBuilder() 
+            .BeginTuple() 
+            .AddElement(optIntType) 
+            .AddElement() 
+                .Primitive(EPrimitiveType::String) 
+            .EndTuple() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(tupleType), 
+            R"(Tuple<Int32?,String>)"); 
+ 
+        auto type = TTypeBuilder() 
+            .BeginDict() 
+            .DictKey(tupleType) 
+            .DictPayload(structType) 
+            .EndDict() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(type), 
+            R"(Dict<Tuple<Int32?,String>,Struct<'Member1':Int32,'Member2':List<Int32?>>>)"); 
+    } 
+ 
+    Y_UNIT_TEST(BuildTypeIncomplete) { 
+        try { 
             auto value = TTypeBuilder()
-                .BeginTuple()
-                .AddElement()
-                    .Primitive(EPrimitiveType::Uint32)
-                .AddElement()
-                    .Primitive(EPrimitiveType::String)
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(ParseValue1) {
-        auto protoTypeStr = R"(
-            struct_type {
-                members {
-                    name: "Member1"
-                    type {
+                .BeginTuple() 
+                .AddElement() 
+                    .Primitive(EPrimitiveType::Uint32) 
+                .AddElement() 
+                    .Primitive(EPrimitiveType::String) 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(ParseValue1) { 
+        auto protoTypeStr = R"( 
+            struct_type { 
+                members { 
+                    name: "Member1" 
+                    type { 
                         type_id: UINT32
-                    }
-                }
-                members {
-                    name: "Member2"
-                    type {
-                        list_type {
-                            item {
+                    } 
+                } 
+                members { 
+                    name: "Member2" 
+                    type { 
+                        list_type { 
+                            item { 
                                 type_id: STRING
-                            }
-                        }
-                    }
-                }
-                members {
-                    name: "Member3"
-                    type {
-                        tuple_type {
-                            elements {
-                                optional_type {
-                                    item {
+                            } 
+                        } 
+                    } 
+                } 
+                members { 
+                    name: "Member3" 
+                    type { 
+                        tuple_type { 
+                            elements { 
+                                optional_type { 
+                                    item { 
                                         type_id: UTF8
-                                    }
-                                }
-                            }
-                            elements {
+                                    } 
+                                } 
+                            } 
+                            elements { 
                                 type_id: UTF8
-                            }
-                            elements {
-                                void_type: NULL_VALUE
-                            }
-                        }
-                    }
-                }
-            }
-        )";
-
-        auto protoValueStr = R"(
-            items {
-                uint32_value: 137
-            }
-            items {
-                items {
-                    bytes_value: "String1"
-                }
-                items {
-                    bytes_value: "String2"
-                }
-            }
-            items {
-                items {
-                    null_flag_value: NULL_VALUE
-                }
-                items {
-                    text_value: "UtfString"
-                }
-                items {
-                }
-            }
-        )";
-
-        Ydb::Type protoType;
-        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType);
-
-        Ydb::Value protoValue;
-        NProtoBuf::TextFormat::ParseFromString(protoValueStr, &protoValue);
-
-        TValue value(TType(protoType), protoValue);
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([137u;["String1";"String2"];[#;"UtfString";"Void"]])");
-    }
-
-    Y_UNIT_TEST(ParseValue2) {
-        auto protoTypeStr = R"(
-            dict_type {
-                key {
+                            } 
+                            elements { 
+                                void_type: NULL_VALUE 
+                            } 
+                        } 
+                    } 
+                } 
+            } 
+        )"; 
+ 
+        auto protoValueStr = R"( 
+            items { 
+                uint32_value: 137 
+            } 
+            items { 
+                items { 
+                    bytes_value: "String1" 
+                } 
+                items { 
+                    bytes_value: "String2" 
+                } 
+            } 
+            items { 
+                items { 
+                    null_flag_value: NULL_VALUE 
+                } 
+                items { 
+                    text_value: "UtfString" 
+                } 
+                items { 
+                } 
+            } 
+        )"; 
+ 
+        Ydb::Type protoType; 
+        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType); 
+ 
+        Ydb::Value protoValue; 
+        NProtoBuf::TextFormat::ParseFromString(protoValueStr, &protoValue); 
+ 
+        TValue value(TType(protoType), protoValue); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([137u;["String1";"String2"];[#;"UtfString";"Void"]])"); 
+    } 
+ 
+    Y_UNIT_TEST(ParseValue2) { 
+        auto protoTypeStr = R"( 
+            dict_type { 
+                key { 
                     type_id: UINT32
-                }
-                payload {
-                    struct_type {
-                        members {
-                            name: "Member1"
-                            type {
+                } 
+                payload { 
+                    struct_type { 
+                        members { 
+                            name: "Member1" 
+                            type { 
                                 type_id: DATE
-                            }
-                        }
-                    }
-                }
-            }
-        )";
-
-        auto protoValueStr = R"(
-            pairs {
-                key {
-                    uint32_value: 10
-                }
-                payload {
-                    items {
-                        uint32_value: 1000
-                    }
-                }
-            }
-            pairs {
-                key {
-                    uint32_value: 20
-                }
-                payload {
-                    items {
-                        uint32_value: 2000
-                    }
-                }
-            }
-        )";
-
-        Ydb::Type protoType;
-        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType);
-
-        Ydb::Value protoValue;
-        NProtoBuf::TextFormat::ParseFromString(protoValueStr, &protoValue);
-
-        TValue value(TType(protoType), protoValue);
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[10u;[1000u]];[20u;[2000u]]])");
+                            } 
+                        } 
+                    } 
+                } 
+            } 
+        )"; 
+ 
+        auto protoValueStr = R"( 
+            pairs { 
+                key { 
+                    uint32_value: 10 
+                } 
+                payload { 
+                    items { 
+                        uint32_value: 1000 
+                    } 
+                } 
+            } 
+            pairs { 
+                key { 
+                    uint32_value: 20 
+                } 
+                payload { 
+                    items { 
+                        uint32_value: 2000 
+                    } 
+                } 
+            } 
+        )"; 
+ 
+        Ydb::Type protoType; 
+        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType); 
+ 
+        Ydb::Value protoValue; 
+        NProtoBuf::TextFormat::ParseFromString(protoValueStr, &protoValue); 
+ 
+        TValue value(TType(protoType), protoValue); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[10u;[1000u]];[20u;[2000u]]])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([[10,{"Member1":"1972-09-27"}],[20,{"Member1":"1975-06-24"}]])");
-    }
-
-    Y_UNIT_TEST(ParseValueMaybe) {
-        auto protoTypeStr = R"(
-            tuple_type {
-                elements {
-                    optional_type {
-                        item {
+    } 
+ 
+    Y_UNIT_TEST(ParseValueMaybe) { 
+        auto protoTypeStr = R"( 
+            tuple_type { 
+                elements { 
+                    optional_type { 
+                        item { 
                             type_id: UTF8
-                        }
-                    }
-                }
-                elements {
-                    optional_type {
-                        item {
+                        } 
+                    } 
+                } 
+                elements { 
+                    optional_type { 
+                        item { 
                             type_id: INT8
-                        }
-                    }
-                }
-                elements {
-                    optional_type {
-                        item {
+                        } 
+                    } 
+                } 
+                elements { 
+                    optional_type { 
+                        item { 
                             type_id: DOUBLE
-                        }
-                    }
-                }
-                elements {
-                    optional_type {
-                        item {
-                            type_id: UINT64
-                        }
-                    }
-                }
+                        } 
+                    } 
+                } 
+                elements { 
+                    optional_type { 
+                        item { 
+                            type_id: UINT64 
+                        } 
+                    } 
+                } 
                 elements {
                     optional_type {
                         item {
@@ -357,160 +357,160 @@ Y_UNIT_TEST_SUITE(YdbValue) {
                         }
                     }
                 }
-            }
-        )";
-
-        auto protoValueStr = R"(
-            items {
-                text_value: "SomeUtf"
-            }
-            items {
-                int32_value: -5
-            }
-            items {
-                null_flag_value: NULL_VALUE
-            }
-            items {
-                nested_value {
-                    uint64_value: 7
-                }
-            }
+            } 
+        )"; 
+ 
+        auto protoValueStr = R"( 
+            items { 
+                text_value: "SomeUtf" 
+            } 
+            items { 
+                int32_value: -5 
+            } 
+            items { 
+                null_flag_value: NULL_VALUE 
+            } 
+            items { 
+                nested_value { 
+                    uint64_value: 7 
+                } 
+            } 
             items {
                 nested_value {
                     text_value: "12.345"
                 }
             }
-        )";
-
-        Ydb::Type protoType;
-        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType);
-
-        Ydb::Value protoValue;
-        NProtoBuf::TextFormat::ParseFromString(protoValueStr, &protoValue);
-
-        TValue value(TType(protoType), protoValue);
-        TValueParser parser(value);
-
-        parser.OpenTuple();
-        UNIT_ASSERT(parser.TryNextElement());
-        UNIT_ASSERT_VALUES_EQUAL(parser.GetOptionalUtf8(), "SomeUtf");
-        UNIT_ASSERT(parser.TryNextElement());
-        UNIT_ASSERT_VALUES_EQUAL(parser.GetOptionalInt8(), -5);
-        UNIT_ASSERT(parser.TryNextElement());
-        UNIT_ASSERT_VALUES_EQUAL(parser.GetOptionalDouble(), TMaybe<double>());
-        UNIT_ASSERT(parser.TryNextElement());
-        UNIT_ASSERT_VALUES_EQUAL(parser.GetOptionalUint64(), (ui64)7);
+        )"; 
+ 
+        Ydb::Type protoType; 
+        NProtoBuf::TextFormat::ParseFromString(protoTypeStr, &protoType); 
+ 
+        Ydb::Value protoValue; 
+        NProtoBuf::TextFormat::ParseFromString(protoValueStr, &protoValue); 
+ 
+        TValue value(TType(protoType), protoValue); 
+        TValueParser parser(value); 
+ 
+        parser.OpenTuple(); 
+        UNIT_ASSERT(parser.TryNextElement()); 
+        UNIT_ASSERT_VALUES_EQUAL(parser.GetOptionalUtf8(), "SomeUtf"); 
+        UNIT_ASSERT(parser.TryNextElement()); 
+        UNIT_ASSERT_VALUES_EQUAL(parser.GetOptionalInt8(), -5); 
+        UNIT_ASSERT(parser.TryNextElement()); 
+        UNIT_ASSERT_VALUES_EQUAL(parser.GetOptionalDouble(), TMaybe<double>()); 
+        UNIT_ASSERT(parser.TryNextElement()); 
+        UNIT_ASSERT_VALUES_EQUAL(parser.GetOptionalUint64(), (ui64)7); 
         UNIT_ASSERT(parser.TryNextElement());
         UNIT_ASSERT_VALUES_EQUAL(parser.GetOptionalDyNumber(), "12.345");
-        parser.CloseTuple();
-    }
-
-    Y_UNIT_TEST(BuildValueIncomplete) {
-        try {
+        parser.CloseTuple(); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueIncomplete) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginTuple()
-                .AddElement()
-                    .Uint32(10)
-                .AddElement()
-                    .String("test")
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueListItemMismatch1) {
-        try {
+                .BeginTuple() 
+                .AddElement() 
+                    .Uint32(10) 
+                .AddElement() 
+                    .String("test") 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueListItemMismatch1) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .Int32(17)
-                .AddListItem()
-                    .Uint32(19)
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueListItemMismatch2) {
-        auto itemValue = TValueBuilder()
-            .String("Test")
-            .Build();
-
-        try {
+                .BeginList() 
+                .AddListItem() 
+                    .Int32(17) 
+                .AddListItem() 
+                    .Uint32(19) 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueListItemMismatch2) { 
+        auto itemValue = TValueBuilder() 
+            .String("Test") 
+            .Build(); 
+ 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem(itemValue)
-                .AddListItem()
-                    .Int32(17)
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueListItemMismatch3) {
-        auto itemValue = TValueBuilder()
-            .String("Test")
-            .Build();
-
-        try {
+                .BeginList() 
+                .AddListItem(itemValue) 
+                .AddListItem() 
+                    .Int32(17) 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueListItemMismatch3) { 
+        auto itemValue = TValueBuilder() 
+            .String("Test") 
+            .Build(); 
+ 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .Int32(17)
-                .AddListItem(itemValue)
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueListItemMismatch4) {
-        try {
+                .BeginList() 
+                .AddListItem() 
+                    .Int32(17) 
+                .AddListItem(itemValue) 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueListItemMismatch4) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .BeginList()
-                    .AddListItem()
-                        .Uint32(10)
-                    .EndList()
-                .AddListItem()
-                    .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint64).Build())
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-
-    Y_UNIT_TEST(BuildValueEmptyListUnknown) {
-        try {
+                .BeginList() 
+                .AddListItem() 
+                    .BeginList() 
+                    .AddListItem() 
+                        .Uint32(10) 
+                    .EndList() 
+                .AddListItem() 
+                    .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint64).Build()) 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+ 
+    Y_UNIT_TEST(BuildValueEmptyListUnknown) { 
+        try { 
             auto value = TValueBuilder()
-                .EmptyList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
+                .EmptyList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
     Y_UNIT_TEST(BuildDyNumberValue) {
         auto value = TValueBuilder()
             .DyNumber("12.345")
@@ -522,704 +522,704 @@ Y_UNIT_TEST_SUITE(YdbValue) {
             R"("12.345")");
     }
 
-    Y_UNIT_TEST(BuildValueList) {
-        auto intValue = TValueBuilder()
-            .Int32(21)
-            .Build();
-
-        auto value = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .Int32(17)
-            .AddListItem()
-                .Int32(19)
-            .AddListItem(intValue)
-            .EndList()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([17;19;21])");
+    Y_UNIT_TEST(BuildValueList) { 
+        auto intValue = TValueBuilder() 
+            .Int32(21) 
+            .Build(); 
+ 
+        auto value = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .Int32(17) 
+            .AddListItem() 
+                .Int32(19) 
+            .AddListItem(intValue) 
+            .EndList() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([17;19;21])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([17,19,21])");
-    }
-
-    Y_UNIT_TEST(BuildValueListEmpty) {
-        auto value = TValueBuilder()
-            .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build())
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()),
-            R"(List<Uint32>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([])");
+    } 
+ 
+    Y_UNIT_TEST(BuildValueListEmpty) { 
+        auto value = TValueBuilder() 
+            .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build()) 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), 
+            R"(List<Uint32>)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([])");
-    }
-
-    Y_UNIT_TEST(BuildValueListEmpty2) {
-        auto value = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .BeginList()
-                .AddListItem()
-                    .Uint32(10)
-                .EndList()
-            .AddListItem()
-                .EmptyList()
-            .EndList()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[10u];[]])");
+    } 
+ 
+    Y_UNIT_TEST(BuildValueListEmpty2) { 
+        auto value = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .BeginList() 
+                .AddListItem() 
+                    .Uint32(10) 
+                .EndList() 
+            .AddListItem() 
+                .EmptyList() 
+            .EndList() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[10u];[]])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([[10],[]])");
-    }
-
-    Y_UNIT_TEST(BuildValueListEmpty3) {
-        auto value = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build())
-            .AddListItem()
-                .BeginList()
-                .AddListItem()
-                    .Uint32(10)
-                .EndList()
-            .EndList()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[];[10u]])");
+    } 
+ 
+    Y_UNIT_TEST(BuildValueListEmpty3) { 
+        auto value = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build()) 
+            .AddListItem() 
+                .BeginList() 
+                .AddListItem() 
+                    .Uint32(10) 
+                .EndList() 
+            .EndList() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[];[10u]])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([[],[10]])");
-    }
-
-    Y_UNIT_TEST(BuildValueBadCall) {
-        try {
+    } 
+ 
+    Y_UNIT_TEST(BuildValueBadCall) { 
+        try { 
             auto value = TValueBuilder()
-                .AddListItem()
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueOptional) {
-        auto value = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .OptionalInt32(1)
-            .AddListItem()
-                .EmptyOptional()
-            .AddListItem()
-                .BeginOptional()
-                    .Int32(57)
-                .EndOptional()
-            .AddListItem()
-                .EmptyOptional(TTypeBuilder().Primitive(EPrimitiveType::Int32).Build())
-            .EndList()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()),
-            R"(List<Int32?>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[1];#;[57];#])");
+                .AddListItem() 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueOptional) { 
+        auto value = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .OptionalInt32(1) 
+            .AddListItem() 
+                .EmptyOptional() 
+            .AddListItem() 
+                .BeginOptional() 
+                    .Int32(57) 
+                .EndOptional() 
+            .AddListItem() 
+                .EmptyOptional(TTypeBuilder().Primitive(EPrimitiveType::Int32).Build()) 
+            .EndList() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), 
+            R"(List<Int32?>)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[1];#;[57];#])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([1,null,57,null])");
-
-        auto expectedProtoValueStr =
-            "items {\n"
-            "  int32_value: 1\n"
-            "}\n"
-            "items {\n"
-            "  null_flag_value: NULL_VALUE\n"
-            "}\n"
-            "items {\n"
-            "  int32_value: 57\n"
-            "}\n"
-            "items {\n"
-            "  null_flag_value: NULL_VALUE\n"
-            "}\n";
-
-        TString protoValueStr;
-        NProtoBuf::TextFormat::PrintToString(TProtoAccessor::GetProto(value), &protoValueStr);
-        UNIT_ASSERT_NO_DIFF(protoValueStr, expectedProtoValueStr);
-    }
-
-    Y_UNIT_TEST(BuildValueNestedOptional) {
-        auto value = TValueBuilder()
-            .BeginTuple()
-            .AddElement()
-                .BeginOptional()
-                    .BeginOptional()
-                        .Int32(10)
-                    .EndOptional()
-                .EndOptional()
-            .AddElement()
-                .BeginOptional()
-                    .BeginOptional()
-                        .BeginOptional()
-                            .Int64(-1)
-                        .EndOptional()
-                    .EndOptional()
-                .EndOptional()
-            .AddElement()
-                .BeginOptional()
-                    .EmptyOptional(TTypeBuilder().Primitive(EPrimitiveType::String).Build())
-                .EndOptional()
-            .AddElement()
-                .BeginOptional()
-                    .BeginOptional()
-                        .EmptyOptional(EPrimitiveType::Utf8)
-                    .EndOptional()
-                .EndOptional()
-            .EndTuple()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()),
-            R"(Tuple<Int32??,Int64???,String??,Utf8???>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[[10]];[[[-1]]];[#];[[#]]])");
+ 
+        auto expectedProtoValueStr = 
+            "items {\n" 
+            "  int32_value: 1\n" 
+            "}\n" 
+            "items {\n" 
+            "  null_flag_value: NULL_VALUE\n" 
+            "}\n" 
+            "items {\n" 
+            "  int32_value: 57\n" 
+            "}\n" 
+            "items {\n" 
+            "  null_flag_value: NULL_VALUE\n" 
+            "}\n"; 
+ 
+        TString protoValueStr; 
+        NProtoBuf::TextFormat::PrintToString(TProtoAccessor::GetProto(value), &protoValueStr); 
+        UNIT_ASSERT_NO_DIFF(protoValueStr, expectedProtoValueStr); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueNestedOptional) { 
+        auto value = TValueBuilder() 
+            .BeginTuple() 
+            .AddElement() 
+                .BeginOptional() 
+                    .BeginOptional() 
+                        .Int32(10) 
+                    .EndOptional() 
+                .EndOptional() 
+            .AddElement() 
+                .BeginOptional() 
+                    .BeginOptional() 
+                        .BeginOptional() 
+                            .Int64(-1) 
+                        .EndOptional() 
+                    .EndOptional() 
+                .EndOptional() 
+            .AddElement() 
+                .BeginOptional() 
+                    .EmptyOptional(TTypeBuilder().Primitive(EPrimitiveType::String).Build()) 
+                .EndOptional() 
+            .AddElement() 
+                .BeginOptional() 
+                    .BeginOptional() 
+                        .EmptyOptional(EPrimitiveType::Utf8) 
+                    .EndOptional() 
+                .EndOptional() 
+            .EndTuple() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), 
+            R"(Tuple<Int32??,Int64???,String??,Utf8???>)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[[10]];[[[-1]]];[#];[[#]]])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([10,-1,null,null])");
-
-        auto expectedProtoValueStr =
-            "items {\n"
-            "  int32_value: 10\n"
-            "}\n"
-            "items {\n"
-            "  int64_value: -1\n"
-            "}\n"
-            "items {\n"
-            "  nested_value {\n"
-            "    null_flag_value: NULL_VALUE\n"
-            "  }\n"
-            "}\n"
-            "items {\n"
-            "  nested_value {\n"
-            "    nested_value {\n"
-            "      null_flag_value: NULL_VALUE\n"
-            "    }\n"
-            "  }\n"
-            "}\n";
-
-        TString protoValueStr;
-        NProtoBuf::TextFormat::PrintToString(TProtoAccessor::GetProto(value), &protoValueStr);
-        UNIT_ASSERT_NO_DIFF(protoValueStr, expectedProtoValueStr);
-    }
-
-    Y_UNIT_TEST(BuildValueOptionalMismatch1) {
-        try {
+ 
+        auto expectedProtoValueStr = 
+            "items {\n" 
+            "  int32_value: 10\n" 
+            "}\n" 
+            "items {\n" 
+            "  int64_value: -1\n" 
+            "}\n" 
+            "items {\n" 
+            "  nested_value {\n" 
+            "    null_flag_value: NULL_VALUE\n" 
+            "  }\n" 
+            "}\n" 
+            "items {\n" 
+            "  nested_value {\n" 
+            "    nested_value {\n" 
+            "      null_flag_value: NULL_VALUE\n" 
+            "    }\n" 
+            "  }\n" 
+            "}\n"; 
+ 
+        TString protoValueStr; 
+        NProtoBuf::TextFormat::PrintToString(TProtoAccessor::GetProto(value), &protoValueStr); 
+        UNIT_ASSERT_NO_DIFF(protoValueStr, expectedProtoValueStr); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueOptionalMismatch1) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .BeginOptional()
-                        .Uint32(10)
-                    .EndOptional()
-                .AddListItem()
-                    .BeginOptional()
-                        .Int32(20)
-                    .EndOptional()
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueOptionalMismatch2) {
-        try {
+                .BeginList() 
+                .AddListItem() 
+                    .BeginOptional() 
+                        .Uint32(10) 
+                    .EndOptional() 
+                .AddListItem() 
+                    .BeginOptional() 
+                        .Int32(20) 
+                    .EndOptional() 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueOptionalMismatch2) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .BeginOptional()
-                        .Uint32(10)
-                    .EndOptional()
-                .AddListItem()
-                    .BeginOptional()
-                        .Int32(57)
-                    .EndOptional()
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueStruct) {
-        auto value = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .BeginStruct()
-                .AddMember("Id")
-                    .Uint32(1)
-                .AddMember("Name")
-                    .String("Anna")
-                .AddMember("Value")
-                    .Int32(-100)
+                .BeginList() 
+                .AddListItem() 
+                    .BeginOptional() 
+                        .Uint32(10) 
+                    .EndOptional() 
+                .AddListItem() 
+                    .BeginOptional() 
+                        .Int32(57) 
+                    .EndOptional() 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueStruct) { 
+        auto value = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .BeginStruct() 
+                .AddMember("Id") 
+                    .Uint32(1) 
+                .AddMember("Name") 
+                    .String("Anna") 
+                .AddMember("Value") 
+                    .Int32(-100) 
                 .AddMember("Description")
                     .EmptyOptional(EPrimitiveType::Utf8)
-                .EndStruct()
-            .AddListItem()
-                .BeginStruct()
-                .AddMember("Name")
-                    .String("Paul")
-                .AddMember("Value", TValueBuilder().Int32(-200).Build())
-                .AddMember("Id")
-                    .Uint32(2)
+                .EndStruct() 
+            .AddListItem() 
+                .BeginStruct() 
+                .AddMember("Name") 
+                    .String("Paul") 
+                .AddMember("Value", TValueBuilder().Int32(-200).Build()) 
+                .AddMember("Id") 
+                    .Uint32(2) 
                 .AddMember("Description")
                     .OptionalUtf8("Some details")
-                .EndStruct()
-            .EndList()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
+                .EndStruct() 
+            .EndList() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
             R"([[1u;"Anna";-100;#];[2u;"Paul";-200;["Some details"]]])");
         UNIT_ASSERT_NO_DIFF(
             FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([{"Id":1,"Name":"Anna","Value":-100,"Description":null},)"
             R"({"Id":2,"Name":"Paul","Value":-200,"Description":"Some details"}])"
         );
-    }
-
-    Y_UNIT_TEST(BuildValueStructMissingMember) {
-        try {
+    } 
+ 
+    Y_UNIT_TEST(BuildValueStructMissingMember) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                    .AddMember("Id")
-                        .Uint32(1)
-                    .AddMember("Name")
-                        .String("Anna")
-                    .AddMember("Value")
-                        .Int32(-100)
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                    .AddMember("Value")
-                        .Int32(-200)
-                    .AddMember("Id")
-                        .Uint32(2)
-                    .EndStruct()
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueTuplePrimitives) {
-        auto value = TValueBuilder()
-            .BeginTuple()
-            .AddElement().Bool(true)
-            .AddElement().Int8(-1)
-            .AddElement().Uint8(1)
-            .AddElement().Int16(-2)
-            .AddElement().Uint16(2)
-            .AddElement().Int32(-3)
-            .AddElement().Uint32(3)
-            .AddElement().Int64(-4)
-            .AddElement().Uint64(4)
-            .AddElement().Float(-5.5)
-            .AddElement().Double(6.6)
-            .AddElement().Date(TInstant::Days(7))
-            .AddElement().Datetime(TInstant::Seconds(8))
-            .AddElement().Timestamp(TInstant::MicroSeconds(9))
-            .AddElement().Interval(-10)
-            .AddElement().TzDate("2018-02-02,Europe/Moscow")
-            .AddElement().TzDatetime("2018-02-03T15:00:00,Europe/Moscow")
-            .AddElement().TzTimestamp("2018-02-07T15:00:00,Europe/Moscow")
-            .AddElement().String("TestString")
-            .AddElement().Utf8("TestUtf8")
-            .AddElement().Yson("[]")
-            .AddElement().Json("{}")
-            .EndTuple()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()),
-            R"(Tuple<Bool,Int8,Uint8,Int16,Uint16,Int32,Uint32,Int64,Uint64,Float,Double,Date,Datetime,Timestamp,Interval,TzDate,TzDatetime,TzTimestamp,String,Utf8,Yson,Json>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([%true;-1;1u;-2;2u;-3;3u;-4;4u;-5.5;6.6;7u;8u;9u;-10;"2018-02-02,Europe/Moscow";"2018-02-03T15:00:00,Europe/Moscow";"2018-02-07T15:00:00,Europe/Moscow";"TestString";"TestUtf8";"[]";"{}"])");
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Id") 
+                        .Uint32(1) 
+                    .AddMember("Name") 
+                        .String("Anna") 
+                    .AddMember("Value") 
+                        .Int32(-100) 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                    .AddMember("Value") 
+                        .Int32(-200) 
+                    .AddMember("Id") 
+                        .Uint32(2) 
+                    .EndStruct() 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueTuplePrimitives) { 
+        auto value = TValueBuilder() 
+            .BeginTuple() 
+            .AddElement().Bool(true) 
+            .AddElement().Int8(-1) 
+            .AddElement().Uint8(1) 
+            .AddElement().Int16(-2) 
+            .AddElement().Uint16(2) 
+            .AddElement().Int32(-3) 
+            .AddElement().Uint32(3) 
+            .AddElement().Int64(-4) 
+            .AddElement().Uint64(4) 
+            .AddElement().Float(-5.5) 
+            .AddElement().Double(6.6) 
+            .AddElement().Date(TInstant::Days(7)) 
+            .AddElement().Datetime(TInstant::Seconds(8)) 
+            .AddElement().Timestamp(TInstant::MicroSeconds(9)) 
+            .AddElement().Interval(-10) 
+            .AddElement().TzDate("2018-02-02,Europe/Moscow") 
+            .AddElement().TzDatetime("2018-02-03T15:00:00,Europe/Moscow") 
+            .AddElement().TzTimestamp("2018-02-07T15:00:00,Europe/Moscow") 
+            .AddElement().String("TestString") 
+            .AddElement().Utf8("TestUtf8") 
+            .AddElement().Yson("[]") 
+            .AddElement().Json("{}") 
+            .EndTuple() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), 
+            R"(Tuple<Bool,Int8,Uint8,Int16,Uint16,Int32,Uint32,Int64,Uint64,Float,Double,Date,Datetime,Timestamp,Interval,TzDate,TzDatetime,TzTimestamp,String,Utf8,Yson,Json>)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([%true;-1;1u;-2;2u;-3;3u;-4;4u;-5.5;6.6;7u;8u;9u;-10;"2018-02-02,Europe/Moscow";"2018-02-03T15:00:00,Europe/Moscow";"2018-02-07T15:00:00,Europe/Moscow";"TestString";"TestUtf8";"[]";"{}"])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([true,-1,1,-2,2,-3,3,-4,4,-5.5,6.6,"1970-01-08","1970-01-01T00:00:08Z",)"
             R"("1970-01-01T00:00:00.000009Z",-10,"2018-02-02,Europe/Moscow",)"
             R"("2018-02-03T15:00:00,Europe/Moscow","2018-02-07T15:00:00,Europe/Moscow",)"
             R"("TestString","TestUtf8","[]","{}"])");
-    }
-
-    Y_UNIT_TEST(BuildValueTuple1) {
-        auto value = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .BeginTuple()
-                .AddElement()
-                    .Int32(10)
-                .AddElement()
-                    .String("Str1")
-                .EndTuple()
-            .AddListItem()
-                .BeginTuple()
-                .AddElement(TValueBuilder().Int32(20).Build())
-                .AddElement()
-                    .String("Str2")
-                .EndTuple()
-            .EndList()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[10;"Str1"];[20;"Str2"]])");
+    } 
+ 
+    Y_UNIT_TEST(BuildValueTuple1) { 
+        auto value = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .BeginTuple() 
+                .AddElement() 
+                    .Int32(10) 
+                .AddElement() 
+                    .String("Str1") 
+                .EndTuple() 
+            .AddListItem() 
+                .BeginTuple() 
+                .AddElement(TValueBuilder().Int32(20).Build()) 
+                .AddElement() 
+                    .String("Str2") 
+                .EndTuple() 
+            .EndList() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[10;"Str1"];[20;"Str2"]])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([[10,"Str1"],[20,"Str2"]])");
-    }
-
-    Y_UNIT_TEST(BuildValueTuple2) {
-        auto value = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .BeginTuple()
-                .AddElement(TValueBuilder().Int32(-10).Build())
-                .AddElement(TValueBuilder().Utf8("Utf1").Build())
-                .EndTuple()
-            .AddListItem()
-                .BeginTuple()
-                .AddElement()
-                    .Int32(-20)
-                .AddElement()
-                    .Utf8("Utf2")
-                .EndTuple()
-            .EndList()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[-10;"Utf1"];[-20;"Utf2"]])");
+    } 
+ 
+    Y_UNIT_TEST(BuildValueTuple2) { 
+        auto value = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .BeginTuple() 
+                .AddElement(TValueBuilder().Int32(-10).Build()) 
+                .AddElement(TValueBuilder().Utf8("Utf1").Build()) 
+                .EndTuple() 
+            .AddListItem() 
+                .BeginTuple() 
+                .AddElement() 
+                    .Int32(-20) 
+                .AddElement() 
+                    .Utf8("Utf2") 
+                .EndTuple() 
+            .EndList() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[-10;"Utf1"];[-20;"Utf2"]])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([[-10,"Utf1"],[-20,"Utf2"]])");
-    }
-
-    Y_UNIT_TEST(BuildValueTupleElementsMismatch1) {
-        try {
+    } 
+ 
+    Y_UNIT_TEST(BuildValueTupleElementsMismatch1) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .BeginTuple()
-                    .AddElement()
-                        .Int32(10)
-                    .AddElement()
-                        .String("Str1")
-                    .EndTuple()
-                .AddListItem()
-                    .BeginTuple()
-                    .AddElement()
-                        .Int32(-20)
-                    .EndTuple()
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueTupleElementsMismatch2) {
-        try {
+                .BeginList() 
+                .AddListItem() 
+                    .BeginTuple() 
+                    .AddElement() 
+                        .Int32(10) 
+                    .AddElement() 
+                        .String("Str1") 
+                    .EndTuple() 
+                .AddListItem() 
+                    .BeginTuple() 
+                    .AddElement() 
+                        .Int32(-20) 
+                    .EndTuple() 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueTupleElementsMismatch2) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .BeginTuple()
-                    .AddElement()
-                        .Int32(10)
-                    .AddElement()
-                        .String("Str1")
-                    .EndTuple()
-                .AddListItem()
-                    .BeginTuple()
-                    .AddElement()
-                        .Int32(20)
-                    .AddElement()
-                        .String("Str2")
-                    .AddElement()
-                        .Uint64(1)
-                    .EndTuple()
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueTupleTypeMismatch) {
-        try {
+                .BeginList() 
+                .AddListItem() 
+                    .BeginTuple() 
+                    .AddElement() 
+                        .Int32(10) 
+                    .AddElement() 
+                        .String("Str1") 
+                    .EndTuple() 
+                .AddListItem() 
+                    .BeginTuple() 
+                    .AddElement() 
+                        .Int32(20) 
+                    .AddElement() 
+                        .String("Str2") 
+                    .AddElement() 
+                        .Uint64(1) 
+                    .EndTuple() 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueTupleTypeMismatch) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .BeginTuple()
-                    .AddElement()
-                        .Int32(10)
-                    .AddElement()
-                        .String("Str1")
-                    .EndTuple()
-                .AddListItem()
-                    .BeginTuple()
-                    .AddElement()
-                        .Int32(20)
-                    .AddElement()
-                        .Utf8("Utf2")
-                    .EndTuple()
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueDict1) {
-        auto value = TValueBuilder()
-            .BeginDict()
-            .AddDictItem()
-                .DictKey(TValueBuilder().Int32(1).Build())
-                .DictPayload(TValueBuilder().String("Str1").Build())
-            .AddDictItem()
-                .DictKey()
-                    .Int32(2)
-                .DictPayload()
-                    .String("Str2")
-            .EndDict()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[1;"Str1"];[2;"Str2"]])");
+                .BeginList() 
+                .AddListItem() 
+                    .BeginTuple() 
+                    .AddElement() 
+                        .Int32(10) 
+                    .AddElement() 
+                        .String("Str1") 
+                    .EndTuple() 
+                .AddListItem() 
+                    .BeginTuple() 
+                    .AddElement() 
+                        .Int32(20) 
+                    .AddElement() 
+                        .Utf8("Utf2") 
+                    .EndTuple() 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueDict1) { 
+        auto value = TValueBuilder() 
+            .BeginDict() 
+            .AddDictItem() 
+                .DictKey(TValueBuilder().Int32(1).Build()) 
+                .DictPayload(TValueBuilder().String("Str1").Build()) 
+            .AddDictItem() 
+                .DictKey() 
+                    .Int32(2) 
+                .DictPayload() 
+                    .String("Str2") 
+            .EndDict() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[1;"Str1"];[2;"Str2"]])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([[1,"Str1"],[2,"Str2"]])");
-    }
-
-    Y_UNIT_TEST(BuildValueDict2) {
-        auto value = TValueBuilder()
-            .BeginDict()
-            .AddDictItem()
-                .DictKey()
-                    .Int32(1)
-                .DictPayload()
-                    .String("Str1")
-            .AddDictItem()
-                .DictKey(TValueBuilder().Int32(2).Build())
-                .DictPayload(TValueBuilder().String("Str2").Build())
-            .EndDict()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[1;"Str1"];[2;"Str2"]])");
+    } 
+ 
+    Y_UNIT_TEST(BuildValueDict2) { 
+        auto value = TValueBuilder() 
+            .BeginDict() 
+            .AddDictItem() 
+                .DictKey() 
+                    .Int32(1) 
+                .DictPayload() 
+                    .String("Str1") 
+            .AddDictItem() 
+                .DictKey(TValueBuilder().Int32(2).Build()) 
+                .DictPayload(TValueBuilder().String("Str2").Build()) 
+            .EndDict() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[1;"Str1"];[2;"Str2"]])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([[1,"Str1"],[2,"Str2"]])");
-    }
-
-    Y_UNIT_TEST(BuildValueDictTypeMismatch1) {
-        try {
+    } 
+ 
+    Y_UNIT_TEST(BuildValueDictTypeMismatch1) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginDict()
-                .AddDictItem()
-                    .DictKey(TValueBuilder().Int32(1).Build())
-                    .DictPayload(TValueBuilder().String("Str1").Build())
-                .AddDictItem()
-                    .DictKey()
-                        .Int32(2)
-                    .DictPayload()
-                        .Utf8("Utf2")
-                .EndDict()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueDictTypeMismatch2) {
-        try {
+                .BeginDict() 
+                .AddDictItem() 
+                    .DictKey(TValueBuilder().Int32(1).Build()) 
+                    .DictPayload(TValueBuilder().String("Str1").Build()) 
+                .AddDictItem() 
+                    .DictKey() 
+                        .Int32(2) 
+                    .DictPayload() 
+                        .Utf8("Utf2") 
+                .EndDict() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueDictTypeMismatch2) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginDict()
-                .AddDictItem()
-                    .DictKey()
-                        .Int32(1)
-                    .DictPayload()
-                        .String("Str1")
-                .AddDictItem()
-                    .DictKey(TValueBuilder().Uint32(2).Build())
-                    .DictPayload(TValueBuilder().String("Str2").Build())
-                .EndDict()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueDictEmpty1) {
-        auto value = TValueBuilder()
-            .EmptyDict(
-                TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build(),
-                TTypeBuilder().Primitive(EPrimitiveType::String).Build())
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()),
-            R"(Dict<Uint32,String>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([])");
+                .BeginDict() 
+                .AddDictItem() 
+                    .DictKey() 
+                        .Int32(1) 
+                    .DictPayload() 
+                        .String("Str1") 
+                .AddDictItem() 
+                    .DictKey(TValueBuilder().Uint32(2).Build()) 
+                    .DictPayload(TValueBuilder().String("Str2").Build()) 
+                .EndDict() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueDictEmpty1) { 
+        auto value = TValueBuilder() 
+            .EmptyDict( 
+                TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build(), 
+                TTypeBuilder().Primitive(EPrimitiveType::String).Build()) 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), 
+            R"(Dict<Uint32,String>)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([])");
-    }
-
-    Y_UNIT_TEST(BuildValueDictEmpty2) {
-        auto value = TValueBuilder()
-            .BeginList()
-            .AddListItem()
-                .BeginDict()
-                .AddDictItem()
-                    .DictKey()
-                        .Int32(1)
-                    .DictPayload()
-                        .String("Str1")
-                .EndDict()
-            .AddListItem()
-                .EmptyDict()
-            .AddListItem()
-                .EmptyDict(
-                    TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(),
-                    TTypeBuilder().Primitive(EPrimitiveType::String).Build())
-            .EndList()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()),
-            R"(List<Dict<Int32,String>>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
-            R"([[[1;"Str1"]];[];[]])");
+    } 
+ 
+    Y_UNIT_TEST(BuildValueDictEmpty2) { 
+        auto value = TValueBuilder() 
+            .BeginList() 
+            .AddListItem() 
+                .BeginDict() 
+                .AddDictItem() 
+                    .DictKey() 
+                        .Int32(1) 
+                    .DictPayload() 
+                        .String("Str1") 
+                .EndDict() 
+            .AddListItem() 
+                .EmptyDict() 
+            .AddListItem() 
+                .EmptyDict( 
+                    TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(), 
+                    TTypeBuilder().Primitive(EPrimitiveType::String).Build()) 
+            .EndList() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), 
+            R"(List<Dict<Int32,String>>)"); 
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
+            R"([[[1;"Str1"]];[];[]])"); 
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([[[1,"Str1"]],[],[]])");
-    }
-
-    Y_UNIT_TEST(BuildValueDictEmptyNoType) {
-        try {
+    } 
+ 
+    Y_UNIT_TEST(BuildValueDictEmptyNoType) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .EmptyDict()
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueDictEmptyTypeMismatch) {
-        try {
+                .BeginList() 
+                .AddListItem() 
+                    .EmptyDict() 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueDictEmptyTypeMismatch) { 
+        try { 
             auto value = TValueBuilder()
-                .BeginList()
-                .AddListItem()
-                    .EmptyDict(
-                        TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(),
-                        TTypeBuilder().Primitive(EPrimitiveType::String).Build())
-                .AddListItem()
-                    .EmptyDict(
-                        TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(),
-                        TTypeBuilder().Primitive(EPrimitiveType::Utf8).Build())
-                .EndList()
-                .Build();
-        } catch (const TExpectedErrorException& e) {
-            return;
-        }
-
-        UNIT_ASSERT(false);
-    }
-
-    Y_UNIT_TEST(BuildValueWithType) {
-        auto type = TTypeBuilder()
-            .BeginTuple()
-            .AddElement()
-                .BeginStruct()
-                .AddMember("Name")
-                    .Primitive(EPrimitiveType::String)
-                .AddMember("Value")
-                    .Primitive(EPrimitiveType::Uint64)
-                .EndStruct()
-            .AddElement()
-                .BeginOptional()
-                    .Primitive(EPrimitiveType::Utf8)
-                .EndOptional()
-            .AddElement()
-                .BeginList()
-                    .Primitive(EPrimitiveType::Bool)
-                .EndList()
-            .AddElement()
-                .BeginDict()
-                .DictKey()
-                    .Primitive(EPrimitiveType::Int32)
-                .DictPayload()
-                    .BeginOptional()
-                        .Primitive(EPrimitiveType::Uint8)
-                    .EndOptional()
-                .EndDict()
+                .BeginList() 
+                .AddListItem() 
+                    .EmptyDict( 
+                        TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(), 
+                        TTypeBuilder().Primitive(EPrimitiveType::String).Build()) 
+                .AddListItem() 
+                    .EmptyDict( 
+                        TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(), 
+                        TTypeBuilder().Primitive(EPrimitiveType::Utf8).Build()) 
+                .EndList() 
+                .Build(); 
+        } catch (const TExpectedErrorException& e) { 
+            return; 
+        } 
+ 
+        UNIT_ASSERT(false); 
+    } 
+ 
+    Y_UNIT_TEST(BuildValueWithType) { 
+        auto type = TTypeBuilder() 
+            .BeginTuple() 
+            .AddElement() 
+                .BeginStruct() 
+                .AddMember("Name") 
+                    .Primitive(EPrimitiveType::String) 
+                .AddMember("Value") 
+                    .Primitive(EPrimitiveType::Uint64) 
+                .EndStruct() 
+            .AddElement() 
+                .BeginOptional() 
+                    .Primitive(EPrimitiveType::Utf8) 
+                .EndOptional() 
+            .AddElement() 
+                .BeginList() 
+                    .Primitive(EPrimitiveType::Bool) 
+                .EndList() 
+            .AddElement() 
+                .BeginDict() 
+                .DictKey() 
+                    .Primitive(EPrimitiveType::Int32) 
+                .DictPayload() 
+                    .BeginOptional() 
+                        .Primitive(EPrimitiveType::Uint8) 
+                    .EndOptional() 
+                .EndDict() 
             .AddElement()
                 .BeginOptional()
                     .Primitive(EPrimitiveType::DyNumber)
                 .EndOptional()
-            .EndTuple()
-            .Build();
-
-        auto value = TValueBuilder(type)
-            .BeginTuple()
-            .AddElement()
-                .BeginStruct()
-                .AddMember("Value")
-                    .Uint64(1)
-                .AddMember("Name")
-                    .String("Sergey")
-                .EndStruct()
-            .AddElement()
-                .EmptyOptional()
-            .AddElement()
-                .BeginList()
-                .AddListItem()
-                    .Bool(true)
-                .EndList()
-            .AddElement()
-                .BeginDict()
-                .AddDictItem()
-                    .DictKey()
-                        .Int32(10)
-                    .DictPayload()
-                        .EmptyOptional()
-                .EndDict()
+            .EndTuple() 
+            .Build(); 
+ 
+        auto value = TValueBuilder(type) 
+            .BeginTuple() 
+            .AddElement() 
+                .BeginStruct() 
+                .AddMember("Value") 
+                    .Uint64(1) 
+                .AddMember("Name") 
+                    .String("Sergey") 
+                .EndStruct() 
+            .AddElement() 
+                .EmptyOptional() 
+            .AddElement() 
+                .BeginList() 
+                .AddListItem() 
+                    .Bool(true) 
+                .EndList() 
+            .AddElement() 
+                .BeginDict() 
+                .AddDictItem() 
+                    .DictKey() 
+                        .Int32(10) 
+                    .DictPayload() 
+                        .EmptyOptional() 
+                .EndDict() 
             .AddElement()
                 .BeginOptional()
                     .DyNumber("12.345")
                 .EndOptional()
-            .EndTuple()
-            .Build();
-
-        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()),
+            .EndTuple() 
+            .Build(); 
+ 
+        UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), 
             R"(Tuple<Struct<'Name':String,'Value':Uint64>,Utf8?,List<Bool>,Dict<Int32,Uint8?>,DyNumber?>)");
-        UNIT_ASSERT_NO_DIFF(FormatValueYson(value),
+        UNIT_ASSERT_NO_DIFF(FormatValueYson(value), 
             R"([["Sergey";1u];#;[%true];[[10;#]];["12.345"]])");
         UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode),
             R"([{"Name":"Sergey","Value":1},null,[true],[[10,null]],"12.345"])");
-    }
-}
-
-} // namespace NYdb
+    } 
+} 
+ 
+} // namespace NYdb 
diff --git a/ydb/public/sdk/python/ydb/issues.py b/ydb/public/sdk/python/ydb/issues.py
index 727aff1bf7..c92e57a1d8 100644
--- a/ydb/public/sdk/python/ydb/issues.py
+++ b/ydb/public/sdk/python/ydb/issues.py
@@ -31,7 +31,7 @@ class StatusCode(enum.IntEnum):
     CANCELLED = _apis.StatusIds.CANCELLED
     UNDETERMINED = _apis.StatusIds.UNDETERMINED
     UNSUPPORTED = _apis.StatusIds.UNSUPPORTED
-    SESSION_BUSY = _apis.StatusIds.SESSION_BUSY
+    SESSION_BUSY = _apis.StatusIds.SESSION_BUSY 
 
     CONNECTION_LOST = _TRANSPORT_STATUSES_FIRST + 10
     CONNECTION_FAILURE = _TRANSPORT_STATUSES_FIRST + 20
@@ -144,10 +144,10 @@ class Unsupported(Error):
     status = StatusCode.UNSUPPORTED
 
 
-class SessionBusy(Error):
-    status = StatusCode.SESSION_BUSY
-
-
+class SessionBusy(Error): 
+    status = StatusCode.SESSION_BUSY 
+ 
+ 
 class SessionPoolEmpty(Error, queue.Empty):
     status = StatusCode.SESSION_POOL_EMPTY
 
@@ -179,7 +179,7 @@ _server_side_error_map = {
     StatusCode.CANCELLED: Cancelled,
     StatusCode.UNDETERMINED: Undetermined,
     StatusCode.UNSUPPORTED: Unsupported,
-    StatusCode.SESSION_BUSY: SessionBusy,
+    StatusCode.SESSION_BUSY: SessionBusy, 
 }
 
 
diff --git a/ydb/public/sdk/python/ydb/table.py b/ydb/public/sdk/python/ydb/table.py
index c49c4660c7..6ada5af31c 100644
--- a/ydb/public/sdk/python/ydb/table.py
+++ b/ydb/public/sdk/python/ydb/table.py
@@ -801,10 +801,10 @@ class OnlineReadOnly(AbstractTransactionModeBuilder):
 
     def __init__(self):
         self._pb = _apis.ydb_table.OnlineModeSettings()
-        self._pb.allow_inconsistent_reads = False
+        self._pb.allow_inconsistent_reads = False 
         self._name = "online_read_only"
 
-    def with_allow_inconsistent_reads(self):
+    def with_allow_inconsistent_reads(self): 
         self._pb.allow_inconsistent_reads = True
         return self
 
diff --git a/ydb/services/cms/cms_ut.cpp b/ydb/services/cms/cms_ut.cpp
index 7d5234715e..db25b0d0dc 100644
--- a/ydb/services/cms/cms_ut.cpp
+++ b/ydb/services/cms/cms_ut.cpp
@@ -29,7 +29,7 @@
 namespace NKikimr {
 
 using namespace Tests;
-using namespace NYdb;
+using namespace NYdb; 
 
 struct TCmsTestSettings : TKikimrTestSettings {
     static constexpr bool PrecreatePools = false;
@@ -125,7 +125,7 @@ void InitConsoleConfig(TKikimrWithGrpcAndRootSchema &server)
 
 template<typename TRequest>
 static void SetSyncOperation(TRequest& req) {
-    req.mutable_operation_params()->set_operation_mode(Ydb::Operations::OperationParams::SYNC);
+    req.mutable_operation_params()->set_operation_mode(Ydb::Operations::OperationParams::SYNC); 
 }
 
 static void doSimpleTenantsTest(bool sync) {
diff --git a/ydb/services/kesus/grpc_service.cpp b/ydb/services/kesus/grpc_service.cpp
index c5826b6627..ee40edf819 100644
--- a/ydb/services/kesus/grpc_service.cpp
+++ b/ydb/services/kesus/grpc_service.cpp
@@ -656,7 +656,7 @@ void TKesusGRpcService::SetupIncomingRequests(NGrpc::TLoggerPtr logger) {
         &Ydb::Coordination::V1::CoordinationService::AsyncService::Request ## NAME, \
         "Coordination/" #NAME,             \
         logger, \
-        getCounterBlock("coordination", #NAME))->Run();
+        getCounterBlock("coordination", #NAME))->Run(); 
 
     ADD_REQUEST(CreateNode, CreateNodeRequest, CreateNodeResponse, {
         ActorSystem->Send(GRpcRequestProxyId, new NGRpcService::TEvCreateCoordinationNode(reqCtx));
@@ -687,7 +687,7 @@ void TKesusGRpcService::SetupIncomingRequests(NGrpc::TLoggerPtr logger) {
         },
         *ActorSystem,
         "Coordination/Session",
-        getCounterBlock("coordination", "Session", true, true),
+        getCounterBlock("coordination", "Session", true, true), 
         /* TODO: limiter */ nullptr);
 }
 
diff --git a/ydb/services/persqueue_v1/grpc_pq_write_actor.cpp b/ydb/services/persqueue_v1/grpc_pq_write_actor.cpp
index 3038cc82a6..7e0712afa3 100644
--- a/ydb/services/persqueue_v1/grpc_pq_write_actor.cpp
+++ b/ydb/services/persqueue_v1/grpc_pq_write_actor.cpp
@@ -539,7 +539,7 @@ void TWriteSessionActor::DiscoverPartition(const NActors::TActorContext& ctx) {
     parameters["$Topic"] = TopicConverter->GetClientsideName();
     parameters["$SourceId"] = EscapedSourceId;
     ev->Record.MutableRequest()->MutableParameters()->Swap(&parameters);
-    ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
+    ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
     State = ES_WAIT_TABLE_REQUEST_1;
 }
 
@@ -579,14 +579,14 @@ void TWriteSessionActor::Handle(TEvPersQueue::TEvGetPartitionIdForWriteResponse:
 void TWriteSessionActor::Handle(NKqp::TEvKqp::TEvQueryResponse::TPtr &ev, const TActorContext &ctx) {
     auto& record = ev->Get()->Record.GetRef();
 
-    if (record.GetYdbStatus() == Ydb::StatusIds::ABORTED) {
+    if (record.GetYdbStatus() == Ydb::StatusIds::ABORTED) { 
         LOG_INFO_S(ctx, NKikimrServices::PQ_WRITE_PROXY, "session v1 cookie: " << Cookie << " sessionId: " << OwnerCookie << " messageGroupId "
             << SourceId << " escaped " << EscapedSourceId << " discover partition race, retrying");
         DiscoverPartition(ctx);
         return;
     }
 
-    if (record.GetYdbStatus() != Ydb::StatusIds::SUCCESS) {
+    if (record.GetYdbStatus() != Ydb::StatusIds::SUCCESS) { 
         TStringBuilder errorReason;
         errorReason << "internal error in kqp Marker# PQ50 : " <<  record;
         if (State == EState::ES_INITED) {
@@ -1162,7 +1162,7 @@ void TWriteSessionActor::HandleWakeup(const TActorContext& ctx) {
     if (!AppData(ctx)->PQConfig.GetTopicsAreFirstClassCitizen() && !SourceIdUpdateInfly && ctx.Now() - LastSourceIdUpdate > SOURCEID_UPDATE_PERIOD) {
         auto ev = MakeUpdateSourceIdMetadataRequest(ctx);
         SourceIdUpdateInfly = true;
-        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release());
+        ctx.Send(NKqp::MakeKqpProxyID(ctx.SelfID.NodeId()), ev.Release()); 
     }
     if (ctx.Now() >= LogSessionDeadline) {
         LogSession(ctx);
diff --git a/ydb/services/ydb/ut/ya.make b/ydb/services/ydb/ut/ya.make
index b7209faa5f..fcb0221b97 100644
--- a/ydb/services/ydb/ut/ya.make
+++ b/ydb/services/ydb/ut/ya.make
@@ -25,8 +25,8 @@ SRCS(
     ydb_import_ut.cpp
     ydb_ut.cpp
     ydb_s3_internal_ut.cpp
-    ydb_scripting_ut.cpp
-    ydb_table_ut.cpp
+    ydb_scripting_ut.cpp 
+    ydb_table_ut.cpp 
     ydb_table_split_ut.cpp
     ydb_stats_ut.cpp
     ydb_long_tx_ut.cpp
diff --git a/ydb/services/ydb/ya.make b/ydb/services/ydb/ya.make
index a2f41a3e75..c751384cf5 100644
--- a/ydb/services/ydb/ya.make
+++ b/ydb/services/ydb/ya.make
@@ -14,9 +14,9 @@ SRCS(
     ydb_logstore.cpp
     ydb_operation.cpp
     ydb_s3_internal.cpp
-    ydb_scheme.cpp
-    ydb_scripting.cpp
-    ydb_table.cpp
+    ydb_scheme.cpp 
+    ydb_scripting.cpp 
+    ydb_table.cpp 
     ydb_long_tx.cpp
 )
 
diff --git a/ydb/services/ydb/ydb_common_ut.h b/ydb/services/ydb/ydb_common_ut.h
index c067928c78..631c170263 100644
--- a/ydb/services/ydb/ydb_common_ut.h
+++ b/ydb/services/ydb/ydb_common_ut.h
@@ -15,10 +15,10 @@
 #include <functional>
 
 using namespace NKikimr;
-namespace NYdb {
+namespace NYdb { 
 
 using namespace Tests;
-using namespace NYdb;
+using namespace NYdb; 
 
 struct TKikimrTestSettings {
     static constexpr bool SSL = false;
@@ -68,10 +68,10 @@ public:
             ServerSettings->AddStoragePoolType("hdd1");
             ServerSettings->AddStoragePoolType("hdd2");
         }
-        ServerSettings->SetAppConfig(appConfig);
+        ServerSettings->SetAppConfig(appConfig); 
         ServerSettings->AuthConfig = appConfig.GetAuthConfig();
         ServerSettings->FeatureFlags = appConfig.GetFeatureFlags();
-        ServerSettings->SetKqpSettings(kqpSettings);
+        ServerSettings->SetKqpSettings(kqpSettings); 
         ServerSettings->SetEnableAsyncIndexes(true);
         ServerSettings->SetEnableDataColumnForIndexTable(true);
         ServerSettings->SetEnableNotNullColumns(true);
@@ -144,10 +144,10 @@ public:
         return Server_->GetRuntime();
     }
 
-    Tests::TServer& GetServer() {
-        return *Server_;
-    }
-
+    Tests::TServer& GetServer() { 
+        return *Server_; 
+    } 
+ 
     TServerSettings::TPtr ServerSettings;
     Tests::TServer::TPtr Server_;
     THolder<Tests::TTenants> Tenants_;
diff --git a/ydb/services/ydb/ydb_coordination_ut.cpp b/ydb/services/ydb/ydb_coordination_ut.cpp
index 54c973a7e8..c4147db6aa 100644
--- a/ydb/services/ydb/ydb_coordination_ut.cpp
+++ b/ydb/services/ydb/ydb_coordination_ut.cpp
@@ -32,7 +32,7 @@ struct TClientContext {
     TString Location;
     NYdb::TDriver Connection;
     NYdb::NCoordination::TClient Client;
-    NYdb::NScheme::TSchemeClient SchemeClient;
+    NYdb::NScheme::TSchemeClient SchemeClient; 
 
     template <typename Config>
     TClientContext(
@@ -45,12 +45,12 @@ struct TClientContext {
         , SchemeClient(Connection)
     { }
 
-    static TDriverConfig CreateParams(
+    static TDriverConfig CreateParams( 
             const TString& endpoint,
             const TString& token,
             bool secure)
     {
-        TDriverConfig params;
+        TDriverConfig params; 
         params.SetEndpoint(endpoint);
         if (token) {
             params.SetAuthToken(token);
diff --git a/ydb/services/ydb/ydb_dummy.cpp b/ydb/services/ydb/ydb_dummy.cpp
index c628b0b3e4..fad6e23617 100644
--- a/ydb/services/ydb/ydb_dummy.cpp
+++ b/ydb/services/ydb/ydb_dummy.cpp
@@ -15,48 +15,48 @@ namespace NGRpcService {
 using namespace Draft::Dummy;
 
 using TEvInfiniteRequest = TGRpcRequestWrapper<0, InfiniteRequest, InfiniteResponse, true>;
-
+ 
 static void HandlePing(NGrpc::IRequestContextBase* ctx) {
     auto req = static_cast<const PingRequest*>(ctx->GetRequest());
     auto resp = google::protobuf::Arena::CreateMessage<PingResponse>(ctx->GetArena());
     if (req->copy()) {
         resp->set_payload(req->payload());
     }
-    ctx->Reply(resp, Ydb::StatusIds::SUCCESS);
+    ctx->Reply(resp, Ydb::StatusIds::SUCCESS); 
 }
 
-class TInfiniteRpc : public TRpcOperationRequestActor<TInfiniteRpc, TEvInfiniteRequest> {
-    using TBase = TRpcOperationRequestActor<TInfiniteRpc, TEvInfiniteRequest>;
-
-public:
-    TInfiniteRpc(TEvInfiniteRequest* request)
-        : TBase(request) {}
-
-    void Bootstrap(const TActorContext& ctx) {
-        TBase::Bootstrap(ctx);
-
-        Become(&TInfiniteRpc::StateWork);
-    }
-
-    bool HasCancelOperation() {
-        return true;
-    }
-
-    void OnCancelOperation(const TActorContext& ctx) {
-        NYql::TIssues issues;
-        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR,
-            "Operation cancelled."));
-        Reply(Ydb::StatusIds::CANCELLED, issues, ctx);
-    }
-
-private:
-    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-        switch (ev->GetTypeRewrite()) {
-            default: TBase::StateFuncBase(ev, ctx);
-        }
-    }
-};
-
+class TInfiniteRpc : public TRpcOperationRequestActor<TInfiniteRpc, TEvInfiniteRequest> { 
+    using TBase = TRpcOperationRequestActor<TInfiniteRpc, TEvInfiniteRequest>; 
+ 
+public: 
+    TInfiniteRpc(TEvInfiniteRequest* request) 
+        : TBase(request) {} 
+ 
+    void Bootstrap(const TActorContext& ctx) { 
+        TBase::Bootstrap(ctx); 
+ 
+        Become(&TInfiniteRpc::StateWork); 
+    } 
+ 
+    bool HasCancelOperation() { 
+        return true; 
+    } 
+ 
+    void OnCancelOperation(const TActorContext& ctx) { 
+        NYql::TIssues issues; 
+        issues.AddIssue(MakeIssue(NKikimrIssues::TIssuesIds::DEFAULT_ERROR, 
+            "Operation cancelled.")); 
+        Reply(Ydb::StatusIds::CANCELLED, issues, ctx); 
+    } 
+ 
+private: 
+    void StateWork(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        switch (ev->GetTypeRewrite()) { 
+            default: TBase::StateFuncBase(ev, ctx); 
+        } 
+    } 
+}; 
+ 
 class TBiStreamPingRequestRPC : public TActorBootstrapped<TBiStreamPingRequestRPC> {
     using TBase = TActorBootstrapped<TBiStreamPingRequestRPC>;
     using IContext = NGRpcServer::IGRpcStreamingContext<
@@ -153,7 +153,7 @@ void TGRpcYdbDummyService::SetupIncomingRequests(NGrpc::TLoggerPtr logger) {
     ADD_REQUEST(Ping, PingRequest, PingResponse, {
         HandlePing(ctx);
     })
-
+ 
     ADD_REQUEST(Infinite, InfiniteRequest, InfiniteResponse, {
         ActorSystem_->Register(new TInfiniteRpc(new TEvInfiniteRequest(ctx)));
     })
diff --git a/ydb/services/ydb/ydb_experimental.cpp b/ydb/services/ydb/ydb_experimental.cpp
index 1ca0009770..9479796b43 100644
--- a/ydb/services/ydb/ydb_experimental.cpp
+++ b/ydb/services/ydb/ydb_experimental.cpp
@@ -45,9 +45,9 @@ void TGRpcYdbExperimentalService::SetupIncomingRequests(NGrpc::TLoggerPtr logger
         }, &Ydb::Experimental::V1::ExperimentalService::AsyncService::Request ## NAME, \
         #NAME, logger, getCounterBlock("experimental", #NAME))->Run();
 
-    ADD_REQUEST(ExecuteStreamQuery, ExecuteStreamQueryRequest, ExecuteStreamQueryResponse, {
-        ActorSystem_->Send(GRpcRequestProxyId_, new TEvExperimentalStreamQueryRequest(ctx));
-    })
+    ADD_REQUEST(ExecuteStreamQuery, ExecuteStreamQueryRequest, ExecuteStreamQueryResponse, { 
+        ActorSystem_->Send(GRpcRequestProxyId_, new TEvExperimentalStreamQueryRequest(ctx)); 
+    }) 
 #undef ADD_REQUEST
 }
 
diff --git a/ydb/services/ydb/ydb_index_table_ut.cpp b/ydb/services/ydb/ydb_index_table_ut.cpp
index 3c31f43a5a..4f136c868a 100644
--- a/ydb/services/ydb/ydb_index_table_ut.cpp
+++ b/ydb/services/ydb/ydb_index_table_ut.cpp
@@ -7,14 +7,14 @@
 
 #include <ydb/library/yql/public/issue/yql_issue.h>
 
-#include "ydb_common_ut.h"
+#include "ydb_common_ut.h" 
 
 #include <util/thread/factory.h>
 
 #include <ydb/public/api/grpc/ydb_table_v1.grpc.pb.h>
 
-using namespace NYdb;
-using namespace NYdb::NTable;
+using namespace NYdb; 
+using namespace NYdb::NTable; 
 
 void CreateTestTableWithIndex(NYdb::NTable::TTableClient& client) {
     auto sessionResult = client.CreateSession().ExtractValueSync();
diff --git a/ydb/services/ydb/ydb_olapstore_ut.cpp b/ydb/services/ydb/ydb_olapstore_ut.cpp
index 6a61447fe9..519704d689 100644
--- a/ydb/services/ydb/ydb_olapstore_ut.cpp
+++ b/ydb/services/ydb/ydb_olapstore_ut.cpp
@@ -190,8 +190,8 @@ Y_UNIT_TEST_SUITE(YdbOlapStore) {
         UNIT_ASSERT_C(it.IsSuccess(), it.GetIssues().ToString());
         auto result = NKikimr::NKqp::CollectStreamResult(it);
         Cerr << "RESULT:\n" << result.ResultSetYson << "\n---------------------\nSTATS:\n";
-        UNIT_ASSERT(result.QueryStats);
-        PrintQueryStats(Cerr, *result.QueryStats);
+        UNIT_ASSERT(result.QueryStats); 
+        PrintQueryStats(Cerr, *result.QueryStats); 
         Cerr << "\n";
         return result.ResultSetYson;
     }
diff --git a/ydb/services/ydb/ydb_s3_internal_ut.cpp b/ydb/services/ydb/ydb_s3_internal_ut.cpp
index 94053711c2..f6a071aee4 100644
--- a/ydb/services/ydb/ydb_s3_internal_ut.cpp
+++ b/ydb/services/ydb/ydb_s3_internal_ut.cpp
@@ -82,14 +82,14 @@ Y_UNIT_TEST_SUITE(YdbS3Internal) {
 
         {
             UNIT_ASSERT_VALUES_EQUAL(res.GetCommonPrefixes().RowsCount(), 1);
-            TResultSetParser parser(res.GetCommonPrefixes());
+            TResultSetParser parser(res.GetCommonPrefixes()); 
             UNIT_ASSERT(parser.TryNextRow());
             UNIT_ASSERT_VALUES_EQUAL(*parser.ColumnParser("Path").GetOptionalUtf8(), "/home/Music/");
         }
 
         {
             UNIT_ASSERT_VALUES_EQUAL(res.GetContents().RowsCount(), 1);
-            TResultSetParser parser(res.GetContents());
+            TResultSetParser parser(res.GetContents()); 
             UNIT_ASSERT(parser.TryNextRow());
             UNIT_ASSERT_VALUES_EQUAL(*parser.ColumnParser("Name").GetOptionalUtf8(), "bucket50");
             UNIT_ASSERT_VALUES_EQUAL(*parser.ColumnParser("Path").GetOptionalUtf8(), "/home/.bashrc");
diff --git a/ydb/services/ydb/ydb_scheme.cpp b/ydb/services/ydb/ydb_scheme.cpp
index ac339f54ab..c336ac3da6 100644
--- a/ydb/services/ydb/ydb_scheme.cpp
+++ b/ydb/services/ydb/ydb_scheme.cpp
@@ -1,4 +1,4 @@
-#include "ydb_scheme.h"
+#include "ydb_scheme.h" 
 
 #include <ydb/core/grpc_services/grpc_helper.h>
 
@@ -23,11 +23,11 @@ void TGRpcYdbSchemeService::SetGlobalLimiterHandle(NGrpc::TGlobalLimiter* limite
     Limiter_ = limiter;
 }
 
-bool TGRpcYdbSchemeService::IncRequest() {
+bool TGRpcYdbSchemeService::IncRequest() { 
     return Limiter_->Inc();
 }
 
-void TGRpcYdbSchemeService::DecRequest() {
+void TGRpcYdbSchemeService::DecRequest() { 
     Limiter_->Dec();
     Y_ASSERT(Limiter_->GetCurrentInFlight() >= 0);
 }
diff --git a/ydb/services/ydb/ydb_scheme.h b/ydb/services/ydb/ydb_scheme.h
index a510e5f592..bec6d1d0bf 100644
--- a/ydb/services/ydb/ydb_scheme.h
+++ b/ydb/services/ydb/ydb_scheme.h
@@ -7,7 +7,7 @@
 namespace NKikimr {
 namespace NGRpcService {
 
-class TGRpcYdbSchemeService
+class TGRpcYdbSchemeService 
     : public NGrpc::TGrpcServiceBase<Ydb::Scheme::V1::SchemeService>
 {
 public:
diff --git a/ydb/services/ydb/ydb_scripting.cpp b/ydb/services/ydb/ydb_scripting.cpp
index 3596b17fd9..219e7baf64 100644
--- a/ydb/services/ydb/ydb_scripting.cpp
+++ b/ydb/services/ydb/ydb_scripting.cpp
@@ -1,37 +1,37 @@
-#include "ydb_scripting.h"
-
+#include "ydb_scripting.h" 
+ 
 #include <ydb/core/grpc_services/grpc_helper.h>
 #include <ydb/core/grpc_services/grpc_request_proxy.h>
 #include <ydb/core/grpc_services/rpc_calls.h>
 #include <ydb/core/grpc_services/service_yql_scripting.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-TGRpcYdbScriptingService::TGRpcYdbScriptingService(NActors::TActorSystem *system,
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+TGRpcYdbScriptingService::TGRpcYdbScriptingService(NActors::TActorSystem *system, 
     TIntrusivePtr<NMonitoring::TDynamicCounters> counters, NActors::TActorId id)
-    : ActorSystem_(system)
-    , Counters_(counters)
-    , GRpcRequestProxyId_(id) {}
-
+    : ActorSystem_(system) 
+    , Counters_(counters) 
+    , GRpcRequestProxyId_(id) {} 
+ 
 void TGRpcYdbScriptingService::InitService(grpc::ServerCompletionQueue *cq, NGrpc::TLoggerPtr logger) {
-    CQ_ = cq;
+    CQ_ = cq; 
     SetupIncomingRequests(std::move(logger));
-}
-
+} 
+ 
 void TGRpcYdbScriptingService::SetGlobalLimiterHandle(NGrpc::TGlobalLimiter* limiter) {
-    Limiter_ = limiter;
-}
-
-bool TGRpcYdbScriptingService::IncRequest() {
-    return Limiter_->Inc();
-}
-
-void TGRpcYdbScriptingService::DecRequest() {
-    Limiter_->Dec();
-    Y_ASSERT(Limiter_->GetCurrentInFlight() >= 0);
-}
-
+    Limiter_ = limiter; 
+} 
+ 
+bool TGRpcYdbScriptingService::IncRequest() { 
+    return Limiter_->Inc(); 
+} 
+ 
+void TGRpcYdbScriptingService::DecRequest() { 
+    Limiter_->Dec(); 
+    Y_ASSERT(Limiter_->GetCurrentInFlight() >= 0); 
+} 
+ 
 void TGRpcYdbScriptingService::SetupIncomingRequests(NGrpc::TLoggerPtr logger) {
     using Ydb::Scripting::ExecuteYqlRequest;
     using Ydb::Scripting::ExecuteYqlResponse;
@@ -39,24 +39,24 @@ void TGRpcYdbScriptingService::SetupIncomingRequests(NGrpc::TLoggerPtr logger) {
     using Ydb::Scripting::ExplainYqlRequest;
     using Ydb::Scripting::ExplainYqlResponse;
 
-    auto getCounterBlock = CreateCounterCb(Counters_, ActorSystem_);
-
-#ifdef ADD_REQUEST
-#error ADD_REQUEST macro already defined
-#endif
-#define ADD_REQUEST(NAME, IN, OUT, ACTION) \
-    MakeIntrusive<TGRpcRequest<Ydb::Scripting::IN, Ydb::Scripting::OUT, TGRpcYdbScriptingService>>(this, &Service_, CQ_, \
+    auto getCounterBlock = CreateCounterCb(Counters_, ActorSystem_); 
+ 
+#ifdef ADD_REQUEST 
+#error ADD_REQUEST macro already defined 
+#endif 
+#define ADD_REQUEST(NAME, IN, OUT, ACTION) \ 
+    MakeIntrusive<TGRpcRequest<Ydb::Scripting::IN, Ydb::Scripting::OUT, TGRpcYdbScriptingService>>(this, &Service_, CQ_, \ 
         [this](NGrpc::IRequestContextBase *ctx) { \
-            NGRpcService::ReportGrpcReqToMon(*ActorSystem_, ctx->GetPeer()); \
-            ACTION; \
-        }, &Ydb::Scripting::V1::ScriptingService::AsyncService::Request ## NAME, \
+            NGRpcService::ReportGrpcReqToMon(*ActorSystem_, ctx->GetPeer()); \ 
+            ACTION; \ 
+        }, &Ydb::Scripting::V1::ScriptingService::AsyncService::Request ## NAME, \ 
         #NAME, logger, getCounterBlock("scripting", #NAME))->Run();
-
-    ADD_REQUEST(ExecuteYql, ExecuteYqlRequest, ExecuteYqlResponse, {
+ 
+    ADD_REQUEST(ExecuteYql, ExecuteYqlRequest, ExecuteYqlResponse, { 
         ActorSystem_->Send(GRpcRequestProxyId_,
             new TGrpcRequestOperationCall<ExecuteYqlRequest, ExecuteYqlResponse>
                 (ctx, &DoExecuteYqlScript, TRequestAuxSettings{TRateLimiterMode::Ru, nullptr}));
-    })
+    }) 
 
     ADD_REQUEST(StreamExecuteYql, ExecuteYqlRequest, ExecuteYqlPartialResponse, {
         ActorSystem_->Send(GRpcRequestProxyId_,
@@ -69,8 +69,8 @@ void TGRpcYdbScriptingService::SetupIncomingRequests(NGrpc::TLoggerPtr logger) {
             new TGrpcRequestOperationCall<ExplainYqlRequest, ExplainYqlResponse>
                 (ctx, &DoExplainYqlScript, TRequestAuxSettings{TRateLimiterMode::Rps, nullptr}));
     })
-#undef ADD_REQUEST
-}
-
-} // namespace NGRpcService
-} // namespace NKikimr
+#undef ADD_REQUEST 
+} 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/services/ydb/ydb_scripting.h b/ydb/services/ydb/ydb_scripting.h
index 9566cadeee..b19480e780 100644
--- a/ydb/services/ydb/ydb_scripting.h
+++ b/ydb/services/ydb/ydb_scripting.h
@@ -1,34 +1,34 @@
-#pragma once
-
+#pragma once 
+ 
 #include <library/cpp/actors/core/actorsystem.h>
 #include <library/cpp/grpc/server/grpc_server.h>
 #include <ydb/public/api/grpc/ydb_scripting_v1.grpc.pb.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-class TGRpcYdbScriptingService
+ 
+namespace NKikimr { 
+namespace NGRpcService { 
+ 
+class TGRpcYdbScriptingService 
     : public NGrpc::TGrpcServiceBase<Ydb::Scripting::V1::ScriptingService>
-{
-public:
-    TGRpcYdbScriptingService(NActors::TActorSystem* system, TIntrusivePtr<NMonitoring::TDynamicCounters> counters,
+{ 
+public: 
+    TGRpcYdbScriptingService(NActors::TActorSystem* system, TIntrusivePtr<NMonitoring::TDynamicCounters> counters, 
         NActors::TActorId id);
-
+ 
     void InitService(grpc::ServerCompletionQueue* cq, NGrpc::TLoggerPtr logger) override;
     void SetGlobalLimiterHandle(NGrpc::TGlobalLimiter* limiter) override;
-
-    bool IncRequest();
-    void DecRequest();
-private:
+ 
+    bool IncRequest(); 
+    void DecRequest(); 
+private: 
     void SetupIncomingRequests(NGrpc::TLoggerPtr logger);
-
-    NActors::TActorSystem* ActorSystem_;
+ 
+    NActors::TActorSystem* ActorSystem_; 
     grpc::ServerCompletionQueue* CQ_ = nullptr;
-
-    TIntrusivePtr<NMonitoring::TDynamicCounters> Counters_;
+ 
+    TIntrusivePtr<NMonitoring::TDynamicCounters> Counters_; 
     NActors::TActorId GRpcRequestProxyId_;
     NGrpc::TGlobalLimiter* Limiter_ = nullptr;
-};
-
-} // namespace NGRpcService
-} // namespace NKikimr
+}; 
+ 
+} // namespace NGRpcService 
+} // namespace NKikimr 
diff --git a/ydb/services/ydb/ydb_scripting_ut.cpp b/ydb/services/ydb/ydb_scripting_ut.cpp
index 58dc29f3f9..5f0e3facef 100644
--- a/ydb/services/ydb/ydb_scripting_ut.cpp
+++ b/ydb/services/ydb/ydb_scripting_ut.cpp
@@ -1,19 +1,19 @@
-#include "ydb_common_ut.h"
-
+#include "ydb_common_ut.h" 
+ 
 #include <ydb/public/api/grpc/ydb_scripting_v1.grpc.pb.h>
 #include <ydb/public/sdk/cpp/client/ydb_result/result.h>
 #include <ydb/public/sdk/cpp/client/draft/ydb_scripting.h>
-
+ 
 #include <ydb/library/yql/public/issue/yql_issue.h>
 #include <ydb/library/yql/public/issue/yql_issue_message.h>
-
-using namespace NYdb;
-
-Y_UNIT_TEST_SUITE(YdbScripting) {
+ 
+using namespace NYdb; 
+ 
+Y_UNIT_TEST_SUITE(YdbScripting) { 
     void DoBasicTest(bool v1) {
-        TKikimrWithGrpcAndRootSchema server;
-        ui16 grpc = server.GetPort();
-        TString location = TStringBuilder() << "localhost:" << grpc;
+        TKikimrWithGrpcAndRootSchema server; 
+        ui16 grpc = server.GetPort(); 
+        TString location = TStringBuilder() << "localhost:" << grpc; 
         auto connection = NYdb::TDriver(
             TDriverConfig()
                 .SetEndpoint(location));
@@ -40,13 +40,13 @@ Y_UNIT_TEST_SUITE(YdbScripting) {
         )";
 
         auto result = client.ExecuteYqlScript((v1 ? v1Prefix : TString()) + sql).GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
+        result.GetIssues().PrintTo(Cerr); 
         UNIT_ASSERT(result.IsSuccess());
 
-        TVector<TResultSet> resultSets = result.GetResultSets();
+        TVector<TResultSet> resultSets = result.GetResultSets(); 
         UNIT_ASSERT_EQUAL(resultSets.size(), 1);
 
-        TResultSetParser rsParser(resultSets[0]);
+        TResultSetParser rsParser(resultSets[0]); 
         UNIT_ASSERT(rsParser.TryNextRow());
         UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetOptionalUint64(), 1ul);
         UNIT_ASSERT_EQUAL(rsParser.ColumnParser(1).GetOptionalString(), "One");
@@ -63,126 +63,126 @@ Y_UNIT_TEST_SUITE(YdbScripting) {
         DoBasicTest(true);
     }
 
-    Y_UNIT_TEST(MultiResults) {
-        TKikimrWithGrpcAndRootSchema server;
-        ui16 grpc = server.GetPort();
-        TString location = TStringBuilder() << "localhost:" << grpc;
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
-                .SetEndpoint(location));
-        auto client = NYdb::NScripting::TScriptingClient(connection);
-
-        auto result = client.ExecuteYqlScript(R"(
-            PRAGMA kikimr.ScanQuery = "false";
-
-            CREATE TABLE [/Root/TestTable] (
-                Key Uint64,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-            COMMIT;
-
-            REPLACE INTO [/Root/TestTable] (Key, Value) VALUES
-                (1, "One"),
-                (2, "Two");
-            COMMIT;
-
-            SELECT Key, Value FROM [/Root/TestTable];
-            COMMIT;
-
-            REPLACE INTO [/Root/TestTable] (Key, Value) VALUES
-                (1, "OneNew");
-            COMMIT;
-
-            SELECT Value, Key FROM [/Root/TestTable] WHERE Key = 1;
-
-            SELECT * FROM [/Root/TestTable];
-        )").GetValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(result.IsSuccess());
-
-        TVector<TResultSet> resultSets = result.GetResultSets();
-        UNIT_ASSERT_EQUAL(resultSets.size(), 3);
-
-        UNIT_ASSERT_EQUAL(resultSets[0].RowsCount(), 2);
-        TResultSetParser rs0(resultSets[0]);
-        UNIT_ASSERT(rs0.TryNextRow());
-        UNIT_ASSERT_EQUAL(rs0.ColumnParser(0).GetOptionalUint64(), 1ul);
-        UNIT_ASSERT_EQUAL(rs0.ColumnParser(1).GetOptionalString(), "One");
-        UNIT_ASSERT(rs0.TryNextRow());
-        UNIT_ASSERT_EQUAL(rs0.ColumnParser(0).GetOptionalUint64(), 2ul);
-        UNIT_ASSERT_EQUAL(rs0.ColumnParser(1).GetOptionalString(), "Two");
-
-        UNIT_ASSERT_EQUAL(resultSets[1].RowsCount(), 1);
-        TResultSetParser rs1(resultSets[1]);
-        UNIT_ASSERT(rs1.TryNextRow());
-        UNIT_ASSERT_EQUAL(rs1.ColumnParser(0).GetOptionalString(), "OneNew");
-        UNIT_ASSERT_EQUAL(rs1.ColumnParser(1).GetOptionalUint64(), 1ul);
-
-        UNIT_ASSERT_EQUAL(resultSets[2].RowsCount(), 2);
-        TResultSetParser rs2(resultSets[2]);
-        UNIT_ASSERT(rs2.TryNextRow());
-        UNIT_ASSERT_EQUAL(rs2.ColumnParser(0).GetOptionalUint64(), 1ul);
-        UNIT_ASSERT_EQUAL(rs2.ColumnParser(1).GetOptionalString(), "OneNew");
-        UNIT_ASSERT(rs2.TryNextRow());
-        UNIT_ASSERT_EQUAL(rs2.ColumnParser(0).GetOptionalUint64(), 2ul);
-        UNIT_ASSERT_EQUAL(rs2.ColumnParser(1).GetOptionalString(), "Two");
-    }
-
-    Y_UNIT_TEST(Params) {
-        TKikimrWithGrpcAndRootSchema server;
-        ui16 grpc = server.GetPort();
-        TString location = TStringBuilder() << "localhost:" << grpc;
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
-                .SetEndpoint(location));
-        auto client = NYdb::NScripting::TScriptingClient(connection);
-
-        auto params = client.GetParamsBuilder()
-            .AddParam("$rows")
-                .BeginList()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").OptionalUint64(10)
-                        .AddMember("Value").OptionalString("Ten")
-                    .EndStruct()
-                .AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key").OptionalUint64(20)
-                        .AddMember("Value").OptionalString("Twenty")
-                    .EndStruct()
-                .EndList()
-                .Build()
-            .Build();
-
-        auto result = client.ExecuteYqlScript(R"(
-            DECLARE $rows AS
-                'List<Struct<
-                    Key: Uint64?,
-                    Value: String?>>';
-
-            CREATE TABLE [/Root/TestTable] (
-                Key Uint64,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-            COMMIT;
-
-            REPLACE INTO [/Root/TestTable]
-            SELECT * FROM AS_TABLE($rows);
-            COMMIT;
-
-            SELECT * FROM [/Root/TestTable];
-        )", params).GetValueSync();
-
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT(result.IsSuccess());
-        UNIT_ASSERT_EQUAL(result.GetResultSets().size(), 1);
-        UNIT_ASSERT_EQUAL(result.GetResultSets()[0].RowsCount(), 2);
-        TResultSetParser rs0(result.GetResultSets()[0]);
-        UNIT_ASSERT(rs0.TryNextRow());
-        UNIT_ASSERT_EQUAL(rs0.ColumnParser(1).GetOptionalString(), "Ten");
-        UNIT_ASSERT(rs0.TryNextRow());
-        UNIT_ASSERT_EQUAL(rs0.ColumnParser(1).GetOptionalString(), "Twenty");
-    }
-}
+    Y_UNIT_TEST(MultiResults) { 
+        TKikimrWithGrpcAndRootSchema server; 
+        ui16 grpc = server.GetPort(); 
+        TString location = TStringBuilder() << "localhost:" << grpc; 
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
+                .SetEndpoint(location)); 
+        auto client = NYdb::NScripting::TScriptingClient(connection); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            PRAGMA kikimr.ScanQuery = "false"; 
+ 
+            CREATE TABLE [/Root/TestTable] ( 
+                Key Uint64, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+            COMMIT; 
+ 
+            REPLACE INTO [/Root/TestTable] (Key, Value) VALUES 
+                (1, "One"), 
+                (2, "Two"); 
+            COMMIT; 
+ 
+            SELECT Key, Value FROM [/Root/TestTable]; 
+            COMMIT; 
+ 
+            REPLACE INTO [/Root/TestTable] (Key, Value) VALUES 
+                (1, "OneNew"); 
+            COMMIT; 
+ 
+            SELECT Value, Key FROM [/Root/TestTable] WHERE Key = 1; 
+ 
+            SELECT * FROM [/Root/TestTable]; 
+        )").GetValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(result.IsSuccess()); 
+ 
+        TVector<TResultSet> resultSets = result.GetResultSets(); 
+        UNIT_ASSERT_EQUAL(resultSets.size(), 3); 
+ 
+        UNIT_ASSERT_EQUAL(resultSets[0].RowsCount(), 2); 
+        TResultSetParser rs0(resultSets[0]); 
+        UNIT_ASSERT(rs0.TryNextRow()); 
+        UNIT_ASSERT_EQUAL(rs0.ColumnParser(0).GetOptionalUint64(), 1ul); 
+        UNIT_ASSERT_EQUAL(rs0.ColumnParser(1).GetOptionalString(), "One"); 
+        UNIT_ASSERT(rs0.TryNextRow()); 
+        UNIT_ASSERT_EQUAL(rs0.ColumnParser(0).GetOptionalUint64(), 2ul); 
+        UNIT_ASSERT_EQUAL(rs0.ColumnParser(1).GetOptionalString(), "Two"); 
+ 
+        UNIT_ASSERT_EQUAL(resultSets[1].RowsCount(), 1); 
+        TResultSetParser rs1(resultSets[1]); 
+        UNIT_ASSERT(rs1.TryNextRow()); 
+        UNIT_ASSERT_EQUAL(rs1.ColumnParser(0).GetOptionalString(), "OneNew"); 
+        UNIT_ASSERT_EQUAL(rs1.ColumnParser(1).GetOptionalUint64(), 1ul); 
+ 
+        UNIT_ASSERT_EQUAL(resultSets[2].RowsCount(), 2); 
+        TResultSetParser rs2(resultSets[2]); 
+        UNIT_ASSERT(rs2.TryNextRow()); 
+        UNIT_ASSERT_EQUAL(rs2.ColumnParser(0).GetOptionalUint64(), 1ul); 
+        UNIT_ASSERT_EQUAL(rs2.ColumnParser(1).GetOptionalString(), "OneNew"); 
+        UNIT_ASSERT(rs2.TryNextRow()); 
+        UNIT_ASSERT_EQUAL(rs2.ColumnParser(0).GetOptionalUint64(), 2ul); 
+        UNIT_ASSERT_EQUAL(rs2.ColumnParser(1).GetOptionalString(), "Two"); 
+    } 
+ 
+    Y_UNIT_TEST(Params) { 
+        TKikimrWithGrpcAndRootSchema server; 
+        ui16 grpc = server.GetPort(); 
+        TString location = TStringBuilder() << "localhost:" << grpc; 
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
+                .SetEndpoint(location)); 
+        auto client = NYdb::NScripting::TScriptingClient(connection); 
+ 
+        auto params = client.GetParamsBuilder() 
+            .AddParam("$rows") 
+                .BeginList() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").OptionalUint64(10) 
+                        .AddMember("Value").OptionalString("Ten") 
+                    .EndStruct() 
+                .AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key").OptionalUint64(20) 
+                        .AddMember("Value").OptionalString("Twenty") 
+                    .EndStruct() 
+                .EndList() 
+                .Build() 
+            .Build(); 
+ 
+        auto result = client.ExecuteYqlScript(R"( 
+            DECLARE $rows AS 
+                'List<Struct< 
+                    Key: Uint64?, 
+                    Value: String?>>'; 
+ 
+            CREATE TABLE [/Root/TestTable] ( 
+                Key Uint64, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+            COMMIT; 
+ 
+            REPLACE INTO [/Root/TestTable] 
+            SELECT * FROM AS_TABLE($rows); 
+            COMMIT; 
+ 
+            SELECT * FROM [/Root/TestTable]; 
+        )", params).GetValueSync(); 
+ 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT(result.IsSuccess()); 
+        UNIT_ASSERT_EQUAL(result.GetResultSets().size(), 1); 
+        UNIT_ASSERT_EQUAL(result.GetResultSets()[0].RowsCount(), 2); 
+        TResultSetParser rs0(result.GetResultSets()[0]); 
+        UNIT_ASSERT(rs0.TryNextRow()); 
+        UNIT_ASSERT_EQUAL(rs0.ColumnParser(1).GetOptionalString(), "Ten"); 
+        UNIT_ASSERT(rs0.TryNextRow()); 
+        UNIT_ASSERT_EQUAL(rs0.ColumnParser(1).GetOptionalString(), "Twenty"); 
+    } 
+} 
diff --git a/ydb/services/ydb/ydb_stats_ut.cpp b/ydb/services/ydb/ydb_stats_ut.cpp
index b40e22fc42..1a8ee7d1c7 100644
--- a/ydb/services/ydb/ydb_stats_ut.cpp
+++ b/ydb/services/ydb/ydb_stats_ut.cpp
@@ -322,9 +322,9 @@ Y_UNIT_TEST_SUITE(ClientStatsCollector) {
 
             upsertOperation();
 
-            return tx.Commit().Apply([](const auto& future) {
-                return NThreading::MakeFuture<NYdb::TStatus>(future.GetValue());
-            });
+            return tx.Commit().Apply([](const auto& future) { 
+                return NThreading::MakeFuture<NYdb::TStatus>(future.GetValue()); 
+            }); 
         }, retrySelectSettings).GetValueSync().IsSuccess() == false);
 
         counters = extractor.Extract();
diff --git a/ydb/services/ydb/ydb_table.cpp b/ydb/services/ydb/ydb_table.cpp
index 7189614b8e..9259d1ad5a 100644
--- a/ydb/services/ydb/ydb_table.cpp
+++ b/ydb/services/ydb/ydb_table.cpp
@@ -1,4 +1,4 @@
-#include "ydb_table.h"
+#include "ydb_table.h" 
 
 #include <ydb/core/grpc_services/grpc_helper.h>
 #include <ydb/core/grpc_services/grpc_request_proxy.h>
@@ -22,11 +22,11 @@ void TGRpcYdbTableService::SetGlobalLimiterHandle(NGrpc::TGlobalLimiter* limiter
     Limiter_ = limiter;
 }
 
-bool TGRpcYdbTableService::IncRequest() {
+bool TGRpcYdbTableService::IncRequest() { 
     return Limiter_->Inc();
 }
 
-void TGRpcYdbTableService::DecRequest() {
+void TGRpcYdbTableService::DecRequest() { 
     Limiter_->Dec();
     Y_ASSERT(Limiter_->GetCurrentInFlight() >= 0);
 }
@@ -37,7 +37,7 @@ void TGRpcYdbTableService::SetupIncomingRequests(NGrpc::TLoggerPtr logger) {
 #error ADD_REQUEST macro already defined
 #endif
 #define ADD_REQUEST(NAME, IN, OUT, ACTION) \
-    MakeIntrusive<TGRpcRequest<Ydb::Table::IN, Ydb::Table::OUT, TGRpcYdbTableService>>(this, &Service_, CQ_, \
+    MakeIntrusive<TGRpcRequest<Ydb::Table::IN, Ydb::Table::OUT, TGRpcYdbTableService>>(this, &Service_, CQ_, \ 
         [this](NGrpc::IRequestContextBase *ctx) { \
             NGRpcService::ReportGrpcReqToMon(*ActorSystem_, ctx->GetPeer()); \
             ACTION; \
@@ -45,7 +45,7 @@ void TGRpcYdbTableService::SetupIncomingRequests(NGrpc::TLoggerPtr logger) {
         #NAME, logger, getCounterBlock("table", #NAME))->Run();
 
 #define ADD_BYTES_REQUEST(NAME, IN, OUT, ACTION) \
-    MakeIntrusive<TGRpcRequest<Ydb::Table::IN, Ydb::Table::OUT, TGRpcYdbTableService>>(this, &Service_, CQ_, \
+    MakeIntrusive<TGRpcRequest<Ydb::Table::IN, Ydb::Table::OUT, TGRpcYdbTableService>>(this, &Service_, CQ_, \ 
         [this](NGrpc::IRequestContextBase *ctx) { \
             NGRpcService::ReportGrpcReqToMon(*ActorSystem_, ctx->GetPeer()); \
             ACTION; \
@@ -85,36 +85,36 @@ void TGRpcYdbTableService::SetupIncomingRequests(NGrpc::TLoggerPtr logger) {
     ADD_REQUEST(RenameTables, RenameTablesRequest, RenameTablesResponse, {
         ActorSystem_->Send(GRpcRequestProxyId_, new TEvRenameTablesRequest(ctx));
     })
-    ADD_REQUEST(ExplainDataQuery, ExplainDataQueryRequest, ExplainDataQueryResponse, {
-        ActorSystem_->Send(GRpcRequestProxyId_, new TEvExplainDataQueryRequest(ctx));
-    })
-    ADD_REQUEST(PrepareDataQuery, PrepareDataQueryRequest, PrepareDataQueryResponse, {
-        ActorSystem_->Send(GRpcRequestProxyId_, new TEvPrepareDataQueryRequest(ctx));
-    })
-    ADD_REQUEST(ExecuteDataQuery, ExecuteDataQueryRequest, ExecuteDataQueryResponse, {
-        ActorSystem_->Send(GRpcRequestProxyId_, new TEvExecuteDataQueryRequest(ctx));
-    })
-    ADD_REQUEST(ExecuteSchemeQuery, ExecuteSchemeQueryRequest, ExecuteSchemeQueryResponse, {
-        ActorSystem_->Send(GRpcRequestProxyId_, new TEvExecuteSchemeQueryRequest(ctx));
-    })
-    ADD_REQUEST(BeginTransaction, BeginTransactionRequest, BeginTransactionResponse, {
-        ActorSystem_->Send(GRpcRequestProxyId_, new TEvBeginTransactionRequest(ctx));
-    })
-    ADD_REQUEST(CommitTransaction, CommitTransactionRequest, CommitTransactionResponse, {
-        ActorSystem_->Send(GRpcRequestProxyId_, new TEvCommitTransactionRequest(ctx));
-    })
-    ADD_REQUEST(RollbackTransaction, RollbackTransactionRequest, RollbackTransactionResponse, {
-        ActorSystem_->Send(GRpcRequestProxyId_, new TEvRollbackTransactionRequest(ctx));
-    })
+    ADD_REQUEST(ExplainDataQuery, ExplainDataQueryRequest, ExplainDataQueryResponse, { 
+        ActorSystem_->Send(GRpcRequestProxyId_, new TEvExplainDataQueryRequest(ctx)); 
+    }) 
+    ADD_REQUEST(PrepareDataQuery, PrepareDataQueryRequest, PrepareDataQueryResponse, { 
+        ActorSystem_->Send(GRpcRequestProxyId_, new TEvPrepareDataQueryRequest(ctx)); 
+    }) 
+    ADD_REQUEST(ExecuteDataQuery, ExecuteDataQueryRequest, ExecuteDataQueryResponse, { 
+        ActorSystem_->Send(GRpcRequestProxyId_, new TEvExecuteDataQueryRequest(ctx)); 
+    }) 
+    ADD_REQUEST(ExecuteSchemeQuery, ExecuteSchemeQueryRequest, ExecuteSchemeQueryResponse, { 
+        ActorSystem_->Send(GRpcRequestProxyId_, new TEvExecuteSchemeQueryRequest(ctx)); 
+    }) 
+    ADD_REQUEST(BeginTransaction, BeginTransactionRequest, BeginTransactionResponse, { 
+        ActorSystem_->Send(GRpcRequestProxyId_, new TEvBeginTransactionRequest(ctx)); 
+    }) 
+    ADD_REQUEST(CommitTransaction, CommitTransactionRequest, CommitTransactionResponse, { 
+        ActorSystem_->Send(GRpcRequestProxyId_, new TEvCommitTransactionRequest(ctx)); 
+    }) 
+    ADD_REQUEST(RollbackTransaction, RollbackTransactionRequest, RollbackTransactionResponse, { 
+        ActorSystem_->Send(GRpcRequestProxyId_, new TEvRollbackTransactionRequest(ctx)); 
+    }) 
     ADD_REQUEST(DescribeTableOptions, DescribeTableOptionsRequest, DescribeTableOptionsResponse, {
         ActorSystem_->Send(GRpcRequestProxyId_, new TEvDescribeTableOptionsRequest(ctx));
     })
     ADD_REQUEST(BulkUpsert, BulkUpsertRequest, BulkUpsertResponse, {
         ActorSystem_->Send(GRpcRequestProxyId_, new TEvBulkUpsertRequest(ctx));
     })
-    ADD_REQUEST(StreamExecuteScanQuery, ExecuteScanQueryRequest, ExecuteScanQueryPartialResponse, {
-        ActorSystem_->Send(GRpcRequestProxyId_, new TEvStreamExecuteScanQueryRequest(ctx));
-    })
+    ADD_REQUEST(StreamExecuteScanQuery, ExecuteScanQueryRequest, ExecuteScanQueryPartialResponse, { 
+        ActorSystem_->Send(GRpcRequestProxyId_, new TEvStreamExecuteScanQueryRequest(ctx)); 
+    }) 
 
 #undef ADD_REQUEST
 }
diff --git a/ydb/services/ydb/ydb_table.h b/ydb/services/ydb/ydb_table.h
index 77756bf023..c7357a8d08 100644
--- a/ydb/services/ydb/ydb_table.h
+++ b/ydb/services/ydb/ydb_table.h
@@ -8,11 +8,11 @@
 namespace NKikimr {
 namespace NGRpcService {
 
-class TGRpcYdbTableService
+class TGRpcYdbTableService 
     : public NGrpc::TGrpcServiceBase<Ydb::Table::V1::TableService>
 {
 public:
-    TGRpcYdbTableService(NActors::TActorSystem* system, TIntrusivePtr<NMonitoring::TDynamicCounters> counters,
+    TGRpcYdbTableService(NActors::TActorSystem* system, TIntrusivePtr<NMonitoring::TDynamicCounters> counters, 
         NActors::TActorId id);
 
     void InitService(grpc::ServerCompletionQueue* cq, NGrpc::TLoggerPtr logger) override;
diff --git a/ydb/services/ydb/ydb_table_ut.cpp b/ydb/services/ydb/ydb_table_ut.cpp
index 4861c06b92..1acb497d1c 100644
--- a/ydb/services/ydb/ydb_table_ut.cpp
+++ b/ydb/services/ydb/ydb_table_ut.cpp
@@ -19,8 +19,8 @@
 
 #include <util/thread/factory.h>
 
-using namespace NYdb;
-using namespace NYdb::NTable;
+using namespace NYdb; 
+using namespace NYdb::NTable; 
 
 TSession CreateSession(TDriver driver, const TString& token = "", const TString& discoveryEndpoint = "") {
     NYdb::NTable::TClientSettings settings;
@@ -111,15 +111,15 @@ static void MultiTenantSDK(bool asyncDiscovery) {
     driver.Stop(true);
 }
 
-Y_UNIT_TEST_SUITE(YdbYqlClient) {
+Y_UNIT_TEST_SUITE(YdbYqlClient) { 
     Y_UNIT_TEST(TestYqlWrongTable) {
         TKikimrWithGrpcAndRootSchema server;
         ui16 grpc = server.GetPort();
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
         auto session = CreateSession(connection);
 
@@ -154,8 +154,8 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
         auto session = CreateSession(connection);
 
@@ -173,7 +173,7 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
         auto result = session.ExecuteDataQuery(R"___(
             UPSERT INTO [Root/Test] (Key, Value)
                 VALUES("foo", "bar");
-            )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+            )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
 
         UNIT_ASSERT_EQUAL(result.IsTransportError(), false);
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::GENERIC_ERROR);
@@ -192,16 +192,16 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
         auto session = CreateSession(connection);
         auto status = session.Close().ExtractValueSync();
         UNIT_ASSERT_EQUAL(status.IsTransportError(), false);
         UNIT_ASSERT_EQUAL(status.GetStatus(), EStatus::SUCCESS);
 
-        auto result = session.ExecuteDataQuery("SELECT 42;",
-            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        auto result = session.ExecuteDataQuery("SELECT 42;", 
+            TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
 
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::BAD_SESSION);
     }
@@ -228,10 +228,10 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
         const TString location = TStringBuilder() << "localhost:" << grpc;
 
         auto driver = NYdb::TDriver(
-            TDriverConfig()
+            TDriverConfig() 
                 .SetEndpoint(location));
 
-        NYdb::NTable::TTableClient client(driver);
+        NYdb::NTable::TTableClient client(driver); 
         int count = 10;
 
         THashSet<TString> sids;
@@ -538,7 +538,7 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
                     if (res.IsSuccess()) {
                         ok++;
                     } else {
-                        UNIT_ASSERT_VALUES_EQUAL(res.GetStatus(), EStatus::SESSION_BUSY);
+                        UNIT_ASSERT_VALUES_EQUAL(res.GetStatus(), EStatus::SESSION_BUSY); 
                         bad++;
                     }
                 }
@@ -568,8 +568,8 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
         auto session = CreateSession(connection);
 
@@ -592,17 +592,17 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
             VALUES(1u, 12u, 13u, 14u);
             UPSERT INTO [Root/Test] (Column1, Column2, Column3, Column4)
             VALUES(2u, 22u, 23u, 24u);
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
 
         auto result = session.ExecuteDataQuery(R"___(
             SELECT Column4, Column2, Column3, Column1 FROM [Root/Test];
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
 
         UNIT_ASSERT_EQUAL(result.IsTransportError(), false);
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-        TVector<TResultSet> resultSets = result.GetResultSets();
+        TVector<TResultSet> resultSets = result.GetResultSets(); 
         UNIT_ASSERT_EQUAL(resultSets.size(), 1);
-        UNIT_ASSERT_EQUAL(resultSets[0].ColumnsCount(), 4);
+        UNIT_ASSERT_EQUAL(resultSets[0].ColumnsCount(), 4); 
         auto columnMeta = resultSets[0].GetColumnsMeta();
         const TString ref[] = { "Column4", "Column2", "Column3", "Column1" };
         for (size_t i = 0; i < columnMeta.size(); ++i) {
@@ -617,7 +617,7 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         auto connection = NYdb::TDriver(
-            TDriverConfig()
+            TDriverConfig() 
                 .SetEndpoint(location));
         auto session = CreateSession(connection);
 
@@ -652,10 +652,10 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         auto connection = NYdb::TDriver(
-            TDriverConfig()
+            TDriverConfig() 
                 .SetEndpoint(location));
 
-        NYdb::NTable::TTableClient client(connection);
+        NYdb::NTable::TTableClient client(connection); 
         auto sessionResponse = client.CreateSession().ExtractValueSync();
         UNIT_ASSERT_EQUAL(sessionResponse.IsTransportError(), false);
 
@@ -817,7 +817,7 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         auto connection = NYdb::TDriver(
-            TDriverConfig()
+            TDriverConfig() 
                 .SetEndpoint(location));
         auto session = CreateSession(connection);
 
@@ -857,9 +857,9 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         auto connection = NYdb::TDriver(
-            TDriverConfig()
+            TDriverConfig() 
                 .SetEndpoint(location));
-        auto scheme = NYdb::NScheme::TSchemeClient(connection);
+        auto scheme = NYdb::NScheme::TSchemeClient(connection); 
         auto session = CreateSession(connection);
         {
             auto status = scheme.MakeDirectory("Root/Foo").ExtractValueSync();
@@ -910,9 +910,9 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
                 .UseSecureConnection(NYdbSslTestData::CaCrt)
                 .SetEndpoint(location));
 
-        auto& tableSettings = server.GetServer().GetSettings().AppConfig.GetTableServiceConfig();
-        bool useSchemeCacheMeta = tableSettings.GetUseSchemeCacheMetadata();
-
+        auto& tableSettings = server.GetServer().GetSettings().AppConfig.GetTableServiceConfig(); 
+        bool useSchemeCacheMeta = tableSettings.GetUseSchemeCacheMetadata(); 
+ 
         {
             auto session = CreateSession(connection, "root@builtin");
             {
@@ -927,7 +927,7 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
                 UNIT_ASSERT_EQUAL(status.GetStatus(), EStatus::SUCCESS);
             }
             {
-                auto scheme = NYdb::NScheme::TSchemeClient(connection);
+                auto scheme = NYdb::NScheme::TSchemeClient(connection); 
                 auto status = scheme.ModifyPermissions("Root/Test",
                     NYdb::NScheme::TModifyPermissionsSettings()
                         .AddGrantPermissions(
@@ -944,7 +944,7 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
                 UNIT_ASSERT_EQUAL(status.GetStatus(), EStatus::SUCCESS);
             }
             {
-                auto scheme = NYdb::NScheme::TSchemeClient(connection);
+                auto scheme = NYdb::NScheme::TSchemeClient(connection); 
                 auto status = scheme.DescribePath("Root/Test").ExtractValueSync();
                 UNIT_ASSERT_EQUAL(status.IsTransportError(), false);
                 UNIT_ASSERT_EQUAL(status.GetStatus(), EStatus::SUCCESS);
@@ -968,8 +968,8 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
                 )__",TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
 
                 UNIT_ASSERT_EQUAL(status.IsTransportError(), false);
-                UNIT_ASSERT_EQUAL(status.GetStatus(),
-                    useSchemeCacheMeta ? EStatus::SCHEME_ERROR : EStatus::UNAUTHORIZED);
+                UNIT_ASSERT_EQUAL(status.GetStatus(), 
+                    useSchemeCacheMeta ? EStatus::SCHEME_ERROR : EStatus::UNAUTHORIZED); 
             }
         }
     }
@@ -1205,14 +1205,14 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
         TString traceId = "CppUtTestQuery";
 
         {
-            NKikimrConfig::TAppConfig appConfig;
-            auto& logConfig = *appConfig.MutableLogConfig();
-            auto& entry = *logConfig.AddEntry();
-            entry.SetComponent(NKikimrServices::EServiceKikimr_Name(NKikimrServices::KQP_YQL));
-            entry.SetLevel(NActors::NLog::PRI_DEBUG);
+            NKikimrConfig::TAppConfig appConfig; 
+            auto& logConfig = *appConfig.MutableLogConfig(); 
+            auto& entry = *logConfig.AddEntry(); 
+            entry.SetComponent(NKikimrServices::EServiceKikimr_Name(NKikimrServices::KQP_YQL)); 
+            entry.SetLevel(NActors::NLog::PRI_DEBUG); 
 
             TKikimrWithGrpcAndRootSchema server(appConfig, {}, logBackend);
-
+ 
             server.Server_->GetRuntime()->SetLogPriority(NKikimrServices::GRPC_SERVER, NActors::NLog::PRI_DEBUG);
             server.Server_->GetRuntime()->SetLogPriority(NKikimrServices::KQP_PROXY, NActors::NLog::PRI_DEBUG);
             server.Server_->GetRuntime()->SetLogPriority(NKikimrServices::KQP_WORKER, NActors::NLog::PRI_DEBUG);
@@ -1222,29 +1222,29 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
 
             TString location = TStringBuilder() << "localhost:" << grpc;
 
-            auto connection = NYdb::TDriver(
-                TDriverConfig()
+            auto connection = NYdb::TDriver( 
+                TDriverConfig() 
                     .SetEndpoint(location));
             auto session = CreateSession(connection);
 
-            auto result = session
+            auto result = session 
                 .ExecuteSchemeQuery(R"___(
                     CREATE TABLE [Root/Test] (
                         Key Uint32,
                         Value String,
                         PRIMARY KEY (Key)
                     );
-                )___", TExecSchemeQuerySettings().TraceId(traceId)).ExtractValueSync();
+                )___", TExecSchemeQuerySettings().TraceId(traceId)).ExtractValueSync(); 
 
             UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
 
-            result = session
+            result = session 
                 .ExecuteDataQuery(R"___(
                     UPSERT INTO [Root/Test] (Key, Value)
                     VALUES(2u, "Two");
-                )___",
-                TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(),
-                TExecDataQuerySettings().TraceId(traceId)).ExtractValueSync();
+                )___", 
+                TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), 
+                TExecDataQuerySettings().TraceId(traceId)).ExtractValueSync(); 
 
             UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
         }
@@ -1338,8 +1338,8 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
         auto session = CreateSession(connection);
 
@@ -1352,22 +1352,22 @@ Y_UNIT_TEST_SUITE(YdbYqlClient) {
 
         auto result1 = session.ExecuteDataQuery(R"___(
             INSERT INTO [Root/Test] (Key, Value) VALUES(1u, "One");
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_EQUAL(result1.GetStatus(), EStatus::SUCCESS);
 
         {
             auto session2 = CreateSession(connection);
             auto result = session2.ExecuteDataQuery(R"___(
                 UPSERT INTO [Root/Test] (Key, Value) VALUES(1u, "Two");
-            )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+            )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
             UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
         }
 
         {
             auto result2 = session.ExecuteDataQuery(R"___(
                 SELECT 42;
-            )___", TTxControl::Tx(*result1.GetTransaction()).CommitTx()).ExtractValueSync();
-            UNIT_ASSERT_EQUAL(result2.GetStatus(), EStatus::NOT_FOUND);
+            )___", TTxControl::Tx(*result1.GetTransaction()).CommitTx()).ExtractValueSync(); 
+            UNIT_ASSERT_EQUAL(result2.GetStatus(), EStatus::NOT_FOUND); 
             auto issueString = result2.GetIssues().ToString();
             TString expected =
 R"___(<main>: Error: Transaction not found: , code: 2015
@@ -1382,10 +1382,10 @@ R"___(<main>: Error: Transaction not found: , code: 2015
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
-        NYdb::NTable::TTableClient client(connection);
+        NYdb::NTable::TTableClient client(connection); 
         auto session = client.CreateSession().ExtractValueSync().GetSession();
 
         {
@@ -1406,41 +1406,41 @@ R"___(<main>: Error: Transaction not found: , code: 2015
             SELECT data.Key AS Key, data.Value AS Value FROM (SELECT $Data AS data) FLATTEN BY data;
         )___").ExtractValueSync();
         UNIT_ASSERT_EQUAL(fillQueryResult.GetStatus(), EStatus::SUCCESS);
-        auto query = fillQueryResult.GetQuery();
+        auto query = fillQueryResult.GetQuery(); 
 
         const ui32 BATCH_NUM = 5;
         const ui32 BATCH_ROWS = 100;
         const ui32 BLOB_SIZE = 100 * 1024; // 100 Kb
 
         for (ui64 i = 0; i < BATCH_NUM ; ++i) {
-            TParamsBuilder paramsBuilder = client.GetParamsBuilder();
-
-            auto& paramBuilder = paramsBuilder.AddParam("$Data");
+            TParamsBuilder paramsBuilder = client.GetParamsBuilder(); 
 
-            paramBuilder.BeginList();
+            auto& paramBuilder = paramsBuilder.AddParam("$Data"); 
+ 
+            paramBuilder.BeginList(); 
             for (ui64 j = 0; j < BATCH_ROWS; ++j) {
                 auto key = i * BATCH_ROWS + j;
                 auto val = TString(BLOB_SIZE, '0' + key % 10);
-                paramBuilder.AddListItem()
-                    .BeginStruct()
-                        .AddMember("Key")
-                            .Uint64(key)
-                        .AddMember("Value")
-                            .String(val)
-                    .EndStruct();
+                paramBuilder.AddListItem() 
+                    .BeginStruct() 
+                        .AddMember("Key") 
+                            .Uint64(key) 
+                        .AddMember("Value") 
+                            .String(val) 
+                    .EndStruct(); 
             }
             paramBuilder.EndList();
-            paramBuilder.Build();
+            paramBuilder.Build(); 
 
-            auto result = query.Execute(TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(),
-                paramsBuilder.Build()).ExtractValueSync();
+            auto result = query.Execute(TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx(), 
+                paramsBuilder.Build()).ExtractValueSync(); 
             UNIT_ASSERT_EQUAL(result.GetStatus(),  EStatus::SUCCESS);
         }
 
         auto result = session.ExecuteDataQuery(R"___(
             SELECT * FROM [Root/Test] WHERE Key != 1;
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_EQUAL(result.GetStatus(),  EStatus::UNDETERMINED);
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_EQUAL(result.GetStatus(),  EStatus::UNDETERMINED); 
         UNIT_ASSERT(result.GetIssues().ToString().Contains("ExecResultUnavailable"));
         UNIT_ASSERT(result.GetIssues().ToString().Contains("REPLY_SIZE_EXECEEDED"));
     }
@@ -1451,10 +1451,10 @@ R"___(<main>: Error: Transaction not found: , code: 2015
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
-        NYdb::NTable::TTableClient client(connection);
+        NYdb::NTable::TTableClient client(connection); 
         auto session = client.CreateSession().ExtractValueSync().GetSession();
 
         auto result = session.ExecuteSchemeQuery(R"___(
@@ -1473,53 +1473,53 @@ R"___(<main>: Error: Transaction not found: , code: 2015
         UNIT_ASSERT_NO_DIFF(result.GetIssues().ToString(), ref);
     }
 
-    Y_UNIT_TEST(TestBusySession) {
+    Y_UNIT_TEST(TestBusySession) { 
         TKikimrWithGrpcAndRootSchema server;
         ui16 grpc = server.GetPort();
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
-        NYdb::NTable::TTableClient client(connection);
+        NYdb::NTable::TTableClient client(connection); 
         auto session = client.CreateSession().ExtractValueSync().GetSession();
-        TVector<NYdb::NTable::TAsyncDataQueryResult> futures;
+        TVector<NYdb::NTable::TAsyncDataQueryResult> futures; 
 
         for (ui32 i = 0; i < 10; ++i) {
-            auto query = session.ExecuteDataQuery(R"___(
-                SELECT 1;
-            )___", TTxControl::BeginTx().CommitTx());
-            futures.push_back(query);
-        }
-
-        for (auto& future : futures) {
-            auto result = future.ExtractValueSync();
-            if (result.GetStatus() != EStatus::SUCCESS) {
-                UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SESSION_BUSY);
-            }
-        }
-    }
-
-    Y_UNIT_TEST(TestMultipleModifications) {
-        TKikimrWithGrpcAndRootSchema server;
-        ui16 grpc = server.GetPort();
-
-        TString location = TStringBuilder() << "localhost:" << grpc;
-        const ui32 sessionsCount = 10;
-
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
-                .SetEndpoint(location));
-        NYdb::NTable::TTableClient client(connection);
-        TVector<TSession> sessions;
-        for (ui32 i = 0; i < sessionsCount; ++i) {
-            sessions.push_back(client.CreateSession().ExtractValueSync().GetSession());
-        }
-
-        TVector<NYdb::TAsyncStatus> futures;
-        for (ui32 i = 0; i < sessionsCount; ++i) {
-            auto query = sessions[i].ExecuteSchemeQuery(R"___(
+            auto query = session.ExecuteDataQuery(R"___( 
+                SELECT 1; 
+            )___", TTxControl::BeginTx().CommitTx()); 
+            futures.push_back(query); 
+        } 
+ 
+        for (auto& future : futures) { 
+            auto result = future.ExtractValueSync(); 
+            if (result.GetStatus() != EStatus::SUCCESS) { 
+                UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SESSION_BUSY); 
+            } 
+        } 
+    } 
+ 
+    Y_UNIT_TEST(TestMultipleModifications) { 
+        TKikimrWithGrpcAndRootSchema server; 
+        ui16 grpc = server.GetPort(); 
+ 
+        TString location = TStringBuilder() << "localhost:" << grpc; 
+        const ui32 sessionsCount = 10; 
+ 
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
+                .SetEndpoint(location)); 
+        NYdb::NTable::TTableClient client(connection); 
+        TVector<TSession> sessions; 
+        for (ui32 i = 0; i < sessionsCount; ++i) { 
+            sessions.push_back(client.CreateSession().ExtractValueSync().GetSession()); 
+        } 
+ 
+        TVector<NYdb::TAsyncStatus> futures; 
+        for (ui32 i = 0; i < sessionsCount; ++i) { 
+            auto query = sessions[i].ExecuteSchemeQuery(R"___( 
                 CREATE TABLE [Root/Test] (
                     Key Int,
                     Value String,
@@ -1537,9 +1537,9 @@ R"___(<main>: Error: Transaction not found: , code: 2015
         }
 
         // Make sure table exists
-        auto result = sessions[0].ExecuteDataQuery(R"___(
+        auto result = sessions[0].ExecuteDataQuery(R"___( 
             UPSERT INTO [Root/Test] (Key, Value) VALUES (1, "One");
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
     }
 
@@ -1549,10 +1549,10 @@ R"___(<main>: Error: Transaction not found: , code: 2015
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
-        NYdb::NTable::TTableClient client(connection);
+        NYdb::NTable::TTableClient client(connection); 
         auto session = client.CreateSession().ExtractValueSync().GetSession();
 
         {
@@ -1568,7 +1568,7 @@ R"___(<main>: Error: Transaction not found: , code: 2015
 
         auto result = session.ExecuteDataQuery(R"___(
             UPSERT INTO [Root/Test] (Key, Value) VALUES(1u, "One");
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         Cerr << result.GetIssues().ToString() << Endl;
         UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
 
@@ -1579,20 +1579,20 @@ R"___(<main>: Error: Transaction not found: , code: 2015
 
         result = session.ExecuteDataQuery(R"___(
             UPSERT INTO [Root/Test] (Key, Value) VALUES(2u, "Two");
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
 
         result = session.ExecuteDataQuery(R"___(
             SELECT * FROM [Root/Test];
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
 
-        TResultSet resultSet = result.GetResultSet(0);
-        TResultSetParser rsParser(resultSet);
+        TResultSet resultSet = result.GetResultSet(0); 
+        TResultSetParser rsParser(resultSet); 
         int c = 0;
-        while (rsParser.TryNextRow()) {
+        while (rsParser.TryNextRow()) { 
             c++;
-        }
+        } 
 
         UNIT_ASSERT_VALUES_EQUAL(c, 2);
     }
@@ -1603,10 +1603,10 @@ R"___(<main>: Error: Transaction not found: , code: 2015
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
-        NYdb::NTable::TTableClient client(connection);
+        NYdb::NTable::TTableClient client(connection); 
         auto session = client.CreateSession().ExtractValueSync().GetSession();
 
         auto result = session.ExecuteSchemeQuery(R"___(
@@ -1620,12 +1620,12 @@ R"___(<main>: Error: Transaction not found: , code: 2015
 
         result = session.ExecuteDataQuery(R"___(
             UPSERT INTO [Root/BadTable1] (Key, Value) VALUES(1u, "One");
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync(); 
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR);
 
         result = session.ExecuteDataQuery(R"___(
             UPSERT INTO [Root/BadTable2] (Key, Value) VALUES(2u, "Two");
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW())).ExtractValueSync(); 
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SCHEME_ERROR);
     }
 
@@ -1636,9 +1636,9 @@ R"___(<main>: Error: Transaction not found: , code: 2015
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         auto connection = NYdb::TDriver(
-            TDriverConfig()
+            TDriverConfig() 
                 .SetEndpoint(location));
-        NYdb::NTable::TTableClient client(connection);
+        NYdb::NTable::TTableClient client(connection); 
         auto session = client.CreateSession().ExtractValueSync().GetSession();
 
         auto result = session.PrepareDataQuery(R"___(
@@ -1646,27 +1646,27 @@ R"___(<main>: Error: Transaction not found: , code: 2015
             SELECT $paramName;
             )___").ExtractValueSync();
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-        auto query = result.GetQuery();
-        auto paramsBuilder = query.GetParamsBuilder();
-        paramsBuilder.AddParam("$paramName").String("someString").Build();
+        auto query = result.GetQuery(); 
+        auto paramsBuilder = query.GetParamsBuilder(); 
+        paramsBuilder.AddParam("$paramName").String("someString").Build(); 
         auto params = paramsBuilder.Build();
         {
-            auto result = query.Execute(TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx(),
+            auto result = query.Execute(TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx(), 
                 params).ExtractValueSync();
             UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-            auto resultSets = result.GetResultSets();
+            auto resultSets = result.GetResultSets(); 
             UNIT_ASSERT_EQUAL(resultSets.size(), 1);
             auto& resultSet = resultSets[0];
-            UNIT_ASSERT_EQUAL(resultSet.ColumnsCount(), 1);
+            UNIT_ASSERT_EQUAL(resultSet.ColumnsCount(), 1); 
             auto meta = resultSet.GetColumnsMeta();
             UNIT_ASSERT_EQUAL(meta.size(), 1);
-            TTypeParser parser(meta[0].Type);
-            UNIT_ASSERT(parser.GetKind() == TTypeParser::ETypeKind::Primitive);
-            UNIT_ASSERT(parser.GetPrimitive() == EPrimitiveType::String);
-
-            TResultSetParser rsParser(resultSet);
-            while (rsParser.TryNextRow()) {
-                UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetString(), "someString");
+            TTypeParser parser(meta[0].Type); 
+            UNIT_ASSERT(parser.GetKind() == TTypeParser::ETypeKind::Primitive); 
+            UNIT_ASSERT(parser.GetPrimitive() == EPrimitiveType::String); 
+ 
+            TResultSetParser rsParser(resultSet); 
+            while (rsParser.TryNextRow()) { 
+                UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetString(), "someString"); 
             }
         }
         // Test params is not destructed during previous execution
@@ -1697,10 +1697,10 @@ R"___(<main>: Error: Transaction not found: , code: 2015
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
-        NYdb::NTable::TTableClient client(connection);
+        NYdb::NTable::TTableClient client(connection); 
         auto session = client.CreateSession().ExtractValueSync().GetSession();
 
         auto result = session.ExecuteSchemeQuery(R"___(
@@ -1714,12 +1714,12 @@ R"___(<main>: Error: Transaction not found: , code: 2015
 
         result = session.ExecuteDataQuery(R"___(
             INSERT INTO [Root/Test] (Key, Value) VALUES (1u, "One");
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
 
         result = session.ExecuteDataQuery(R"___(
             INSERT INTO [Root/Test] (Key, Value) VALUES (1u, "Two");
-        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync();
+        )___", TTxControl::BeginTx(TTxSettings::SerializableRW()).CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::PRECONDITION_FAILED);
     }
 
@@ -1730,9 +1730,9 @@ R"___(<main>: Error: Transaction not found: , code: 2015
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         auto connection = NYdb::TDriver(
-            TDriverConfig()
+            TDriverConfig() 
                 .SetEndpoint(location));
-        NYdb::NTable::TTableClient client(connection);
+        NYdb::NTable::TTableClient client(connection); 
         auto session = client.CreateSession().ExtractValueSync().GetSession();
 
         auto result = session.ExecuteSchemeQuery(R"___(
@@ -2074,156 +2074,156 @@ R"___(<main>: Error: Transaction not found: , code: 2015
         UNIT_ASSERT_VALUES_EQUAL(it.ReadNext().GetValueSync().EOS(), true);
     }
 
-    Y_UNIT_TEST(RetryOperation) {
-        TKikimrWithGrpcAndRootSchema server;
-        NYdb::TDriver driver(TDriverConfig().SetEndpoint(TStringBuilder() << "localhost:" << server.GetPort()));
-        NYdb::NTable::TTableClient client(driver);
-
-        auto createFuture = client.RetryOperation([](TSession session) {
-            return session.ExecuteSchemeQuery(R"___(
-                CREATE TABLE [Root/Test] (
-                    Key Uint64,
-                    Value String,
-                    PRIMARY KEY (Key)
-                );
-            )___");
-        });
-
-        auto upsertFuture = createFuture.Apply([client](const TAsyncStatus& asyncStatus) mutable {
-            auto status = asyncStatus.GetValue();
-            if (!status.IsSuccess()) {
-                return NThreading::MakeFuture(status);
-            }
-
-            return client.RetryOperation<TDataQueryResult>([](TSession session) {
-                return session.ExecuteDataQuery(R"___(
-                    UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, "One");
-                )___", TTxControl::BeginTx().CommitTx());
-            }, TRetryOperationSettings().MaxRetries(0));
-        });
-
-        auto upsertStatus = upsertFuture.GetValueSync();
-        UNIT_ASSERT(upsertStatus.IsSuccess());
-
-        TMaybe<TResultSet> selectResult;
-        auto selectStatus = client.RetryOperationSync([&selectResult] (TSession session) {
-            auto result = session.ExecuteDataQuery(R"___(
-                SELECT * FROM [Root/Test];
-            )___", TTxControl::BeginTx().CommitTx()).GetValueSync();
-
-            if (result.IsSuccess()) {
-                selectResult = result.GetResultSet(0);
-            }
-
-            return result;
-        }, TRetryOperationSettings().MaxRetries(0));
-
-        UNIT_ASSERT(selectStatus.IsSuccess());
-
-        TResultSetParser parser(*selectResult);
-        UNIT_ASSERT(parser.TryNextRow());
+    Y_UNIT_TEST(RetryOperation) { 
+        TKikimrWithGrpcAndRootSchema server; 
+        NYdb::TDriver driver(TDriverConfig().SetEndpoint(TStringBuilder() << "localhost:" << server.GetPort())); 
+        NYdb::NTable::TTableClient client(driver); 
+ 
+        auto createFuture = client.RetryOperation([](TSession session) { 
+            return session.ExecuteSchemeQuery(R"___( 
+                CREATE TABLE [Root/Test] ( 
+                    Key Uint64, 
+                    Value String, 
+                    PRIMARY KEY (Key) 
+                ); 
+            )___"); 
+        }); 
+ 
+        auto upsertFuture = createFuture.Apply([client](const TAsyncStatus& asyncStatus) mutable { 
+            auto status = asyncStatus.GetValue(); 
+            if (!status.IsSuccess()) { 
+                return NThreading::MakeFuture(status); 
+            } 
+ 
+            return client.RetryOperation<TDataQueryResult>([](TSession session) { 
+                return session.ExecuteDataQuery(R"___( 
+                    UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, "One"); 
+                )___", TTxControl::BeginTx().CommitTx()); 
+            }, TRetryOperationSettings().MaxRetries(0)); 
+        }); 
+ 
+        auto upsertStatus = upsertFuture.GetValueSync(); 
+        UNIT_ASSERT(upsertStatus.IsSuccess()); 
+ 
+        TMaybe<TResultSet> selectResult; 
+        auto selectStatus = client.RetryOperationSync([&selectResult] (TSession session) { 
+            auto result = session.ExecuteDataQuery(R"___( 
+                SELECT * FROM [Root/Test]; 
+            )___", TTxControl::BeginTx().CommitTx()).GetValueSync(); 
+ 
+            if (result.IsSuccess()) { 
+                selectResult = result.GetResultSet(0); 
+            } 
+ 
+            return result; 
+        }, TRetryOperationSettings().MaxRetries(0)); 
+ 
+        UNIT_ASSERT(selectStatus.IsSuccess()); 
+ 
+        TResultSetParser parser(*selectResult); 
+        UNIT_ASSERT(parser.TryNextRow()); 
         driver.Stop(true);
-    }
-
-    Y_UNIT_TEST(QueryLimits) {
-        NKikimrConfig::TAppConfig appConfig;
-        auto& tableServiceConfig = *appConfig.MutableTableServiceConfig();
-        tableServiceConfig.SetQueryLimitBytes(200);
-        tableServiceConfig.SetParametersLimitBytes(100);
-
-        TKikimrWithGrpcAndRootSchema server(appConfig);
-
-        NYdb::TDriver driver(TDriverConfig().SetEndpoint(TStringBuilder() << "localhost:" << server.GetPort()));
-        NYdb::NTable::TTableClient client(driver);
-        auto session = client.CreateSession().ExtractValueSync().GetSession();
-
-        auto result = session.ExecuteSchemeQuery(R"___(
-            CREATE TABLE [Root/Test] (
-                Key Uint64,
-                Value String,
-                PRIMARY KEY (Key)
-            );
-        )___").ExtractValueSync();
-        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-
-        result = session.ExecuteDataQuery(Sprintf(R"___(
-            UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, "%s");
-        )___", TString(100, '*').c_str()), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-
-        result = session.ExecuteDataQuery(Sprintf(R"___(
-            UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, "%s");
-        )___", TString(200, '*').c_str()), TTxControl::BeginTx().CommitTx()).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
-
-        auto params = client.GetParamsBuilder()
-            .AddParam("$value").String(TString(50, '*'))
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(R"___(
-            DECLARE $value AS String;
-            UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, $value);
-        )___", TTxControl::BeginTx().CommitTx(), std::move(params)).ExtractValueSync();
-        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-
-        params = client.GetParamsBuilder()
-            .AddParam("$value").String(TString(100, '*'))
-                .Build()
-            .Build();
-
-        result = session.ExecuteDataQuery(R"___(
-            DECLARE $value AS String;
-            UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, $value);
-        )___", TTxControl::BeginTx().CommitTx(), std::move(params)).ExtractValueSync();
-        result.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST);
-    }
-
+    } 
+ 
+    Y_UNIT_TEST(QueryLimits) { 
+        NKikimrConfig::TAppConfig appConfig; 
+        auto& tableServiceConfig = *appConfig.MutableTableServiceConfig(); 
+        tableServiceConfig.SetQueryLimitBytes(200); 
+        tableServiceConfig.SetParametersLimitBytes(100); 
+ 
+        TKikimrWithGrpcAndRootSchema server(appConfig); 
+ 
+        NYdb::TDriver driver(TDriverConfig().SetEndpoint(TStringBuilder() << "localhost:" << server.GetPort())); 
+        NYdb::NTable::TTableClient client(driver); 
+        auto session = client.CreateSession().ExtractValueSync().GetSession(); 
+ 
+        auto result = session.ExecuteSchemeQuery(R"___( 
+            CREATE TABLE [Root/Test] ( 
+                Key Uint64, 
+                Value String, 
+                PRIMARY KEY (Key) 
+            ); 
+        )___").ExtractValueSync(); 
+        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+ 
+        result = session.ExecuteDataQuery(Sprintf(R"___( 
+            UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, "%s"); 
+        )___", TString(100, '*').c_str()), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+ 
+        result = session.ExecuteDataQuery(Sprintf(R"___( 
+            UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, "%s"); 
+        )___", TString(200, '*').c_str()), TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST); 
+ 
+        auto params = client.GetParamsBuilder() 
+            .AddParam("$value").String(TString(50, '*')) 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(R"___( 
+            DECLARE $value AS String; 
+            UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, $value); 
+        )___", TTxControl::BeginTx().CommitTx(), std::move(params)).ExtractValueSync(); 
+        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+ 
+        params = client.GetParamsBuilder() 
+            .AddParam("$value").String(TString(100, '*')) 
+                .Build() 
+            .Build(); 
+ 
+        result = session.ExecuteDataQuery(R"___( 
+            DECLARE $value AS String; 
+            UPSERT INTO [Root/Test] (Key, Value) VALUES (1u, $value); 
+        )___", TTxControl::BeginTx().CommitTx(), std::move(params)).ExtractValueSync(); 
+        result.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::BAD_REQUEST); 
+    } 
+ 
     Y_UNIT_TEST(SessionsServerLimit) {
-        NKikimrConfig::TAppConfig appConfig;
-        auto& tableServiceConfig = *appConfig.MutableTableServiceConfig();
-        tableServiceConfig.SetSessionsLimitPerNode(2);
-
-        TKikimrWithGrpcAndRootSchema server(appConfig);
-
-        NYdb::TDriver driver(TDriverConfig().SetEndpoint(TStringBuilder() << "localhost:" << server.GetPort()));
-        NYdb::NTable::TTableClient client(driver);
-        auto sessionResult = client.CreateSession().ExtractValueSync();
+        NKikimrConfig::TAppConfig appConfig; 
+        auto& tableServiceConfig = *appConfig.MutableTableServiceConfig(); 
+        tableServiceConfig.SetSessionsLimitPerNode(2); 
+ 
+        TKikimrWithGrpcAndRootSchema server(appConfig); 
+ 
+        NYdb::TDriver driver(TDriverConfig().SetEndpoint(TStringBuilder() << "localhost:" << server.GetPort())); 
+        NYdb::NTable::TTableClient client(driver); 
+        auto sessionResult = client.CreateSession().ExtractValueSync(); 
         UNIT_ASSERT_VALUES_EQUAL(client.GetActiveSessionCount(), 0);
-        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::SUCCESS);
-        auto session1 = sessionResult.GetSession();
-
-        sessionResult = client.CreateSession().ExtractValueSync();
+        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::SUCCESS); 
+        auto session1 = sessionResult.GetSession(); 
+ 
+        sessionResult = client.CreateSession().ExtractValueSync(); 
         UNIT_ASSERT_VALUES_EQUAL(client.GetActiveSessionCount(), 0);
-        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::SUCCESS);
-        auto session2 = sessionResult.GetSession();
-
-        sessionResult = client.CreateSession().ExtractValueSync();
-        sessionResult.GetIssues().PrintTo(Cerr);
+        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::SUCCESS); 
+        auto session2 = sessionResult.GetSession(); 
+ 
+        sessionResult = client.CreateSession().ExtractValueSync(); 
+        sessionResult.GetIssues().PrintTo(Cerr); 
         UNIT_ASSERT_VALUES_EQUAL(client.GetActiveSessionCount(), 0);
-        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::OVERLOADED);
-
-        auto status = session1.Close().ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(status.IsTransportError(), false);
+        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::OVERLOADED); 
+ 
+        auto status = session1.Close().ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(status.IsTransportError(), false); 
         UNIT_ASSERT_VALUES_EQUAL(client.GetActiveSessionCount(), 0);
-        UNIT_ASSERT_VALUES_EQUAL(status.GetStatus(), EStatus::SUCCESS);
-
-        auto result = session2.ExecuteDataQuery(R"___(
-            SELECT 1;
-        )___", TTxControl::BeginTx().CommitTx()).ExtractValueSync();
+        UNIT_ASSERT_VALUES_EQUAL(status.GetStatus(), EStatus::SUCCESS); 
+ 
+        auto result = session2.ExecuteDataQuery(R"___( 
+            SELECT 1; 
+        )___", TTxControl::BeginTx().CommitTx()).ExtractValueSync(); 
         UNIT_ASSERT_VALUES_EQUAL(client.GetActiveSessionCount(), 0);
-        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS);
-
-        sessionResult = client.CreateSession().ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::SUCCESS);
-
-        sessionResult = client.CreateSession().ExtractValueSync();
-        sessionResult.GetIssues().PrintTo(Cerr);
-        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::OVERLOADED);
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::SUCCESS); 
+ 
+        sessionResult = client.CreateSession().ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::SUCCESS); 
+ 
+        sessionResult = client.CreateSession().ExtractValueSync(); 
+        sessionResult.GetIssues().PrintTo(Cerr); 
+        UNIT_ASSERT_VALUES_EQUAL(sessionResult.GetStatus(), EStatus::OVERLOADED); 
         UNIT_ASSERT_VALUES_EQUAL(client.GetActiveSessionCount(), 0);
-    }
+    } 
 
     Y_UNIT_TEST(SessionsServerLimitWithSessionPool) {
         NKikimrConfig::TAppConfig appConfig;
@@ -4566,48 +4566,48 @@ R"___(<main>: Error: Transaction not found: , code: 2015
             "Warning: Table profile and ReadReplicasSettings are set. They are mutually exclusive. Use either one of them.",
             "Unexpected error message");
     }
-
-    Y_UNIT_TEST(TableKeyRangesSinglePartition) {
-        TKikimrWithGrpcAndRootSchema server;
-
-        NYdb::TDriver driver(TDriverConfig().SetEndpoint(TStringBuilder() << "localhost:" << server.GetPort()));
-
-        NYdb::NTable::TTableClient client(driver);
-        auto getSessionResult = client.CreateSession().ExtractValueSync();
-        UNIT_ASSERT_VALUES_EQUAL_C(getSessionResult.GetStatus(), EStatus::SUCCESS,
-            getSessionResult.GetIssues().ToString());
-        auto session = getSessionResult.GetSession();
-
-        {
-            auto builder = TTableBuilder()
-                .AddNullableColumn("key", EPrimitiveType::Uint64)
-                .AddNullableColumn("value", EPrimitiveType::Utf8)
-                .SetPrimaryKeyColumn("key");
-
-            auto desc = builder.Build();
-            auto result = session.CreateTable("Root/Test", std::move(desc)).GetValueSync();
-            UNIT_ASSERT_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString());
-        }
-
-        {
-            auto describeResult = session.DescribeTable("Root/Test").ExtractValueSync();
-            UNIT_ASSERT_C(describeResult.IsSuccess(), describeResult.GetIssues().ToString());
-
-            auto tableDesc = describeResult.GetTableDescription();
-            UNIT_ASSERT_VALUES_EQUAL(tableDesc.GetKeyRanges().size(), 0);
-        }
-
-        {
-            auto describeTableSettings = TDescribeTableSettings()
-                .WithKeyShardBoundary(true);
-            auto describeResult = session.DescribeTable("Root/Test", describeTableSettings).ExtractValueSync();
-            UNIT_ASSERT_C(describeResult.IsSuccess(), describeResult.GetIssues().ToString());
-
-            auto tableDesc = describeResult.GetTableDescription();
-            auto& keyRanges = tableDesc.GetKeyRanges();
-            UNIT_ASSERT_VALUES_EQUAL(keyRanges.size(), 1);
-            UNIT_ASSERT(!keyRanges[0].From());
-            UNIT_ASSERT(!keyRanges[0].To());
-        }
-    }
+ 
+    Y_UNIT_TEST(TableKeyRangesSinglePartition) { 
+        TKikimrWithGrpcAndRootSchema server; 
+ 
+        NYdb::TDriver driver(TDriverConfig().SetEndpoint(TStringBuilder() << "localhost:" << server.GetPort())); 
+ 
+        NYdb::NTable::TTableClient client(driver); 
+        auto getSessionResult = client.CreateSession().ExtractValueSync(); 
+        UNIT_ASSERT_VALUES_EQUAL_C(getSessionResult.GetStatus(), EStatus::SUCCESS, 
+            getSessionResult.GetIssues().ToString()); 
+        auto session = getSessionResult.GetSession(); 
+ 
+        { 
+            auto builder = TTableBuilder() 
+                .AddNullableColumn("key", EPrimitiveType::Uint64) 
+                .AddNullableColumn("value", EPrimitiveType::Utf8) 
+                .SetPrimaryKeyColumn("key"); 
+ 
+            auto desc = builder.Build(); 
+            auto result = session.CreateTable("Root/Test", std::move(desc)).GetValueSync(); 
+            UNIT_ASSERT_EQUAL_C(result.GetStatus(), EStatus::SUCCESS, result.GetIssues().ToString()); 
+        } 
+ 
+        { 
+            auto describeResult = session.DescribeTable("Root/Test").ExtractValueSync(); 
+            UNIT_ASSERT_C(describeResult.IsSuccess(), describeResult.GetIssues().ToString()); 
+ 
+            auto tableDesc = describeResult.GetTableDescription(); 
+            UNIT_ASSERT_VALUES_EQUAL(tableDesc.GetKeyRanges().size(), 0); 
+        } 
+ 
+        { 
+            auto describeTableSettings = TDescribeTableSettings() 
+                .WithKeyShardBoundary(true); 
+            auto describeResult = session.DescribeTable("Root/Test", describeTableSettings).ExtractValueSync(); 
+            UNIT_ASSERT_C(describeResult.IsSuccess(), describeResult.GetIssues().ToString()); 
+ 
+            auto tableDesc = describeResult.GetTableDescription(); 
+            auto& keyRanges = tableDesc.GetKeyRanges(); 
+            UNIT_ASSERT_VALUES_EQUAL(keyRanges.size(), 1); 
+            UNIT_ASSERT(!keyRanges[0].From()); 
+            UNIT_ASSERT(!keyRanges[0].To()); 
+        } 
+    } 
 }
diff --git a/ydb/services/ydb/ydb_ut.cpp b/ydb/services/ydb/ydb_ut.cpp
index 2d37063079..379b5b29d9 100644
--- a/ydb/services/ydb/ydb_ut.cpp
+++ b/ydb/services/ydb/ydb_ut.cpp
@@ -36,29 +36,29 @@
 namespace NKikimr {
 
 using namespace Tests;
-using namespace NYdb;
-using namespace NYdb::NTable;
-using namespace NYdb::NScheme;
-
-static bool HasIssue(const NYql::TIssues& issues, ui32 code,
-    std::function<bool(const NYql::TIssue& issue)> predicate = {})
-{
-    bool hasIssue = false;
-
-    for (auto& issue : issues) {
-        WalkThroughIssues(issue, false, [code, predicate, &hasIssue] (const NYql::TIssue& issue, int level) {
-            Y_UNUSED(level);
-            if (issue.GetCode() == code) {
-                hasIssue = predicate
-                    ? predicate(issue)
-                    : true;
-            }
-        });
-    }
-
-    return hasIssue;
-}
-
+using namespace NYdb; 
+using namespace NYdb::NTable; 
+using namespace NYdb::NScheme; 
+
+static bool HasIssue(const NYql::TIssues& issues, ui32 code, 
+    std::function<bool(const NYql::TIssue& issue)> predicate = {}) 
+{ 
+    bool hasIssue = false; 
+ 
+    for (auto& issue : issues) { 
+        WalkThroughIssues(issue, false, [code, predicate, &hasIssue] (const NYql::TIssue& issue, int level) { 
+            Y_UNUSED(level); 
+            if (issue.GetCode() == code) { 
+                hasIssue = predicate 
+                    ? predicate(issue) 
+                    : true; 
+            } 
+        }); 
+    } 
+ 
+    return hasIssue; 
+} 
+ 
 Ydb::Table::DescribeTableResult DescribeTable(std::shared_ptr<grpc::Channel> channel, const TString& sessionId, const TString& path)
 {
     Ydb::Table::DescribeTableRequest request;
@@ -89,7 +89,7 @@ Ydb::Table::DescribeTableResult DescribeTable(std::shared_ptr<grpc::Channel> cha
 
 Ydb::Table::ExecuteQueryResult ExecYql(std::shared_ptr<grpc::Channel> channel, const TString &sessionId, const TString &yql, bool withStat = false);
 
-static Ydb::StatusIds::StatusCode WaitForStatus(std::shared_ptr<grpc::Channel> channel, const TString& opId) {
+static Ydb::StatusIds::StatusCode WaitForStatus(std::shared_ptr<grpc::Channel> channel, const TString& opId) { 
     std::unique_ptr<Ydb::Operation::V1::OperationService::Stub> stub;
     stub = Ydb::Operation::V1::OperationService::NewStub(channel);
     Ydb::Operations::GetOperationRequest request;
@@ -479,14 +479,14 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         //TDriver
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
 
-        auto client = NYdb::NTable::TTableClient(connection);
+        auto client = NYdb::NTable::TTableClient(connection); 
 
-        std::function<void(const TAsyncCreateSessionResult& future)> createSessionHandler =
-            [client] (const TAsyncCreateSessionResult& future) mutable {
+        std::function<void(const TAsyncCreateSessionResult& future)> createSessionHandler = 
+            [client] (const TAsyncCreateSessionResult& future) mutable { 
                 const auto& sessionValue = future.GetValue();
                 UNIT_ASSERT(!sessionValue.IsTransportError());
                 auto session = sessionValue.GetSession();
@@ -496,37 +496,37 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
                         const auto& createTableResult = future.GetValue();
                         UNIT_ASSERT(!createTableResult.IsTransportError());
                         auto sqlResultHandler =
-                            [](TAsyncDataQueryResult future) mutable {
+                            [](TAsyncDataQueryResult future) mutable { 
                                 auto sqlResultSets = future.ExtractValue();
                                 UNIT_ASSERT(!sqlResultSets.IsTransportError());
-
-                                auto resultSets = sqlResultSets.GetResultSets();
+ 
+                                auto resultSets = sqlResultSets.GetResultSets(); 
                                 UNIT_ASSERT_EQUAL(resultSets.size(), 1);
                                 auto& resultSet = resultSets[0];
-                                UNIT_ASSERT_EQUAL(resultSet.ColumnsCount(), 1);
+                                UNIT_ASSERT_EQUAL(resultSet.ColumnsCount(), 1); 
                                 auto meta = resultSet.GetColumnsMeta();
                                 UNIT_ASSERT_EQUAL(meta.size(), 1);
                                 UNIT_ASSERT_EQUAL(meta[0].Name, "colName");
-                                TTypeParser parser(meta[0].Type);
-                                UNIT_ASSERT(parser.GetKind() == TTypeParser::ETypeKind::Primitive);
-                                UNIT_ASSERT(parser.GetPrimitive() == EPrimitiveType::Int32);
-
-                                TResultSetParser rsParser(resultSet);
-                                while (rsParser.TryNextRow()) {
-                                    UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetInt32(), 42);
+                                TTypeParser parser(meta[0].Type); 
+                                UNIT_ASSERT(parser.GetKind() == TTypeParser::ETypeKind::Primitive); 
+                                UNIT_ASSERT(parser.GetPrimitive() == EPrimitiveType::Int32); 
+ 
+                                TResultSetParser rsParser(resultSet); 
+                                while (rsParser.TryNextRow()) { 
+                                    UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetInt32(), 42); 
                                 }
                             };
-
-                        session.ExecuteDataQuery(
-                            "SELECT 42 as colName;", TTxControl::BeginTx(
-                                TTxSettings::SerializableRW()).CommitTx()
+ 
+                        session.ExecuteDataQuery( 
+                            "SELECT 42 as colName;", TTxControl::BeginTx( 
+                                TTxSettings::SerializableRW()).CommitTx() 
                         ).Apply(std::move(sqlResultHandler)).Wait();
                     };
 
                 auto tableBuilder = client.GetTableBuilder();
-                tableBuilder
-                    .AddNullableColumn("Key", EPrimitiveType::Int32)
-                    .AddNullableColumn("Value", EPrimitiveType::String);
+                tableBuilder 
+                    .AddNullableColumn("Key", EPrimitiveType::Int32) 
+                    .AddNullableColumn("Value", EPrimitiveType::String); 
                 tableBuilder.SetPrimaryKeyColumn("Key");
                 session.CreateTable("/Root/FooTable", tableBuilder.Build()).Apply(createTableHandler).Wait();
             };
@@ -540,12 +540,12 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         auto connection = NYdb::TDriver(
-            TDriverConfig()
+            TDriverConfig() 
                 .SetAuthToken("test_user@builtin")
                 .UseSecureConnection(NYdbSslTestData::CaCrt)
                 .SetEndpoint(location));
 
-        auto client = NYdb::NTable::TTableClient(connection);
+        auto client = NYdb::NTable::TTableClient(connection); 
         std::function<void(const TAsyncCreateSessionResult& future)> createSessionHandler =
             [client] (const TAsyncCreateSessionResult& future) mutable {
                 const auto& sessionValue = future.GetValue();
@@ -563,51 +563,51 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         //TDriver
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
 
-        auto client = NYdb::NTable::TTableClient(connection);
+        auto client = NYdb::NTable::TTableClient(connection); 
 
-        std::function<void(const TAsyncCreateSessionResult& future)> createSessionHandler =
-            [client] (const TAsyncCreateSessionResult& future) mutable {
+        std::function<void(const TAsyncCreateSessionResult& future)> createSessionHandler = 
+            [client] (const TAsyncCreateSessionResult& future) mutable { 
                 const auto& sessionValue = future.GetValue();
                 UNIT_ASSERT(!sessionValue.IsTransportError());
                 auto session = sessionValue.GetSession();
 
                 auto prepareQueryHandler =
-                    [session, client] (TAsyncPrepareQueryResult future) mutable {
+                    [session, client] (TAsyncPrepareQueryResult future) mutable { 
                         const auto& prepareQueryResult = future.GetValue();
                         UNIT_ASSERT(!prepareQueryResult.IsTransportError());
                         UNIT_ASSERT_EQUAL(prepareQueryResult.GetStatus(), EStatus::SUCCESS);
-                        auto query = prepareQueryResult.GetQuery();
+                        auto query = prepareQueryResult.GetQuery(); 
                         auto paramsBuilder = client.GetParamsBuilder();
-                        auto& param = paramsBuilder.AddParam("$paramName");
-                        param.String("someString").Build();
+                        auto& param = paramsBuilder.AddParam("$paramName"); 
+                        param.String("someString").Build(); 
 
                         auto sqlResultHandler =
-                            [](TAsyncDataQueryResult future) mutable {
+                            [](TAsyncDataQueryResult future) mutable { 
                                 auto sqlResultSets = future.ExtractValue();
                                 UNIT_ASSERT(!sqlResultSets.IsTransportError());
-                                UNIT_ASSERT(sqlResultSets.IsSuccess());
-
-                                auto resultSets = sqlResultSets.GetResultSets();
+                                UNIT_ASSERT(sqlResultSets.IsSuccess()); 
+ 
+                                auto resultSets = sqlResultSets.GetResultSets(); 
                                 UNIT_ASSERT_EQUAL(resultSets.size(), 1);
                                 auto& resultSet = resultSets[0];
-                                UNIT_ASSERT_EQUAL(resultSet.ColumnsCount(), 1);
+                                UNIT_ASSERT_EQUAL(resultSet.ColumnsCount(), 1); 
                                 auto meta = resultSet.GetColumnsMeta();
                                 UNIT_ASSERT_EQUAL(meta.size(), 1);
-                                TTypeParser parser(meta[0].Type);
-                                UNIT_ASSERT(parser.GetKind() == TTypeParser::ETypeKind::Primitive);
-                                UNIT_ASSERT(parser.GetPrimitive() == EPrimitiveType::String);
-
-                                TResultSetParser rsParser(resultSet);
-                                while (rsParser.TryNextRow()) {
-                                    UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetString(), "someString");
+                                TTypeParser parser(meta[0].Type); 
+                                UNIT_ASSERT(parser.GetKind() == TTypeParser::ETypeKind::Primitive); 
+                                UNIT_ASSERT(parser.GetPrimitive() == EPrimitiveType::String); 
+ 
+                                TResultSetParser rsParser(resultSet); 
+                                while (rsParser.TryNextRow()) { 
+                                    UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetString(), "someString"); 
                                 }
                             };
-
-                        query.Execute(TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx(),
+ 
+                        query.Execute(TTxControl::BeginTx(TTxSettings::OnlineRO()).CommitTx(), 
                             paramsBuilder.Build()).Apply(sqlResultHandler).Wait();
                     };
 
@@ -622,28 +622,28 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
         ui16 grpc = server.GetPort();
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
 
-        auto client = NYdb::NTable::TTableClient(connection);
+        auto client = NYdb::NTable::TTableClient(connection); 
         bool done = false;
 
-        std::function<void(const TAsyncCreateSessionResult& future)> createSessionHandler =
-            [client, &done] (const TAsyncCreateSessionResult& future) mutable {
+        std::function<void(const TAsyncCreateSessionResult& future)> createSessionHandler = 
+            [client, &done] (const TAsyncCreateSessionResult& future) mutable { 
                 const auto& sessionValue = future.GetValue();
                 UNIT_ASSERT(!sessionValue.IsTransportError());
                 UNIT_ASSERT_EQUAL(sessionValue.GetStatus(), EStatus::SUCCESS);
                 auto session = sessionValue.GetSession();
 
                 auto schemeQueryHandler =
-                    [session, &done] (const NYdb::TAsyncStatus& future) mutable {
+                    [session, &done] (const NYdb::TAsyncStatus& future) mutable { 
                         const auto& schemeQueryResult = future.GetValue();
                         UNIT_ASSERT(!schemeQueryResult.IsTransportError());
                         UNIT_ASSERT_EQUAL(schemeQueryResult.GetStatus(), EStatus::SUCCESS);
 
                         auto sqlResultHandler =
-                            [&done] (const TAsyncExplainDataQueryResult& future) mutable {
+                            [&done] (const TAsyncExplainDataQueryResult& future) mutable { 
                                 const auto& explainResult = future.GetValue();
                                 UNIT_ASSERT(!explainResult.IsTransportError());
                                 Cerr << explainResult.GetIssues().ToString() << Endl;
@@ -667,24 +667,24 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
         ui16 grpc = server.GetPort();
         TString location = TStringBuilder() << "localhost:" << grpc;
 
-        auto connection = NYdb::TDriver(
-            TDriverConfig()
+        auto connection = NYdb::TDriver( 
+            TDriverConfig() 
                 .SetEndpoint(location));
         {
 
-            auto asyncStatus = NYdb::NScheme::TSchemeClient(connection).MakeDirectory("/Root/TheDir");
+            auto asyncStatus = NYdb::NScheme::TSchemeClient(connection).MakeDirectory("/Root/TheDir"); 
             asyncStatus.Wait();
             UNIT_ASSERT_EQUAL(asyncStatus.GetValue().GetStatus(), EStatus::SUCCESS);
         }
         {
-            auto asyncDescPath = NYdb::NScheme::TSchemeClient(connection).DescribePath("/Root/TheDir");
+            auto asyncDescPath = NYdb::NScheme::TSchemeClient(connection).DescribePath("/Root/TheDir"); 
             asyncDescPath.Wait();
             auto entry = asyncDescPath.GetValue().GetEntry();
             UNIT_ASSERT_EQUAL(entry.Name, "TheDir");
             UNIT_ASSERT_EQUAL(entry.Type, ESchemeEntryType::Directory);
         }
         {
-            auto asyncDescDir = NYdb::NScheme::TSchemeClient(connection).ListDirectory("/Root");
+            auto asyncDescDir = NYdb::NScheme::TSchemeClient(connection).ListDirectory("/Root"); 
             asyncDescDir.Wait();
             const auto& val = asyncDescDir.GetValue();
             auto entry = val.GetEntry();
@@ -697,11 +697,11 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
 
         }
 
-        auto client = NYdb::NTable::TTableClient(connection);
+        auto client = NYdb::NTable::TTableClient(connection); 
         bool done = false;
 
-        std::function<void(const TAsyncCreateSessionResult& future)> createSessionHandler =
-            [client, &done] (const TAsyncCreateSessionResult& future) mutable {
+        std::function<void(const TAsyncCreateSessionResult& future)> createSessionHandler = 
+            [client, &done] (const TAsyncCreateSessionResult& future) mutable { 
                 const auto& sessionValue = future.GetValue();
                 UNIT_ASSERT(!sessionValue.IsTransportError());
                 auto session = sessionValue.GetSession();
@@ -716,12 +716,12 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
                                 UNIT_ASSERT(!alterStatus.IsTransportError());
                                 UNIT_ASSERT_EQUAL(alterStatus.GetStatus(), EStatus::SUCCESS);
                                 auto upsertHandler =
-                                    [session, &done] (const TAsyncDataQueryResult& future) mutable {
+                                    [session, &done] (const TAsyncDataQueryResult& future) mutable { 
                                         const auto& sqlResultSets = future.GetValue();
                                         UNIT_ASSERT(!sqlResultSets.IsTransportError());
                                         UNIT_ASSERT_EQUAL(sqlResultSets.GetStatus(), EStatus::SUCCESS);
                                         auto describeHandler =
-                                            [session, &done] (const TAsyncDescribeTableResult& future) mutable {
+                                            [session, &done] (const TAsyncDescribeTableResult& future) mutable { 
                                                 const auto& value = future.GetValue();
                                                 UNIT_ASSERT(!value.IsTransportError());
                                                 UNIT_ASSERT_EQUAL(value.GetStatus(), EStatus::SUCCESS);
@@ -732,18 +732,18 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
                                                 UNIT_ASSERT_EQUAL(columns[0].Name, "Key");
                                                 UNIT_ASSERT_EQUAL(columns[1].Name, "Value");
                                                 UNIT_ASSERT_EQUAL(columns[2].Name, "NewColumn");
-                                                TTypeParser column0(columns[0].Type);
-                                                TTypeParser column1(columns[1].Type);
-                                                TTypeParser column2(columns[2].Type);
-                                                UNIT_ASSERT_EQUAL(column0.GetKind(), TTypeParser::ETypeKind::Optional);
-                                                UNIT_ASSERT_EQUAL(column1.GetKind(), TTypeParser::ETypeKind::Optional);
-                                                UNIT_ASSERT_EQUAL(column2.GetKind(), TTypeParser::ETypeKind::Optional);
-                                                column0.OpenOptional();
-                                                column1.OpenOptional();
-                                                column2.OpenOptional();
-                                                UNIT_ASSERT_EQUAL(column0.GetPrimitive(), EPrimitiveType::Int32);
-                                                UNIT_ASSERT_EQUAL(column1.GetPrimitive(), EPrimitiveType::String);
-                                                UNIT_ASSERT_EQUAL(column2.GetPrimitive(), EPrimitiveType::Utf8);
+                                                TTypeParser column0(columns[0].Type); 
+                                                TTypeParser column1(columns[1].Type); 
+                                                TTypeParser column2(columns[2].Type); 
+                                                UNIT_ASSERT_EQUAL(column0.GetKind(), TTypeParser::ETypeKind::Optional); 
+                                                UNIT_ASSERT_EQUAL(column1.GetKind(), TTypeParser::ETypeKind::Optional); 
+                                                UNIT_ASSERT_EQUAL(column2.GetKind(), TTypeParser::ETypeKind::Optional); 
+                                                column0.OpenOptional(); 
+                                                column1.OpenOptional(); 
+                                                column2.OpenOptional(); 
+                                                UNIT_ASSERT_EQUAL(column0.GetPrimitive(), EPrimitiveType::Int32); 
+                                                UNIT_ASSERT_EQUAL(column1.GetPrimitive(), EPrimitiveType::String); 
+                                                UNIT_ASSERT_EQUAL(column2.GetPrimitive(), EPrimitiveType::Utf8); 
                                                 UNIT_ASSERT_EQUAL( desc.GetOwner(), "root@builtin");
                                                 auto dropHandler =
                                                     [&done] (const NThreading::TFuture<TStatus>& future) mutable {
@@ -761,27 +761,27 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
                                                                             };
                                 const TString sql = "UPSERT INTO [Root/TheDir/FooTable] (Key, Value, NewColumn)"
                                    " VALUES (1, \"One\", \"йцукен\")";
-                                session.ExecuteDataQuery(sql, TTxControl::
-                                    BeginTx(TTxSettings::SerializableRW()).CommitTx()
+                                session.ExecuteDataQuery(sql, TTxControl:: 
+                                    BeginTx(TTxSettings::SerializableRW()).CommitTx() 
                                 ).Apply(upsertHandler).Wait();
                             };
 
                         {
-                            auto type = TTypeBuilder()
-                                    .BeginOptional()
-                                        .Primitive(EPrimitiveType::Utf8)
-                                    .EndOptional()
-                                    .Build();
-
-                            session.AlterTable("/Root/TheDir/FooTable", TAlterTableSettings()
+                            auto type = TTypeBuilder() 
+                                    .BeginOptional() 
+                                        .Primitive(EPrimitiveType::Utf8) 
+                                    .EndOptional() 
+                                    .Build(); 
+ 
+                            session.AlterTable("/Root/TheDir/FooTable", TAlterTableSettings() 
                                 .AppendAddColumns(TColumn{"NewColumn", type})).Apply(alterResultHandler).Wait();
                         }
                     };
 
                 auto tableBuilder = client.GetTableBuilder();
-                tableBuilder
-                    .AddNullableColumn("Key", EPrimitiveType::Int32)
-                    .AddNullableColumn("Value", EPrimitiveType::String);
+                tableBuilder 
+                    .AddNullableColumn("Key", EPrimitiveType::Int32) 
+                    .AddNullableColumn("Value", EPrimitiveType::String); 
                 tableBuilder.SetPrimaryKeyColumn("Key");
                 session.CreateTable("/Root/TheDir/FooTable", tableBuilder.Build()).Apply(createTableHandler).Wait();
             };
@@ -791,23 +791,23 @@ Y_UNIT_TEST_SUITE(TGRpcNewClient) {
     }
 }
 
-static TString CreateSession(std::shared_ptr<grpc::Channel> channel) {
-    std::unique_ptr<Ydb::Table::V1::TableService::Stub> stub;
-    stub = Ydb::Table::V1::TableService::NewStub(channel);
-    grpc::ClientContext context;
-    Ydb::Table::CreateSessionRequest request;
-    Ydb::Table::CreateSessionResponse response;
-
-    auto status = stub->CreateSession(&context, request, &response);
-    auto deferred = response.operation();
-    UNIT_ASSERT(status.ok());
-    UNIT_ASSERT(deferred.ready() == true);
-    Ydb::Table::CreateSessionResult result;
-
-    deferred.result().UnpackTo(&result);
-    return result.session_id();
-}
-
+static TString CreateSession(std::shared_ptr<grpc::Channel> channel) { 
+    std::unique_ptr<Ydb::Table::V1::TableService::Stub> stub; 
+    stub = Ydb::Table::V1::TableService::NewStub(channel); 
+    grpc::ClientContext context; 
+    Ydb::Table::CreateSessionRequest request; 
+    Ydb::Table::CreateSessionResponse response; 
+ 
+    auto status = stub->CreateSession(&context, request, &response); 
+    auto deferred = response.operation(); 
+    UNIT_ASSERT(status.ok()); 
+    UNIT_ASSERT(deferred.ready() == true); 
+    Ydb::Table::CreateSessionResult result; 
+ 
+    deferred.result().UnpackTo(&result); 
+    return result.session_id(); 
+} 
+ 
 void IncorrectConnectionStringPending(const TString& incorrectLocation) {
     auto connection = NYdb::TDriver(incorrectLocation);
     auto client = NYdb::NTable::TTableClient(connection);
@@ -881,7 +881,7 @@ Y_UNIT_TEST_SUITE(TGRpcYdbTest) {
             auto deferred = response.operation();
             UNIT_ASSERT(status.ok());  //GRpc layer - OK
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SCHEME_ERROR);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SCHEME_ERROR); 
             NYql::TIssues issues;
             NYql::IssuesFromMessage(deferred.issues(), issues);
             TString tmp = issues.ToString();
@@ -917,7 +917,7 @@ Y_UNIT_TEST_SUITE(TGRpcYdbTest) {
         /*
         {
             auto status = WaitForStatus(Channel_, id);
-            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS); 
         }
         */
         {
@@ -983,7 +983,7 @@ Y_UNIT_TEST_SUITE(TGRpcYdbTest) {
         /*
         {
             auto status = WaitForStatus(Channel_, id);
-            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS); 
         }
         */
     }
@@ -1025,7 +1025,7 @@ Y_UNIT_TEST_SUITE(TGRpcYdbTest) {
         Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials());
         {
             auto status = WaitForStatus(Channel_, "ydb://operation/1?txid=42&sstid=66");
-            UNIT_ASSERT(status == Ydb::StatusIds::BAD_REQUEST);
+            UNIT_ASSERT(status == Ydb::StatusIds::BAD_REQUEST); 
         }
     }
 */
@@ -1045,7 +1045,7 @@ Y_UNIT_TEST_SUITE(TGRpcYdbTest) {
         auto deferred = response.operation();
         UNIT_ASSERT(status.ok()); //GRpc layer - OK
         UNIT_ASSERT(deferred.ready() == true); //Ready to get status
-        UNIT_ASSERT(deferred.status() == Ydb::StatusIds::BAD_REQUEST); //But with error
+        UNIT_ASSERT(deferred.status() == Ydb::StatusIds::BAD_REQUEST); //But with error 
     }
 
     static void CreateTableBadRequest(const TString& scheme,
@@ -1120,7 +1120,7 @@ Y_UNIT_TEST_SUITE(TGRpcYdbTest) {
             auto deferred = response.operation();
             UNIT_ASSERT(status.ok()); //GRpc layer - OK
             UNIT_ASSERT(deferred.ready() == true); //Ready to get status
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::BAD_REQUEST); //But with error
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::BAD_REQUEST); //But with error 
         }
         {
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
@@ -1137,7 +1137,7 @@ Y_UNIT_TEST_SUITE(TGRpcYdbTest) {
             auto deferred = response.operation();
             UNIT_ASSERT(status.ok()); //GRpc layer - OK
             UNIT_ASSERT(deferred.ready() == true); //Ready to get status
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SCHEME_ERROR); //But with error
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SCHEME_ERROR); //But with error 
         }
 
     }
@@ -1218,7 +1218,7 @@ Y_UNIT_TEST_SUITE(TGRpcYdbTest) {
         /*
         {
             auto status = WaitForStatus(Channel_, id);
-            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS); 
         }
         */
         {
@@ -1320,7 +1320,7 @@ partitioning_settings {
         /*
         {
             auto status = WaitForStatus(Channel_, id);
-            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS); 
         }
         */
         id.clear();
@@ -1343,7 +1343,7 @@ partitioning_settings {
         /*
         {
             auto status = WaitForStatus(Channel_, id);
-            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS); 
         }
         */
         id.clear();
@@ -1396,7 +1396,7 @@ partitioning_settings {
         /*
         {
             auto status = WaitForStatus(Channel_, id);
-            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS); 
         }
         */
     }
@@ -1697,8 +1697,8 @@ partitioning_settings {
 
         std::shared_ptr<grpc::Channel> Channel_;
         Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials());
-
-        TString sessionId;
+ 
+        TString sessionId; 
         {
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
@@ -1706,28 +1706,28 @@ partitioning_settings {
             Ydb::Table::CreateSessionRequest request;
             Ydb::Table::CreateSessionResponse response;
 
-            auto status = Stub_->CreateSession(&context, request, &response);
+            auto status = Stub_->CreateSession(&context, request, &response); 
             auto deferred = response.operation();
-            UNIT_ASSERT(status.ok());
-            UNIT_ASSERT(deferred.ready() == true);
+            UNIT_ASSERT(status.ok()); 
+            UNIT_ASSERT(deferred.ready() == true); 
             Ydb::Table::CreateSessionResult result;
-
-            deferred.result().UnpackTo(&result);
-            sessionId = result.session_id();
-        }
-
-        {
+ 
+            deferred.result().UnpackTo(&result); 
+            sessionId = result.session_id(); 
+        } 
+ 
+        { 
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
+            grpc::ClientContext context; 
             Ydb::Table::ExecuteDataQueryRequest request;
-            request.set_session_id(sessionId);
+            request.set_session_id(sessionId); 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             auto deferred = response.operation();
             UNIT_ASSERT(status.ok());  //GRpc layer - OK
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT_VALUES_EQUAL(deferred.status(), Ydb::StatusIds::BAD_REQUEST);
+            UNIT_ASSERT_VALUES_EQUAL(deferred.status(), Ydb::StatusIds::BAD_REQUEST); 
         }
     }
 
@@ -1742,13 +1742,13 @@ partitioning_settings {
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
             grpc::ClientContext context;
             Ydb::Table::ExecuteDataQueryRequest request;
-            request.mutable_query()->set_yql_text("SELECT 1 as a, 'qwerty' as b, 43.5 as c UNION ALL SELECT 11 as a, 'asdfgg' as b, Null as c;");
+            request.mutable_query()->set_yql_text("SELECT 1 as a, 'qwerty' as b, 43.5 as c UNION ALL SELECT 11 as a, 'asdfgg' as b, Null as c;"); 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::BAD_REQUEST);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::BAD_REQUEST); 
         }
     }
 
@@ -1787,7 +1787,7 @@ partitioning_settings {
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
         }
 
         {
@@ -1796,15 +1796,15 @@ partitioning_settings {
             grpc::ClientContext context;
             Ydb::Table::ExecuteDataQueryRequest request;
             request.set_session_id(sessionId);
-            request.mutable_query()->set_yql_text("SELECT 1 as a, 'qwerty' as b, 43.5 as c UNION ALL SELECT 11 as a, 'asdfgg' as b, Null as c;");
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
+            request.mutable_query()->set_yql_text("SELECT 1 as a, 'qwerty' as b, 43.5 as c UNION ALL SELECT 11 as a, 'asdfgg' as b, Null as c;"); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
 
             Ydb::Table::ExecuteQueryResult result;
             deferred.result().UnpackTo(&result);
@@ -1813,19 +1813,19 @@ partitioning_settings {
                 google::protobuf::TextFormat::PrintToString(result, &tmp);
                 const TString expected =
                     "result_sets {\n"
-                    "  columns {\n"
+                    "  columns {\n" 
                     "    name: \"a\"\n"
                     "    type {\n"
                     "      type_id: INT32\n"
                     "    }\n"
                     "  }\n"
-                    "  columns {\n"
+                    "  columns {\n" 
                     "    name: \"b\"\n"
                     "    type {\n"
                     "      type_id: STRING\n"
                     "    }\n"
                     "  }\n"
-                    "  columns {\n"
+                    "  columns {\n" 
                     "    name: \"c\"\n"
                     "    type {\n"
                     "      optional_type {\n"
@@ -1857,28 +1857,28 @@ partitioning_settings {
                     "      null_flag_value: NULL_VALUE\n"
                     "    }\n"
                     "  }\n"
-                    "}\n"
-                    "tx_meta {\n"
+                    "}\n" 
+                    "tx_meta {\n" 
                     "}\n";
                 UNIT_ASSERT_NO_DIFF(tmp, expected);
-                TResultSet resultSet(result.result_sets(0));
-                UNIT_ASSERT_EQUAL(resultSet.ColumnsCount(), 3);
-
+                TResultSet resultSet(result.result_sets(0)); 
+                UNIT_ASSERT_EQUAL(resultSet.ColumnsCount(), 3); 
+ 
                 int row = 0;
-                TResultSetParser rsParser(resultSet);
-                while (rsParser.TryNextRow()) {
+                TResultSetParser rsParser(resultSet); 
+                while (rsParser.TryNextRow()) { 
                     switch (row) {
                         case 0: {
-                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetInt32(), 1);
-                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(1).GetString(), "qwerty");
-                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(2).GetOptionalDouble(), 43.5);
+                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetInt32(), 1); 
+                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(1).GetString(), "qwerty"); 
+                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(2).GetOptionalDouble(), 43.5); 
                         }
                         break;
                         case 1: {
-                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetInt32(), 11);
-                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(1).GetString(), "asdfgg");
-                            rsParser.ColumnParser(2).OpenOptional();
-                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(2).IsNull(), true);
+                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(0).GetInt32(), 11); 
+                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(1).GetString(), "asdfgg"); 
+                            rsParser.ColumnParser(2).OpenOptional(); 
+                            UNIT_ASSERT_EQUAL(rsParser.ColumnParser(2).IsNull(), true); 
                         }
                         break;
                         default: {
@@ -1934,7 +1934,7 @@ partitioning_settings {
             deferred.result().UnpackTo(&result);
             {
                 TString expected = R"___(result_sets {
-  columns {
+  columns { 
     name: "column0"
     type {
       optional_type {
@@ -1984,73 +1984,73 @@ tx_meta {
             deferred.result().UnpackTo(&result);
             sessionId = result.session_id();
         }
-
+ 
         std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
         Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-        Ydb::Table::ExecuteDataQueryRequest request;
-        request.set_session_id(sessionId);
-        request.mutable_query()->set_yql_text("DECLARE $param1 AS \"Tuple<Int32,Bool>\"; SELECT $param1 AS Tuple;");
-        request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-        request.mutable_tx_control()->set_commit_tx(true);
-
-        {
-            // Bad type Kind
+        Ydb::Table::ExecuteDataQueryRequest request; 
+        request.set_session_id(sessionId); 
+        request.mutable_query()->set_yql_text("DECLARE $param1 AS \"Tuple<Int32,Bool>\"; SELECT $param1 AS Tuple;"); 
+        request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+        request.mutable_tx_control()->set_commit_tx(true); 
+ 
+        {
+            // Bad type Kind 
             ::google::protobuf::Map<TString, Ydb::TypedValue> parameters;
-
-            const TString type = R"(
-                type_id: TYPE_UNDEFINED
-            )";
-            google::protobuf::TextFormat::ParseFromString(type, parameters["$param1"].mutable_type());
-
-            const TString value = R"(
-                int32_value: 10
-            )";
-            google::protobuf::TextFormat::ParseFromString(value, parameters["$param1"].mutable_value());
-
-            *request.mutable_parameters() = parameters;
-            Ydb::Table::ExecuteDataQueryResponse response;
+ 
+            const TString type = R"( 
+                type_id: TYPE_UNDEFINED 
+            )"; 
+            google::protobuf::TextFormat::ParseFromString(type, parameters["$param1"].mutable_type()); 
+ 
+            const TString value = R"( 
+                int32_value: 10 
+            )"; 
+            google::protobuf::TextFormat::ParseFromString(value, parameters["$param1"].mutable_value()); 
+ 
+            *request.mutable_parameters() = parameters; 
+            Ydb::Table::ExecuteDataQueryResponse response; 
             grpc::ClientContext context;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
-            auto deferred = response.operation();
-            UNIT_ASSERT(deferred.ready() == true);
-            NYql::TIssues issues;
-            NYql::IssuesFromMessage(deferred.issues(), issues);
-            issues.PrintTo(Cerr);
-            UNIT_ASSERT_VALUES_EQUAL(deferred.status(), Ydb::StatusIds::BAD_REQUEST);
-        }
-
-        {
-            // Value mismatch
+            auto deferred = response.operation(); 
+            UNIT_ASSERT(deferred.ready() == true); 
+            NYql::TIssues issues; 
+            NYql::IssuesFromMessage(deferred.issues(), issues); 
+            issues.PrintTo(Cerr); 
+            UNIT_ASSERT_VALUES_EQUAL(deferred.status(), Ydb::StatusIds::BAD_REQUEST); 
+        } 
+
+        { 
+            // Value mismatch 
             ::google::protobuf::Map<TString, Ydb::TypedValue> parameters;
-
-            const TString type = R"(
-                tuple_type {
-                    elements {
-                        type_id: Int32
-                    }
-                    elements {
-                        type_id: Bool
-                    }
-                }
-            )";
-            google::protobuf::TextFormat::ParseFromString(type, parameters["$param1"].mutable_type());
-
-            const TString value = R"(
-                int32_value: 10
-            )";
-            google::protobuf::TextFormat::ParseFromString(value, parameters["$param1"].mutable_value());
-
-            *request.mutable_parameters() = parameters;
+ 
+            const TString type = R"( 
+                tuple_type { 
+                    elements { 
+                        type_id: Int32 
+                    } 
+                    elements { 
+                        type_id: Bool 
+                    } 
+                } 
+            )"; 
+            google::protobuf::TextFormat::ParseFromString(type, parameters["$param1"].mutable_type()); 
+ 
+            const TString value = R"( 
+                int32_value: 10 
+            )"; 
+            google::protobuf::TextFormat::ParseFromString(value, parameters["$param1"].mutable_value()); 
+ 
+            *request.mutable_parameters() = parameters; 
             Ydb::Table::ExecuteDataQueryResponse response;
-            grpc::ClientContext context;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            grpc::ClientContext context; 
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            NYql::TIssues issues;
-            NYql::IssuesFromMessage(deferred.issues(), issues);
-            issues.PrintTo(Cerr);
+            NYql::TIssues issues; 
+            NYql::IssuesFromMessage(deferred.issues(), issues); 
+            issues.PrintTo(Cerr); 
             UNIT_ASSERT_VALUES_EQUAL(deferred.status(), Ydb::StatusIds::BAD_REQUEST);
         }
     }
@@ -2083,9 +2083,9 @@ tx_meta {
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
             grpc::ClientContext context;
             Ydb::Table::ExecuteDataQueryRequest request;
-            request.mutable_query()->set_yql_text("DECLARE $paramName AS String; SELECT $paramName;");
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
+            request.mutable_query()->set_yql_text("DECLARE $paramName AS String; SELECT $paramName;"); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
             Ydb::TypedValue parameter;
             {
                 const TString type =
@@ -2101,16 +2101,16 @@ tx_meta {
                 TString tmp;
                 google::protobuf::TextFormat::PrintToString(request, &tmp);
                 const TString expected =
-                    "tx_control {\n"
-                    "  begin_tx {\n"
-                    "    serializable_read_write {\n"
-                    "    }\n"
-                    "  }\n"
-                    "  commit_tx: true\n"
-                    "}\n"
-                    "query {\n"
-                    "  yql_text: \"DECLARE $paramName AS String; SELECT $paramName;\"\n"
-                    "}\n"
+                    "tx_control {\n" 
+                    "  begin_tx {\n" 
+                    "    serializable_read_write {\n" 
+                    "    }\n" 
+                    "  }\n" 
+                    "  commit_tx: true\n" 
+                    "}\n" 
+                    "query {\n" 
+                    "  yql_text: \"DECLARE $paramName AS String; SELECT $paramName;\"\n" 
+                    "}\n" 
                     "parameters {\n"
                     "  key: \"$paramName\"\n"
                     "  value {\n"
@@ -2126,11 +2126,11 @@ tx_meta {
             }
             request.set_session_id(sessionId);
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
 
             Ydb::Table::ExecuteQueryResult result;
             deferred.result().UnpackTo(&result);
@@ -2139,7 +2139,7 @@ tx_meta {
                 google::protobuf::TextFormat::PrintToString(result, &tmp);
                 const TString expected =
                     "result_sets {\n"
-                    "  columns {\n"
+                    "  columns {\n" 
                     "    name: \"column0\"\n"
                     "    type {\n"
                     "      type_id: STRING\n"
@@ -2150,8 +2150,8 @@ tx_meta {
                     "      bytes_value: \"Paul\"\n"
                     "    }\n"
                     "  }\n"
-                    "}\n"
-                    "tx_meta {\n"
+                    "}\n" 
+                    "tx_meta {\n" 
                     "}\n";
                 UNIT_ASSERT_NO_DIFF(tmp, expected);
             }
@@ -2191,7 +2191,7 @@ tx_meta {
                 TString tmp;
                 google::protobuf::TextFormat::PrintToString(result, &tmp);
                 const TString expected = R"___(result_sets {
-  columns {
+  columns { 
     name: "column0"
     type {
       type_id: UUID
@@ -2214,198 +2214,198 @@ tx_meta {
     }
 
     Y_UNIT_TEST(ExecuteDmlQuery) {
-        TKikimrWithGrpcAndRootSchema server;
-        ui16 grpc = server.GetPort();
-
-        std::shared_ptr<grpc::Channel> Channel_;
-        Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials());
-
-        TString sessionId;
-        {
+        TKikimrWithGrpcAndRootSchema server; 
+        ui16 grpc = server.GetPort(); 
+
+        std::shared_ptr<grpc::Channel> Channel_; 
+        Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials()); 
+ 
+        TString sessionId; 
+        { 
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
+            grpc::ClientContext context; 
             Ydb::Table::CreateSessionRequest request;
             Ydb::Table::CreateSessionResponse response;
-
-            auto status = Stub_->CreateSession(&context, request, &response);
+ 
+            auto status = Stub_->CreateSession(&context, request, &response); 
             auto deferred = response.operation();
-            UNIT_ASSERT(status.ok());
-            UNIT_ASSERT(deferred.ready() == true);
+            UNIT_ASSERT(status.ok()); 
+            UNIT_ASSERT(deferred.ready() == true); 
             Ydb::Table::CreateSessionResult result;
-
-            deferred.result().UnpackTo(&result);
-            sessionId = result.session_id();
-        }
-
-        {
+ 
+            deferred.result().UnpackTo(&result); 
+            sessionId = result.session_id(); 
+        } 
+ 
+        { 
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
-
+            grpc::ClientContext context; 
+ 
             Ydb::Table::ExecuteSchemeQueryRequest request;
-            request.set_session_id(sessionId);
-            request.set_yql_text(R"(
-                CREATE TABLE [Root/TheTable] (
+            request.set_session_id(sessionId); 
+            request.set_yql_text(R"( 
+                CREATE TABLE [Root/TheTable] ( 
                     Key UINT64,
                     Value UTF8,
-                    PRIMARY KEY (Key)
-                );
-            )");
-
+                    PRIMARY KEY (Key) 
+                ); 
+            )"); 
+ 
             Ydb::Table::ExecuteSchemeQueryResponse response;
-            auto status = Stub_->ExecuteSchemeQuery(&context, request, &response);
+            auto status = Stub_->ExecuteSchemeQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
-
-            UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
-        }
-
-        {
+ 
+            UNIT_ASSERT(deferred.ready() == true); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
+        } 
+ 
+        { 
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
-
+            grpc::ClientContext context; 
+ 
             Ydb::Table::ExplainDataQueryRequest request;
-            request.set_session_id(sessionId);
-            request.set_yql_text(R"(
-                UPSERT INTO [Root/TheTable] (Key, Value)
-                VALUES (1, "One");
-            )");
-
+            request.set_session_id(sessionId); 
+            request.set_yql_text(R"( 
+                UPSERT INTO [Root/TheTable] (Key, Value) 
+                VALUES (1, "One"); 
+            )"); 
+ 
             Ydb::Table::ExplainDataQueryResponse response;
-            auto status = Stub_->ExplainDataQuery(&context, request, &response);
+            auto status = Stub_->ExplainDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
-
-            UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
-        }
-
-        TString txId;
-        {
+ 
+            UNIT_ASSERT(deferred.ready() == true); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
+        } 
+ 
+        TString txId; 
+        { 
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
-
+            grpc::ClientContext context; 
+ 
             Ydb::Table::ExecuteDataQueryRequest request;
-            request.set_session_id(sessionId);
-            request.mutable_query()->set_yql_text(R"(
-                UPSERT INTO [Root/TheTable] (Key, Value)
-                VALUES (1, "One");
-            )");
-
-            auto& txControl = *request.mutable_tx_control();
-            txControl.mutable_begin_tx()->mutable_serializable_read_write();
-
+            request.set_session_id(sessionId); 
+            request.mutable_query()->set_yql_text(R"( 
+                UPSERT INTO [Root/TheTable] (Key, Value) 
+                VALUES (1, "One"); 
+            )"); 
+ 
+            auto& txControl = *request.mutable_tx_control(); 
+            txControl.mutable_begin_tx()->mutable_serializable_read_write(); 
+ 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
-
-            UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
-
+ 
+            UNIT_ASSERT(deferred.ready() == true); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
+ 
             Ydb::Table::ExecuteQueryResult result;
-            deferred.result().UnpackTo(&result);
-
-            txId = result.tx_meta().id();
-            UNIT_ASSERT(!txId.empty());
-        }
-
-        {
+            deferred.result().UnpackTo(&result); 
+ 
+            txId = result.tx_meta().id(); 
+            UNIT_ASSERT(!txId.empty()); 
+        } 
+ 
+        { 
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
-
+            grpc::ClientContext context; 
+ 
             Ydb::Table::ExecuteDataQueryRequest request;
-            request.set_session_id(sessionId);
-            request.mutable_query()->set_yql_text(R"(
-                UPSERT INTO [Root/TheTable] (Key, Value)
-                VALUES (2, "Two");
-            )");
-
-            auto& txControl = *request.mutable_tx_control();
-            txControl.set_tx_id(txId);
-            txControl.set_commit_tx(true);
-
+            request.set_session_id(sessionId); 
+            request.mutable_query()->set_yql_text(R"( 
+                UPSERT INTO [Root/TheTable] (Key, Value) 
+                VALUES (2, "Two"); 
+            )"); 
+ 
+            auto& txControl = *request.mutable_tx_control(); 
+            txControl.set_tx_id(txId); 
+            txControl.set_commit_tx(true); 
+ 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
-
-            UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
-        }
-
-        TString queryId;
-        {
+ 
+            UNIT_ASSERT(deferred.ready() == true); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
+        } 
+ 
+        TString queryId; 
+        { 
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
-
+            grpc::ClientContext context; 
+ 
             Ydb::Table::PrepareDataQueryRequest request;
-            request.set_session_id(sessionId);
-            request.set_yql_text(R"(
-                DECLARE $Key AS Uint64;
-                SELECT * FROM [Root/TheTable] WHERE Key < $Key;
-            )");
-
+            request.set_session_id(sessionId); 
+            request.set_yql_text(R"( 
+                DECLARE $Key AS Uint64; 
+                SELECT * FROM [Root/TheTable] WHERE Key < $Key; 
+            )"); 
+ 
             Ydb::Table::PrepareDataQueryResponse response;
-            auto status = Stub_->PrepareDataQuery(&context, request, &response);
-            UNIT_ASSERT(status.ok());
-
+            auto status = Stub_->PrepareDataQuery(&context, request, &response); 
+            UNIT_ASSERT(status.ok()); 
+ 
             auto deferred = response.operation();
-            UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
-
+            UNIT_ASSERT(deferred.ready() == true); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
+ 
             Ydb::Table::PrepareQueryResult result;
-            deferred.result().UnpackTo(&result);
-            queryId = result.query_id();
-        }
-
-        {
+            deferred.result().UnpackTo(&result); 
+            queryId = result.query_id(); 
+        } 
+ 
+        { 
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
             Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
-
+            grpc::ClientContext context; 
+ 
             Ydb::Table::ExecuteDataQueryRequest request;
-            request.set_session_id(sessionId);
-            request.mutable_query()->set_id(queryId);
-
-            auto& txControl = *request.mutable_tx_control();
-            txControl.mutable_begin_tx()->mutable_online_read_only();
-            txControl.set_commit_tx(true);
-
+            request.set_session_id(sessionId); 
+            request.mutable_query()->set_id(queryId); 
+ 
+            auto& txControl = *request.mutable_tx_control(); 
+            txControl.mutable_begin_tx()->mutable_online_read_only(); 
+            txControl.set_commit_tx(true); 
+ 
             Ydb::TypedValue parameter;
-            {
-                const TString type =
+            { 
+                const TString type = 
                     "type_id: UINT64\n";
-                google::protobuf::TextFormat::ParseFromString(type, parameter.mutable_type());
-                const TString value = "uint64_value: 5\n";
-                google::protobuf::TextFormat::ParseFromString(value, parameter.mutable_value());
-            }
-
-            auto& map = *request.mutable_parameters();
-            map["$Key"] = parameter;
-
+                google::protobuf::TextFormat::ParseFromString(type, parameter.mutable_type()); 
+                const TString value = "uint64_value: 5\n"; 
+                google::protobuf::TextFormat::ParseFromString(value, parameter.mutable_value()); 
+            } 
+ 
+            auto& map = *request.mutable_parameters(); 
+            map["$Key"] = parameter; 
+ 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
-
-            UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
-
+ 
+            UNIT_ASSERT(deferred.ready() == true); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
+ 
             Ydb::Table::ExecuteQueryResult result;
-            deferred.result().UnpackTo(&result);
-
-            UNIT_ASSERT(result.tx_meta().id().empty());
-            UNIT_ASSERT_VALUES_EQUAL(result.result_sets(0).rows_size(), 2);
-        }
-    }
-
+            deferred.result().UnpackTo(&result); 
+ 
+            UNIT_ASSERT(result.tx_meta().id().empty()); 
+            UNIT_ASSERT_VALUES_EQUAL(result.result_sets(0).rows_size(), 2); 
+        } 
+    } 
+ 
     Y_UNIT_TEST(CreateYqlSessionExecuteQuery) {
         TKikimrWithGrpcAndRootSchema server;
         ui16 grpc = server.GetPort();
@@ -2435,11 +2435,11 @@ tx_meta {
             grpc::ClientContext context;
             Ydb::Table::ExecuteDataQueryRequest request;
             request.set_session_id(sessionId);
-            request.mutable_query()->set_yql_text("SELECT 1, \"qq\"; SELECT 2;");
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
+            request.mutable_query()->set_yql_text("SELECT 1, \"qq\"; SELECT 2;"); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             auto deferred = response.operation();
             UNIT_ASSERT(status.ok());
             UNIT_ASSERT(deferred.ready() == true);
@@ -2450,22 +2450,22 @@ tx_meta {
             grpc::ClientContext context;
             Ydb::Table::ExecuteDataQueryRequest request;
             request.set_session_id(sessionId);
-            request.mutable_query()->set_yql_text("SELECT * from [Root/NotFound]");
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
+            request.mutable_query()->set_yql_text("SELECT * from [Root/NotFound]"); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             auto deferred = response.operation();
             UNIT_ASSERT(status.ok());
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SCHEME_ERROR);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SCHEME_ERROR); 
             NYql::TIssues issues;
             NYql::IssuesFromMessage(deferred.issues(), issues);
-            UNIT_ASSERT(HasIssue(issues, NYql::TIssuesIds::KIKIMR_SCHEME_ERROR));
+            UNIT_ASSERT(HasIssue(issues, NYql::TIssuesIds::KIKIMR_SCHEME_ERROR)); 
         }
 
     }
-
+ 
     Y_UNIT_TEST(ExecutePreparedQuery) {
         TKikimrWithGrpcAndRootSchema server;
         ui16 grpc = server.GetPort();
@@ -2495,13 +2495,13 @@ tx_meta {
             grpc::ClientContext context;
             Ydb::Table::PrepareDataQueryRequest request;
             request.set_session_id(sessionId);
-            request.set_yql_text("DECLARE $paramName AS String; SELECT $paramName;");
+            request.set_yql_text("DECLARE $paramName AS String; SELECT $paramName;"); 
             Ydb::Table::PrepareDataQueryResponse response;
-            auto status = Stub_->PrepareDataQuery(&context, request, &response);
+            auto status = Stub_->PrepareDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
             Ydb::Table::PrepareQueryResult result;
 
             deferred.result().UnpackTo(&result);
@@ -2513,9 +2513,9 @@ tx_meta {
             grpc::ClientContext context;
             Ydb::Table::ExecuteDataQueryRequest request;
             request.set_session_id(sessionId);
-            request.mutable_query()->set_id(preparedQueryId);
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
+            request.mutable_query()->set_id(preparedQueryId); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
             Ydb::TypedValue parameter;
             {
                 const TString type =
@@ -2529,11 +2529,11 @@ tx_meta {
             map["$paramName"] = parameter;
 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
             Ydb::Table::ExecuteQueryResult result;
             deferred.result().UnpackTo(&result);
             {
@@ -2541,7 +2541,7 @@ tx_meta {
                 google::protobuf::TextFormat::PrintToString(result, &tmp);
                 const TString expected =
                     "result_sets {\n"
-                    "  columns {\n"
+                    "  columns {\n" 
                     "    name: \"column0\"\n"
                     "    type {\n"
                     "      type_id: STRING\n"
@@ -2552,100 +2552,100 @@ tx_meta {
                     "      bytes_value: \"Paul\"\n"
                     "    }\n"
                     "  }\n"
-                    "}\n"
-                    "tx_meta {\n"
+                    "}\n" 
+                    "tx_meta {\n" 
                     "}\n";
                 UNIT_ASSERT_NO_DIFF(tmp, expected);
             }
         }
     }
 
-    Y_UNIT_TEST(ExecuteQueryCache) {
-        TKikimrWithGrpcAndRootSchema server;
-        ui16 grpc = server.GetPort();
-
-        std::shared_ptr<grpc::Channel> Channel_;
-        Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials());
-        TString sessionId;
-        {
-            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
-            Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
-            Ydb::Table::CreateSessionRequest request;
-            Ydb::Table::CreateSessionResponse response;
-
-            auto status = Stub_->CreateSession(&context, request, &response);
-            auto deferred = response.operation();
-            UNIT_ASSERT(status.ok());  //GRpc layer - OK
-            UNIT_ASSERT(deferred.ready() == true);
-            Ydb::Table::CreateSessionResult result;
-
-            deferred.result().UnpackTo(&result);
-            sessionId = result.session_id();
-        }
-
-        Ydb::TypedValue parameter;
-        {
-            const TString type =
-                "type_id: STRING\n";
-            google::protobuf::TextFormat::ParseFromString(type, parameter.mutable_type());
-            const TString value = "bytes_value: \"Paul\"\n";
-            google::protobuf::TextFormat::ParseFromString(value, parameter.mutable_value());
-        }
-
-        TString queryId;
-        {
-            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
-            Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
-            Ydb::Table::ExecuteDataQueryRequest request;
-            request.set_session_id(sessionId);
-            request.mutable_query()->set_yql_text("DECLARE $paramName AS String; SELECT $paramName;");
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
-            request.mutable_query_cache_policy()->set_keep_in_cache(true);
-            auto& map = *request.mutable_parameters();
-            map["$paramName"] = parameter;
-            Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
-            auto deferred = response.operation();
+    Y_UNIT_TEST(ExecuteQueryCache) { 
+        TKikimrWithGrpcAndRootSchema server; 
+        ui16 grpc = server.GetPort(); 
+ 
+        std::shared_ptr<grpc::Channel> Channel_; 
+        Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials()); 
+        TString sessionId; 
+        { 
+            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_; 
+            Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_); 
+            grpc::ClientContext context; 
+            Ydb::Table::CreateSessionRequest request; 
+            Ydb::Table::CreateSessionResponse response; 
+ 
+            auto status = Stub_->CreateSession(&context, request, &response); 
+            auto deferred = response.operation(); 
+            UNIT_ASSERT(status.ok());  //GRpc layer - OK 
+            UNIT_ASSERT(deferred.ready() == true); 
+            Ydb::Table::CreateSessionResult result; 
+ 
+            deferred.result().UnpackTo(&result); 
+            sessionId = result.session_id(); 
+        } 
+ 
+        Ydb::TypedValue parameter; 
+        { 
+            const TString type = 
+                "type_id: STRING\n"; 
+            google::protobuf::TextFormat::ParseFromString(type, parameter.mutable_type()); 
+            const TString value = "bytes_value: \"Paul\"\n"; 
+            google::protobuf::TextFormat::ParseFromString(value, parameter.mutable_value()); 
+        } 
+ 
+        TString queryId; 
+        { 
+            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_; 
+            Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_); 
+            grpc::ClientContext context; 
+            Ydb::Table::ExecuteDataQueryRequest request; 
+            request.set_session_id(sessionId); 
+            request.mutable_query()->set_yql_text("DECLARE $paramName AS String; SELECT $paramName;"); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
+            request.mutable_query_cache_policy()->set_keep_in_cache(true); 
+            auto& map = *request.mutable_parameters(); 
+            map["$paramName"] = parameter; 
+            Ydb::Table::ExecuteDataQueryResponse response; 
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
+            auto deferred = response.operation(); 
             UNIT_ASSERT(status.ok());
-            UNIT_ASSERT(deferred.ready() == true);
-
-            Ydb::Table::ExecuteQueryResult result;
-            deferred.result().UnpackTo(&result);
-            UNIT_ASSERT(result.has_query_meta());
-            queryId = result.query_meta().id();
+            UNIT_ASSERT(deferred.ready() == true); 
+ 
+            Ydb::Table::ExecuteQueryResult result; 
+            deferred.result().UnpackTo(&result); 
+            UNIT_ASSERT(result.has_query_meta()); 
+            queryId = result.query_meta().id(); 
             UNIT_ASSERT(!queryId.empty());
-            UNIT_ASSERT(!result.query_meta().parameters_types().empty());
-        }
-
-        {
-            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
-            Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_);
-            grpc::ClientContext context;
-            Ydb::Table::ExecuteDataQueryRequest request;
-            request.set_session_id(sessionId);
-            request.mutable_query()->set_id(queryId);
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
-            request.mutable_query_cache_policy()->set_keep_in_cache(true);
-            auto& map = *request.mutable_parameters();
-            map["$paramName"] = parameter;
-
-            Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
-            UNIT_ASSERT(status.ok());
-            auto deferred = response.operation();
-            UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
-
-            Ydb::Table::ExecuteQueryResult result;
-            deferred.result().UnpackTo(&result);
-            UNIT_ASSERT(!result.has_query_meta());
-        }
-    }
-
+            UNIT_ASSERT(!result.query_meta().parameters_types().empty()); 
+        } 
+ 
+        { 
+            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_; 
+            Stub_ = Ydb::Table::V1::TableService::NewStub(Channel_); 
+            grpc::ClientContext context; 
+            Ydb::Table::ExecuteDataQueryRequest request; 
+            request.set_session_id(sessionId); 
+            request.mutable_query()->set_id(queryId); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
+            request.mutable_query_cache_policy()->set_keep_in_cache(true); 
+            auto& map = *request.mutable_parameters(); 
+            map["$paramName"] = parameter; 
+ 
+            Ydb::Table::ExecuteDataQueryResponse response; 
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
+            UNIT_ASSERT(status.ok()); 
+            auto deferred = response.operation(); 
+            UNIT_ASSERT(deferred.ready() == true); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
+ 
+            Ydb::Table::ExecuteQueryResult result; 
+            deferred.result().UnpackTo(&result); 
+            UNIT_ASSERT(!result.has_query_meta()); 
+        } 
+    } 
+ 
     Y_UNIT_TEST(ExplainQuery) {
         TKikimrWithGrpcAndRootSchema server;
         ui16 grpc = server.GetPort();
@@ -2681,7 +2681,7 @@ tx_meta {
         /*
         {
             auto status = WaitForStatus(Channel_, id);
-            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS); 
         }
         */
 
@@ -2710,15 +2710,15 @@ tx_meta {
             grpc::ClientContext context;
             Ydb::Table::ExecuteDataQueryRequest request;
             request.set_session_id(sessionId);
-            request.mutable_query()->set_yql_text("UPSERT INTO [Root/TheTable] (Key, Value) VALUES (42, \"data\");");
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
+            request.mutable_query()->set_yql_text("UPSERT INTO [Root/TheTable] (Key, Value) VALUES (42, \"data\");"); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
         }
 
         {
@@ -2727,13 +2727,13 @@ tx_meta {
             grpc::ClientContext context;
             Ydb::Table::ExplainDataQueryRequest request;
             request.set_session_id(sessionId);
-            request.set_yql_text("SELECT COUNT(*) FROM [Root/TheTable];");
+            request.set_yql_text("SELECT COUNT(*) FROM [Root/TheTable];"); 
             Ydb::Table::ExplainDataQueryResponse response;
-            auto status = Stub_->ExplainDataQuery(&context, request, &response);
+            auto status = Stub_->ExplainDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
         }
     }
 
@@ -2768,7 +2768,7 @@ tx_meta {
         /*
         {
             auto status = WaitForStatus(Channel_, id);
-            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS); 
         }
         */
         {
@@ -2810,7 +2810,7 @@ tx_meta {
         /*
         {
             auto status = WaitForStatus(Channel_, id);
-            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(status == Ydb::StatusIds::SUCCESS); 
         }
         */
         {
@@ -2835,15 +2835,15 @@ tx_meta {
             grpc::ClientContext context;
             Ydb::Table::ExecuteDataQueryRequest request;
             request.set_session_id(sessionId);
-            request.mutable_query()->set_yql_text("DELETE FROM [Root/TheTable];");
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
+            request.mutable_query()->set_yql_text("DELETE FROM [Root/TheTable];"); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
         }
         {
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
@@ -2851,15 +2851,15 @@ tx_meta {
             grpc::ClientContext context;
             Ydb::Table::ExecuteDataQueryRequest request;
             request.set_session_id(sessionId);
-            request.mutable_query()->set_yql_text("DELETE FROM [Root/TheTable2];");
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
+            request.mutable_query()->set_yql_text("DELETE FROM [Root/TheTable2];"); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
         }
     }
 
@@ -2936,14 +2936,14 @@ tx_meta {
             req.back() = ';';
             request.mutable_query()->set_yql_text(req);
 
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            request.mutable_tx_control()->set_commit_tx(true);
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            request.mutable_tx_control()->set_commit_tx(true); 
             Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
             UNIT_ASSERT(status.ok());
             auto deferred = response.operation();
             UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
         }
         {
             std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
@@ -3059,124 +3059,124 @@ tx_meta {
             }
         }
     }
-
-    Y_UNIT_TEST(OperationTimeout) {
-        TKikimrWithGrpcAndRootSchema server;
-        ui16 grpc = server.GetPort();
-
-        std::shared_ptr<grpc::Channel> Channel_;
-        Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials());
-        {
-            std::unique_ptr<Draft::Dummy::DummyService::Stub> Stub_;
-            Stub_ = Draft::Dummy::DummyService::NewStub(Channel_);
-            grpc::ClientContext context;
-
-            Draft::Dummy::InfiniteRequest request;
-            Draft::Dummy::InfiniteResponse response;
-
-            request.mutable_operation_params()->mutable_operation_timeout()->set_nanos(100000000); // 100ms
-
-            auto status = Stub_->Infinite(&context, request, &response);
-            auto deferred = response.operation();
-            UNIT_ASSERT(status.ok());  //GRpc layer - OK
-            UNIT_ASSERT(deferred.ready() == true);
-
-            NYql::TIssues issues;
-            NYql::IssuesFromMessage(deferred.issues(), issues);
-            issues.PrintTo(Cerr);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::TIMEOUT);
-        }
-    }
-
-    Y_UNIT_TEST(OperationCancelAfter) {
-        TKikimrWithGrpcAndRootSchema server;
-        ui16 grpc = server.GetPort();
-
-        std::shared_ptr<grpc::Channel> Channel_;
-        Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials());
-        {
-            std::unique_ptr<Draft::Dummy::DummyService::Stub> Stub_;
-            Stub_ = Draft::Dummy::DummyService::NewStub(Channel_);
-            grpc::ClientContext context;
-
-            Draft::Dummy::InfiniteRequest request;
-            Draft::Dummy::InfiniteResponse response;
-
-            request.mutable_operation_params()->mutable_cancel_after()->set_nanos(100000000); // 100ms
-
-            auto status = Stub_->Infinite(&context, request, &response);
-            auto deferred = response.operation();
-            UNIT_ASSERT(status.ok());  //GRpc layer - OK
-            UNIT_ASSERT(deferred.ready() == true);
-
-            NYql::TIssues issues;
-            NYql::IssuesFromMessage(deferred.issues(), issues);
-            issues.PrintTo(Cerr);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::CANCELLED);
-        }
-    }
-
-    Y_UNIT_TEST(KeepAlive) {
-        TKikimrWithGrpcAndRootSchema server;
-        ui16 grpc = server.GetPort();
-
-        std::shared_ptr<grpc::Channel> channel;
-        channel = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials());
-
-        TString sessionId = CreateSession(channel);
-
-        {
-            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
-            Stub_ = Ydb::Table::V1::TableService::NewStub(channel);
-            grpc::ClientContext context;
-            Ydb::Table::KeepAliveRequest request;
-            request.set_session_id(sessionId);
-            Ydb::Table::KeepAliveResponse response;
-            auto status = Stub_->KeepAlive(&context, request, &response);
+ 
+    Y_UNIT_TEST(OperationTimeout) { 
+        TKikimrWithGrpcAndRootSchema server; 
+        ui16 grpc = server.GetPort(); 
+ 
+        std::shared_ptr<grpc::Channel> Channel_; 
+        Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials()); 
+        { 
+            std::unique_ptr<Draft::Dummy::DummyService::Stub> Stub_; 
+            Stub_ = Draft::Dummy::DummyService::NewStub(Channel_); 
+            grpc::ClientContext context; 
+ 
+            Draft::Dummy::InfiniteRequest request; 
+            Draft::Dummy::InfiniteResponse response; 
+ 
+            request.mutable_operation_params()->mutable_operation_timeout()->set_nanos(100000000); // 100ms 
+ 
+            auto status = Stub_->Infinite(&context, request, &response); 
+            auto deferred = response.operation(); 
+            UNIT_ASSERT(status.ok());  //GRpc layer - OK 
+            UNIT_ASSERT(deferred.ready() == true); 
+ 
+            NYql::TIssues issues; 
+            NYql::IssuesFromMessage(deferred.issues(), issues); 
+            issues.PrintTo(Cerr); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::TIMEOUT); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST(OperationCancelAfter) { 
+        TKikimrWithGrpcAndRootSchema server; 
+        ui16 grpc = server.GetPort(); 
+ 
+        std::shared_ptr<grpc::Channel> Channel_; 
+        Channel_ = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials()); 
+        { 
+            std::unique_ptr<Draft::Dummy::DummyService::Stub> Stub_; 
+            Stub_ = Draft::Dummy::DummyService::NewStub(Channel_); 
+            grpc::ClientContext context; 
+ 
+            Draft::Dummy::InfiniteRequest request; 
+            Draft::Dummy::InfiniteResponse response; 
+ 
+            request.mutable_operation_params()->mutable_cancel_after()->set_nanos(100000000); // 100ms 
+ 
+            auto status = Stub_->Infinite(&context, request, &response); 
+            auto deferred = response.operation(); 
+            UNIT_ASSERT(status.ok());  //GRpc layer - OK 
+            UNIT_ASSERT(deferred.ready() == true); 
+ 
+            NYql::TIssues issues; 
+            NYql::IssuesFromMessage(deferred.issues(), issues); 
+            issues.PrintTo(Cerr); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::CANCELLED); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST(KeepAlive) { 
+        TKikimrWithGrpcAndRootSchema server; 
+        ui16 grpc = server.GetPort(); 
+ 
+        std::shared_ptr<grpc::Channel> channel; 
+        channel = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials()); 
+ 
+        TString sessionId = CreateSession(channel); 
+ 
+        { 
+            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_; 
+            Stub_ = Ydb::Table::V1::TableService::NewStub(channel); 
+            grpc::ClientContext context; 
+            Ydb::Table::KeepAliveRequest request; 
+            request.set_session_id(sessionId); 
+            Ydb::Table::KeepAliveResponse response; 
+            auto status = Stub_->KeepAlive(&context, request, &response); 
             UNIT_ASSERT(status.ok());
-            auto deferred = response.operation();
-            UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS);
-
-            Ydb::Table::KeepAliveResult result;
-            deferred.result().UnpackTo(&result);
-
-            UNIT_ASSERT(result.session_status() == Ydb::Table::KeepAliveResult::SESSION_STATUS_READY);
-        }
-    }
-
-    Y_UNIT_TEST(BeginTxRequestError) {
-        TVector<NKikimrKqp::TKqpSetting> settings;
-        auto setting = NKikimrKqp::TKqpSetting();
-        setting.SetName("_KqpMaxActiveTxPerSession");
-        setting.SetValue("2");
-        settings.push_back(setting);
-
+            auto deferred = response.operation(); 
+            UNIT_ASSERT(deferred.ready() == true); 
+            UNIT_ASSERT(deferred.status() == Ydb::StatusIds::SUCCESS); 
+ 
+            Ydb::Table::KeepAliveResult result; 
+            deferred.result().UnpackTo(&result); 
+ 
+            UNIT_ASSERT(result.session_status() == Ydb::Table::KeepAliveResult::SESSION_STATUS_READY); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST(BeginTxRequestError) { 
+        TVector<NKikimrKqp::TKqpSetting> settings; 
+        auto setting = NKikimrKqp::TKqpSetting(); 
+        setting.SetName("_KqpMaxActiveTxPerSession"); 
+        setting.SetValue("2"); 
+        settings.push_back(setting); 
+ 
         TKikimrWithGrpcAndRootSchema server(NKikimrConfig::TAppConfig(), settings);
-        ui16 grpc = server.GetPort();
-
-        std::shared_ptr<grpc::Channel> channel;
-        channel = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials());
-
-        TString sessionId = CreateSession(channel);
-
-        for (ui32 i = 0; i < 3; ++i) {
-            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_;
-            Stub_ = Ydb::Table::V1::TableService::NewStub(channel);
-            grpc::ClientContext context;
-            Ydb::Table::ExecuteDataQueryRequest request;
-            request.set_session_id(sessionId);
-            request.mutable_query()->set_id("ydb://preparedqueryid/0?id=bad_query");
-            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
-            Ydb::Table::ExecuteDataQueryResponse response;
-            auto status = Stub_->ExecuteDataQuery(&context, request, &response);
-            auto deferred = response.operation();
-
-            UNIT_ASSERT(status.ok());
-            UNIT_ASSERT(deferred.ready() == true);
-            UNIT_ASSERT_VALUES_EQUAL(deferred.status(), Ydb::StatusIds::NOT_FOUND);
-        }
-    }
+        ui16 grpc = server.GetPort(); 
+ 
+        std::shared_ptr<grpc::Channel> channel; 
+        channel = grpc::CreateChannel("localhost:" + ToString(grpc), grpc::InsecureChannelCredentials()); 
+ 
+        TString sessionId = CreateSession(channel); 
+ 
+        for (ui32 i = 0; i < 3; ++i) { 
+            std::unique_ptr<Ydb::Table::V1::TableService::Stub> Stub_; 
+            Stub_ = Ydb::Table::V1::TableService::NewStub(channel); 
+            grpc::ClientContext context; 
+            Ydb::Table::ExecuteDataQueryRequest request; 
+            request.set_session_id(sessionId); 
+            request.mutable_query()->set_id("ydb://preparedqueryid/0?id=bad_query"); 
+            request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write(); 
+            Ydb::Table::ExecuteDataQueryResponse response; 
+            auto status = Stub_->ExecuteDataQuery(&context, request, &response); 
+            auto deferred = response.operation(); 
+ 
+            UNIT_ASSERT(status.ok()); 
+            UNIT_ASSERT(deferred.ready() == true); 
+            UNIT_ASSERT_VALUES_EQUAL(deferred.status(), Ydb::StatusIds::NOT_FOUND); 
+        } 
+    } 
 }
 
 namespace {
@@ -3764,7 +3764,7 @@ void CreateTableComplexKey(TKikimrWithGrpcAndRootSchema &server,
 
 Y_UNIT_TEST_SUITE(TTableProfileTests) {
     Y_UNIT_TEST(UseDefaultProfile) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         //server.Server_->GetRuntime()->SetLogPriority(NKikimrServices::CMS_CONFIGS, NLog::PRI_TRACE);
         //server.Server_->GetRuntime()->SetLogPriority(NKikimrServices::CONFIGS_DISPATCHER, NLog::PRI_TRACE);
         InitConfigs(server);
@@ -3800,7 +3800,7 @@ Y_UNIT_TEST_SUITE(TTableProfileTests) {
     }
 
     Y_UNIT_TEST(UseTableProfilePreset) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         InitConfigs(server);
 
         {
@@ -3837,16 +3837,16 @@ Y_UNIT_TEST_SUITE(TTableProfileTests) {
     }
 
     Y_UNIT_TEST(UseTableProfilePresetViaSdk) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         InitConfigs(server);
         ui16 grpc = server.GetPort();
 
         TString location = TStringBuilder() << "localhost:" << grpc;
 
         auto connection = NYdb::TDriver(
-            TDriverConfig()
+            TDriverConfig() 
                 .SetEndpoint(location));
-        auto client = NYdb::NTable::TTableClient(connection);
+        auto client = NYdb::NTable::TTableClient(connection); 
         auto session = client.CreateSession().ExtractValueSync().GetSession();
 
         {
@@ -3900,7 +3900,7 @@ Y_UNIT_TEST_SUITE(TTableProfileTests) {
 
 
     Y_UNIT_TEST(OverwriteCompactionPolicy) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         InitConfigs(server);
 
         {
@@ -3940,7 +3940,7 @@ Y_UNIT_TEST_SUITE(TTableProfileTests) {
 
 
     Y_UNIT_TEST(OverwriteExecutionPolicy) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         InitConfigs(server);
 
         {
@@ -3978,7 +3978,7 @@ Y_UNIT_TEST_SUITE(TTableProfileTests) {
     }
 
     Y_UNIT_TEST(OverwritePartitioningPolicy) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         InitConfigs(server);
 
         {
@@ -4149,30 +4149,30 @@ Y_UNIT_TEST_SUITE(TTableProfileTests) {
 
             for (const auto& range : ranges) {
                 if (n == 0) {
-                    UNIT_ASSERT(!range.From());
+                    UNIT_ASSERT(!range.From()); 
                 } else {
-                    UNIT_ASSERT(range.From()->IsInclusive());
-
+                    UNIT_ASSERT(range.From()->IsInclusive()); 
+ 
                     auto left = extractValue(range.From()->GetValue());
-                    UNIT_ASSERT_VALUES_EQUAL(left, expectedRanges[n - 1]);
+                    UNIT_ASSERT_VALUES_EQUAL(left, expectedRanges[n - 1]); 
                 }
 
-                if (n == 9) {
-                    UNIT_ASSERT(!range.To());
-                } else {
-                    UNIT_ASSERT(!range.To()->IsInclusive());
+                if (n == 9) { 
+                    UNIT_ASSERT(!range.To()); 
+                } else { 
+                    UNIT_ASSERT(!range.To()->IsInclusive()); 
                     auto right = extractValue(range.To()->GetValue());
                     UNIT_ASSERT_VALUES_EQUAL(right, expectedRanges[n]);
                 }
-
-                ++n;
+ 
+                ++n; 
             }
 
         }
     }
 
     Y_UNIT_TEST(OverwriteStoragePolicy) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         server.Server_->GetRuntime()->GetAppData().FeatureFlags.SetEnablePublicApiKeepInMemory(true);
         InitConfigs(server);
 
@@ -4291,7 +4291,7 @@ Y_UNIT_TEST_SUITE(TTableProfileTests) {
     }
 
     Y_UNIT_TEST(OverwriteCachingPolicy) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         InitConfigs(server);
 
         {
@@ -4329,7 +4329,7 @@ Y_UNIT_TEST_SUITE(TTableProfileTests) {
     }
 
     Y_UNIT_TEST(WrongTableProfile) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         InitConfigs(server);
 
         {
@@ -4553,7 +4553,7 @@ Y_UNIT_TEST_SUITE(TTableProfileTests) {
     }
 
     Y_UNIT_TEST(DescribeTableOptions) {
-        TKikimrWithGrpcAndRootSchema server;
+        TKikimrWithGrpcAndRootSchema server; 
         InitConfigs(server);
 
 
@@ -4755,7 +4755,7 @@ Ydb::Table::ExecuteQueryResult ExecYql(std::shared_ptr<grpc::Channel> channel, c
     request.mutable_tx_control()->mutable_begin_tx()->mutable_serializable_read_write();
     request.mutable_tx_control()->set_commit_tx(true);
     if (withStat) {
-        request.set_collect_stats(Ydb::Table::QueryStatsCollection::STATS_COLLECTION_BASIC);
+        request.set_collect_stats(Ydb::Table::QueryStatsCollection::STATS_COLLECTION_BASIC); 
     }
     Ydb::Table::ExecuteDataQueryResponse response;
     auto status = stub->ExecuteDataQuery(&context, request, &response);
diff --git a/ydb/tests/functional/api/test_public_api.py b/ydb/tests/functional/api/test_public_api.py
index 072ee35de3..269c3f293a 100644
--- a/ydb/tests/functional/api/test_public_api.py
+++ b/ydb/tests/functional/api/test_public_api.py
@@ -266,7 +266,7 @@ class TestCRUDOperations(Base):
 
         assert_that(
             callee, raises(
-                ydb.Error
+                ydb.Error 
             )
         )
 
@@ -586,7 +586,7 @@ SELECT * FROM $InputSource;
         assert_that(
             invalid_callable,
             raises(
-                ydb.BadSession,
+                ydb.BadSession, 
                 "Empty session_id"
             )
         )
@@ -618,7 +618,7 @@ SELECT * FROM $InputSource;
         assert_that(
             invalid_callable,
             raises(
-                ydb.Aborted
+                ydb.Aborted 
             )
         )
 
@@ -926,14 +926,14 @@ actions {
         assert_that(
             callee,
             raises(
-                ydb.BadSession,
+                ydb.BadSession, 
                 'Exceeded maximum allowed number of active transactions'
             )
         )
 
         try:
             callee()
-        except ydb.BadSession as expected_error:
+        except ydb.BadSession as expected_error: 
             assert_that(
                 isinstance(expected_error.message, str),
                 is_(True)
@@ -1564,7 +1564,7 @@ class TestSelectAfterDropWithRepetitions(object):
             assert_that(
                 callee,
                 raises(
-                    ydb.SchemeError,
+                    ydb.SchemeError, 
                 )
             )
 
@@ -1707,7 +1707,7 @@ class TestJsonExample(object):
         assert_that(
             callee,
             raises(
-                ydb.BadRequest
+                ydb.BadRequest 
             )
         )
 
diff --git a/ydb/tests/functional/canonical/canondata/result.json b/ydb/tests/functional/canonical/canondata/result.json
index d927ff0f90..a29abc77e2 100644
--- a/ydb/tests/functional/canonical/canondata/result.json
+++ b/ydb/tests/functional/canonical/canondata/result.json
@@ -129,24 +129,24 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_index_predicate_point.sql-result_sets_/index_predicate_point.sql.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[join/group_by_lookup.script-script]": {
-        "script": {
+    "test_sql.TestCanonicalFolder1.test_case[join/group_by_lookup.script-script]": { 
+        "script": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_join_group_by_lookup.script-script_/join_group_by_lookup.script.results"
-        },
-        "script_plan": {
+        }, 
+        "script_plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_join_group_by_lookup.script-script_/join_group_by_lookup.script.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[join/join_double_lookup.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[join/join_double_lookup.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_join_join_double_lookup.sql-plan_/join_join_double_lookup.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[join/join_double_lookup.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[join/join_double_lookup.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_join_join_double_lookup.sql-result_sets_/join_join_double_lookup.sql.results"
-        }
-    },
+        } 
+    }, 
     "test_sql.TestCanonicalFolder1.test_case[join/join_dup_column_right.sql-plan]": {
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_join_join_dup_column_right.sql-plan_/join_join_dup_column_right.sql.plan"
@@ -377,12 +377,12 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_join_join_with_agg.sql-result_sets_/join_join_with_agg.sql.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/insert_from_table.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/insert_from_table.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_insert_from_table.sql-plan_/json_insert_from_table.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/insert_from_table.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/insert_from_table.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_insert_from_table.sql-result_sets_/json_insert_from_table.sql.results"
         },
@@ -390,12 +390,12 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_insert_from_table.sql-result_sets_/json_insert_from_table.sql_ResultTableJD.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/insert_literal.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/insert_literal.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_insert_literal.sql-plan_/json_insert_literal.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/insert_literal.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/insert_literal.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_insert_literal.sql-result_sets_/json_insert_literal.sql.results"
         },
@@ -403,12 +403,12 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_insert_literal.sql-result_sets_/json_insert_literal.sql_ResultLiteralJD.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/insert_params.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/insert_params.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_insert_params.sql-plan_/json_insert_params.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/insert_params.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/insert_params.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_insert_params.sql-result_sets_/json_insert_params.sql.results"
         },
@@ -416,42 +416,42 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_insert_params.sql-result_sets_/json_insert_params.sql_ResultParamsJD.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/json_query.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/json_query.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_json_query.sql-plan_/json_json_query.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/json_query.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/json_query.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_json_query.sql-result_sets_/json_json_query.sql.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/select_from_table.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/select_from_table.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_select_from_table.sql-plan_/json_select_from_table.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/select_from_table.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/select_from_table.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_select_from_table.sql-result_sets_/json_select_from_table.sql.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/select_literal.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/select_literal.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_select_literal.sql-plan_/json_select_literal.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/select_literal.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/select_literal.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_select_literal.sql-result_sets_/json_select_literal.sql.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/select_params.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/select_params.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_select_params.sql-plan_/json_select_params.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[json/select_params.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[json/select_params.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_json_select_params.sql-result_sets_/json_select_params.sql.results"
         },
@@ -739,16 +739,16 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pk_predicate_pk_predicate_reverse_1.sql-result_sets_/pk_predicate_pk_predicate_reverse_1.sql.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[pk_predicate/pk_predicate_subquery.sql-plan]": {
-        "plan": {
+    "test_sql.TestCanonicalFolder1.test_case[pk_predicate/pk_predicate_subquery.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pk_predicate_pk_predicate_subquery.sql-plan_/pk_predicate_pk_predicate_subquery.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pk_predicate/pk_predicate_subquery.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pk_predicate/pk_predicate_subquery.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pk_predicate_pk_predicate_subquery.sql-result_sets_/pk_predicate_pk_predicate_subquery.sql.results"
-        }
-    },
+        } 
+    }, 
     "test_sql.TestCanonicalFolder1.test_case[pk_predicate/pk_predicate_utf8.sql-plan]": {
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pk_predicate_pk_predicate_utf8.sql-plan_/pk_predicate_pk_predicate_utf8.sql.plan"
@@ -759,136 +759,136 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pk_predicate_pk_predicate_utf8.sql-result_sets_/pk_predicate_pk_predicate_utf8.sql.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_1.sql-plan]": {
-        "plan": {
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_1.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_1.sql-plan_/pure_trivial_1.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_1.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_1.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_1.sql-result_sets_/pure_trivial_1.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_10.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_10.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_10.sql-plan_/pure_trivial_10.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_10.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_10.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_10.sql-result_sets_/pure_trivial_10.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_11.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_11.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_11.sql-plan_/pure_trivial_11.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_11.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_11.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_11.sql-result_sets_/pure_trivial_11.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_12.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_12.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_12.sql-plan_/pure_trivial_12.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_12.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_12.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_12.sql-result_sets_/pure_trivial_12.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_13.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_13.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_13.sql-plan_/pure_trivial_13.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_13.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_13.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_13.sql-result_sets_/pure_trivial_13.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_2.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_2.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_2.sql-plan_/pure_trivial_2.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_2.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_2.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_2.sql-result_sets_/pure_trivial_2.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_3.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_3.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_3.sql-plan_/pure_trivial_3.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_3.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_3.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_3.sql-result_sets_/pure_trivial_3.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_4.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_4.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_4.sql-plan_/pure_trivial_4.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_4.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_4.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_4.sql-result_sets_/pure_trivial_4.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_5.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_5.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_5.sql-plan_/pure_trivial_5.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_5.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_5.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_5.sql-result_sets_/pure_trivial_5.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_6.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_6.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_6.sql-plan_/pure_trivial_6.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_6.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_6.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_6.sql-result_sets_/pure_trivial_6.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_7.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_7.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_7.sql-plan_/pure_trivial_7.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_7.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_7.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_7.sql-result_sets_/pure_trivial_7.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_8.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_8.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_8.sql-plan_/pure_trivial_8.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_8.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_8.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_8.sql-result_sets_/pure_trivial_8.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_9.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_9.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_9.sql-plan_/pure_trivial_9.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_9.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[pure/trivial_9.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_pure_trivial_9.sql-result_sets_/pure_trivial_9.sql.results"
-        }
-    },
+        } 
+    }, 
     "test_sql.TestCanonicalFolder1.test_case[range_skip_take.sql-plan]": {
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_range_skip_take.sql-plan_/range_skip_take.sql.plan"
@@ -920,26 +920,26 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_simple_ct.script-script_/simple_ct.script_Questions.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[simple/empty_select.sql-plan]": {
-        "plan": {
+    "test_sql.TestCanonicalFolder1.test_case[simple/empty_select.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_simple_empty_select.sql-plan_/simple_empty_select.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[simple/empty_select.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[simple/empty_select.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_simple_empty_select.sql-result_sets_/simple_empty_select.sql.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[simple/multi_select.sql-plan]": {
-        "plan": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[simple/multi_select.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_simple_multi_select.sql-plan_/simple_multi_select.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[simple/multi_select.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[simple/multi_select.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_simple_multi_select.sql-result_sets_/simple_multi_select.sql.results"
-        }
-    },
+        } 
+    }, 
     "test_sql.TestCanonicalFolder1.test_case[simple/q1.sql-plan]": {
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_simple_q1.sql-plan_/simple_q1.sql.plan"
@@ -1168,14 +1168,14 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_simple_script_params.script-script_/simple_script_params.script.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[table_types.script-script]": {
-        "script": {
+    "test_sql.TestCanonicalFolder1.test_case[table_types.script-script]": { 
+        "script": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_table_types.script-script_/table_types.script.results"
         },
         "script_plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_table_types.script-script_/table_types.script.plan"
-        }
-    },
+        } 
+    }, 
     "test_sql.TestCanonicalFolder1.test_case[topsort/topsort.sql-plan]": {
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_topsort_topsort.sql-plan_/topsort_topsort.sql.plan"
@@ -1226,189 +1226,189 @@
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_topsort_topsort_pk.sql-result_sets_/topsort_topsort_pk.sql.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/delete_by_pk.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/delete_by_pk.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_by_pk.sql-plan_/write_delete_by_pk.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/delete_by_pk.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/delete_by_pk.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_by_pk.sql-result_sets_/write_delete_by_pk.sql.results"
-        },
-        "table_data_Input": {
+        }, 
+        "table_data_Input": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_by_pk.sql-result_sets_/write_delete_by_pk.sql_Input.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/delete_on.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/delete_on.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_on.sql-plan_/write_delete_on.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/delete_on.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/delete_on.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_on.sql-result_sets_/write_delete_on.sql.results"
-        },
-        "table_data_Input": {
+        }, 
+        "table_data_Input": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_on.sql-result_sets_/write_delete_on.sql_Input.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_on.sql-result_sets_/write_delete_on.sql_Input1.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/delete_same.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/delete_same.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_same.sql-plan_/write_delete_same.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/delete_same.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/delete_same.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_same.sql-result_sets_/write_delete_same.sql.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_delete_same.sql-result_sets_/write_delete_same.sql_Input1.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/insert.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/insert.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_insert.sql-plan_/write_insert.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/insert.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/insert.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_insert.sql-result_sets_/write_insert.sql.results"
-        },
-        "table_data_Input": {
+        }, 
+        "table_data_Input": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_insert.sql-result_sets_/write_insert.sql_Input.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_insert.sql-result_sets_/write_insert.sql_Input1.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/insert_revert.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/insert_revert.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_insert_revert.sql-plan_/write_insert_revert.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/insert_revert.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/insert_revert.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_insert_revert.sql-result_sets_/write_insert_revert.sql.results"
-        },
-        "table_data_Input": {
+        }, 
+        "table_data_Input": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_insert_revert.sql-result_sets_/write_insert_revert.sql_Input.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_insert_revert.sql-result_sets_/write_insert_revert.sql_Input1.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/multi_usage.script-script]": {
-        "script": {
+    "test_sql.TestCanonicalFolder1.test_case[write/multi_usage.script-script]": { 
+        "script": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_multi_usage.script-script_/write_multi_usage.script.results"
-        },
-        "script_plan": {
+        }, 
+        "script_plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_multi_usage.script-script_/write_multi_usage.script.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[write/multi_usage_key.script-script]": {
-        "script": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[write/multi_usage_key.script-script]": { 
+        "script": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_multi_usage_key.script-script_/write_multi_usage_key.script.results"
-        },
-        "script_plan": {
+        }, 
+        "script_plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_multi_usage_key.script-script_/write_multi_usage_key.script.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[write/multi_write.sql-plan]": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[write/multi_write.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_multi_write.sql-plan_/write_multi_write.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/multi_write.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/multi_write.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_multi_write.sql-result_sets_/write_multi_write.sql.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_multi_write.sql-result_sets_/write_multi_write.sql_Input1.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/replace.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/replace.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_replace.sql-plan_/write_replace.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/replace.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/replace.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_replace.sql-result_sets_/write_replace.sql.results"
-        },
-        "table_data_Input": {
+        }, 
+        "table_data_Input": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_replace.sql-result_sets_/write_replace.sql_Input.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_replace.sql-result_sets_/write_replace.sql_Input1.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/update.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/update.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_update.sql-plan_/write_update.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/update.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/update.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_update.sql-result_sets_/write_update.sql.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_update.sql-result_sets_/write_update.sql_Input1.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/update_on.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/update_on.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_update_on.sql-plan_/write_update_on.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/update_on.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/update_on.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_update_on.sql-result_sets_/write_update_on.sql.results"
-        },
-        "table_data_Input": {
+        }, 
+        "table_data_Input": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_update_on.sql-result_sets_/write_update_on.sql_Input.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_update_on.sql-result_sets_/write_update_on.sql_Input1.results"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/upsert.sql-plan]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/upsert.sql-plan]": { 
         "plan": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_upsert.sql-plan_/write_upsert.sql.plan"
         }
     },
-    "test_sql.TestCanonicalFolder1.test_case[write/upsert.sql-result_sets]": {
+    "test_sql.TestCanonicalFolder1.test_case[write/upsert.sql-result_sets]": { 
         "result_sets": {
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_upsert.sql-result_sets_/write_upsert.sql.results"
-        },
-        "table_data_Input": {
+        }, 
+        "table_data_Input": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_upsert.sql-result_sets_/write_upsert.sql_Input.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_upsert.sql-result_sets_/write_upsert.sql_Input1.results"
         }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[write/upsert_cast.sql-plan]": {
-        "plan": {
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[write/upsert_cast.sql-plan]": { 
+        "plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_upsert_cast.sql-plan_/write_upsert_cast.sql.plan"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[write/upsert_cast.sql-result_sets]": {
-        "result_sets": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[write/upsert_cast.sql-result_sets]": { 
+        "result_sets": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_upsert_cast.sql-result_sets_/write_upsert_cast.sql.results"
-        },
-        "table_data_Input1": {
+        }, 
+        "table_data_Input1": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_upsert_cast.sql-result_sets_/write_upsert_cast.sql_Input1.results"
-        }
-    },
-    "test_sql.TestCanonicalFolder1.test_case[write/write_group_by.script-script]": {
-        "script": {
+        } 
+    }, 
+    "test_sql.TestCanonicalFolder1.test_case[write/write_group_by.script-script]": { 
+        "script": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_write_group_by.script-script_/write_write_group_by.script.results"
-        },
-        "script_plan": {
+        }, 
+        "script_plan": { 
             "uri": "file://test_sql.TestCanonicalFolder1.test_case_write_write_group_by.script-script_/write_write_group_by.script.plan"
-        }
+        } 
     }
-}
+} 
diff --git a/ydb/tests/functional/canonical/sql/join/group_by_lookup.script b/ydb/tests/functional/canonical/sql/join/group_by_lookup.script
index cf1ab66d50..5a600b7cff 100644
--- a/ydb/tests/functional/canonical/sql/join/group_by_lookup.script
+++ b/ydb/tests/functional/canonical/sql/join/group_by_lookup.script
@@ -1,22 +1,22 @@
---!syntax_v1
-
-CREATE TABLE Temp (
-    Group Uint64,
-    Value String,
-    PRIMARY KEY (Group)
-);
-COMMIT;
-
-REPLACE INTO Temp (Group, Value) VALUES
-    (1u, "One"),
-    (3u, "Three");
-COMMIT;
-
-$agg = (
-    SELECT Group, COUNT(*) AS Count FROM Input1 GROUP BY Group
-);
-
-SELECT a.Group, a.Count, t.Value
-FROM $agg AS a
-LEFT JOIN Temp AS t
-ON a.Group = t.Group;
+--!syntax_v1 
+ 
+CREATE TABLE Temp ( 
+    Group Uint64, 
+    Value String, 
+    PRIMARY KEY (Group) 
+); 
+COMMIT; 
+ 
+REPLACE INTO Temp (Group, Value) VALUES 
+    (1u, "One"), 
+    (3u, "Three"); 
+COMMIT; 
+ 
+$agg = ( 
+    SELECT Group, COUNT(*) AS Count FROM Input1 GROUP BY Group 
+); 
+ 
+SELECT a.Group, a.Count, t.Value 
+FROM $agg AS a 
+LEFT JOIN Temp AS t 
+ON a.Group = t.Group; 
diff --git a/ydb/tests/functional/canonical/sql/join/join_double_lookup.sql b/ydb/tests/functional/canonical/sql/join/join_double_lookup.sql
index 99d5ea307d..67f5fce008 100644
--- a/ydb/tests/functional/canonical/sql/join/join_double_lookup.sql
+++ b/ydb/tests/functional/canonical/sql/join/join_double_lookup.sql
@@ -1,10 +1,10 @@
---!syntax_v1
-PRAGMA AnsiInForEmptyOrNullableItemsCollections;
-
-$keys = AsList("One", "Three");
-
-SELECT COUNT(*)
-FROM InputJoin1 AS j1
-JOIN InputJoin2 AS j2
-ON j1.Fk21 = j2.Key1
-WHERE Key2 IN $keys;
+--!syntax_v1 
+PRAGMA AnsiInForEmptyOrNullableItemsCollections; 
+ 
+$keys = AsList("One", "Three"); 
+ 
+SELECT COUNT(*) 
+FROM InputJoin1 AS j1 
+JOIN InputJoin2 AS j2 
+ON j1.Fk21 = j2.Key1 
+WHERE Key2 IN $keys; 
diff --git a/ydb/tests/functional/canonical/sql/pk_predicate/pk_predicate_subquery.sql b/ydb/tests/functional/canonical/sql/pk_predicate/pk_predicate_subquery.sql
index 6f61d0093a..8fb4b3f75a 100644
--- a/ydb/tests/functional/canonical/sql/pk_predicate/pk_predicate_subquery.sql
+++ b/ydb/tests/functional/canonical/sql/pk_predicate/pk_predicate_subquery.sql
@@ -1,8 +1,8 @@
---!syntax_v1
-
-$group = (
-    SELECT Type FROM Input3 WHERE Value = "Value_7"
-);
-
-SELECT * FROM Input1
-WHERE Group = $group;
+--!syntax_v1 
+ 
+$group = ( 
+    SELECT Type FROM Input3 WHERE Value = "Value_7" 
+); 
+ 
+SELECT * FROM Input1 
+WHERE Group = $group; 
diff --git a/ydb/tests/functional/canonical/sql/simple/empty_select.sql b/ydb/tests/functional/canonical/sql/simple/empty_select.sql
index 75385e8723..32e680220a 100644
--- a/ydb/tests/functional/canonical/sql/simple/empty_select.sql
+++ b/ydb/tests/functional/canonical/sql/simple/empty_select.sql
@@ -1,2 +1,2 @@
---!syntax_v1
-SELECT * FROM Input1 LIMIT 0;
+--!syntax_v1 
+SELECT * FROM Input1 LIMIT 0; 
diff --git a/ydb/tests/functional/canonical/sql/simple/multi_select.sql b/ydb/tests/functional/canonical/sql/simple/multi_select.sql
index a725d7a079..62f14210ea 100644
--- a/ydb/tests/functional/canonical/sql/simple/multi_select.sql
+++ b/ydb/tests/functional/canonical/sql/simple/multi_select.sql
@@ -1,9 +1,9 @@
---!syntax_v1
-
-SELECT Group, Amount, Name FROM Input1
-WHERE Group = 1
-ORDER BY Name;
-
-SELECT * FROM Input
-ORDER BY key, subkey
-LIMIT 2;
+--!syntax_v1 
+ 
+SELECT Group, Amount, Name FROM Input1 
+WHERE Group = 1 
+ORDER BY Name; 
+ 
+SELECT * FROM Input 
+ORDER BY key, subkey 
+LIMIT 2; 
diff --git a/ydb/tests/functional/canonical/sql/table_types.script b/ydb/tests/functional/canonical/sql/table_types.script
index 4d6aa4a8a1..f68e6ce90e 100644
--- a/ydb/tests/functional/canonical/sql/table_types.script
+++ b/ydb/tests/functional/canonical/sql/table_types.script
@@ -1,84 +1,84 @@
---!syntax_v1
-
-CREATE TABLE TableTypes (
-    Key String,
-
-    Value01 Bool,
-    Value02 Uint8,
-    Value03 Int32,
-    Value04 Uint32,
-    Value05 Int64,
-    Value06 Uint64,
-    Value07 Float,
-    Value08 Double,
-    Value09 Decimal(22,9),
-    Value10 DyNumber,
-
-    Value21 Utf8,
-    Value22 Json,
-    Value23 JsonDocument,
-    Value24 Yson,
-
-    Value31 Date,
-    Value32 Datetime,
-    Value33 Timestamp,
-    Value34 Interval,
-
-    PRIMARY KEY (Key)
-);
-COMMIT;
-
-REPLACE INTO TableTypes
-(
-    Key,
-
-    Value01,
-    Value02,
-    Value03,
-    Value04,
-    Value05,
-    Value06,
-    Value07,
-    Value08,
-    Value09,
-    Value10,
-
-    Value21,
-    Value22,
-    Value23,
-    Value24,
-
-    Value31,
-    Value32,
-    Value33,
-    Value34
-)
-VALUES
-(
-    /* String        */ "Key",
-
-    /* Bool          */ true,
-    /* Uint8         */ Uint8("1"),
-    /* Int32         */ -1,
-    /* Uint32        */ 2u,
-    /* Int64         */ -2l,
-    /* Uint64        */ 3ul,
-    /* Float         */ 4.5f,
-    /* Double        */ -5.5,
-    /* Decimal(22,9) */ Decimal("3.14", 22, 9),
-    /* DyNumber      */ DyNumber("1.23"),
-
-    /* Utf8          */ Utf8("Привет"),
-    /* Json          */ Json(@@{"name": "George", "age": 23}@@),
-    /* JsonDocument  */ JsonDocument(@@{"name": "Anna", "age": 27}@@),
-    /* Yson          */ Yson(@@{a=1; b=2}@@),
-
-    /* Date          */ DateTime::MakeDate(DateTime::ParseIso8601("2019-04-18")),
-    /* Datetime      */ DateTime::MakeDatetime(DateTime::ParseIso8601("2018-03-17T22:16:44")),
-    /* Timestamp     */ DateTime::MakeTimestamp(DateTime::ParseIso8601("2017-06-21T20:37:55.10")),
-    /* Interval      */ DateTime::IntervalFromSeconds(91)
-);
-COMMIT;
-
-SELECT * FROM TableTypes;
-
+--!syntax_v1 
+ 
+CREATE TABLE TableTypes ( 
+    Key String, 
+ 
+    Value01 Bool, 
+    Value02 Uint8, 
+    Value03 Int32, 
+    Value04 Uint32, 
+    Value05 Int64, 
+    Value06 Uint64, 
+    Value07 Float, 
+    Value08 Double, 
+    Value09 Decimal(22,9), 
+    Value10 DyNumber, 
+ 
+    Value21 Utf8, 
+    Value22 Json, 
+    Value23 JsonDocument, 
+    Value24 Yson, 
+ 
+    Value31 Date, 
+    Value32 Datetime, 
+    Value33 Timestamp, 
+    Value34 Interval, 
+ 
+    PRIMARY KEY (Key) 
+); 
+COMMIT; 
+ 
+REPLACE INTO TableTypes 
+( 
+    Key, 
+ 
+    Value01, 
+    Value02, 
+    Value03, 
+    Value04, 
+    Value05, 
+    Value06, 
+    Value07, 
+    Value08, 
+    Value09, 
+    Value10, 
+ 
+    Value21, 
+    Value22, 
+    Value23, 
+    Value24, 
+ 
+    Value31, 
+    Value32, 
+    Value33, 
+    Value34 
+) 
+VALUES 
+( 
+    /* String        */ "Key", 
+ 
+    /* Bool          */ true, 
+    /* Uint8         */ Uint8("1"), 
+    /* Int32         */ -1, 
+    /* Uint32        */ 2u, 
+    /* Int64         */ -2l, 
+    /* Uint64        */ 3ul, 
+    /* Float         */ 4.5f, 
+    /* Double        */ -5.5, 
+    /* Decimal(22,9) */ Decimal("3.14", 22, 9), 
+    /* DyNumber      */ DyNumber("1.23"), 
+ 
+    /* Utf8          */ Utf8("Привет"), 
+    /* Json          */ Json(@@{"name": "George", "age": 23}@@), 
+    /* JsonDocument  */ JsonDocument(@@{"name": "Anna", "age": 27}@@), 
+    /* Yson          */ Yson(@@{a=1; b=2}@@), 
+ 
+    /* Date          */ DateTime::MakeDate(DateTime::ParseIso8601("2019-04-18")), 
+    /* Datetime      */ DateTime::MakeDatetime(DateTime::ParseIso8601("2018-03-17T22:16:44")), 
+    /* Timestamp     */ DateTime::MakeTimestamp(DateTime::ParseIso8601("2017-06-21T20:37:55.10")), 
+    /* Interval      */ DateTime::IntervalFromSeconds(91) 
+); 
+COMMIT; 
+ 
+SELECT * FROM TableTypes; 
+ 
diff --git a/ydb/tests/functional/canonical/sql/write/delete_on.sql b/ydb/tests/functional/canonical/sql/write/delete_on.sql
index 7a9b18e689..d629c099bb 100644
--- a/ydb/tests/functional/canonical/sql/write/delete_on.sql
+++ b/ydb/tests/functional/canonical/sql/write/delete_on.sql
@@ -1,10 +1,10 @@
---!syntax_v1
-
-DELETE FROM Input1 ON (Group, Name) VALUES
-    (1, "Name1"),
-    (1, "Name2"),
-    (1, "Name5");
-
-DELETE FROM Input ON
-SELECT key, subkey FROM Input
-WHERE value = "b";
+--!syntax_v1 
+ 
+DELETE FROM Input1 ON (Group, Name) VALUES 
+    (1, "Name1"), 
+    (1, "Name2"), 
+    (1, "Name5"); 
+ 
+DELETE FROM Input ON 
+SELECT key, subkey FROM Input 
+WHERE value = "b"; 
diff --git a/ydb/tests/functional/canonical/sql/write/delete_same.sql b/ydb/tests/functional/canonical/sql/write/delete_same.sql
index 678bfc92fb..df34286a31 100644
--- a/ydb/tests/functional/canonical/sql/write/delete_same.sql
+++ b/ydb/tests/functional/canonical/sql/write/delete_same.sql
@@ -1,7 +1,7 @@
---!syntax_v1
-
-DELETE FROM Input1 WHERE Name = "Name1";
-
-DELETE FROM Input1 ON (Group, Name) VALUES
-    (1, "Name1"),
-    (1, "Name2");
+--!syntax_v1 
+ 
+DELETE FROM Input1 WHERE Name = "Name1"; 
+ 
+DELETE FROM Input1 ON (Group, Name) VALUES 
+    (1, "Name1"), 
+    (1, "Name2"); 
diff --git a/ydb/tests/functional/canonical/sql/write/insert.sql b/ydb/tests/functional/canonical/sql/write/insert.sql
index c2a8ae3dc3..efe256bd2a 100644
--- a/ydb/tests/functional/canonical/sql/write/insert.sql
+++ b/ydb/tests/functional/canonical/sql/write/insert.sql
@@ -1,10 +1,10 @@
---!syntax_v1
-INSERT INTO Input (key, subkey, value) VALUES
-    (3u, 3u, "three"),
-    (4u, 4u, "four"),
-    (3u, 5u, "five");
-
-INSERT INTO Input1
-SELECT Group + 100u AS Group, Name, 17 AS Amount
-FROM Input1
-WHERE Group = 1;
+--!syntax_v1 
+INSERT INTO Input (key, subkey, value) VALUES 
+    (3u, 3u, "three"), 
+    (4u, 4u, "four"), 
+    (3u, 5u, "five"); 
+ 
+INSERT INTO Input1 
+SELECT Group + 100u AS Group, Name, 17 AS Amount 
+FROM Input1 
+WHERE Group = 1; 
diff --git a/ydb/tests/functional/canonical/sql/write/insert_revert.sql b/ydb/tests/functional/canonical/sql/write/insert_revert.sql
index 47257b6404..a9357446d7 100644
--- a/ydb/tests/functional/canonical/sql/write/insert_revert.sql
+++ b/ydb/tests/functional/canonical/sql/write/insert_revert.sql
@@ -1,10 +1,10 @@
---!syntax_v1
-INSERT OR REVERT INTO Input (key, subkey, value) VALUES
-    (3u, 3u, "three"),
-    (3u, 4u, "four"),
-    (3u, 5u, "five");
-
-INSERT OR REVERT INTO Input1 (Group, Name, Comment) VALUES
-    (100u, "N1", "Inserted"),
-    (100u, "N2", "Inserted"),
-    (100u, "N3", "Inserted");
+--!syntax_v1 
+INSERT OR REVERT INTO Input (key, subkey, value) VALUES 
+    (3u, 3u, "three"), 
+    (3u, 4u, "four"), 
+    (3u, 5u, "five"); 
+ 
+INSERT OR REVERT INTO Input1 (Group, Name, Comment) VALUES 
+    (100u, "N1", "Inserted"), 
+    (100u, "N2", "Inserted"), 
+    (100u, "N3", "Inserted"); 
diff --git a/ydb/tests/functional/canonical/sql/write/multi_usage.script b/ydb/tests/functional/canonical/sql/write/multi_usage.script
index cadb6e85d9..454ff8ecf8 100644
--- a/ydb/tests/functional/canonical/sql/write/multi_usage.script
+++ b/ydb/tests/functional/canonical/sql/write/multi_usage.script
@@ -1,33 +1,33 @@
---!syntax_v1
-
-DECLARE $Name1 AS Utf8;
-DECLARE $Name2 AS Utf8;
-
-CREATE TABLE Temp (
-    Name String,
-    Value Int64,
-    PRIMARY KEY (Name)
-);
-
-COMMIT;
-
-$name = $Name1 || $Name2;
-
-$data = (
-    SELECT
-        $name AS Name,
-        Amount AS Value
-    FROM Input1
-    WHERE Group = 2
-);
-
-UPSERT INTO Temp
-SELECT * FROM $data;
-
-DELETE FROM Input1
-WHERE Group = 1 AND Name = $name;
-
-COMMIT;
-
-SELECT * FROM Temp ORDER BY Name;
-SELECT * FROM Input1 ORDER BY Group, Name;
+--!syntax_v1 
+ 
+DECLARE $Name1 AS Utf8; 
+DECLARE $Name2 AS Utf8; 
+ 
+CREATE TABLE Temp ( 
+    Name String, 
+    Value Int64, 
+    PRIMARY KEY (Name) 
+); 
+ 
+COMMIT; 
+ 
+$name = $Name1 || $Name2; 
+ 
+$data = ( 
+    SELECT 
+        $name AS Name, 
+        Amount AS Value 
+    FROM Input1 
+    WHERE Group = 2 
+); 
+ 
+UPSERT INTO Temp 
+SELECT * FROM $data; 
+ 
+DELETE FROM Input1 
+WHERE Group = 1 AND Name = $name; 
+ 
+COMMIT; 
+ 
+SELECT * FROM Temp ORDER BY Name; 
+SELECT * FROM Input1 ORDER BY Group, Name; 
diff --git a/ydb/tests/functional/canonical/sql/write/multi_usage_key.script b/ydb/tests/functional/canonical/sql/write/multi_usage_key.script
index 0f7ca589ce..c8e3ee52a0 100644
--- a/ydb/tests/functional/canonical/sql/write/multi_usage_key.script
+++ b/ydb/tests/functional/canonical/sql/write/multi_usage_key.script
@@ -1,29 +1,29 @@
---!syntax_v1
-
-DECLARE $Name1 AS Utf8;
-DECLARE $Name2 AS Utf8;
-
-CREATE TABLE Temp (
-    Name String,
-    Value Int64,
-    PRIMARY KEY (Name)
-);
-
-COMMIT;
-
-$name = $Name1 || $Name2;
-
-$data = (
-    SELECT
-        $name AS Name,
-        Amount AS Value
-    FROM Input1
-    WHERE Name = $name
-);
-
-UPSERT INTO Temp
-SELECT * FROM $data;
-
-COMMIT;
-
-SELECT * FROM Temp ORDER BY Name;
+--!syntax_v1 
+ 
+DECLARE $Name1 AS Utf8; 
+DECLARE $Name2 AS Utf8; 
+ 
+CREATE TABLE Temp ( 
+    Name String, 
+    Value Int64, 
+    PRIMARY KEY (Name) 
+); 
+ 
+COMMIT; 
+ 
+$name = $Name1 || $Name2; 
+ 
+$data = ( 
+    SELECT 
+        $name AS Name, 
+        Amount AS Value 
+    FROM Input1 
+    WHERE Name = $name 
+); 
+ 
+UPSERT INTO Temp 
+SELECT * FROM $data; 
+ 
+COMMIT; 
+ 
+SELECT * FROM Temp ORDER BY Name; 
diff --git a/ydb/tests/functional/canonical/sql/write/multi_write.sql b/ydb/tests/functional/canonical/sql/write/multi_write.sql
index 1c0acf443a..3ebe245da4 100644
--- a/ydb/tests/functional/canonical/sql/write/multi_write.sql
+++ b/ydb/tests/functional/canonical/sql/write/multi_write.sql
@@ -1,19 +1,19 @@
---!syntax_v1
-
-DELETE FROM Input1 ON (Group, Name) VALUES
-    (1, "Name1"),
-    (1, "Name2");
-
-REPLACE INTO Input1 (Group, Name, Amount) VALUES
-    (1, "Name2", 1002),
-    (1, "Name3", 1003),
-    (1, "Name4", 1004);
-
-UPSERT INTO Input1 (Group, Name, Comment) VALUES
-    (1, "Name3", "Upserted"),
-    (1, "Name4", "Upserted"),
-    (1, "Name5", "Upserted"),
-    (1, "Name6", "Upserted");
-
-DELETE FROM Input1 ON (Group, Name) VALUES
-    (1, "Name5");
+--!syntax_v1 
+ 
+DELETE FROM Input1 ON (Group, Name) VALUES 
+    (1, "Name1"), 
+    (1, "Name2"); 
+ 
+REPLACE INTO Input1 (Group, Name, Amount) VALUES 
+    (1, "Name2", 1002), 
+    (1, "Name3", 1003), 
+    (1, "Name4", 1004); 
+ 
+UPSERT INTO Input1 (Group, Name, Comment) VALUES 
+    (1, "Name3", "Upserted"), 
+    (1, "Name4", "Upserted"), 
+    (1, "Name5", "Upserted"), 
+    (1, "Name6", "Upserted"); 
+ 
+DELETE FROM Input1 ON (Group, Name) VALUES 
+    (1, "Name5"); 
diff --git a/ydb/tests/functional/canonical/sql/write/replace.sql b/ydb/tests/functional/canonical/sql/write/replace.sql
index 07a1e83f36..3648a36d44 100644
--- a/ydb/tests/functional/canonical/sql/write/replace.sql
+++ b/ydb/tests/functional/canonical/sql/write/replace.sql
@@ -1,13 +1,13 @@
---!syntax_v1
-REPLACE INTO Input1 (Name, Group, Amount) VALUES
-    ("Name1", 1, 500),
-    ("Name10", 1, 600);
-
-REPLACE INTO Input1 (Name, Group, Comment) VALUES
-    ("Name1", 2, "Replaced1"),
-    ("Name10", 2, "Replaced10");
-
-REPLACE INTO Input
-SELECT key + 1u AS key, subkey, "Replaced" AS value
-FROM Input
-WHERE key > 1;
+--!syntax_v1 
+REPLACE INTO Input1 (Name, Group, Amount) VALUES 
+    ("Name1", 1, 500), 
+    ("Name10", 1, 600); 
+ 
+REPLACE INTO Input1 (Name, Group, Comment) VALUES 
+    ("Name1", 2, "Replaced1"), 
+    ("Name10", 2, "Replaced10"); 
+ 
+REPLACE INTO Input 
+SELECT key + 1u AS key, subkey, "Replaced" AS value 
+FROM Input 
+WHERE key > 1; 
diff --git a/ydb/tests/functional/canonical/sql/write/test_config.json b/ydb/tests/functional/canonical/sql/write/test_config.json
index c933b4d80f..154ee80a44 100644
--- a/ydb/tests/functional/canonical/sql/write/test_config.json
+++ b/ydb/tests/functional/canonical/sql/write/test_config.json
@@ -1,56 +1,56 @@
 {
   "delete_by_pk.sql": {
     "compare_tables": ["Input"]
-  },
-  "delete_on.sql": {
-    "compare_tables": ["Input", "Input1"]
-  },
-  "delete_same.sql": {
+  }, 
+  "delete_on.sql": { 
+    "compare_tables": ["Input", "Input1"] 
+  }, 
+  "delete_same.sql": { 
     "compare_tables": ["Input1"],
     "check_new_engine_plan": false
-  },
-  "insert_revert.sql": {
-    "compare_tables": ["Input", "Input1"]
-  },
-  "insert.sql": {
-    "compare_tables": ["Input", "Input1"]
-  },
-  "multi_write.sql": {
-    "compare_tables": ["Input1"]
-  },
-  "replace.sql": {
-    "compare_tables": ["Input", "Input1"]
-  },
-  "update_on.sql": {
-    "compare_tables": ["Input", "Input1"]
-  },
-  "update.sql": {
-    "compare_tables": ["Input1"]
-  },
-  "upsert_cast.sql": {
-    "compare_tables": ["Input1"]
-  },
-  "upsert.sql": {
-    "compare_tables": ["Input", "Input1"]
-  },
-  "multi_usage.script": {
-    "parameters_types": {
-      "$Name1": "Utf8",
-      "$Name2": "Utf8"
-    },
-    "parameters_values": {
-      "$Name1": "Anna",
-      "$Name2": ""
-    }
-  },
-  "multi_usage_key.script": {
-    "parameters_types": {
-      "$Name1": "Utf8",
-      "$Name2": "Utf8"
-    },
-    "parameters_values": {
-      "$Name1": "Name1",
-      "$Name2": ""
-    }
+  }, 
+  "insert_revert.sql": { 
+    "compare_tables": ["Input", "Input1"] 
+  }, 
+  "insert.sql": { 
+    "compare_tables": ["Input", "Input1"] 
+  }, 
+  "multi_write.sql": { 
+    "compare_tables": ["Input1"] 
+  }, 
+  "replace.sql": { 
+    "compare_tables": ["Input", "Input1"] 
+  }, 
+  "update_on.sql": { 
+    "compare_tables": ["Input", "Input1"] 
+  }, 
+  "update.sql": { 
+    "compare_tables": ["Input1"] 
+  }, 
+  "upsert_cast.sql": { 
+    "compare_tables": ["Input1"] 
+  }, 
+  "upsert.sql": { 
+    "compare_tables": ["Input", "Input1"] 
+  }, 
+  "multi_usage.script": { 
+    "parameters_types": { 
+      "$Name1": "Utf8", 
+      "$Name2": "Utf8" 
+    }, 
+    "parameters_values": { 
+      "$Name1": "Anna", 
+      "$Name2": "" 
+    } 
+  }, 
+  "multi_usage_key.script": { 
+    "parameters_types": { 
+      "$Name1": "Utf8", 
+      "$Name2": "Utf8" 
+    }, 
+    "parameters_values": { 
+      "$Name1": "Name1", 
+      "$Name2": "" 
+    } 
   }
 }
diff --git a/ydb/tests/functional/canonical/sql/write/update.sql b/ydb/tests/functional/canonical/sql/write/update.sql
index ad9292a243..f27ca4d91b 100644
--- a/ydb/tests/functional/canonical/sql/write/update.sql
+++ b/ydb/tests/functional/canonical/sql/write/update.sql
@@ -1,3 +1,3 @@
---!syntax_v1
-
-UPDATE Input1 SET Amount = -Amount WHERE Group = 1;
+--!syntax_v1 
+ 
+UPDATE Input1 SET Amount = -Amount WHERE Group = 1; 
diff --git a/ydb/tests/functional/canonical/sql/write/update_on.sql b/ydb/tests/functional/canonical/sql/write/update_on.sql
index 64e458d721..3ba2a7a296 100644
--- a/ydb/tests/functional/canonical/sql/write/update_on.sql
+++ b/ydb/tests/functional/canonical/sql/write/update_on.sql
@@ -1,12 +1,12 @@
---!syntax_v1
-
-UPDATE Input ON (key, subkey, value) VALUES
-    (1, 2, "a_updated"),
-    (1, 3, "non_existent1"),
-    (5, 6, "c_updated"),
-    (6, 1, "non_existent2");
-
-UPDATE Input1 ON
-SELECT Group, Name, Amount - 50 AS Amount
-FROM Input1
-WHERE Group = 1;
+--!syntax_v1 
+ 
+UPDATE Input ON (key, subkey, value) VALUES 
+    (1, 2, "a_updated"), 
+    (1, 3, "non_existent1"), 
+    (5, 6, "c_updated"), 
+    (6, 1, "non_existent2"); 
+ 
+UPDATE Input1 ON 
+SELECT Group, Name, Amount - 50 AS Amount 
+FROM Input1 
+WHERE Group = 1; 
diff --git a/ydb/tests/functional/canonical/sql/write/upsert.sql b/ydb/tests/functional/canonical/sql/write/upsert.sql
index 819490f565..53501c393e 100644
--- a/ydb/tests/functional/canonical/sql/write/upsert.sql
+++ b/ydb/tests/functional/canonical/sql/write/upsert.sql
@@ -1,13 +1,13 @@
---!syntax_v1
-UPSERT INTO Input1 (Name, Group, Amount) VALUES
-    ("Name1", 1, 500),
-    ("Name10", 1, 600);
-
-UPSERT INTO Input1 (Name, Group, Comment) VALUES
-    ("Name1", 2, "Upserted1"),
-    ("Name10", 2, "Upserted10");
-
-UPSERT INTO Input
-SELECT key, subkey + 1u AS subkey, "Upserted" AS value
-FROM Input
-WHERE key < 5;
+--!syntax_v1 
+UPSERT INTO Input1 (Name, Group, Amount) VALUES 
+    ("Name1", 1, 500), 
+    ("Name10", 1, 600); 
+ 
+UPSERT INTO Input1 (Name, Group, Comment) VALUES 
+    ("Name1", 2, "Upserted1"), 
+    ("Name10", 2, "Upserted10"); 
+ 
+UPSERT INTO Input 
+SELECT key, subkey + 1u AS subkey, "Upserted" AS value 
+FROM Input 
+WHERE key < 5; 
diff --git a/ydb/tests/functional/canonical/sql/write/upsert_cast.sql b/ydb/tests/functional/canonical/sql/write/upsert_cast.sql
index f6bdeb7ade..87d2e542d5 100644
--- a/ydb/tests/functional/canonical/sql/write/upsert_cast.sql
+++ b/ydb/tests/functional/canonical/sql/write/upsert_cast.sql
@@ -1,6 +1,6 @@
---!syntax_v1
-
-UPSERT INTO Input1
-SELECT key AS Group, subkey AS Amount, value AS Name
-FROM Input;
-
+--!syntax_v1 
+ 
+UPSERT INTO Input1 
+SELECT key AS Group, subkey AS Amount, value AS Name 
+FROM Input; 
+ 
diff --git a/ydb/tests/functional/canonical/sql/write/write_group_by.script b/ydb/tests/functional/canonical/sql/write/write_group_by.script
index d0296340dd..48c7c6cabf 100644
--- a/ydb/tests/functional/canonical/sql/write/write_group_by.script
+++ b/ydb/tests/functional/canonical/sql/write/write_group_by.script
@@ -1,18 +1,18 @@
---!syntax_v1
-
-CREATE TABLE Temp (
-    Group Uint64,
-    MinAmount Int64,
-    Value String,
-    PRIMARY KEY (Group)
-);
-
-COMMIT;
-
-UPSERT INTO Temp
-SELECT Group, MIN(Amount) AS MinAmount, "" as Value FROM Input1
-GROUP BY Group;
-
-COMMIT;
-
-SELECT * FROM Temp ORDER BY Group;
+--!syntax_v1 
+ 
+CREATE TABLE Temp ( 
+    Group Uint64, 
+    MinAmount Int64, 
+    Value String, 
+    PRIMARY KEY (Group) 
+); 
+ 
+COMMIT; 
+ 
+UPSERT INTO Temp 
+SELECT Group, MIN(Amount) AS MinAmount, "" as Value FROM Input1 
+GROUP BY Group; 
+ 
+COMMIT; 
+ 
+SELECT * FROM Temp ORDER BY Group; 
diff --git a/ydb/tests/functional/suite_tests/test_sql_logic.py b/ydb/tests/functional/suite_tests/test_sql_logic.py
index aa5b0d5292..df86e555a6 100644
--- a/ydb/tests/functional/suite_tests/test_sql_logic.py
+++ b/ydb/tests/functional/suite_tests/test_sql_logic.py
@@ -17,7 +17,7 @@ from test_base import BaseSuiteRunner, get_token, get_test_suites, safe_execute,
 
 class TestSQLLogic(BaseSuiteRunner):
     check_new_engine_plan = False
-    check_new_engine_query_results = True
+    check_new_engine_query_results = True 
 
     def execute_assert(self, left, right, message):
         assert left == right, message
diff --git a/ydb/tests/library/harness/kikimr_config.py b/ydb/tests/library/harness/kikimr_config.py
index 57c282b9f4..d4fa6ea781 100644
--- a/ydb/tests/library/harness/kikimr_config.py
+++ b/ydb/tests/library/harness/kikimr_config.py
@@ -156,7 +156,7 @@ class KikimrConfigGenerator(object):
         self.domain_name = domain_name
         self.__number_of_pdisks_per_node = 1 + len(dynamic_pdisks)
         self.__load_udfs = load_udfs
-        self.__udfs_path = udfs_path
+        self.__udfs_path = udfs_path 
         self.__yql_config_path = yql_config_path
         self.__auth_config_path = auth_config_path
         self.__slot_count = slot_count
@@ -339,9 +339,9 @@ class KikimrConfigGenerator(object):
     def get_yql_udfs_to_load(self):
         if not self.__load_udfs:
             return []
-        udfs_path = self.__udfs_path or yatest_common.build_path("yql/udfs")
+        udfs_path = self.__udfs_path or yatest_common.build_path("yql/udfs") 
         result = []
-        for dirpath, dnames, fnames in os.walk(udfs_path):
+        for dirpath, dnames, fnames in os.walk(udfs_path): 
             for f in fnames:
                 if f.endswith(".so"):
                     full = os.path.join(dirpath, f)
diff --git a/ydb/tests/library/harness/kikimr_runner.py b/ydb/tests/library/harness/kikimr_runner.py
index 251f485b5d..7607009d68 100644
--- a/ydb/tests/library/harness/kikimr_runner.py
+++ b/ydb/tests/library/harness/kikimr_runner.py
@@ -617,8 +617,8 @@ class KikimrExternalNode(daemon.ExternalNodeDaemon, kikimr_node_interface.NodeIn
     @property
     def grpc_port(self):
         return self.__port
-
-    @property
+ 
+    @property 
     def mbus_port(self):
         return self.__mbus_port