YQL-20086 providers

commit_hash:3f4b66a979b9b87af7cdfd80f139eb132532e910

32 files changed, 605 insertions, 583 deletions

diff --git a/yql/essentials/providers/common/codec/yql_json_codec.h b/yql/essentials/providers/common/codec/yql_json_codec.h
index 46ed2927e16..aec74763e00 100644
--- a/yql/essentials/providers/common/codec/yql_json_codec.h
+++ b/yql/essentials/providers/common/codec/yql_json_codec.h
@@ -25,7 +25,7 @@ using TValueConvertPolicy = TEnumBitSet<EValueConvertPolicy, EValueConvertPolicy
 
 class DefaultPolicy {
 public:
-    static DefaultPolicy& getInstance() {
+    static DefaultPolicy& GetInstance() {
         static DefaultPolicy instance;
         return instance;
     }
@@ -38,16 +38,16 @@ public:
     void operator=(const DefaultPolicy &) = delete;
 
     TValueConvertPolicy CloudFunction() const {
-        return CloudFunctionPolicy;
+        return CloudFunctionPolicy_;
     }
 
     TValueConvertPolicy Export() const {
-        return ExportPolicy;
+        return ExportPolicy_;
     }
 
 private:
-    TValueConvertPolicy CloudFunctionPolicy = TValueConvertPolicy{NUMBER_AS_STRING, BOOL_AS_STRING};
-    TValueConvertPolicy ExportPolicy = TValueConvertPolicy{DISALLOW_NaN};
+    TValueConvertPolicy CloudFunctionPolicy_ = TValueConvertPolicy{NUMBER_AS_STRING, BOOL_AS_STRING};
+    TValueConvertPolicy ExportPolicy_ = TValueConvertPolicy{DISALLOW_NaN};
 };
 
 
diff --git a/yql/essentials/providers/common/codec/yql_json_codec_ut.cpp b/yql/essentials/providers/common/codec/yql_json_codec_ut.cpp
index fc3d0a43c77..b9e6eed0dbd 100644
--- a/yql/essentials/providers/common/codec/yql_json_codec_ut.cpp
+++ b/yql/essentials/providers/common/codec/yql_json_codec_ut.cpp
@@ -585,7 +585,7 @@ Y_UNIT_TEST_SUITE(DefaultPolicy) {
     Y_UNIT_TEST(CloudFunction) {
         TTestContext ctx;
         auto value = NUdf::TUnboxedValuePod(i64(540138));
-        auto policy = DefaultPolicy::getInstance().CloudFunction();
+        auto policy = DefaultPolicy::GetInstance().CloudFunction();
         auto json = WriteValueToExportJsonStr(value, TDataType::Create(NUdf::TDataType<i64>::Id, ctx.TypeEnv), policy);
         UNIT_ASSERT_VALUES_EQUAL(json, "\"540138\"");
     }
diff --git a/yql/essentials/providers/common/comp_nodes/yql_formattypediff.cpp b/yql/essentials/providers/common/comp_nodes/yql_formattypediff.cpp
index cd96c764709..d6e4da78a7b 100644
--- a/yql/essentials/providers/common/comp_nodes/yql_formattypediff.cpp
+++ b/yql/essentials/providers/common/comp_nodes/yql_formattypediff.cpp
@@ -16,13 +16,13 @@ class TFormatTypeDiffWrapper : public TMutableComputationNode<TFormatTypeDiffWra
 public:
     TFormatTypeDiffWrapper(TComputationMutables& mutables, IComputationNode* handle_left, IComputationNode* handle_right)
         : TBaseComputation(mutables)
-        , HandleLeft(handle_left)
-        , HandleRight(handle_right)
+        , HandleLeft_(handle_left)
+        , HandleRight_(handle_right)
     {}
 
     NUdf::TUnboxedValue DoCalculate(TComputationContext& ctx) const {
-        const NYql::TTypeAnnotationNode* type_left = GetYqlType(HandleLeft->GetValue(ctx));
-        const NYql::TTypeAnnotationNode* type_right =  GetYqlType(HandleRight->GetValue(ctx));
+        const NYql::TTypeAnnotationNode* type_left = GetYqlType(HandleLeft_->GetValue(ctx));
+        const NYql::TTypeAnnotationNode* type_right =  GetYqlType(HandleRight_->GetValue(ctx));
         if constexpr (Pretty) {
             return MakeString(NYql::GetTypePrettyDiff(*type_left, *type_right));
         } else {
@@ -31,13 +31,13 @@ public:
     }
 
     void RegisterDependencies() const override {
-        this->DependsOn(HandleLeft);
-        this->DependsOn(HandleRight);
+        this->DependsOn(HandleLeft_);
+        this->DependsOn(HandleRight_);
     }
 
 private:
-    IComputationNode* HandleLeft;
-    IComputationNode* HandleRight;
+    IComputationNode* HandleLeft_;
+    IComputationNode* HandleRight_;
 };
 
 IComputationNode* WrapFormatTypeDiff(TCallable& callable, const TComputationNodeFactoryContext& ctx, ui32 exprCtxMutableIndex) {
@@ -48,7 +48,7 @@ IComputationNode* WrapFormatTypeDiff(TCallable& callable, const TComputationNode
     auto handle_right = LocateNode(ctx.NodeLocator, callable, 1);
     if (pretty) {
         return new TFormatTypeDiffWrapper<true>(ctx.Mutables, handle_left, handle_right);
-    } 
+    }
     return new TFormatTypeDiffWrapper<false>(ctx.Mutables, handle_left, handle_right);
 }
 
diff --git a/yql/essentials/providers/common/config/yql_configuration_transformer.cpp b/yql/essentials/providers/common/config/yql_configuration_transformer.cpp
index 721a5d7f50a..574367c257d 100644
--- a/yql/essentials/providers/common/config/yql_configuration_transformer.cpp
+++ b/yql/essentials/providers/common/config/yql_configuration_transformer.cpp
@@ -16,12 +16,12 @@ using namespace NNodes;
 TProviderConfigurationTransformer::TProviderConfigurationTransformer(TSettingDispatcher::TPtr dispatcher,
     const TTypeAnnotationContext& types, const TString& provider, const THashSet<TStringBuf>& configureCallables)
     : Dispatcher(dispatcher)
-    , Types(types)
-    , Provider(provider)
-    , ConfigureCallables(configureCallables)
+    , Types_(types)
+    , Provider_(provider)
+    , ConfigureCallables_(configureCallables)
 {
-    if (ConfigureCallables.empty()) {
-        ConfigureCallables.insert(TCoConfigure::CallableName());
+    if (ConfigureCallables_.empty()) {
+        ConfigureCallables_.insert(TCoConfigure::CallableName());
     }
 }
 
@@ -36,7 +36,7 @@ IGraphTransformer::TStatus TProviderConfigurationTransformer::DoTransform(TExprN
     TOptimizeExprSettings settings(nullptr);
     settings.VisitChanges = true;
     auto status = OptimizeExpr(input, output, [&](const TExprNode::TPtr& node, TExprContext& ctx) -> TExprNode::TPtr {
-        if (node->IsCallable(ConfigureCallables)) {
+        if (node->IsCallable(ConfigureCallables_)) {
             if (!EnsureMinArgsCount(*node, 2, ctx)) {
                 return nullptr;
             }
@@ -45,7 +45,7 @@ IGraphTransformer::TStatus TProviderConfigurationTransformer::DoTransform(TExprN
                 return node;
             }
             auto ds = node->Child(TCoConfigure::idx_DataSource);
-            if (ds->Child(TCoDataSource::idx_Category)->Content() != Provider) {
+            if (ds->Child(TCoDataSource::idx_Category)->Content() != Provider_) {
                 return node;
             }
             if (!EnsureMinArgsCount(*ds, 2, ctx)) {
@@ -134,19 +134,23 @@ bool TProviderConfigurationTransformer::HandleAttr(TPositionHandle pos, const TS
     return Dispatcher->Dispatch(cluster, name, value, TSettingDispatcher::EStage::STATIC, TSettingDispatcher::GetErrorCallback(pos, ctx));
 }
 
+TSettingDispatcher::TPtr TProviderConfigurationTransformer::GetDispatcher() const {
+    return Dispatcher;
+}
+
 bool TProviderConfigurationTransformer::HandleAuth(TPositionHandle pos, const TString& cluster, const TString& alias,
     TExprContext& ctx)
 {
-    auto cred = Types.Credentials->FindCredential(alias);
+    auto cred = Types_.Credentials->FindCredential(alias);
     if (!cred) {
         ctx.AddError(TIssue(ctx.GetPosition(pos), TStringBuilder() << "Unknown credential: " << alias));
         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));
+            << Provider_ << ", but found: " << cred->Category));
         return false;
     }
 
diff --git a/yql/essentials/providers/common/config/yql_configuration_transformer.h b/yql/essentials/providers/common/config/yql_configuration_transformer.h
index 64622c463c9..a4955a71890 100644
--- a/yql/essentials/providers/common/config/yql_configuration_transformer.h
+++ b/yql/essentials/providers/common/config/yql_configuration_transformer.h
@@ -27,10 +27,13 @@ protected:
     virtual bool HandleAuth(TPositionHandle pos, const TString& cluster, const TString& alias, TExprContext& ctx);
 
 protected:
-    TSettingDispatcher::TPtr Dispatcher;
-    const TTypeAnnotationContext& Types;
-    TString Provider;
-    THashSet<TStringBuf> ConfigureCallables;
+    // FIXME switch to an accessor
+    TSettingDispatcher::TPtr GetDispatcher() const;
+
+    TSettingDispatcher::TPtr Dispatcher; // NOLINT(readability-identifier-naming)
+    const TTypeAnnotationContext& Types_;
+    TString Provider_;
+    THashSet<TStringBuf> ConfigureCallables_;
 };
 
 THolder<IGraphTransformer> CreateProviderConfigurationTransformer(
diff --git a/yql/essentials/providers/common/config/yql_dispatch.cpp b/yql/essentials/providers/common/config/yql_dispatch.cpp
index 2e195720394..053d949bc82 100644
--- a/yql/essentials/providers/common/config/yql_dispatch.cpp
+++ b/yql/essentials/providers/common/config/yql_dispatch.cpp
@@ -92,7 +92,7 @@ namespace NCommon {
 
 bool TSettingDispatcher::IsRuntime(const TString& name) {
     auto normalizedName = NormalizeName(name);
-    if (auto handler = Handlers.Value(normalizedName, TSettingHandler::TPtr())) {
+    if (auto handler = Handlers_.Value(normalizedName, TSettingHandler::TPtr())) {
         return handler->IsRuntime();
     }
     return false;
@@ -100,7 +100,7 @@ bool TSettingDispatcher::IsRuntime(const TString& name) {
 
 bool TSettingDispatcher::Dispatch(const TString& cluster, const TString& name, const TMaybe<TString>& value, EStage stage, const TErrorCallback& errorCallback) {
     auto normalizedName = NormalizeName(name);
-    if (auto handler = Handlers.Value(normalizedName, TSettingHandler::TPtr())) {
+    if (auto handler = Handlers_.Value(normalizedName, TSettingHandler::TPtr())) {
         if (cluster != ALL_CLUSTERS) {
             if (!handler->IsPerCluster()) {
                 return errorCallback(TStringBuilder() << "Static setting " << name.Quote() << " cannot be set for specific cluster", true);
@@ -142,7 +142,7 @@ bool TSettingDispatcher::Dispatch(const TString& cluster, const TString& name, c
         }
 
         TStringBuilder nearHandlerMsg;
-        for (auto& item: Handlers) {
+        for (auto& item: Handlers_) {
             if (NLevenshtein::Distance(normalizedName, item.first) < DefaultMistypeDistance) {
                 nearHandlerMsg << ", did you mean " << item.second->GetDisplayName().Quote() << '?';
                 break;
@@ -153,23 +153,27 @@ bool TSettingDispatcher::Dispatch(const TString& cluster, const TString& name, c
 }
 
 void TSettingDispatcher::FreezeDefaults() {
-    for (auto& item: Handlers) {
+    for (auto& item: Handlers_) {
         item.second->FreezeDefault();
     }
 }
 
 void TSettingDispatcher::Restore() {
-    for (auto& item: Handlers) {
+    for (auto& item: Handlers_) {
         item.second->Restore(ALL_CLUSTERS);
     }
 }
 
 void TSettingDispatcher::Enumerate(std::function<void(std::string_view)> callback) {
-    for (const auto& name : Names) {
+    for (const auto& name : Names_) {
         callback(name);
     }
 }
 
+const THashSet<TString>& TSettingDispatcher::GetValidClusters() const {
+    return ValidClusters;
+}
+
 TSettingDispatcher::TErrorCallback TSettingDispatcher::GetDefaultErrorCallback() {
     return [] (const TString& msg, bool isError) -> bool {
         if (isError) {
diff --git a/yql/essentials/providers/common/config/yql_dispatch.h b/yql/essentials/providers/common/config/yql_dispatch.h
index fd74a29f62f..9265e2e0f8e 100644
--- a/yql/essentials/providers/common/config/yql_dispatch.h
+++ b/yql/essentials/providers/common/config/yql_dispatch.h
@@ -352,12 +352,12 @@ public:
     template <typename TType, EConfSettingType SettingType>
     TSettingHandlerImpl<TType, SettingType>& AddSetting(const TString& name, TConfSetting<TType, SettingType>& setting) {
         TIntrusivePtr<TSettingHandlerImpl<TType, SettingType>> handler = new TSettingHandlerImpl<TType, SettingType>(name, setting);
-        if (!Handlers.insert({NormalizeName(name), handler}).second) {
+        if (!Handlers_.insert({NormalizeName(name), handler}).second) {
             ythrow yexception() << "Duplicate configuration setting name " << name.Quote();
         }
 
         if (!name.StartsWith('_')) {
-            Names.insert(name);
+            Names_.insert(name);
         }
 
         return *handler;
@@ -402,9 +402,12 @@ public:
     void Enumerate(std::function<void(std::string_view)> callback);
 
 protected:
-    THashSet<TString> ValidClusters;
-    THashMap<TString, TSettingHandler::TPtr> Handlers;
-    TSet<TString> Names;
+    // FIXME switch usages to an acesssor
+    const THashSet<TString>& GetValidClusters() const;
+
+    THashSet<TString> ValidClusters; // NOLINT(readability-identifier-naming)
+    THashMap<TString, TSettingHandler::TPtr> Handlers_;
+    TSet<TString> Names_;
 };
 
 } // namespace NCommon
diff --git a/yql/essentials/providers/common/config/yql_setting.h b/yql/essentials/providers/common/config/yql_setting.h
index 1d0be5750ef..b527cb609e3 100644
--- a/yql/essentials/providers/common/config/yql_setting.h
+++ b/yql/essentials/providers/common/config/yql_setting.h
@@ -23,7 +23,7 @@ class TConfSetting {
 public:
     TConfSetting() = default;
     TConfSetting(const TType& value) {
-        PerClusterValue[ALL_CLUSTERS] = value;
+        PerClusterValue_[ALL_CLUSTERS] = value;
     }
     TConfSetting(const TConfSetting&) = default;
     TConfSetting(TConfSetting&&) = default;
@@ -39,13 +39,13 @@ public:
 
     TType& operator[](const TString& cluster) {
         if (ALL_CLUSTERS == cluster) {
-            PerClusterValue.clear();
+            PerClusterValue_.clear();
         }
-        return PerClusterValue[cluster];
+        return PerClusterValue_[cluster];
     }
     TConfSetting& operator =(const TType& value) {
-        PerClusterValue.clear();
-        PerClusterValue[ALL_CLUSTERS] = value;
+        PerClusterValue_.clear();
+        PerClusterValue_[ALL_CLUSTERS] = value;
         return *this;
     }
     TConfSetting& operator =(const TConfSetting&) = default;
@@ -53,20 +53,20 @@ public:
 
     template <typename TFunc>
     void UpdateAll(TFunc func) {
-        PerClusterValue[ALL_CLUSTERS]; // insert record for all clusters if it is not present
-        for (auto& it: PerClusterValue) {
+        PerClusterValue_[ALL_CLUSTERS]; // insert record for all clusters if it is not present
+        for (auto& it: PerClusterValue_) {
             func(it.first, it.second);
         }
     }
 
     TMaybe<TType> Get(const TString& cluster) const {
-        if (!PerClusterValue.empty()) {
-            auto it = PerClusterValue.find(cluster);
-            if (it != PerClusterValue.end()) {
+        if (!PerClusterValue_.empty()) {
+            auto it = PerClusterValue_.find(cluster);
+            if (it != PerClusterValue_.end()) {
                 return MakeMaybe(it->second);
             }
-            it = PerClusterValue.find(ALL_CLUSTERS);
-            if (it != PerClusterValue.end()) {
+            it = PerClusterValue_.find(ALL_CLUSTERS);
+            if (it != PerClusterValue_.end()) {
                 return MakeMaybe(it->second);
             }
         }
@@ -74,19 +74,19 @@ public:
     }
 
     void Clear() {
-        PerClusterValue.clear();
+        PerClusterValue_.clear();
     }
 
     void Clear(const TString& cluster) {
         if (ALL_CLUSTERS == cluster) {
-            PerClusterValue.clear();
+            PerClusterValue_.clear();
         } else {
-            PerClusterValue.erase(cluster);
+            PerClusterValue_.erase(cluster);
         }
     }
 
 private:
-    NSorted::TSimpleMap<TString, TType> PerClusterValue; // Uses special '$all' key for all clusters
+    NSorted::TSimpleMap<TString, TType> PerClusterValue_; // Uses special '$all' key for all clusters
 };
 
 template <typename TType>
@@ -94,7 +94,7 @@ class TConfSetting<TType, EConfSettingType::Static> {
 public:
     TConfSetting() = default;
     TConfSetting(const TType& value)
-        : Value(value)
+        : Value_(value)
     {
     }
     TConfSetting(const TConfSetting&) = default;
@@ -113,30 +113,30 @@ public:
         if (cluster != ALL_CLUSTERS) {
             ythrow yexception() << "Global static setting cannot be set for specific cluster";
         }
-        Value.ConstructInPlace();
-        return Value.GetRef();
+        Value_.ConstructInPlace();
+        return Value_.GetRef();
     }
     TConfSetting& operator =(const TType& value) {
-        Value = value;
+        Value_ = value;
         return *this;
     }
     TConfSetting& operator =(const TConfSetting&) = default;
     TConfSetting& operator =(TConfSetting&&) = default;
 
     TMaybe<TType> Get() const {
-        return Value;
+        return Value_;
     }
 
     void Clear() {
-        Value.Clear();
+        Value_.Clear();
     }
 
     void Clear(const TString&) {
-        Value.Clear();
+        Value_.Clear();
     }
 
 private:
-    TMaybe<TType> Value;
+    TMaybe<TType> Value_;
 };
 
 } // namespace NCommon
diff --git a/yql/essentials/providers/common/metrics/metrics_registry.cpp b/yql/essentials/providers/common/metrics/metrics_registry.cpp
index 5b796c2d824..89862982142 100644
--- a/yql/essentials/providers/common/metrics/metrics_registry.cpp
+++ b/yql/essentials/providers/common/metrics/metrics_registry.cpp
@@ -249,8 +249,8 @@ private:
                 auto histogram = group->GetNamedHistogram(
                     label.GetName(), label.GetValue(),
                     THolder(collector));
-                Histograms.insert(std::make_pair(histogram, collector));
-                Histograms[histogram]->Collect(*histSnapshot);
+                Histograms_.insert(std::make_pair(histogram, collector));
+                Histograms_[histogram]->Collect(*histSnapshot);
             } else {
                 auto counter = group->GetNamedCounter(
                             label.GetName(), label.GetValue(),
@@ -275,7 +275,7 @@ private:
     TSensorsGroupPtr Sensors_;
     const TMaybe<TString> UserName_;
 
-    THashMap<NMonitoring::THistogramPtr, NMonitoring::IHistogramCollector*> Histograms;
+    THashMap<NMonitoring::THistogramPtr, NMonitoring::IHistogramCollector*> Histograms_;
 };
 
 } // namespace
diff --git a/yql/essentials/providers/common/mkql/yql_provider_mkql.cpp b/yql/essentials/providers/common/mkql/yql_provider_mkql.cpp
index 733bc5a3ad5..24505ba8d3b 100644
--- a/yql/essentials/providers/common/mkql/yql_provider_mkql.cpp
+++ b/yql/essentials/providers/common/mkql/yql_provider_mkql.cpp
@@ -251,11 +251,11 @@ std::pair<TLayout, ui16> CutTimezone(const std::string_view& atom) {
 } // namespace
 
 bool TMkqlCallableCompilerBase::HasCallable(const std::string_view& name) const {
-    return Callables.contains(name);
+    return Callables_.contains(name);
 }
 
 void TMkqlCallableCompilerBase::AddCallable(const std::string_view& name, TCompiler compiler) {
-    const auto result = Callables.emplace(TString(name), compiler);
+    const auto result = Callables_.emplace(TString(name), compiler);
     YQL_ENSURE(result.second, "Callable already exists: " << name);
 }
 
@@ -354,21 +354,21 @@ void TMkqlCallableCompilerBase::AddSimpleCallables(const std::initializer_list<s
 }
 
 void TMkqlCallableCompilerBase::OverrideCallable(const std::string_view& name, TCompiler compiler) {
-    const auto prevCompiler = Callables.find(name);
-    YQL_ENSURE(Callables.cend() != prevCompiler, "Missed callable: " << name);
+    const auto prevCompiler = Callables_.find(name);
+    YQL_ENSURE(Callables_.cend() != prevCompiler, "Missed callable: " << name);
     prevCompiler->second = compiler;
-    Callables[name] = 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);
+    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();
+    const auto compiler = Callables_.find(name);
+    return Callables_.cend() != compiler ? compiler->second : IMkqlCallableCompiler::TCompiler();
 }
 
 bool TMkqlCommonCallableCompiler::HasCallable(const std::string_view& name) const {
diff --git a/yql/essentials/providers/common/mkql/yql_provider_mkql.h b/yql/essentials/providers/common/mkql/yql_provider_mkql.h
index 1cdcfd82624..b4dc285d2a6 100644
--- a/yql/essentials/providers/common/mkql/yql_provider_mkql.h
+++ b/yql/essentials/providers/common/mkql/yql_provider_mkql.h
@@ -74,7 +74,7 @@ public:
     virtual void OverrideCallable(const std::string_view& name, TCompiler compiler);
 
 private:
-    THashMap<TString, TCompiler> Callables;
+    THashMap<TString, TCompiler> Callables_;
 
 protected:
     void AddSimpleCallables(const std::initializer_list<std::pair<std::string_view, NKikimr::NMiniKQL::TProgramBuilder::UnaryFunctionMethod>>& callables);
diff --git a/yql/essentials/providers/common/schema/expr/yql_expr_schema.cpp b/yql/essentials/providers/common/schema/expr/yql_expr_schema.cpp
index 1ac4c89927f..b834794b5bd 100644
--- a/yql/essentials/providers/common/schema/expr/yql_expr_schema.cpp
+++ b/yql/essentials/providers/common/schema/expr/yql_expr_schema.cpp
@@ -139,15 +139,15 @@ class TExprTypeSaver: public TSaver<TExprTypeSaver<TSaver>> {
     void SaveErrorType(const TErrorExprType& errorType) {
         TBase::SaveTypeHeader("ErrorType");
         auto err = errorType.GetError();
-        TBase::Writer.OnListItem();
-        TBase::Writer.OnInt64Scalar(err.Position.Row);
-        TBase::Writer.OnListItem();
-        TBase::Writer.OnInt64Scalar(err.Position.Column);
-        TBase::Writer.OnListItem();
-        TBase::Writer.OnStringScalar(err.Position.File);
-        TBase::Writer.OnListItem();
-        TBase::Writer.OnStringScalar(err.GetMessage());
-        TBase::Writer.OnEndList();
+        TBase::Writer_.OnListItem();
+        TBase::Writer_.OnInt64Scalar(err.Position.Row);
+        TBase::Writer_.OnListItem();
+        TBase::Writer_.OnInt64Scalar(err.Position.Column);
+        TBase::Writer_.OnListItem();
+        TBase::Writer_.OnStringScalar(err.Position.File);
+        TBase::Writer_.OnListItem();
+        TBase::Writer_.OnStringScalar(err.GetMessage());
+        TBase::Writer_.OnEndList();
     }
 
 public:
diff --git a/yql/essentials/providers/common/schema/parser/yql_type_parser.cpp b/yql/essentials/providers/common/schema/parser/yql_type_parser.cpp
index fb159ffeb1c..22299aba86d 100644
--- a/yql/essentials/providers/common/schema/parser/yql_type_parser.cpp
+++ b/yql/essentials/providers/common/schema/parser/yql_type_parser.cpp
@@ -7,15 +7,15 @@ namespace NYql {
 namespace NCommon {
 
 void TYqlTypeYsonSaverBase::SaveTypeHeader(TStringBuf name) {
-    Writer.OnBeginList();
-    Writer.OnListItem();
-    Writer.OnStringScalar(name);
+    Writer_.OnBeginList();
+    Writer_.OnListItem();
+    Writer_.OnStringScalar(name);
 }
 
 #define SAVE_TYPE_IMPL(type) \
 void TYqlTypeYsonSaverBase::Save ## type() { \
     SaveTypeHeader(#type); \
-    Writer.OnEndList(); \
+    Writer_.OnEndList(); \
 }
 
 SAVE_TYPE_IMPL(Type)
@@ -30,45 +30,45 @@ SAVE_TYPE_IMPL(EmptyDictType)
 
 void TYqlTypeYsonSaverBase::SaveDataType(const TStringBuf& dataType) {
     SaveTypeHeader("DataType");
-    Writer.OnListItem();
-    Writer.OnStringScalar(dataType);
-    Writer.OnEndList();
+    Writer_.OnListItem();
+    Writer_.OnStringScalar(dataType);
+    Writer_.OnEndList();
 }
 
 void TYqlTypeYsonSaverBase::SavePgType(const TStringBuf& pgType) {
     SaveTypeHeader("PgType");
-    Writer.OnListItem();
-    Writer.OnStringScalar(pgType);
-    if (ExtendedForm) {
-        Writer.OnListItem();
+    Writer_.OnListItem();
+    Writer_.OnStringScalar(pgType);
+    if (ExtendedForm_) {
+        Writer_.OnListItem();
         const auto& desc = NYql::NPg::LookupType(TString(pgType));
         char cat = desc.Category;
         if (desc.ArrayTypeId == desc.TypeId) {
             cat = NYql::NPg::LookupType(desc.ElementTypeId).Category;
         }
-        
-        Writer.OnStringScalar(TStringBuf(&cat, 1));
+
+        Writer_.OnStringScalar(TStringBuf(&cat, 1));
     }
-    
-    Writer.OnEndList();
+
+    Writer_.OnEndList();
 }
 
 void TYqlTypeYsonSaverBase::SaveDataTypeParams(const TStringBuf& dataType, const TStringBuf& paramOne, const TStringBuf& paramTwo) {
     SaveTypeHeader("DataType");
-    Writer.OnListItem();
-    Writer.OnStringScalar(dataType);
-    Writer.OnListItem();
-    Writer.OnStringScalar(paramOne);
-    Writer.OnListItem();
-    Writer.OnStringScalar(paramTwo);
-    Writer.OnEndList();
+    Writer_.OnListItem();
+    Writer_.OnStringScalar(dataType);
+    Writer_.OnListItem();
+    Writer_.OnStringScalar(paramOne);
+    Writer_.OnListItem();
+    Writer_.OnStringScalar(paramTwo);
+    Writer_.OnEndList();
 }
 
 void TYqlTypeYsonSaverBase::SaveResourceType(const TStringBuf& tag) {
     SaveTypeHeader("ResourceType");
-    Writer.OnListItem();
-    Writer.OnStringScalar(tag);
-    Writer.OnEndList();
+    Writer_.OnListItem();
+    Writer_.OnStringScalar(tag);
+    Writer_.OnEndList();
 }
 
 bool ParseYson(NYT::TNode& res, const TStringBuf yson, IOutputStream& err) {
diff --git a/yql/essentials/providers/common/schema/parser/yql_type_parser.h b/yql/essentials/providers/common/schema/parser/yql_type_parser.h
index 4b228dcc526..df673d760b4 100644
--- a/yql/essentials/providers/common/schema/parser/yql_type_parser.h
+++ b/yql/essentials/providers/common/schema/parser/yql_type_parser.h
@@ -17,8 +17,8 @@ public:
     typedef NYson::TYsonConsumerBase TConsumer;
 
     TYqlTypeYsonSaverBase(TConsumer& writer, bool extendedForm)
-        : Writer(writer)
-        , ExtendedForm(extendedForm)
+        : Writer_(writer)
+        , ExtendedForm_(extendedForm)
     {
     }
 
@@ -37,8 +37,8 @@ protected:
     void SaveResourceType(const TStringBuf& tag);
 
 protected:
-    NYson::TYsonConsumerBase& Writer;
-    const bool ExtendedForm;
+    NYson::TYsonConsumerBase& Writer_;
+    const bool ExtendedForm_;
 };
 
 
@@ -61,143 +61,143 @@ protected:
     template <typename TTaggedType>
     void SaveTaggedType(const TTaggedType& taggedType) {
         SaveTypeHeader("TaggedType");
-        Writer.OnListItem();
-        Writer.OnStringScalar(taggedType.GetTag());
-        Writer.OnListItem();
-        TSelf baseType(Writer, ExtendedForm);
+        Writer_.OnListItem();
+        Writer_.OnStringScalar(taggedType.GetTag());
+        Writer_.OnListItem();
+        TSelf baseType(Writer_, ExtendedForm_);
         baseType.Save(taggedType.GetBaseType());
-        Writer.OnEndList();
+        Writer_.OnEndList();
     }
 
     template <typename TStructType>
     void SaveStructType(const TStructType& structType) {
         SaveTypeHeader("StructType");
-        Writer.OnListItem();
-        Writer.OnBeginList();
+        Writer_.OnListItem();
+        Writer_.OnBeginList();
         for (ui32 i = 0, e = structType.GetMembersCount(); i < e; ++i) {
-            Writer.OnListItem();
-            Writer.OnBeginList();
-            Writer.OnListItem();
-            Writer.OnStringScalar(structType.GetMemberName(i));
-            Writer.OnListItem();
-            TSelf value(Writer, ExtendedForm);
+            Writer_.OnListItem();
+            Writer_.OnBeginList();
+            Writer_.OnListItem();
+            Writer_.OnStringScalar(structType.GetMemberName(i));
+            Writer_.OnListItem();
+            TSelf value(Writer_, ExtendedForm_);
             value.Save(structType.GetMemberType(i));
-            Writer.OnEndList();
+            Writer_.OnEndList();
         }
-        Writer.OnEndList();
-        Writer.OnEndList();
+        Writer_.OnEndList();
+        Writer_.OnEndList();
     }
 
     template <typename TListType>
     void SaveListType(const TListType& listType) {
         SaveTypeHeader("ListType");
-        Writer.OnListItem();
-        TSelf item(Writer, ExtendedForm);
+        Writer_.OnListItem();
+        TSelf item(Writer_, ExtendedForm_);
         item.Save(listType.GetItemType());
-        Writer.OnEndList();
+        Writer_.OnEndList();
     }
 
     template <typename TStreamType>
     void SaveStreamType(const TStreamType& streamType) {
         SaveTypeHeader("StreamType");
-        Writer.OnListItem();
-        TSelf item(Writer, ExtendedForm);
+        Writer_.OnListItem();
+        TSelf item(Writer_, ExtendedForm_);
         item.Save(streamType.GetItemType());
-        Writer.OnEndList();
+        Writer_.OnEndList();
     }
 
     template <typename TOptionalType>
     void SaveOptionalType(const TOptionalType& optionalType) {
         SaveTypeHeader("OptionalType");
-        Writer.OnListItem();
-        TSelf item(Writer, ExtendedForm);
+        Writer_.OnListItem();
+        TSelf item(Writer_, ExtendedForm_);
         item.Save(optionalType.GetItemType());
-        Writer.OnEndList();
+        Writer_.OnEndList();
     }
 
     template <typename TDictType>
     void SaveDictType(const TDictType& dictType) {
         SaveTypeHeader("DictType");
-        Writer.OnListItem();
-        TSelf key(Writer, ExtendedForm);
+        Writer_.OnListItem();
+        TSelf key(Writer_, ExtendedForm_);
         key.Save(dictType.GetKeyType());
-        Writer.OnListItem();
-        TSelf val(Writer, ExtendedForm);
+        Writer_.OnListItem();
+        TSelf val(Writer_, ExtendedForm_);
         val.Save(dictType.GetPayloadType());
-        Writer.OnEndList();
+        Writer_.OnEndList();
     }
 
     template <typename TTupleType>
     void SaveTupleType(const TTupleType& tupleType) {
         SaveTypeHeader("TupleType");
-        Writer.OnListItem();
-        Writer.OnBeginList();
+        Writer_.OnListItem();
+        Writer_.OnBeginList();
         for (ui32 i = 0, e = tupleType.GetElementsCount(); i < e; ++i) {
-            Writer.OnListItem();
-            TSelf element(Writer, ExtendedForm);
+            Writer_.OnListItem();
+            TSelf element(Writer_, ExtendedForm_);
             element.Save(tupleType.GetElementType(i));
         }
-        Writer.OnEndList();
-        Writer.OnEndList();
+        Writer_.OnEndList();
+        Writer_.OnEndList();
     }
 
     template <typename TCallableType>
     void SaveCallableType(const TCallableType& callableType) {
         SaveTypeHeader("CallableType");
-        Writer.OnListItem();
+        Writer_.OnListItem();
         // main settings
-        Writer.OnBeginList();
+        Writer_.OnBeginList();
         if (callableType.GetOptionalArgsCount() > 0 || !callableType.GetPayload().empty()) {
-            Writer.OnListItem();
-            Writer.OnUint64Scalar(callableType.GetOptionalArgsCount());
+            Writer_.OnListItem();
+            Writer_.OnUint64Scalar(callableType.GetOptionalArgsCount());
         }
 
         if (!callableType.GetPayload().empty()) {
-            Writer.OnListItem();
-            Writer.OnStringScalar(callableType.GetPayload());
+            Writer_.OnListItem();
+            Writer_.OnStringScalar(callableType.GetPayload());
         }
 
-        Writer.OnEndList();
+        Writer_.OnEndList();
         // ret
-        Writer.OnListItem();
-        Writer.OnBeginList();
-        Writer.OnListItem();
-        TSelf ret(Writer, ExtendedForm);
+        Writer_.OnListItem();
+        Writer_.OnBeginList();
+        Writer_.OnListItem();
+        TSelf ret(Writer_, ExtendedForm_);
         ret.Save(callableType.GetReturnType());
-        Writer.OnEndList();
+        Writer_.OnEndList();
         // args
-        Writer.OnListItem();
-        Writer.OnBeginList();
+        Writer_.OnListItem();
+        Writer_.OnBeginList();
         for (ui32 i = 0, e = callableType.GetArgumentsCount(); i < e; ++i) {
-            Writer.OnListItem();
-            Writer.OnBeginList();
-            Writer.OnListItem();
-            TSelf arg(Writer, ExtendedForm);
+            Writer_.OnListItem();
+            Writer_.OnBeginList();
+            Writer_.OnListItem();
+            TSelf arg(Writer_, ExtendedForm_);
             arg.Save(callableType.GetArgumentType(i));
             if (!callableType.GetArgumentName(i).empty()) {
-                Writer.OnListItem();
-                Writer.OnStringScalar(callableType.GetArgumentName(i));
+                Writer_.OnListItem();
+                Writer_.OnStringScalar(callableType.GetArgumentName(i));
             }
 
             if (callableType.GetArgumentFlags(i) != 0) {
-                Writer.OnListItem();
-                Writer.OnUint64Scalar(callableType.GetArgumentFlags(i));
+                Writer_.OnListItem();
+                Writer_.OnUint64Scalar(callableType.GetArgumentFlags(i));
             }
 
-            Writer.OnEndList();
+            Writer_.OnEndList();
         }
 
-        Writer.OnEndList();
-        Writer.OnEndList();
+        Writer_.OnEndList();
+        Writer_.OnEndList();
     }
 
     template <typename TVariantType>
     void SaveVariantType(const TVariantType& variantType) {
         SaveTypeHeader("VariantType");
-        Writer.OnListItem();
-        TSelf item(Writer, ExtendedForm);
+        Writer_.OnListItem();
+        TSelf item(Writer_, ExtendedForm_);
         item.Save(variantType.GetUnderlyingType());
-        Writer.OnEndList();
+        Writer_.OnEndList();
     }
 };
 
diff --git a/yql/essentials/providers/common/structured_token/yql_structured_token.cpp b/yql/essentials/providers/common/structured_token/yql_structured_token.cpp
index f194e7dca34..88482f68312 100644
--- a/yql/essentials/providers/common/structured_token/yql_structured_token.cpp
+++ b/yql/essentials/providers/common/structured_token/yql_structured_token.cpp
@@ -10,12 +10,12 @@
 namespace NYql {
 
 TStructuredToken::TStructuredToken(TMap<TString, TString>&& data)
-    : Data(std::move(data)) {
+    : Data_(std::move(data)) {
 
 }
 
 TString TStructuredToken::GetField(const TString& name) const {
-    return Data.at(name);
+    return Data_.at(name);
 }
 
 TString TStructuredToken::GetFieldOrDefault(const TString& name, const TString& defaultValue) const {
@@ -23,21 +23,21 @@ TString TStructuredToken::GetFieldOrDefault(const TString& name, const TString&
 }
 
 TMaybe<TString> TStructuredToken::FindField(const TString& name) const {
-    auto* r = Data.FindPtr(name);
+    auto* r = Data_.FindPtr(name);
     return r ? MakeMaybe(*r) : Nothing();
 }
 
 bool TStructuredToken::HasField(const TString& name) const {
-    return Data.contains(name);
+    return Data_.contains(name);
 }
 
 TStructuredToken& TStructuredToken::SetField(const TString& name, const TString& value) {
-    Data[name] = value;
+    Data_[name] = value;
     return *this;
 }
 
 TStructuredToken& TStructuredToken::ClearField(const TString& name) {
-    Data.erase(name);
+    Data_.erase(name);
     return *this;
 }
 
@@ -49,7 +49,7 @@ TString TStructuredToken::ToJson() const {
     NJson::TJsonWriter writer(&output, false, true, true);
     writer.OpenMap();
 
-    for (auto&[k, v] : Data) {
+    for (auto&[k, v] : Data_) {
         if (!IsUtf8(v)) {
             writer.Write(k + "(base64)", Base64Encode(TStringBuf(v)));
         } else {
diff --git a/yql/essentials/providers/common/structured_token/yql_structured_token.h b/yql/essentials/providers/common/structured_token/yql_structured_token.h
index 2789723663b..e1d27f0d59c 100644
--- a/yql/essentials/providers/common/structured_token/yql_structured_token.h
+++ b/yql/essentials/providers/common/structured_token/yql_structured_token.h
@@ -21,7 +21,7 @@ public:
     TString ToJson() const;
 
 private:
-    TMap<TString, TString> Data;
+    TMap<TString, TString> Data_;
 };
 
 // is used for backward compatibility when content contains just token
diff --git a/yql/essentials/providers/common/structured_token/yql_token_builder.cpp b/yql/essentials/providers/common/structured_token/yql_token_builder.cpp
index 8ecae8a4b5a..f09b664ad18 100644
--- a/yql/essentials/providers/common/structured_token/yql_token_builder.cpp
+++ b/yql/essentials/providers/common/structured_token/yql_token_builder.cpp
@@ -6,90 +6,90 @@ TStructuredTokenBuilder::TStructuredTokenBuilder() {
 }
 
 TStructuredTokenBuilder::TStructuredTokenBuilder(const TStructuredToken& data)
-    : Data(data)
+    : Data_(data)
 {
 }
 
 TStructuredTokenBuilder& TStructuredTokenBuilder::SetServiceAccountIdAuth(const TString& accountId, const TString& accountIdSignature) {
-    Data.SetField("sa_id", accountId);
-    Data.SetField("sa_id_signature", accountIdSignature);
+    Data_.SetField("sa_id", accountId);
+    Data_.SetField("sa_id_signature", accountIdSignature);
     return *this;
 }
 
 TStructuredTokenBuilder& TStructuredTokenBuilder::SetServiceAccountIdAuthWithSecret(const TString& accountId, const TString& accountIdSignatureReference, const TString& accountIdSignature) {
-    Data.SetField("sa_id", accountId);
-    Data.SetField("sa_id_signature_ref", accountIdSignatureReference);
-    Data.SetField("sa_id_signature", accountIdSignature);
+    Data_.SetField("sa_id", accountId);
+    Data_.SetField("sa_id_signature_ref", accountIdSignatureReference);
+    Data_.SetField("sa_id_signature", accountIdSignature);
     return *this;
 }
 
 TStructuredTokenBuilder& TStructuredTokenBuilder::SetBasicAuth(const TString& login, const TString& password) {
-    Data.SetField("basic_login", login);
-    Data.SetField("basic_password", password);
+    Data_.SetField("basic_login", login);
+    Data_.SetField("basic_password", password);
     return *this;
 }
 
 TStructuredTokenBuilder& TStructuredTokenBuilder::SetBasicAuthWithSecret(const TString& login, const TString& passwordReference) {
-    Data.SetField("basic_login", login);
-    Data.SetField("basic_password_ref", passwordReference);
+    Data_.SetField("basic_login", login);
+    Data_.SetField("basic_password_ref", passwordReference);
     return *this;
 }
 
 TStructuredTokenBuilder& TStructuredTokenBuilder::SetTokenAuthWithSecret(const TString& tokenReference, const TString& token) {
-    Data.SetField("token_ref", tokenReference);
-    Data.SetField("token", token);
+    Data_.SetField("token_ref", tokenReference);
+    Data_.SetField("token", token);
     return *this;
 }
 
 TStructuredTokenBuilder& TStructuredTokenBuilder::SetIAMToken(const TString& token) {
-    Data.SetField("token", token);
+    Data_.SetField("token", token);
     return *this;
 }
 
 TStructuredTokenBuilder& TStructuredTokenBuilder::SetNoAuth() {
-    Data.SetField("no_auth", {});
+    Data_.SetField("no_auth", {});
     return *this;
 }
 
 TStructuredTokenBuilder& TStructuredTokenBuilder::ReplaceReferences(const std::map<TString, TString>& secrets) {
-    if (Data.HasField("basic_password_ref")) {
-        auto reference = Data.GetField("basic_password_ref");
-        Data.ClearField("basic_password_ref");
-        Data.SetField("basic_password", secrets.at(reference));
+    if (Data_.HasField("basic_password_ref")) {
+        auto reference = Data_.GetField("basic_password_ref");
+        Data_.ClearField("basic_password_ref");
+        Data_.SetField("basic_password", secrets.at(reference));
     }
-    if (Data.HasField("sa_id_signature_ref")) {
-        auto reference = Data.GetField("sa_id_signature_ref");
-        Data.ClearField("sa_id_signature_ref");
-        Data.SetField("sa_id_signature", secrets.at(reference));
+    if (Data_.HasField("sa_id_signature_ref")) {
+        auto reference = Data_.GetField("sa_id_signature_ref");
+        Data_.ClearField("sa_id_signature_ref");
+        Data_.SetField("sa_id_signature", secrets.at(reference));
     }
-    if (Data.HasField("token_ref")) {
-        auto reference = Data.GetField("token_ref");
-        Data.ClearField("token_ref");
-        Data.SetField("token", secrets.at(reference));
+    if (Data_.HasField("token_ref")) {
+        auto reference = Data_.GetField("token_ref");
+        Data_.ClearField("token_ref");
+        Data_.SetField("token", secrets.at(reference));
     }
     return *this;
 }
 
 TStructuredTokenBuilder& TStructuredTokenBuilder::RemoveSecrets() {
-    Data.ClearField("basic_password");
-    Data.ClearField("sa_id_signature");
-    Data.ClearField("token");
+    Data_.ClearField("basic_password");
+    Data_.ClearField("sa_id_signature");
+    Data_.ClearField("token");
     return *this;
 }
 
 TString TStructuredTokenBuilder::ToJson() const {
-    return Data.ToJson();
+    return Data_.ToJson();
 }
 
 ///////////////////////////////////////////////////////////////////
 
 TStructuredTokenParser::TStructuredTokenParser(TStructuredToken&& data)
-    : Data(std::move(data))
+    : Data_(std::move(data))
 {
 }
 
 bool TStructuredTokenParser::HasServiceAccountIdAuth() const {
-    return Data.HasField("sa_id");
+    return Data_.HasField("sa_id");
 }
 
 bool TStructuredTokenParser::GetServiceAccountIdAuth(TString& accountId, TString& accountIdSignature) const  {
@@ -98,14 +98,14 @@ bool TStructuredTokenParser::GetServiceAccountIdAuth(TString& accountId, TString
 }
 
 bool TStructuredTokenParser::GetServiceAccountIdAuth(TString& accountId, TString& accountIdSignature, TString& accountIdSignatureReference) const {
-    accountId = Data.GetField("sa_id");
-    accountIdSignature = Data.GetFieldOrDefault("sa_id_signature", "");
-    accountIdSignatureReference = Data.GetFieldOrDefault("sa_id_signature_ref", "");
+    accountId = Data_.GetField("sa_id");
+    accountIdSignature = Data_.GetFieldOrDefault("sa_id_signature", "");
+    accountIdSignatureReference = Data_.GetFieldOrDefault("sa_id_signature_ref", "");
     return true;
 }
 
 bool TStructuredTokenParser::HasBasicAuth() const {
-    return Data.HasField("basic_login");
+    return Data_.HasField("basic_login");
 }
 
 bool TStructuredTokenParser::GetBasicAuth(TString& login, TString& password) const {
@@ -114,38 +114,38 @@ bool TStructuredTokenParser::GetBasicAuth(TString& login, TString& password) con
 }
 
 bool TStructuredTokenParser::GetBasicAuth(TString& login, TString& password, TString& passwordReference) const {
-    login = Data.GetField("basic_login");
-    password = Data.GetFieldOrDefault("basic_password", "");
-    passwordReference = Data.GetFieldOrDefault("basic_password_ref", "");
+    login = Data_.GetField("basic_login");
+    password = Data_.GetFieldOrDefault("basic_password", "");
+    passwordReference = Data_.GetFieldOrDefault("basic_password_ref", "");
     return true;
 }
 
 bool TStructuredTokenParser::HasIAMToken() const {
-    return Data.HasField("token");
+    return Data_.HasField("token");
 }
 
 TString TStructuredTokenParser::GetIAMToken() const {
-    return Data.GetField("token");
+    return Data_.GetField("token");
 }
 
 bool TStructuredTokenParser::IsNoAuth() const {
-    return Data.HasField("no_auth");
+    return Data_.HasField("no_auth");
 }
 
 void TStructuredTokenParser::ListReferences(TSet<TString>& references) const {
-    if (Data.HasField("basic_password_ref")) {
-        references.insert(Data.GetField("basic_password_ref"));
+    if (Data_.HasField("basic_password_ref")) {
+        references.insert(Data_.GetField("basic_password_ref"));
     }
-    if (Data.HasField("sa_id_signature_ref")) {
-        references.insert(Data.GetField("sa_id_signature_ref"));
+    if (Data_.HasField("sa_id_signature_ref")) {
+        references.insert(Data_.GetField("sa_id_signature_ref"));
     }
-    if (Data.HasField("token_ref")) {
-        references.insert(Data.GetField("token_ref"));
+    if (Data_.HasField("token_ref")) {
+        references.insert(Data_.GetField("token_ref"));
     }
 }
 
 TStructuredTokenBuilder TStructuredTokenParser::ToBuilder() const {
-    return TStructuredTokenBuilder(Data);
+    return TStructuredTokenBuilder(Data_);
 }
 
 TStructuredTokenParser CreateStructuredTokenParser(const TString& content = {}) {
@@ -154,7 +154,7 @@ TStructuredTokenParser CreateStructuredTokenParser(const TString& content = {})
 
 TString ComposeStructuredTokenJsonForServiceAccount(const TString& serviceAccountId, const TString& serviceAccountIdSignature, const TString& token) {
     TStructuredTokenBuilder result;
-    
+
     if (serviceAccountId && serviceAccountIdSignature) {
         result.SetServiceAccountIdAuth(serviceAccountId, serviceAccountIdSignature);
         return result.ToJson();
@@ -171,7 +171,7 @@ TString ComposeStructuredTokenJsonForServiceAccount(const TString& serviceAccoun
 
 TString ComposeStructuredTokenJsonForServiceAccountWithSecret(const TString& serviceAccountId, const TString& serviceAccountIdSignatureSecretName, const TString& serviceAccountIdSignature) {
     TStructuredTokenBuilder result;
-    
+
     if (serviceAccountId && serviceAccountIdSignatureSecretName && serviceAccountIdSignature) {
         result.SetServiceAccountIdAuthWithSecret(serviceAccountId, serviceAccountIdSignatureSecretName, serviceAccountIdSignature);
         return result.ToJson();
@@ -183,7 +183,7 @@ TString ComposeStructuredTokenJsonForServiceAccountWithSecret(const TString& ser
 
 TString ComposeStructuredTokenJsonForBasicAuthWithSecret(const TString& login, const TString& passwordSecretName, const TString& password) {
     TStructuredTokenBuilder result;
-    
+
     if (login && passwordSecretName && password) {
         result.SetBasicAuth(login, password).SetBasicAuthWithSecret(login, passwordSecretName);
         return result.ToJson();
diff --git a/yql/essentials/providers/common/structured_token/yql_token_builder.h b/yql/essentials/providers/common/structured_token/yql_token_builder.h
index 60f0a221fec..f9edf7f0213 100644
--- a/yql/essentials/providers/common/structured_token/yql_token_builder.h
+++ b/yql/essentials/providers/common/structured_token/yql_token_builder.h
@@ -25,7 +25,7 @@ public:
     TString ToJson() const;
 
 private:
-    TStructuredToken Data;
+    TStructuredToken Data_;
 };
 
 class TStructuredTokenParser {
@@ -45,7 +45,7 @@ public:
     TStructuredTokenBuilder ToBuilder() const;
 
 private:
-    const TStructuredToken Data;
+    const TStructuredToken Data_;
 };
 
 TStructuredTokenParser CreateStructuredTokenParser(const TString& content);
diff --git a/yql/essentials/providers/common/transform/yql_exec.cpp b/yql/essentials/providers/common/transform/yql_exec.cpp
index 6128cf211d9..e68f1840cef 100644
--- a/yql/essentials/providers/common/transform/yql_exec.cpp
+++ b/yql/essentials/providers/common/transform/yql_exec.cpp
@@ -16,7 +16,7 @@ using namespace NNodes;
 TExecTransformerBase::TStatusCallbackPair TExecTransformerBase::CallbackTransform(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
     YQL_ENSURE(input->Type() == TExprNode::Callable);
     output = input;
-    if (auto handlerInfo = Handlers.FindPtr(input->Content())) {
+    if (auto handlerInfo = Handlers_.FindPtr(input->Content())) {
         auto status = (handlerInfo->Prerequisite)(input);
         if (status.Level != TStatus::Ok) {
             return SyncStatus(status);
@@ -36,7 +36,7 @@ void TExecTransformerBase::AddHandler(std::initializer_list<TStringBuf> names, T
     info.Handler = std::move(handler);
     info.Prerequisite = std::move(prerequisite);
     for (auto name: names) {
-        YQL_ENSURE(Handlers.emplace(name, info).second, "Duplicate execution handler for " << name);
+        YQL_ENSURE(Handlers_.emplace(name, info).second, "Duplicate execution handler for " << name);
     }
 }
 
diff --git a/yql/essentials/providers/common/transform/yql_exec.h b/yql/essentials/providers/common/transform/yql_exec.h
index caacb78a2aa..63af3b8f1bc 100644
--- a/yql/essentials/providers/common/transform/yql_exec.h
+++ b/yql/essentials/providers/common/transform/yql_exec.h
@@ -22,7 +22,7 @@ public:
     TStatusCallbackPair CallbackTransform(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx);
 
     bool CanExec(const TExprNode& node) const {
-        return Handlers.contains(node.Content());
+        return Handlers_.contains(node.Content());
     }
 
 protected:
@@ -64,7 +64,7 @@ protected:
         TPrerequisite Prerequisite;
         THandler Handler;
     };
-    THashMap<TStringBuf, THandlerInfo> Handlers;
+    THashMap<TStringBuf, THandlerInfo> Handlers_;
 };
 
 } // NYql
diff --git a/yql/essentials/providers/common/transform/yql_lazy_init.h b/yql/essentials/providers/common/transform/yql_lazy_init.h
index b9c7a3dd4ad..281614a1d62 100644
--- a/yql/essentials/providers/common/transform/yql_lazy_init.h
+++ b/yql/essentials/providers/common/transform/yql_lazy_init.h
@@ -15,24 +15,24 @@ public:
     using TFactory = std::function<THolder<T>()>;
 
     TLazyInitHolder(TFactory&& factory)
-        : Factory(std::move(factory))
+        : Factory_(std::move(factory))
     {
     }
 
     T* Get() const noexcept {
-        if (!Value) {
-            Value = Factory();
+        if (!Value_) {
+            Value_ = Factory_();
         }
-        return Value.Get();
+        return Value_.Get();
     }
 
     inline explicit operator bool() const noexcept {
-        return !!Value.Get();
+        return !!Value_.Get();
     }
 
 private:
-    TFactory Factory;
-    mutable THolder<T> Value;
+    TFactory Factory_;
+    mutable THolder<T> Value_;
 
 };
 
diff --git a/yql/essentials/providers/common/transform/yql_optimize.cpp b/yql/essentials/providers/common/transform/yql_optimize.cpp
index c59132174d5..14789fbb515 100644
--- a/yql/essentials/providers/common/transform/yql_optimize.cpp
+++ b/yql/essentials/providers/common/transform/yql_optimize.cpp
@@ -55,8 +55,8 @@ private:
 
 TOptimizeTransformerBase::TOptimizeTransformerBase(TTypeAnnotationContext* types, NLog::EComponent logComponent, const TSet<TString>& disabledOpts)
     : Types(types)
-    , LogComponent(logComponent)
-    , DisabledOpts(disabledOpts)
+    , LogComponent_(logComponent)
+    , DisabledOpts_(disabledOpts)
 {
 }
 
@@ -65,7 +65,7 @@ IGraphTransformer::TStatus TOptimizeTransformerBase::DoTransform(TExprNode::TPtr
     IGraphTransformer::TStatus status = IGraphTransformer::TStatus::Ok;
 
     output = input;
-    for (auto& step: Steps) {
+    for (auto& step: Steps_) {
         TParentsMap parentsMap;
         bool parentsMapInit = false;
         TGetParents getParents = [&input, &parentsMap, &parentsMapInit] () {
@@ -89,14 +89,14 @@ IGraphTransformer::TStatus TOptimizeTransformerBase::DoTransform(TExprNode::TPtr
                                 try {
                                     auto ret = opt.Handler(NNodes::TExprBase(node), ctx, optCtx, getParents);
                                     if (!ret) {
-                                        YQL_CVLOG(NLog::ELevel::ERROR, LogComponent) << "Error applying " << opt.OptName;
+                                        YQL_CVLOG(NLog::ELevel::ERROR, LogComponent_) << "Error applying " << opt.OptName;
                                         optCtx.SetError();
                                     } else if (auto retNode = ret.Cast(); retNode.Ptr() != node) {
-                                        YQL_CVLOG(NLog::ELevel::INFO, LogComponent) << opt.OptName;
+                                        YQL_CVLOG(NLog::ELevel::INFO, LogComponent_) << opt.OptName;
                                         optCtx.RemapNode(*node, retNode.Ptr());
                                     }
                                 } catch (...) {
-                                    YQL_CVLOG(NLog::ELevel::ERROR, LogComponent) << "Error applying " << opt.OptName << ": " << CurrentExceptionMessage();
+                                    YQL_CVLOG(NLog::ELevel::ERROR, LogComponent_) << "Error applying " << opt.OptName << ": " << CurrentExceptionMessage();
                                     throw;
                                 }
                             }
@@ -127,16 +127,16 @@ IGraphTransformer::TStatus TOptimizeTransformerBase::DoTransform(TExprNode::TPtr
                         try {
                             auto ret = opt.Handler(NNodes::TExprBase(node), ctx, ignoreOptCtx, getParents);
                             if (!ret) {
-                                YQL_CVLOG(NLog::ELevel::ERROR, LogComponent) << "Error applying " << opt.OptName;
+                                YQL_CVLOG(NLog::ELevel::ERROR, LogComponent_) << "Error applying " << opt.OptName;
                                 return {};
                             }
                             auto retNode = ret.Cast();
                             if (retNode.Ptr() != node) {
-                                YQL_CVLOG(NLog::ELevel::INFO, LogComponent) << opt.OptName;
+                                YQL_CVLOG(NLog::ELevel::INFO, LogComponent_) << opt.OptName;
                                 return retNode.Ptr();
                             }
                         } catch (...) {
-                            YQL_CVLOG(NLog::ELevel::ERROR, LogComponent) << "Error applying " << opt.OptName << ": " << CurrentExceptionMessage();
+                            YQL_CVLOG(NLog::ELevel::ERROR, LogComponent_) << "Error applying " << opt.OptName << ": " << CurrentExceptionMessage();
                             throw;
                         }
                     }
@@ -154,7 +154,7 @@ IGraphTransformer::TStatus TOptimizeTransformerBase::DoTransform(TExprNode::TPtr
 }
 
 void TOptimizeTransformerBase::Rewind() {
-    for (auto& step: Steps) {
+    for (auto& step: Steps_) {
         step.ProcessedNodes.clear();
     }
 }
@@ -183,27 +183,31 @@ TOptimizeTransformerBase::TFilter TOptimizeTransformerBase::Or(std::initializer_
     };
 }
 
+TTypeAnnotationContext* TOptimizeTransformerBase::GetTypes() const {
+    return Types;
+}
+
 void TOptimizeTransformerBase::AddHandler(size_t step, TFilter filter, TStringBuf optName, THandler handler) {
-    if (DisabledOpts.contains(optName)) {
+    if (DisabledOpts_.contains(optName)) {
         return;
     }
 
-    if (step >= Steps.size()) {
-        Steps.resize(step + 1);
+    if (step >= Steps_.size()) {
+        Steps_.resize(step + 1);
     }
 
     TOptInfo opt;
     opt.OptName = optName;
     opt.Filter = filter;
     opt.Handler = handler;
-    Steps[step].Optimizers.push_back(std::move(opt));
+    Steps_[step].Optimizers.push_back(std::move(opt));
 }
 
 void TOptimizeTransformerBase::SetGlobal(size_t step) {
-    if (step >= Steps.size()) {
-        Steps.resize(step + 1);
+    if (step >= Steps_.size()) {
+        Steps_.resize(step + 1);
     }
-    Steps[step].Global = true;
+    Steps_[step].Global = true;
 }
 
 }
diff --git a/yql/essentials/providers/common/transform/yql_optimize.h b/yql/essentials/providers/common/transform/yql_optimize.h
index 2b7a5b8a306..826e7b92bac 100644
--- a/yql/essentials/providers/common/transform/yql_optimize.h
+++ b/yql/essentials/providers/common/transform/yql_optimize.h
@@ -105,10 +105,14 @@ protected:
         TVector<TOptInfo> Optimizers;
         bool Global = false;
     };
-    TTypeAnnotationContext* Types;
-    const NLog::EComponent LogComponent;
-    TSet<TString> DisabledOpts;
-    TVector<TStep> Steps;
+
+    TTypeAnnotationContext* GetTypes() const;
+
+    // FIXME switch to an accessor
+    TTypeAnnotationContext* Types; // NOLINT(readability-identifier-naming)
+    const NLog::EComponent LogComponent_;
+    TSet<TString> DisabledOpts_;
+    TVector<TStep> Steps_;
 };
 
 } // NYql
diff --git a/yql/essentials/providers/common/transform/yql_visit.cpp b/yql/essentials/providers/common/transform/yql_visit.cpp
index 990c7458594..7ef0543864c 100644
--- a/yql/essentials/providers/common/transform/yql_visit.cpp
+++ b/yql/essentials/providers/common/transform/yql_visit.cpp
@@ -8,7 +8,7 @@ namespace NYql {
 
 void TVisitorTransformerBase::AddHandler(std::initializer_list<TStringBuf> names, THandler handler) {
     for (auto name: names) {
-        YQL_ENSURE(Handlers.emplace(name, handler).second, "Duplicate handler for " << name);
+        YQL_ENSURE(Handlers_.emplace(name, handler).second, "Duplicate handler for " << name);
     }
 }
 
@@ -16,10 +16,10 @@ IGraphTransformer::TStatus TVisitorTransformerBase::DoTransform(TExprNode::TPtr
     YQL_ENSURE(input->Type() == TExprNode::Callable);
     output = input;
 
-    if (auto handler = Handlers.FindPtr(input->Content())) {
+    if (auto handler = Handlers_.FindPtr(input->Content())) {
         return (*handler)(input, output, ctx);
     }
-    if (FailOnUnknown) {
+    if (FailOnUnknown_) {
         ctx.AddError(TIssue(ctx.GetPosition(input->Pos()), TStringBuilder() << "Unsupported callable: " << input->Content()));
         return TStatus::Error;
     }
diff --git a/yql/essentials/providers/common/transform/yql_visit.h b/yql/essentials/providers/common/transform/yql_visit.h
index 438e6d76bac..19e5402192d 100644
--- a/yql/essentials/providers/common/transform/yql_visit.h
+++ b/yql/essentials/providers/common/transform/yql_visit.h
@@ -17,7 +17,7 @@ public:
     using THandler = std::function<TStatus(const TExprNode::TPtr&, TExprNode::TPtr&, TExprContext&)>;
 
     TVisitorTransformerBase(bool failOnUnknown)
-        : FailOnUnknown(failOnUnknown)
+        : FailOnUnknown_(failOnUnknown)
     {
     }
 
@@ -27,7 +27,7 @@ public:
     }
 
     bool CanParse(const TExprNode& node) const {
-        return Handlers.contains(node.Content());
+        return Handlers_.contains(node.Content());
     }
 
 protected:
@@ -67,8 +67,8 @@ protected:
     }
 
 protected:
-    const bool FailOnUnknown;
-    THashMap<TStringBuf, THandler> Handlers;
+    const bool FailOnUnknown_;
+    THashMap<TStringBuf, THandler> Handlers_;
 };
 
 } // NYql
diff --git a/yql/essentials/providers/common/udf_resolve/yql_files_box.cpp b/yql/essentials/providers/common/udf_resolve/yql_files_box.cpp
index 0220ba8f6c9..fcf1817cc01 100644
--- a/yql/essentials/providers/common/udf_resolve/yql_files_box.cpp
+++ b/yql/essentials/providers/common/udf_resolve/yql_files_box.cpp
@@ -12,8 +12,8 @@ namespace NYql {
 namespace NCommon {
 
 TFilesBox::TFilesBox(TFsPath dir, TRandGuid randGuid)
-    : Dir(std::move(dir))
-    , RandGuid(std::move(randGuid))
+    : Dir_(std::move(dir))
+    , RandGuid_(std::move(randGuid))
 {
 }
 
@@ -27,7 +27,7 @@ TFilesBox::~TFilesBox() {
 
 TString TFilesBox::MakeLinkFrom(const TString& source, const TString& filename) {
     if (!filename) {
-        if (auto* existingPath = Mapping.FindPtr(source)) {
+        if (auto* existingPath = Mapping_.FindPtr(source)) {
             return *existingPath;
         }
     }
@@ -36,31 +36,31 @@ TString TFilesBox::MakeLinkFrom(const TString& source, const TString& filename)
     TString sourceAbsolutePath = sourcePath.IsAbsolute() ? source : (TFsPath::Cwd() / sourcePath).GetPath();
     TString path;
     if (filename) {
-        path = Dir / filename;
+        path = Dir_ / filename;
         if (!NFs::SymLink(sourceAbsolutePath, path)) {
             ythrow TSystemError() << "Failed to create symlink for file " << sourceAbsolutePath.Quote() << " to file " << path.Quote();
         }
     } else {
         while (true) {
-            path = Dir / RandGuid.GenGuid();
+            path = Dir_ / RandGuid_.GenGuid();
             if (NFs::SymLink(sourceAbsolutePath, path)) {
                 break;
             } else if (LastSystemError() != EEXIST) {
                 ythrow TSystemError() << "Failed to create symlink for file " << sourceAbsolutePath.Quote() << " to file " << path.Quote();
             }
         }
-        Mapping.emplace(source, path);
+        Mapping_.emplace(source, path);
     }
     return path;
 }
 
 TString TFilesBox::GetDir() const {
-    return Dir;
+    return Dir_;
 }
 
 void TFilesBox::Destroy() {
-    Mapping.clear();
-    Dir.ForceDelete();
+    Mapping_.clear();
+    Dir_.ForceDelete();
 }
 
 THolder<TFilesBox> CreateFilesBox(const TFsPath& baseDir) {
diff --git a/yql/essentials/providers/common/udf_resolve/yql_files_box.h b/yql/essentials/providers/common/udf_resolve/yql_files_box.h
index d7f348660c2..aac5f7ef196 100644
--- a/yql/essentials/providers/common/udf_resolve/yql_files_box.h
+++ b/yql/essentials/providers/common/udf_resolve/yql_files_box.h
@@ -22,9 +22,9 @@ public:
     void Destroy();
 
 private:
-    TFsPath Dir;
-    TRandGuid RandGuid;
-    THashMap<TString, TString> Mapping;
+    TFsPath Dir_;
+    TRandGuid RandGuid_;
+    THashMap<TString, TString> Mapping_;
 };
 
 THolder<TFilesBox> CreateFilesBox(const TFsPath& baseDir);
diff --git a/yql/essentials/providers/common/udf_resolve/yql_udf_resolver_with_index.cpp b/yql/essentials/providers/common/udf_resolve/yql_udf_resolver_with_index.cpp
index b8b28d7bdee..e284fb73370 100644
--- a/yql/essentials/providers/common/udf_resolve/yql_udf_resolver_with_index.cpp
+++ b/yql/essentials/providers/common/udf_resolve/yql_udf_resolver_with_index.cpp
@@ -29,16 +29,16 @@ class TUdfResolverWithIndex : public IUdfResolver {
 
     public:
         TResourceFile(TString alias, const TVector<TString>& modules, TFileLinkPtr link)
-            : Link_(std::move(link))
+            : Link(std::move(link))
         {
-            Import_.FileAlias = alias;
-            Import_.Block = &Block_;
-            Import_.Modules = MakeMaybe(modules);
-
-            Block_.Type = EUserDataType::PATH;
-            Block_.Data = Link_->GetPath();
-            Block_.Usage.Set(EUserDataBlockUsage::Udf);
-            Block_.FrozenFile = Link_;
+            Import.FileAlias = alias;
+            Import.Block = &Block;
+            Import.Modules = MakeMaybe(modules);
+
+            Block.Type = EUserDataType::PATH;
+            Block.Data = Link->GetPath();
+            Block.Usage.Set(EUserDataBlockUsage::Udf);
+            Block.FrozenFile = Link;
         }
 
         static TResourceFile::TPtr Create(const TString& packageName, const TSet<TString>& modules, TFileLinkPtr link) {
@@ -50,9 +50,9 @@ class TUdfResolverWithIndex : public IUdfResolver {
         }
 
     public:
-        TFileLinkPtr Link_;
-        TUserDataBlock Block_;
-        TImport Import_;
+        TFileLinkPtr Link;
+        TUserDataBlock Block;
+        TImport Import;
     };
 
 public:
@@ -75,7 +75,7 @@ public:
             }
 
             auto file = DownloadFileWithModule(moduleNameStr);
-            return MakeMaybe<TFilePathWithMd5>(file->Link_->GetPath(), file->Link_->GetMd5());
+            return MakeMaybe<TFilePathWithMd5>(file->Link->GetPath(), file->Link->GetMd5());
         }
     }
 
@@ -172,7 +172,7 @@ private:
             return false;
         }
 
-        additionalImport = &file->Import_;
+        additionalImport = &file->Import;
 
         if (info.IsTypeAwareness) {
             function.Name = info.Name;
@@ -246,7 +246,7 @@ private:
             auto p = DownloadedFiles_.emplace(d, file);
             if (!p.second) {
                 // should not happen because UdfIndex handles conflicts
-                ythrow yexception() << "file already downloaded for module " << canonizedModuleName << ", conflicting path " << downloadLink.Path << ", existing local file " << p.first->second->Link_->GetPath();
+                ythrow yexception() << "file already downloaded for module " << canonizedModuleName << ", conflicting path " << downloadLink.Path << ", existing local file " << p.first->second->Link->GetPath();
             }
         }
 
diff --git a/yql/essentials/providers/config/yql_config_provider.cpp b/yql/essentials/providers/config/yql_config_provider.cpp
index 0857fce61b5..d5bf747fd3c 100644
--- a/yql/essentials/providers/config/yql_config_provider.cpp
+++ b/yql/essentials/providers/config/yql_config_provider.cpp
@@ -32,9 +32,9 @@ namespace {
     class TConfigCallableExecutionTransformer : public TSyncTransformerBase {
     public:
         TConfigCallableExecutionTransformer(const TTypeAnnotationContext& types)
-            : Types(types)
+            : Types_(types)
         {
-            Y_UNUSED(Types);
+            Y_UNUSED(Types_);
         }
 
         TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
@@ -121,7 +121,7 @@ namespace {
         }
 
     private:
-        const TTypeAnnotationContext& Types;
+        const TTypeAnnotationContext& Types_;
     };
 
     class TConfigProvider : public TDataProviderBase {
@@ -135,10 +135,10 @@ namespace {
         };
 
         TConfigProvider(TTypeAnnotationContext& types, const TGatewaysConfig* config, const TString& username, const TAllowSettingPolicy& policy)
-            : Types(types)
-            , CoreConfig(config && config->HasYqlCore() ? &config->GetYqlCore() : nullptr)
-            , Username(username)
-            , Policy(policy)
+            : Types_(types)
+            , CoreConfig_(config && config->HasYqlCore() ? &config->GetYqlCore() : nullptr)
+            , Username_(username)
+            , Policy_(policy)
         {}
 
         TStringBuf GetName() const override {
@@ -147,22 +147,22 @@ namespace {
 
         bool Initialize(TExprContext& ctx) override {
             std::unordered_set<std::string_view> groups;
-            if (Types.Credentials != nullptr) {
-                groups.insert(Types.Credentials->GetGroups().begin(), Types.Credentials->GetGroups().end());
+            if (Types_.Credentials != nullptr) {
+                groups.insert(Types_.Credentials->GetGroups().begin(), Types_.Credentials->GetGroups().end());
             }
             auto filter = [this, groups = std::move(groups)](const TCoreAttr& attr) {
-                if (!attr.HasActivation() || !Username) {
+                if (!attr.HasActivation() || !Username_) {
                     return true;
                 }
-                if (NConfig::Allow(attr.GetActivation(), Username, groups)) {
-                    Statistics.Entries.emplace_back(TStringBuilder() << "Activation:" << attr.GetName(), 0, 0, 0, 0, 1);
+                if (NConfig::Allow(attr.GetActivation(), Username_, groups)) {
+                    Statistics_.Entries.emplace_back(TStringBuilder() << "Activation:" << attr.GetName(), 0, 0, 0, 0, 1);
                     return true;
                 }
                 return false;
             };
-            if (CoreConfig) {
+            if (CoreConfig_) {
                 TPosition pos;
-                for (auto& flag: CoreConfig->GetFlags()) {
+                for (auto& flag: CoreConfig_->GetFlags()) {
                     if (filter(flag)) {
                         TVector<TStringBuf> args;
                         for (auto& arg: flag.GetArgs()) {
@@ -178,12 +178,12 @@ namespace {
         }
 
         bool CollectStatistics(NYson::TYsonWriter& writer, bool totalOnly) override {
-            if (Statistics.Entries.empty()) {
+            if (Statistics_.Entries.empty()) {
                 return false;
             }
 
             THashMap<ui32, TOperationStatistics> tmp;
-            tmp.emplace(Max<ui32>(), Statistics);
+            tmp.emplace(Max<ui32>(), Statistics_);
             NCommon::WriteStatistics(writer, totalOnly, tmp);
 
             return true;
@@ -213,11 +213,11 @@ namespace {
         }
 
         IGraphTransformer& GetConfigurationTransformer() override {
-            if (ConfigurationTransformer) {
-                return *ConfigurationTransformer;
+            if (ConfigurationTransformer_) {
+                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)) {
@@ -273,8 +273,8 @@ namespace {
                         }
 
                         if (command == "PureDataSource") {
-                            if (Types.PureResultDataSource != node->Child(3)->Content()) {
-                                res = ctx.ChangeChild(*node, 3, ctx.RenameNode(*node->Child(3), Types.PureResultDataSource));
+                            if (Types_.PureResultDataSource != node->Child(3)->Content()) {
+                                res = ctx.ChangeChild(*node, 3, ctx.RenameNode(*node->Child(3), Types_.PureResultDataSource));
                             }
                         }
                     }
@@ -285,13 +285,13 @@ namespace {
                 return status;
             });
 
-            return *ConfigurationTransformer;
+            return *ConfigurationTransformer_;
         }
 
         IGraphTransformer& GetTypeAnnotationTransformer(bool instantOnly) override {
             Y_UNUSED(instantOnly);
-            if (!TypeAnnotationTransformer) {
-                TypeAnnotationTransformer = CreateFunctorTransformer(
+            if (!TypeAnnotationTransformer_) {
+                TypeAnnotationTransformer_ = CreateFunctorTransformer(
                     [&](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) -> IGraphTransformer::TStatus {
                     output = input;
                     if (input->Content() == ConfReadName) {
@@ -379,7 +379,7 @@ namespace {
                 });
             }
 
-            return *TypeAnnotationTransformer;
+            return *TypeAnnotationTransformer_;
         }
 
         TExprNode::TPtr RewriteIO(const TExprNode::TPtr& node, TExprContext& ctx) override {
@@ -423,11 +423,11 @@ namespace {
         }
 
         IGraphTransformer& GetCallableExecutionTransformer() override {
-            if (!CallableExecutionTransformer) {
-                CallableExecutionTransformer = new TConfigCallableExecutionTransformer(Types);
+            if (!CallableExecutionTransformer_) {
+                CallableExecutionTransformer_ = new TConfigCallableExecutionTransformer(Types_);
             }
 
-            return *CallableExecutionTransformer;
+            return *CallableExecutionTransformer_;
         }
 
         bool GetDependencies(const TExprNode& node, TExprNode::TListType& children, bool compact) override {
@@ -453,7 +453,7 @@ namespace {
 
     private:
         bool IsSettingAllowed(const TPosition& pos, TStringBuf name, TExprContext& ctx) {
-            if (Policy && !Policy(name)) {
+            if (Policy_ && !Policy_(name)) {
                 ctx.AddError(TIssue(pos, TStringBuilder() << "Changing setting " << name << " is not allowed"));
                 return false;
             }
@@ -497,7 +497,7 @@ namespace {
                 }
 
                 try {
-                    Types.ValidateMode = NKikimr::NUdf::ValidateModeByStr(TString(args[0]));
+                    Types_.ValidateMode = NKikimr::NUdf::ValidateModeByStr(TString(args[0]));
                 } catch (const yexception& err) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << err.AsStrBuf() << ", available modes: " << NKikimr::NUdf::ValidateModeAvailables()));
                     return false;
@@ -508,14 +508,14 @@ namespace {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected no arguments, but got " << args.size()));
                     return false;
                 }
-                Types.OptLLVM = "OFF";
+                Types_.OptLLVM = "OFF";
             }
             else if (name == "LLVM") {
                 if (args.size() > 1) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected at most 1 argument, but got " << args.size()));
                     return false;
                 }
-                Types.OptLLVM = args.empty() ? TString() : TString(args[0]);
+                Types_.OptLLVM = args.empty() ? TString() : TString(args[0]);
             }
             else if (name == "RuntimeLogLevel") {
                 if (args.size() != 1) {
@@ -527,7 +527,7 @@ namespace {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Invalid log level value: " << args[0]));
                     return false;
                 }
-                Types.RuntimeLogLevel = *value;
+                Types_.RuntimeLogLevel = *value;
             }
             else if (name == "NodesAllocationLimit") {
                 if (args.size() != 1) {
@@ -576,11 +576,11 @@ namespace {
                 }
 
                 auto dataSource = args[0];
-                if (Find(Types.AvailablePureResultDataSources, dataSource) == Types.AvailablePureResultDataSources.end()) {
+                if (Find(Types_.AvailablePureResultDataSources, dataSource) == Types_.AvailablePureResultDataSources.end()) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Unsupported datasource for result provider: " << dataSource));
                     return false;
                 }
-                if (auto p = Types.DataSourceMap.FindPtr(dataSource)) {
+                if (auto p = Types_.DataSourceMap.FindPtr(dataSource)) {
                     if ((*p)->GetName() != dataSource) {
                         dataSource = (*p)->GetName();
                     }
@@ -589,7 +589,7 @@ namespace {
                     return false;
                 }
 
-                Types.PureResultDataSource = dataSource;
+                Types_.PureResultDataSource = dataSource;
             }
             else if (name == "FullResultDataSink") {
                 if (args.size() != 1) {
@@ -598,7 +598,7 @@ namespace {
                 }
 
                 auto dataSink = args[0];
-                if (auto p = Types.DataSinkMap.FindPtr(dataSink)) {
+                if (auto p = Types_.DataSinkMap.FindPtr(dataSink)) {
                     if ((*p)->GetName() != dataSink) {
                         dataSink = (*p)->GetName();
                     }
@@ -607,7 +607,7 @@ namespace {
                     return false;
                 }
 
-                Types.FullResultDataSink = dataSink;
+                Types_.FullResultDataSink = dataSink;
             }
             else if (name == "Diagnostics") {
                 if (args.size() != 0) {
@@ -615,7 +615,7 @@ namespace {
                     return false;
                 }
 
-                Types.Diagnostics = true;
+                Types_.Diagnostics = true;
             }
             else if (name == TStringBuf("Warning")) {
                 if (!SetWarningRule(pos, args, ctx)) {
@@ -636,14 +636,14 @@ namespace {
                     }
                 }
 
-                Types.UdfSupportsYield = res;
+                Types_.UdfSupportsYield = res;
             }
             else if (name == "EvaluateForLimit") {
                 if (args.size() != 1) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected 1 argument, but got " << args.size()));
                     return false;
                 }
-                if (!TryFromString(args[0], Types.EvaluateForLimit)) {
+                if (!TryFromString(args[0], Types_.EvaluateForLimit)) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected integer, but got: " << args[0]));
                     return false;
                 }
@@ -653,7 +653,7 @@ namespace {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected 1 argument, but got " << args.size()));
                     return false;
                 }
-                if (!TryFromString(args[0], Types.EvaluateParallelForLimit)) {
+                if (!TryFromString(args[0], Types_.EvaluateParallelForLimit)) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected integer, but got: " << args[0]));
                     return false;
                 }
@@ -664,14 +664,14 @@ namespace {
                     return false;
                 }
 
-                Types.PullUpFlatMapOverJoin = (name == "PullUpFlatMapOverJoin");
+                Types_.PullUpFlatMapOverJoin = (name == "PullUpFlatMapOverJoin");
             } else if (name == "DisableFilterPushdownOverJoinOptionalSide" || name == "FilterPushdownOverJoinOptionalSide") {
                 if (args.size() != 0) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected no arguments, but got " << args.size()));
                     return false;
                 }
 
-                Types.FilterPushdownOverJoinOptionalSide = (name == "FilterPushdownOverJoinOptionalSide");
+                Types_.FilterPushdownOverJoinOptionalSide = (name == "FilterPushdownOverJoinOptionalSide");
             } else if (name == "RotateJoinTree") {
                 if (args.size() > 1) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected at most 1 argument, but got " << args.size()));
@@ -686,7 +686,7 @@ namespace {
                     }
                 }
 
-                Types.RotateJoinTree = res;
+                Types_.RotateJoinTree = res;
             }
             else if (name == "SQL") {
                 if (args.size() > 1) {
@@ -694,7 +694,7 @@ namespace {
                     return false;
                 }
 
-                Types.DeprecatedSQL = (args[0] == "0");
+                Types_.DeprecatedSQL = (args[0] == "0");
             }
             else if (name == "DisableConstraintCheck") {
                 if (args.empty()) {
@@ -702,7 +702,7 @@ namespace {
                     return false;
                 }
                 for (auto arg: args) {
-                    Types.DisableConstraintCheck.emplace(arg);
+                    Types_.DisableConstraintCheck.emplace(arg);
                 }
             }
             else if (name == "EnableConstraintCheck") {
@@ -711,7 +711,7 @@ namespace {
                     return false;
                 }
                 for (auto arg: args) {
-                    Types.DisableConstraintCheck.erase(TString{arg});
+                    Types_.DisableConstraintCheck.erase(TString{arg});
                 }
             }
             else if (name == "DisableConstraints") {
@@ -746,14 +746,14 @@ namespace {
                     }
                 }
 
-                Types.UseTableMetaFromGraph = res;
+                Types_.UseTableMetaFromGraph = res;
             }
             else if (name == "DiscoveryMode") {
                 if (args.size() != 0) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected no arguments, but got " << args.size()));
                     return false;
                 }
-                Types.DiscoveryMode = true;
+                Types_.DiscoveryMode = true;
             }
             else if (name == "EnableSystemColumns") {
                 if (args.size() != 0) {
@@ -767,12 +767,12 @@ namespace {
                     return false;
                 }
 
-                if (!Types.UdfIndex) {
+                if (!Types_.UdfIndex) {
                     ctx.AddError(TIssue(pos, "UdfIndex is not available"));
                     return false;
                 }
 
-                Types.UdfIndex->SetCaseSentiveSearch(name == "UdfStrictCase");
+                Types_.UdfIndex->SetCaseSentiveSearch(name == "UdfStrictCase");
             } else if (name == "DqEngine") {
                 if (args.size() != 1) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected at most 1 argument, but got " << args.size()));
@@ -780,7 +780,7 @@ namespace {
                 }
 
                 auto arg = TString{args[0]};
-                if (Types.EngineType == EEngineType::Ytflow) {
+                if (Types_.EngineType == EEngineType::Ytflow) {
                     if (arg == "force") {
                         ctx.AddError(TIssue(pos, TStringBuilder()
                             << "Expected `disable|auto` argument for DqEngine pragma "
@@ -790,18 +790,18 @@ namespace {
                     }
 
                     arg = "disable";
-                } else if (Types.EngineType == EEngineType::Dq) {
+                } else if (Types_.EngineType == EEngineType::Dq) {
                     arg = "force";
                 }
 
-                if (Find(Types.AvailablePureResultDataSources, DqProviderName) == Types.AvailablePureResultDataSources.end() || arg == "disable") {
+                if (Find(Types_.AvailablePureResultDataSources, DqProviderName) == Types_.AvailablePureResultDataSources.end() || arg == "disable") {
                     ; // reserved
                 } else if (arg == "auto") {
-                    Types.PureResultDataSource = DqProviderName;
-                    Types.ForceDq = false;
+                    Types_.PureResultDataSource = DqProviderName;
+                    Types_.ForceDq = false;
                 } else if (arg == "force") {
-                    Types.PureResultDataSource = DqProviderName;
-                    Types.ForceDq = true;
+                    Types_.PureResultDataSource = DqProviderName;
+                    Types_.ForceDq = true;
                 } else {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected `disable|auto|force', but got: " << args[0]));
                     return false;
@@ -824,21 +824,21 @@ namespace {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected no arguments, but got " << args.size()));
                     return false;
                 }
-                Types.StrictTableProps = true;
+                Types_.StrictTableProps = true;
             }
             else if (name == "DisableStrictTableProps") {
                 if (args.size() != 0) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected no arguments, but got " << args.size()));
                     return false;
                 }
-                Types.StrictTableProps = false;
+                Types_.StrictTableProps = false;
             }
             else if (name == "GeobaseDownloadUrl") {
                 if (args.size() != 1) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected 1 argument, but got " << args.size()));
                     return false;
                 }
-                auto& userDataBlock = (Types.UserDataStorageCrutches[TUserDataKey::File(TStringBuf("/home/geodata6.bin"))] = TUserDataBlock{EUserDataType::URL, {}, TString(args[0]), {}, {}});
+                auto& userDataBlock = (Types_.UserDataStorageCrutches[TUserDataKey::File(TStringBuf("/home/geodata6.bin"))] = TUserDataBlock{EUserDataType::URL, {}, TString(args[0]), {}, {}});
                 userDataBlock.Usage.Set(EUserDataBlockUsage::Path);
             } else if (name == "JsonQueryReturnsJsonDocument" || name == "DisableJsonQueryReturnsJsonDocument") {
                 if (args.size() != 0) {
@@ -846,27 +846,27 @@ namespace {
                     return false;
                 }
 
-                Types.JsonQueryReturnsJsonDocument = (name == "JsonQueryReturnsJsonDocument");
+                Types_.JsonQueryReturnsJsonDocument = (name == "JsonQueryReturnsJsonDocument");
             } else if (name == "OrderedColumns" || name == "DisableOrderedColumns") {
                 if (args.size() != 0) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected no arguments, but got " << args.size()));
                     return false;
                 }
-                Types.DeriveColumnOrder = (name == "OrderedColumns");
-                Types.OrderedColumns = (name == "OrderedColumns");
+                Types_.DeriveColumnOrder = (name == "OrderedColumns");
+                Types_.OrderedColumns = (name == "OrderedColumns");
             } else if (name == "DeriveColumnOrder" || name == "DisableDeriveColumnOrder") {
                 if (args.size() != 0) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected no arguments, but got " << args.size()));
                     return false;
                 }
 
-                Types.DeriveColumnOrder = (name == "DeriveColumnOrder");
+                Types_.DeriveColumnOrder = (name == "DeriveColumnOrder");
             } else if (name == "FolderSubDirsLimit") {
                 if (args.size() != 1) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected 1 argument, but got " << args.size()));
                     return false;
                 }
-                if (!TryFromString(args[0], Types.FolderSubDirsLimit)) {
+                if (!TryFromString(args[0], Types_.FolderSubDirsLimit)) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected integer, but got: " << args[0]));
                     return false;
                 }
@@ -877,7 +877,7 @@ namespace {
                     return false;
                 }
 
-                Types.YsonCastToString = (name == "YsonCastToString");
+                Types_.YsonCastToString = (name == "YsonCastToString");
             }
             else if (name == "UseBlocks" || name == "DisableUseBlocks") {
                 if (args.size() != 0) {
@@ -885,7 +885,7 @@ namespace {
                     return false;
                 }
 
-                Types.UseBlocks = (name == "UseBlocks");
+                Types_.UseBlocks = (name == "UseBlocks");
             }
             else if (name == "PgEmitAggApply" || name == "DisablePgEmitAggApply") {
                 if (args.size() != 0) {
@@ -893,7 +893,7 @@ namespace {
                     return false;
                 }
 
-                Types.PgEmitAggApply = (name == "PgEmitAggApply");
+                Types_.PgEmitAggApply = (name == "PgEmitAggApply");
             }
             else if (name == "CostBasedOptimizer") {
                 if (args.size() != 1) {
@@ -901,7 +901,7 @@ namespace {
                     return false;
                 }
 
-                if (!TryFromString(args[0], Types.CostBasedOptimizer)) {
+                if (!TryFromString(args[0], Types_.CostBasedOptimizer)) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected `disable|pg|native', but got: " << args[0]));
                     return false;
                 }
@@ -911,18 +911,18 @@ namespace {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected no arguments, but got " << args.size()));
                     return false;
                 }
-                Types.MatchRecognize = name == "_EnableMatchRecognize";
+                Types_.MatchRecognize = name == "_EnableMatchRecognize";
             }
             else if (name == "TimeOrderRecoverDelay") {
                 if (args.size() != 1) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected one argument, but got " << args.size()));
                     return false;
                 }
-                if (!TryFromString(args[0], Types.TimeOrderRecoverDelay)) {
+                if (!TryFromString(args[0], Types_.TimeOrderRecoverDelay)) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected integer, but got: " << args[0]));
                     return false;
                 }
-                if (Types.TimeOrderRecoverDelay >= 0) {
+                if (Types_.TimeOrderRecoverDelay >= 0) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected negative value, but got: " << args[0]));
                     return false;
                 }
@@ -932,11 +932,11 @@ namespace {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected one argument, but got " << args.size()));
                     return false;
                 }
-                if (!TryFromString(args[0], Types.TimeOrderRecoverAhead)) {
+                if (!TryFromString(args[0], Types_.TimeOrderRecoverAhead)) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected integer, but got: " << args[0]));
                     return false;
                 }
-                if (Types.TimeOrderRecoverAhead <= 0) {
+                if (Types_.TimeOrderRecoverAhead <= 0) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected positive value, but got: " << args[0]));
                     return false;
                 }
@@ -946,11 +946,11 @@ namespace {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected one argument, but got " << args.size()));
                     return false;
                 }
-                if (!TryFromString(args[0], Types.TimeOrderRecoverRowLimit)) {
+                if (!TryFromString(args[0], Types_.TimeOrderRecoverRowLimit)) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected integer, but got: " << args[0]));
                     return false;
                 }
-                if (Types.TimeOrderRecoverRowLimit == 0) {
+                if (Types_.TimeOrderRecoverRowLimit == 0) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected positive value, but got: " << args[0]));
                     return false;
                 }
@@ -962,11 +962,11 @@ namespace {
                 }
                 const auto& arg = args[0];
                 if (arg == "disable") {
-                    Types.MatchRecognizeStreaming = EMatchRecognizeStreamingMode::Disable;
+                    Types_.MatchRecognizeStreaming = EMatchRecognizeStreamingMode::Disable;
                 } else if (arg == "auto") {
-                    Types.MatchRecognizeStreaming = EMatchRecognizeStreamingMode::Auto;
+                    Types_.MatchRecognizeStreaming = EMatchRecognizeStreamingMode::Auto;
                 } else if (arg == "force") {
-                    Types.MatchRecognizeStreaming = EMatchRecognizeStreamingMode::Force;
+                    Types_.MatchRecognizeStreaming = EMatchRecognizeStreamingMode::Force;
                 } else {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected `disable|auto|force', but got: " << args[0]));
                     return false;
@@ -979,7 +979,7 @@ namespace {
                 }
 
                 auto arg = TString{args[0]};
-                if (!TryFromString(arg, Types.BlockEngineMode)) {
+                if (!TryFromString(arg, Types_.BlockEngineMode)) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected `disable|auto|force', but got: " << args[0]));
                     return false;
                 }
@@ -990,7 +990,7 @@ namespace {
                         ctx.AddError(TIssue(pos, "Empty flags are not supported"));
                         return false;
                     }
-                    Types.OptimizerFlags.insert(to_lower(ToString(arg)));
+                    Types_.OptimizerFlags.insert(to_lower(ToString(arg)));
                 }
             }
             else if (name == "PeepholeFlags") {
@@ -999,7 +999,7 @@ namespace {
                         ctx.AddError(TIssue(pos, "Empty flags are not supported"));
                         return false;
                     }
-                    Types.PeepholeFlags.insert(to_lower(ToString(arg)));
+                    Types_.PeepholeFlags.insert(to_lower(ToString(arg)));
                 }
             }
             else if (name == "_EnableStreamLookupJoin" || name == "DisableStreamLookupJoin") {
@@ -1007,7 +1007,7 @@ namespace {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected no arguments, but got " << args.size()));
                     return false;
                 }
-                Types.StreamLookupJoin = name == "_EnableStreamLookupJoin";
+                Types_.StreamLookupJoin = name == "_EnableStreamLookupJoin";
             } else if (name == "MaxAggPushdownPredicates") {
                 if (args.size() != 1) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected single numeric argument, but got " << args.size()));
@@ -1023,7 +1023,7 @@ namespace {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Hard limit for setting MaxAggPushdownPredicates is " << hardLimit << ", but got: " << args[0]));
                     return false;
                 }
-                Types.MaxAggPushdownPredicates = value;
+                Types_.MaxAggPushdownPredicates = value;
             } else if (name == "Engine") {
                 if (args.size() != 1) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected at most 1 argument, but got " << args.size()));
@@ -1032,7 +1032,7 @@ namespace {
 
                 auto arg = TString{args[0]};
                 if (arg == "ytflow") {
-                    if (Types.ForceDq) {
+                    if (Types_.ForceDq) {
                         ctx.AddError(TIssue(pos, TStringBuilder()
                             << "Expected `disable|auto` argument for DqEngine pragma "
                             << "with Engine pragma argument `ytflow`"));
@@ -1040,22 +1040,22 @@ namespace {
                         return false;
                     }
 
-                    if (Types.PureResultDataSource == DqProviderName) {
-                        Types.PureResultDataSource.clear();
+                    if (Types_.PureResultDataSource == DqProviderName) {
+                        Types_.PureResultDataSource.clear();
                     }
 
-                    Types.EngineType = EEngineType::Ytflow;
+                    Types_.EngineType = EEngineType::Ytflow;
                 } else if (arg == "dq") {
-                    if (Find(Types.AvailablePureResultDataSources, DqProviderName) == Types.AvailablePureResultDataSources.end()) {
+                    if (Find(Types_.AvailablePureResultDataSources, DqProviderName) == Types_.AvailablePureResultDataSources.end()) {
                         ; // reserved
                     } else {
-                        Types.PureResultDataSource = DqProviderName;
-                        Types.ForceDq = true;
+                        Types_.PureResultDataSource = DqProviderName;
+                        Types_.ForceDq = true;
                     }
 
-                    Types.EngineType = EEngineType::Dq;
+                    Types_.EngineType = EEngineType::Dq;
                 } else if (arg == "default") {
-                    Types.EngineType = EEngineType::Default;
+                    Types_.EngineType = EEngineType::Default;
                 } else {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Expected `default|dq|ytflow', but got: " << arg));
                     return false;
@@ -1074,7 +1074,7 @@ namespace {
                 return false;
             }
 
-            if (Types.DisableNativeUdfSupport) {
+            if (Types_.DisableNativeUdfSupport) {
                 ctx.AddError(TIssue(pos, "Native UDF support is disabled"));
                 return false;
             }
@@ -1085,8 +1085,8 @@ namespace {
             const auto key = TUserDataStorage::ComposeUserDataKey(fileAlias);
             TString errorMessage;
             const TUserDataBlock* udfSource = nullptr;
-            if (!Types.QContext.CanRead()) {
-                udfSource = Types.UserDataStorage->FreezeUdfNoThrow(key, errorMessage, customUdfPrefix, Types.RuntimeLogLevel);
+            if (!Types_.QContext.CanRead()) {
+                udfSource = Types_.UserDataStorage->FreezeUdfNoThrow(key, errorMessage, customUdfPrefix, Types_.RuntimeLogLevel);
                 if (!udfSource) {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Unknown file: " << fileAlias << ", details: " << errorMessage));
                     return false;
@@ -1097,7 +1097,7 @@ namespace {
             import.Pos = pos;
             import.FileAlias = fileAlias;
             import.Block = udfSource;
-            Types.UdfImports.insert({ TString(fileAlias), import });
+            Types_.UdfImports.insert({ TString(fileAlias), import });
             return true;
         }
 
@@ -1107,11 +1107,11 @@ namespace {
                 return false;
             }
 
-            if (Types.Credentials->FindCredential(args[0])) {
+            if (Types_.Credentials->FindCredential(args[0])) {
                 return true;
             }
 
-            Types.Credentials->AddCredential(TString(args[0]), TCredential(TString(args[1]), TString(args[2]), TString(args[3])));
+            Types_.Credentials->AddCredential(TString(args[0]), TCredential(TString(args[1]), TString(args[2]), TString(args[3])));
             return true;
         }
 
@@ -1122,13 +1122,13 @@ namespace {
             }
 
             auto key = TUserDataStorage::ComposeUserDataKey(alias);
-            if (Types.UserDataStorage->ContainsUserDataBlock(key)) {
+            if (Types_.UserDataStorage->ContainsUserDataBlock(key)) {
                 // Don't overwrite.
                 return true;
             }
 
             TUserDataBlock block;
-            if (Types.QContext.CanRead()) {
+            if (Types_.QContext.CanRead()) {
                 block.Type = EUserDataType::RAW_INLINE_DATA;
             } else {
                 block.Type = EUserDataType::URL;
@@ -1138,7 +1138,7 @@ namespace {
                 }
             }
 
-            Types.UserDataStorage->AddUserDataBlock(key, block);
+            Types_.UserDataStorage->AddUserDataBlock(key, block);
             return true;
         }
 
@@ -1150,7 +1150,7 @@ namespace {
 
             TStringBuf token = args.size() == 3 ? args[2] : TStringBuf();
             if (token) {
-                if (auto cred = Types.Credentials->FindCredential(token)) {
+                if (auto cred = Types_.Credentials->FindCredential(token)) {
                     token = cred->Content;
                 } else {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Unknown token name '" << token << "'."));
@@ -1163,7 +1163,7 @@ namespace {
 
         bool SetFileOptionImpl(const TStringBuf alias, const TString& key, const TString& value, const TPosition& pos, TExprContext& ctx) {
             const auto dataKey = TUserDataStorage::ComposeUserDataKey(alias);
-            const auto dataBlock = Types.UserDataStorage->FindUserDataBlock(dataKey);
+            const auto dataBlock = Types_.UserDataStorage->FindUserDataBlock(dataKey);
             if (!dataBlock) {
                 ctx.AddError(TIssue(pos, TStringBuilder() << "No such file '" << alias << "'"));
                 return false;
@@ -1192,12 +1192,12 @@ namespace {
                 return false;
             }
 
-            if (!Types.UdfIndexPackageSet || !Types.UdfIndex) {
+            if (!Types_.UdfIndexPackageSet || !Types_.UdfIndex) {
                 ctx.AddError(TIssue(pos, TStringBuilder() << "UdfIndex is not initialized, unable to set version for package " << args[0]));
                 return false;
             }
 
-            if (!Types.UdfIndexPackageSet->AddResourceTo(TString(args[0]), version, Types.UdfIndex)) {
+            if (!Types_.UdfIndexPackageSet->AddResourceTo(TString(args[0]), version, Types_.UdfIndex)) {
                 ctx.AddError(TIssue(pos, TStringBuilder() << "Unable set default version to " << version << " for package " << args[0]));
                 return false;
             }
@@ -1269,13 +1269,13 @@ namespace {
 
             TStringBuf token = args.size() == 3 ? args[2] : TStringBuf();
             if (token) {
-                if (auto cred = Types.Credentials->FindCredential(token)) {
+                if (auto cred = Types_.Credentials->FindCredential(token)) {
                     token = cred->Content;
                 } else {
                     ctx.AddError(TIssue(pos, TStringBuilder() << "Unknown token name '" << token << "' for folder."));
                     return false;
                 }
-            } else if (auto cred = Types.Credentials->FindCredential("default_sandbox")) {
+            } else if (auto cred = Types_.Credentials->FindCredential("default_sandbox")) {
                 token = cred->Content;
             }
 
@@ -1312,8 +1312,8 @@ namespace {
                             }
                         } else if (type == "DIRECTORY") {
                             queue.emplace_back(alias, fileUrl->GetString());
-                            if (++count > Types.FolderSubDirsLimit) {
-                                ctx.AddError(TIssue(pos, TStringBuilder() << "Sandbox resource has too many subfolders. Limit is " << Types.FolderSubDirsLimit));
+                            if (++count > Types_.FolderSubDirsLimit) {
+                                ctx.AddError(TIssue(pos, TStringBuilder() << "Sandbox resource has too many subfolders. Limit is " << Types_.FolderSubDirsLimit));
                                 return false;
                             }
                         } else {
@@ -1355,14 +1355,14 @@ namespace {
         }
 
     private:
-        TTypeAnnotationContext& Types;
-        TAutoPtr<IGraphTransformer> TypeAnnotationTransformer;
-        TAutoPtr<IGraphTransformer> ConfigurationTransformer;
-        TAutoPtr<IGraphTransformer> CallableExecutionTransformer;
-        const TYqlCoreConfig* CoreConfig;
-        TString Username;
-        const TAllowSettingPolicy Policy;
-        TOperationStatistics Statistics;
+        TTypeAnnotationContext& Types_;
+        TAutoPtr<IGraphTransformer> TypeAnnotationTransformer_;
+        TAutoPtr<IGraphTransformer> ConfigurationTransformer_;
+        TAutoPtr<IGraphTransformer> CallableExecutionTransformer_;
+        const TYqlCoreConfig* CoreConfig_;
+        TString Username_;
+        const TAllowSettingPolicy Policy_;
+        TOperationStatistics Statistics_;
     };
 }
 
diff --git a/yql/essentials/providers/result/expr_nodes/yql_res_expr_nodes.h b/yql/essentials/providers/result/expr_nodes/yql_res_expr_nodes.h
index 4ea8ed93d0c..cded54b3647 100644
--- a/yql/essentials/providers/result/expr_nodes/yql_res_expr_nodes.h
+++ b/yql/essentials/providers/result/expr_nodes/yql_res_expr_nodes.h
@@ -47,16 +47,16 @@ public:
 
     TNodeBuilder(TExprContext& ctx, TPositionHandle pos, BuildFuncType buildFunc, GetArgFuncType getArgFunc)
         : TNodeBuilderBase(ctx, pos, getArgFunc)
-        , BuildFunc(buildFunc) {}
+        , BuildFunc_(buildFunc) {}
 
     TParent& Build() {
         auto atom = this->Ctx_.NewAtom(this->Pos_, ResultProviderName);
         auto node = this->Ctx_.NewCallable(this->Pos_, "DataSink", { atom });
-        return BuildFunc(TResultDataSink(node));
+        return BuildFunc_(TResultDataSink(node));
     }
 
 private:
-    BuildFuncType BuildFunc;
+    BuildFuncType BuildFunc_;
 };
 
 } // namespace NNodes
diff --git a/yql/essentials/providers/result/provider/yql_result_provider.cpp b/yql/essentials/providers/result/provider/yql_result_provider.cpp
index 3ad6a86ca86..b47ba4f050d 100644
--- a/yql/essentials/providers/result/provider/yql_result_provider.cpp
+++ b/yql/essentials/providers/result/provider/yql_result_provider.cpp
@@ -29,75 +29,75 @@ namespace {
     {
     public:
         TYsonResultWriter(NYson::EYsonFormat format)
-            : Writer(new NYson::TYsonWriter(&PartialStream, format, ::NYson::EYsonType::Node, true))
+            : Writer_(new NYson::TYsonWriter(&PartialStream_, format, ::NYson::EYsonType::Node, true))
         {}
 
         void Init(bool discard, const TString& label, TMaybe<TPosition> pos, bool unordered) override {
-            Discard = discard;
-            Unordered = unordered;
-            if (!Discard) {
-                Writer->OnBeginMap();
+            Discard_ = discard;
+            Unordered_ = unordered;
+            if (!Discard_) {
+                Writer_->OnBeginMap();
                 if (label) {
-                    Writer->OnKeyedItem("Label");
-                    Writer->OnStringScalar(label);
+                    Writer_->OnKeyedItem("Label");
+                    Writer_->OnStringScalar(label);
                 }
 
                 if (pos) {
-                    Writer->OnKeyedItem("Position");
-                    Writer->OnBeginMap();
-                    Writer->OnKeyedItem("File");
-                    Writer->OnStringScalar(pos->File ? pos->File : "<main>");
-                    Writer->OnKeyedItem("Row");
-                    Writer->OnInt64Scalar(pos->Row);
-                    Writer->OnKeyedItem("Column");
-                    Writer->OnInt64Scalar(pos->Column);
-                    Writer->OnEndMap();
+                    Writer_->OnKeyedItem("Position");
+                    Writer_->OnBeginMap();
+                    Writer_->OnKeyedItem("File");
+                    Writer_->OnStringScalar(pos->File ? pos->File : "<main>");
+                    Writer_->OnKeyedItem("Row");
+                    Writer_->OnInt64Scalar(pos->Row);
+                    Writer_->OnKeyedItem("Column");
+                    Writer_->OnInt64Scalar(pos->Column);
+                    Writer_->OnEndMap();
                 }
 
-                Writer->OnKeyedItem("Write");
-                Writer->OnBeginList();
+                Writer_->OnKeyedItem("Write");
+                Writer_->OnBeginList();
             }
         }
 
         void Write(const TStringBuf& resultData) override {
-            if (!Discard) {
-                Writer->OnListItem();
-                Writer->OnRaw(resultData);
+            if (!Discard_) {
+                Writer_->OnListItem();
+                Writer_->OnRaw(resultData);
             }
         }
 
         void Commit(bool overflow) override {
-            if (!Discard) {
-                Writer->OnEndList();
+            if (!Discard_) {
+                Writer_->OnEndList();
                 if (overflow) {
-                    Writer->OnKeyedItem("Truncated");
-                    Writer->OnBooleanScalar(true);
+                    Writer_->OnKeyedItem("Truncated");
+                    Writer_->OnBooleanScalar(true);
                 }
-                if (Unordered) {
-                    Writer->OnKeyedItem("Unordered");
-                    Writer->OnBooleanScalar(true);
+                if (Unordered_) {
+                    Writer_->OnKeyedItem("Unordered");
+                    Writer_->OnBooleanScalar(true);
                 }
-                Writer->OnEndMap();
+                Writer_->OnEndMap();
             }
         }
 
         bool IsDiscard() const override {
-            return Discard;
+            return Discard_;
         }
 
         TStringBuf Str() override {
-            return PartialStream.Str();
+            return PartialStream_.Str();
         }
 
         ui64 Size() override {
-            return PartialStream.Size();
+            return PartialStream_.Size();
         }
 
     private:
-        TStringStream PartialStream;
-        TAutoPtr<NYson::TYsonWriter> Writer;
-        bool Discard = false;
-        bool Unordered = false;
+        TStringStream PartialStream_;
+        TAutoPtr<NYson::TYsonWriter> Writer_;
+        bool Discard_ = false;
+        bool Unordered_ = false;
     };
 
     IGraphTransformer::TStatus ValidateColumns(TExprNode::TPtr& columns, const TTypeAnnotationNode* listType, TExprContext& ctx) {
@@ -234,9 +234,9 @@ namespace {
     class TResultCallableExecutionTransformer : public TGraphTransformerBase {
     public:
         TResultCallableExecutionTransformer(const TIntrusivePtr<TResultProviderConfig>& config)
-            : Config(config)
+            : Config_(config)
         {
-            YQL_ENSURE(!Config->Types.AvailablePureResultDataSources.empty());
+            YQL_ENSURE(!Config_->Types.AvailablePureResultDataSources.empty());
         }
 
         TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
@@ -248,7 +248,7 @@ namespace {
             YQL_ENSURE(input->Type() == TExprNode::Callable);
             TExprBase node(input);
             if (node.Maybe<TResFill>() || node.Maybe<TResPull>() || node.Maybe<TResIf>() || node.Maybe<TResFor>()) {
-                auto provider = Config->Types.DataSourceMap.FindPtr(input->Child(5)->Content());
+                auto provider = Config_->Types.DataSourceMap.FindPtr(input->Child(5)->Content());
                 Y_ENSURE(provider, "DataSource not exist: " << input->Child(5)->Content());
                 if (node.Maybe<TResPull>()) {
                     return HandleFillOrPull<TPull>(node, output, ctx, *(*provider));
@@ -258,19 +258,19 @@ namespace {
             }
 
             if (input->Content() == CommitName) {
-                if (ResultWriter) {
+                if (ResultWriter_) {
                     TExprBase commitChild(input->ChildPtr(0));
 
-                    bool overflow = commitChild.Maybe<TResPull>() ? PullOverflow : FillOverflow;
-                    ui64& committedSize = commitChild.Maybe<TResPull>() ? CommittedPullSize : CommittedFillSize;
+                    bool overflow = commitChild.Maybe<TResPull>() ? PullOverflow_ : FillOverflow_;
+                    ui64& committedSize = commitChild.Maybe<TResPull>() ? CommittedPullSize_ : CommittedFillSize_;
 
-                    if (!ResultWriter->IsDiscard()) {
-                        ResultWriter->Commit(overflow);
-                        Config->CommittedResults.push_back(TString(ResultWriter->Str()));
-                        committedSize += Config->CommittedResults.back().size();
+                    if (!ResultWriter_->IsDiscard()) {
+                        ResultWriter_->Commit(overflow);
+                        Config_->CommittedResults.push_back(TString(ResultWriter_->Str()));
+                        committedSize += Config_->CommittedResults.back().size();
                     }
 
-                    ResultWriter.Reset();
+                    ResultWriter_.Reset();
                 }
 
                 input->SetState(TExprNode::EState::ExecutionComplete);
@@ -290,22 +290,22 @@ namespace {
 
         NThreading::TFuture<void> DoGetAsyncFuture(const TExprNode& input) final {
             Y_UNUSED(input);
-            YQL_ENSURE(DelegatedProvider);
-            YQL_ENSURE(DelegatedNode);
-            YQL_ENSURE(DelegatedNodeOutput);
-            return DelegatedProvider->GetCallableExecutionTransformer()
-                .GetAsyncFuture(*DelegatedNode);
+            YQL_ENSURE(DelegatedProvider_);
+            YQL_ENSURE(DelegatedNode_);
+            YQL_ENSURE(DelegatedNodeOutput_);
+            return DelegatedProvider_->GetCallableExecutionTransformer()
+                .GetAsyncFuture(*DelegatedNode_);
         }
 
         TStatus DoApplyAsyncChanges(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
             output = input;
-            YQL_ENSURE(DelegatedProvider);
-            YQL_ENSURE(DelegatedNode);
-            YQL_ENSURE(DelegatedNodeOutput);
-            auto status = DelegatedProvider->GetCallableExecutionTransformer()
-                .ApplyAsyncChanges(DelegatedNode, DelegatedNodeOutput, ctx);
-            if (status == TStatus::Repeat && input != DelegatedNodeOutput->TailPtr()) {
-                output = DelegatedNodeOutput->TailPtr();
+            YQL_ENSURE(DelegatedProvider_);
+            YQL_ENSURE(DelegatedNode_);
+            YQL_ENSURE(DelegatedNodeOutput_);
+            auto status = DelegatedProvider_->GetCallableExecutionTransformer()
+                .ApplyAsyncChanges(DelegatedNode_, DelegatedNodeOutput_, ctx);
+            if (status == TStatus::Repeat && input != DelegatedNodeOutput_->TailPtr()) {
+                output = DelegatedNodeOutput_->TailPtr();
             } else {
                 FinishNode(*input, ctx, status);
             }
@@ -313,17 +313,17 @@ namespace {
         }
 
         void Rewind() final {
-            DelegatedProvider = nullptr;
-            DelegatedNode = nullptr;
-            DelegatedNodeOutput = nullptr;
+            DelegatedProvider_ = nullptr;
+            DelegatedNode_ = nullptr;
+            DelegatedNodeOutput_ = nullptr;
 
-            CommittedPullSize = 0;
-            PullOverflow = false;
+            CommittedPullSize_ = 0;
+            PullOverflow_ = false;
 
-            CommittedFillSize = 0;
-            FillOverflow = false;
+            CommittedFillSize_ = 0;
+            FillOverflow_ = false;
 
-            ResultWriter.Drop();
+            ResultWriter_.Drop();
         }
 
    private:
@@ -521,9 +521,9 @@ namespace {
                 options = input.Cast<TResWriteBase>().Settings();
             }
 
-            DelegatedProvider = &provider;
-            auto fillSettings = Config->FillSettings;
-            auto resultSize = ResultWriter ? ResultWriter->Size() : 0;
+            DelegatedProvider_ = &provider;
+            auto fillSettings = Config_->FillSettings;
+            auto resultSize = ResultWriter_ ? ResultWriter_->Size() : 0;
 
             ui64 committedSize;
             bool& overflow = GetOverflowFlagAndCommitedSize<TTarget>(committedSize);
@@ -563,14 +563,14 @@ namespace {
             }
 
             TString publicId;
-            if (auto id = Config->Types.TranslateOperationId(input.Ref().UniqueId())) {
+            if (auto id = Config_->Types.TranslateOperationId(input.Ref().UniqueId())) {
                 publicId = ToString(*id);
             }
 
-            if (needWriter && !ResultWriter) {
-                YQL_ENSURE(Config->WriterFactory);
-                ResultWriter = Config->WriterFactory();
-                ResultWriter->Init(discard, label, Config->SupportsResultPosition ?
+            if (needWriter && !ResultWriter_) {
+                YQL_ENSURE(Config_->WriterFactory);
+                ResultWriter_ = Config_->WriterFactory();
+                ResultWriter_->Init(discard, label, Config_->SupportsResultPosition ?
                     TMaybe<TPosition>(ctx.GetPosition(input.Pos())) : Nothing(), unordered);
             }
 
@@ -584,7 +584,7 @@ namespace {
                 rowsLimit.Clear();
             }
 
-            DelegatedNode = Build<TTarget>(ctx, input.Pos())
+            DelegatedNode_ = Build<TTarget>(ctx, input.Pos())
                 .Input(dataNode.Cast())
                 .BytesLimit()
                     .Value(fillSettings.AllResultsBytesLimit ? ToString(*fillSettings.AllResultsBytesLimit) : TString())
@@ -610,14 +610,14 @@ namespace {
 
             for (auto idx: {TResOrPullBase::idx_BytesLimit, TResOrPullBase::idx_RowsLimit, TResOrPullBase::idx_FormatDetails,
                 TResOrPullBase::idx_Format, TResOrPullBase::idx_PublicId, TResOrPullBase::idx_Discard }) {
-                DelegatedNode->Child(idx)->SetTypeAnn(atomType);
-                DelegatedNode->Child(idx)->SetState(TExprNode::EState::ConstrComplete);
+                DelegatedNode_->Child(idx)->SetTypeAnn(atomType);
+                DelegatedNode_->Child(idx)->SetState(TExprNode::EState::ConstrComplete);
             }
 
-            DelegatedNode->SetTypeAnn(input.Ref().GetTypeAnn());
-            DelegatedNode->SetState(TExprNode::EState::ConstrComplete);
+            DelegatedNode_->SetTypeAnn(input.Ref().GetTypeAnn());
+            DelegatedNode_->SetState(TExprNode::EState::ConstrComplete);
             input.Ptr()->SetState(TExprNode::EState::ExecutionInProgress);
-            auto status = DelegatedProvider->GetCallableExecutionTransformer().Transform(DelegatedNode, DelegatedNodeOutput, ctx);
+            auto status = DelegatedProvider_->GetCallableExecutionTransformer().Transform(DelegatedNode_, DelegatedNodeOutput_, ctx);
             if (status.Level != TStatus::Async) {
                 status = FinishNode(*input.Ptr(), ctx, status);
             }
@@ -627,11 +627,11 @@ namespace {
 
         IGraphTransformer::TStatus FinishNode(TExprNode& input, TExprContext& ctx, IGraphTransformer::TStatus status) {
             if (status.Level == TStatus::Ok) {
-                auto data = DelegatedNode->GetResult().Content();
+                auto data = DelegatedNode_->GetResult().Content();
                 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);
@@ -641,73 +641,73 @@ namespace {
                     status = IGraphTransformer::TStatus::Repeat;
                 }
             } else if (status.Level == TStatus::Error) {
-                if (const auto issies = ctx.AssociativeIssues.extract(DelegatedNode.Get())) {
+                if (const auto issies = ctx.AssociativeIssues.extract(DelegatedNode_.Get())) {
                     ctx.IssueManager.RaiseIssues(issies.mapped());
                 }
             } else {
                 input.SetState(TExprNode::EState::ExecutionRequired);
             }
 
-            DelegatedProvider = nullptr;
-            DelegatedNode = nullptr;
-            DelegatedNodeOutput = nullptr;
+            DelegatedProvider_ = nullptr;
+            DelegatedNode_ = nullptr;
+            DelegatedNodeOutput_ = nullptr;
             return status;
         }
 
     private:
-        const TIntrusivePtr<TResultProviderConfig> Config;
-        IDataProvider* DelegatedProvider = nullptr;
-        TExprNode::TPtr DelegatedNode;
-        TExprNode::TPtr DelegatedNodeOutput;
+        const TIntrusivePtr<TResultProviderConfig> Config_;
+        IDataProvider* DelegatedProvider_ = nullptr;
+        TExprNode::TPtr DelegatedNode_;
+        TExprNode::TPtr DelegatedNodeOutput_;
 
-        ui64 CommittedPullSize = 0;
-        bool PullOverflow = false;
+        ui64 CommittedPullSize_ = 0;
+        bool PullOverflow_ = false;
 
-        ui64 CommittedFillSize = 0;
-        bool FillOverflow = false;
+        ui64 CommittedFillSize_ = 0;
+        bool FillOverflow_ = false;
 
-        TIntrusivePtr<IResultWriter> ResultWriter;
+        TIntrusivePtr<IResultWriter> ResultWriter_;
     };
 
     template <class TTarget>
     bool& TResultCallableExecutionTransformer::GetOverflowFlagAndCommitedSize(ui64& committed) {
-        committed = CommittedFillSize;
-        return FillOverflow;
+        committed = CommittedFillSize_;
+        return FillOverflow_;
     }
 
     template<>
     bool& TResultCallableExecutionTransformer::GetOverflowFlagAndCommitedSize<TPull>(ui64& committed) {
-        committed = CommittedPullSize;
-        return PullOverflow;
+        committed = CommittedPullSize_;
+        return PullOverflow_;
     }
 
     class TResultTrackableNodeProcessor : public TTrackableNodeProcessorBase {
     public:
         TResultTrackableNodeProcessor(const TIntrusivePtr<TResultProviderConfig>& config)
-            : Config(config)
+            : Config_(config)
         {}
 
         void GetUsedNodes(const TExprNode& input, TVector<TString>& usedNodeIds) override {
             usedNodeIds.clear();
             if (TMaybeNode<TResFill>(&input) || TMaybeNode<TResPull>(&input) || TMaybeNode<TResIf>(&input)
                 || TMaybeNode<TResFor>(&input)) {
-                auto provider = Config->Types.DataSourceMap.FindPtr(input.Child(5)->Content());
+                auto provider = Config_->Types.DataSourceMap.FindPtr(input.Child(5)->Content());
                 Y_ENSURE(provider, "DataSource not exist: " << input.Child(5)->Content());
                 (*provider)->GetTrackableNodeProcessor().GetUsedNodes(input, usedNodeIds);
             }
         }
     private:
-        const TIntrusivePtr<TResultProviderConfig> Config;
+        const TIntrusivePtr<TResultProviderConfig> Config_;
     };
 
     class TPhysicalFinalizingTransformer final : public TSyncTransformerBase {
     public:
         TPhysicalFinalizingTransformer(const TIntrusivePtr<TResultProviderConfig>& config)
-            : Config(config) {}
+            : Config_(config) {}
 
         TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) final {
-            TOptimizeExprSettings settings(&Config->Types);
-            settings.ProcessedNodes = &PhysicalOptProcessedNodes;
+            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;
@@ -726,7 +726,7 @@ namespace {
                     }
 
                     auto writeInput = resWrite.Data();
-                    for (auto& source : Config->Types.DataSources) {
+                    for (auto& source : Config_->Types.DataSources) {
                         TSyncMap syncList;
                         bool canRef;
                         if (source->CanPullResult(writeInput.Ref(), syncList, canRef)) {
@@ -738,7 +738,7 @@ namespace {
                                 return nullptr;
                             }
 
-                            auto fillSettings = Config->FillSettings;
+                            auto fillSettings = Config_->FillSettings;
                             if (!isRef && (!isAutoRef || !canRef)) {
                                 for (auto setting: resWrite.Settings()) {
                                     if (setting.Name().Value() == "take") {
@@ -795,7 +795,7 @@ namespace {
                                 .Data(cleanup)
                                 .Settings(resWrite.Settings())
                                 .DelegatedSource()
-                                    .Value(Config->Types.GetDefaultDataSource())
+                                    .Value(Config_->Types.GetDefaultDataSource())
                                 .Build()
                                 .Done().Ptr();
 
@@ -803,7 +803,7 @@ namespace {
                             return ret;
                         }
 
-                        for (auto& source : Config->Types.DataSources) {
+                        for (auto& source : Config_->Types.DataSources) {
                             TSyncMap syncList;
                             if (source->CanBuildResult(writeInput.Ref(), syncList)) {
                                 auto cleanup = source->CleanupWorld(data.Ptr(), ctx);
@@ -831,7 +831,7 @@ namespace {
                     TSyncMap syncList;
                     auto foundDataSource = FindDataSource(*node->Child(1), syncList);
                     if (!foundDataSource.empty()) {
-                        auto provider = Config->Types.DataSourceMap.FindPtr(foundDataSource);
+                        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) {
@@ -859,7 +859,7 @@ namespace {
                     TSyncMap syncList;
                     auto foundDataSource = FindDataSource(*node->Child(1), syncList);
                     if (!foundDataSource.empty()) {
-                        auto provider = Config->Types.DataSourceMap.FindPtr(foundDataSource);
+                        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) {
@@ -900,7 +900,7 @@ namespace {
         }
 
         void Rewind() final {
-            PhysicalOptProcessedNodes.clear();
+            PhysicalOptProcessedNodes_.clear();
         }
 
     private:
@@ -908,11 +908,11 @@ namespace {
             syncList.clear();
             TString foundDataSource;
             if (IsPureIsolatedLambda(node)) {
-                foundDataSource = Config->Types.GetDefaultDataSource();
+                foundDataSource = Config_->Types.GetDefaultDataSource();
             }
 
             if (foundDataSource.empty()) {
-                for (auto& source : Config->Types.DataSources) {
+                for (auto& source : Config_->Types.DataSources) {
                     syncList.clear();
                     if (source->CanBuildResult(node, syncList)) {
                         foundDataSource = TString(source->GetName());
@@ -925,8 +925,8 @@ namespace {
         }
 
     private:
-        const TIntrusivePtr<TResultProviderConfig> Config;
-        TProcessedNodesSet PhysicalOptProcessedNodes;
+        const TIntrusivePtr<TResultProviderConfig> Config_;
+        TProcessedNodesSet PhysicalOptProcessedNodes_;
     };
 
     class TResultProvider : public TDataProviderBase {
@@ -944,8 +944,8 @@ namespace {
         };
 
         TResultProvider(const TIntrusivePtr<TResultProviderConfig>& config)
-            : Config(config)
-            , TrackableNodeProcessor(config)
+            : Config_(config)
+            , TrackableNodeProcessor_(config)
         {}
 
         TStringBuf GetName() const override {
@@ -971,8 +971,8 @@ namespace {
 
         IGraphTransformer& GetTypeAnnotationTransformer(bool instantOnly) override {
             Y_UNUSED(instantOnly);
-            if (!TypeAnnotationTransformer) {
-                TypeAnnotationTransformer = CreateFunctorTransformer(
+            if (!TypeAnnotationTransformer_) {
+                TypeAnnotationTransformer_ = CreateFunctorTransformer(
                     [&](const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx)->IGraphTransformer::TStatus {
                     output = input;
 
@@ -1112,13 +1112,13 @@ namespace {
                                 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);
+                                        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);
+                                        provider = Config_->Types.DataSinkMap.FindPtr(name);
                                         Y_ENSURE(provider, "DataSink doesn't exist: " << name);
                                     }
                                 }
@@ -1136,16 +1136,16 @@ namespace {
                                 return IGraphTransformer::TStatus::Error;
                             }
 
-                            if (!Config->Types.DataSourceMap.FindPtr(resTransient.DelegatedSource().Value())) {
+                            if (!Config_->Types.DataSourceMap.FindPtr(resTransient.DelegatedSource().Value())) {
                                 ctx.AddError(TIssue(ctx.GetPosition(resTransient.DelegatedSource().Pos()),
                                     TStringBuilder() << "DataSource is not found: " << resTransient.DelegatedSource().Value()));
                                 return IGraphTransformer::TStatus::Error;
                             }
                         }
 
-                        if (Config->Types.OrderedColumns && res.Data().Ref().IsCallable("AssumeColumnOrder")) {
+                        if (Config_->Types.OrderedColumns && res.Data().Ref().IsCallable("AssumeColumnOrder")) {
                             if (!HasSetting(res.Settings().Ref(), "freezeColumns")) {
-                                auto dataOrder = Config->Types.LookupColumnOrder(res.Data().Ref());
+                                auto dataOrder = Config_->Types.LookupColumnOrder(res.Data().Ref());
                                 YQL_ENSURE(dataOrder);
 
                                 YQL_CLOG(INFO, ProviderResult) << "Setting result column order: " << FormatColumnOrder(dataOrder);
@@ -1194,7 +1194,7 @@ namespace {
                             return IGraphTransformer::TStatus::Error;
                         }
 
-                        if (!Config->Types.DataSourceMap.FindPtr(input->Child(TResIf::idx_DelegatedSource)->Content())) {
+                        if (!Config_->Types.DataSourceMap.FindPtr(input->Child(TResIf::idx_DelegatedSource)->Content())) {
                             ctx.AddError(TIssue(ctx.GetPosition(input->Child(TResIf::idx_DelegatedSource)->Pos()),
                                 TStringBuilder() << "DataSource is not found: " << input->Child(TResIf::idx_DelegatedSource)->Content()));
                             return IGraphTransformer::TStatus::Error;
@@ -1271,7 +1271,7 @@ namespace {
                             return IGraphTransformer::TStatus::Error;
                         }
 
-                        if (!Config->Types.DataSourceMap.FindPtr(input->Child(TResFor::idx_DelegatedSource)->Content())) {
+                        if (!Config_->Types.DataSourceMap.FindPtr(input->Child(TResFor::idx_DelegatedSource)->Content())) {
                             ctx.AddError(TIssue(ctx.GetPosition(input->Child(TResFor::idx_DelegatedSource)->Pos()),
                                 TStringBuilder() << "DataSource is not found: " << input->Child(TResFor::idx_DelegatedSource)->Content()));
                             return IGraphTransformer::TStatus::Error;
@@ -1373,10 +1373,10 @@ namespace {
                                 return IGraphTransformer::TStatus::Error;
                             }
 
-                            if (Config->FillSettings.AllResultsBytesLimit) {
-                                Config->FillSettings.AllResultsBytesLimit = Min(*Config->FillSettings.AllResultsBytesLimit, limit);
+                            if (Config_->FillSettings.AllResultsBytesLimit) {
+                                Config_->FillSettings.AllResultsBytesLimit = Min(*Config_->FillSettings.AllResultsBytesLimit, limit);
                             } else {
-                                Config->FillSettings.AllResultsBytesLimit = limit;
+                                Config_->FillSettings.AllResultsBytesLimit = limit;
                             }
 
                         } else {
@@ -1393,7 +1393,7 @@ namespace {
                 });
             }
 
-            return *TypeAnnotationTransformer;
+            return *TypeAnnotationTransformer_;
         }
 
         TExprNode::TPtr RewriteIO(const TExprNode::TPtr& node, TExprContext& ctx) override {
@@ -1420,11 +1420,11 @@ namespace {
         }
 
         IGraphTransformer& GetPhysicalFinalizingTransformer() override {
-            if (!PhysicalFinalizingTransformer) {
-                PhysicalFinalizingTransformer = new TPhysicalFinalizingTransformer(Config);
+            if (!PhysicalFinalizingTransformer_) {
+                PhysicalFinalizingTransformer_ = new TPhysicalFinalizingTransformer(Config_);
             }
 
-            return *PhysicalFinalizingTransformer;
+            return *PhysicalFinalizingTransformer_;
         }
 
         bool CanExecute(const TExprNode& node) override {
@@ -1453,7 +1453,7 @@ namespace {
 
         bool ValidateExecution(const TExprNode& node, TExprContext& ctx) override {
             auto getDataProvider = [&]() {
-                auto provider = Config->Types.DataSourceMap.FindPtr(node.Child(5)->Content());
+                auto provider = Config_->Types.DataSourceMap.FindPtr(node.Child(5)->Content());
                 Y_ENSURE(provider, "DataSource doesn't exist: " << node.Child(5)->Content());
                 return *provider;
             };
@@ -1471,19 +1471,19 @@ namespace {
         }
 
         IGraphTransformer& GetCallableExecutionTransformer() override {
-            if (!CallableExecutionTransformer) {
-                CallableExecutionTransformer = new TResultCallableExecutionTransformer(Config);
+            if (!CallableExecutionTransformer_) {
+                CallableExecutionTransformer_ = new TResultCallableExecutionTransformer(Config_);
             }
 
-            return *CallableExecutionTransformer;
+            return *CallableExecutionTransformer_;
         }
 
         void Reset() final {
             TDataProviderBase::Reset();
-            if (CallableExecutionTransformer) {
-                CallableExecutionTransformer.Reset();
+            if (CallableExecutionTransformer_) {
+                CallableExecutionTransformer_.Reset();
             }
-            Config->CommittedResults.clear();
+            Config_->CommittedResults.clear();
         }
 
         bool GetDependencies(const TExprNode& node, TExprNode::TListType& children, bool compact) override {
@@ -1500,7 +1500,7 @@ namespace {
                         children.push_back(active);
                     }
                 } else if (auto resFill = TMaybeNode<TResFill>(&node)) {
-                    const auto provider = Config->Types.DataSourceMap.FindPtr(resFill.Cast().DelegatedSource().Value());
+                    const auto provider = Config_->Types.DataSourceMap.FindPtr(resFill.Cast().DelegatedSource().Value());
                     Y_ENSURE(provider, "DataSource not exist: " << resFill.Cast().DelegatedSource().Value());
                     (*provider)->GetPlanFormatter().GetResultDependencies(resFill.Cast().Data().Ptr(), children, compact);
                 }
@@ -1515,7 +1515,7 @@ namespace {
             Y_UNUSED(withLimits);
             if (auto resPull = TMaybeNode<TResPull>(&node)) {
                 auto dataSourceName = resPull.Cast().DelegatedSource().Value();
-                auto dataSource = Config->Types.DataSourceMap.FindPtr(dataSourceName);
+                auto dataSource = Config_->Types.DataSourceMap.FindPtr(dataSourceName);
                 YQL_ENSURE(dataSource);
 
                 (*dataSource)->GetPlanFormatter().WritePullDetails(resPull.Cast().Data().Ref(), writer);
@@ -1549,15 +1549,15 @@ namespace {
         }
 
         ITrackableNodeProcessor& GetTrackableNodeProcessor() override {
-            return TrackableNodeProcessor;
+            return TrackableNodeProcessor_;
         }
 
     private:
-        const TIntrusivePtr<TResultProviderConfig> Config;
-        TResultTrackableNodeProcessor TrackableNodeProcessor;
-        TAutoPtr<IGraphTransformer> TypeAnnotationTransformer;
-        TAutoPtr<IGraphTransformer> PhysicalFinalizingTransformer;
-        TAutoPtr<IGraphTransformer> CallableExecutionTransformer;
+        const TIntrusivePtr<TResultProviderConfig> Config_;
+        TResultTrackableNodeProcessor TrackableNodeProcessor_;
+        TAutoPtr<IGraphTransformer> TypeAnnotationTransformer_;
+        TAutoPtr<IGraphTransformer> PhysicalFinalizingTransformer_;
+        TAutoPtr<IGraphTransformer> CallableExecutionTransformer_;
     };
 }
 
diff --git a/yt/yql/providers/yt/common/yql_yt_settings.cpp b/yt/yql/providers/yt/common/yql_yt_settings.cpp
index ab90b5f3cf1..bc895a1d1dd 100644
--- a/yt/yql/providers/yt/common/yql_yt_settings.cpp
+++ b/yt/yql/providers/yt/common/yql_yt_settings.cpp
@@ -156,7 +156,7 @@ TYtConfiguration::TYtConfiguration(TTypeAnnotationContext& typeCtx)
 
     REGISTER_SETTING(*this, DefaultCluster)
         .Validator([this] (const TString&, TString value) {
-            if (!ValidClusters.contains(value)) {
+            if (!GetValidClusters().contains(value)) {
                 throw yexception() << "Unknown cluster name: " << value;
             }
         });
@@ -544,14 +544,14 @@ TYtConfiguration::TYtConfiguration(TTypeAnnotationContext& typeCtx)
             if (cluster != "$all") {
                 throw yexception() << "Per-cluster setting is not supported for RuntimeCluster";
             }
-            if (!ValidClusters.contains(value)) {
+            if (!GetValidClusters().contains(value)) {
                 throw yexception() << "Unknown cluster name: " << value;
             }
         });
     REGISTER_SETTING(*this, RuntimeClusterSelection).Parser([](const TString& v) { return FromString<ERuntimeClusterSelectionMode>(v); });
     REGISTER_SETTING(*this, DefaultRuntimeCluster)
         .Validator([this] (const TString&, TString value) {
-            if (!ValidClusters.contains(value)) {
+            if (!GetValidClusters().contains(value)) {
                 throw yexception() << "Unknown cluster name: " << value;
             }
         });