YQL-20086 udfs

commit_hash:631fd9ed259a7c95a618e1265f61df28a87ce922

31 files changed, 759 insertions, 759 deletions

diff --git a/yql/essentials/udfs/common/datetime2/datetime_udf.cpp b/yql/essentials/udfs/common/datetime2/datetime_udf.cpp
index 631b68254de..aeffa815133 100644
--- a/yql/essentials/udfs/common/datetime2/datetime_udf.cpp
+++ b/yql/essentials/udfs/common/datetime2/datetime_udf.cpp
@@ -3100,13 +3100,13 @@ private:
         std::vector<std::function<bool(std::string_view::const_iterator& it, size_t, TUnboxedValuePod&, const IDateBuilder&)>> Scanners_;
 
         struct TDataScanner {
-            const std::string_view Data_;
+            const std::string_view Data;
 
             bool operator()(std::string_view::const_iterator& it, size_t limit, TUnboxedValuePod&, const IDateBuilder&) const {
-                if (limit < Data_.size() || !std::equal(Data_.begin(), Data_.end(), it)) {
+                if (limit < Data.size() || !std::equal(Data.begin(), Data.end(), it)) {
                     return false;
                 }
-                std::advance(it, Data_.size());
+                std::advance(it, Data.size());
                 return true;
             }
         };
diff --git a/yql/essentials/udfs/common/digest/digest_udf.cpp b/yql/essentials/udfs/common/digest/digest_udf.cpp
index 5f87d42bfd2..834d38aeaf6 100644
--- a/yql/essentials/udfs/common/digest/digest_udf.cpp
+++ b/yql/essentials/udfs/common/digest/digest_udf.cpp
@@ -410,7 +410,7 @@ namespace {
         return TUnboxedValuePod(hash);
     }
 
-    class TXXH3_128: public TBoxedValue {
+    class TXXH3_128: public TBoxedValue { // NOLINT(readability-identifier-naming)
     public:
         static TStringRef Name() {
             static auto name = TStringRef::Of("XXH3_128");
diff --git a/yql/essentials/udfs/common/file/file_udf.cpp b/yql/essentials/udfs/common/file/file_udf.cpp
index fa5f84a2c57..ee09b2af20d 100644
--- a/yql/essentials/udfs/common/file/file_udf.cpp
+++ b/yql/essentials/udfs/common/file/file_udf.cpp
@@ -169,15 +169,15 @@ namespace {
         typedef TIntrusivePtr<TStreamMeta> TPtr;
 
         TStreamMeta(TString filePath)
-            : FilePath(filePath)
+            : FilePath_(filePath)
         {
             // work in greedy mode to catch error on creation
-            Cached = DoCreateStream();
+            Cached_ = DoCreateStream();
         }
 
         std::unique_ptr<TStream> CreateStream(TTerminateFunc terminateFunc) {
-            if (Cached) {
-                return std::move(Cached);
+            if (Cached_) {
+                return std::move(Cached_);
             }
 
             terminateFunc("The file iterator was already created. To scan file data multiple times please use ListCollect either over ParseFile or over some lazy function over it, e.g. ListMap");
@@ -185,37 +185,37 @@ namespace {
         }
 
         bool GetLinesCount(ui64& count) const {
-            if (LinesCount == Unknown)
+            if (LinesCount_ == Unknown)
                 return false;
-            count = LinesCount;
+            count = LinesCount_;
             return true;
         }
         void SetLinesCount(ui64 count) {
-            Y_DEBUG_ABORT_UNLESS(LinesCount == Unknown || count == LinesCount, "Set another value of count lines");
-            if (LinesCount == Unknown) {
-                LinesCount = count;
+            Y_DEBUG_ABORT_UNLESS(LinesCount_ == Unknown || count == LinesCount_, "Set another value of count lines");
+            if (LinesCount_ == Unknown) {
+                LinesCount_ = count;
             }
         }
 
         const TString& GetFilePath() const {
-            return FilePath;
+            return FilePath_;
         }
 
     private:
         std::unique_ptr<TStream> DoCreateStream() {
             static const auto bufferSize = 1 << 12;
-            TFile file(FilePath, OpenExisting | RdOnly | Seq);
-            if (FileSize == Unknown) {
-                FileSize = file.GetLength();
+            TFile file(FilePath_, OpenExisting | RdOnly | Seq);
+            if (FileSize_ == Unknown) {
+                FileSize_ = file.GetLength();
             }
             return std::make_unique<TBuffered<TUnbufferedFileInput>>(bufferSize, file);
         }
 
-        TString FilePath;
+        TString FilePath_;
         static const ui64 Unknown = -1;
-        ui64 FileSize = Unknown;
-        ui64 LinesCount = Unknown;
-        std::unique_ptr<TStream> Cached;
+        ui64 FileSize_ = Unknown;
+        ui64 LinesCount_ = Unknown;
+        std::unique_ptr<TStream> Cached_;
     };
 
     class TEmptyIter: public TBoxedValue {
@@ -229,102 +229,102 @@ namespace {
 
     public:
         TEmptyIter(TTerminateFunc terminateFunc)
-            : TerminateFunc(terminateFunc)
+            : TerminateFunc_(terminateFunc)
         {
         }
 
     private:
-        const TTerminateFunc TerminateFunc;
+        const TTerminateFunc TerminateFunc_;
     };
 
     template <class TUserType>
     class TLineByLineBoxedValueIterator: public TBoxedValue {
     public:
         TLineByLineBoxedValueIterator(TStreamMeta::TPtr metaPtr, std::unique_ptr<TStreamMeta::TStream>&& stream, const IValueBuilder& valueBuilder, TTerminateFunc terminateFunc)
-            : MetaPtr(metaPtr)
-            , ValueBuilder(valueBuilder)
-            , Stream(std::move(stream))
-            , Splitter(*Stream)
-            , TerminateFunc(terminateFunc)
+            : MetaPtr_(metaPtr)
+            , ValueBuilder_(valueBuilder)
+            , Stream_(std::move(stream))
+            , Splitter_(*Stream_)
+            , TerminateFunc_(terminateFunc)
         {
         }
 
         void SetLimit(ui64 limit = TAKE_UNLIM) {
-            Limit = limit;
+            Limit_ = limit;
         }
 
     private:
         bool SkipLimit() {
-            if (Limit != TAKE_UNLIM) {
-                if (Limit == 0) {
+            if (Limit_ != TAKE_UNLIM) {
+                if (Limit_ == 0) {
                     return false;
                 }
-                --Limit;
+                --Limit_;
             }
             return true;
         }
 
         bool Skip() final {
-            ++CurLineNum;
-            return Splitter.Next(CurLine) && SkipLimit();
+            ++CurLineNum_;
+            return Splitter_.Next(CurLine_) && SkipLimit();
         }
 
         bool Next(TUnboxedValue& value) override {
             if (!Skip()) {
                 return false;
             }
-            if (!Helper::ConvertToUnboxed<TUserType>(ValueBuilder, CurLine, value)) {
+            if (!Helper::ConvertToUnboxed<TUserType>(ValueBuilder_, CurLine_, value)) {
                 TStringBuilder sb;
-                sb << "File::ByLines failed to cast string '" << CurLine << "' to " << Helper::TypeToTypeName<TUserType>::Name() << Endl;
-                sb << "- path: " << MetaPtr->GetFilePath() << Endl;
-                sb << "- line: " << CurLineNum << Endl;
-                TerminateFunc(sb);
+                sb << "File::ByLines failed to cast string '" << CurLine_ << "' to " << Helper::TypeToTypeName<TUserType>::Name() << Endl;
+                sb << "- path: " << MetaPtr_->GetFilePath() << Endl;
+                sb << "- line: " << CurLineNum_ << Endl;
+                TerminateFunc_(sb);
                 Y_ABORT("Terminate unstoppable!");
             }
             return true;
         }
 
-        TStreamMeta::TPtr MetaPtr;
-        const IValueBuilder& ValueBuilder;
+        TStreamMeta::TPtr MetaPtr_;
+        const IValueBuilder& ValueBuilder_;
 
-        std::unique_ptr<TStreamMeta::TStream> Stream;
-        TLineSplitter Splitter;
-        TTerminateFunc TerminateFunc;
-        TString CurLine;
-        ui64 CurLineNum = 0;
-        ui64 Limit = TAKE_UNLIM;
-        TUnboxedValue Result;
+        std::unique_ptr<TStreamMeta::TStream> Stream_;
+        TLineSplitter Splitter_;
+        TTerminateFunc TerminateFunc_;
+        TString CurLine_;
+        ui64 CurLineNum_ = 0;
+        ui64 Limit_ = TAKE_UNLIM;
+        TUnboxedValue Result_;
     };
 
     template <class TUserType>
     class TListByLineBoxedValue: public TBoxedValue {
     public:
         TListByLineBoxedValue(TStreamMeta::TPtr metaPtr, const IValueBuilder& valueBuilder, TTerminateFunc terminateFunc, ui64 skip = 0ULL, ui64 take = TAKE_UNLIM)
-            : MetaPtr(metaPtr)
-            , ValueBuilder(valueBuilder)
-            , TerminateFunc(terminateFunc)
-            , Skip(skip)
-            , Take(take)
+            : MetaPtr_(metaPtr)
+            , ValueBuilder_(valueBuilder)
+            , TerminateFunc_(terminateFunc)
+            , Skip_(skip)
+            , Take_(take)
         {}
     private:
         bool HasFastListLength() const override {
             ui64 tmp;
-            return MetaPtr->GetLinesCount(tmp);
+            return MetaPtr_->GetLinesCount(tmp);
         }
         ui64 GetListLength() const override {
             ui64 length;
-            if (!MetaPtr->GetLinesCount(length)) {
-                length = Skip;
+            if (!MetaPtr_->GetLinesCount(length)) {
+                length = Skip_;
                 for (const auto iter = GetListIterator(); iter.Skip(); ++length)
                     continue;
-                if (Take == TAKE_UNLIM) {
-                    MetaPtr->SetLinesCount(length);
+                if (Take_ == TAKE_UNLIM) {
+                    MetaPtr_->SetLinesCount(length);
                 }
             }
-            if (length <= Skip) {
+            if (length <= Skip_) {
                 return 0;
             }
-            return Min(length - Skip, Take);
+            return Min(length - Skip_, Take_);
         }
         ui64 GetEstimatedListLength() const override {
             /// \todo some optimisation?
@@ -333,35 +333,35 @@ namespace {
 
         TUnboxedValue GetListIterator() const override {
             try {
-                auto stream = MetaPtr->CreateStream(TerminateFunc);
-                IBoxedValuePtr iter(new TLineByLineBoxedValueIterator<TUserType>(MetaPtr, std::move(stream), ValueBuilder, TerminateFunc));
-                if (!Take || !SkipElements(*iter, Skip)) {
-                    return TUnboxedValuePod(new TEmptyIter(TerminateFunc));
+                auto stream = MetaPtr_->CreateStream(TerminateFunc_);
+                IBoxedValuePtr iter(new TLineByLineBoxedValueIterator<TUserType>(MetaPtr_, std::move(stream), ValueBuilder_, TerminateFunc_));
+                if (!Take_ || !SkipElements(*iter, Skip_)) {
+                    return TUnboxedValuePod(new TEmptyIter(TerminateFunc_));
                 }
-                static_cast<TLineByLineBoxedValueIterator<TUserType>*>(iter.Get())->SetLimit(Take);
+                static_cast<TLineByLineBoxedValueIterator<TUserType>*>(iter.Get())->SetLimit(Take_);
                 return TUnboxedValuePod(std::move(iter));
             } catch (const std::exception& e) {
-                TerminateFunc(CurrentExceptionMessage());
+                TerminateFunc_(CurrentExceptionMessage());
                 Y_ABORT("Terminate unstoppable!");
             }
         }
 
         IBoxedValuePtr SkipListImpl(const IValueBuilder& builder, ui64 count) const override {
-            return new TListByLineBoxedValue(MetaPtr, builder, TerminateFunc, Skip + count, Take == TAKE_UNLIM ? TAKE_UNLIM : Take - std::min(Take, count));
+            return new TListByLineBoxedValue(MetaPtr_, builder, TerminateFunc_, Skip_ + count, Take_ == TAKE_UNLIM ? TAKE_UNLIM : Take_ - std::min(Take_, count));
         }
         IBoxedValuePtr TakeListImpl(const IValueBuilder& builder, ui64 count) const override {
-            return new TListByLineBoxedValue(MetaPtr, builder, TerminateFunc, Skip, std::min(Take, count));
+            return new TListByLineBoxedValue(MetaPtr_, builder, TerminateFunc_, Skip_, std::min(Take_, count));
         }
 
         bool HasListItems() const override {
             return true;
         }
 
-        TStreamMeta::TPtr MetaPtr;
-        const IValueBuilder& ValueBuilder;
-        TTerminateFunc TerminateFunc;
-        ui64 Skip = 0ULL;
-        ui64 Take = TAKE_UNLIM;
+        TStreamMeta::TPtr MetaPtr_;
+        const IValueBuilder& ValueBuilder_;
+        TTerminateFunc TerminateFunc_;
+        ui64 Skip_ = 0ULL;
+        ui64 Take_ = TAKE_UNLIM;
     };
 
     template <class TUserType>
@@ -469,20 +469,20 @@ namespace {
             }
 
             bool HasFastListLength() const override {
-                return bool(Length);
+                return bool(Length_);
             }
 
             ui64 GetListLength() const override {
-                if (!Length) {
+                if (!Length_) {
                     ui64 length = 0ULL;
                     for (const auto it = GetListIterator(); it.Skip();) {
                         ++length;
                     }
 
-                    Length = length;
+                    Length_ = length;
                 }
 
-                return *Length;
+                return *Length_;
             }
 
             ui64 GetEstimatedListLength() const override {
@@ -490,18 +490,18 @@ namespace {
             }
 
             bool HasListItems() const override {
-                if (HasItems) {
-                    return *HasItems;
+                if (HasItems_) {
+                    return *HasItems_;
                 }
 
-                if (Length) {
-                    HasItems = (*Length != 0);
-                    return *HasItems;
+                if (Length_) {
+                    HasItems_ = (*Length_ != 0);
+                    return *HasItems_;
                 }
 
                 auto iter = GetListIterator();
-                HasItems = iter.Skip();
-                return *HasItems;
+                HasItems_ = iter.Skip();
+                return *HasItems_;
             }
 
         protected:
@@ -511,8 +511,8 @@ namespace {
             const IValueBuilder& ValueBuilder_;
             const TSourcePosition Pos_;
             const TString FilePath_;
-            mutable TMaybe<ui64> Length;
-            mutable TMaybe<bool> HasItems;
+            mutable TMaybe<ui64> Length_;
+            mutable TMaybe<bool> HasItems_;
         };
 
     public:
diff --git a/yql/essentials/udfs/common/histogram/histogram_udf.cpp b/yql/essentials/udfs/common/histogram/histogram_udf.cpp
index 3dcb2ca98ec..1242c60927f 100644
--- a/yql/essentials/udfs/common/histogram/histogram_udf.cpp
+++ b/yql/essentials/udfs/common/histogram/histogram_udf.cpp
@@ -51,19 +51,19 @@ namespace {
     public:
         TLinearHistogram(double step, double begin, double end)
             : TAdaptiveWardHistogram(1ULL << 24)
-            , Step(step)
-            , Begin(begin)
-            , End(end)
+            , Step_(step)
+            , Begin_(begin)
+            , End_(end)
         {
         }
 
         void Add(double value, double weight) override {
-            if (value < Begin) {
-                value = Begin;
-            } else if (value > End) {
-                value = End;
+            if (value < Begin_) {
+                value = Begin_;
+            } else if (value > End_) {
+                value = End_;
             } else {
-                value = std::floor(value / Step + 0.5) * Step;
+                value = std::floor(value / Step_ + 0.5) * Step_;
             }
             TAdaptiveWardHistogram::Add(value, weight);
         }
@@ -73,9 +73,9 @@ namespace {
         }
 
     protected:
-        double Step;
-        double Begin;
-        double End;
+        double Step_;
+        double Begin_;
+        double End_;
     };
 
     class TLogarithmicHistogram: public TLinearHistogram {
@@ -86,19 +86,19 @@ namespace {
         }
 
         void Add(double value, double weight) override {
-            double base = std::log(value) / std::log(Step);
-            double prev = std::pow(Step, std::floor(base));
-            double next = std::pow(Step, std::ceil(base));
+            double base = std::log(value) / std::log(Step_);
+            double prev = std::pow(Step_, std::floor(base));
+            double next = std::pow(Step_, std::ceil(base));
             if (std::abs(value - next) > std::abs(value - prev)) {
                 value = prev;
             } else {
                 value = next;
             }
 
-            if (value < Begin) {
-                value = Begin;
-            } else if (value > End) {
-                value = End;
+            if (value < Begin_) {
+                value = Begin_;
+            } else if (value > End_) {
+                value = End_;
             }
 
             if (!std::isnan(value)) {
@@ -398,7 +398,7 @@ namespace {
         typedef TBoxedResource<THistogramType, ResourceName> THistogramResource;
 
         THistogram_GetResult(const THistogramIndexes& histogramIndexes, TSourcePosition pos)
-            : HistogramIndexes(histogramIndexes)
+            : HistogramIndexes_(histogramIndexes)
             , Pos_(pos)
         {
         }
@@ -419,25 +419,25 @@ namespace {
 
             auto size = proto.FreqSize();
             TUnboxedValue* fields = nullptr;
-            auto result = valueBuilder->NewArray(HistogramIndexes.ResultFieldsCount, fields);
-            fields[HistogramIndexes.Kind] = valueBuilder->NewString(TStringBuf(ResourceName).Skip(10));
+            auto result = valueBuilder->NewArray(HistogramIndexes_.ResultFieldsCount, fields);
+            fields[HistogramIndexes_.Kind] = valueBuilder->NewString(TStringBuf(ResourceName).Skip(10));
             if (size) {
                 TUnboxedValue* items = nullptr;
-                fields[HistogramIndexes.Bins] = valueBuilder->NewArray(size, items);
-                fields[HistogramIndexes.Min] = TUnboxedValuePod(static_cast<double>(histogram->GetMinValue()));
-                fields[HistogramIndexes.Max] = TUnboxedValuePod(static_cast<double>(histogram->GetMaxValue()));
-                fields[HistogramIndexes.WeightsSum] = TUnboxedValuePod(static_cast<double>(histogram->GetSum()));
+                fields[HistogramIndexes_.Bins] = valueBuilder->NewArray(size, items);
+                fields[HistogramIndexes_.Min] = TUnboxedValuePod(static_cast<double>(histogram->GetMinValue()));
+                fields[HistogramIndexes_.Max] = TUnboxedValuePod(static_cast<double>(histogram->GetMaxValue()));
+                fields[HistogramIndexes_.WeightsSum] = TUnboxedValuePod(static_cast<double>(histogram->GetSum()));
                 for (ui64 i = 0; i < size; ++i) {
                     TUnboxedValue* binFields = nullptr;
-                    *items++ = valueBuilder->NewArray(HistogramIndexes.BinFieldsCount, binFields);
-                    binFields[HistogramIndexes.Frequency] = TUnboxedValuePod(static_cast<double>(proto.GetFreq(i)));
-                    binFields[HistogramIndexes.Position] = TUnboxedValuePod(static_cast<double>(proto.GetPosition(i)));
+                    *items++ = valueBuilder->NewArray(HistogramIndexes_.BinFieldsCount, binFields);
+                    binFields[HistogramIndexes_.Frequency] = TUnboxedValuePod(static_cast<double>(proto.GetFreq(i)));
+                    binFields[HistogramIndexes_.Position] = TUnboxedValuePod(static_cast<double>(proto.GetPosition(i)));
                 }
             } else {
-                fields[HistogramIndexes.Bins] = valueBuilder->NewEmptyList();
-                fields[HistogramIndexes.Min] = TUnboxedValuePod(0.0);
-                fields[HistogramIndexes.Max] = TUnboxedValuePod(0.0);
-                fields[HistogramIndexes.WeightsSum] = TUnboxedValuePod(0.0);
+                fields[HistogramIndexes_.Bins] = valueBuilder->NewEmptyList();
+                fields[HistogramIndexes_.Min] = TUnboxedValuePod(0.0);
+                fields[HistogramIndexes_.Max] = TUnboxedValuePod(0.0);
+                fields[HistogramIndexes_.WeightsSum] = TUnboxedValuePod(0.0);
             }
 
             return result;
@@ -467,7 +467,7 @@ namespace {
         }
 
     private:
-        const THistogramIndexes HistogramIndexes;
+        const THistogramIndexes HistogramIndexes_;
         TSourcePosition Pos_;
     };
 
@@ -614,7 +614,7 @@ namespace {
     class THistogramPrint: public TBoxedValue {
     public:
         THistogramPrint(const THistogramIndexes& histogramIndexes)
-            : HistogramIndexes(histogramIndexes)
+            : HistogramIndexes_(histogramIndexes)
         {
         }
 
@@ -626,11 +626,11 @@ namespace {
         TUnboxedValue Run(
             const IValueBuilder* valueBuilder,
             const TUnboxedValuePod* args) const override {
-            auto kind = args[0].GetElement(HistogramIndexes.Kind);
-            auto bins = args[0].GetElement(HistogramIndexes.Bins);
-            double min = args[0].GetElement(HistogramIndexes.Min).Get<double>();
-            double max = args[0].GetElement(HistogramIndexes.Max).Get<double>();
-            double weightsSum = args[0].GetElement(HistogramIndexes.WeightsSum).Get<double>();
+            auto kind = args[0].GetElement(HistogramIndexes_.Kind);
+            auto bins = args[0].GetElement(HistogramIndexes_.Bins);
+            double min = args[0].GetElement(HistogramIndexes_.Min).Get<double>();
+            double max = args[0].GetElement(HistogramIndexes_.Max).Get<double>();
+            double weightsSum = args[0].GetElement(HistogramIndexes_.WeightsSum).Get<double>();
             auto binsIterator = bins.GetListIterator();
 
             TStringBuilder result;
@@ -644,13 +644,13 @@ namespace {
 
             for (TUnboxedValue current; binsIterator.Next(current);) {
                 if (bars) {
-                    double frequency = current.GetElement(HistogramIndexes.Frequency).Get<double>();
+                    double frequency = current.GetElement(HistogramIndexes_.Frequency).Get<double>();
                     if (frequency > maxFrequency) {
                         maxFrequency = frequency;
                     }
                 }
-                size_t positionLength = Sprintf("%.3f", current.GetElement(HistogramIndexes.Position).Get<double>()).length();
-                size_t frequencyLength = Sprintf("%.3f", current.GetElement(HistogramIndexes.Frequency).Get<double>()).length();
+                size_t positionLength = Sprintf("%.3f", current.GetElement(HistogramIndexes_.Position).Get<double>()).length();
+                size_t frequencyLength = Sprintf("%.3f", current.GetElement(HistogramIndexes_.Frequency).Get<double>()).length();
 
                 if (positionLength > maxPositionLength) {
                     maxPositionLength = positionLength;
@@ -662,8 +662,8 @@ namespace {
 
             binsIterator = bins.GetListIterator();
             for (TUnboxedValue current; binsIterator.Next(current);) {
-                double position = current.GetElement(HistogramIndexes.Position).Get<double>();
-                double frequency = current.GetElement(HistogramIndexes.Frequency).Get<double>();
+                double position = current.GetElement(HistogramIndexes_.Position).Get<double>();
+                double frequency = current.GetElement(HistogramIndexes_.Frequency).Get<double>();
                 result << "\n";
                 if (bars && maxFrequency > 0) {
                     ui8 filledBars = static_cast<ui8>(bars * frequency / maxFrequency);
@@ -705,13 +705,13 @@ namespace {
         }
 
     private:
-        const THistogramIndexes HistogramIndexes;
+        const THistogramIndexes HistogramIndexes_;
     };
 
     class THistogramToCumulativeDistributionFunction: public TBoxedValue {
     public:
         THistogramToCumulativeDistributionFunction(const THistogramIndexes& histogramIndexes)
-            : HistogramIndexes(histogramIndexes)
+            : HistogramIndexes_(histogramIndexes)
         {
         }
 
@@ -724,10 +724,10 @@ namespace {
             const IValueBuilder* valueBuilder,
             const TUnboxedValuePod* args) const override {
             TUnboxedValue* fields = nullptr;
-            auto result = valueBuilder->NewArray(HistogramIndexes.ResultFieldsCount, fields);
-            auto bins = args[0].GetElement(HistogramIndexes.Bins);
-            double minValue = args[0].GetElement(HistogramIndexes.Min).Get<double>();
-            double maxValue = args[0].GetElement(HistogramIndexes.Max).Get<double>();
+            auto result = valueBuilder->NewArray(HistogramIndexes_.ResultFieldsCount, fields);
+            auto bins = args[0].GetElement(HistogramIndexes_.Bins);
+            double minValue = args[0].GetElement(HistogramIndexes_.Min).Get<double>();
+            double maxValue = args[0].GetElement(HistogramIndexes_.Max).Get<double>();
             double sum = 0.0;
             double weightsSum = 0.0;
             std::vector<TUnboxedValue> resultBins;
@@ -736,21 +736,21 @@ namespace {
             const auto binsIterator = bins.GetListIterator();
             for (TUnboxedValue current; binsIterator.Next(current);) {
                 TUnboxedValue* binFields = nullptr;
-                auto resultCurrent = valueBuilder->NewArray(HistogramIndexes.BinFieldsCount, binFields);
-                const auto frequency = current.GetElement(HistogramIndexes.Frequency).Get<double>();
+                auto resultCurrent = valueBuilder->NewArray(HistogramIndexes_.BinFieldsCount, binFields);
+                const auto frequency = current.GetElement(HistogramIndexes_.Frequency).Get<double>();
                 sum += frequency;
                 weightsSum += sum;
-                binFields[HistogramIndexes.Frequency] = TUnboxedValuePod(sum);
-                binFields[HistogramIndexes.Position] = current.GetElement(HistogramIndexes.Position);
+                binFields[HistogramIndexes_.Frequency] = TUnboxedValuePod(sum);
+                binFields[HistogramIndexes_.Position] = current.GetElement(HistogramIndexes_.Position);
                 resultBins.emplace_back(std::move(resultCurrent));
             }
 
-            auto kind = args[0].GetElement(HistogramIndexes.Kind);
-            fields[HistogramIndexes.Kind] = valueBuilder->AppendString(kind, "Cdf");
-            fields[HistogramIndexes.Bins] = valueBuilder->NewList(resultBins.data(), resultBins.size());
-            fields[HistogramIndexes.Max] = TUnboxedValuePod(maxValue);
-            fields[HistogramIndexes.Min] = TUnboxedValuePod(minValue);
-            fields[HistogramIndexes.WeightsSum] = TUnboxedValuePod(weightsSum);
+            auto kind = args[0].GetElement(HistogramIndexes_.Kind);
+            fields[HistogramIndexes_.Kind] = valueBuilder->AppendString(kind, "Cdf");
+            fields[HistogramIndexes_.Bins] = valueBuilder->NewList(resultBins.data(), resultBins.size());
+            fields[HistogramIndexes_.Max] = TUnboxedValuePod(maxValue);
+            fields[HistogramIndexes_.Min] = TUnboxedValuePod(minValue);
+            fields[HistogramIndexes_.WeightsSum] = TUnboxedValuePod(weightsSum);
             return result;
         }
 
@@ -776,13 +776,13 @@ namespace {
         }
 
     private:
-        const THistogramIndexes HistogramIndexes;
+        const THistogramIndexes HistogramIndexes_;
     };
 
     class THistogramNormalize: public TBoxedValue {
     public:
         THistogramNormalize(const THistogramIndexes& histogramIndexes)
-            : HistogramIndexes(histogramIndexes)
+            : HistogramIndexes_(histogramIndexes)
         {
         }
 
@@ -795,10 +795,10 @@ namespace {
             const IValueBuilder* valueBuilder,
             const TUnboxedValuePod* args) const override {
             TUnboxedValue* fields = nullptr;
-            auto result = valueBuilder->NewArray(HistogramIndexes.ResultFieldsCount, fields);
-            auto bins = args[0].GetElement(HistogramIndexes.Bins);
-            double minValue = args[0].GetElement(HistogramIndexes.Min).Get<double>();
-            double maxValue = args[0].GetElement(HistogramIndexes.Max).Get<double>();
+            auto result = valueBuilder->NewArray(HistogramIndexes_.ResultFieldsCount, fields);
+            auto bins = args[0].GetElement(HistogramIndexes_.Bins);
+            double minValue = args[0].GetElement(HistogramIndexes_.Min).Get<double>();
+            double maxValue = args[0].GetElement(HistogramIndexes_.Max).Get<double>();
             double area = args[1].GetOrDefault<double>(100.0);
             bool cdfNormalization = args[2].GetOrDefault<bool>(false);
             double sum = 0.0;
@@ -809,35 +809,35 @@ namespace {
                 resultBins.reserve(bins.GetListLength());
             auto binsIterator = bins.GetListIterator();
             for (TUnboxedValue current; binsIterator.Next(current);) {
-                sum += current.GetElement(HistogramIndexes.Frequency).Get<double>();
-                lastBinFrequency = current.GetElement(HistogramIndexes.Frequency).Get<double>();
+                sum += current.GetElement(HistogramIndexes_.Frequency).Get<double>();
+                lastBinFrequency = current.GetElement(HistogramIndexes_.Frequency).Get<double>();
             }
             binsIterator = bins.GetListIterator();
             for (TUnboxedValue current; binsIterator.Next(current);) {
                 TUnboxedValue* binFields = nullptr;
-                auto resultCurrent = valueBuilder->NewArray(HistogramIndexes.BinFieldsCount, binFields);
-                double frequency = current.GetElement(HistogramIndexes.Frequency).Get<double>();
+                auto resultCurrent = valueBuilder->NewArray(HistogramIndexes_.BinFieldsCount, binFields);
+                double frequency = current.GetElement(HistogramIndexes_.Frequency).Get<double>();
                 if (cdfNormalization) {
                     frequency = area * frequency / lastBinFrequency;
                 } else {
                     frequency = area * frequency / sum;
                 }
                 weightsSum += frequency;
-                binFields[HistogramIndexes.Frequency] = TUnboxedValuePod(frequency);
-                binFields[HistogramIndexes.Position] = current.GetElement(HistogramIndexes.Position);
+                binFields[HistogramIndexes_.Frequency] = TUnboxedValuePod(frequency);
+                binFields[HistogramIndexes_.Position] = current.GetElement(HistogramIndexes_.Position);
                 resultBins.emplace_back(std::move(resultCurrent));
             }
 
-            TUnboxedValue kind = args[0].GetElement(HistogramIndexes.Kind);
+            TUnboxedValue kind = args[0].GetElement(HistogramIndexes_.Kind);
             if (cdfNormalization) {
                 kind = valueBuilder->AppendString(kind, "Cdf");
             }
 
-            fields[HistogramIndexes.Kind] = kind;
-            fields[HistogramIndexes.Bins] = valueBuilder->NewList(resultBins.data(), resultBins.size());
-            fields[HistogramIndexes.Max] = TUnboxedValuePod(maxValue);
-            fields[HistogramIndexes.Min] = TUnboxedValuePod(minValue);
-            fields[HistogramIndexes.WeightsSum] = TUnboxedValuePod(weightsSum);
+            fields[HistogramIndexes_.Kind] = kind;
+            fields[HistogramIndexes_.Bins] = valueBuilder->NewList(resultBins.data(), resultBins.size());
+            fields[HistogramIndexes_.Max] = TUnboxedValuePod(maxValue);
+            fields[HistogramIndexes_.Min] = TUnboxedValuePod(minValue);
+            fields[HistogramIndexes_.WeightsSum] = TUnboxedValuePod(weightsSum);
             return result;
         }
 
@@ -865,14 +865,14 @@ namespace {
         }
 
     private:
-        const THistogramIndexes HistogramIndexes;
+        const THistogramIndexes HistogramIndexes_;
     };
 
     template <bool twoArgs>
     class THistogramMethodBase: public TBoxedValue {
     public:
         THistogramMethodBase(const THistogramIndexes& histogramIndexes, TSourcePosition pos)
-            : HistogramIndexes(histogramIndexes)
+            : HistogramIndexes_(histogramIndexes)
             , Pos_(pos)
         {
         }
@@ -885,9 +885,9 @@ namespace {
             const IValueBuilder*,
             const TUnboxedValuePod* args) const override {
             try {
-                auto bins = args[0].GetElement(HistogramIndexes.Bins);
-                double min = args[0].GetElement(HistogramIndexes.Min).template Get<double>();
-                double max = args[0].GetElement(HistogramIndexes.Max).template Get<double>();
+                auto bins = args[0].GetElement(HistogramIndexes_.Bins);
+                double min = args[0].GetElement(HistogramIndexes_.Min).template Get<double>();
+                double max = args[0].GetElement(HistogramIndexes_.Max).template Get<double>();
                 auto binsIterator = bins.GetListIterator();
 
                 THistogram histogram;
@@ -895,8 +895,8 @@ namespace {
                 histogram.SetMinValue(min);
                 histogram.SetMaxValue(max);
                 for (TUnboxedValue current; binsIterator.Next(current);) {
-                    double frequency = current.GetElement(HistogramIndexes.Frequency).template Get<double>();
-                    double position = current.GetElement(HistogramIndexes.Position).template Get<double>();
+                    double frequency = current.GetElement(HistogramIndexes_.Frequency).template Get<double>();
+                    double position = current.GetElement(HistogramIndexes_.Position).template Get<double>();
                     histogram.AddFreq(frequency);
                     histogram.AddPosition(position);
                 }
@@ -919,7 +919,7 @@ namespace {
         }
 
     protected:
-        const THistogramIndexes HistogramIndexes;
+        const THistogramIndexes HistogramIndexes_;
         TSourcePosition Pos_;
     };
 
diff --git a/yql/essentials/udfs/common/hyperloglog/hyperloglog_udf.cpp b/yql/essentials/udfs/common/hyperloglog/hyperloglog_udf.cpp
index 348fd69b9dc..744c25feac6 100644
--- a/yql/essentials/udfs/common/hyperloglog/hyperloglog_udf.cpp
+++ b/yql/essentials/udfs/common/hyperloglog/hyperloglog_udf.cpp
@@ -16,11 +16,11 @@ namespace {
         using THybridHll = THyperLogLogWithAlloc<TStdAllocatorForUdf<ui8>>;
 
         explicit THybridHyperLogLog(unsigned precision)
-            : Var(THybridSet()), SizeLimit((1u << precision) / 8), Precision(precision)
+            : Var_(THybridSet()), SizeLimit_((1u << precision) / 8), Precision_(precision)
         { }
 
         THybridHll ConvertToHyperLogLog() const {
-            auto res = THybridHll::Create(Precision);
+            auto res = THybridHll::Create(Precision_);
             for (auto& el : GetSetRef()) {
                 res.Update(el);
             }
@@ -28,23 +28,23 @@ namespace {
         }
 
         bool IsSet() const {
-            return Var.index() == 1;
+            return Var_.index() == 1;
         }
 
         const THybridSet& GetSetRef() const {
-            return std::get<1>(Var);
+            return std::get<1>(Var_);
         }
 
         THybridSet& GetMutableSetRef() {
-            return std::get<1>(Var);
+            return std::get<1>(Var_);
         }
 
         const THybridHll& GetHllRef() const {
-            return std::get<0>(Var);
+            return std::get<0>(Var_);
         }
 
         THybridHll& GetMutableHllRef() {
-            return std::get<0>(Var);
+            return std::get<0>(Var_);
         }
 
     public:
@@ -55,8 +55,8 @@ namespace {
         void Update(ui64 hash) {
             if (IsSet()) {
                 GetMutableSetRef().insert(hash);
-                if (GetSetRef().size() >= SizeLimit) {
-                    Var = ConvertToHyperLogLog();
+                if (GetSetRef().size() >= SizeLimit_) {
+                    Var_ = ConvertToHyperLogLog();
                 }
             } else {
                 GetMutableHllRef().Update(hash);
@@ -66,12 +66,12 @@ namespace {
         void Merge(const THybridHyperLogLog& rh) {
             if (IsSet() && rh.IsSet()) {
                 GetMutableSetRef().insert(rh.GetSetRef().begin(), rh.GetSetRef().end());
-                if (GetSetRef().size() >= SizeLimit) {
-                    Var = ConvertToHyperLogLog();
+                if (GetSetRef().size() >= SizeLimit_) {
+                    Var_ = ConvertToHyperLogLog();
                 }
             } else {
                 if (IsSet()) {
-                    Var = ConvertToHyperLogLog();
+                    Var_ = ConvertToHyperLogLog();
                 }
                 if (rh.IsSet()) {
                     GetMutableHllRef().Merge(rh.ConvertToHyperLogLog());
@@ -82,8 +82,8 @@ namespace {
         }
 
         void Save(IOutputStream& out) const {
-            out.Write(static_cast<char>(Var.index()));
-            out.Write(static_cast<char>(Precision));
+            out.Write(static_cast<char>(Var_.index()));
+            out.Write(static_cast<char>(Precision_));
             if (IsSet()) {
                 ::Save(&out, GetSetRef());
             } else {
@@ -112,26 +112,26 @@ namespace {
             if (type) {
                 ::Load(&in, res.GetMutableSetRef());
             } else {
-                res.Var = THybridHll::Load(in);
+                res.Var_ = THybridHll::Load(in);
             }
             return res;
         }
 
     private:
-        std::variant<THybridHll, THybridSet> Var;
+        std::variant<THybridHll, THybridSet> Var_;
 
-        size_t SizeLimit;
+        size_t SizeLimit_;
 
-        unsigned Precision;
+        unsigned Precision_;
     };
 
     extern const char HyperLogLogResourceName[] = "HyperLogLog.State";
 
     using THyperLogLogResource = TBoxedResource<THybridHyperLogLog, HyperLogLogResourceName>;
 
-    class THyperLogLog_Create: public TBoxedValue {
+    class THyperLogLogCreate: public TBoxedValue {
     public:
-        THyperLogLog_Create(TSourcePosition pos)
+        THyperLogLogCreate(TSourcePosition pos)
             : Pos_(pos)
         {}
 
@@ -163,7 +163,7 @@ namespace {
             if (Name() == name) {
                 builder.SimpleSignature<TResource<HyperLogLogResourceName>(ui64, ui32)>();
                 if (!typesOnly) {
-                    builder.Implementation(new THyperLogLog_Create(builder.GetSourcePosition()));
+                    builder.Implementation(new THyperLogLogCreate(builder.GetSourcePosition()));
                 }
                 return true;
             } else {
@@ -175,9 +175,9 @@ namespace {
         TSourcePosition Pos_;
     };
 
-    class THyperLogLog_AddValue: public TBoxedValue {
+    class THyperLogLogAddValue: public TBoxedValue {
     public:
-        THyperLogLog_AddValue(TSourcePosition pos)
+        THyperLogLogAddValue(TSourcePosition pos)
             : Pos_(pos)
         {}
 
@@ -210,7 +210,7 @@ namespace {
             if (Name() == name) {
                 builder.SimpleSignature<TResource<HyperLogLogResourceName>(TResource<HyperLogLogResourceName>, ui64)>();
                 if (!typesOnly) {
-                    builder.Implementation(new THyperLogLog_AddValue(builder.GetSourcePosition()));
+                    builder.Implementation(new THyperLogLogAddValue(builder.GetSourcePosition()));
                 }
                 builder.IsStrict();
                 return true;
@@ -223,9 +223,9 @@ namespace {
         TSourcePosition Pos_;
     };
 
-    class THyperLogLog_Serialize: public TBoxedValue {
+    class THyperLogLogSerialize: public TBoxedValue {
     public:
-        THyperLogLog_Serialize(TSourcePosition pos)
+        THyperLogLogSerialize(TSourcePosition pos)
             : Pos_(pos)
         {}
 
@@ -258,7 +258,7 @@ namespace {
             if (Name() == name) {
                 builder.SimpleSignature<char*(TResource<HyperLogLogResourceName>)>();
                 if (!typesOnly) {
-                    builder.Implementation(new THyperLogLog_Serialize(builder.GetSourcePosition()));
+                    builder.Implementation(new THyperLogLogSerialize(builder.GetSourcePosition()));
                 }
                 return true;
             } else {
@@ -270,9 +270,9 @@ namespace {
         TSourcePosition Pos_;
     };
 
-    class THyperLogLog_Deserialize: public TBoxedValue {
+    class THyperLogLogDeserialize: public TBoxedValue {
     public:
-        THyperLogLog_Deserialize(TSourcePosition pos)
+        THyperLogLogDeserialize(TSourcePosition pos)
             : Pos_(pos)
         {}
 
@@ -306,7 +306,7 @@ namespace {
             if (Name() == name) {
                 builder.SimpleSignature<TResource<HyperLogLogResourceName>(char*)>();
                 if (!typesOnly) {
-                    builder.Implementation(new THyperLogLog_Deserialize(builder.GetSourcePosition()));
+                    builder.Implementation(new THyperLogLogDeserialize(builder.GetSourcePosition()));
                 }
                 return true;
             } else {
@@ -318,9 +318,9 @@ namespace {
         TSourcePosition Pos_;
     };
 
-    class THyperLogLog_Merge: public TBoxedValue {
+    class THyperLogLogMerge: public TBoxedValue {
     public:
-        THyperLogLog_Merge(TSourcePosition pos)
+        THyperLogLogMerge(TSourcePosition pos)
             : Pos_(pos)
         {}
 
@@ -353,7 +353,7 @@ namespace {
             if (Name() == name) {
                 builder.SimpleSignature<TResource<HyperLogLogResourceName>(TResource<HyperLogLogResourceName>, TResource<HyperLogLogResourceName>)>();
                 if (!typesOnly) {
-                    builder.Implementation(new THyperLogLog_Merge(builder.GetSourcePosition()));
+                    builder.Implementation(new THyperLogLogMerge(builder.GetSourcePosition()));
                 }
                 builder.IsStrict();
                 return true;
@@ -366,9 +366,9 @@ namespace {
         TSourcePosition Pos_;
     };
 
-    class THyperLogLog_GetResult: public TBoxedValue {
+    class THyperLogLogGetResult: public TBoxedValue {
     public:
-        THyperLogLog_GetResult(TSourcePosition pos)
+        THyperLogLogGetResult(TSourcePosition pos)
             : Pos_(pos)
         {}
 
@@ -398,7 +398,7 @@ namespace {
                 builder.Args()->Add(resource).Done().Returns<ui64>();
 
                 if (!typesOnly) {
-                    builder.Implementation(new THyperLogLog_GetResult(builder.GetSourcePosition()));
+                    builder.Implementation(new THyperLogLogGetResult(builder.GetSourcePosition()));
                 }
                 builder.IsStrict();
                 return true;
@@ -412,12 +412,12 @@ namespace {
     };
 
     SIMPLE_MODULE(THyperLogLogModule,
-                  THyperLogLog_Create,
-                  THyperLogLog_AddValue,
-                  THyperLogLog_Serialize,
-                  THyperLogLog_Deserialize,
-                  THyperLogLog_Merge,
-                  THyperLogLog_GetResult)
+                  THyperLogLogCreate,
+                  THyperLogLogAddValue,
+                  THyperLogLogSerialize,
+                  THyperLogLogDeserialize,
+                  THyperLogLogMerge,
+                  THyperLogLogGetResult)
 }
 
 REGISTER_MODULES(THyperLogLogModule)
diff --git a/yql/essentials/udfs/common/hyperscan/hyperscan_udf.cpp b/yql/essentials/udfs/common/hyperscan/hyperscan_udf.cpp
index 6559e4a8425..45c64e73a70 100644
--- a/yql/essentials/udfs/common/hyperscan/hyperscan_udf.cpp
+++ b/yql/essentials/udfs/common/hyperscan/hyperscan_udf.cpp
@@ -52,9 +52,9 @@ namespace {
                 THyperscanMatch::EMode mode,
                 size_t regexpsCount = 0)
                 : Pos_(pos)
-                , SurroundMode(surroundMode)
-                , Mode(mode)
-                , RegexpsCount(regexpsCount)
+                , SurroundMode_(surroundMode)
+                , Mode_(mode)
+                , RegexpsCount_(regexpsCount)
             {
             }
 
@@ -66,16 +66,16 @@ namespace {
                     new THyperscanMatch(
                         valueBuilder,
                         args[0],
-                        SurroundMode,
-                        Mode,
+                        SurroundMode_,
+                        Mode_,
                         Pos_,
-                        RegexpsCount));
+                        RegexpsCount_));
             }
 
             TSourcePosition Pos_;
-            bool SurroundMode;
-            THyperscanMatch::EMode Mode;
-            size_t RegexpsCount;
+            bool SurroundMode_;
+            THyperscanMatch::EMode Mode_;
+            size_t RegexpsCount_;
         };
 
         static const TStringRef& Name(bool isGrep, THyperscanMatch::EMode mode) {
@@ -116,14 +116,14 @@ namespace {
             TSourcePosition pos,
             size_t regexpsCount)
             : Regex_(runConfig.AsStringRef())
-            , Mode(mode)
+            , Mode_(mode)
             , Pos_(pos)
-            , RegexpsCount(regexpsCount)
+            , RegexpsCount_(regexpsCount)
         {
             try {
                 TOptions options = 0;
                 int pcreOptions = REG_EXTENDED;
-                if (Mode == THyperscanMatch::EMode::BACKTRACKING && Regex_.StartsWith(IGNORE_CASE_PREFIX)) {
+                if (Mode_ == THyperscanMatch::EMode::BACKTRACKING && Regex_.StartsWith(IGNORE_CASE_PREFIX)) {
                     pcreOptions |= REG_ICASE;
                 }
                 auto regex = Regex_;
@@ -142,7 +142,7 @@ namespace {
                         }
                         try {
                             Database_ = Compile(regex, options);
-                            Mode = THyperscanMatch::EMode::NORMAL;
+                            Mode_ = THyperscanMatch::EMode::NORMAL;
                         } catch (const TCompileException&) {
                             options |= HS_FLAG_PREFILTER;
                             Database_ = Compile(regex, options);
@@ -193,9 +193,9 @@ namespace {
             TUnboxedValue tuple;
             size_t i = 0;
 
-            if (Mode == THyperscanMatch::EMode::MULTI) {
-                tuple = valueBuilder->NewArray(RegexpsCount, items);
-                for (i = 0; i < RegexpsCount; ++i) {
+            if (Mode_ == THyperscanMatch::EMode::MULTI) {
+                tuple = valueBuilder->NewArray(RegexpsCount_, items);
+                for (i = 0; i < RegexpsCount_; ++i) {
                     items[i] = TUnboxedValuePod(false);
                 }
             }
@@ -205,7 +205,7 @@ namespace {
                 // <TRegExMatch::Match> expects ASCIIZ string. Explicitly copy
                 // the given argument string and append the NUL terminator to it.
                 const TString input(args[0].AsStringRef());
-                if (Y_UNLIKELY(Mode == THyperscanMatch::EMode::MULTI)) {
+                if (Y_UNLIKELY(Mode_ == THyperscanMatch::EMode::MULTI)) {
                     auto callback = [items] (TOptions id, ui64 /* from */, ui64 /* to */) {
                         items[id] = TUnboxedValuePod(true);
                     };
@@ -213,14 +213,14 @@ namespace {
                     return tuple;
                 } else {
                     bool matches = Matches(Database_, Scratch_, input);
-                    if (matches && Mode == THyperscanMatch::EMode::BACKTRACKING) {
+                    if (matches && Mode_ == THyperscanMatch::EMode::BACKTRACKING) {
                         matches = Fallback_.Match(input.data());
                     }
                     return TUnboxedValuePod(matches);
                 }
 
             } else {
-                return Mode == THyperscanMatch::EMode::MULTI ? tuple : TUnboxedValue(TUnboxedValuePod(false));
+                return Mode_ == THyperscanMatch::EMode::MULTI ? tuple : TUnboxedValue(TUnboxedValuePod(false));
             }
         } catch (const std::exception& e) {
             UdfTerminate((TStringBuilder() << Pos_ << " " << e.what()).data());
@@ -228,9 +228,9 @@ namespace {
 
     private:
         const TString Regex_;
-        THyperscanMatch::EMode Mode;
+        THyperscanMatch::EMode Mode_;
         const TSourcePosition Pos_;
-        const size_t RegexpsCount;
+        const size_t RegexpsCount_;
         TDatabase Database_;
         TScratch Scratch_;
         TRegExMatch Fallback_;
diff --git a/yql/essentials/udfs/common/ip_base/lib/ip_base_udf.h b/yql/essentials/udfs/common/ip_base/lib/ip_base_udf.h
index dfb9cc29c0c..3644207f8b3 100644
--- a/yql/essentials/udfs/common/ip_base/lib/ip_base_udf.h
+++ b/yql/essentials/udfs/common/ip_base/lib/ip_base_udf.h
@@ -27,7 +27,7 @@ namespace {
     }
 
     struct TRawIp4 {
-        ui8 a, b, c, d;
+        ui8 A, B, C, D;
 
         static TRawIp4 FromIpAddress(const TIpv6Address& addr) {
             ui128 x = addr;
@@ -46,39 +46,39 @@ namespace {
         }
 
         TIpv6Address ToIpAddress() const {
-            return {a, b, c, d};
+            return {A, B, C, D};
         }
 
         std::pair<TRawIp4, TRawIp4> ApplyMask(const TRawIp4& mask) const {
             return {{
-                    ui8(a & mask.a),
-                    ui8(b & mask.b),
-                    ui8(c & mask.c),
-                    ui8(d & mask.d)
+                    ui8(A & mask.A),
+                    ui8(B & mask.B),
+                    ui8(C & mask.C),
+                    ui8(D & mask.D)
                 },{
-                    ui8(a | ~mask.a),
-                    ui8(b | ~mask.b),
-                    ui8(c | ~mask.c),
-                    ui8(d | ~mask.d)
+                    ui8(A | ~mask.A),
+                    ui8(B | ~mask.B),
+                    ui8(C | ~mask.C),
+                    ui8(D | ~mask.D)
             }};
         }
     };
 
     struct TRawIp4Subnet {
-        TRawIp4 base, mask;
+        TRawIp4 Base, Mask;
 
         static TRawIp4Subnet FromIpRange(const TIpAddressRange& range) {
             return {TRawIp4::FromIpAddress(*range.Begin()), TRawIp4::MaskFromPrefix(GetAddressRangePrefix(range))};
         }
 
         TIpAddressRange ToIpRange() const {
-            auto range = base.ApplyMask(mask);
+            auto range = Base.ApplyMask(Mask);
             return {range.first.ToIpAddress(), range.second.ToIpAddress()};
         }
     };
 
     struct TRawIp6 {
-        ui8 a1, a0, b1, b0, c1, c0, d1, d0, e1, e0, f1, f0, g1, g0, h1, h0;
+        ui8 A1, A0, B1, B0, C1, C0, D1, D0, E1, E0, F1, F0, G1, G0, H1, H0;
 
         static TRawIp6 FromIpAddress(const TIpv6Address& addr) {
             ui128 x = addr;
@@ -100,65 +100,65 @@ namespace {
         }
 
         TIpv6Address ToIpAddress() const {
-            return {ui16(ui32(a1) << ui32(8) | ui32(a0)),
-               ui16(ui32(b1) << ui32(8) | ui32(b0)),
-               ui16(ui32(c1) << ui32(8) | ui32(c0)),
-               ui16(ui32(d1) << ui32(8) | ui32(d0)),
-               ui16(ui32(e1) << ui32(8) | ui32(e0)),
-               ui16(ui32(f1) << ui32(8) | ui32(f0)),
-               ui16(ui32(g1) << ui32(8) | ui32(g0)),
-               ui16(ui32(h1) << ui32(8) | ui32(h0)),
+            return {ui16(ui32(A1) << ui32(8) | ui32(A0)),
+               ui16(ui32(B1) << ui32(8) | ui32(B0)),
+               ui16(ui32(C1) << ui32(8) | ui32(C0)),
+               ui16(ui32(D1) << ui32(8) | ui32(D0)),
+               ui16(ui32(E1) << ui32(8) | ui32(E0)),
+               ui16(ui32(F1) << ui32(8) | ui32(F0)),
+               ui16(ui32(G1) << ui32(8) | ui32(G0)),
+               ui16(ui32(H1) << ui32(8) | ui32(H0)),
             };
         }
 
         std::pair<TRawIp6, TRawIp6> ApplyMask(const TRawIp6& mask) const {
             return { {
-                    ui8(a1 & mask.a1),
-                    ui8(a0 & mask.a0),
-                    ui8(b1 & mask.b1),
-                    ui8(b0 & mask.b0),
-                    ui8(c1 & mask.c1),
-                    ui8(c0 & mask.c0),
-                    ui8(d1 & mask.d1),
-                    ui8(d0 & mask.d0),
-                    ui8(e1 & mask.e1),
-                    ui8(e0 & mask.e0),
-                    ui8(f1 & mask.f1),
-                    ui8(f0 & mask.f0),
-                    ui8(g1 & mask.g1),
-                    ui8(g0 & mask.g0),
-                    ui8(h1 & mask.h1),
-                    ui8(h0 & mask.h0)
+                    ui8(A1 & mask.A1),
+                    ui8(A0 & mask.A0),
+                    ui8(B1 & mask.B1),
+                    ui8(B0 & mask.B0),
+                    ui8(C1 & mask.C1),
+                    ui8(C0 & mask.C0),
+                    ui8(D1 & mask.D1),
+                    ui8(D0 & mask.D0),
+                    ui8(E1 & mask.E1),
+                    ui8(E0 & mask.E0),
+                    ui8(F1 & mask.F1),
+                    ui8(F0 & mask.F0),
+                    ui8(G1 & mask.G1),
+                    ui8(G0 & mask.G0),
+                    ui8(H1 & mask.H1),
+                    ui8(H0 & mask.H0)
                 }, {
-                    ui8(a1 | ~mask.a1),
-                    ui8(a0 | ~mask.a0),
-                    ui8(b1 | ~mask.b1),
-                    ui8(b0 | ~mask.b0),
-                    ui8(c1 | ~mask.c1),
-                    ui8(c0 | ~mask.c0),
-                    ui8(d1 | ~mask.d1),
-                    ui8(d0 | ~mask.d0),
-                    ui8(e1 | ~mask.e1),
-                    ui8(e0 | ~mask.e0),
-                    ui8(f1 | ~mask.f1),
-                    ui8(f0 | ~mask.f0),
-                    ui8(g1 | ~mask.g1),
-                    ui8(g0 | ~mask.g0),
-                    ui8(h1 | ~mask.h1),
-                    ui8(h0 | ~mask.h0)
+                    ui8(A1 | ~mask.A1),
+                    ui8(A0 | ~mask.A0),
+                    ui8(B1 | ~mask.B1),
+                    ui8(B0 | ~mask.B0),
+                    ui8(C1 | ~mask.C1),
+                    ui8(C0 | ~mask.C0),
+                    ui8(D1 | ~mask.D1),
+                    ui8(D0 | ~mask.D0),
+                    ui8(E1 | ~mask.E1),
+                    ui8(E0 | ~mask.E0),
+                    ui8(F1 | ~mask.F1),
+                    ui8(F0 | ~mask.F0),
+                    ui8(G1 | ~mask.G1),
+                    ui8(G0 | ~mask.G0),
+                    ui8(H1 | ~mask.H1),
+                    ui8(H0 | ~mask.H0)
             }};
         }
     };
 
     struct TRawIp6Subnet {
-        TRawIp6 base, mask;
+        TRawIp6 Base, Mask;
 
         static TRawIp6Subnet FromIpRange(const TIpAddressRange& range) {
             return {TRawIp6::FromIpAddress(*range.Begin()), TRawIp6::MaskFromPrefix(GetAddressRangePrefix(range))};
         }
 
         TIpAddressRange ToIpRange() const {
-            auto range = base.ApplyMask(mask);
+            auto range = Base.ApplyMask(Mask);
             return {range.first.ToIpAddress(), range.second.ToIpAddress()};
         }
     };
diff --git a/yql/essentials/udfs/common/json2/as_json_node.h b/yql/essentials/udfs/common/json2/as_json_node.h
index c7463fffa66..12937f4351a 100644
--- a/yql/essentials/udfs/common/json2/as_json_node.h
+++ b/yql/essentials/udfs/common/json2/as_json_node.h
@@ -49,7 +49,7 @@ namespace NJson2Udf {
         }
 
     private:
-        const size_t MaxParseErrors = 10;
+        const size_t MaxParseErrors_ = 10;
 
         static TUnboxedValue Interpret(const TUnboxedValue& sourceValue, const IValueBuilder* valueBuilder);
 
diff --git a/yql/essentials/udfs/common/json2/compile_path.h b/yql/essentials/udfs/common/json2/compile_path.h
index 8239cfc1eee..3d7eba01cb5 100644
--- a/yql/essentials/udfs/common/json2/compile_path.h
+++ b/yql/essentials/udfs/common/json2/compile_path.h
@@ -45,7 +45,7 @@ namespace NJson2Udf {
         }
 
     private:
-        const size_t MaxParseErrors = 10;
+        const size_t MaxParseErrors_ = 10;
 
         TUnboxedValue Run(
             const IValueBuilder* valueBuilder,
@@ -53,7 +53,7 @@ namespace NJson2Udf {
             Y_UNUSED(valueBuilder);
             try {
                 TIssues issues;
-                const auto jsonPath = NJsonPath::ParseJsonPath(args[0].AsStringRef(), issues, MaxParseErrors);
+                const auto jsonPath = NJsonPath::ParseJsonPath(args[0].AsStringRef(), issues, MaxParseErrors_);
                 if (!issues.Empty()) {
                     ythrow yexception() << "Error parsing jsonpath:" << Endl << issues.ToString();
                 }
diff --git a/yql/essentials/udfs/common/math/lib/erfinv.cpp b/yql/essentials/udfs/common/math/lib/erfinv.cpp
index b762ec28070..def902860c3 100644
--- a/yql/essentials/udfs/common/math/lib/erfinv.cpp
+++ b/yql/essentials/udfs/common/math/lib/erfinv.cpp
@@ -5,7 +5,7 @@
 #include "erfinv.h"
 
 template <size_t N>
-static double polEval(double x, const std::array<double, N>& coef) {
+static double PolEval(double x, const std::array<double, N>& coef) {
     static_assert(N > 0, "Array coef[] should not be empty.");
     return std::accumulate(coef.crbegin() + 1, coef.crend(), coef[N - 1],
                            [x] (auto init, auto cur) {
@@ -97,14 +97,14 @@ double ErfInv(double x) {
     double ans;
     if (x <= 0.85) {
         double r = 0.180625 - 0.25 * x * x;
-        ans = x * polEval(r, a) / polEval(r, b);
+        ans = x * PolEval(r, a) / PolEval(r, b);
     } else {
         double r = std::sqrt(M_LN2 - log(1. - x)) - 1.6;
         if (r <= 3.4) {
-            ans = polEval(r, c) / polEval(r, d);
+            ans = PolEval(r, c) / PolEval(r, d);
         } else {
             r -= 3.4;
-            ans = polEval(r, e) / polEval(r, f);
+            ans = PolEval(r, e) / PolEval(r, f);
         }
     }
 
diff --git a/yql/essentials/udfs/common/pire/pire_udf.cpp b/yql/essentials/udfs/common/pire/pire_udf.cpp
index 0f9ffc5c213..b8a05b5d6dc 100644
--- a/yql/essentials/udfs/common/pire/pire_udf.cpp
+++ b/yql/essentials/udfs/common/pire/pire_udf.cpp
@@ -43,9 +43,9 @@ namespace {
                 TSourcePosition pos,
                 size_t regexpsCount = 0)
                 : TPireUdfBase(pos)
-                , SurroundMode(surroundMode)
-                , MultiMode(multiMode)
-                , RegexpsCount(regexpsCount)
+                , SurroundMode_(surroundMode)
+                , MultiMode_(multiMode)
+                , RegexpsCount_(regexpsCount)
             {
             }
 
@@ -57,15 +57,15 @@ namespace {
                     new TPireMatch(
                         valueBuilder,
                         args[0],
-                        SurroundMode,
-                        MultiMode,
+                        SurroundMode_,
+                        MultiMode_,
                         Pos_,
-                        RegexpsCount));
+                        RegexpsCount_));
             }
 
-            bool SurroundMode;
-            bool MultiMode;
-            size_t RegexpsCount;
+            bool SurroundMode_;
+            bool MultiMode_;
+            size_t RegexpsCount_;
         };
 
         static const TStringRef& Name(bool surroundMode, bool multiMode) {
@@ -88,9 +88,9 @@ namespace {
             TSourcePosition pos,
             size_t regexpsCount)
             : TPireUdfBase(pos)
-            , MultiMode(multiMode)
-            , RegexpsCount(regexpsCount)
-            , SurroundMode(surroundMode)
+            , MultiMode_(multiMode)
+            , RegexpsCount_(regexpsCount)
+            , SurroundMode_(surroundMode)
         {
             Y_UNUSED(valueBuilder);
             try {
@@ -128,10 +128,10 @@ namespace {
             TUnboxedValue tuple;
             size_t i = 0;
 
-            if (MultiMode) {
-                tuple = valueBuilder->NewArray(RegexpsCount, items);
+            if (MultiMode_) {
+                tuple = valueBuilder->NewArray(RegexpsCount_, items);
 
-                for (i = 0; i < RegexpsCount; ++i) {
+                for (i = 0; i < RegexpsCount_; ++i) {
                     items[i] = TUnboxedValuePod(false);
                 }
             }
@@ -139,8 +139,8 @@ namespace {
             if (args[0]) {
                 const auto input = args[0].AsStringRef();
                 TMatcher matcher(*Fsm_);
-                const bool isMatch = matcher.Match(input.Data(), input.Size(), SurroundMode, SurroundMode).Final();
-                if (MultiMode) {
+                const bool isMatch = matcher.Match(input.Data(), input.Size(), SurroundMode_, SurroundMode_).Final();
+                if (MultiMode_) {
                     if (isMatch) {
                         const auto& matchedRegexps = matcher.MatchedRegexps();
                         size_t matchesCount = matchedRegexps.second - matchedRegexps.first;
@@ -156,7 +156,7 @@ namespace {
                 }
 
             } else {
-                return MultiMode ? tuple : TUnboxedValue(TUnboxedValuePod(false));
+                return MultiMode_ ? tuple : TUnboxedValue(TUnboxedValuePod(false));
             }
         } catch (const std::exception& e) {
             UdfTerminate((TStringBuilder() << Pos_ << " " << e.what()).data());
@@ -164,9 +164,9 @@ namespace {
 
     private:
         TUniquePtr<TFsm> Fsm_;
-        bool MultiMode;
-        size_t RegexpsCount;
-        bool SurroundMode;
+        bool MultiMode_;
+        size_t RegexpsCount_;
+        bool SurroundMode_;
     };
 
     class TPireCapture: public TPireUdfBase {
diff --git a/yql/essentials/udfs/common/python/bindings/py_cast.cpp b/yql/essentials/udfs/common/python/bindings/py_cast.cpp
index ac44ac42e5a..fe2a6eb5002 100644
--- a/yql/essentials/udfs/common/python/bindings/py_cast.cpp
+++ b/yql/essentials/udfs/common/python/bindings/py_cast.cpp
@@ -27,11 +27,11 @@
 #include <util/string/builder.h>
 
 #ifdef HAVE_LONG_LONG
-#   define YQL_PyLong_AsUnsignedMask PyLong_AsUnsignedLongLongMask
+#   define YQL_PyLong_AsUnsignedMask PyLong_AsUnsignedLongLongMask // NOLINT(readability-identifier-naming)
 #   define YQL_PyLong_Asi64 PyLong_AsLongLong
 #   define YQL_PyLong_Asui64 PyLong_AsUnsignedLongLong
 #else
-#   define YQL_PyLong_AsUnsignedMask PyLong_AsUnsignedLongMask
+#   define YQL_PyLong_AsUnsignedMask PyLong_AsUnsignedLongMask // NOLINT(readability-identifier-naming)
 #   define YQL_PyLong_Asi64 PyLong_AsLong
 #   define YQL_PyLong_Asui64 PyLong_AsUnsignedLong
 #endif
diff --git a/yql/essentials/udfs/common/python/bindings/py_ctx.h b/yql/essentials/udfs/common/python/bindings/py_ctx.h
index 9e86042908f..7958fc1f815 100644
--- a/yql/essentials/udfs/common/python/bindings/py_ctx.h
+++ b/yql/essentials/udfs/common/python/bindings/py_ctx.h
@@ -41,28 +41,28 @@ public:
     }
 
     void Cleanup() override {
-        Value = {};
+        Value_ = {};
     }
 
     template <typename TCtx>
     void Set(const TIntrusivePtr<TCtx>& ctx, TValueType val) {
-        Value = std::move(val);
+        Value_ = std::move(val);
         ctx->CleanupList.PushBack(this);
     }
 
     bool IsSet() const {
-        return !!Value;
+        return !!Value_;
     }
 
     const TValueType& Get() const {
-        if (!Value) {
+        if (!Value_) {
             throw yexception() << "Trying to use python wrap object with destroyed yql value";
         }
-        return Value;
+        return Value_;
     }
 
 private:
-    TValueType Value;
+    TValueType Value_;
 };
 
 struct TPyContext: public TSimpleRefCount<TPyContext> {
diff --git a/yql/essentials/udfs/common/python/bindings/py_dict.cpp b/yql/essentials/udfs/common/python/bindings/py_dict.cpp
index f2bd0669eda..2df6eb4e99f 100644
--- a/yql/essentials/udfs/common/python/bindings/py_dict.cpp
+++ b/yql/essentials/udfs/common/python/bindings/py_dict.cpp
@@ -144,8 +144,8 @@ PyNumberMethods LazyDictNumbering = {
 
 
 #if PY_MAJOR_VERSION >= 3
-#define Py_TPFLAGS_HAVE_ITER 0
-#define Py_TPFLAGS_HAVE_SEQUENCE_IN 0
+#define Py_TPFLAGS_HAVE_ITER 0  // NOLINT(readability-identifier-naming)
+#define Py_TPFLAGS_HAVE_SEQUENCE_IN 0  // NOLINT(readability-identifier-naming)
 #endif
 
 PyDoc_STRVAR(get__doc__,
diff --git a/yql/essentials/udfs/common/python/bindings/py_gil.h b/yql/essentials/udfs/common/python/bindings/py_gil.h
index 70e9bf3e91d..6d629e7b237 100644
--- a/yql/essentials/udfs/common/python/bindings/py_gil.h
+++ b/yql/essentials/udfs/common/python/bindings/py_gil.h
@@ -8,30 +8,30 @@ namespace NPython {
 struct TPyGilLocker
 {
     TPyGilLocker()
-        : Gil(PyGILState_Ensure())
+        : Gil_(PyGILState_Ensure())
     {
     }
 
     ~TPyGilLocker() {
-        PyGILState_Release(Gil);
+        PyGILState_Release(Gil_);
     }
 
 private:
-    PyGILState_STATE Gil;
+    PyGILState_STATE Gil_;
 };
 
 struct TPyGilUnlocker {
     TPyGilUnlocker()
-        : ThreadState(PyEval_SaveThread())
+        : ThreadState_(PyEval_SaveThread())
     {
     }
 
     ~TPyGilUnlocker() {
-        PyEval_RestoreThread(ThreadState);
+        PyEval_RestoreThread(ThreadState_);
     }
 
 private:
-    PyThreadState* ThreadState;
+    PyThreadState* ThreadState_;
 };
 
 } // namespace NPython
diff --git a/yql/essentials/udfs/common/python/bindings/py_iterator.cpp b/yql/essentials/udfs/common/python/bindings/py_iterator.cpp
index 090211be2c1..c6f21cecb16 100644
--- a/yql/essentials/udfs/common/python/bindings/py_iterator.cpp
+++ b/yql/essentials/udfs/common/python/bindings/py_iterator.cpp
@@ -38,7 +38,7 @@ struct TPyIterator
 };
 
 #if PY_MAJOR_VERSION >= 3
-#define Py_TPFLAGS_HAVE_ITER 0
+#define Py_TPFLAGS_HAVE_ITER 0 // NOLINT(readability-identifier-naming)
 #endif
 
 PyTypeObject PyIteratorType = {
diff --git a/yql/essentials/udfs/common/python/bindings/py_lazy_mkql_dict.cpp b/yql/essentials/udfs/common/python/bindings/py_lazy_mkql_dict.cpp
index ffaa2fe4ec0..b9d90e49f9f 100644
--- a/yql/essentials/udfs/common/python/bindings/py_lazy_mkql_dict.cpp
+++ b/yql/essentials/udfs/common/python/bindings/py_lazy_mkql_dict.cpp
@@ -508,35 +508,35 @@ private:
     class TKeyIterator: public NUdf::TBoxedValue {
     public:
         TKeyIterator(Py_ssize_t size)
-            : Size(size), Index(0)
+            : Size_(size), Index_(0)
         {}
 
     private:
         bool Skip() override {
-            if (Index >= Size)
+            if (Index_ >= Size_)
                 return false;
 
-            ++Index;
+            ++Index_;
             return true;
         }
 
         bool Next(NUdf::TUnboxedValue& value) override {
-            if (Index >= Size)
+            if (Index_ >= Size_)
                 return false;
 
-            value = NUdf::TUnboxedValuePod(KeyType(Index++));
+            value = NUdf::TUnboxedValuePod(KeyType(Index_++));
             return true;
         }
 
     private:
-        const Py_ssize_t Size;
-        Py_ssize_t Index;
+        const Py_ssize_t Size_;
+        Py_ssize_t Index_;
     };
 
     class TIterator: public NUdf::TBoxedValue {
     public:
         TIterator(const TPyCastContext::TPtr& ctx, const NUdf::TType* itemType, Py_ssize_t size, const TPyObjectPtr& pySeq)
-            : CastCtx_(ctx),  ItemType_(itemType), PySeq_(pySeq), Size(size), Index(0)
+            : CastCtx_(ctx),  ItemType_(itemType), PySeq_(pySeq), Size_(size), Index_(0)
         {}
 
         ~TIterator() {
@@ -546,31 +546,31 @@ private:
 
     private:
         bool Skip() override {
-            if (Index >= Size)
+            if (Index_ >= Size_)
                 return false;
 
-            ++Index;
+            ++Index_;
             return true;
         }
 
         bool Next(NUdf::TUnboxedValue& value) override try {
-            if (Index >= Size)
+            if (Index_ >= Size_)
                 return false;
 
             const TPyGilLocker lock;
-            value = FromPyObject(CastCtx_, ItemType_, PySequence_Fast_GET_ITEM(PySeq_.Get(), Index++));
+            value = FromPyObject(CastCtx_, ItemType_, PySequence_Fast_GET_ITEM(PySeq_.Get(), Index_++));
             return true;
         } catch (const yexception& e) {
             UdfTerminate((TStringBuilder() << CastCtx_->PyCtx->Pos << e.what()).data());
         }
 
         bool NextPair(NUdf::TUnboxedValue& key, NUdf::TUnboxedValue& pay) override try {
-            if (Index >= Size)
+            if (Index_ >= Size_)
                 return false;
 
             const TPyGilLocker lock;
-            key = NUdf::TUnboxedValuePod(KeyType(Index));
-            pay = FromPyObject(CastCtx_, ItemType_, PySequence_Fast_GET_ITEM(PySeq_.Get(), Index++));
+            key = NUdf::TUnboxedValuePod(KeyType(Index_));
+            pay = FromPyObject(CastCtx_, ItemType_, PySequence_Fast_GET_ITEM(PySeq_.Get(), Index_++));
             return true;
         } catch (const yexception& e) {
             UdfTerminate((TStringBuilder() << CastCtx_->PyCtx->Pos << e.what()).data());
@@ -580,13 +580,13 @@ private:
         const TPyCastContext::TPtr CastCtx_;
         const NUdf::TType* ItemType_;
         TPyObjectPtr PySeq_;
-        const Py_ssize_t Size;
-        Py_ssize_t Index;
+        const Py_ssize_t Size_;
+        Py_ssize_t Index_;
     };
 
 public:
     TLazySequenceAsDict(const TPyCastContext::TPtr& ctx, const NUdf::TType* itemType, TPyObjectPtr&& sequence, Py_ssize_t size)
-        : CastCtx_(ctx), ItemType_(itemType), Size(size), PySeq_(std::move(sequence))
+        : CastCtx_(ctx), ItemType_(itemType), Size_(size), PySeq_(std::move(sequence))
     {}
 
     ~TLazySequenceAsDict()
@@ -599,18 +599,18 @@ private:
     bool IsSortedDict() const override { return true; }
 
     bool HasDictItems() const override {
-        return Size > 0;
+        return Size_ > 0;
     }
 
     ui64 GetDictLength() const override {
-        return Size;
+        return Size_;
     }
 
     NUdf::TUnboxedValue Lookup(const NUdf::TUnboxedValuePod& key) const override {
         const Py_ssize_t index = key.Get<KeyType>();
-        if (index >= -Size && index < Size) try {
+        if (index >= -Size_ && index < Size_) try {
             const TPyGilLocker lock;
-            if (const auto item = PySequence_Fast_GET_ITEM(PySeq_.Get(), index >= 0 ? index : Size + index)) {
+            if (const auto item = PySequence_Fast_GET_ITEM(PySeq_.Get(), index >= 0 ? index : Size_ + index)) {
                 return FromPyObject(CastCtx_, ItemType_, item).Release().MakeOptional();
             } else if (PyErr_Occurred()) {
                 UdfTerminate((TStringBuilder() << CastCtx_->PyCtx->Pos << GetLastErrorAsString()).data());
@@ -623,24 +623,24 @@ private:
 
     bool Contains(const NUdf::TUnboxedValuePod& key) const override {
         const Py_ssize_t index = key.Get<KeyType>();
-        return index >= -Size && index < Size;
+        return index >= -Size_ && index < Size_;
     }
 
     NUdf::TUnboxedValue GetKeysIterator() const override {
-        return NUdf::TUnboxedValuePod(new TKeyIterator(Size));
+        return NUdf::TUnboxedValuePod(new TKeyIterator(Size_));
     }
 
     NUdf::TUnboxedValue GetPayloadsIterator() const override {
-        return NUdf::TUnboxedValuePod(new TIterator(CastCtx_, ItemType_, Size, PySeq_));
+        return NUdf::TUnboxedValuePod(new TIterator(CastCtx_, ItemType_, Size_, PySeq_));
     }
 
     NUdf::TUnboxedValue GetDictIterator() const override {
-        return NUdf::TUnboxedValuePod(new TIterator(CastCtx_, ItemType_, Size, PySeq_));
+        return NUdf::TUnboxedValuePod(new TIterator(CastCtx_, ItemType_, Size_, PySeq_));
     }
 
     const TPyCastContext::TPtr CastCtx_;
     const NUdf::TType* ItemType_;
-    const Py_ssize_t Size;
+    const Py_ssize_t Size_;
     TPyObjectPtr PySeq_;
 };
 
diff --git a/yql/essentials/udfs/common/python/bindings/py_list.cpp b/yql/essentials/udfs/common/python/bindings/py_list.cpp
index 376a1ca124a..bbae59865f2 100644
--- a/yql/essentials/udfs/common/python/bindings/py_list.cpp
+++ b/yql/essentials/udfs/common/python/bindings/py_list.cpp
@@ -165,7 +165,7 @@ static PyMethodDef TPyLazyListMethods[] = {
 };
 
 #if PY_MAJOR_VERSION >= 3
-#define Py_TPFLAGS_HAVE_ITER 0
+#define Py_TPFLAGS_HAVE_ITER 0 // NOLINT(readability-identifier-naming)
 #endif
 
 PyTypeObject PyLazyListType = {
@@ -736,7 +736,7 @@ static PyMethodDef TPyThinListMethods[] = {
 };
 
 #if PY_MAJOR_VERSION >= 3
-#define Py_TPFLAGS_HAVE_ITER 0
+#define Py_TPFLAGS_HAVE_ITER 0 // NOLINT(readability-identifier-naming)
 #endif
 
 PyTypeObject PyThinListType = {
diff --git a/yql/essentials/udfs/common/python/bindings/py_stream.cpp b/yql/essentials/udfs/common/python/bindings/py_stream.cpp
index 3d9aecdc00b..5be78e442aa 100644
--- a/yql/essentials/udfs/common/python/bindings/py_stream.cpp
+++ b/yql/essentials/udfs/common/python/bindings/py_stream.cpp
@@ -49,7 +49,7 @@ struct TPyStream {
 };
 
 #if PY_MAJOR_VERSION >= 3
-#define Py_TPFLAGS_HAVE_ITER 0
+#define Py_TPFLAGS_HAVE_ITER 0 // NOLINT(readability-identifier-naming)
 #endif
 
 PyTypeObject PyStreamType = {
diff --git a/yql/essentials/udfs/common/python/bindings/py_yql_module.cpp b/yql/essentials/udfs/common/python/bindings/py_yql_module.cpp
index 5d1497f7c76..11ba4262173 100644
--- a/yql/essentials/udfs/common/python/bindings/py_yql_module.cpp
+++ b/yql/essentials/udfs/common/python/bindings/py_yql_module.cpp
@@ -94,21 +94,21 @@ static PyModuleDef ModuleDefinitionTyping = {
         INIT_MEMBER(m_free, nullptr),
 };
 
-PyMODINIT_FUNC PyInit_YQL(void)
+PyMODINIT_FUNC PyInit_YQL(void) // NOLINT(readability-identifier-naming)
 {
     auto mod = PyModule_Create(&ModuleDefinition);
     PyModule_AddObject(mod, "__path__", Py_BuildValue("()"));
     return mod;
 }
 
-void go_throw();
+void GoThrow();
 
-PyMODINIT_FUNC PyInit_YQLTyping(void)
+PyMODINIT_FUNC PyInit_YQLTyping(void) // NOLINT(readability-identifier-naming)
 {
     return PyModule_Create(&ModuleDefinitionTyping);
 }
 #else
-PyMODINIT_FUNC PyInit_YQL(void)
+PyMODINIT_FUNC PyInit_YQL(void) // NOLINT(readability-identifier-naming)
 {
     Py_InitModule3(MODULE_NAME, ModuleMethods, ModuleDoc);
 }
diff --git a/yql/essentials/udfs/common/python/python_udf/python_function_factory.h b/yql/essentials/udfs/common/python/python_udf/python_function_factory.h
index a4e393b4868..657fb1f442b 100644
--- a/yql/essentials/udfs/common/python/python_udf/python_function_factory.h
+++ b/yql/essentials/udfs/common/python/python_udf/python_function_factory.h
@@ -34,14 +34,14 @@ public:
             const TType* functionType,
             ITypeInfoHelper::TPtr&& helper,
             const NYql::NUdf::TSourcePosition& pos)
-        : Ctx(new TPyContext(helper, tag, pos))
-        , FunctionName(name)
+        : Ctx_(new TPyContext(helper, tag, pos))
+        , FunctionName_(name)
         , FunctionType_(functionType)
     {
     }
 
     ~TPythonFunctionFactory() {
-        Ctx->Cleanup();
+        Ctx_->Cleanup();
         PyCleanup();
     }
 
@@ -50,30 +50,30 @@ private:
             const IValueBuilder* valueBuilder,
             const TUnboxedValuePod* args) const override
     {
-        TPyCastContext::TPtr castCtx = MakeIntrusive<TPyCastContext>(valueBuilder, Ctx);
+        TPyCastContext::TPtr castCtx = MakeIntrusive<TPyCastContext>(valueBuilder, Ctx_);
 
         // for get propper c-compatible null-terminating string
         TString source(args[0].AsStringRef());
 
         TPyGilLocker lock;
-        TPyObjectPtr module = CompileModule(FunctionName, source);
+        TPyObjectPtr module = CompileModule(FunctionName_, source);
         if (!module) {
-            UdfTerminate((TStringBuilder() << Ctx->Pos << "Failed to compile module: " << GetLastErrorAsString()).data());
+            UdfTerminate((TStringBuilder() << Ctx_->Pos << "Failed to compile module: " << GetLastErrorAsString()).data());
         }
 
-        TPyObjectPtr function(PyObject_GetAttrString(module.Get(), FunctionName.data()));
+        TPyObjectPtr function(PyObject_GetAttrString(module.Get(), FunctionName_.data()));
         if (!function) {
-            UdfTerminate((TStringBuilder() << Ctx->Pos << "Failed to find entry point: " << GetLastErrorAsString()).data());
+            UdfTerminate((TStringBuilder() << Ctx_->Pos << "Failed to find entry point: " << GetLastErrorAsString()).data());
         }
 
         if (!PyCallable_Check(function.Get())) {
-            UdfTerminate((TStringBuilder() << Ctx->Pos << "Entry point is not a callable").data());
+            UdfTerminate((TStringBuilder() << Ctx_->Pos << "Entry point is not a callable").data());
         }
 
         try {
             SetupCallableSettings(castCtx, function.Get());
         } catch (const yexception& e) {
-            UdfTerminate((TStringBuilder() << Ctx->Pos << "Failed to setup callable settings: "
+            UdfTerminate((TStringBuilder() << Ctx_->Pos << "Failed to setup callable settings: "
                                            << e.what()).data());
         }
         return FromPyCallable(castCtx, FunctionType_, function.Release());
@@ -104,8 +104,8 @@ private:
         return module;
     }
 
-    const TPyContext::TPtr Ctx;
-    const TString FunctionName;
+    const TPyContext::TPtr Ctx_;
+    const TString FunctionName_;
     const TType* FunctionType_;
     inline static std::atomic_uint AtomicCounter = 0;
 };
diff --git a/yql/essentials/udfs/common/python/python_udf/python_udf.cpp b/yql/essentials/udfs/common/python/python_udf/python_udf.cpp
index 1007c75edc3..a14d9d81c32 100644
--- a/yql/essentials/udfs/common/python/python_udf/python_udf.cpp
+++ b/yql/essentials/udfs/common/python/python_udf/python_udf.cpp
@@ -49,9 +49,9 @@ class TPythonModule: public IUdfModule
 {
 public:
     TPythonModule(const TString& resourceName, EPythonFlavor pythonFlavor, bool standalone = true)
-        : ResourceName(resourceName), Standalone(standalone)
+        : ResourceName_(resourceName), Standalone_(standalone)
     {
-        if (Standalone) {
+        if (Standalone_) {
             Py_SetProgramName(PYTHON_PROGRAMM_NAME);
             PrepareYqlModule();
             Py_Initialize();
@@ -67,7 +67,7 @@ public:
         }
 
 #ifndef _win_
-        if (Standalone) {
+        if (Standalone_) {
             TVector<TStringBuf> paths;
             if (pythonFlavor == EPythonFlavor::System) {
                 paths.push_back(TStringBuf("/usr/lib/python2.7/dist-packages"));
@@ -82,14 +82,14 @@ public:
         TPyObjectPtr pyExecutableStr = PyRepr(GetExecPath().data());
         Y_ABORT_UNLESS(PySys_SetObject(executableVar, pyExecutableStr.Get()) >= 0, "Can't set sys.executable");
 
-        if (Standalone) {
+        if (Standalone_) {
             PyEval_InitThreads();
             MainThreadState_ = PyEval_SaveThread();
         }
     }
 
     ~TPythonModule() {
-        if (Standalone) {
+        if (Standalone_) {
             PyEval_RestoreThread(MainThreadState_);
             Py_Finalize();
         }
@@ -121,15 +121,15 @@ public:
             }
 
             const auto pos = builder.GetSourcePosition();
-            builder.Implementation(new TPythonFunctionFactory(name, ResourceName, userType, std::move(typeHelper), pos));
+            builder.Implementation(new TPythonFunctionFactory(name, ResourceName_, userType, std::move(typeHelper), pos));
         } catch (const yexception& e) {
             builder.SetError(TStringBuf(e.what()));
         }
     }
 
 private:
-    TString ResourceName;
-    bool Standalone;
+    TString ResourceName_;
+    bool Standalone_;
     PyThreadState* MainThreadState_;
 };
 
diff --git a/yql/essentials/udfs/common/re2/re2_udf.cpp b/yql/essentials/udfs/common/re2/re2_udf.cpp
index 36c92829467..baa3c6a3ec5 100644
--- a/yql/essentials/udfs/common/re2/re2_udf.cpp
+++ b/yql/essentials/udfs/common/re2/re2_udf.cpp
@@ -107,11 +107,11 @@ namespace {
                 TSourcePosition pos,
                 NYql::TLangVersion currentlangVersion,
                 const TRegexpGroups& regexpGroups = TRegexpGroups())
-                : Mode(mode)
-                , OptionsSchema(optionsSchema)
+                : Mode_(mode)
+                , OptionsSchema_(optionsSchema)
                 , Pos_(pos)
-                , RegexpGroups(regexpGroups)
-                , CurrentLangVersion(currentlangVersion)
+                , RegexpGroups_(regexpGroups)
+                , CurrentLangVersion_(currentlangVersion)
             {
             }
 
@@ -123,19 +123,19 @@ namespace {
                     new TRe2Udf(
                         valueBuilder,
                         args[0],
-                        RegexpGroups,
-                        Mode,
+                        RegexpGroups_,
+                        Mode_,
                         posix,
-                        OptionsSchema,
+                        OptionsSchema_,
                         Pos_,
-                        CurrentLangVersion));
+                        CurrentLangVersion_));
             }
 
-            EMode Mode;
-            const TOptionsSchema OptionsSchema;
+            EMode Mode_;
+            const TOptionsSchema OptionsSchema_;
             TSourcePosition Pos_;
-            const TRegexpGroups RegexpGroups;
-            NYql::TLangVersion CurrentLangVersion;
+            const TRegexpGroups RegexpGroups_;
+            NYql::TLangVersion CurrentLangVersion_;
         };
 
         static const TStringRef& Name(EMode mode) {
@@ -172,12 +172,12 @@ namespace {
             const TOptionsSchema& optionsSchema,
             TSourcePosition pos,
             NYql::TLangVersion currentLangVersion)
-            : RegexpGroups(regexpGroups)
-            , Mode(mode)
-            , Captured()
-            , OptionsSchema(optionsSchema)
+            : RegexpGroups_(regexpGroups)
+            , Mode_(mode)
+            , Captured_()
+            , OptionsSchema_(optionsSchema)
             , Pos_(pos)
-            , CurrentLangVersion(currentLangVersion) {
+            , CurrentLangVersion_(currentLangVersion) {
             try {
                 auto patternValue = runConfig.GetElement(0);
                 auto optionsValue = runConfig.GetElement(1);
@@ -192,20 +192,20 @@ namespace {
                         : RE2::Options::Encoding::EncodingLatin1
                 );
                 if (optionsValue) {
-#define FIELD_HANDLE(name, index, type, defVal, setter, conv) options.setter(conv(optionsValue.GetElement(OptionsSchema.Indices[index]).Get<type>()));
+#define FIELD_HANDLE(name, index, type, defVal, setter, conv) options.setter(conv(optionsValue.GetElement(OptionsSchema_.Indices[index]).Get<type>()));
                     OPTIONS_MAP(FIELD_HANDLE)
 #undef FIELD_HANDLE
                     options.set_log_errors(false);
                 }
 
-                Regexp = std::make_unique<RE2>(StringPiece(pattern.data(), pattern.size()), options);
+                Regexp_ = std::make_unique<RE2>(StringPiece(pattern.data(), pattern.size()), options);
 
-                if (!Regexp->ok() && ShouldFailOnInvalidRegexp(pattern, CurrentLangVersion)) {
-                    throw yexception() << FormatRegexpError(*Regexp);
+                if (!Regexp_->ok() && ShouldFailOnInvalidRegexp(pattern, CurrentLangVersion_)) {
+                    throw yexception() << FormatRegexpError(*Regexp_);
                 }
 
                 if (mode == EMode::CAPTURE) {
-                    Captured = std::make_unique<StringPiece[]>(Regexp->NumberOfCapturingGroups() + 1);
+                    Captured_ = std::make_unique<StringPiece[]>(Regexp_->NumberOfCapturingGroups() + 1);
                 }
 
             } catch (const std::exception& e) {
@@ -222,20 +222,20 @@ namespace {
                 const std::string_view input(args[0].AsStringRef());
                 const StringPiece piece(input.data(), input.size());
 
-                switch (Mode) {
+                switch (Mode_) {
                     case MATCH:
                         anchor = RE2::ANCHOR_BOTH;
                         [[fallthrough]];
                     case GREP:
-                        return TUnboxedValuePod(Regexp->Match(piece, 0, input.size(), anchor, nullptr, 0));
+                        return TUnboxedValuePod(Regexp_->Match(piece, 0, input.size(), anchor, nullptr, 0));
                     case CAPTURE: {
-                        const int count = Regexp->NumberOfCapturingGroups() + 1;
+                        const int count = Regexp_->NumberOfCapturingGroups() + 1;
                         TUnboxedValue* items = nullptr;
-                        const auto result = valueBuilder->NewArray(RegexpGroups.Names.size(), items);
-                        if (Regexp->Match(piece, 0, input.size(), anchor, Captured.get(), count)) {
+                        const auto result = valueBuilder->NewArray(RegexpGroups_.Names.size(), items);
+                        if (Regexp_->Match(piece, 0, input.size(), anchor, Captured_.get(), count)) {
                             for (int i = 0; i < count; ++i) {
-                                if (!Captured[i].empty()) {
-                                    items[RegexpGroups.Indexes[i]] = valueBuilder->SubString(args[0], std::distance(piece.begin(), Captured[i].begin()), Captured[i].size());
+                                if (!Captured_[i].empty()) {
+                                    items[RegexpGroups_.Indexes[i]] = valueBuilder->SubString(args[0], std::distance(piece.begin(), Captured_[i].begin()), Captured_[i].size());
                                 }
                             }
                         } else {
@@ -247,22 +247,22 @@ namespace {
                         const std::string_view rewriteRef(args[1].AsStringRef());
                         const StringPiece rewrite(rewriteRef.data(), rewriteRef.size());
                         TString rewriteError;
-                        if (!Regexp->CheckRewriteString(rewrite, &rewriteError)) {
+                        if (!Regexp_->CheckRewriteString(rewrite, &rewriteError)) {
                             UdfTerminate((TStringBuilder() << Pos_ << " [rewrite error] " << rewriteError).data());
                         }
                         std::string result(input);
-                        RE2::GlobalReplace(&result, *Regexp, rewrite);
+                        RE2::GlobalReplace(&result, *Regexp_, rewrite);
                         return input == result ? TUnboxedValue(args[0]) : valueBuilder->NewString(result);
                     }
                     case COUNT: {
                         std::string inputHolder(input);
-                        const ui32 result = RE2::GlobalReplace(&inputHolder, *Regexp, "");
+                        const ui32 result = RE2::GlobalReplace(&inputHolder, *Regexp_, "");
                         return TUnboxedValuePod(result);
                     }
                     case FIND_AND_CONSUME: {
                         StringPiece text(piece);
                         std::vector<TUnboxedValue> matches;
-                        for (StringPiece w; text.begin() < text.end() && RE2::FindAndConsume(&text, *Regexp, &w);) {
+                        for (StringPiece w; text.begin() < text.end() && RE2::FindAndConsume(&text, *Regexp_, &w);) {
                             if (w.size() == 0 && !text.empty()) {
                                 text.remove_prefix(1);
                             }
@@ -273,7 +273,7 @@ namespace {
                 }
                 Y_ABORT("Unexpected mode");
             } else {
-                switch (Mode) {
+                switch (Mode_) {
                     case MATCH:
                     case GREP:
                         return TUnboxedValuePod(false);
@@ -292,17 +292,17 @@ namespace {
             UdfTerminate((TStringBuilder() << Pos_ << " " << e.what()).data());
         }
 
-        std::unique_ptr<RE2> Regexp;
-        const TRegexpGroups RegexpGroups;
-        EMode Mode;
-        std::unique_ptr<StringPiece[]> Captured;
-        const TOptionsSchema OptionsSchema;
+        std::unique_ptr<RE2> Regexp_;
+        const TRegexpGroups RegexpGroups_;
+        EMode Mode_;
+        std::unique_ptr<StringPiece[]> Captured_;
+        const TOptionsSchema OptionsSchema_;
         TSourcePosition Pos_;
-        NYql::TLangVersion CurrentLangVersion;
+        NYql::TLangVersion CurrentLangVersion_;
 
         TUnboxedValue BuildEmptyStruct(const IValueBuilder* valueBuilder) const {
             TUnboxedValue* items = nullptr;
-            return valueBuilder->NewArray(RegexpGroups.Names.size(), items);
+            return valueBuilder->NewArray(RegexpGroups_.Names.size(), items);
         }
     };
 
diff --git a/yql/essentials/udfs/common/set/set_udf.cpp b/yql/essentials/udfs/common/set/set_udf.cpp
index 4a9d050a31a..a7851ec8633 100644
--- a/yql/essentials/udfs/common/set/set_udf.cpp
+++ b/yql/essentials/udfs/common/set/set_udf.cpp
@@ -11,32 +11,32 @@ namespace {
 template <typename THash, typename TEquals>
 class TSetBase {
 private:
-    std::unordered_set<TUnboxedValue, THash, TEquals, TUnboxedValue::TAllocator> Set;
-    ui32 MaxSize = 0;
-    bool WasChanged = false;
+    std::unordered_set<TUnboxedValue, THash, TEquals, TUnboxedValue::TAllocator> Set_;
+    ui32 MaxSize_ = 0;
+    bool WasChanged_ = false;
 
 protected:
     TSetBase(THash hash, TEquals equals)
-        : Set(1, hash, equals)
+        : Set_(1, hash, equals)
     {}
 
     void Init(const TUnboxedValuePod& value, ui32 maxSize) {
-        MaxSize = maxSize ? maxSize : std::numeric_limits<ui32>::max();
+        MaxSize_ = maxSize ? maxSize : std::numeric_limits<ui32>::max();
         AddValue(value);
     }
 
     void Merge(const TSetBase& left, const TSetBase& right) {
-        MaxSize = std::max(left.MaxSize, right.MaxSize);
-        for (const auto& item : left.Set) {
+        MaxSize_ = std::max(left.MaxSize_, right.MaxSize_);
+        for (const auto& item : left.Set_) {
             AddValue(item);
         }
-        for (const auto& item : right.Set) {
+        for (const auto& item : right.Set_) {
             AddValue(item);
         }
     }
 
     void Deserialize(const TUnboxedValuePod& serialized) {
-        MaxSize = serialized.GetElement(0).Get<ui32>();
+        MaxSize_ = serialized.GetElement(0).Get<ui32>();
         auto list = serialized.GetElement(1);
 
         const auto listIter = list.GetListIterator();
@@ -47,24 +47,24 @@ protected:
 
 public:
     void ResetChanged() {
-        WasChanged = false;
+        WasChanged_ = false;
     }
 
     bool Changed() const {
-        return WasChanged;
+        return WasChanged_;
     }
 
     TUnboxedValue Serialize(const IValueBuilder* builder) {
         TUnboxedValue* values = nullptr;
-        auto list = builder->NewArray(Set.size(), values);
+        auto list = builder->NewArray(Set_.size(), values);
 
-        for (const auto& item : Set) {
+        for (const auto& item : Set_) {
             *values++ = item;
         }
 
         TUnboxedValue* items = nullptr;
         auto result = builder->NewArray(2U, items);
-        items[0] = TUnboxedValuePod(MaxSize);
+        items[0] = TUnboxedValuePod(MaxSize_);
         items[1] = list;
 
         return result;
@@ -72,17 +72,17 @@ public:
 
     TUnboxedValue GetResult(const IValueBuilder* builder) {
         TUnboxedValue* values = nullptr;
-        auto result = builder->NewArray(Set.size(), values);
+        auto result = builder->NewArray(Set_.size(), values);
 
-        for (const auto& item : Set) {
+        for (const auto& item : Set_) {
             *values++ = item;
         }
         return result;
     }
 
     void AddValue(const TUnboxedValuePod& value) {
-        if (Set.size() < MaxSize) {
-            WasChanged = Set.insert(TUnboxedValuePod(value)).second;
+        if (Set_.size() < MaxSize_) {
+            WasChanged_ = Set_.insert(TUnboxedValuePod(value)).second;
         }
     }
 };
diff --git a/yql/essentials/udfs/common/streaming/streaming_udf.cpp b/yql/essentials/udfs/common/streaming/streaming_udf.cpp
index bd01935321e..dcae482b320 100644
--- a/yql/essentials/udfs/common/streaming/streaming_udf.cpp
+++ b/yql/essentials/udfs/common/streaming/streaming_udf.cpp
@@ -29,41 +29,41 @@ namespace {
     class TCyclicRWBuffer {
     public:
         TCyclicRWBuffer(size_t capacity)
-            : Buffer(capacity)
-            , Finished(false)
-            , DataStart(0)
-            , DataSize(0)
+            : Buffer_(capacity)
+            , Finished_(false)
+            , DataStart_(0)
+            , DataSize_(0)
         {
-            Buffer.Resize(capacity);
+            Buffer_.Resize(capacity);
         }
 
         bool IsFinished() const {
-            return Finished;
+            return Finished_;
         }
 
         void Finish() {
-            Finished = true;
+            Finished_ = true;
         }
 
         bool HasData() const {
-            return DataSize > 0;
+            return DataSize_ > 0;
         }
 
         size_t GetDataSize() const {
-            return DataSize;
+            return DataSize_;
         }
 
         void GetData(const char*& ptr, size_t& len) const {
-            size_t readSize = GetDataRegionSize(DataStart, DataSize);
-            ptr = Buffer.Data() + DataStart;
+            size_t readSize = GetDataRegionSize(DataStart_, DataSize_);
+            ptr = Buffer_.Data() + DataStart_;
             len = readSize;
         }
 
         void CommitRead(size_t len) {
-            Y_DEBUG_ABORT_UNLESS(len <= GetDataRegionSize(DataStart, DataSize));
+            Y_DEBUG_ABORT_UNLESS(len <= GetDataRegionSize(DataStart_, DataSize_));
 
-            DataStart = GetBufferPosition(DataStart + len);
-            DataSize -= len;
+            DataStart_ = GetBufferPosition(DataStart_ + len);
+            DataSize_ -= len;
         }
 
         bool CanWrite() const {
@@ -71,7 +71,7 @@ namespace {
         }
 
         size_t WriteSize() const {
-            return Buffer.Size() - DataSize;
+            return Buffer_.Size() - DataSize_;
         }
 
         size_t Write(const char*& ptr, size_t& len) {
@@ -87,7 +87,7 @@ namespace {
 
                 MemCopy(Data(writeStart), ptr, writeSize);
 
-                DataSize += writeSize;
+                DataSize_ += writeSize;
                 bytesWritten += writeSize;
                 bytesToWrite -= writeSize;
 
@@ -107,32 +107,32 @@ namespace {
 
     private:
         size_t GetBufferPosition(size_t pos) const {
-            return pos % Buffer.Size();
+            return pos % Buffer_.Size();
         }
 
         size_t GetDataRegionSize(size_t start, size_t size) const {
-            Y_DEBUG_ABORT_UNLESS(start < Buffer.Size());
+            Y_DEBUG_ABORT_UNLESS(start < Buffer_.Size());
 
-            return std::min(size, Buffer.Size() - start);
+            return std::min(size, Buffer_.Size() - start);
         }
 
         size_t GetWriteStart() const {
-            return GetBufferPosition(DataStart + DataSize);
+            return GetBufferPosition(DataStart_ + DataSize_);
         }
 
         char* Data(size_t pos) {
-            Y_DEBUG_ABORT_UNLESS(pos < Buffer.Size());
+            Y_DEBUG_ABORT_UNLESS(pos < Buffer_.Size());
 
-            return (Buffer.Data() + pos);
+            return (Buffer_.Data() + pos);
         }
 
     private:
-        TBuffer Buffer;
+        TBuffer Buffer_;
 
-        bool Finished;
+        bool Finished_;
 
-        size_t DataStart;
-        size_t DataSize;
+        size_t DataStart_;
+        size_t DataSize_;
     };
 
     struct TStreamingParams {
@@ -174,14 +174,14 @@ namespace {
     public:
         TStringListBufferedInputStream(TUnboxedValue rowsStream, const TString& delimiter, size_t bufferSizeBytes,
                                        TThreadSyncData& syncData, TSourcePosition pos)
-            : RowsStream(rowsStream)
-            , Delimiter(delimiter)
-            , SyncData(syncData)
+            : RowsStream_(rowsStream)
+            , Delimiter_(delimiter)
+            , SyncData_(syncData)
             , Pos_(pos)
-            , DelimiterMatcher(delimiter)
-            , DelimiterInput(delimiter)
-            , Buffer(bufferSizeBytes)
-            , CurReadMode(ReadMode::Start)
+            , DelimiterMatcher_(delimiter)
+            , DelimiterInput_(delimiter)
+            , Buffer_(bufferSizeBytes)
+            , CurReadMode_(ReadMode::Start)
         {
         }
 
@@ -189,20 +189,20 @@ namespace {
         TStringListBufferedInputStream& operator=(const TStringListBufferedInputStream&) = delete;
 
         TCyclicRWBuffer& GetBuffer() {
-            return Buffer;
+            return Buffer_;
         }
 
         // Fetch input from upstream list iterator to the buffer.
         // Called from Main thread.
         EFetchStatus FetchInput() {
-            with_lock (SyncData.BuffersMutex) {
-                Y_DEBUG_ABORT_UNLESS(!Buffer.HasData());
-                Y_DEBUG_ABORT_UNLESS(Buffer.CanWrite());
+            with_lock (SyncData_.BuffersMutex) {
+                Y_DEBUG_ABORT_UNLESS(!Buffer_.HasData());
+                Y_DEBUG_ABORT_UNLESS(Buffer_.CanWrite());
 
                 bool receivedYield = false;
 
-                while (Buffer.CanWrite() && CurReadMode != ReadMode::Done && !receivedYield) {
-                    switch (CurReadMode) {
+                while (Buffer_.CanWrite() && CurReadMode_ != ReadMode::Done && !receivedYield) {
+                    switch (CurReadMode_) {
                         case ReadMode::Start: {
                             auto status = ReadNextString();
                             if (status == EFetchStatus::Yield) {
@@ -210,7 +210,7 @@ namespace {
                                 break;
                             }
 
-                            CurReadMode = (status == EFetchStatus::Ok)
+                            CurReadMode_ = (status == EFetchStatus::Ok)
                                               ? ReadMode::String
                                               : ReadMode::Done;
 
@@ -218,22 +218,22 @@ namespace {
                         }
 
                         case ReadMode::String:
-                            if (CurStringInput.Exhausted()) {
-                                DelimiterInput.Reset(Delimiter.data(), Delimiter.size());
-                                CurReadMode = ReadMode::Delimiter;
+                            if (CurStringInput_.Exhausted()) {
+                                DelimiterInput_.Reset(Delimiter_.data(), Delimiter_.size());
+                                CurReadMode_ = ReadMode::Delimiter;
                                 break;
                             }
 
-                            Buffer.Write(CurStringInput);
+                            Buffer_.Write(CurStringInput_);
                             break;
 
                         case ReadMode::Delimiter:
-                            if (DelimiterInput.Exhausted()) {
-                                CurReadMode = ReadMode::Start;
+                            if (DelimiterInput_.Exhausted()) {
+                                CurReadMode_ = ReadMode::Start;
                                 break;
                             }
 
-                            Buffer.Write(DelimiterInput);
+                            Buffer_.Write(DelimiterInput_);
                             break;
 
                         default:
@@ -241,11 +241,11 @@ namespace {
                     }
                 }
 
-                if (CurReadMode == ReadMode::Done) {
-                    Buffer.Finish();
+                if (CurReadMode_ == ReadMode::Done) {
+                    Buffer_.Finish();
                 }
 
-                SyncData.InputBufferCanReadCond.Signal();
+                SyncData_.InputBufferCanReadCond.Signal();
                 return receivedYield ? EFetchStatus::Yield : EFetchStatus::Ok;
             }
         }
@@ -255,25 +255,25 @@ namespace {
         // Called from Communicate thread.
         size_t DoRead(void* buf, size_t len) override {
             try {
-                with_lock (SyncData.BuffersMutex) {
-                    while (!Buffer.HasData() && !Buffer.IsFinished()) {
-                        SyncData.MainThreadHasWorkCond.Signal();
-                        SyncData.InputBufferCanReadCond.WaitI(SyncData.BuffersMutex);
+                with_lock (SyncData_.BuffersMutex) {
+                    while (!Buffer_.HasData() && !Buffer_.IsFinished()) {
+                        SyncData_.MainThreadHasWorkCond.Signal();
+                        SyncData_.InputBufferCanReadCond.WaitI(SyncData_.BuffersMutex);
                     }
 
-                    if (!Buffer.HasData()) {
-                        Y_DEBUG_ABORT_UNLESS(Buffer.IsFinished());
+                    if (!Buffer_.HasData()) {
+                        Y_DEBUG_ABORT_UNLESS(Buffer_.IsFinished());
                         return 0;
                     }
 
                     const char* dataPtr;
                     size_t dataLen;
-                    Buffer.GetData(dataPtr, dataLen);
+                    Buffer_.GetData(dataPtr, dataLen);
 
                     size_t bytesRead = std::min(dataLen, len);
                     Y_DEBUG_ABORT_UNLESS(bytesRead > 0);
                     memcpy(buf, dataPtr, bytesRead);
-                    Buffer.CommitRead(bytesRead);
+                    Buffer_.CommitRead(bytesRead);
                     return bytesRead;
                 }
 
@@ -285,7 +285,7 @@ namespace {
 
         EFetchStatus ReadNextString() {
             TUnboxedValue item;
-            EFetchStatus status = RowsStream.Fetch(item);
+            EFetchStatus status = RowsStream_.Fetch(item);
             switch (status) {
                 case EFetchStatus::Yield:
                 case EFetchStatus::Finish:
@@ -294,15 +294,15 @@ namespace {
                     break;
             }
 
-            CurString = item.GetElement(0);
-            CurStringInput.Reset(CurString.AsStringRef().Data(), CurString.AsStringRef().Size());
+            CurString_ = item.GetElement(0);
+            CurStringInput_.Reset(CurString_.AsStringRef().Data(), CurString_.AsStringRef().Size());
 
             // Check that input string doesn't contain delimiters
             const char* match;
             Y_UNUSED(match);
-            if (DelimiterMatcher.SubStr(
-                    CurString.AsStringRef().Data(),
-                    CurString.AsStringRef().Data() + CurString.AsStringRef().Size(),
+            if (DelimiterMatcher_.SubStr(
+                    CurString_.AsStringRef().Data(),
+                    CurString_.AsStringRef().Data() + CurString_.AsStringRef().Size(),
                     match))
             {
                 ythrow yexception() << "Delimiter found in input string.";
@@ -319,32 +319,32 @@ namespace {
             Done
         };
 
-        TUnboxedValue RowsStream;
-        TString Delimiter;
-        TThreadSyncData& SyncData;
+        TUnboxedValue RowsStream_;
+        TString Delimiter_;
+        TThreadSyncData& SyncData_;
         TSourcePosition Pos_;
 
-        TKMPMatcher DelimiterMatcher;
-        TUnboxedValue CurString;
-        TMemoryInput CurStringInput;
-        TMemoryInput DelimiterInput;
+        TKMPMatcher DelimiterMatcher_;
+        TUnboxedValue CurString_;
+        TMemoryInput CurStringInput_;
+        TMemoryInput DelimiterInput_;
 
-        TCyclicRWBuffer Buffer;
+        TCyclicRWBuffer Buffer_;
 
-        ReadMode CurReadMode;
+        ReadMode CurReadMode_;
     };
 
     class TStringListBufferedOutputStream: public IOutputStream {
     public:
         TStringListBufferedOutputStream(const TString& delimiter, size_t stringBufferSizeBytes,
                                         TStringListBufferedInputStream& inputStream, TThreadSyncData& syncData)
-            : Delimiter(delimiter)
-            , InputStream(inputStream)
-            , SyncData(syncData)
-            , HasDelimiterMatch(false)
-            , DelimiterMatcherCallback(HasDelimiterMatch)
-            , DelimiterMatcher(delimiter.data(), delimiter.data() + delimiter.size(), &DelimiterMatcherCallback)
-            , Buffer(stringBufferSizeBytes)
+            : Delimiter_(delimiter)
+            , InputStream_(inputStream)
+            , SyncData_(syncData)
+            , HasDelimiterMatch_(false)
+            , DelimiterMatcherCallback_(HasDelimiterMatch_)
+            , DelimiterMatcher_(delimiter.data(), delimiter.data() + delimiter.size(), &DelimiterMatcherCallback_)
+            , Buffer_(stringBufferSizeBytes)
         {
         }
 
@@ -354,22 +354,22 @@ namespace {
         // Get string record from buffer.
         // Called from Main thread.
         EFetchStatus FetchNextString(TString& str) {
-            while (!HasDelimiterMatch) {
-                with_lock (SyncData.BuffersMutex) {
+            while (!HasDelimiterMatch_) {
+                with_lock (SyncData_.BuffersMutex) {
                     bool inputHasData;
                     bool bufferNeedsData;
 
                     do {
-                        inputHasData = InputStream.GetBuffer().HasData() || InputStream.GetBuffer().IsFinished();
-                        bufferNeedsData = !Buffer.HasData() && !Buffer.IsFinished();
+                        inputHasData = InputStream_.GetBuffer().HasData() || InputStream_.GetBuffer().IsFinished();
+                        bufferNeedsData = !Buffer_.HasData() && !Buffer_.IsFinished();
 
                         if (inputHasData && bufferNeedsData) {
-                            SyncData.MainThreadHasWorkCond.WaitI(SyncData.BuffersMutex);
+                            SyncData_.MainThreadHasWorkCond.WaitI(SyncData_.BuffersMutex);
                         }
                     } while (inputHasData && bufferNeedsData);
 
                     if (!inputHasData) {
-                        auto status = InputStream.FetchInput();
+                        auto status = InputStream_.FetchInput();
                         if (status == EFetchStatus::Yield) {
                             return EFetchStatus::Yield;
                         }
@@ -379,44 +379,44 @@ namespace {
                         continue;
                     }
 
-                    if (!Buffer.HasData()) {
-                        Y_DEBUG_ABORT_UNLESS(Buffer.IsFinished());
-                        str = TString(TStringBuf(CurrentString.Data(), CurrentString.Size()));
-                        CurrentString.Clear();
+                    if (!Buffer_.HasData()) {
+                        Y_DEBUG_ABORT_UNLESS(Buffer_.IsFinished());
+                        str = TString(TStringBuf(CurrentString_.Data(), CurrentString_.Size()));
+                        CurrentString_.Clear();
                         return str.empty() ? EFetchStatus::Finish : EFetchStatus::Ok;
                     }
 
                     const char* data;
                     size_t size;
-                    Buffer.GetData(data, size);
+                    Buffer_.GetData(data, size);
 
                     size_t read = 0;
-                    while (!HasDelimiterMatch && read < size) {
-                        DelimiterMatcher.Push(data[read]);
+                    while (!HasDelimiterMatch_ && read < size) {
+                        DelimiterMatcher_.Push(data[read]);
                         ++read;
                     }
 
                     Y_DEBUG_ABORT_UNLESS(read > 0);
-                    CurrentString.Append(data, read);
-                    bool signalCanWrite = !Buffer.CanWrite();
-                    Buffer.CommitRead(read);
+                    CurrentString_.Append(data, read);
+                    bool signalCanWrite = !Buffer_.CanWrite();
+                    Buffer_.CommitRead(read);
 
                     if (signalCanWrite) {
-                        SyncData.OutputBufferCanWriteCond.Signal();
+                        SyncData_.OutputBufferCanWriteCond.Signal();
                     }
                 }
             }
 
-            Y_DEBUG_ABORT_UNLESS(CurrentString.Size() >= Delimiter.size());
-            str = TString(TStringBuf(CurrentString.Data(), CurrentString.Size() - Delimiter.size()));
-            CurrentString.Clear();
-            HasDelimiterMatch = false;
+            Y_DEBUG_ABORT_UNLESS(CurrentString_.Size() >= Delimiter_.size());
+            str = TString(TStringBuf(CurrentString_.Data(), CurrentString_.Size() - Delimiter_.size()));
+            CurrentString_.Clear();
+            HasDelimiterMatch_ = false;
 
             return EFetchStatus::Ok;
         }
 
         TCyclicRWBuffer& GetBuffer() {
-            return Buffer;
+            return Buffer_;
         }
 
     private:
@@ -427,20 +427,20 @@ namespace {
             size_t curStrLen = len;
 
             while (curStrLen > 0) {
-                with_lock (SyncData.BuffersMutex) {
-                    while (!Buffer.CanWrite() && !Buffer.IsFinished()) {
-                        SyncData.OutputBufferCanWriteCond.WaitI(SyncData.BuffersMutex);
+                with_lock (SyncData_.BuffersMutex) {
+                    while (!Buffer_.CanWrite() && !Buffer_.IsFinished()) {
+                        SyncData_.OutputBufferCanWriteCond.WaitI(SyncData_.BuffersMutex);
                     }
 
-                    if (Buffer.IsFinished()) {
+                    if (Buffer_.IsFinished()) {
                         return;
                     }
 
-                    bool signalCanRead = !Buffer.HasData();
-                    Buffer.Write(curStrPos, curStrLen);
+                    bool signalCanRead = !Buffer_.HasData();
+                    Buffer_.Write(curStrPos, curStrLen);
 
                     if (signalCanRead) {
-                        SyncData.MainThreadHasWorkCond.Signal();
+                        SyncData_.MainThreadHasWorkCond.Signal();
                     }
                 }
             }
@@ -449,9 +449,9 @@ namespace {
         void DoFinish() override {
             IOutputStream::DoFinish();
 
-            with_lock (SyncData.BuffersMutex) {
-                Buffer.Finish();
-                SyncData.MainThreadHasWorkCond.Signal();
+            with_lock (SyncData_.BuffersMutex) {
+                Buffer_.Finish();
+                SyncData_.MainThreadHasWorkCond.Signal();
             }
         }
 
@@ -459,7 +459,7 @@ namespace {
         class MatcherCallback: public TKMPStreamMatcher<char>::ICallback {
         public:
             MatcherCallback(bool& hasMatch)
-                : HasMatch(hasMatch)
+                : HasMatch_(hasMatch)
             {
             }
 
@@ -467,32 +467,32 @@ namespace {
                 Y_UNUSED(begin);
                 Y_UNUSED(end);
 
-                HasMatch = true;
+                HasMatch_ = true;
             }
 
         private:
-            bool& HasMatch;
+            bool& HasMatch_;
         };
 
     private:
-        TString Delimiter;
-        TStringListBufferedInputStream& InputStream;
-        TThreadSyncData& SyncData;
+        TString Delimiter_;
+        TStringListBufferedInputStream& InputStream_;
+        TThreadSyncData& SyncData_;
 
-        bool HasDelimiterMatch;
-        MatcherCallback DelimiterMatcherCallback;
-        TKMPStreamMatcher<char> DelimiterMatcher;
+        bool HasDelimiterMatch_;
+        MatcherCallback DelimiterMatcherCallback_;
+        TKMPStreamMatcher<char> DelimiterMatcher_;
 
-        TBuffer CurrentString;
+        TBuffer CurrentString_;
 
-        TCyclicRWBuffer Buffer;
+        TCyclicRWBuffer Buffer_;
     };
 
     class TStreamingOutputListIterator {
     public:
         TStreamingOutputListIterator(const TStreamingParams& params, const IValueBuilder* valueBuilder, TSourcePosition pos)
-            : StreamingParams(params)
-            , ValueBuilder(valueBuilder)
+            : StreamingParams_(params)
+            , ValueBuilder_(valueBuilder)
             , Pos_(pos)
         {
         }
@@ -501,24 +501,24 @@ namespace {
         TStreamingOutputListIterator& operator=(const TStreamingOutputListIterator&) = delete;
 
         ~TStreamingOutputListIterator() {
-            if (ShellCommand) {
-                Y_DEBUG_ABORT_UNLESS(InputStream && OutputStream);
+            if (ShellCommand_) {
+                Y_DEBUG_ABORT_UNLESS(InputStream_ && OutputStream_);
 
                 try {
-                    ShellCommand->Terminate();
+                    ShellCommand_->Terminate();
                 } catch (const std::exception& e) {
                     Cerr << CurrentExceptionMessage();
                 }
 
                 // Let Communicate thread finish.
-                with_lock (ThreadSyncData.BuffersMutex) {
-                    InputStream->GetBuffer().Finish();
-                    OutputStream->GetBuffer().Finish();
-                    ThreadSyncData.InputBufferCanReadCond.Signal();
-                    ThreadSyncData.OutputBufferCanWriteCond.Signal();
+                with_lock (ThreadSyncData_.BuffersMutex) {
+                    InputStream_->GetBuffer().Finish();
+                    OutputStream_->GetBuffer().Finish();
+                    ThreadSyncData_.InputBufferCanReadCond.Signal();
+                    ThreadSyncData_.OutputBufferCanWriteCond.Signal();
                 }
 
-                ShellCommand->Wait();
+                ShellCommand_->Wait();
             }
         }
 
@@ -531,35 +531,35 @@ namespace {
 
                     // Don't try to fetch data if there was a problem starting the process,
                     // this causes infinite wait on Windows system due to incorrect ShellCommand behavior.
-                    if (ShellCommand->GetStatus() != TShellCommand::SHELL_RUNNING && ShellCommand->GetStatus() != TShellCommand::SHELL_FINISHED) {
+                    if (ShellCommand_->GetStatus() != TShellCommand::SHELL_RUNNING && ShellCommand_->GetStatus() != TShellCommand::SHELL_FINISHED) {
                         status = EFetchStatus::Finish;
                     }
                 }
 
                 if (status == EFetchStatus::Ok) {
-                    status = OutputStream->FetchNextString(CurrentRecord);
+                    status = OutputStream_->FetchNextString(CurrentRecord_);
                 }
 
                 if (status == EFetchStatus::Finish) {
-                    switch (ShellCommand->GetStatus()) {
+                    switch (ShellCommand_->GetStatus()) {
                         case TShellCommand::SHELL_FINISHED:
                             break;
                         case TShellCommand::SHELL_INTERNAL_ERROR:
-                            ythrow yexception() << "Internal error running process: " << ShellCommand->GetInternalError();
+                            ythrow yexception() << "Internal error running process: " << ShellCommand_->GetInternalError();
                             break;
                         case TShellCommand::SHELL_ERROR:
-                            ythrow yexception() << "Error running user process: " << ShellCommand->GetError();
+                            ythrow yexception() << "Error running user process: " << ShellCommand_->GetError();
                             break;
                         default:
-                            ythrow yexception() << "Unexpected shell command status: " << (int)ShellCommand->GetStatus();
+                            ythrow yexception() << "Unexpected shell command status: " << (int)ShellCommand_->GetStatus();
                     }
                     return EFetchStatus::Finish;
                 }
 
                 if (status == EFetchStatus::Ok) {
                     TUnboxedValue* items = nullptr;
-                    result = ValueBuilder->NewArray(1, items);
-                    *items = ValueBuilder->NewString(TStringRef(CurrentRecord.data(), CurrentRecord.size()));
+                    result = ValueBuilder_->NewArray(1, items);
+                    *items = ValueBuilder_->NewString(TStringRef(CurrentRecord_.data(), CurrentRecord_.size()));
                 }
 
                 return status;
@@ -570,50 +570,50 @@ namespace {
 
     private:
         void StartProcess() {
-            InputStream.Reset(new TStringListBufferedInputStream(
-                StreamingParams.InputStreamObj, StreamingParams.InputDelimiter,
-                StreamingParams.InputBufferSizeBytes, ThreadSyncData, Pos_));
+            InputStream_.Reset(new TStringListBufferedInputStream(
+                StreamingParams_.InputStreamObj, StreamingParams_.InputDelimiter,
+                StreamingParams_.InputBufferSizeBytes, ThreadSyncData_, Pos_));
 
-            OutputStream.Reset(new TStringListBufferedOutputStream(
-                StreamingParams.OutputDelimiter, StreamingParams.OutputBufferSizeBytes, *InputStream,
-                ThreadSyncData));
+            OutputStream_.Reset(new TStringListBufferedOutputStream(
+                StreamingParams_.OutputDelimiter, StreamingParams_.OutputBufferSizeBytes, *InputStream_,
+                ThreadSyncData_));
 
             TShellCommandOptions opt;
-            opt.SetAsync(true).SetUseShell(false).SetLatency(StreamingParams.ProcessPollLatencyMs).SetInputStream(InputStream.Get()).SetOutputStream(OutputStream.Get()).SetCloseStreams(true).SetCloseAllFdsOnExec(true);
+            opt.SetAsync(true).SetUseShell(false).SetLatency(StreamingParams_.ProcessPollLatencyMs).SetInputStream(InputStream_.Get()).SetOutputStream(OutputStream_.Get()).SetCloseStreams(true).SetCloseAllFdsOnExec(true);
 
             TList<TString> commandArguments;
-            auto argumetsIterator = StreamingParams.ArgumentsList.GetListIterator();
+            auto argumetsIterator = StreamingParams_.ArgumentsList.GetListIterator();
             for (TUnboxedValue item; argumetsIterator.Next(item);) {
                 commandArguments.emplace_back(TStringBuf(item.AsStringRef()));
             }
 
-            ShellCommand.Reset(new TShellCommand(StreamingParams.CommandLine, commandArguments, opt));
-            ShellCommand->Run();
+            ShellCommand_.Reset(new TShellCommand(StreamingParams_.CommandLine, commandArguments, opt));
+            ShellCommand_->Run();
         }
 
         bool ProcessStarted() const {
-            return !!ShellCommand;
+            return !!ShellCommand_;
         }
 
     private:
-        TStreamingParams StreamingParams;
-        const IValueBuilder* ValueBuilder;
+        TStreamingParams StreamingParams_;
+        const IValueBuilder* ValueBuilder_;
         TSourcePosition Pos_;
 
-        TThreadSyncData ThreadSyncData;
+        TThreadSyncData ThreadSyncData_;
 
-        THolder<TShellCommand> ShellCommand;
-        THolder<TStringListBufferedInputStream> InputStream;
-        THolder<TStringListBufferedOutputStream> OutputStream;
+        THolder<TShellCommand> ShellCommand_;
+        THolder<TStringListBufferedInputStream> InputStream_;
+        THolder<TStringListBufferedOutputStream> OutputStream_;
 
-        TString CurrentRecord;
+        TString CurrentRecord_;
     };
 
     class TStreamingOutput: public TBoxedValue {
     public:
         TStreamingOutput(const TStreamingParams& params, const IValueBuilder* valueBuilder, TSourcePosition pos)
-            : StreamingParams(params)
-            , ValueBuilder(valueBuilder)
+            : StreamingParams_(params)
+            , ValueBuilder_(valueBuilder)
             , Pos_(pos)
         {
         }
@@ -623,29 +623,29 @@ namespace {
 
     private:
         EFetchStatus Fetch(TUnboxedValue& result) override {
-            if (IsFinished) {
+            if (IsFinished_) {
                 return EFetchStatus::Finish;
             }
 
-            if (!Iterator) {
-                Iterator.Reset(new TStreamingOutputListIterator(StreamingParams, ValueBuilder, Pos_));
+            if (!Iterator_) {
+                Iterator_.Reset(new TStreamingOutputListIterator(StreamingParams_, ValueBuilder_, Pos_));
             }
 
-            auto ret = Iterator->Fetch(result);
+            auto ret = Iterator_->Fetch(result);
 
             if (ret == EFetchStatus::Finish) {
-                IsFinished = true;
-                Iterator.Reset();
+                IsFinished_ = true;
+                Iterator_.Reset();
             }
 
             return ret;
         }
 
-        TStreamingParams StreamingParams;
-        const IValueBuilder* ValueBuilder;
+        TStreamingParams StreamingParams_;
+        const IValueBuilder* ValueBuilder_;
         TSourcePosition Pos_;
-        bool IsFinished = false;
-        THolder<TStreamingOutputListIterator> Iterator;
+        bool IsFinished_ = false;
+        THolder<TStreamingOutputListIterator> Iterator_;
     };
 
     class TStreamingScriptOutput: public TStreamingOutput {
@@ -653,14 +653,14 @@ namespace {
         TStreamingScriptOutput(const TStreamingParams& params, const IValueBuilder* valueBuilder,
                                TSourcePosition pos, const TString& script, const TString& scriptFilename)
             : TStreamingOutput(params, valueBuilder, pos)
-            , ScriptFileHandle(scriptFilename)
+            , ScriptFileHandle_(scriptFilename)
         {
             auto scriptStripped = StripBeforeShebang(script);
-            ScriptFileHandle.Write(scriptStripped.data(), scriptStripped.size());
-            ScriptFileHandle.Close();
+            ScriptFileHandle_.Write(scriptStripped.data(), scriptStripped.size());
+            ScriptFileHandle_.Close();
 
-            if (Chmod(ScriptFileHandle.Name().c_str(), MODE0755) != 0) {
-                ythrow yexception() << "Chmod failed for script file:" << ScriptFileHandle.Name()
+            if (Chmod(ScriptFileHandle_.Name().c_str(), MODE0755) != 0) {
+                ythrow yexception() << "Chmod failed for script file:" << ScriptFileHandle_.Name()
                                     << " with error: " << LastSystemErrorText();
             }
         }
@@ -679,7 +679,7 @@ namespace {
             return script;
         }
 
-        TTempFileHandle ScriptFileHandle;
+        TTempFileHandle ScriptFileHandle_;
     };
 
     class TStreamingProcess: public TBoxedValue {
diff --git a/yql/essentials/udfs/common/top/top_udf.cpp b/yql/essentials/udfs/common/top/top_udf.cpp
index 7d722ea2ea5..a9b3d3e430d 100644
--- a/yql/essentials/udfs/common/top/top_udf.cpp
+++ b/yql/essentials/udfs/common/top/top_udf.cpp
@@ -65,106 +65,106 @@ struct TGenericPairCompare {
 
 template <typename TValue, typename TCompare, typename TAllocator>
 class TTopKeeperContainer {
-    TTopKeeper<TValue, TCompare, true, TAllocator> Keeper;
+    TTopKeeper<TValue, TCompare, true, TAllocator> Keeper_;
     using TOrderedSet = TMultiSet<TValue, TCompare, TAllocator>;
-    TMaybe<TOrderedSet> OrderedSet;
-    size_t MaxSize = 0;
-    bool Finalized = false;
-    TCompare Compare;
+    TMaybe<TOrderedSet> OrderedSet_;
+    size_t MaxSize_ = 0;
+    bool Finalized_ = false;
+    TCompare Compare_;
 public:
     explicit TTopKeeperContainer(TCompare compare)
-        : Keeper(0, compare)
-        , Compare(compare)
+        : Keeper_(0, compare)
+        , Compare_(compare)
     {}
 
     TVector<TValue, TAllocator> GetInternal() {
-        if (OrderedSet) {
+        if (OrderedSet_) {
             TVector<TValue, TAllocator> result;
-            std::copy(OrderedSet->begin(), OrderedSet->end(), std::back_inserter(result));
+            std::copy(OrderedSet_->begin(), OrderedSet_->end(), std::back_inserter(result));
             return result;
         }
-        Finalized = true;
-        return Keeper.GetInternal();
+        Finalized_ = true;
+        return Keeper_.GetInternal();
     }
 
     void Insert(const TValue& value) {
-        if (MaxSize == 0) {
+        if (MaxSize_ == 0) {
             return;
         }
-        if (Finalized && !OrderedSet) {
-            const auto& items = Keeper.Extract();
-            OrderedSet = TOrderedSet{items.begin(), items.end(), Compare};
+        if (Finalized_ && !OrderedSet_) {
+            const auto& items = Keeper_.Extract();
+            OrderedSet_ = TOrderedSet{items.begin(), items.end(), Compare_};
         }
-        if (OrderedSet) {
-            if (OrderedSet->size() < MaxSize) {
-                OrderedSet->insert(value);
+        if (OrderedSet_) {
+            if (OrderedSet_->size() < MaxSize_) {
+                OrderedSet_->insert(value);
                 return;
             }
-            Y_ENSURE(OrderedSet->size() == MaxSize);
-            Y_ENSURE(!OrderedSet->empty());
-            auto last = --OrderedSet->end();
-            if (Compare(value, *last)) {
-                OrderedSet->erase(last);
-                OrderedSet->insert(value);
+            Y_ENSURE(OrderedSet_->size() == MaxSize_);
+            Y_ENSURE(!OrderedSet_->empty());
+            auto last = --OrderedSet_->end();
+            if (Compare_(value, *last)) {
+                OrderedSet_->erase(last);
+                OrderedSet_->insert(value);
             }
             return;
         }
-        Keeper.Insert(value);
+        Keeper_.Insert(value);
     }
 
     bool IsEmpty() const {
-        return OrderedSet ? OrderedSet->empty() : Keeper.IsEmpty();
+        return OrderedSet_ ? OrderedSet_->empty() : Keeper_.IsEmpty();
     }
 
     size_t GetSize() const {
-        return OrderedSet ? OrderedSet->size() : Keeper.GetSize();
+        return OrderedSet_ ? OrderedSet_->size() : Keeper_.GetSize();
     }
 
     size_t GetMaxSize() const {
-        return MaxSize;
+        return MaxSize_;
     }
 
     void SetMaxSize(size_t newMaxSize) {
-        MaxSize = newMaxSize;
-        if (Finalized && !OrderedSet) {
-            auto items = Keeper.Extract();
+        MaxSize_ = newMaxSize;
+        if (Finalized_ && !OrderedSet_) {
+            auto items = Keeper_.Extract();
             auto begin = items.begin();
-            auto end = begin + Min(MaxSize, items.size());
-            OrderedSet = TOrderedSet{begin, end, Compare};
+            auto end = begin + Min(MaxSize_, items.size());
+            OrderedSet_ = TOrderedSet{begin, end, Compare_};
         }
-        if (OrderedSet) {
-            while (OrderedSet->size() > MaxSize) {
-                auto last = --OrderedSet->end();
-                OrderedSet->erase(last);
+        if (OrderedSet_) {
+            while (OrderedSet_->size() > MaxSize_) {
+                auto last = --OrderedSet_->end();
+                OrderedSet_->erase(last);
             }
             return;
         }
 
-        Keeper.SetMaxSize(MaxSize);
+        Keeper_.SetMaxSize(MaxSize_);
     }
 };
 
 template <typename TCompare>
 class TTopKeeperWrapperBase {
 protected:
-    TTopKeeperContainer<TUnboxedValue, TCompare, TUnboxedValue::TAllocator> Keeper;
+    TTopKeeperContainer<TUnboxedValue, TCompare, TUnboxedValue::TAllocator> Keeper_;
 
 protected:
     explicit TTopKeeperWrapperBase(TCompare compare)
-        : Keeper(compare)
+        : Keeper_(compare)
     {}
 
     void Init(const TUnboxedValuePod& value, ui32 maxSize) {
-        Keeper.SetMaxSize(maxSize);
+        Keeper_.SetMaxSize(maxSize);
         AddValue(value);
     }
 
     void Merge(TTopKeeperWrapperBase& left, TTopKeeperWrapperBase& right) {
-        Keeper.SetMaxSize(left.Keeper.GetMaxSize());
-        for (const auto& item : left.Keeper.GetInternal()) {
+        Keeper_.SetMaxSize(left.Keeper_.GetMaxSize());
+        for (const auto& item : left.Keeper_.GetInternal()) {
             AddValue(item);
         }
-        for (const auto& item : right.Keeper.GetInternal()) {
+        for (const auto& item : right.Keeper_.GetInternal()) {
             AddValue(item);
         }
     }
@@ -173,7 +173,7 @@ protected:
         auto maxSize = serialized.GetElement(0).Get<ui32>();
         auto list = serialized.GetElement(1);
 
-        Keeper.SetMaxSize(maxSize);
+        Keeper_.SetMaxSize(maxSize);
         const auto listIter = list.GetListIterator();
         for (TUnboxedValue current; listIter.Next(current);) {
             AddValue(current);
@@ -182,20 +182,20 @@ protected:
 
 public:
     void AddValue(const TUnboxedValuePod& value) {
-        Keeper.Insert(TUnboxedValuePod(value));
+        Keeper_.Insert(TUnboxedValuePod(value));
     }
 
     TUnboxedValue Serialize(const IValueBuilder* builder) {
         TUnboxedValue* values = nullptr;
-        auto list = builder->NewArray(Keeper.GetSize(), values);
+        auto list = builder->NewArray(Keeper_.GetSize(), values);
 
-        for (const auto& item : Keeper.GetInternal()) {
+        for (const auto& item : Keeper_.GetInternal()) {
             *values++ = item;
         }
 
         TUnboxedValue* items = nullptr;
         auto result = builder->NewArray(2U, items);
-        items[0] = TUnboxedValuePod((ui32)Keeper.GetMaxSize());
+        items[0] = TUnboxedValuePod((ui32)Keeper_.GetMaxSize());
         items[1] = list;
 
         return result;
@@ -203,9 +203,9 @@ public:
 
     TUnboxedValue GetResult(const IValueBuilder* builder) {
         TUnboxedValue* values = nullptr;
-        auto list = builder->NewArray(Keeper.GetSize(), values);
+        auto list = builder->NewArray(Keeper_.GetSize(), values);
 
-        for (const auto& item : Keeper.GetInternal()) {
+        for (const auto& item : Keeper_.GetInternal()) {
             *values++ = item;
         }
         return list;
@@ -215,24 +215,24 @@ public:
 template <typename TCompare>
 class TTopKeeperPairWrapperBase {
 protected:
-    TTopKeeperContainer<TUnboxedValuePair, TCompare, TStdAllocatorForUdf<TUnboxedValuePair>> Keeper;
+    TTopKeeperContainer<TUnboxedValuePair, TCompare, TStdAllocatorForUdf<TUnboxedValuePair>> Keeper_;
 
 protected:
     explicit TTopKeeperPairWrapperBase(TCompare compare)
-        : Keeper(compare)
+        : Keeper_(compare)
     {}
 
     void Init(const TUnboxedValuePod& key, const TUnboxedValuePod& payload, ui32 maxSize) {
-        Keeper.SetMaxSize(maxSize);
+        Keeper_.SetMaxSize(maxSize);
         AddValue(key, payload);
     }
 
     void Merge(TTopKeeperPairWrapperBase& left, TTopKeeperPairWrapperBase& right) {
-        Keeper.SetMaxSize(left.Keeper.GetMaxSize());
-        for (const auto& item : left.Keeper.GetInternal()) {
+        Keeper_.SetMaxSize(left.Keeper_.GetMaxSize());
+        for (const auto& item : left.Keeper_.GetInternal()) {
             AddValue(item.first, item.second);
         }
-        for (const auto& item : right.Keeper.GetInternal()) {
+        for (const auto& item : right.Keeper_.GetInternal()) {
             AddValue(item.first, item.second);
         }
     }
@@ -241,7 +241,7 @@ protected:
         auto maxSize = serialized.GetElement(0).Get<ui32>();
         auto list = serialized.GetElement(1);
 
-        Keeper.SetMaxSize(maxSize);
+        Keeper_.SetMaxSize(maxSize);
         const auto listIter = list.GetListIterator();
         for (TUnboxedValue current; listIter.Next(current);) {
             AddValue(current.GetElement(0), current.GetElement(1));
@@ -250,14 +250,14 @@ protected:
 
 public:
     void AddValue(const TUnboxedValuePod& key, const TUnboxedValuePod& payload) {
-        Keeper.Insert(std::make_pair(TUnboxedValuePod(key), TUnboxedValuePod(payload)));
+        Keeper_.Insert(std::make_pair(TUnboxedValuePod(key), TUnboxedValuePod(payload)));
     }
 
     TUnboxedValue Serialize(const IValueBuilder* builder) {
         TUnboxedValue* values = nullptr;
-        auto list = builder->NewArray(Keeper.GetSize(), values);
+        auto list = builder->NewArray(Keeper_.GetSize(), values);
 
-        for (const auto& item : Keeper.GetInternal()) {
+        for (const auto& item : Keeper_.GetInternal()) {
             TUnboxedValue* items = nullptr;
             auto pair = builder->NewArray(2U, items);
             items[0] = item.first;
@@ -267,7 +267,7 @@ public:
 
         TUnboxedValue* items = nullptr;
         auto result = builder->NewArray(2U, items);
-        items[0] = TUnboxedValuePod((ui32)Keeper.GetMaxSize());
+        items[0] = TUnboxedValuePod((ui32)Keeper_.GetMaxSize());
         items[1] = list;
 
         return result;
@@ -275,9 +275,9 @@ public:
 
     TUnboxedValue GetResult(const IValueBuilder* builder) {
         TUnboxedValue* values = nullptr;
-        auto list = builder->NewArray(Keeper.GetSize(), values);
+        auto list = builder->NewArray(Keeper_.GetSize(), values);
 
-        for (const auto& item : Keeper.GetInternal()) {
+        for (const auto& item : Keeper_.GetInternal()) {
             *values++ = item.second;
         }
         return list;
diff --git a/yql/essentials/udfs/common/topfreq/static/topfreq_udf.h b/yql/essentials/udfs/common/topfreq/static/topfreq_udf.h
index d6df05a048f..93f8c3fd587 100644
--- a/yql/essentials/udfs/common/topfreq/static/topfreq_udf.h
+++ b/yql/essentials/udfs/common/topfreq/static/topfreq_udf.h
@@ -42,7 +42,7 @@ namespace {
 
 
     template <EDataSlot Slot>
-    class TTopFreq_CreateData: public TBoxedValue {
+    class TTopFreqCreateData: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder*, const TUnboxedValuePod* args) const {
             ui32 minSize = args[1].Get<ui32>();
@@ -50,7 +50,7 @@ namespace {
         }
     };
 
-    class TTopFreq_Create: public TBoxedValue {
+    class TTopFreqCreate: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder*, const TUnboxedValuePod* args) const {
             ui32 minSize = args[1].Get<ui32>();
@@ -58,7 +58,7 @@ namespace {
         }
 
     public:
-        TTopFreq_Create(IHash::TPtr hash, IEquate::TPtr equate)
+        TTopFreqCreate(IHash::TPtr hash, IEquate::TPtr equate)
             : Hash_(hash)
             , Equate_(equate)
         {}
@@ -69,7 +69,7 @@ namespace {
     };
 
     template <EDataSlot Slot>
-    class TTopFreq_AddValueData: public TBoxedValue {
+    class TTopFreqAddValueData: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder*, const TUnboxedValuePod* args) const {
             const auto topFreq = GetTopFreqResourceData<Slot>(args[0]);
@@ -78,7 +78,7 @@ namespace {
         }
     };
 
-    class TTopFreq_AddValue: public TBoxedValue {
+    class TTopFreqAddValue: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder*, const TUnboxedValuePod* args) const {
             const auto topFreq = GetTopFreqResource(args[0]);
@@ -88,14 +88,14 @@ namespace {
     };
 
     template <EDataSlot Slot>
-    class TTopFreq_SerializeData: public TBoxedValue {
+    class TTopFreqSerializeData: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder* valueBuilder, const TUnboxedValuePod* args) const {
             return GetTopFreqResourceData<Slot>(args[0])->Get()->Serialize(valueBuilder);
         }
     };
 
-    class TTopFreq_Serialize: public TBoxedValue {
+    class TTopFreqSerialize: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder* valueBuilder, const TUnboxedValuePod* args) const {
             return GetTopFreqResource(args[0])->Get()->Serialize(valueBuilder);
@@ -103,21 +103,21 @@ namespace {
     };
 
     template <EDataSlot Slot>
-    class TTopFreq_DeserializeData: public TBoxedValue {
+    class TTopFreqDeserializeData: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder*, const TUnboxedValuePod* args) const {
             return TUnboxedValuePod(new TTopFreqResourceData<Slot>(args[0]));
         }
     };
 
-    class TTopFreq_Deserialize: public TBoxedValue {
+    class TTopFreqDeserialize: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder*, const TUnboxedValuePod* args) const {
             return TUnboxedValuePod(new TTopFreqResource(args[0], Hash_, Equate_));
         }
 
     public:
-        TTopFreq_Deserialize(IHash::TPtr hash, IEquate::TPtr equate)
+        TTopFreqDeserialize(IHash::TPtr hash, IEquate::TPtr equate)
             : Hash_(hash)
             , Equate_(equate)
         {}
@@ -128,7 +128,7 @@ namespace {
     };
 
     template <EDataSlot Slot>
-    class TTopFreq_MergeData: public TBoxedValue {
+    class TTopFreqMergeData: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder*, const TUnboxedValuePod* args) const {
             const auto topFreq0 = GetTopFreqResourceData<Slot>(args[0]);
@@ -137,7 +137,7 @@ namespace {
         }
     };
 
-    class TTopFreq_Merge: public TBoxedValue {
+    class TTopFreqMerge: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder*, const TUnboxedValuePod* args) const {
             const auto topFreq0 = GetTopFreqResource(args[0]);
@@ -146,7 +146,7 @@ namespace {
         }
 
     public:
-        TTopFreq_Merge(IHash::TPtr hash, IEquate::TPtr equate)
+        TTopFreqMerge(IHash::TPtr hash, IEquate::TPtr equate)
             : Hash_(hash)
             , Equate_(equate)
         {}
@@ -157,14 +157,14 @@ namespace {
     };
 
     template <EDataSlot Slot>
-    class TTopFreq_GetData: public TBoxedValue {
+    class TTopFreqGetData: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder* valueBuilder, const TUnboxedValuePod* args) const {
             return GetTopFreqResourceData<Slot>(args[0])->Get()->Get(valueBuilder, args[1].Get<ui32>());
         }
     };
 
-    class TTopFreq_Get: public TBoxedValue {
+    class TTopFreqGet: public TBoxedValue {
     private:
         TUnboxedValue Run(const IValueBuilder* valueBuilder, const TUnboxedValuePod* args) const {
             return GetTopFreqResource(args[0])->Get()->Get(valueBuilder, args[1].Get<ui32>());
@@ -192,12 +192,12 @@ namespace {
         builder.Implementation(new operation<EDataSlot::slot>); \
         break;
 
-#define MAKE_CREATE(slot, ...) MAKE_IMPL(TTopFreq_CreateData, slot)
-#define MAKE_ADD_VALUE(slot, ...) MAKE_IMPL(TTopFreq_AddValueData, slot)
-#define MAKE_SERIALIZE(slot, ...) MAKE_IMPL(TTopFreq_SerializeData, slot)
-#define MAKE_DESERIALIZE(slot, ...) MAKE_IMPL(TTopFreq_DeserializeData, slot)
-#define MAKE_MERGE(slot, ...) MAKE_IMPL(TTopFreq_MergeData, slot)
-#define MAKE_GET(slot, ...) MAKE_IMPL(TTopFreq_GetData, slot)
+#define MAKE_CREATE(slot, ...) MAKE_IMPL(TTopFreqCreateData, slot)
+#define MAKE_ADD_VALUE(slot, ...) MAKE_IMPL(TTopFreqAddValueData, slot)
+#define MAKE_SERIALIZE(slot, ...) MAKE_IMPL(TTopFreqSerializeData, slot)
+#define MAKE_DESERIALIZE(slot, ...) MAKE_IMPL(TTopFreqDeserializeData, slot)
+#define MAKE_MERGE(slot, ...) MAKE_IMPL(TTopFreqMergeData, slot)
+#define MAKE_GET(slot, ...) MAKE_IMPL(TTopFreqGetData, slot)
 
 #define MAKE_TYPE(slot, ...)                                       \
     case EDataSlot::slot:                                          \
@@ -296,7 +296,7 @@ namespace {
 
                     if (!typesOnly) {
                         if (isGeneric) {
-                            builder.Implementation(new TTopFreq_Create(hash, equate));
+                            builder.Implementation(new TTopFreqCreate(hash, equate));
                         } else {
                             switch (*slot) {
                             UDF_TYPE_ID_MAP(MAKE_CREATE)
@@ -311,7 +311,7 @@ namespace {
 
                     if (!typesOnly) {
                         if (isGeneric) {
-                            builder.Implementation(new TTopFreq_AddValue);
+                            builder.Implementation(new TTopFreqAddValue);
                         } else {
                             switch (*slot) {
                             UDF_TYPE_ID_MAP(MAKE_ADD_VALUE)
@@ -326,7 +326,7 @@ namespace {
 
                     if (!typesOnly) {
                         if (isGeneric) {
-                            builder.Implementation(new TTopFreq_Merge(hash, equate));
+                            builder.Implementation(new TTopFreqMerge(hash, equate));
                         } else {
                             switch (*slot) {
                             UDF_TYPE_ID_MAP(MAKE_MERGE)
@@ -341,7 +341,7 @@ namespace {
 
                     if (!typesOnly) {
                         if (isGeneric) {
-                            builder.Implementation(new TTopFreq_Serialize);
+                            builder.Implementation(new TTopFreqSerialize);
                         } else {
                             switch (*slot) {
                             UDF_TYPE_ID_MAP(MAKE_SERIALIZE)
@@ -356,7 +356,7 @@ namespace {
 
                     if (!typesOnly) {
                         if (isGeneric) {
-                            builder.Implementation(new TTopFreq_Deserialize(hash, equate));
+                            builder.Implementation(new TTopFreqDeserialize(hash, equate));
                         } else {
                             switch (*slot) {
                             UDF_TYPE_ID_MAP(MAKE_DESERIALIZE)
@@ -374,7 +374,7 @@ namespace {
 
                     if (!typesOnly) {
                         if (isGeneric) {
-                            builder.Implementation(new TTopFreq_Get);
+                            builder.Implementation(new TTopFreqGet);
                         } else {
                             switch (*slot) {
                             UDF_TYPE_ID_MAP(MAKE_GET)
diff --git a/yql/essentials/udfs/common/url_base/lib/url_parse.cpp b/yql/essentials/udfs/common/url_base/lib/url_parse.cpp
index 63015dadc67..34485970ee0 100644
--- a/yql/essentials/udfs/common/url_base/lib/url_parse.cpp
+++ b/yql/essentials/udfs/common/url_base/lib/url_parse.cpp
@@ -3,7 +3,7 @@
 #define FIELD_ADD(name) structBuilder->AddField(#name, optionalStringType, &urlParseIndexes.name);
 #define FIELD_FILL(name) \
     if (value.FldIsSet(TUri::Field##name)) { \
-        fields[UrlParseIndexes.name] = valueBuilder->NewString(value.GetField(TUri::Field##name)); \
+        fields[UrlParseIndexes_.name] = valueBuilder->NewString(value.GetField(TUri::Field##name)); \
     }
 
 namespace NUrlUdf {
@@ -15,13 +15,13 @@ namespace NUrlUdf {
         const IValueBuilder* valueBuilder,
         const TUnboxedValuePod* args) const {
         TUri value;
-        const auto ParseError = value.ParseAbs(args[0].AsStringRef(), ParseFlags);
+        const auto ParseError = value.ParseAbs(args[0].AsStringRef(), ParseFlags_);
         TUnboxedValue* fields = nullptr;
         const auto result = valueBuilder->NewArray(FieldsCount, fields);
         if (ParseError == TUri::ParsedOK) {
             FIELD_MAP(FIELD_FILL)
         } else {
-            fields[UrlParseIndexes.ParseError] = valueBuilder->NewString(TStringBuilder() << ParseError);
+            fields[UrlParseIndexes_.ParseError] = valueBuilder->NewString(TStringBuilder() << ParseError);
         }
         return result;
     }
diff --git a/yql/essentials/udfs/common/url_base/lib/url_parse.h b/yql/essentials/udfs/common/url_base/lib/url_parse.h
index b0a1679d1e9..e25e79c5196 100644
--- a/yql/essentials/udfs/common/url_base/lib/url_parse.h
+++ b/yql/essentials/udfs/common/url_base/lib/url_parse.h
@@ -28,8 +28,8 @@ namespace NUrlUdf {
     class TParse: public TBoxedValue {
     public:
         TParse(const TUrlParseIndexes& UrlParseIndexes)
-            : UrlParseIndexes(UrlParseIndexes)
-            , ParseFlags(TUri::FeaturesRecommended)
+            : UrlParseIndexes_(UrlParseIndexes)
+            , ParseFlags_(TUri::FeaturesRecommended)
         {
         }
 
@@ -51,8 +51,8 @@ namespace NUrlUdf {
             bool typesOnly);
 
     private:
-        const TUrlParseIndexes UrlParseIndexes;
-        const NUri::TParseFlags ParseFlags;
+        const TUrlParseIndexes UrlParseIndexes_;
+        const NUri::TParseFlags ParseFlags_;
 
         static constexpr ui32 FieldsCount = sizeof(TUrlParseIndexes) / sizeof(ui32);
     };
diff --git a/yql/essentials/udfs/common/vector/vector_udf.cpp b/yql/essentials/udfs/common/vector/vector_udf.cpp
index e8b01e5a05c..f1afafa7217 100644
--- a/yql/essentials/udfs/common/vector/vector_udf.cpp
+++ b/yql/essentials/udfs/common/vector/vector_udf.cpp
@@ -10,37 +10,37 @@ namespace {
 
 class TVector {
 private:
-    std::vector<TUnboxedValue, TUnboxedValue::TAllocator> Vector;
+    std::vector<TUnboxedValue, TUnboxedValue::TAllocator> Vector_;
 
 public:
     TVector()
-        : Vector()
+        : Vector_()
     {}
 
     TUnboxedValue GetResult(const IValueBuilder* builder) {
         TUnboxedValue* values = nullptr;
-        auto list = builder->NewArray(Vector.size(), values);
-        std::copy(Vector.begin(), Vector.end(), values);
+        auto list = builder->NewArray(Vector_.size(), values);
+        std::copy(Vector_.begin(), Vector_.end(), values);
 
         return list;
     }
 
     void Emplace(const ui64 index, const TUnboxedValuePod& value) {
-        if (index < Vector.size()) {
-            Vector[index] = value;
+        if (index < Vector_.size()) {
+            Vector_[index] = value;
         } else {
-            Vector.push_back(value);
+            Vector_.push_back(value);
         }
     }
 
     void Swap(const ui64 a, const ui64 b) {
-        if (a < Vector.size() && b < Vector.size()) {
-            std::swap(Vector[a], Vector[b]);
+        if (a < Vector_.size() && b < Vector_.size()) {
+            std::swap(Vector_[a], Vector_[b]);
         }
     }
 
     void Reserve(ui64 expectedSize) {
-        Vector.reserve(expectedSize);
+        Vector_.reserve(expectedSize);
     }
 };
 
diff --git a/yql/essentials/udfs/common/yson2/yson2_udf.cpp b/yql/essentials/udfs/common/yson2/yson2_udf.cpp
index 997b0cecf1a..42f19d144e2 100644
--- a/yql/essentials/udfs/common/yson2/yson2_udf.cpp
+++ b/yql/essentials/udfs/common/yson2/yson2_udf.cpp
@@ -102,25 +102,25 @@ template <TConverterPtr Converter>
 class TLazyConveterT : public TManagedBoxedValue {
 public:
     TLazyConveterT(TUnboxedValue&& original, const IValueBuilder* valueBuilder, const TSourcePosition& pos)
-        : Original(std::move(original)), ValueBuilder(valueBuilder), Pos_(pos)
+        : Original_(std::move(original)), ValueBuilder_(valueBuilder), Pos_(pos)
     {}
 private:
     template <bool NoSwap>
     class TIterator: public TManagedBoxedValue {
     public:
         TIterator(TUnboxedValue&& original, const IValueBuilder* valueBuilder, const TSourcePosition& pos)
-            : Original(std::move(original)), ValueBuilder(valueBuilder), Pos_(pos)
+            : Original_(std::move(original)), ValueBuilder_(valueBuilder), Pos_(pos)
         {}
 
     private:
         bool Skip() final {
-            return Original.Skip();
+            return Original_.Skip();
         }
 
         bool Next(TUnboxedValue& value) final {
-            if (Original.Next(value)) {
+            if (Original_.Next(value)) {
                 if constexpr (!NoSwap) {
-                    value = Converter(value.Release(), ValueBuilder, Pos_);
+                    value = Converter(value.Release(), ValueBuilder_, Pos_);
                 }
                 return true;
             }
@@ -128,75 +128,75 @@ private:
         }
 
         bool NextPair(TUnboxedValue& key, TUnboxedValue& payload) final {
-            if (Original.NextPair(key, payload)) {
+            if (Original_.NextPair(key, payload)) {
                 if constexpr (NoSwap) {
-                    payload = Converter(payload.Release(), ValueBuilder, Pos_);
+                    payload = Converter(payload.Release(), ValueBuilder_, Pos_);
                 } else {
-                    key = Converter(key.Release(), ValueBuilder, Pos_);
+                    key = Converter(key.Release(), ValueBuilder_, Pos_);
                 }
                 return true;
             }
             return false;
         }
 
-        const TUnboxedValue Original;
-        const IValueBuilder *const ValueBuilder;
+        const TUnboxedValue Original_;
+        const IValueBuilder *const ValueBuilder_;
         const TSourcePosition Pos_;
     };
 
     ui64 GetDictLength() const final {
-        return Original.GetDictLength();
+        return Original_.GetDictLength();
     }
 
     ui64 GetListLength() const final {
-        return Original.GetListLength();
+        return Original_.GetListLength();
     }
 
     bool HasFastListLength() const final {
-        return Original.HasFastListLength();
+        return Original_.HasFastListLength();
     }
 
     bool HasDictItems() const final {
-        return Original.HasDictItems();
+        return Original_.HasDictItems();
     }
 
     bool HasListItems() const final {
-        return Original.HasListItems();
+        return Original_.HasListItems();
     }
 
     TUnboxedValue GetListIterator() const final {
-        return TUnboxedValuePod(new TIterator<false>(Original.GetListIterator(), ValueBuilder, Pos_));
+        return TUnboxedValuePod(new TIterator<false>(Original_.GetListIterator(), ValueBuilder_, Pos_));
     }
 
     TUnboxedValue GetDictIterator() const final {
-        return TUnboxedValuePod(new TIterator<true>(Original.GetDictIterator(), ValueBuilder, Pos_));
+        return TUnboxedValuePod(new TIterator<true>(Original_.GetDictIterator(), ValueBuilder_, Pos_));
     }
 
     TUnboxedValue GetKeysIterator() const final {
-        return TUnboxedValuePod(new TIterator<true>(Original.GetKeysIterator(), ValueBuilder, Pos_));
+        return TUnboxedValuePod(new TIterator<true>(Original_.GetKeysIterator(), ValueBuilder_, Pos_));
     }
 
     TUnboxedValue GetPayloadsIterator() const override {
-        return TUnboxedValuePod(new TIterator<false>(Original.GetPayloadsIterator(), ValueBuilder, Pos_));
+        return TUnboxedValuePod(new TIterator<false>(Original_.GetPayloadsIterator(), ValueBuilder_, Pos_));
     }
 
     bool Contains(const TUnboxedValuePod& key) const final {
-        return Original.Contains(key);
+        return Original_.Contains(key);
     }
 
     TUnboxedValue Lookup(const TUnboxedValuePod& key) const final {
-        if (auto lookup = Original.Lookup(key)) {
-            return Converter(lookup.Release().GetOptionalValue(), ValueBuilder, Pos_).MakeOptional();
+        if (auto lookup = Original_.Lookup(key)) {
+            return Converter(lookup.Release().GetOptionalValue(), ValueBuilder_, Pos_).MakeOptional();
         }
         return {};
     }
 
     bool IsSortedDict() const final {
-        return Original.IsSortedDict();
+        return Original_.IsSortedDict();
     }
 
-    const TUnboxedValue Original;
-    const IValueBuilder *const ValueBuilder;
+    const TUnboxedValue Original_;
+    const IValueBuilder *const ValueBuilder_;
     const TSourcePosition Pos_;
 };