YQL-20086 public

commit_hash:95a833af8fda8e357f7f0100b4e3bfd15dafe3e1

41 files changed, 866 insertions, 865 deletions

diff --git a/yql/essentials/minikql/comp_nodes/mkql_decimal_div.cpp b/yql/essentials/minikql/comp_nodes/mkql_decimal_div.cpp
index be561df7e3f..54aa99bbcff 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_decimal_div.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_decimal_div.cpp
@@ -71,9 +71,9 @@ public:
 
             block = good;
 
-            const auto muldiv = CallInst::Create(func, { GetterForInt128(left, block), NDecimal::GenConstant(Divider, context), GetterForInt128(right, block) }, "mul_and_div", block);
+            const auto muldiv = CallInst::Create(func, { GetterForInt128(left, block), NDecimal::GenConstant(Divider_, context), GetterForInt128(right, block) }, "mul_and_div", block);
 
-            const auto ok = NDecimal::GenInBounds(muldiv, NDecimal::GenConstant(-Bound, context), NDecimal::GenConstant(+Bound, context), block);
+            const auto ok = NDecimal::GenInBounds(muldiv, NDecimal::GenConstant(-Bound_, context), NDecimal::GenConstant(+Bound_, context), block);
             const auto nan = NDecimal::GenIsNonComparable(muldiv, context, block);
             const auto plus = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_SGT, muldiv, ConstantInt::get(muldiv->getType(), 0), "plus", block);
 
@@ -87,9 +87,9 @@ public:
             block = done;
             return result;
         } else {
-            const auto muldiv = CallInst::Create(func, { GetterForInt128(left, block), NDecimal::GenConstant(Divider, context), GetterForInt128(right, block) }, "mul_and_div", block);
+            const auto muldiv = CallInst::Create(func, { GetterForInt128(left, block), NDecimal::GenConstant(Divider_, context), GetterForInt128(right, block) }, "mul_and_div", block);
 
-            const auto ok = NDecimal::GenInBounds(muldiv, NDecimal::GenConstant(-Bound, context), NDecimal::GenConstant(+Bound, context), block);
+            const auto ok = NDecimal::GenInBounds(muldiv, NDecimal::GenConstant(-Bound_, context), NDecimal::GenConstant(+Bound_, context), block);
             const auto nan = NDecimal::GenIsNonComparable(muldiv, context, block);
             const auto plus = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_SGT, muldiv, ConstantInt::get(muldiv->getType(), 0), "plus", block);
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_decimal_mod.cpp b/yql/essentials/minikql/comp_nodes/mkql_decimal_mod.cpp
index 9703e413b71..dcc81bf284c 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_decimal_mod.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_decimal_mod.cpp
@@ -111,8 +111,8 @@ private:
 template<bool IsLeftOptional, bool IsRightOptional, typename TRight>
 class TDecimalModIntegralWrapper : public TMutableCodegeneratorNode<TDecimalModIntegralWrapper<IsLeftOptional, IsRightOptional, TRight>>, NYql::NDecimal::TDecimalRemainder<TRight> {
     typedef TMutableCodegeneratorNode<TDecimalModIntegralWrapper<IsLeftOptional, IsRightOptional, TRight>> TBaseComputation;
-    using NYql::NDecimal::TDecimalRemainder<TRight>::Divider;
-    using NYql::NDecimal::TDecimalRemainder<TRight>::Bound;
+    using NYql::NDecimal::TDecimalRemainder<TRight>::Divider_;
+    using NYql::NDecimal::TDecimalRemainder<TRight>::Bound_;
 public:
     TDecimalModIntegralWrapper(TComputationMutables& mutables, IComputationNode* left, IComputationNode* right, ui8 precision, ui8 scale)
         : TBaseComputation(mutables, EValueRepresentation::Embedded)
@@ -139,7 +139,7 @@ public:
         auto& context = ctx.Codegen.GetContext();
 
         const auto valType = Type::getInt128Ty(context);
-        const auto divider = NDecimal::GenConstant(Divider, context);
+        const auto divider = NDecimal::GenConstant(Divider_, context);
 
         const auto left = GetNodeValue(Left, ctx, block);
         const auto right = GetNodeValue(Right, ctx, block);
@@ -166,8 +166,8 @@ public:
                 static_cast<CastInst*>(new ZExtInst(GetterFor<TRight>(right, context, block), valType, "zext", block));
 
             const auto out = std::is_signed<TRight>() ?
-                NDecimal::GenOutOfBounds(cast, NDecimal::GenConstant(-Bound, context), NDecimal::GenConstant(+Bound, context), block):
-                CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_UGE, cast, NDecimal::GenConstant(Bound, context), "out", block);
+                NDecimal::GenOutOfBounds(cast, NDecimal::GenConstant(-Bound_, context), NDecimal::GenConstant(+Bound_, context), block):
+                CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_UGE, cast, NDecimal::GenConstant(Bound_, context), "out", block);
 
             const auto nul = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, cast, zero, "check", block);
 
@@ -192,8 +192,8 @@ public:
                 static_cast<CastInst*>(new ZExtInst(GetterFor<TRight>(right, context, block), valType, "zext", block));
 
             const auto out = std::is_signed<TRight>() ?
-                NDecimal::GenOutOfBounds(cast, NDecimal::GenConstant(-Bound, context), NDecimal::GenConstant(+Bound, context), block):
-                CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_UGE, cast, NDecimal::GenConstant(Bound, context), "out", block);
+                NDecimal::GenOutOfBounds(cast, NDecimal::GenConstant(-Bound_, context), NDecimal::GenConstant(+Bound_, context), block):
+                CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_UGE, cast, NDecimal::GenConstant(Bound_, context), "out", block);
 
             const auto nul = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, cast, zero, "check", block);
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_decimal_mul.cpp b/yql/essentials/minikql/comp_nodes/mkql_decimal_mul.cpp
index 80dd95b79e7..9fc646d28b6 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_decimal_mul.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_decimal_mul.cpp
@@ -48,7 +48,7 @@ public:
 
         const auto valType = Type::getInt128Ty(context);
 
-        const bool useMulAddDiv = Divider > 1;
+        const bool useMulAddDiv = Divider_ > 1;
         const auto name = useMulAddDiv ? "DecimalMulAndDivNormalDivider" : "DecimalMul";
         const auto fnType = useMulAddDiv ?
             FunctionType::get(valType, { valType, valType, valType }, false):
@@ -77,12 +77,12 @@ public:
 
             Value* muldiv;
             if (useMulAddDiv) {
-                muldiv = CallInst::Create(func, { GetterForInt128(left, block), GetterForInt128(right, block), NDecimal::GenConstant(Divider, context) }, "mul_and_div", block);
+                muldiv = CallInst::Create(func, { GetterForInt128(left, block), GetterForInt128(right, block), NDecimal::GenConstant(Divider_, context) }, "mul_and_div", block);
             } else {
                 muldiv = CallInst::Create(func, { GetterForInt128(left, block), GetterForInt128(right, block) }, "mul", block);
             }
 
-            const auto ok = NDecimal::GenInBounds(muldiv, NDecimal::GenConstant(-Bound, context), NDecimal::GenConstant(+Bound, context), block);
+            const auto ok = NDecimal::GenInBounds(muldiv, NDecimal::GenConstant(-Bound_, context), NDecimal::GenConstant(+Bound_, context), block);
             const auto nan = NDecimal::GenIsNonComparable(muldiv, context, block);
             const auto plus = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_SGT, muldiv, ConstantInt::get(muldiv->getType(), 0), "plus", block);
 
@@ -98,12 +98,12 @@ public:
         } else {
             Value* muldiv;
             if (useMulAddDiv) {
-                muldiv = CallInst::Create(func, { GetterForInt128(left, block), GetterForInt128(right, block), NDecimal::GenConstant(Divider, context) }, "mul_and_div", block);
+                muldiv = CallInst::Create(func, { GetterForInt128(left, block), GetterForInt128(right, block), NDecimal::GenConstant(Divider_, context) }, "mul_and_div", block);
             } else {
                 muldiv = CallInst::Create(func, { GetterForInt128(left, block), GetterForInt128(right, block) }, "mul", block);
             }
 
-            const auto ok = NDecimal::GenInBounds(muldiv, NDecimal::GenConstant(-Bound, context), NDecimal::GenConstant(+Bound, context), block);
+            const auto ok = NDecimal::GenInBounds(muldiv, NDecimal::GenConstant(-Bound_, context), NDecimal::GenConstant(+Bound_, context), block);
             const auto nan = NDecimal::GenIsNonComparable(muldiv, context, block);
             const auto plus = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_SGT, muldiv, ConstantInt::get(muldiv->getType(), 0), "plus", block);
 
@@ -129,7 +129,7 @@ private:
 template<bool IsLeftOptional, bool IsRightOptional, typename TRight>
 class TDecimalMulIntegralWrapper : public TMutableCodegeneratorNode<TDecimalMulIntegralWrapper<IsLeftOptional, IsRightOptional, TRight>>, NYql::NDecimal::TDecimalMultiplicator<TRight> {
     typedef TMutableCodegeneratorNode<TDecimalMulIntegralWrapper<IsLeftOptional, IsRightOptional, TRight>> TBaseComputation;
-    using NYql::NDecimal::TDecimalMultiplicator<TRight>::Bound;
+    using NYql::NDecimal::TDecimalMultiplicator<TRight>::Bound_;
 
 public:
     TDecimalMulIntegralWrapper(TComputationMutables& mutables, IComputationNode* left, IComputationNode* right, ui8 precision)
@@ -187,7 +187,7 @@ public:
                 static_cast<CastInst*>(new ZExtInst(GetterFor<TRight>(right, context, block), valType, "zext", block));
             const auto mul = CallInst::Create(func, {GetterForInt128(left, block), cast}, "div", block);
 
-            const auto ok = NDecimal::GenInBounds(mul, NDecimal::GenConstant(-Bound, context), NDecimal::GenConstant(+Bound, context), block);
+            const auto ok = NDecimal::GenInBounds(mul, NDecimal::GenConstant(-Bound_, context), NDecimal::GenConstant(+Bound_, context), block);
             const auto nan = NDecimal::GenIsNonComparable(mul, context, block);
             const auto plus = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_SGT, mul, ConstantInt::get(mul->getType(), 0), "plus", block);
 
@@ -206,7 +206,7 @@ public:
                 static_cast<CastInst*>(new ZExtInst(GetterFor<TRight>(right, context, block), valType, "zext", block));
             const auto mul = CallInst::Create(func, {GetterForInt128(left, block), cast}, "div", block);
 
-            const auto ok = NDecimal::GenInBounds(mul, NDecimal::GenConstant(-Bound, context), NDecimal::GenConstant(+Bound, context), block);
+            const auto ok = NDecimal::GenInBounds(mul, NDecimal::GenConstant(-Bound_, context), NDecimal::GenConstant(+Bound_, context), block);
             const auto nan = NDecimal::GenIsNonComparable(mul, context, block);
             const auto plus = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_SGT, mul, ConstantInt::get(mul->getType(), 0), "plus", block);
 
diff --git a/yql/essentials/minikql/comp_nodes/mkql_udf.cpp b/yql/essentials/minikql/comp_nodes/mkql_udf.cpp
index f81d4f2bc49..42fedd2c247 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_udf.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_udf.cpp
@@ -465,9 +465,9 @@ IComputationNode* WrapUdf(TCallable& callable, const TComputationNodeFactoryCont
 
     NUdf::TSourcePosition pos;
     if (callable.GetInputsCount() == 7) {
-        pos.File_ = AS_VALUE(TDataLiteral, callable.GetInput(4))->AsValue().AsStringRef();
-        pos.Row_ = AS_VALUE(TDataLiteral, callable.GetInput(5))->AsValue().Get<ui32>();
-        pos.Column_ = AS_VALUE(TDataLiteral, callable.GetInput(6))->AsValue().Get<ui32>();
+        pos.File = AS_VALUE(TDataLiteral, callable.GetInput(4))->AsValue().AsStringRef();
+        pos.Row = AS_VALUE(TDataLiteral, callable.GetInput(5))->AsValue().Get<ui32>();
+        pos.Column = AS_VALUE(TDataLiteral, callable.GetInput(6))->AsValue().Get<ui32>();
     }
 
     ui32 flags = 0;
@@ -614,9 +614,9 @@ IComputationNode* WrapScriptUdf(TCallable& callable, const TComputationNodeFacto
 
     NUdf::TSourcePosition pos;
     if (callable.GetInputsCount() == 7) {
-        pos.File_ = AS_VALUE(TDataLiteral, callable.GetInput(4))->AsValue().AsStringRef();
-        pos.Row_ = AS_VALUE(TDataLiteral, callable.GetInput(5))->AsValue().Get<ui32>();
-        pos.Column_ = AS_VALUE(TDataLiteral, callable.GetInput(6))->AsValue().Get<ui32>();
+        pos.File = AS_VALUE(TDataLiteral, callable.GetInput(4))->AsValue().AsStringRef();
+        pos.Row = AS_VALUE(TDataLiteral, callable.GetInput(5))->AsValue().Get<ui32>();
+        pos.Column = AS_VALUE(TDataLiteral, callable.GetInput(6))->AsValue().Get<ui32>();
     }
 
     const auto userType = static_cast<TType*>(userTypeNode.GetNode());
diff --git a/yql/essentials/public/decimal/yql_decimal.h b/yql/essentials/public/decimal/yql_decimal.h
index a53ed3ffa48..01740ecfe2f 100644
--- a/yql/essentials/public/decimal/yql_decimal.h
+++ b/yql/essentials/public/decimal/yql_decimal.h
@@ -212,21 +212,21 @@ struct TDecimal {
 template<typename TRight>
 class TDecimalMultiplicator {
 protected:
-    const TInt128 Bound;
+    const TInt128 Bound_;
 
 public:
     TDecimalMultiplicator(
         ui8 precision,
         ui8 scale = 0 /* unused */)
-        : Bound(GetDivider(precision))
-    { 
+        : Bound_(GetDivider(precision))
+    {
         Y_UNUSED(scale);
     }
 
     TInt128 Do(TInt128 left, TRight right) const {
-        TInt128 mul = Mul(left, right);        
+        TInt128 mul = Mul(left, right);
 
-        if (mul > -Bound && mul < +Bound)
+        if (mul > -Bound_ && mul < +Bound_)
             return mul;
 
         return IsNan(mul) ? Nan() : (mul > 0 ? +Inf() : -Inf());
@@ -236,23 +236,23 @@ public:
 template<>
 class TDecimalMultiplicator<TInt128> {
 protected:
-    const TInt128 Bound;
-    const TInt128 Divider;
+    const TInt128 Bound_;
+    const TInt128 Divider_;
 
 public:
     TDecimalMultiplicator(
         ui8 precision,
         ui8 scale)
-        : Bound(GetDivider(precision))
-        , Divider(GetDivider(scale))
+        : Bound_(GetDivider(precision))
+        , Divider_(GetDivider(scale))
     { }
 
     TInt128 Do(TInt128 left, TInt128 right) const {
-        TInt128 mul = Divider > 1 ?
-            MulAndDivNormalDivider(left, right, Divider):
+        TInt128 mul = Divider_ > 1 ?
+            MulAndDivNormalDivider(left, right, Divider_):
             Mul(left, right);
 
-        if (mul > -Bound && mul < +Bound)
+        if (mul > -Bound_ && mul < +Bound_)
             return mul;
 
         return IsNan(mul) ? Nan() : (mul > 0 ? +Inf() : -Inf());
@@ -265,7 +265,7 @@ public:
     TDecimalDivisor(
         ui8 precision = 0 /* unused */,
         ui8 scale = 0 /* unused */)
-    { 
+    {
         Y_UNUSED(precision);
         Y_UNUSED(scale);
     }
@@ -278,20 +278,20 @@ public:
 template<>
 class TDecimalDivisor<TInt128> {
 protected:
-    const TInt128 Bound;
-    const TInt128 Divider;
+    const TInt128 Bound_;
+    const TInt128 Divider_;
 
 public:
     TDecimalDivisor(
         ui8 precision,
         ui8 scale)
-        : Bound(GetDivider(precision))
-        , Divider(GetDivider(scale))
+        : Bound_(GetDivider(precision))
+        , Divider_(GetDivider(scale))
     { }
 
     TInt128 Do(TInt128 left, TInt128 right) const {
-        TInt128 div = MulAndDivNormalMultiplier(left, Divider, right);
-        if (div > -Bound && div < +Bound) {
+        TInt128 div = MulAndDivNormalMultiplier(left, Divider_, right);
+        if (div > -Bound_ && div < +Bound_) {
             return div;
         }
 
@@ -302,27 +302,27 @@ public:
 template<typename TRight>
 class TDecimalRemainder {
 protected:
-    const TInt128 Bound;
-    const TInt128 Divider;
+    const TInt128 Bound_;
+    const TInt128 Divider_;
 
 public:
     TDecimalRemainder(
         ui8 precision,
         ui8 scale)
-        : Bound(NYql::NDecimal::GetDivider(precision - scale))
-        , Divider(NYql::NDecimal::GetDivider(scale))
+        : Bound_(NYql::NDecimal::GetDivider(precision - scale))
+        , Divider_(NYql::NDecimal::GetDivider(scale))
     { }
 
     TInt128 Do(TInt128 left, TRight right) const {
         if constexpr (std::is_signed<TRight>::value) {
-            if (TInt128(right) >= +Bound || TInt128(right) <= -Bound)
+            if (TInt128(right) >= +Bound_ || TInt128(right) <= -Bound_)
                 return left;
         } else {
-            if (TInt128(right) >= Bound)
+            if (TInt128(right) >= Bound_)
                 return left;
         }
 
-        return Mod(left, Mul(Divider, right));
+        return Mod(left, Mul(Divider_, right));
     }
 };
 
diff --git a/yql/essentials/public/decimal/yql_wide_int.h b/yql/essentials/public/decimal/yql_wide_int.h
index 0f650213b90..ce0506844ed 100644
--- a/yql/essentials/public/decimal/yql_wide_int.h
+++ b/yql/essentials/public/decimal/yql_wide_int.h
@@ -25,8 +25,8 @@ private:
     static_assert(TIsSigned::value || TIsUnsigned::value, "Invalid using of TWide.");
     static_assert(sizeof(TSignedPart) == sizeof(TUnsignedPart), "Different sizes of TWide parts.");
 
-    TPart Lo;
-    THalf Hi;
+    TPart Lo_;
+    THalf Hi_;
 
     static constexpr auto FullBitSize = sizeof(TPart) << 4U;
     static constexpr auto PartBitSize = sizeof(TPart) << 3U;
@@ -43,7 +43,7 @@ private:
 
     template<typename T>
     constexpr std::enable_if_t<sizeof(T) <= sizeof(THalf), T> CastImpl() const {
-        return static_cast<T>(Lo);
+        return static_cast<T>(Lo_);
     }
 
     template<typename T>
@@ -53,12 +53,12 @@ private:
 
     template<typename T>
     constexpr std::enable_if_t<sizeof(THalf) << 1U < sizeof(T), T> CastImpl() const {
-        return (T(std::make_unsigned_t<T>(Hi) << PartBitSize)) | Lo;
+        return (T(std::make_unsigned_t<T>(Hi_) << PartBitSize)) | Lo_;
     }
 
     constexpr size_t GetBits() const {
-        size_t out = Hi ? PartBitSize : 0U;
-        for (auto up = TPart(out ? Hi : Lo); up; up >>= 1U) {
+        size_t out = Hi_ ? PartBitSize : 0U;
+        for (auto up = TPart(out ? Hi_ : Lo_); up; up >>= 1U) {
             ++out;
         }
         return out;
@@ -78,44 +78,44 @@ public:
     constexpr TWide& operator=(TWide&& rhs) = default;
 
     constexpr TWide(const TSibling& rhs)
-        : Lo(rhs.Lo), Hi(rhs.Hi)
+        : Lo_(rhs.Lo_), Hi_(rhs.Hi_)
     {}
 
     template<typename U, typename L>
     constexpr TWide(const U upper_rhs, const L lower_rhs)
-        : Lo(lower_rhs), Hi(upper_rhs)
+        : Lo_(lower_rhs), Hi_(upper_rhs)
     {}
 
     template <typename T, std::enable_if_t<std::is_integral<T>::value && sizeof(THalf) < sizeof(T), size_t> Shift = PartBitSize>
     constexpr TWide(const T rhs)
-        : Lo(rhs), Hi(rhs >> Shift)
+        : Lo_(rhs), Hi_(rhs >> Shift)
     {}
 
     template <typename T, std::enable_if_t<std::is_integral<T>::value && sizeof(T) <= sizeof(THalf), bool> Signed = std::is_signed<T>::value>
     constexpr TWide(const T rhs)
-        : Lo(rhs), Hi(Signed && rhs < 0 ? ~0 : 0)
+        : Lo_(rhs), Hi_(Signed && rhs < 0 ? ~0 : 0)
     {}
 
     template <typename T, typename TArg = std::enable_if_t<std::is_class<T>::value && std::is_same<T, THalf>::value, THalf>>
     constexpr explicit TWide(const T& rhs)
-        : Lo(rhs), Hi(TIsSigned::value && rhs < 0 ? ~0 : 0)
+        : Lo_(rhs), Hi_(TIsSigned::value && rhs < 0 ? ~0 : 0)
     {}
 
     template <typename T, std::enable_if_t<std::is_integral<T>::value && sizeof(THalf) < sizeof(T), size_t> Shift = PartBitSize>
     constexpr TWide& operator=(const T rhs) {
-        Hi = rhs >> Shift;
-        Lo = rhs;
+        Hi_ = rhs >> Shift;
+        Lo_ = rhs;
         return *this;
     }
 
     template <typename T, std::enable_if_t<std::is_integral<T>::value && sizeof(T) <= sizeof(THalf), bool> Signed = std::is_signed<T>::value>
     constexpr TWide& operator=(const T rhs) {
-        Hi = Signed && rhs < 0 ? ~0 : 0;
-        Lo = rhs;
+        Hi_ = Signed && rhs < 0 ? ~0 : 0;
+        Lo_ = rhs;
         return *this;
     }
 
-    constexpr explicit operator bool() const { return bool(Hi) || bool(Lo); }
+    constexpr explicit operator bool() const { return bool(Hi_) || bool(Lo_); }
 
     constexpr explicit operator i8()   const { return CastImpl<i8>(); }
     constexpr explicit operator ui8()  const { return CastImpl<ui8>(); }
@@ -130,35 +130,35 @@ public:
     constexpr explicit operator ui128_t() const { return CastImpl<ui128_t>(); }
 #endif
     constexpr explicit operator float() const {
-        return TIsSigned::value && Hi < 0 ? -float(-*this) : std::fma(float(Hi), std::exp2(float(PartBitSize)), float(Lo));
+        return TIsSigned::value && Hi_ < 0 ? -float(-*this) : std::fma(float(Hi_), std::exp2(float(PartBitSize)), float(Lo_));
     }
 
     constexpr explicit operator double() const {
-        return TIsSigned::value && Hi < 0 ? -double(-*this) : std::fma(double(Hi), std::exp2(double(PartBitSize)), double(Lo));
+        return TIsSigned::value && Hi_ < 0 ? -double(-*this) : std::fma(double(Hi_), std::exp2(double(PartBitSize)), double(Lo_));
     }
 
     constexpr TWide operator~() const {
-        return TWide(~Hi, ~Lo);
+        return TWide(~Hi_, ~Lo_);
     }
 
     constexpr TWide operator+() const {
-        return TWide(Hi, Lo);
+        return TWide(Hi_, Lo_);
     }
 
     constexpr TWide operator-() const {
         const auto sign = THalf(1) << PartBitSize - 1U;
-        if (TIsSigned::value && !Lo && Hi == sign)
+        if (TIsSigned::value && !Lo_ && Hi_ == sign)
             return *this;
         return ++~*this;
     }
 
     constexpr TWide& operator++() {
-        if (!++Lo) ++Hi;
+        if (!++Lo_) ++Hi_;
         return *this;
     }
 
     constexpr TWide& operator--() {
-        if (!Lo--) --Hi;
+        if (!Lo_--) --Hi_;
         return *this;
     }
 
@@ -175,48 +175,48 @@ public:
     }
 
     constexpr TWide& operator&=(const TWide& rhs) {
-        Hi &= rhs.Hi;
-        Lo &= rhs.Lo;
+        Hi_ &= rhs.Hi_;
+        Lo_ &= rhs.Lo_;
         return *this;
     }
 
     constexpr TWide& operator|=(const TWide& rhs) {
-        Hi |= rhs.Hi;
-        Lo |= rhs.Lo;
+        Hi_ |= rhs.Hi_;
+        Lo_ |= rhs.Lo_;
         return *this;
     }
 
     constexpr TWide& operator^=(const TWide& rhs) {
-        Hi ^= rhs.Hi;
-        Lo ^= rhs.Lo;
+        Hi_ ^= rhs.Hi_;
+        Lo_ ^= rhs.Lo_;
         return *this;
     }
 
     constexpr TWide& operator+=(const TWide& rhs) {
-        const auto l = Lo;
-        Lo += rhs.Lo;
-        Hi += rhs.Hi;
-        if (l > Lo) ++Hi;
+        const auto l = Lo_;
+        Lo_ += rhs.Lo_;
+        Hi_ += rhs.Hi_;
+        if (l > Lo_) ++Hi_;
         return *this;
     }
 
     constexpr TWide& operator-=(const TWide& rhs) {
-        const auto l = Lo;
-        Lo -= rhs.Lo;
-        Hi -= rhs.Hi;
-        if (l < Lo) --Hi;
+        const auto l = Lo_;
+        Lo_ -= rhs.Lo_;
+        Hi_ -= rhs.Hi_;
+        if (l < Lo_) --Hi_;
         return *this;
     }
 
     constexpr TWide& operator<<=(const TWide& rhs) {
-        if (const auto shift = size_t(rhs.Lo) % FullBitSize) {
+        if (const auto shift = size_t(rhs.Lo_) % FullBitSize) {
             if (shift < PartBitSize) {
-                Hi = TPart(Hi) << shift;
-                Hi |= Lo >> (PartBitSize - shift);
-                Lo <<= shift;
+                Hi_ = TPart(Hi_) << shift;
+                Hi_ |= Lo_ >> (PartBitSize - shift);
+                Lo_ <<= shift;
             } else {
-                Hi = Lo << (shift - PartBitSize);
-                Lo = 0;
+                Hi_ = Lo_ << (shift - PartBitSize);
+                Lo_ = 0;
             }
         }
 
@@ -224,14 +224,14 @@ public:
     }
 
     constexpr TWide& operator>>=(const TWide& rhs) {
-        if (const auto shift = size_t(rhs.Lo) % FullBitSize) {
+        if (const auto shift = size_t(rhs.Lo_) % FullBitSize) {
             if (shift < PartBitSize) {
-                Lo >>= shift;
-                Lo |= TPart(Hi) << (PartBitSize - shift);
-                Hi >>= shift;
+                Lo_ >>= shift;
+                Lo_ |= TPart(Hi_) << (PartBitSize - shift);
+                Hi_ >>= shift;
             } else {
-                Lo = Hi >> (shift - PartBitSize);
-                Hi = TIsSigned::value && Hi < 0 ? ~0 : 0;
+                Lo_ = Hi_ >> (shift - PartBitSize);
+                Hi_ = TIsSigned::value && Hi_ < 0 ? ~0 : 0;
             }
         }
 
@@ -256,17 +256,17 @@ public:
     template <typename T>
     constexpr std::enable_if_t<std::is_integral<T>::value, T> operator&(const T rhs) const { return T(*this) & rhs; }
 
-    constexpr bool operator==(const TWide& rhs) const { return std::tie(Hi, Lo) == std::tie(rhs.Hi, rhs.Lo); }
-    constexpr bool operator!=(const TWide& rhs) const { return std::tie(Hi, Lo) != std::tie(rhs.Hi, rhs.Lo); }
-    constexpr bool operator>=(const TWide& rhs) const { return std::tie(Hi, Lo) >= std::tie(rhs.Hi, rhs.Lo); }
-    constexpr bool operator<=(const TWide& rhs) const { return std::tie(Hi, Lo) <= std::tie(rhs.Hi, rhs.Lo); }
-    constexpr bool operator>(const TWide& rhs) const  { return std::tie(Hi, Lo) > std::tie(rhs.Hi, rhs.Lo); }
-    constexpr bool operator<(const TWide& rhs) const  { return std::tie(Hi, Lo) < std::tie(rhs.Hi, rhs.Lo); }
+    constexpr bool operator==(const TWide& rhs) const { return std::tie(Hi_, Lo_) == std::tie(rhs.Hi_, rhs.Lo_); }
+    constexpr bool operator!=(const TWide& rhs) const { return std::tie(Hi_, Lo_) != std::tie(rhs.Hi_, rhs.Lo_); }
+    constexpr bool operator>=(const TWide& rhs) const { return std::tie(Hi_, Lo_) >= std::tie(rhs.Hi_, rhs.Lo_); }
+    constexpr bool operator<=(const TWide& rhs) const { return std::tie(Hi_, Lo_) <= std::tie(rhs.Hi_, rhs.Lo_); }
+    constexpr bool operator>(const TWide& rhs) const  { return std::tie(Hi_, Lo_) > std::tie(rhs.Hi_, rhs.Lo_); }
+    constexpr bool operator<(const TWide& rhs) const  { return std::tie(Hi_, Lo_) < std::tie(rhs.Hi_, rhs.Lo_); }
 
 private:
     static constexpr TWide Mul(const TWide& lhs, const TWide& rhs) {
-        const TPart lq[] = {GetLowerQuarter(lhs.Lo), GetUpperQuarter(lhs.Lo), GetLowerQuarter(lhs.Hi), GetUpperQuarter(lhs.Hi)};
-        const TPart rq[] = {GetLowerQuarter(rhs.Lo), GetUpperQuarter(rhs.Lo), GetLowerQuarter(rhs.Hi), GetUpperQuarter(rhs.Hi)};
+        const TPart lq[] = {GetLowerQuarter(lhs.Lo_), GetUpperQuarter(lhs.Lo_), GetLowerQuarter(lhs.Hi_), GetUpperQuarter(lhs.Hi_)};
+        const TPart rq[] = {GetLowerQuarter(rhs.Lo_), GetUpperQuarter(rhs.Lo_), GetLowerQuarter(rhs.Hi_), GetUpperQuarter(rhs.Hi_)};
 
         const TPart prod0[] = {TPart(lq[0] * rq[0])};
         const TPart prod1[] = {TPart(lq[0] * rq[1]), TPart(lq[1] * rq[0])};
@@ -287,8 +287,8 @@ private:
     }
 
     static constexpr std::pair<TWide, TWide> DivMod(const TWide& lhs, const TWide& rhs) {
-        const bool nl = TIsSigned::value && lhs.Hi < 0;
-        const bool nr = TIsSigned::value && rhs.Hi < 0;
+        const bool nl = TIsSigned::value && lhs.Hi_ < 0;
+        const bool nr = TIsSigned::value && rhs.Hi_ < 0;
 
         const TUnsigned l = nl ? -lhs : +lhs, r = nr ? -rhs : +rhs;
 
@@ -298,7 +298,7 @@ private:
             mod <<= 1;
             div <<= 1;
 
-            if (--x < PartBitSize ? l.Lo & (TPart(1U) << x) : l.Hi & (TPart(1U) << x - PartBitSize)) {
+            if (--x < PartBitSize ? l.Lo_ & (TPart(1U) << x) : l.Hi_ & (TPart(1U) << x - PartBitSize)) {
                 ++mod;
             }
 
diff --git a/yql/essentials/public/issue/yql_issue.cpp b/yql/essentials/public/issue/yql_issue.cpp
index af47895927d..08b35ae56c5 100644
--- a/yql/essentials/public/issue/yql_issue.cpp
+++ b/yql/essentials/public/issue/yql_issue.cpp
@@ -42,42 +42,42 @@ void SanitizeNonAscii(TString& s) {
 
 TTextWalker& TTextWalker::Advance(char c) {
     if (c == '\n') {
-        HaveCr = false;
-        ++LfCount;
+        HaveCr_ = false;
+        ++LfCount_;
         return *this;
     }
 
 
-    if (c == '\r' && !HaveCr) {
-        HaveCr = true;
+    if (c == '\r' && !HaveCr_) {
+        HaveCr_ = true;
         return *this;
     }
 
     ui32 charDistance = 1;
-    if (Utf8Aware && IsUTF8ContinuationByte(c)) {
+    if (Utf8Aware_ && IsUTF8ContinuationByte(c)) {
         charDistance = 0;
     }
 
     // either not '\r' or second '\r'
-    if (LfCount) {
-        Position.Row += LfCount;
-        Position.Column = charDistance;
-        LfCount = 0;
+    if (LfCount_) {
+        Position_.Row += LfCount_;
+        Position_.Column = charDistance;
+        LfCount_ = 0;
     } else {
-        Position.Column += charDistance + (HaveCr && c != '\r');
+        Position_.Column += charDistance + (HaveCr_ && c != '\r');
     }
-    HaveCr = (c == '\r');
+    HaveCr_ = (c == '\r');
     return *this;
 }
 
 void TIssue::PrintTo(IOutputStream& out, bool oneLine) const {
     out << Range() << ": " << SeverityToString(GetSeverity()) << ": ";
     if (oneLine) {
-        TString message = StripString(Message);
+        TString message = StripString(Message_);
         SubstGlobal(message, '\n', ' ');
         out << message;
     } else {
-        out << Message;
+        out << Message_;
     }
     if (GetCode()) {
         out << ", code: " << GetCode();
diff --git a/yql/essentials/public/issue/yql_issue.h b/yql/essentials/public/issue/yql_issue.h
index 2c60b979531..ee2b376f0b2 100644
--- a/yql/essentials/public/issue/yql_issue.h
+++ b/yql/essentials/public/issue/yql_issue.h
@@ -56,10 +56,10 @@ struct TPosition {
 class TTextWalker {
 public:
     TTextWalker(TPosition& position, bool utf8Aware)
-        : Position(position)
-        , Utf8Aware(utf8Aware)
-        , HaveCr(false)
-        , LfCount(0)
+        : Position_(position)
+        , Utf8Aware_(utf8Aware)
+        , HaveCr_(false)
+        , LfCount_(0)
     {
     }
 
@@ -74,10 +74,10 @@ public:
     TTextWalker& Advance(char c);
 
 private:
-    TPosition& Position;
-    const bool Utf8Aware;
-    bool HaveCr;
-    ui32 LfCount;
+    TPosition& Position_;
+    const bool Utf8Aware_;
+    bool HaveCr_;
+    ui32 LfCount_;
 };
 
 struct TRange {
@@ -111,7 +111,7 @@ class TIssue;
 using TIssuePtr = TIntrusivePtr<TIssue>;
 class TIssue: public TThrRefBase {
     TVector<TIntrusivePtr<TIssue>> Children_;
-    TString Message;
+    TString Message_;
 public:
     TPosition Position;
     TPosition EndPosition;
@@ -122,20 +122,20 @@ public:
 
     template <typename T>
     explicit TIssue(const T& message)
-        : Message(message)
+        : Message_(message)
         , Position(TPosition())
         , EndPosition(TPosition())
     {
-        SanitizeNonAscii(Message);
+        SanitizeNonAscii(Message_);
     }
 
     template <typename T>
     TIssue(TPosition position, const T& message)
-        : Message(message)
+        : Message_(message)
         , Position(position)
         , EndPosition(position)
     {
-        SanitizeNonAscii(Message);
+        SanitizeNonAscii(Message_);
     }
 
     inline TRange Range() const {
@@ -144,15 +144,15 @@ public:
 
     template <typename T>
     TIssue(TPosition position, TPosition endPosition, const T& message)
-        : Message(message)
+        : Message_(message)
         , Position(position)
         , EndPosition(endPosition)
     {
-        SanitizeNonAscii(Message);
+        SanitizeNonAscii(Message_);
     }
 
     inline bool operator==(const TIssue& other) const {
-        return Position == other.Position && Message == other.Message
+        return Position == other.Position && Message_ == other.Message_
             && IssueCode == other.IssueCode;
     }
 
@@ -162,7 +162,7 @@ public:
                 (size_t)CombineHashes(IntHash(Position.Row), IntHash(Position.Column)),
                 ComputeHash(Position.File)
             ),
-            (size_t)CombineHashes((size_t)IntHash(static_cast<int>(IssueCode)), ComputeHash(Message)));
+            (size_t)CombineHashes((size_t)IntHash(static_cast<int>(IssueCode)), ComputeHash(Message_)));
     }
 
     TIssue& SetCode(TIssueCode id, ESeverity severity) {
@@ -172,8 +172,8 @@ public:
     }
 
     TIssue& SetMessage(const TString& msg) {
-        Message = msg;
-        SanitizeNonAscii(Message);
+        Message_ = msg;
+        SanitizeNonAscii(Message_);
         return *this;
     }
 
@@ -186,7 +186,7 @@ public:
     }
 
     const TString& GetMessage() const {
-        return Message;
+        return Message_;
     }
 
     TIssue& AddSubIssue(TIntrusivePtr<TIssue> issue) {
@@ -209,11 +209,11 @@ public:
 
     // Unsafe method. Doesn't call SanitizeNonAscii(Message)
     TString* MutableMessage() {
-        return &Message;
+        return &Message_;
     }
 
     TIssue& CopyWithoutSubIssues(const TIssue& src) {
-        Message = src.Message;
+        Message_ = src.Message_;
         IssueCode = src.IssueCode;
         Severity = src.Severity;
         Position = src.Position;
diff --git a/yql/essentials/public/issue/yql_warning.cpp b/yql/essentials/public/issue/yql_warning.cpp
index 6364025ff30..80d4686d1e5 100644
--- a/yql/essentials/public/issue/yql_warning.cpp
+++ b/yql/essentials/public/issue/yql_warning.cpp
@@ -10,10 +10,10 @@ TWarningRule::EParseResult TWarningRule::ParseFrom(const TString& codePattern, c
                                                    TWarningRule& result, TString& errorMessage)
 {
     errorMessage.clear();
-    result.IssueCodePattern.clear();
-    result.Action = EWarningAction::DEFAULT;
+    result.IssueCodePattern_.clear();
+    result.Action_ = EWarningAction::DEFAULT;
 
-    if (!TryFromString<EWarningAction>(to_upper(action), result.Action)) {
+    if (!TryFromString<EWarningAction>(to_upper(action), result.Action_)) {
         errorMessage = "unknown warning action '" + action + "', expecting one of " +
                        Join(", ", EWarningAction::DEFAULT, EWarningAction::ERROR, EWarningAction::DISABLE);
         return EParseResult::PARSE_ACTION_FAIL;
@@ -27,12 +27,12 @@ TWarningRule::EParseResult TWarningRule::ParseFrom(const TString& codePattern, c
         }
     }
 
-    result.IssueCodePattern = codePattern;
+    result.IssueCodePattern_ = codePattern;
     return EParseResult::PARSE_OK;
 }
 
 TWarningPolicy::TWarningPolicy(bool isReplay)
-    : IsReplay(isReplay)
+    : IsReplay_(isReplay)
 {}
 
 void TWarningPolicy::AddRule(const TWarningRule& rule)
@@ -42,40 +42,40 @@ void TWarningPolicy::AddRule(const TWarningRule& rule)
         return;
     }
 
-    if (pattern == "*" && IsReplay) {
+    if (pattern == "*" && IsReplay_) {
         return;
     }
 
-    Rules.push_back(rule);
+    Rules_.push_back(rule);
 
     EWarningAction action = rule.GetAction();
     if (pattern == "*") {
-        BaseAction = action;
-        Overrides.clear();
+        BaseAction_ = action;
+        Overrides_.clear();
         return;
     }
 
     TIssueCode code;
     Y_ENSURE(TryFromString(pattern, code));
 
-    if (action == BaseAction) {
-        Overrides.erase(Overrides.find(code));
+    if (action == BaseAction_) {
+        Overrides_.erase(Overrides_.find(code));
     } else {
-        Overrides[code] = action;
+        Overrides_[code] = action;
     }
 }
 
 EWarningAction TWarningPolicy::GetAction(TIssueCode code) const
 {
-    auto it = Overrides.find(code);
-    return (it == Overrides.end()) ? BaseAction : it->second;
+    auto it = Overrides_.find(code);
+    return (it == Overrides_.end()) ? BaseAction_ : it->second;
 }
 
 void TWarningPolicy::Clear()
 {
-    BaseAction = EWarningAction::DEFAULT;
-    Overrides.clear();
-    Rules.clear();
+    BaseAction_ = EWarningAction::DEFAULT;
+    Overrides_.clear();
+    Rules_.clear();
 }
 
 }
diff --git a/yql/essentials/public/issue/yql_warning.h b/yql/essentials/public/issue/yql_warning.h
index 7c3939d1d34..e21972d1d17 100644
--- a/yql/essentials/public/issue/yql_warning.h
+++ b/yql/essentials/public/issue/yql_warning.h
@@ -19,15 +19,15 @@ enum class EWarningAction {
 
 class TWarningRule {
 public:
-    const TString& GetPattern() const { return IssueCodePattern; }
-    EWarningAction GetAction() const  { return Action; }
+    const TString& GetPattern() const { return IssueCodePattern_; }
+    EWarningAction GetAction() const  { return Action_; }
 
     enum class EParseResult { PARSE_OK, PARSE_PATTERN_FAIL, PARSE_ACTION_FAIL };
     static EParseResult ParseFrom(const TString& codePattern, const TString& action,
                                   TWarningRule& result, TString& errorMessage);
 private:
-    TString IssueCodePattern;
-    EWarningAction Action = EWarningAction::DEFAULT;
+    TString IssueCodePattern_;
+    EWarningAction Action_ = EWarningAction::DEFAULT;
 };
 
 using TWarningRules = TVector<TWarningRule>;
@@ -40,15 +40,15 @@ public:
 
     EWarningAction GetAction(TIssueCode code) const;
 
-    const TWarningRules& GetRules() const { return Rules; }
+    const TWarningRules& GetRules() const { return Rules_; }
 
     void Clear();
 
 private:
-    const  bool IsReplay;
-    TWarningRules Rules;
-    EWarningAction BaseAction = EWarningAction::DEFAULT;
-    THashMap<TIssueCode, EWarningAction> Overrides;
+    const  bool IsReplay_;
+    TWarningRules Rules_;
+    EWarningAction BaseAction_ = EWarningAction::DEFAULT;
+    THashMap<TIssueCode, EWarningAction> Overrides_;
 };
 
 }
diff --git a/yql/essentials/public/purecalc/common/interface.cpp b/yql/essentials/public/purecalc/common/interface.cpp
index d9dd9fa634f..23633b5065f 100644
--- a/yql/essentials/public/purecalc/common/interface.cpp
+++ b/yql/essentials/public/purecalc/common/interface.cpp
@@ -8,13 +8,13 @@ using namespace NYql;
 using namespace NYql::NPureCalc;
 
 TLoggingOptions::TLoggingOptions()
-    : LogLevel_(ELogPriority::TLOG_ERR)
+    : LogLevel(ELogPriority::TLOG_ERR)
     , LogDestination(&Clog)
 {
 }
 
 TLoggingOptions& TLoggingOptions::SetLogLevel(ELogPriority logLevel) {
-    LogLevel_ = logLevel;
+    LogLevel = logLevel;
     return *this;
 }
 
@@ -24,8 +24,8 @@ TLoggingOptions& TLoggingOptions::SetLogDestination(IOutputStream* logDestinatio
 }
 
 TProgramFactoryOptions::TProgramFactoryOptions()
-    : UdfsDir_("")
-    , UserData_()
+    : UdfsDir("")
+    , UserData()
     , LLVMSettings("OFF")
     , BlockEngineSettings("disable")
     , ExprOutputStream(nullptr)
@@ -44,12 +44,12 @@ TProgramFactoryOptions& TProgramFactoryOptions::SetLanguageVersion(TLangVersion
 }
 
 TProgramFactoryOptions& TProgramFactoryOptions::SetUDFsDir(TStringBuf dir) {
-    UdfsDir_ = dir;
+    UdfsDir = dir;
     return *this;
 }
 
 TProgramFactoryOptions& TProgramFactoryOptions::AddLibrary(NUserData::EDisposition disposition, TStringBuf name, TStringBuf content) {
-    auto& ref = UserData_.emplace_back();
+    auto& ref = UserData.emplace_back();
 
     ref.Type = NUserData::EType::LIBRARY;
     ref.Disposition = disposition;
@@ -60,7 +60,7 @@ TProgramFactoryOptions& TProgramFactoryOptions::AddLibrary(NUserData::EDispositi
 }
 
 TProgramFactoryOptions& TProgramFactoryOptions::AddFile(NUserData::EDisposition disposition, TStringBuf name, TStringBuf content) {
-    auto& ref = UserData_.emplace_back();
+    auto& ref = UserData.emplace_back();
 
     ref.Type = NUserData::EType::FILE;
     ref.Disposition = disposition;
@@ -71,7 +71,7 @@ TProgramFactoryOptions& TProgramFactoryOptions::AddFile(NUserData::EDisposition
 }
 
 TProgramFactoryOptions& TProgramFactoryOptions::AddUDF(NUserData::EDisposition disposition, TStringBuf name, TStringBuf content) {
-    auto& ref = UserData_.emplace_back();
+    auto& ref = UserData.emplace_back();
 
     ref.Type = NUserData::EType::UDF;
     ref.Disposition = disposition;
diff --git a/yql/essentials/public/purecalc/common/interface.h b/yql/essentials/public/purecalc/common/interface.h
index f16f9fca238..23aa93bdf23 100644
--- a/yql/essentials/public/purecalc/common/interface.h
+++ b/yql/essentials/public/purecalc/common/interface.h
@@ -210,7 +210,7 @@ namespace NYql {
         struct TLoggingOptions final {
         public:
             /// Logging level for messages generated during compilation.
-            ELogPriority LogLevel_;  // TODO: rename to LogLevel
+            ELogPriority LogLevel;
 
             /// Where to write log messages.
             IOutputStream* LogDestination;
@@ -238,10 +238,10 @@ namespace NYql {
         struct TProgramFactoryOptions final {
         public:
             /// Path to a directory with compiled UDFs. Leave empty to disable loading external UDFs.
-            TString UdfsDir_;  // TODO: rename to UDFDir
+            TString UdfsDir;
 
             /// List of available external resources, e.g. files, UDFs, libraries.
-            TVector<NUserData::TUserData> UserData_;   // TODO: rename to UserData
+            TVector<NUserData::TUserData> UserData;
 
             /// LLVM settings. Assign "OFF" to disable LLVM, empty string for default settings.
             TString LLVMSettings;
diff --git a/yql/essentials/public/purecalc/common/logger_init.cpp b/yql/essentials/public/purecalc/common/logger_init.cpp
index a7da19d9f10..0c1e53d0338 100644
--- a/yql/essentials/public/purecalc/common/logger_init.cpp
+++ b/yql/essentials/public/purecalc/common/logger_init.cpp
@@ -14,9 +14,9 @@ namespace {
     void InitLogging(const TLoggingOptions& options) {
         NLog::InitLogger(options.LogDestination);
         auto& logger = NLog::YqlLogger();
-        logger.SetDefaultPriority(options.LogLevel_);
+        logger.SetDefaultPriority(options.LogLevel);
         for (int i = 0; i < NLog::EComponentHelpers::ToInt(NLog::EComponent::MaxValue); ++i) {
-            logger.SetComponentLevel((NLog::EComponent) i, (NLog::ELevel) options.LogLevel_);
+            logger.SetComponentLevel((NLog::EComponent) i, (NLog::ELevel) options.LogLevel);
         }
         Initialized = true;
     }
diff --git a/yql/essentials/public/purecalc/common/program_factory.cpp b/yql/essentials/public/purecalc/common/program_factory.cpp
index 051c4cfa465..320d1b6aa8a 100644
--- a/yql/essentials/public/purecalc/common/program_factory.cpp
+++ b/yql/essentials/public/purecalc/common/program_factory.cpp
@@ -22,9 +22,9 @@ TProgramFactory::TProgramFactory(const TProgramFactoryOptions& options)
                                      << Options_.BlockEngineSettings;
     }
 
-    NUserData::TUserData::UserDataToLibraries(Options_.UserData_, Modules_);
+    NUserData::TUserData::UserDataToLibraries(Options_.UserData, Modules_);
 
-    UserData_ = GetYqlModuleResolver(ExprContext_, ModuleResolver_, Options_.UserData_, {}, {});
+    UserData_ = GetYqlModuleResolver(ExprContext_, ModuleResolver_, Options_.UserData, {}, {});
 
     if (!ModuleResolver_) {
         auto issues = ExprContext_.IssueManager.GetIssues();
@@ -33,7 +33,7 @@ TProgramFactory::TProgramFactory(const TProgramFactoryOptions& options)
     }
 
     TVector<TString> UDFsPaths;
-    for (const auto& item: Options_.UserData_) {
+    for (const auto& item: Options_.UserData) {
         if (
             item.Type == NUserData::EType::UDF &&
             item.Disposition == NUserData::EDisposition::FILESYSTEM
@@ -42,8 +42,8 @@ TProgramFactory::TProgramFactory(const TProgramFactoryOptions& options)
         }
     }
 
-    if (!Options_.UdfsDir_.empty()) {
-        NKikimr::NMiniKQL::FindUdfsInDir(Options_.UdfsDir_, &UDFsPaths);
+    if (!Options_.UdfsDir.empty()) {
+        NKikimr::NMiniKQL::FindUdfsInDir(Options_.UdfsDir, &UDFsPaths);
     }
 
     FuncRegistry_ = NKikimr::NMiniKQL::CreateFunctionRegistry(
diff --git a/yql/essentials/public/purecalc/common/worker.cpp b/yql/essentials/public/purecalc/common/worker.cpp
index 965bc4c30eb..d5561fc4f73 100644
--- a/yql/essentials/public/purecalc/common/worker.cpp
+++ b/yql/essentials/public/purecalc/common/worker.cpp
@@ -48,23 +48,23 @@ TWorkerGraph::TWorkerGraph(
     TLangVersion langver,
     bool insideEvaluation
 )
-    : ScopedAlloc_(__LOCATION__, NKikimr::TAlignedPagePoolCounters(), funcRegistry.SupportsSizedAllocators())
-    , Env_(ScopedAlloc_)
-    , FuncRegistry_(funcRegistry)
-    , RandomProvider_(CreateDefaultRandomProvider())
-    , TimeProvider_(deterministicTimeProviderSeed ?
+    : ScopedAlloc(__LOCATION__, NKikimr::TAlignedPagePoolCounters(), funcRegistry.SupportsSizedAllocators())
+    , Env(ScopedAlloc)
+    , FuncRegistry(funcRegistry)
+    , RandomProvider(CreateDefaultRandomProvider())
+    , TimeProvider(deterministicTimeProviderSeed ?
         CreateDeterministicTimeProvider(*deterministicTimeProviderSeed) :
         CreateDefaultTimeProvider())
-    , LLVMSettings_(LLVMSettings)
-    , NativeYtTypeFlags_(nativeYtTypeFlags)
+    , LLVMSettings(LLVMSettings)
+    , NativeYtTypeFlags(nativeYtTypeFlags)
 {
     // Build the root MKQL node
     NCommon::TMemoizedTypesMap typeMemoization;
     NKikimr::NMiniKQL::TRuntimeNode rootNode;
     if (exprRoot) {
-        rootNode = CompileMkql(exprRoot, exprCtx, FuncRegistry_, Env_, userData, &typeMemoization);
+        rootNode = CompileMkql(exprRoot, exprCtx, FuncRegistry, Env, userData, &typeMemoization);
     } else {
-        rootNode = NKikimr::NMiniKQL::DeserializeRuntimeNode(serializedProgram, Env_);
+        rootNode = NKikimr::NMiniKQL::DeserializeRuntimeNode(serializedProgram, Env);
     }
 
     // Prepare container for input nodes
@@ -73,13 +73,13 @@ TWorkerGraph::TWorkerGraph(
 
     YQL_ENSURE(inputTypes.size() == originalInputTypes.size());
 
-    SelfNodes_.resize(inputsCount, nullptr);
+    SelfNodes.resize(inputsCount, nullptr);
 
-    YQL_ENSURE(SelfNodes_.size() == inputsCount);
+    YQL_ENSURE(SelfNodes.size() == inputsCount);
 
     // Setup struct types
 
-    NKikimr::NMiniKQL::TProgramBuilder pgmBuilder(Env_, FuncRegistry_, false, langver);
+    NKikimr::NMiniKQL::TProgramBuilder pgmBuilder(Env, FuncRegistry, false, langver);
     for (ui32 i = 0; i < inputsCount; ++i) {
         const auto* type = static_cast<NKikimr::NMiniKQL::TStructType*>(NCommon::BuildType(TPositionHandle(), *inputTypes[i], pgmBuilder, typeMemoization));
         const auto* originalType = type;
@@ -89,16 +89,16 @@ TWorkerGraph::TWorkerGraph(
             originalType = static_cast<NKikimr::NMiniKQL::TStructType*>(NCommon::BuildType(TPositionHandle(), *originalInputTypes[i], pgmBuilder, typeMemoization));
         }
 
-        InputTypes_.push_back(type);
-        OriginalInputTypes_.push_back(originalType);
-        RawInputTypes_.push_back(rawType);
+        InputTypes.push_back(type);
+        OriginalInputTypes.push_back(originalType);
+        RawInputTypes.push_back(rawType);
     }
 
     if (outputType) {
-        OutputType_ = NCommon::BuildType(TPositionHandle(), *outputType, pgmBuilder, typeMemoization);
+        OutputType = NCommon::BuildType(TPositionHandle(), *outputType, pgmBuilder, typeMemoization);
     }
     if (rawOutputType) {
-        RawOutputType_ = NCommon::BuildType(TPositionHandle(), *rawOutputType, pgmBuilder, typeMemoization);
+        RawOutputType = NCommon::BuildType(TPositionHandle(), *rawOutputType, pgmBuilder, typeMemoization);
     }
 
     if (!exprRoot) {
@@ -110,25 +110,25 @@ TWorkerGraph::TWorkerGraph(
         } else {
             ythrow TCompileError("", "") << "unexpected mkql output type " << NKikimr::NMiniKQL::TType::KindAsStr(outMkqlType->GetKind());
         }
-        if (OutputType_) {
-            if (!OutputType_->IsSameType(*outMkqlType)) {
+        if (OutputType) {
+            if (!OutputType->IsSameType(*outMkqlType)) {
                 ythrow TCompileError("", "") << "precompiled program output type doesn't match the output schema";
             }
         } else {
-            OutputType_ = outMkqlType;
-            RawOutputType_ = outMkqlType;
+            OutputType = outMkqlType;
+            RawOutputType = outMkqlType;
         }
     }
 
     // Compile computation pattern
 
     const THashSet<NKikimr::NMiniKQL::TInternName> selfCallableNames = {
-        Env_.InternName(PurecalcInputCallableName),
-        Env_.InternName(PurecalcBlockInputCallableName)
+        Env.InternName(PurecalcInputCallableName),
+        Env.InternName(PurecalcBlockInputCallableName)
     };
 
     NKikimr::NMiniKQL::TExploringNodeVisitor explorer;
-    explorer.Walk(rootNode.GetNode(), Env_.GetNodeStack());
+    explorer.Walk(rootNode.GetNode(), Env.GetNodeStack());
 
     auto compositeNodeFactory = NKikimr::NMiniKQL::GetCompositeWithBuiltinFactory(
         {NKikimr::NMiniKQL::GetYqlFactory(), NYql::GetPgFactory()}
@@ -145,8 +145,8 @@ TWorkerGraph::TWorkerGraph(
             YQL_ENSURE(callable.GetInputsCount() == 1, "Self takes exactly 1 argument");
             const auto inputIndex = AS_VALUE(NKikimr::NMiniKQL::TDataLiteral, callable.GetInput(0))->AsValue().Get<ui32>();
             YQL_ENSURE(inputIndex < inputsCount, "Self index is out of range");
-            YQL_ENSURE(!SelfNodes_[inputIndex], "Self can be called at most once with each index");
-            return SelfNodes_[inputIndex] = new NKikimr::NMiniKQL::TExternalComputationNode(ctx.Mutables);
+            YQL_ENSURE(!SelfNodes[inputIndex], "Self can be called at most once with each index");
+            return SelfNodes[inputIndex] = new NKikimr::NMiniKQL::TExternalComputationNode(ctx.Mutables);
         }
         else {
             return compositeNodeFactory(callable, ctx);
@@ -154,8 +154,8 @@ TWorkerGraph::TWorkerGraph(
     };
 
     NKikimr::NMiniKQL::TComputationPatternOpts computationPatternOpts(
-        ScopedAlloc_.Ref(),
-        Env_,
+        ScopedAlloc.Ref(),
+        Env,
         nodeFactory,
         &funcRegistry,
         NKikimr::NUdf::EValidateMode::None,
@@ -168,25 +168,25 @@ TWorkerGraph::TWorkerGraph(
         nullptr,
         langver);
 
-    ComputationPattern_ = NKikimr::NMiniKQL::MakeComputationPattern(
+    ComputationPattern = NKikimr::NMiniKQL::MakeComputationPattern(
         explorer,
         rootNode,
         { rootNode.GetNode() },
         computationPatternOpts);
 
-    ComputationGraph_ = ComputationPattern_->Clone(
-        computationPatternOpts.ToComputationOptions(*RandomProvider_, *TimeProvider_));
+    ComputationGraph = ComputationPattern->Clone(
+        computationPatternOpts.ToComputationOptions(*RandomProvider, *TimeProvider));
 
-    ComputationGraph_->Prepare();
+    ComputationGraph->Prepare();
 
     // Scoped alloc acquires itself on construction. We need to release it before returning control to user.
     // Note that scoped alloc releases itself on destruction so it is no problem if the above code throws.
-    ScopedAlloc_.Release();
+    ScopedAlloc.Release();
 }
 
 TWorkerGraph::~TWorkerGraph() {
     // Remember, we've released scoped alloc in constructor? Now, we need to acquire it back before destroying.
-    ScopedAlloc_.Acquire();
+    ScopedAlloc.Acquire();
 }
 
 template <typename TBase>
@@ -217,12 +217,12 @@ TWorker<TBase>::TWorker(
 
 template <typename TBase>
 inline ui32 TWorker<TBase>::GetInputsCount() const {
-    return Graph_.InputTypes_.size();
+    return Graph_.InputTypes.size();
 }
 
 template <typename TBase>
 inline const NKikimr::NMiniKQL::TStructType* TWorker<TBase>::GetInputType(ui32 inputIndex, bool original) const {
-    const auto& container = original ? Graph_.OriginalInputTypes_ : Graph_.InputTypes_;
+    const auto& container = original ? Graph_.OriginalInputTypes : Graph_.InputTypes;
 
     YQL_ENSURE(inputIndex < container.size(), "invalid input index (" << inputIndex << ") in GetInputType call");
 
@@ -231,7 +231,7 @@ inline const NKikimr::NMiniKQL::TStructType* TWorker<TBase>::GetInputType(ui32 i
 
 template <typename TBase>
 inline const NKikimr::NMiniKQL::TStructType* TWorker<TBase>::GetInputType(bool original) const {
-    const auto& container = original ? Graph_.OriginalInputTypes_ : Graph_.InputTypes_;
+    const auto& container = original ? Graph_.OriginalInputTypes : Graph_.InputTypes;
 
     YQL_ENSURE(container.size() == 1, "GetInputType() can be used only for single-input programs");
 
@@ -240,26 +240,26 @@ inline const NKikimr::NMiniKQL::TStructType* TWorker<TBase>::GetInputType(bool o
 
 template <typename TBase>
 inline const NKikimr::NMiniKQL::TStructType* TWorker<TBase>::GetRawInputType(ui32 inputIndex) const {
-    const auto& container = Graph_.RawInputTypes_;
+    const auto& container = Graph_.RawInputTypes;
     YQL_ENSURE(inputIndex < container.size(), "invalid input index (" << inputIndex << ") in GetInputType call");
     return container[inputIndex];
 }
 
 template <typename TBase>
 inline const NKikimr::NMiniKQL::TStructType* TWorker<TBase>::GetRawInputType() const {
-    const auto& container = Graph_.RawInputTypes_;
+    const auto& container = Graph_.RawInputTypes;
     YQL_ENSURE(container.size() == 1, "GetInputType() can be used only for single-input programs");
     return container[0];
 }
 
 template <typename TBase>
 inline const NKikimr::NMiniKQL::TType* TWorker<TBase>::GetOutputType() const {
-    return Graph_.OutputType_;
+    return Graph_.OutputType;
 }
 
 template <typename TBase>
 inline const NKikimr::NMiniKQL::TType* TWorker<TBase>::GetRawOutputType() const {
-    return Graph_.RawOutputType_;
+    return Graph_.RawOutputType;
 }
 
 template <typename TBase>
@@ -306,39 +306,39 @@ NYT::TNode TWorker<TBase>::MakeFullOutputSchema() const {
 
 template <typename TBase>
 inline NKikimr::NMiniKQL::TScopedAlloc& TWorker<TBase>::GetScopedAlloc() {
-    return Graph_.ScopedAlloc_;
+    return Graph_.ScopedAlloc;
 }
 
 template <typename TBase>
 inline NKikimr::NMiniKQL::IComputationGraph& TWorker<TBase>::GetGraph() {
-    return *Graph_.ComputationGraph_;
+    return *Graph_.ComputationGraph;
 }
 
 template <typename TBase>
 inline const NKikimr::NMiniKQL::IFunctionRegistry&
 TWorker<TBase>::GetFunctionRegistry() const {
-    return Graph_.FuncRegistry_;
+    return Graph_.FuncRegistry;
 }
 
 template <typename TBase>
 inline NKikimr::NMiniKQL::TTypeEnvironment&
 TWorker<TBase>::GetTypeEnvironment() {
-    return Graph_.Env_;
+    return Graph_.Env;
 }
 
 template <typename TBase>
 inline const TString& TWorker<TBase>::GetLLVMSettings() const {
-    return Graph_.LLVMSettings_;
+    return Graph_.LLVMSettings;
 }
 
 template <typename TBase>
 inline ui64 TWorker<TBase>::GetNativeYtTypeFlags() const {
-    return Graph_.NativeYtTypeFlags_;
+    return Graph_.NativeYtTypeFlags;
 }
 
 template <typename TBase>
 ITimeProvider* TWorker<TBase>::GetTimeProvider() const {
-    return Graph_.TimeProvider_.Get();
+    return Graph_.TimeProvider.Get();
 }
 
 template <typename TBase>
@@ -352,13 +352,13 @@ void TWorker<TBase>::Release() {
 
 template <typename TBase>
 void TWorker<TBase>::Invalidate() {
-    auto& ctx = Graph_.ComputationGraph_->GetContext();
-    for (const auto* selfNode : Graph_.SelfNodes_) {
+    auto& ctx = Graph_.ComputationGraph->GetContext();
+    for (const auto* selfNode : Graph_.SelfNodes) {
         if (selfNode) {
             selfNode->InvalidateValue(ctx);
         }
     }
-    Graph_.ComputationGraph_->InvalidateCaches();
+    Graph_.ComputationGraph->InvalidateCaches();
 }
 
 TPullStreamWorker::~TPullStreamWorker() {
@@ -367,7 +367,7 @@ TPullStreamWorker::~TPullStreamWorker() {
 }
 
 void TPullStreamWorker::SetInput(NKikimr::NUdf::TUnboxedValue&& value, ui32 inputIndex) {
-    const auto inputsCount = Graph_.SelfNodes_.size();
+    const auto inputsCount = Graph_.SelfNodes.size();
 
     if (Y_UNLIKELY(inputIndex >= inputsCount)) {
         ythrow yexception() << "invalid input index (" << inputIndex << ") in SetInput call";
@@ -381,17 +381,17 @@ void TPullStreamWorker::SetInput(NKikimr::NUdf::TUnboxedValue&& value, ui32 inpu
         ythrow yexception() << "input value for #" << inputIndex << " input is already set";
     }
 
-    auto selfNode = Graph_.SelfNodes_[inputIndex];
+    auto selfNode = Graph_.SelfNodes[inputIndex];
 
     if (selfNode) {
         YQL_ENSURE(value);
-        selfNode->SetValue(Graph_.ComputationGraph_->GetContext(), std::move(value));
+        selfNode->SetValue(Graph_.ComputationGraph->GetContext(), std::move(value));
     }
 
     HasInput_[inputIndex] = true;
 
     if (CheckAllInputsSet()) {
-        Output_ = Graph_.ComputationGraph_->GetValue();
+        Output_ = Graph_.ComputationGraph->GetValue();
     }
 }
 
@@ -406,9 +406,9 @@ NKikimr::NUdf::TUnboxedValue& TPullStreamWorker::GetOutput() {
 void TPullStreamWorker::Release() {
     with_lock(GetScopedAlloc()) {
         Output_ = NKikimr::NUdf::TUnboxedValue::Invalid();
-        for (auto selfNode: Graph_.SelfNodes_) {
+        for (auto selfNode: Graph_.SelfNodes) {
             if (selfNode) {
-                selfNode->SetValue(Graph_.ComputationGraph_->GetContext(), NKikimr::NUdf::TUnboxedValue::Invalid());
+                selfNode->SetValue(Graph_.ComputationGraph->GetContext(), NKikimr::NUdf::TUnboxedValue::Invalid());
             }
         }
     }
@@ -423,7 +423,7 @@ TPullListWorker::~TPullListWorker() {
 }
 
 void TPullListWorker::SetInput(NKikimr::NUdf::TUnboxedValue&& value, ui32 inputIndex) {
-    const auto inputsCount = Graph_.SelfNodes_.size();
+    const auto inputsCount = Graph_.SelfNodes.size();
 
     if (Y_UNLIKELY(inputIndex >= inputsCount)) {
         ythrow yexception() << "invalid input index (" << inputIndex << ") in SetInput call";
@@ -437,17 +437,17 @@ void TPullListWorker::SetInput(NKikimr::NUdf::TUnboxedValue&& value, ui32 inputI
         ythrow yexception() << "input value for #" << inputIndex << " input is already set";
     }
 
-    auto selfNode = Graph_.SelfNodes_[inputIndex];
+    auto selfNode = Graph_.SelfNodes[inputIndex];
 
     if (selfNode) {
         YQL_ENSURE(value);
-        selfNode->SetValue(Graph_.ComputationGraph_->GetContext(), std::move(value));
+        selfNode->SetValue(Graph_.ComputationGraph->GetContext(), std::move(value));
     }
 
     HasInput_[inputIndex] = true;
 
     if (CheckAllInputsSet()) {
-        Output_ = Graph_.ComputationGraph_->GetValue();
+        Output_ = Graph_.ComputationGraph->GetValue();
         ResetOutputIterator();
     }
 }
@@ -481,9 +481,9 @@ void TPullListWorker::Release() {
         Output_ = NKikimr::NUdf::TUnboxedValue::Invalid();
         OutputIterator_ = NKikimr::NUdf::TUnboxedValue::Invalid();
 
-        for (auto selfNode: Graph_.SelfNodes_) {
+        for (auto selfNode: Graph_.SelfNodes) {
             if (selfNode) {
-                selfNode->SetValue(Graph_.ComputationGraph_->GetContext(), NKikimr::NUdf::TUnboxedValue::Invalid());
+                selfNode->SetValue(Graph_.ComputationGraph->GetContext(), NKikimr::NUdf::TUnboxedValue::Invalid());
             }
         }
     }
@@ -533,7 +533,7 @@ namespace {
 }
 
 void TPushStreamWorker::FeedToConsumer() {
-    auto value = Graph_.ComputationGraph_->GetValue();
+    auto value = Graph_.ComputationGraph->GetValue();
 
     for (;;) {
         NKikimr::NUdf::TUnboxedValue item;
@@ -548,11 +548,11 @@ void TPushStreamWorker::FeedToConsumer() {
 }
 
 NYql::NUdf::IBoxedValue* TPushStreamWorker::GetPushStream() const {
-    auto& ctx = Graph_.ComputationGraph_->GetContext();
+    auto& ctx = Graph_.ComputationGraph->GetContext();
     NUdf::TUnboxedValue pushStream = SelfNode_->GetValue(ctx);
 
     if (Y_UNLIKELY(pushStream.IsInvalid())) {
-        SelfNode_->SetValue(ctx, Graph_.ComputationGraph_->GetHolderFactory().Create<TPushStream>());
+        SelfNode_->SetValue(ctx, Graph_.ComputationGraph->GetHolderFactory().Create<TPushStream>());
         pushStream = SelfNode_->GetValue(ctx);
     }
 
@@ -561,7 +561,7 @@ NYql::NUdf::IBoxedValue* TPushStreamWorker::GetPushStream() const {
 
 void TPushStreamWorker::SetConsumer(THolder<IConsumer<const NKikimr::NUdf::TUnboxedValue*>> consumer) {
     auto guard = Guard(GetScopedAlloc());
-    const auto inputsCount = Graph_.SelfNodes_.size();
+    const auto inputsCount = Graph_.SelfNodes.size();
 
     YQL_ENSURE(inputsCount < 2, "push stream mode doesn't support several inputs");
     YQL_ENSURE(!Consumer_, "consumer is already set");
@@ -569,13 +569,13 @@ void TPushStreamWorker::SetConsumer(THolder<IConsumer<const NKikimr::NUdf::TUnbo
     Consumer_ = std::move(consumer);
 
     if (inputsCount == 1) {
-        SelfNode_ = Graph_.SelfNodes_[0];
+        SelfNode_ = Graph_.SelfNodes[0];
     }
 
     if (SelfNode_) {
         SelfNode_->SetValue(
-            Graph_.ComputationGraph_->GetContext(),
-            Graph_.ComputationGraph_->GetHolderFactory().Create<TPushStream>());
+            Graph_.ComputationGraph->GetContext(),
+            Graph_.ComputationGraph->GetHolderFactory().Create<TPushStream>());
     }
 
     FeedToConsumer();
@@ -611,7 +611,7 @@ void TPushStreamWorker::Release() {
     with_lock(GetScopedAlloc()) {
         Consumer_.Destroy();
         if (SelfNode_) {
-            SelfNode_->SetValue(Graph_.ComputationGraph_->GetContext(), NKikimr::NUdf::TUnboxedValue::Invalid());
+            SelfNode_->SetValue(Graph_.ComputationGraph->GetContext(), NKikimr::NUdf::TUnboxedValue::Invalid());
         }
         SelfNode_ = nullptr;
     }
diff --git a/yql/essentials/public/purecalc/common/worker.h b/yql/essentials/public/purecalc/common/worker.h
index 0e218142331..b032b15af15 100644
--- a/yql/essentials/public/purecalc/common/worker.h
+++ b/yql/essentials/public/purecalc/common/worker.h
@@ -37,22 +37,22 @@ namespace NYql {
 
             ~TWorkerGraph();
 
-            NKikimr::NMiniKQL::TScopedAlloc ScopedAlloc_;
-            NKikimr::NMiniKQL::TTypeEnvironment Env_;
-            const NKikimr::NMiniKQL::IFunctionRegistry& FuncRegistry_;
-            TIntrusivePtr<IRandomProvider> RandomProvider_;
-            TIntrusivePtr<ITimeProvider> TimeProvider_;
-            NKikimr::NMiniKQL::IComputationPattern::TPtr ComputationPattern_;
-            THolder<NKikimr::NMiniKQL::IComputationGraph> ComputationGraph_;
-            TString LLVMSettings_;
-            ui64 NativeYtTypeFlags_;
-            TMaybe<TString> TimestampColumn_;
-            const NKikimr::NMiniKQL::TType* OutputType_;
-            const NKikimr::NMiniKQL::TType* RawOutputType_;
-            TVector<NKikimr::NMiniKQL::IComputationExternalNode*> SelfNodes_;
-            TVector<const NKikimr::NMiniKQL::TStructType*> InputTypes_;
-            TVector<const NKikimr::NMiniKQL::TStructType*> OriginalInputTypes_;
-            TVector<const NKikimr::NMiniKQL::TStructType*> RawInputTypes_;
+            NKikimr::NMiniKQL::TScopedAlloc ScopedAlloc;
+            NKikimr::NMiniKQL::TTypeEnvironment Env;
+            const NKikimr::NMiniKQL::IFunctionRegistry& FuncRegistry;
+            TIntrusivePtr<IRandomProvider> RandomProvider;
+            TIntrusivePtr<ITimeProvider> TimeProvider;
+            NKikimr::NMiniKQL::IComputationPattern::TPtr ComputationPattern;
+            THolder<NKikimr::NMiniKQL::IComputationGraph> ComputationGraph;
+            TString LLVMSettings;
+            ui64 NativeYtTypeFlags;
+            TMaybe<TString> TimestampColumn;
+            const NKikimr::NMiniKQL::TType* OutputType;
+            const NKikimr::NMiniKQL::TType* RawOutputType;
+            TVector<NKikimr::NMiniKQL::IComputationExternalNode*> SelfNodes;
+            TVector<const NKikimr::NMiniKQL::TStructType*> InputTypes;
+            TVector<const NKikimr::NMiniKQL::TStructType*> OriginalInputTypes;
+            TVector<const NKikimr::NMiniKQL::TStructType*> RawInputTypes;
         };
 
         template <typename TBase>
diff --git a/yql/essentials/public/purecalc/common/worker_factory.cpp b/yql/essentials/public/purecalc/common/worker_factory.cpp
index ea1a4ee5187..54477fd80e7 100644
--- a/yql/essentials/public/purecalc/common/worker_factory.cpp
+++ b/yql/essentials/public/purecalc/common/worker_factory.cpp
@@ -51,12 +51,12 @@ TWorkerFactory<TBase>::TWorkerFactory(TWorkerFactoryOptions options, EProcessorM
     , LLVMSettings_(std::move(options.LLVMSettings))
     , BlockEngineMode_(options.BlockEngineMode)
     , ExprOutputStream_(options.ExprOutputStream)
-    , CountersProvider_(options.CountersProvider_)
-    , NativeYtTypeFlags_(options.NativeYtTypeFlags_)
-    , DeterministicTimeProviderSeed_(options.DeterministicTimeProviderSeed_)
+    , CountersProvider_(options.CountersProvider)
+    , NativeYtTypeFlags_(options.NativeYtTypeFlags)
+    , DeterministicTimeProviderSeed_(options.DeterministicTimeProviderSeed)
     , UseSystemColumns_(options.UseSystemColumns)
     , UseWorkerPool_(options.UseWorkerPool)
-    , LangVer_(options.LangVer_)
+    , LangVer_(options.LangVer)
 {
     // Prepare input struct types and extract all column names from inputs
 
@@ -108,11 +108,11 @@ TWorkerFactory<TBase>::TWorkerFactory(TWorkerFactoryOptions options, EProcessorM
 
     // Translate
 
-    if (options.TranslationMode_ == ETranslationMode::Mkql) {
+    if (options.TranslationMode == ETranslationMode::Mkql) {
         SerializedProgram_ = TString{options.Query};
     } else {
-        ExprRoot_ = Compile(options.Query, options.TranslationMode_,
-            options.ModuleResolver, options.SyntaxVersion_, options.LangVer_, options.Modules,
+        ExprRoot_ = Compile(options.Query, options.TranslationMode,
+            options.ModuleResolver, options.SyntaxVersion, options.LangVer, options.Modules,
             options.InputSpec, options.OutputSpec, options.UseAntlr4, processorMode);
 
         RawOutputType_ = GetSequenceItemType(ExprRoot_->Pos(), ExprRoot_->GetTypeAnn(), true, ExprContext_);
@@ -307,9 +307,9 @@ TExprNode::TPtr TWorkerFactory<TBase>::Compile(
             true
         );
 
-        with_lock (graph.ScopedAlloc_) {
-            const auto value = graph.ComputationGraph_->GetValue();
-            NCommon::WriteYsonValue(writer, value, const_cast<NKikimr::NMiniKQL::TType*>(graph.OutputType_), nullptr);
+        with_lock (graph.ScopedAlloc) {
+            const auto value = graph.ComputationGraph->GetValue();
+            NCommon::WriteYsonValue(writer, value, const_cast<NKikimr::NMiniKQL::TType*>(graph.OutputType), nullptr);
         }
         writer.OnEndMap();
 
diff --git a/yql/essentials/public/purecalc/common/worker_factory.h b/yql/essentials/public/purecalc/common/worker_factory.h
index 1252048efaa..afcf3779451 100644
--- a/yql/essentials/public/purecalc/common/worker_factory.h
+++ b/yql/essentials/public/purecalc/common/worker_factory.h
@@ -25,12 +25,12 @@ namespace NYql {
             TString LLVMSettings;
             EBlockEngineMode BlockEngineMode;
             IOutputStream* ExprOutputStream;
-            NKikimr::NUdf::ICountersProvider* CountersProvider_;
-            ETranslationMode TranslationMode_;
-            ui16 SyntaxVersion_;
-            TLangVersion LangVer_;
-            ui64 NativeYtTypeFlags_;
-            TMaybe<ui64> DeterministicTimeProviderSeed_;
+            NKikimr::NUdf::ICountersProvider* CountersProvider;
+            ETranslationMode TranslationMode;
+            ui16 SyntaxVersion;
+            TLangVersion LangVer;
+            ui64 NativeYtTypeFlags;
+            TMaybe<ui64> DeterministicTimeProviderSeed;
             bool UseSystemColumns;
             bool UseWorkerPool;
             bool UseAntlr4;
@@ -68,12 +68,12 @@ namespace NYql {
                 , LLVMSettings(std::move(LLVMSettings))
                 , BlockEngineMode(BlockEngineMode)
                 , ExprOutputStream(ExprOutputStream)
-                , CountersProvider_(CountersProvider)
-                , TranslationMode_(translationMode)
-                , SyntaxVersion_(syntaxVersion)
-                , LangVer_(langver)
-                , NativeYtTypeFlags_(nativeYtTypeFlags)
-                , DeterministicTimeProviderSeed_(deterministicTimeProviderSeed)
+                , CountersProvider(CountersProvider)
+                , TranslationMode(translationMode)
+                , SyntaxVersion(syntaxVersion)
+                , LangVer(langver)
+                , NativeYtTypeFlags(nativeYtTypeFlags)
+                , DeterministicTimeProviderSeed(deterministicTimeProviderSeed)
                 , UseSystemColumns(useSystemColumns)
                 , UseWorkerPool(useWorkerPool)
                 , UseAntlr4(useAntlr4)
diff --git a/yql/essentials/public/purecalc/common/wrappers.h b/yql/essentials/public/purecalc/common/wrappers.h
index 4d65e012716..35edeb7398a 100644
--- a/yql/essentials/public/purecalc/common/wrappers.h
+++ b/yql/essentials/public/purecalc/common/wrappers.h
@@ -50,21 +50,21 @@ namespace NYql::NPureCalc::NPrivate {
     template <typename T, typename C>
     class TNonOwningConsumer final: public IConsumer<T> {
     private:
-        C Consumer;
+        C Consumer_;
 
     public:
         explicit TNonOwningConsumer(const C& consumer)
-            : Consumer(consumer)
+            : Consumer_(consumer)
         {
         }
 
     public:
         void OnObject(T t) override {
-            Consumer->OnObject(t);
+            Consumer_->OnObject(t);
         }
 
         void OnFinish() override {
-            Consumer->OnFinish();
+            Consumer_->OnFinish();
         }
     };
 }
diff --git a/yql/essentials/public/purecalc/io_specs/arrow/ut/test_spec.cpp b/yql/essentials/public/purecalc/io_specs/arrow/ut/test_spec.cpp
index fa1ca5171a4..e9e0cb7072b 100644
--- a/yql/essentials/public/purecalc/io_specs/arrow/ut/test_spec.cpp
+++ b/yql/essentials/public/purecalc/io_specs/arrow/ut/test_spec.cpp
@@ -42,39 +42,39 @@ NYql::NPureCalc::TProgramFactoryOptions TestOptions(NYql::EBlockEngineMode mode)
 
 template <typename T>
 struct TVectorStream: public NYql::NPureCalc::IStream<T*> {
-    TVector<T> Data_;
-    size_t Index_ = 0;
+    TVector<T> Data;
+    size_t Index = 0;
 
 public:
     TVectorStream(TVector<T> items)
-        : Data_(std::move(items))
+        : Data(std::move(items))
     {
     }
 
     T* Fetch() override {
-        return Index_ < Data_.size() ? &Data_[Index_++] : nullptr;
+        return Index < Data.size() ? &Data[Index++] : nullptr;
     }
 };
 
 
 template<typename T>
 struct TVectorConsumer: public NYql::NPureCalc::IConsumer<T*> {
-    TVector<T>& Data_;
-    size_t Index_ = 0;
+    TVector<T>& Data;
+    size_t Index = 0;
 
 public:
     TVectorConsumer(TVector<T>& items)
-        : Data_(items)
+        : Data(items)
     {
     }
 
     void OnObject(T* t) override {
-        Index_++;
-        Data_.push_back(*t);
+        Index++;
+        Data.push_back(*t);
     }
 
     void OnFinish() override {
-        UNIT_ASSERT_GT(Index_, 0);
+        UNIT_ASSERT_GT(Index, 0);
     }
 };
 
diff --git a/yql/essentials/public/result_format/yql_codec_results.cpp b/yql/essentials/public/result_format/yql_codec_results.cpp
index 911993c0c4a..ac961cb3927 100644
--- a/yql/essentials/public/result_format/yql_codec_results.cpp
+++ b/yql/essentials/public/result_format/yql_codec_results.cpp
@@ -12,12 +12,12 @@ constexpr TStringBuf TYsonResultWriter::VoidString;
 void TYsonResultWriter::OnStringScalar(TStringBuf value) {
     if (!IsUtf8(value)) {
         TString encoded = Base64Encode(value);
-        Writer.OnBeginList();
-        Writer.OnListItem();
-        Writer.OnStringScalar(TStringBuf(encoded));
-        Writer.OnEndList();
+        Writer_.OnBeginList();
+        Writer_.OnListItem();
+        Writer_.OnStringScalar(TStringBuf(encoded));
+        Writer_.OnEndList();
     } else {
-        Writer.OnStringScalar(value);
+        Writer_.OnStringScalar(value);
     }
 }
 
diff --git a/yql/essentials/public/result_format/yql_codec_results.h b/yql/essentials/public/result_format/yql_codec_results.h
index 3fae20cf833..f4822b5d8c3 100644
--- a/yql/essentials/public/result_format/yql_codec_results.h
+++ b/yql/essentials/public/result_format/yql_codec_results.h
@@ -17,25 +17,25 @@ public:
 
 public:
     explicit TYsonResultWriter(NYson::TYsonConsumerBase& writer)
-        : Writer(writer)
+        : Writer_(writer)
     {
     }
     void OnVoid() {
-        Writer.OnStringScalar(VoidString);
+        Writer_.OnStringScalar(VoidString);
     }
     void OnNull() {
-        Writer.OnEntity();
+        Writer_.OnEntity();
     }
     void OnEmptyList() {
-        Writer.OnBeginList();
-        Writer.OnEndList();
+        Writer_.OnBeginList();
+        Writer_.OnEndList();
     }
     void OnEmptyDict() {
-        Writer.OnBeginList();
-        Writer.OnEndList();
+        Writer_.OnBeginList();
+        Writer_.OnEndList();
     }
     void OnEntity() {
-        Writer.OnEntity();
+        Writer_.OnEntity();
     }
     // numbers
     void OnInt64Scalar(i64 value) {
@@ -45,56 +45,56 @@ public:
         WriteNumberAsString(value);
     }
     void OnFloatScalar(float value) {
-        Writer.OnStringScalar(::FloatToString(value));
+        Writer_.OnStringScalar(::FloatToString(value));
     }
     void OnDoubleScalar(double value) {
-        Writer.OnStringScalar(::FloatToString(value));
+        Writer_.OnStringScalar(::FloatToString(value));
     }
     void OnBooleanScalar(bool value) {
-        Writer.OnBooleanScalar(value);
+        Writer_.OnBooleanScalar(value);
     }
     // strings
     void OnStringScalar(TStringBuf value);
     void OnUtf8StringScalar(TStringBuf value) {
-        Writer.OnStringScalar(value);
+        Writer_.OnStringScalar(value);
     }
     // list construction
     void OnBeginList() {
-        Writer.OnBeginList();
+        Writer_.OnBeginList();
     }
     void OnListItem() {
-        Writer.OnListItem();
+        Writer_.OnListItem();
     }
     void OnEndList() {
-        Writer.OnEndList();
+        Writer_.OnEndList();
     }
     void OnBeginMap() {
-        Writer.OnBeginMap();
+        Writer_.OnBeginMap();
     }
     void OnKeyedItem(const TStringBuf& key) {
-        Writer.OnKeyedItem(key);
+        Writer_.OnKeyedItem(key);
     }
     void OnEndMap() {
-        Writer.OnEndMap();
+        Writer_.OnEndMap();
     }
     void OnBeginAttributes() {
-        Writer.OnBeginAttributes();
+        Writer_.OnBeginAttributes();
     }
     void OnEndAttributes() {
-        Writer.OnEndAttributes();
+        Writer_.OnEndAttributes();
     }
     void OnRaw(TStringBuf ysonNode, NYT::NYson::EYsonType type) {
-        Writer.OnRaw(ysonNode, type);
+        Writer_.OnRaw(ysonNode, type);
     }
 
 private:
     template <typename T>
     void WriteNumberAsString(T value) {
-        Writer.OnStringScalar(::ToString(value));
+        Writer_.OnStringScalar(::ToString(value));
     }
 
 private:
-    NYson::TYsonConsumerBase& Writer;
+    NYson::TYsonConsumerBase& Writer_;
 };
 }
 }
diff --git a/yql/essentials/public/result_format/yql_restricted_yson.cpp b/yql/essentials/public/result_format/yql_restricted_yson.cpp
index 405411aebf7..dec45b2c2b0 100644
--- a/yql/essentials/public/result_format/yql_restricted_yson.cpp
+++ b/yql/essentials/public/result_format/yql_restricted_yson.cpp
@@ -19,35 +19,35 @@ namespace {
 class TRestrictedYsonFormatter : public NYson::TYsonConsumerBase {
 public:
     TRestrictedYsonFormatter(TYsonResultWriter& writer)
-        : Writer(writer) {
+        : Writer_(writer) {
     }
 
     void OnStringScalar(TStringBuf value) override {
         Open();
         Type(TStringBuf("string"));
 
-        Buffer.clear();
+        Buffer_.clear();
         bool isAscii = true;
         for (size_t i = 0; i < value.size(); ++i) {
             if (ui8(value[i]) < 128) {
                 if (!isAscii) {
-                    Buffer.push_back(value[i]);
+                    Buffer_.push_back(value[i]);
                 }
             } else {
                 if (isAscii) {
-                    Buffer.resize(i);
-                    Copy(value.data(), value.data() + i, Buffer.data());
+                    Buffer_.resize(i);
+                    Copy(value.data(), value.data() + i, Buffer_.data());
                     isAscii = false;
                 }
-                Buffer.push_back('\xC0' | (ui8(value[i]) >> 6));
-                Buffer.push_back('\x80' | (ui8(value[i]) & ~'\xC0'));
+                Buffer_.push_back('\xC0' | (ui8(value[i]) >> 6));
+                Buffer_.push_back('\x80' | (ui8(value[i]) & ~'\xC0'));
             }
         }
 
         if (isAscii) {
             Value(value);
         } else {
-            Value(TStringBuf(Buffer.data(), Buffer.size()));
+            Value(TStringBuf(Buffer_.data(), Buffer_.size()));
         }
 
         Close();
@@ -82,103 +82,103 @@ public:
     }
 
     void OnEntity() override {
-        if (AfterAttributes) {
-            Writer.OnKeyedItem(TStringBuf("$value"));
-            Writer.OnEntity();
-            Writer.OnEndMap();
-            AfterAttributes = false;
+        if (AfterAttributes_) {
+            Writer_.OnKeyedItem(TStringBuf("$value"));
+            Writer_.OnEntity();
+            Writer_.OnEndMap();
+            AfterAttributes_ = false;
         } else {
-            Writer.OnEntity();
+            Writer_.OnEntity();
         }
     }
 
     void OnBeginList() override {
-        if (AfterAttributes) {
-            Writer.OnKeyedItem(TStringBuf("$value"));
+        if (AfterAttributes_) {
+            Writer_.OnKeyedItem(TStringBuf("$value"));
         }
 
-        Writer.OnBeginList();
-        HasAttributes.push(AfterAttributes);
-        AfterAttributes = false;
+        Writer_.OnBeginList();
+        HasAttributes_.push(AfterAttributes_);
+        AfterAttributes_ = false;
     }
 
     void OnListItem() override {
-        Writer.OnListItem();
+        Writer_.OnListItem();
     }
 
     void OnEndList() override {
-        Writer.OnEndList();
-        if (HasAttributes.top()) {
-            Writer.OnEndMap();
+        Writer_.OnEndList();
+        if (HasAttributes_.top()) {
+            Writer_.OnEndMap();
         }
 
-        HasAttributes.pop();
+        HasAttributes_.pop();
     }
 
     void OnBeginMap() override {
-        if (AfterAttributes) {
-            Writer.OnKeyedItem(TStringBuf("$value"));
+        if (AfterAttributes_) {
+            Writer_.OnKeyedItem(TStringBuf("$value"));
         }
 
-        Writer.OnBeginMap();
-        HasAttributes.push(AfterAttributes);
-        AfterAttributes = false;
+        Writer_.OnBeginMap();
+        HasAttributes_.push(AfterAttributes_);
+        AfterAttributes_ = false;
     }
 
     void OnKeyedItem(TStringBuf key) override {
         if (key.StartsWith('$')) {
-            Writer.OnKeyedItem(TString("$") + key);
+            Writer_.OnKeyedItem(TString("$") + key);
         } else {
-            Writer.OnKeyedItem(key);
+            Writer_.OnKeyedItem(key);
         }
     }
 
     void OnEndMap() override {
-        Writer.OnEndMap();
-        if (HasAttributes.top()) {
-            Writer.OnEndMap();
+        Writer_.OnEndMap();
+        if (HasAttributes_.top()) {
+            Writer_.OnEndMap();
         }
 
-        HasAttributes.pop();
+        HasAttributes_.pop();
     }
 
     void OnBeginAttributes() override {
-        Writer.OnBeginMap();
-        Writer.OnKeyedItem(TStringBuf("$attributes"));
-        Writer.OnBeginMap();
+        Writer_.OnBeginMap();
+        Writer_.OnKeyedItem(TStringBuf("$attributes"));
+        Writer_.OnBeginMap();
     }
 
     void OnEndAttributes() override {
-        Writer.OnEndMap();
-        AfterAttributes = true;
+        Writer_.OnEndMap();
+        AfterAttributes_ = true;
     }
 
     void Open() {
-        if (!AfterAttributes) {
-            Writer.OnBeginMap();
+        if (!AfterAttributes_) {
+            Writer_.OnBeginMap();
         }
     }
 
     void Close() {
-        Writer.OnEndMap();
-        AfterAttributes = false;
+        Writer_.OnEndMap();
+        AfterAttributes_ = false;
     }
 
     void Type(const TStringBuf& type) {
-        Writer.OnKeyedItem(TStringBuf("$type"));
-        Writer.OnUtf8StringScalar(type);
+        Writer_.OnKeyedItem(TStringBuf("$type"));
+        Writer_.OnUtf8StringScalar(type);
     }
 
     void Value(const TStringBuf& value) {
-        Writer.OnKeyedItem(TStringBuf("$value"));
-        Writer.OnUtf8StringScalar(value);
+        Writer_.OnKeyedItem(TStringBuf("$value"));
+        Writer_.OnUtf8StringScalar(value);
     }
 
 private:
-    TYsonResultWriter& Writer;
-    TStack<bool> HasAttributes;
-    bool AfterAttributes = false;
-    TVector<char> Buffer;
+    TYsonResultWriter& Writer_;
+    TStack<bool> HasAttributes_;
+    bool AfterAttributes_ = false;
+    TVector<char> Buffer_;
 };
 
 TString DecodeRestrictedBinaryString(const TString& data) {
diff --git a/yql/essentials/public/result_format/yql_result_format_data.cpp b/yql/essentials/public/result_format/yql_result_format_data.cpp
index a4aeb2545da..df6f553750d 100644
--- a/yql/essentials/public/result_format/yql_result_format_data.cpp
+++ b/yql/essentials/public/result_format/yql_result_format_data.cpp
@@ -112,7 +112,7 @@ public:
 class TOptionalProcessor : public IDataProcessor {
 public:
     TOptionalProcessor(std::unique_ptr<IDataProcessor>&& inner)
-        : Inner(std::move(inner))
+        : Inner_(std::move(inner))
     {}
 
     void Process(const NYT::TNode& dataNode, IDataVisitor& visitor) final {
@@ -122,7 +122,7 @@ public:
             visitor.OnEmptyOptional();
         } else {
             visitor.OnBeforeOptionalItem();
-            Inner->Process(dataNode.AsList()[0], visitor);
+            Inner_->Process(dataNode.AsList()[0], visitor);
             visitor.OnAfterOptionalItem();
         }
 
@@ -130,13 +130,13 @@ public:
     }
 
 private:
-    const std::unique_ptr<IDataProcessor> Inner;
+    const std::unique_ptr<IDataProcessor> Inner_;
 };
 
 class TListProcessor : public IDataProcessor {
 public:
     TListProcessor(std::unique_ptr<IDataProcessor>&& inner)
-        : Inner(std::move(inner))
+        : Inner_(std::move(inner))
     {}
 
     void Process(const NYT::TNode& dataNode, IDataVisitor& visitor) final {
@@ -144,7 +144,7 @@ public:
         visitor.OnBeginList();
         for (const auto& item : dataNode.AsList()) {
             visitor.OnBeforeListItem();
-            Inner->Process(item, visitor);
+            Inner_->Process(item, visitor);
             visitor.OnAfterListItem();
         }
 
@@ -152,22 +152,22 @@ public:
     }
 
 private:
-    const std::unique_ptr<IDataProcessor> Inner;
+    const std::unique_ptr<IDataProcessor> Inner_;
 };
 
 class TTupleProcessor : public IDataProcessor {
 public:
     TTupleProcessor(TVector<std::unique_ptr<IDataProcessor>>&& inners)
-        : Inners(std::move(inners))
+        : Inners_(std::move(inners))
     {}
 
     void Process(const NYT::TNode& dataNode, IDataVisitor& visitor) final {
         CHECK(dataNode.IsList());
         visitor.OnBeginTuple();
-        CHECK(dataNode.AsList().size() == Inners.size());
-        for (ui32 i = 0; i < Inners.size(); ++i) {
+        CHECK(dataNode.AsList().size() == Inners_.size());
+        for (ui32 i = 0; i < Inners_.size(); ++i) {
             visitor.OnBeforeTupleItem();
-            Inners[i]->Process(dataNode.AsList()[i], visitor);
+            Inners_[i]->Process(dataNode.AsList()[i], visitor);
             visitor.OnAfterTupleItem();
         }
 
@@ -175,22 +175,22 @@ public:
     }
 
 private:
-    const TVector<std::unique_ptr<IDataProcessor>> Inners;
+    const TVector<std::unique_ptr<IDataProcessor>> Inners_;
 };
 
 class TStructProcessor : public IDataProcessor {
 public:
     TStructProcessor(TVector<std::unique_ptr<IDataProcessor>>&& inners)
-        : Inners(std::move(inners))
+        : Inners_(std::move(inners))
     {}
 
     void Process(const NYT::TNode& dataNode, IDataVisitor& visitor) final {
         CHECK(dataNode.IsList());
         visitor.OnBeginStruct();
-        CHECK(dataNode.AsList().size() == Inners.size());
-        for (ui32 i = 0; i < Inners.size(); ++i) {
+        CHECK(dataNode.AsList().size() == Inners_.size());
+        for (ui32 i = 0; i < Inners_.size(); ++i) {
             visitor.OnBeforeStructItem();
-            Inners[i]->Process(dataNode.AsList()[i], visitor);
+            Inners_[i]->Process(dataNode.AsList()[i], visitor);
             visitor.OnAfterStructItem();
         }
 
@@ -198,14 +198,14 @@ public:
     }
 
 private:
-    const TVector<std::unique_ptr<IDataProcessor>> Inners;
+    const TVector<std::unique_ptr<IDataProcessor>> Inners_;
 };
 
 class TDictProcessor : public IDataProcessor {
 public:
     TDictProcessor(std::unique_ptr<IDataProcessor>&& innerKey, std::unique_ptr<IDataProcessor>&& innerPayload)
-        : InnerKey(std::move(innerKey))
-        , InnerPayload(std::move(innerPayload))
+        : InnerKey_(std::move(innerKey))
+        , InnerPayload_(std::move(innerPayload))
     {}
 
     void Process(const NYT::TNode& dataNode, IDataVisitor& visitor) final {
@@ -215,10 +215,10 @@ public:
             CHECK(item.IsList() && item.AsList().size() == 2);
             visitor.OnBeforeDictItem();
             visitor.OnBeforeDictKey();
-            InnerKey->Process(item.AsList()[0], visitor);
+            InnerKey_->Process(item.AsList()[0], visitor);
             visitor.OnAfterDictKey();
             visitor.OnBeforeDictPayload();
-            InnerPayload->Process(item.AsList()[1], visitor);
+            InnerPayload_->Process(item.AsList()[1], visitor);
             visitor.OnAfterDictPayload();
             visitor.OnAfterDictItem();
         }
@@ -227,28 +227,28 @@ public:
     }
 
 private:
-    const std::unique_ptr<IDataProcessor> InnerKey;
-    const std::unique_ptr<IDataProcessor> InnerPayload;
+    const std::unique_ptr<IDataProcessor> InnerKey_;
+    const std::unique_ptr<IDataProcessor> InnerPayload_;
 };
 
 class TVariantProcessor : public IDataProcessor {
 public:
     TVariantProcessor(TVector<std::unique_ptr<IDataProcessor>>&& inners)
-        : Inners(std::move(inners))
+        : Inners_(std::move(inners))
     {}
 
     void Process(const NYT::TNode& dataNode, IDataVisitor& visitor) final {
         CHECK(dataNode.IsList() && dataNode.AsList().size() == 2);
         CHECK(dataNode.AsList()[0].IsString());
         ui32 index = FromString<ui32>(dataNode.AsList()[0].AsString());
-        CHECK(index < Inners.size());
+        CHECK(index < Inners_.size());
         visitor.OnBeginVariant(index);
-        Inners[index]->Process(dataNode.AsList()[1], visitor);
+        Inners_[index]->Process(dataNode.AsList()[1], visitor);
         visitor.OnEndVariant();
     }
 
 private:
-    const TVector<std::unique_ptr<IDataProcessor>> Inners;
+    const TVector<std::unique_ptr<IDataProcessor>> Inners_;
 };
 
 class TPgProcessor : public IDataProcessor {
@@ -269,162 +269,162 @@ public:
 class TDataProcessorBuilder : public TThrowingTypeVisitor {
 public:
     TDataProcessorBuilder() {
-        IsVariant.push_back(false);
+        IsVariant_.push_back(false);
     }
 
     IDataProcessor& GetResult() {
-        CHECK(Stack.size() == 1);
-        return *Stack.front();
+        CHECK(Stack_.size() == 1);
+        return *Stack_.front();
     }
 
     void OnVoid() final {
-        Stack.push_back(std::make_unique<TVoidProcessor>());
+        Stack_.push_back(std::make_unique<TVoidProcessor>());
     }
 
     void OnNull() final {
-        Stack.push_back(std::make_unique<TNullProcessor>());
+        Stack_.push_back(std::make_unique<TNullProcessor>());
     }
 
     void OnEmptyList() final {
-        Stack.push_back(std::make_unique<TEmptyListProcessor>());
+        Stack_.push_back(std::make_unique<TEmptyListProcessor>());
     }
 
     void OnEmptyDict() final {
-        Stack.push_back(std::make_unique<TEmptyDictProcessor>());
+        Stack_.push_back(std::make_unique<TEmptyDictProcessor>());
     }
 
     void OnBool() final {
-        Stack.push_back(std::make_unique<TBoolProcessor>());
+        Stack_.push_back(std::make_unique<TBoolProcessor>());
     }
 
     void OnInt8() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<i8, &IDataVisitor::OnInt8>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<i8, &IDataVisitor::OnInt8>>());
     }
 
     void OnUint8() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<ui8, &IDataVisitor::OnUint8>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<ui8, &IDataVisitor::OnUint8>>());
     }
 
     void OnInt16() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<i16, &IDataVisitor::OnInt16>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<i16, &IDataVisitor::OnInt16>>());
     }
 
     void OnUint16() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<ui16, &IDataVisitor::OnUint16>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<ui16, &IDataVisitor::OnUint16>>());
     }
 
     void OnInt32() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<i32, &IDataVisitor::OnInt32>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<i32, &IDataVisitor::OnInt32>>());
     }
 
     void OnUint32() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<ui32, &IDataVisitor::OnUint32>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<ui32, &IDataVisitor::OnUint32>>());
     }
 
     void OnInt64() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnInt64>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnInt64>>());
     }
 
     void OnUint64() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<ui64, &IDataVisitor::OnUint64>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<ui64, &IDataVisitor::OnUint64>>());
     }
 
     void OnFloat() final {
-        Stack.push_back(std::make_unique<TFloatingProcessor<float, FloatFromString, &IDataVisitor::OnFloat>>());
+        Stack_.push_back(std::make_unique<TFloatingProcessor<float, FloatFromString, &IDataVisitor::OnFloat>>());
     }
 
     void OnDouble() final {
-        Stack.push_back(std::make_unique<TFloatingProcessor<double, DoubleFromString, &IDataVisitor::OnDouble>>());
-    }    
+        Stack_.push_back(std::make_unique<TFloatingProcessor<double, DoubleFromString, &IDataVisitor::OnDouble>>());
+    }
 
     void OnString() final {
-        Stack.push_back(std::make_unique<TStringProcessor<&IDataVisitor::OnString>>());
+        Stack_.push_back(std::make_unique<TStringProcessor<&IDataVisitor::OnString>>());
     }
 
     void OnUtf8() final {
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnUtf8>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnUtf8>>());
     }
 
     void OnYson() final {
-        Stack.push_back(std::make_unique<TYsonProcessor>());
+        Stack_.push_back(std::make_unique<TYsonProcessor>());
     }
 
     void OnJson() final {
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnJson>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnJson>>());
     }
 
     void OnJsonDocument() final {
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnJsonDocument>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnJsonDocument>>());
     }
 
     void OnUuid() final {
-        Stack.push_back(std::make_unique<TStringProcessor<&IDataVisitor::OnUuid>>());
+        Stack_.push_back(std::make_unique<TStringProcessor<&IDataVisitor::OnUuid>>());
     }
 
     void OnDyNumber() final {
-        Stack.push_back(std::make_unique<TStringProcessor<&IDataVisitor::OnDyNumber>>());
+        Stack_.push_back(std::make_unique<TStringProcessor<&IDataVisitor::OnDyNumber>>());
     }
 
     void OnDate() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<ui16, &IDataVisitor::OnDate>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<ui16, &IDataVisitor::OnDate>>());
     }
 
     void OnDatetime() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<ui32, &IDataVisitor::OnDatetime>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<ui32, &IDataVisitor::OnDatetime>>());
     }
 
     void OnTimestamp() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<ui64, &IDataVisitor::OnTimestamp>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<ui64, &IDataVisitor::OnTimestamp>>());
     }
 
     void OnTzDate() final {
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzDate>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzDate>>());
     }
 
     void OnTzDatetime() final {
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzDatetime>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzDatetime>>());
     }
 
     void OnTzTimestamp() final {
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzTimestamp>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzTimestamp>>());
     }
 
     void OnInterval() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnInterval>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnInterval>>());
     }
 
     void OnDate32() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<i32, &IDataVisitor::OnDate32>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<i32, &IDataVisitor::OnDate32>>());
     }
 
     void OnDatetime64() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnDatetime64>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnDatetime64>>());
     }
 
     void OnTimestamp64() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnTimestamp64>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnTimestamp64>>());
     }
 
     void OnTzDate32() final {
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzDate32>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzDate32>>());
     }
 
     void OnTzDatetime64() final {
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzDatetime64>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzDatetime64>>());
     }
 
     void OnTzTimestamp64() final {
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzTimestamp64>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnTzTimestamp64>>());
     }
 
     void OnInterval64() final {
-        Stack.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnInterval64>>());
+        Stack_.push_back(std::make_unique<TIntegerProcessor<i64, &IDataVisitor::OnInterval64>>());
     }
 
     void OnDecimal(ui32 precision, ui32 scale) final {
         Y_UNUSED(precision);
         Y_UNUSED(scale);
-        Stack.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnDecimal>>());
+        Stack_.push_back(std::make_unique<TUtf8Processor<&IDataVisitor::OnDecimal>>());
     }
 
     void OnBeginOptional() final {
@@ -432,7 +432,7 @@ public:
 
     void OnEndOptional() final {
         auto inner = Pop();
-        Stack.push_back(std::make_unique<TOptionalProcessor>(std::move(inner)));
+        Stack_.push_back(std::make_unique<TOptionalProcessor>(std::move(inner)));
     }
 
     void OnBeginList() final {
@@ -440,52 +440,52 @@ public:
 
     void OnEndList() final {
         auto inner = Pop();
-        Stack.push_back(std::make_unique<TListProcessor>(std::move(inner)));
+        Stack_.push_back(std::make_unique<TListProcessor>(std::move(inner)));
     }
 
     void OnBeginTuple() final {
-        IsVariant.push_back(false);
-        Args.push_back(0);
+        IsVariant_.push_back(false);
+        Args_.push_back(0);
     }
 
     void OnTupleItem() final {
-        Args.back() += 1;
+        Args_.back() += 1;
     }
 
     void OnEndTuple() final {
-        const ui32 width = Args.back();
+        const ui32 width = Args_.back();
         auto inners = Pop(width);
-        if (!IsVariant[IsVariant.size() - 2]) {
-            Stack.push_back(std::make_unique<TTupleProcessor>(std::move(inners)));
+        if (!IsVariant_[IsVariant_.size() - 2]) {
+            Stack_.push_back(std::make_unique<TTupleProcessor>(std::move(inners)));
         } else {
-            Stack.push_back(std::make_unique<TVariantProcessor>(std::move(inners)));
+            Stack_.push_back(std::make_unique<TVariantProcessor>(std::move(inners)));
         }
 
-        Args.pop_back();
-        IsVariant.pop_back();
+        Args_.pop_back();
+        IsVariant_.pop_back();
     }
 
     void OnBeginStruct() final {
-        IsVariant.push_back(false);
-        Args.push_back(0);
+        IsVariant_.push_back(false);
+        Args_.push_back(0);
     }
 
     void OnStructItem(TStringBuf member) final {
         Y_UNUSED(member);
-        Args.back() += 1;
+        Args_.back() += 1;
     }
 
     void OnEndStruct() final {
-        const ui32 width = Args.back();
+        const ui32 width = Args_.back();
         auto inners = Pop(width);
-        if (!IsVariant[IsVariant.size() - 2]) {
-            Stack.push_back(std::make_unique<TStructProcessor>(std::move(inners)));
+        if (!IsVariant_[IsVariant_.size() - 2]) {
+            Stack_.push_back(std::make_unique<TStructProcessor>(std::move(inners)));
         } else {
-            Stack.push_back(std::make_unique<TVariantProcessor>(std::move(inners)));
+            Stack_.push_back(std::make_unique<TVariantProcessor>(std::move(inners)));
         }
 
-        Args.pop_back();
-        IsVariant.pop_back();
+        Args_.pop_back();
+        IsVariant_.pop_back();
     }
 
     void OnBeginDict() final {
@@ -500,15 +500,15 @@ public:
     void OnEndDict() final {
         auto innerPayload = Pop();
         auto innerKey = Pop();
-        Stack.push_back(std::make_unique<TDictProcessor>(std::move(innerKey), std::move(innerPayload)));
+        Stack_.push_back(std::make_unique<TDictProcessor>(std::move(innerKey), std::move(innerPayload)));
     }
 
     void OnBeginVariant() {
-        IsVariant.push_back(true);
+        IsVariant_.push_back(true);
     }
 
     void OnEndVariant() {
-        IsVariant.pop_back();
+        IsVariant_.pop_back();
     }
 
     void OnBeginTagged(TStringBuf tag) {
@@ -521,19 +521,19 @@ public:
     void OnPg(TStringBuf name, TStringBuf category) final {
         Y_UNUSED(name);
         Y_UNUSED(category);
-        Stack.push_back(std::make_unique<TPgProcessor>());
+        Stack_.push_back(std::make_unique<TPgProcessor>());
     }
 
 private:
     std::unique_ptr<IDataProcessor> Pop() {
-        CHECK(!Stack.empty());
-        auto res = std::move(Stack.back());
-        Stack.pop_back();
+        CHECK(!Stack_.empty());
+        auto res = std::move(Stack_.back());
+        Stack_.pop_back();
         return res;
     }
 
     TVector<std::unique_ptr<IDataProcessor>> Pop(ui32 width) {
-        CHECK(Stack.size() >= width);
+        CHECK(Stack_.size() >= width);
         TVector<std::unique_ptr<IDataProcessor>> res;
         res.reserve(width);
         for (ui32 i = 0; i < width; ++i) {
@@ -545,9 +545,9 @@ private:
     }
 
 private:
-    TVector<std::unique_ptr<IDataProcessor>> Stack;
-    TVector<ui32> Args;
-    TVector<bool> IsVariant;
+    TVector<std::unique_ptr<IDataProcessor>> Stack_;
+    TVector<ui32> Args_;
+    TVector<bool> IsVariant_;
 };
 
 void ParseData(const NYT::TNode& typeNode, const NYT::TNode& dataNode, IDataVisitor& visitor) {
@@ -557,12 +557,12 @@ void ParseData(const NYT::TNode& typeNode, const NYT::TNode& dataNode, IDataVisi
 }
 
 TDataBuilder::TDataBuilder() {
-    Stack.push_back(&Root);
+    Stack_.push_back(&Root_);
 }
 
 const NYT::TNode& TDataBuilder::GetResult() const {
-    CHECK(Stack.size() == 1);
-    return Root;
+    CHECK(Stack_.size() == 1);
+    return Root_;
 }
 
 void TDataBuilder::OnVoid() {
@@ -843,15 +843,15 @@ void TDataBuilder::OnPg(TMaybe<TStringBuf> value, bool isUtf8) {
 }
 
 NYT::TNode& TDataBuilder::Top() {
-    return *Stack.back();
+    return *Stack_.back();
 }
 
 void TDataBuilder::Push(NYT::TNode* value) {
-    Stack.push_back(value);
+    Stack_.push_back(value);
 }
 
 void TDataBuilder::Pop() {
-    Stack.pop_back();
+    Stack_.pop_back();
 }
 
 void TSameActionDataVisitor::OnVoid() {
diff --git a/yql/essentials/public/result_format/yql_result_format_data.h b/yql/essentials/public/result_format/yql_result_format_data.h
index 58290a5c410..5c03716d6e1 100644
--- a/yql/essentials/public/result_format/yql_result_format_data.h
+++ b/yql/essentials/public/result_format/yql_result_format_data.h
@@ -238,8 +238,8 @@ private:
     void Pop();
 
 private:
-    NYT::TNode Root;
-    TVector<NYT::TNode*> Stack;
+    NYT::TNode Root_;
+    TVector<NYT::TNode*> Stack_;
 };
 
 }
diff --git a/yql/essentials/public/result_format/yql_result_format_type.cpp b/yql/essentials/public/result_format/yql_result_format_type.cpp
index aaccde3d27a..39ce7334cde 100644
--- a/yql/essentials/public/result_format/yql_result_format_type.cpp
+++ b/yql/essentials/public/result_format/yql_result_format_type.cpp
@@ -202,12 +202,12 @@ void ParseType(const NYT::TNode& typeNode, ITypeVisitor& visitor) {
 }
 
 TTypeBuilder::TTypeBuilder() {
-    Stack.push_back(&Root);
+    Stack_.push_back(&Root_);
 }
 
 const NYT::TNode& TTypeBuilder::GetResult() const {
-    CHECK(Stack.size() == 1);
-    return Root;
+    CHECK(Stack_.size() == 1);
+    return Root_;
 }
 
 void TTypeBuilder::OnVoid() {
@@ -360,7 +360,7 @@ void TTypeBuilder::OnDecimal(ui32 precision, ui32 scale) {
 }
 
 NYT::TNode& TTypeBuilder::Top() {
-    return *Stack.back();
+    return *Stack_.back();
 }
 
 void TTypeBuilder::OnBeginOptional() {
@@ -383,14 +383,14 @@ void TTypeBuilder::OnEndList() {
 
 void TTypeBuilder::OnBeginTuple() {
     Top() = NYT::TNode().Add("TupleType").Add(NYT::TNode::CreateList());
-    Stack.push_back(&Top().AsList()[1]);
+    Stack_.push_back(&Top().AsList()[1]);
 }
 
 void TTypeBuilder::OnTupleItem() {
     if (!Top().AsList().empty()) {
         Pop();
     }
-    
+
     Push();
 }
 
@@ -404,7 +404,7 @@ void TTypeBuilder::OnEndTuple() {
 
 void TTypeBuilder::OnBeginStruct() {
     Top() = NYT::TNode().Add("StructType").Add(NYT::TNode::CreateList());
-    Stack.push_back(&Top().AsList()[1]);
+    Stack_.push_back(&Top().AsList()[1]);
 }
 
 void TTypeBuilder::OnStructItem(TStringBuf member) {
@@ -416,7 +416,7 @@ void TTypeBuilder::OnStructItem(TStringBuf member) {
     auto& pair = Top().AsList().back();
     pair.Add(member);
     auto ptr = &pair.Add();
-    Stack.push_back(ptr);
+    Stack_.push_back(ptr);
 }
 
 void TTypeBuilder::OnEndStruct() {
@@ -429,7 +429,7 @@ void TTypeBuilder::OnEndStruct() {
 
 void TTypeBuilder::OnBeginDict() {
     Top() = NYT::TNode().Add("DictType");
-    Stack.push_back(&Top());
+    Stack_.push_back(&Top());
 }
 
 
@@ -471,11 +471,11 @@ void TTypeBuilder::OnPg(TStringBuf name, TStringBuf category) {
 
 void TTypeBuilder::Push() {
     auto ptr = &Top().Add();
-    Stack.push_back(ptr);
+    Stack_.push_back(ptr);
 }
 
 void TTypeBuilder::Pop() {
-    Stack.pop_back();
+    Stack_.pop_back();
 }
 
 void TSameActionTypeVisitor::OnVoid() {
diff --git a/yql/essentials/public/result_format/yql_result_format_type.h b/yql/essentials/public/result_format/yql_result_format_type.h
index 0eb0b173158..360f88a4063 100644
--- a/yql/essentials/public/result_format/yql_result_format_type.h
+++ b/yql/essentials/public/result_format/yql_result_format_type.h
@@ -211,8 +211,8 @@ private:
     void Pop();
 
 private:
-    NYT::TNode Root;
-    TVector<NYT::TNode*> Stack;
+    NYT::TNode Root_;
+    TVector<NYT::TNode*> Stack_;
 };
 
 }
diff --git a/yql/essentials/public/udf/arrow/args_dechunker.cpp b/yql/essentials/public/udf/arrow/args_dechunker.cpp
index 1104c0e51ba..f52e1839836 100644
--- a/yql/essentials/public/udf/arrow/args_dechunker.cpp
+++ b/yql/essentials/public/udf/arrow/args_dechunker.cpp
@@ -7,13 +7,13 @@ namespace NYql {
 namespace NUdf {
 
 TArgsDechunker::TArgsDechunker(std::vector<arrow::Datum>&& args)
-    : Args(std::move(args))
-    , Arrays(Args.size())
+    : Args_(std::move(args))
+    , Arrays_(Args_.size())
 {
-    for (size_t i = 0; i < Args.size(); ++i) {
-        if (Args[i].is_arraylike()) {
-            ForEachArrayData(Args[i], [&](const auto& data) {
-                Arrays[i].push_back(data);
+    for (size_t i = 0; i < Args_.size(); ++i) {
+        if (Args_[i].is_arraylike()) {
+            ForEachArrayData(Args_[i], [&](const auto& data) {
+                Arrays_[i].push_back(data);
             });
         }
     }
@@ -26,24 +26,24 @@ bool TArgsDechunker::Next(std::vector<arrow::Datum>& chunk) {
 
 bool TArgsDechunker::Next(std::vector<arrow::Datum>& chunk, ui64& chunkLen) {
     chunkLen = 0;
-    if (Finish) {
+    if (Finish_) {
         return false;
     }
 
     size_t minSize = Max<size_t>();
     bool haveData = false;
-    chunk.resize(Args.size());
-    for (size_t i = 0; i < Args.size(); ++i) {
-        if (Args[i].is_scalar()) {
-            chunk[i] = Args[i];
+    chunk.resize(Args_.size());
+    for (size_t i = 0; i < Args_.size(); ++i) {
+        if (Args_[i].is_scalar()) {
+            chunk[i] = Args_[i];
             continue;
         }
-        while (!Arrays[i].empty() && Arrays[i].front()->length == 0) {
-            Arrays[i].pop_front();
+        while (!Arrays_[i].empty() && Arrays_[i].front()->length == 0) {
+            Arrays_[i].pop_front();
         }
-        if (!Arrays[i].empty()) {
+        if (!Arrays_[i].empty()) {
             haveData = true;
-            minSize = std::min<size_t>(minSize, Arrays[i].front()->length);
+            minSize = std::min<size_t>(minSize, Arrays_[i].front()->length);
         } else {
             minSize = 0;
         }
@@ -51,14 +51,14 @@ bool TArgsDechunker::Next(std::vector<arrow::Datum>& chunk, ui64& chunkLen) {
 
     Y_ENSURE(!haveData || minSize > 0, "Block length mismatch");
     if (!haveData) {
-        Finish = true;
+        Finish_ = true;
         return false;
     }
 
-    for (size_t i = 0; i < Args.size(); ++i) {
-        if (!Args[i].is_scalar()) {
-            Y_ENSURE(!Arrays[i].empty(), "Block length mismatch");
-            chunk[i] = arrow::Datum(Chop(Arrays[i].front(), minSize));
+    for (size_t i = 0; i < Args_.size(); ++i) {
+        if (!Args_[i].is_scalar()) {
+            Y_ENSURE(!Arrays_[i].empty(), "Block length mismatch");
+            chunk[i] = arrow::Datum(Chop(Arrays_[i].front(), minSize));
         }
     }
     chunkLen = minSize;
diff --git a/yql/essentials/public/udf/arrow/args_dechunker.h b/yql/essentials/public/udf/arrow/args_dechunker.h
index af267a8c9ae..6aed9491b41 100644
--- a/yql/essentials/public/udf/arrow/args_dechunker.h
+++ b/yql/essentials/public/udf/arrow/args_dechunker.h
@@ -17,9 +17,9 @@ public:
     bool Next(std::vector<arrow::Datum>& chunk, ui64& chunkLen);
 
 private:
-    const std::vector<arrow::Datum> Args;
-    std::vector<std::deque<std::shared_ptr<arrow::ArrayData>>> Arrays;
-    bool Finish = false;
+    const std::vector<arrow::Datum> Args_;
+    std::vector<std::deque<std::shared_ptr<arrow::ArrayData>>> Arrays_;
+    bool Finish_ = false;
 };
 
 }
diff --git a/yql/essentials/public/udf/arrow/block_builder.h b/yql/essentials/public/udf/arrow/block_builder.h
index 13808b78b19..2be1d26c3bd 100644
--- a/yql/essentials/public/udf/arrow/block_builder.h
+++ b/yql/essentials/public/udf/arrow/block_builder.h
@@ -86,14 +86,14 @@ public:
     };
 
     TArrayBuilderBase(const ITypeInfoHelper& typeInfoHelper, std::shared_ptr<arrow::DataType> arrowType, arrow::MemoryPool& pool, size_t maxLen, const TParams& params)
-        : ArrowType(std::move(arrowType))
-        , Pool(&pool)
-        , MaxLen(maxLen)
-        , MaxBlockSizeInBytes(typeInfoHelper.GetMaxBlockBytes())
-        , MinFillPercentage(params.MinFillPercentage)
+        : ArrowType_(std::move(arrowType))
+        , Pool_(&pool)
+        , MaxLen_(maxLen)
+        , MaxBlockSizeInBytes_(typeInfoHelper.GetMaxBlockBytes())
+        , MinFillPercentage_(params.MinFillPercentage)
         , TotalAllocated_(params.TotalAllocated)
     {
-        Y_ABORT_UNLESS(ArrowType);
+        Y_ABORT_UNLESS(ArrowType_);
         Y_ABORT_UNLESS(maxLen > 0);
     }
 
@@ -103,37 +103,37 @@ public:
     }
 
     size_t MaxLength() const final {
-        return MaxLen;
+        return MaxLen_;
     }
 
     void Add(NUdf::TUnboxedValuePod value) final {
-        Y_DEBUG_ABORT_UNLESS(CurrLen < MaxLen);
+        Y_DEBUG_ABORT_UNLESS(CurrLen_ < MaxLen_);
         DoAdd(value);
-        CurrLen++;
+        CurrLen_++;
     }
 
     void Add(TBlockItem value) final {
-        Y_DEBUG_ABORT_UNLESS(CurrLen < MaxLen);
+        Y_DEBUG_ABORT_UNLESS(CurrLen_ < MaxLen_);
         DoAdd(value);
-        CurrLen++;
+        CurrLen_++;
     }
 
     void Add(TBlockItem value, size_t count) final {
-        Y_DEBUG_ABORT_UNLESS(CurrLen + count <= MaxLen);
+        Y_DEBUG_ABORT_UNLESS(CurrLen_ + count <= MaxLen_);
         DoAdd(value, count);
-        CurrLen += count;
+        CurrLen_ += count;
     }
 
     void Add(TInputBuffer& input) final {
-        Y_DEBUG_ABORT_UNLESS(CurrLen < MaxLen);
+        Y_DEBUG_ABORT_UNLESS(CurrLen_ < MaxLen_);
         DoAdd(input);
-        CurrLen++;
+        CurrLen_++;
     }
 
     void AddDefault() {
-        Y_DEBUG_ABORT_UNLESS(CurrLen < MaxLen);
+        Y_DEBUG_ABORT_UNLESS(CurrLen_ < MaxLen_);
         DoAddDefault();
-        CurrLen++;
+        CurrLen_++;
     }
 
     inline void AddMany(const arrow::ArrayData& array, ui64 beginIndex, size_t count) {
@@ -149,13 +149,13 @@ public:
     void AddMany(const arrow::ArrayData& array, size_t popCount, const ui8* sparseBitmap, size_t bitmapSize) final {
         Y_ABORT_UNLESS(size_t(array.length) == bitmapSize);
         Y_ABORT_UNLESS(popCount <= bitmapSize);
-        Y_ABORT_UNLESS(CurrLen + popCount <= MaxLen);
+        Y_ABORT_UNLESS(CurrLen_ + popCount <= MaxLen_);
 
         if (popCount) {
             DoAddMany(array, sparseBitmap, popCount);
         }
 
-        CurrLen += popCount;
+        CurrLen_ += popCount;
     }
 
     void AddMany(const TArrayDataItem* arrays, size_t arrayCount, ui64 beginIndex, size_t count) final {
@@ -184,19 +184,19 @@ public:
                 }
             }
         }
-        CurrLen += count;
+        CurrLen_ += count;
     }
 
     void AddMany(const TArrayDataItem* arrays, size_t arrayCount, const ui64* indexes, size_t count) final {
         Y_ABORT_UNLESS(arrays);
         Y_ABORT_UNLESS(arrayCount > 0);
         Y_ABORT_UNLESS(indexes);
-        Y_ABORT_UNLESS(CurrLen + count <= MaxLen);
+        Y_ABORT_UNLESS(CurrLen_ + count <= MaxLen_);
 
         if (arrayCount == 1) {
             Y_ABORT_UNLESS(arrays->Data);
             DoAddMany(*arrays->Data, indexes, count);
-            CurrLen += count;
+            CurrLen_ += count;
         } else {
             const IArrayBuilder::TArrayDataItem* currData = nullptr;
             TVector<ui64> currDataIndexes;
@@ -209,7 +209,7 @@ public:
 
                 if (data != currData) {
                     DoAddMany(*currData->Data, currDataIndexes.data(), currDataIndexes.size());
-                    CurrLen += currDataIndexes.size();
+                    CurrLen_ += currDataIndexes.size();
                     currDataIndexes.clear();
                     currData = data;
                 }
@@ -217,7 +217,7 @@ public:
             }
             if (!currDataIndexes.empty()) {
                 DoAddMany(*currData->Data, currDataIndexes.data(), currDataIndexes.size());
-                CurrLen += currDataIndexes.size();
+                CurrLen_ += currDataIndexes.size();
             }
         }
     }
@@ -234,7 +234,7 @@ public:
 
     TBlockArrayTree::Ptr BuildTree(bool finish) {
         auto result = DoBuildTree(finish);
-        CurrLen = 0;
+        CurrLen_ = 0;
         return result;
     }
 protected:
@@ -307,12 +307,12 @@ private:
 
 protected:
     size_t GetCurrLen() const {
-        return CurrLen;
+        return CurrLen_;
     }
 
     void SetCurrLen(size_t len) {
-        Y_ABORT_UNLESS(len <= MaxLen);
-        CurrLen = len;
+        Y_ABORT_UNLESS(len <= MaxLen_);
+        CurrLen_ = len;
     }
 
     void Reserve() {
@@ -328,13 +328,13 @@ protected:
         }
     }
 
-    const std::shared_ptr<arrow::DataType> ArrowType;
-    arrow::MemoryPool* const Pool;
-    const size_t MaxLen;
-    const size_t MaxBlockSizeInBytes;
-    const TMaybe<ui8> MinFillPercentage;
+    const std::shared_ptr<arrow::DataType> ArrowType_;
+    arrow::MemoryPool* const Pool_;
+    const size_t MaxLen_;
+    const size_t MaxBlockSizeInBytes_;
+    const TMaybe<ui8> MinFillPercentage_;
 private:
-    size_t CurrLen = 0;
+    size_t CurrLen_ = 0;
     size_t* TotalAllocated_ = nullptr;
 };
 
@@ -358,11 +358,11 @@ public:
     }
 
     TLayout* MutableData() {
-        return DataPtr;
+        return DataPtr_;
     }
 
     ui8* MutableValidMask() {
-        return NullPtr;
+        return NullPtr_;
     }
 
     void DoAdd(NUdf::TUnboxedValuePod value) final {
@@ -371,7 +371,7 @@ public:
                 DoAddNull();
                 return;
             }
-            NullPtr[GetCurrLen()] = 1;
+            NullPtr_[GetCurrLen()] = 1;
         }
         static_cast<TDerived*>(this)->DoAddNotNull(value);
     }
@@ -382,14 +382,14 @@ public:
                 DoAddNull();
                 return;
             }
-            NullPtr[GetCurrLen()] = 1;
+            NullPtr_[GetCurrLen()] = 1;
         }
         static_cast<TDerived*>(this)->DoAddNotNull(value);
     }
 
     void DoAddNull() {
         if constexpr (Nullable) {
-            NullPtr[GetCurrLen()] = 0;
+            NullPtr_[GetCurrLen()] = 0;
             PlaceItem(TLayout{});
         }
     }
@@ -397,11 +397,11 @@ public:
     void DoAdd(TBlockItem value, size_t count) final {
         if constexpr (Nullable) {
             if (!value) {
-                std::fill(NullPtr + GetCurrLen(), NullPtr + GetCurrLen() + count, 0);
-                std::fill(DataPtr + GetCurrLen(), DataPtr + GetCurrLen() + count, TLayout{});
+                std::fill(NullPtr_ + GetCurrLen(), NullPtr_ + GetCurrLen() + count, 0);
+                std::fill(DataPtr_ + GetCurrLen(), DataPtr_ + GetCurrLen() + count, TLayout{});
                 return;
             }
-            std::fill(NullPtr + GetCurrLen(), NullPtr + GetCurrLen() + count, 1);
+            std::fill(NullPtr_ + GetCurrLen(), NullPtr_ + GetCurrLen() + count, 1);
         }
 
         static_cast<TDerived*>(this)->DoAddNotNull(value, count);
@@ -419,7 +419,7 @@ public:
 
     void DoAddDefault() final {
         if constexpr (Nullable) {
-            NullPtr[GetCurrLen()] = 1;
+            NullPtr_[GetCurrLen()] = 1;
         }
         PlaceItem(TLayout{});
     }
@@ -428,16 +428,16 @@ public:
         Y_ABORT_UNLESS(array.buffers.size() > 1);
         if constexpr (Nullable) {
             if (array.buffers.front()) {
-                ui8* dstBitmap = NullPtr + GetCurrLen();
+                ui8* dstBitmap = NullPtr_ + GetCurrLen();
                 CompressAsSparseBitmap(array.GetValues<ui8>(0, 0), array.offset, sparseBitmap, dstBitmap, array.length);
             } else {
-                ui8* dstBitmap = NullPtr + GetCurrLen();
+                ui8* dstBitmap = NullPtr_ + GetCurrLen();
                 std::fill_n(dstBitmap, popCount, 1);
             }
         }
 
         const TLayout* src = array.GetValues<TLayout>(1);
-        TLayout* dst = DataPtr + GetCurrLen();
+        TLayout* dst = DataPtr_ + GetCurrLen();
         CompressArray(src, sparseBitmap, dst, array.length);
     }
 
@@ -445,13 +445,13 @@ public:
         Y_ABORT_UNLESS(array.buffers.size() > 1);
         if constexpr (Nullable) {
             for (size_t i = beginIndex; i < beginIndex + count; ++i) {
-                NullPtr[GetCurrLen() + i - beginIndex] = !IsNull(array, i);
+                NullPtr_[GetCurrLen() + i - beginIndex] = !IsNull(array, i);
             }
         }
 
         const TLayout* values = array.GetValues<TLayout>(1);
         for (size_t i = beginIndex; i < beginIndex + count; ++i) {
-            ::new(DataPtr + GetCurrLen() + i - beginIndex) TLayout(values[i]);
+            ::new(DataPtr_ + GetCurrLen() + i - beginIndex) TLayout(values[i]);
         }
     }
 
@@ -459,13 +459,13 @@ public:
         Y_ABORT_UNLESS(array.buffers.size() > 1);
         if constexpr (Nullable) {
             for (size_t i = 0; i < count; ++i) {
-                NullPtr[GetCurrLen() + i] = !IsNull(array, indexes[i]);
+                NullPtr_[GetCurrLen() + i] = !IsNull(array, indexes[i]);
             }
         }
 
         const TLayout* values = array.GetValues<TLayout>(1);
         for (size_t i = 0; i < count; ++i) {
-            ::new(DataPtr + GetCurrLen() + i) TLayout(values[indexes[i]]);
+            ::new(DataPtr_ + GetCurrLen() + i) TLayout(values[indexes[i]]);
         }
     }
 
@@ -473,18 +473,18 @@ public:
         const size_t len = GetCurrLen();
         std::shared_ptr<arrow::Buffer> nulls;
         if constexpr (Nullable) {
-            NullBuilder->UnsafeAdvance(len);
-            nulls = NullBuilder->Finish();
-            nulls = MakeDenseBitmap(nulls->data(), len, Pool);
+            NullBuilder_->UnsafeAdvance(len);
+            nulls = NullBuilder_->Finish();
+            nulls = MakeDenseBitmap(nulls->data(), len, Pool_);
         }
-        DataBuilder->UnsafeAdvance(len);
-        std::shared_ptr<arrow::Buffer> data = DataBuilder->Finish();
+        DataBuilder_->UnsafeAdvance(len);
+        std::shared_ptr<arrow::Buffer> data = DataBuilder_->Finish();
 
         TBlockArrayTree::Ptr result = std::make_shared<TBlockArrayTree>();
-        result->Payload.push_back(arrow::ArrayData::Make(ArrowType, len, {nulls, data}));
+        result->Payload.push_back(arrow::ArrayData::Make(ArrowType_, len, {nulls, data}));
 
-        NullBuilder.reset();
-        DataBuilder.reset();
+        NullBuilder_.reset();
+        DataBuilder_.reset();
         if (!finish) {
             Reserve();
         }
@@ -492,29 +492,29 @@ public:
     }
 protected:
     void PlaceItem(TLayout&& value)  {
-        ::new(DataPtr + GetCurrLen()) TLayout(std::move(value));
+        ::new(DataPtr_ + GetCurrLen()) TLayout(std::move(value));
     }
 
-    TLayout* DataPtr = nullptr;
+    TLayout* DataPtr_ = nullptr;
 
 private:
     size_t DoReserve() final {
-        DataBuilder = std::make_unique<TTypedBufferBuilder<TLayout>>(Pool, MinFillPercentage);
-        DataBuilder->Reserve(MaxLen + 1);
-        DataPtr = DataBuilder->MutableData();
-        auto result = DataBuilder->Capacity();
+        DataBuilder_ = std::make_unique<TTypedBufferBuilder<TLayout>>(Pool_, MinFillPercentage_);
+        DataBuilder_->Reserve(MaxLen_ + 1);
+        DataPtr_ = DataBuilder_->MutableData();
+        auto result = DataBuilder_->Capacity();
         if constexpr (Nullable) {
-            NullBuilder = std::make_unique<TTypedBufferBuilder<ui8>>(Pool, MinFillPercentage);
-            NullBuilder->Reserve(MaxLen + 1);
-            NullPtr = NullBuilder->MutableData();
-            result += NullBuilder->Capacity();
+            NullBuilder_ = std::make_unique<TTypedBufferBuilder<ui8>>(Pool_, MinFillPercentage_);
+            NullBuilder_->Reserve(MaxLen_ + 1);
+            NullPtr_ = NullBuilder_->MutableData();
+            result += NullBuilder_->Capacity();
         }
         return result;
     }
 
-    std::unique_ptr<TTypedBufferBuilder<ui8>> NullBuilder;
-    std::unique_ptr<TTypedBufferBuilder<TLayout>> DataBuilder;
-    ui8* NullPtr = nullptr;
+    std::unique_ptr<TTypedBufferBuilder<ui8>> NullBuilder_;
+    std::unique_ptr<TTypedBufferBuilder<TLayout>> DataBuilder_;
+    ui8* NullPtr_ = nullptr;
 };
 
 template<typename TLayout, bool Nullable>
@@ -545,7 +545,7 @@ public:
     }
 
     void DoAddNotNull(TBlockItem value, size_t count) {
-        std::fill(this->DataPtr + this->GetCurrLen(), this->DataPtr + this->GetCurrLen() + count, value.Get<TLayout>());
+        std::fill(this->DataPtr_ + this->GetCurrLen(), this->DataPtr_ + this->GetCurrLen() + count, value.Get<TLayout>());
     }
 };
 
@@ -577,7 +577,7 @@ public:
     }
 
     void DoAddNotNull(TBlockItem value, size_t count) {
-        std::fill(this->DataPtr + this->GetCurrLen(), this->DataPtr + this->GetCurrLen() + count, value.GetInt128());
+        std::fill(this->DataPtr_ + this->GetCurrLen(), this->DataPtr_ + this->GetCurrLen() + count, value.GetInt128());
     }
 };
 
@@ -616,7 +616,7 @@ public:
 
     void DoAddNotNull(TBlockItem item, size_t count) {
         for (size_t i = 0; i < count; ++i) {
-            ::new(this->DataPtr + this->GetCurrLen() + i) TUnboxedValue(FromBlockItem(item));
+            ::new(this->DataPtr_ + this->GetCurrLen() + i) TUnboxedValue(FromBlockItem(item));
         }
     }
 };
@@ -640,8 +640,8 @@ public:
 
     void SetPgBuilder(const NUdf::IPgBuilder* pgBuilder, i32 typeLen) {
         Y_ENSURE(PgString != EPgStringType::None);
-        PgBuilder = pgBuilder;
-        TypeLen = typeLen;
+        PgBuilder_ = pgBuilder;
+        TypeLen_ = typeLen;
     }
 
     void DoAdd(NUdf::TUnboxedValuePod value) final {
@@ -653,15 +653,15 @@ public:
 
         if constexpr (PgString == EPgStringType::CString) {
             static_assert(Nullable);
-            auto buf = PgBuilder->AsCStringBuffer(value);
+            auto buf = PgBuilder_->AsCStringBuffer(value);
             AddPgItem(buf);
         } else if constexpr (PgString == EPgStringType::Text) {
             static_assert(Nullable);
-            auto buf = PgBuilder->AsTextBuffer(value);
+            auto buf = PgBuilder_->AsTextBuffer(value);
             AddPgItem(buf);
         } else if constexpr (PgString == EPgStringType::Fixed) {
             static_assert(Nullable);
-            auto buf = PgBuilder->AsFixedStringBuffer(value, TypeLen);
+            auto buf = PgBuilder_->AsFixedStringBuffer(value, TypeLen_);
             AddPgItem(buf);
         } else {
             DoAdd(TBlockItem(value.AsStringRef()));
@@ -687,22 +687,22 @@ public:
     }
 
     ui8* AddNoFill(size_t size) {
-        size_t currentLen = DataBuilder->Length();
+        size_t currentLen = DataBuilder_->Length();
         // empty string can always be appended
-        if (size > 0 && currentLen + size > MaxBlockSizeInBytes) {
+        if (size > 0 && currentLen + size > MaxBlockSizeInBytes_) {
             if (currentLen) {
                 FlushChunk(false);
             }
-            if (size > MaxBlockSizeInBytes) {
+            if (size > MaxBlockSizeInBytes_) {
                 ReserveForLargeString(size);
             }
         }
 
         AppendCurrentOffset();
-        auto ret = DataBuilder->End();
-        DataBuilder->UnsafeAdvance(size);
+        auto ret = DataBuilder_->End();
+        DataBuilder_->UnsafeAdvance(size);
         if constexpr (Nullable) {
-            NullBuilder->UnsafeAppend(1);
+            NullBuilder_->UnsafeAppend(1);
         }
 
         return ret;
@@ -711,7 +711,7 @@ public:
     void DoAdd(TBlockItem value) final {
         if constexpr (Nullable) {
             if (!value) {
-                NullBuilder->UnsafeAppend(0);
+                NullBuilder_->UnsafeAppend(0);
                 AppendCurrentOffset();
                 return;
             }
@@ -737,7 +737,7 @@ public:
 
     void DoAddDefault() final {
         if constexpr (Nullable) {
-            NullBuilder->UnsafeAppend(1);
+            NullBuilder_->UnsafeAppend(1);
         }
         AppendCurrentOffset();
     }
@@ -745,7 +745,7 @@ public:
     void DoAddMany(const arrow::ArrayData& array, const ui8* sparseBitmap, size_t popCount) final {
         Y_UNUSED(popCount);
         Y_ABORT_UNLESS(array.buffers.size() > 2);
-        Y_ABORT_UNLESS(!Nullable || NullBuilder->Length() == OffsetsBuilder->Length());
+        Y_ABORT_UNLESS(!Nullable || NullBuilder_->Length() == OffsetsBuilder_->Length());
 
         const ui8* srcNulls = array.GetValues<ui8>(0, 0);
         const TOffset* srcOffset = array.GetValues<TOffset>(1);
@@ -753,10 +753,10 @@ public:
 
         const ui8* chunkStart = srcData;
         const ui8* chunkEnd = chunkStart;
-        size_t dataLen = DataBuilder->Length();
+        size_t dataLen = DataBuilder_->Length();
 
-        ui8* dstNulls = Nullable ? NullBuilder->End() : nullptr;
-        TOffset* dstOffset = OffsetsBuilder->End();
+        ui8* dstNulls = Nullable ? NullBuilder_->End() : nullptr;
+        TOffset* dstOffset = OffsetsBuilder_->End();
         size_t countAdded = 0;
         for (size_t i = 0; i < size_t(array.length); i++) {
             if (!sparseBitmap[i]) {
@@ -767,7 +767,7 @@ public:
             const ui8* end   = srcData + srcOffset[i + 1];
             const size_t strSize = end - begin;
 
-            size_t availBytes = std::max(dataLen, MaxBlockSizeInBytes)  - dataLen;
+            size_t availBytes = std::max(dataLen, MaxBlockSizeInBytes_)  - dataLen;
 
             for (;;) {
                 // try to append ith string
@@ -775,7 +775,7 @@ public:
                     if (begin == chunkEnd)  {
                         chunkEnd = end;
                     } else {
-                        DataBuilder->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
+                        DataBuilder_->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
                         chunkStart = begin;
                         chunkEnd = end;
                     }
@@ -794,22 +794,22 @@ public:
 
                 if (dataLen) {
                     if (chunkStart != chunkEnd) {
-                        DataBuilder->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
+                        DataBuilder_->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
                         chunkStart = chunkEnd = srcData;
                     }
-                    Y_ABORT_UNLESS(dataLen == DataBuilder->Length());
-                    OffsetsBuilder->UnsafeAdvance(countAdded);
+                    Y_ABORT_UNLESS(dataLen == DataBuilder_->Length());
+                    OffsetsBuilder_->UnsafeAdvance(countAdded);
                     if constexpr (Nullable) {
-                        NullBuilder->UnsafeAdvance(countAdded);
+                        NullBuilder_->UnsafeAdvance(countAdded);
                     }
                     FlushChunk(false);
 
                     dataLen = 0;
                     countAdded = 0;
                     if constexpr (Nullable) {
-                        dstNulls = NullBuilder->End();
+                        dstNulls = NullBuilder_->End();
                     }
-                    dstOffset = OffsetsBuilder->End();
+                    dstOffset = OffsetsBuilder_->End();
                 } else {
                     ReserveForLargeString(strSize);
                     availBytes = strSize;
@@ -817,20 +817,20 @@ public:
             }
         }
         if (chunkStart != chunkEnd) {
-            DataBuilder->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
+            DataBuilder_->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
         }
-        Y_ABORT_UNLESS(dataLen == DataBuilder->Length());
-        OffsetsBuilder->UnsafeAdvance(countAdded);
+        Y_ABORT_UNLESS(dataLen == DataBuilder_->Length());
+        OffsetsBuilder_->UnsafeAdvance(countAdded);
         if constexpr (Nullable) {
-            NullBuilder->UnsafeAdvance(countAdded);
+            NullBuilder_->UnsafeAdvance(countAdded);
         }
     }
 
     void DoAddMany(const arrow::ArrayData& array, ui64 beginIndex, size_t count) final {
         Y_ABORT_UNLESS(array.buffers.size() > 2);
-        Y_ABORT_UNLESS(!Nullable || NullBuilder->Length() == OffsetsBuilder->Length());
+        Y_ABORT_UNLESS(!Nullable || NullBuilder_->Length() == OffsetsBuilder_->Length());
 
-        size_t dataLen = DataBuilder->Length();
+        size_t dataLen = DataBuilder_->Length();
 
         const TOffset* offsets = array.GetValues<TOffset>(1);
         const ui8* srcData = array.GetValues<ui8>(2, 0);
@@ -841,20 +841,20 @@ public:
             const ui8* end   = srcData + offsets[i + 1];
             const size_t strSize = end - begin;
 
-            size_t availBytes = std::max(dataLen, MaxBlockSizeInBytes) - dataLen;
+            size_t availBytes = std::max(dataLen, MaxBlockSizeInBytes_) - dataLen;
             for (;;) {
                 if (strSize <= availBytes) {
                     if constexpr (Nullable) {
-                        NullBuilder->UnsafeAppend(!IsNull(array, i));
+                        NullBuilder_->UnsafeAppend(!IsNull(array, i));
                     }
-                    OffsetsBuilder->UnsafeAppend(TOffset(dataLen));
+                    OffsetsBuilder_->UnsafeAppend(TOffset(dataLen));
                     chunkEnd = end;
                     dataLen += strSize;
                     break;
                 }
 
                 if (dataLen) {
-                    DataBuilder->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
+                    DataBuilder_->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
                     chunkStart = begin;
                     chunkEnd = end;
                     FlushChunk(false);
@@ -866,15 +866,15 @@ public:
             }
         }
         if (chunkStart != chunkEnd) {
-            DataBuilder->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
+            DataBuilder_->UnsafeAppend(chunkStart, chunkEnd - chunkStart);
         }
     }
 
     void DoAddMany(const arrow::ArrayData& array, const ui64* indexes, size_t count) final {
         Y_ABORT_UNLESS(array.buffers.size() > 2);
-        Y_ABORT_UNLESS(!Nullable || NullBuilder->Length() == OffsetsBuilder->Length());
+        Y_ABORT_UNLESS(!Nullable || NullBuilder_->Length() == OffsetsBuilder_->Length());
 
-        size_t dataLen = DataBuilder->Length();
+        size_t dataLen = DataBuilder_->Length();
 
         const TOffset* offsets = array.GetValues<TOffset>(1);
         const char* strData = array.GetValues<char>(2, 0);
@@ -882,14 +882,14 @@ public:
             ui64 idx = indexes[i];
             std::string_view str(strData + offsets[idx], offsets[idx + 1] - offsets[idx]);
 
-            size_t availBytes = std::max(dataLen, MaxBlockSizeInBytes) - dataLen;
+            size_t availBytes = std::max(dataLen, MaxBlockSizeInBytes_) - dataLen;
             for (;;) {
                 if (str.size() <= availBytes) {
                     if constexpr (Nullable) {
-                        NullBuilder->UnsafeAppend(!IsNull(array, idx));
+                        NullBuilder_->UnsafeAppend(!IsNull(array, idx));
                     }
-                    OffsetsBuilder->UnsafeAppend(TOffset(dataLen));
-                    DataBuilder->UnsafeAppend((const ui8*)str.data(), str.size());
+                    OffsetsBuilder_->UnsafeAppend(TOffset(dataLen));
+                    DataBuilder_->UnsafeAppend((const ui8*)str.data(), str.size());
                     dataLen += str.size();
                     break;
                 }
@@ -909,65 +909,65 @@ public:
     TBlockArrayTree::Ptr DoBuildTree(bool finish) final {
         FlushChunk(finish);
         TBlockArrayTree::Ptr result = std::make_shared<TBlockArrayTree>();
-        result->Payload = std::move(Chunks);
-        Chunks.clear();
+        result->Payload = std::move(Chunks_);
+        Chunks_.clear();
         return result;
     }
 
 private:
     size_t DoReserve() final {
-        OffsetsBuilder = std::make_unique<TTypedBufferBuilder<TOffset>>(Pool, MinFillPercentage);
-        OffsetsBuilder->Reserve(MaxLen + 1);
-        DataBuilder = std::make_unique<TTypedBufferBuilder<ui8>>(Pool, MinFillPercentage);
-        DataBuilder->Reserve(MaxBlockSizeInBytes);
-        auto result = OffsetsBuilder->Capacity() + DataBuilder->Capacity();
+        OffsetsBuilder_ = std::make_unique<TTypedBufferBuilder<TOffset>>(Pool_, MinFillPercentage_);
+        OffsetsBuilder_->Reserve(MaxLen_ + 1);
+        DataBuilder_ = std::make_unique<TTypedBufferBuilder<ui8>>(Pool_, MinFillPercentage_);
+        DataBuilder_->Reserve(MaxBlockSizeInBytes_);
+        auto result = OffsetsBuilder_->Capacity() + DataBuilder_->Capacity();
         if constexpr (Nullable) {
-            NullBuilder = std::make_unique<TTypedBufferBuilder<ui8>>(Pool, MinFillPercentage);
-            NullBuilder->Reserve(MaxLen + 1);
-            result += NullBuilder->Capacity();
+            NullBuilder_ = std::make_unique<TTypedBufferBuilder<ui8>>(Pool_, MinFillPercentage_);
+            NullBuilder_->Reserve(MaxLen_ + 1);
+            result += NullBuilder_->Capacity();
         }
         return result;
     }
 
     void ReserveForLargeString(size_t strSize) {
-        size_t before = DataBuilder->Capacity();
-        DataBuilder->Reserve(strSize);
-        size_t after = DataBuilder->Capacity();
+        size_t before = DataBuilder_->Capacity();
+        DataBuilder_->Reserve(strSize);
+        size_t after = DataBuilder_->Capacity();
         Y_ENSURE(before <= after);
         AddExtraAllocated(after - before);
     }
 
     void AppendCurrentOffset() {
-        OffsetsBuilder->UnsafeAppend(DataBuilder->Length());
+        OffsetsBuilder_->UnsafeAppend(DataBuilder_->Length());
     }
 
     void FlushChunk(bool finish) {
-        const auto length = OffsetsBuilder->Length();
+        const auto length = OffsetsBuilder_->Length();
         Y_ABORT_UNLESS(length > 0);
 
         AppendCurrentOffset();
         std::shared_ptr<arrow::Buffer> nullBitmap;
         if constexpr (Nullable) {
-            nullBitmap = NullBuilder->Finish();
-            nullBitmap = MakeDenseBitmap(nullBitmap->data(), length, Pool);
+            nullBitmap = NullBuilder_->Finish();
+            nullBitmap = MakeDenseBitmap(nullBitmap->data(), length, Pool_);
         }
-        std::shared_ptr<arrow::Buffer> offsets = OffsetsBuilder->Finish();
-        std::shared_ptr<arrow::Buffer> data = DataBuilder->Finish();
+        std::shared_ptr<arrow::Buffer> offsets = OffsetsBuilder_->Finish();
+        std::shared_ptr<arrow::Buffer> data = DataBuilder_->Finish();
 
-        Chunks.push_back(arrow::ArrayData::Make(ArrowType, length, { nullBitmap, offsets, data }));
+        Chunks_.push_back(arrow::ArrayData::Make(ArrowType_, length, { nullBitmap, offsets, data }));
         if (!finish) {
             Reserve();
         }
     }
 
-    std::unique_ptr<TTypedBufferBuilder<ui8>> NullBuilder;
-    std::unique_ptr<TTypedBufferBuilder<TOffset>> OffsetsBuilder;
-    std::unique_ptr<TTypedBufferBuilder<ui8>> DataBuilder;
+    std::unique_ptr<TTypedBufferBuilder<ui8>> NullBuilder_;
+    std::unique_ptr<TTypedBufferBuilder<TOffset>> OffsetsBuilder_;
+    std::unique_ptr<TTypedBufferBuilder<ui8>> DataBuilder_;
 
-    std::deque<std::shared_ptr<arrow::ArrayData>> Chunks;
+    std::deque<std::shared_ptr<arrow::ArrayData>> Chunks_;
 
-    const IPgBuilder* PgBuilder = nullptr;
-    i32 TypeLen = 0;
+    const IPgBuilder* PgBuilder_ = nullptr;
+    i32 TypeLen_ = 0;
 };
 
 template<bool Nullable, typename TDerived>
@@ -982,11 +982,11 @@ public:
     void DoAdd(NUdf::TUnboxedValuePod value) final {
         if constexpr (Nullable) {
             if (!value) {
-                NullBuilder->UnsafeAppend(0);
+                NullBuilder_->UnsafeAppend(0);
                 static_cast<TDerived*>(this)->AddToChildrenDefault();
                 return;
             }
-            NullBuilder->UnsafeAppend(1);
+            NullBuilder_->UnsafeAppend(1);
         }
 
         static_cast<TDerived*>(this)->AddToChildren(value);
@@ -995,11 +995,11 @@ public:
     void DoAdd(TBlockItem value) final {
         if constexpr (Nullable) {
             if (!value) {
-                NullBuilder->UnsafeAppend(0);
+                NullBuilder_->UnsafeAppend(0);
                 static_cast<TDerived*>(this)->AddToChildrenDefault();
                 return;
             }
-            NullBuilder->UnsafeAppend(1);
+            NullBuilder_->UnsafeAppend(1);
         }
 
         static_cast<TDerived*>(this)->AddToChildren(value);
@@ -1008,11 +1008,11 @@ public:
     void DoAdd(TInputBuffer& input) final {
         if constexpr (Nullable) {
             if (!input.PopChar()) {
-                NullBuilder->UnsafeAppend(0);
+                NullBuilder_->UnsafeAppend(0);
                 static_cast<TDerived*>(this)->AddToChildrenDefault();
                 return;
             }
-            NullBuilder->UnsafeAppend(1);
+            NullBuilder_->UnsafeAppend(1);
         }
 
         static_cast<TDerived*>(this)->AddToChildren(input);
@@ -1020,7 +1020,7 @@ public:
 
     void DoAddDefault() final {
         if constexpr (Nullable) {
-            NullBuilder->UnsafeAppend(1);
+            NullBuilder_->UnsafeAppend(1);
         }
         static_cast<TDerived*>(this)->AddToChildrenDefault();
     }
@@ -1030,11 +1030,11 @@ public:
 
         if constexpr (Nullable) {
             if (array.buffers.front()) {
-                ui8* dstBitmap = NullBuilder->End();
+                ui8* dstBitmap = NullBuilder_->End();
                 CompressAsSparseBitmap(array.GetValues<ui8>(0, 0), array.offset, sparseBitmap, dstBitmap, array.length);
-                NullBuilder->UnsafeAdvance(popCount);
+                NullBuilder_->UnsafeAdvance(popCount);
             } else {
-                NullBuilder->UnsafeAppend(popCount, 1);
+                NullBuilder_->UnsafeAppend(popCount, 1);
             }
         }
 
@@ -1046,7 +1046,7 @@ public:
 
         if constexpr (Nullable) {
             for (ui64 i = beginIndex; i < beginIndex + count; ++i) {
-                NullBuilder->UnsafeAppend(!IsNull(array, i));
+                NullBuilder_->UnsafeAppend(!IsNull(array, i));
             }
         }
 
@@ -1058,7 +1058,7 @@ public:
 
         if constexpr (Nullable) {
             for (size_t i = 0; i < count; ++i) {
-                NullBuilder->UnsafeAppend(!IsNull(array, indexes[i]));
+                NullBuilder_->UnsafeAppend(!IsNull(array, indexes[i]));
             }
         }
 
@@ -1071,13 +1071,13 @@ public:
         std::shared_ptr<arrow::Buffer> nullBitmap;
         const size_t length = GetCurrLen();
         if constexpr (Nullable) {
-            Y_ENSURE(length == NullBuilder->Length(), "Unexpected NullBuilder length");
-            nullBitmap = NullBuilder->Finish();
-            nullBitmap = MakeDenseBitmap(nullBitmap->data(), length, Pool);
+            Y_ENSURE(length == NullBuilder_->Length(), "Unexpected NullBuilder length");
+            nullBitmap = NullBuilder_->Finish();
+            nullBitmap = MakeDenseBitmap(nullBitmap->data(), length, Pool_);
         }
 
         Y_ABORT_UNLESS(length);
-        result->Payload.push_back(arrow::ArrayData::Make(ArrowType, length, { nullBitmap }));
+        result->Payload.push_back(arrow::ArrayData::Make(ArrowType_, length, { nullBitmap }));
         static_cast<TDerived*>(this)->BuildChildrenTree(finish, result->Children);
 
         if (!finish) {
@@ -1090,15 +1090,15 @@ public:
 private:
     size_t DoReserve() final {
         if constexpr (Nullable) {
-            NullBuilder = std::make_unique<TTypedBufferBuilder<ui8>>(Pool, MinFillPercentage);
-            NullBuilder->Reserve(MaxLen + 1);
-            return NullBuilder->Capacity();
+            NullBuilder_ = std::make_unique<TTypedBufferBuilder<ui8>>(Pool_, MinFillPercentage_);
+            NullBuilder_->Reserve(MaxLen_ + 1);
+            return NullBuilder_->Capacity();
         }
         return 0;
     }
 
 private:
-    std::unique_ptr<TTypedBufferBuilder<ui8>> NullBuilder;
+    std::unique_ptr<TTypedBufferBuilder<ui8>> NullBuilder_;
 };
 
 template<bool Nullable>
@@ -1248,47 +1248,47 @@ public:
     TExternalOptionalArrayBuilder(std::unique_ptr<TArrayBuilderBase>&& inner, const TType* type, const ITypeInfoHelper& typeInfoHelper, arrow::MemoryPool& pool,
                                   size_t maxLen, const TParams& params = {})
         : TArrayBuilderBase(typeInfoHelper, type, pool, maxLen, params)
-        , Inner(std::move(inner))
+        , Inner_(std::move(inner))
     {
         Reserve();
     }
 
     void DoAdd(NUdf::TUnboxedValuePod value) final {
         if (!value) {
-            NullBuilder->UnsafeAppend(0);
-            Inner->AddDefault();
+            NullBuilder_->UnsafeAppend(0);
+            Inner_->AddDefault();
             return;
         }
 
-        NullBuilder->UnsafeAppend(1);
-        Inner->Add(value.GetOptionalValue());
+        NullBuilder_->UnsafeAppend(1);
+        Inner_->Add(value.GetOptionalValue());
     }
 
     void DoAdd(TBlockItem value) final {
         if (!value) {
-            NullBuilder->UnsafeAppend(0);
-            Inner->AddDefault();
+            NullBuilder_->UnsafeAppend(0);
+            Inner_->AddDefault();
             return;
         }
 
-        NullBuilder->UnsafeAppend(1);
-        Inner->Add(value.GetOptionalValue());
+        NullBuilder_->UnsafeAppend(1);
+        Inner_->Add(value.GetOptionalValue());
     }
 
     void DoAdd(TInputBuffer& input) final {
         if (!input.PopChar()) {
-            NullBuilder->UnsafeAppend(0);
-            Inner->AddDefault();
+            NullBuilder_->UnsafeAppend(0);
+            Inner_->AddDefault();
             return;
         }
 
-        NullBuilder->UnsafeAppend(1);
-        Inner->Add(input);
+        NullBuilder_->UnsafeAppend(1);
+        Inner_->Add(input);
     }
 
     void DoAddDefault() final {
-        NullBuilder->UnsafeAppend(1);
-        Inner->AddDefault();
+        NullBuilder_->UnsafeAppend(1);
+        Inner_->AddDefault();
     }
 
     void DoAddMany(const arrow::ArrayData& array, const ui8* sparseBitmap, size_t popCount) final {
@@ -1296,14 +1296,14 @@ public:
         Y_ABORT_UNLESS(array.child_data.size() == 1);
 
         if (array.buffers.front()) {
-            ui8* dstBitmap = NullBuilder->End();
+            ui8* dstBitmap = NullBuilder_->End();
             CompressAsSparseBitmap(array.GetValues<ui8>(0, 0), array.offset, sparseBitmap, dstBitmap, array.length);
-            NullBuilder->UnsafeAdvance(popCount);
+            NullBuilder_->UnsafeAdvance(popCount);
         } else {
-            NullBuilder->UnsafeAppend(popCount, 1);
+            NullBuilder_->UnsafeAppend(popCount, 1);
         }
 
-        Inner->AddMany(*array.child_data[0], popCount, sparseBitmap, array.length);
+        Inner_->AddMany(*array.child_data[0], popCount, sparseBitmap, array.length);
     }
 
     void DoAddMany(const arrow::ArrayData& array, ui64 beginIndex, size_t count) final {
@@ -1311,10 +1311,10 @@ public:
         Y_ABORT_UNLESS(array.child_data.size() == 1);
 
         for (ui64 i = beginIndex; i < beginIndex + count; ++i) {
-            NullBuilder->UnsafeAppend(!IsNull(array, i));
+            NullBuilder_->UnsafeAppend(!IsNull(array, i));
         }
 
-        Inner->AddMany(*array.child_data[0], beginIndex, count);
+        Inner_->AddMany(*array.child_data[0], beginIndex, count);
     }
 
     void DoAddMany(const arrow::ArrayData& array, const ui64* indexes, size_t count) final {
@@ -1322,10 +1322,10 @@ public:
         Y_ABORT_UNLESS(array.child_data.size() == 1);
 
         for (size_t i = 0; i < count; ++i) {
-            NullBuilder->UnsafeAppend(!IsNull(array, indexes[i]));
+            NullBuilder_->UnsafeAppend(!IsNull(array, indexes[i]));
         }
 
-        Inner->AddMany(*array.child_data[0], indexes, count);
+        Inner_->AddMany(*array.child_data[0], indexes, count);
     }
 
     TBlockArrayTree::Ptr DoBuildTree(bool finish) final {
@@ -1333,13 +1333,13 @@ public:
 
         std::shared_ptr<arrow::Buffer> nullBitmap;
         const size_t length = GetCurrLen();
-        Y_ENSURE(length == NullBuilder->Length(), "Unexpected NullBuilder length");
-        nullBitmap = NullBuilder->Finish();
-        nullBitmap = MakeDenseBitmap(nullBitmap->data(), length, Pool);
+        Y_ENSURE(length == NullBuilder_->Length(), "Unexpected NullBuilder length");
+        nullBitmap = NullBuilder_->Finish();
+        nullBitmap = MakeDenseBitmap(nullBitmap->data(), length, Pool_);
 
         Y_ABORT_UNLESS(length);
-        result->Payload.push_back(arrow::ArrayData::Make(ArrowType, length, { nullBitmap }));
-        result->Children.emplace_back(Inner->BuildTree(finish));
+        result->Payload.push_back(arrow::ArrayData::Make(ArrowType_, length, { nullBitmap }));
+        result->Children.emplace_back(Inner_->BuildTree(finish));
 
         if (!finish) {
             Reserve();
@@ -1350,14 +1350,14 @@ public:
 
 private:
     size_t DoReserve() final {
-        NullBuilder = std::make_unique<TTypedBufferBuilder<ui8>>(Pool, MinFillPercentage);
-        NullBuilder->Reserve(MaxLen + 1);
-        return NullBuilder->Capacity();
+        NullBuilder_ = std::make_unique<TTypedBufferBuilder<ui8>>(Pool_, MinFillPercentage_);
+        NullBuilder_->Reserve(MaxLen_ + 1);
+        return NullBuilder_->Capacity();
     }
 
 private:
-    std::unique_ptr<TArrayBuilderBase> Inner;
-    std::unique_ptr<TTypedBufferBuilder<ui8>> NullBuilder;
+    std::unique_ptr<TArrayBuilderBase> Inner_;
+    std::unique_ptr<TTypedBufferBuilder<ui8>> NullBuilder_;
 };
 
 class TSingularBlockBuilder final: public TArrayBuilderBase {
diff --git a/yql/essentials/public/udf/arrow/block_reader.h b/yql/essentials/public/udf/arrow/block_reader.h
index dc3e7be87b3..25a3dbe4775 100644
--- a/yql/essentials/public/udf/arrow/block_reader.h
+++ b/yql/essentials/public/udf/arrow/block_reader.h
@@ -341,24 +341,24 @@ template<bool Nullable>
 class TTupleBlockReader final : public TTupleBlockReaderBase<Nullable, TTupleBlockReader<Nullable>> {
 public:
     TTupleBlockReader(TVector<std::unique_ptr<IBlockReader>>&& children)
-        : Children(std::move(children))
-        , Items(Children.size())
+        : Children_(std::move(children))
+        , Items_(Children_.size())
     {}
 
     TBlockItem GetChildrenItems(const arrow::ArrayData& data, size_t index) {
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            Items[i] = Children[i]->GetItem(*data.child_data[i], index);
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            Items_[i] = Children_[i]->GetItem(*data.child_data[i], index);
         }
 
-        return TBlockItem(Items.data());
+        return TBlockItem(Items_.data());
     }
 
     TBlockItem GetChildrenScalarItems(const arrow::StructScalar& structScalar) {
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            Items[i] = Children[i]->GetScalarItem(*structScalar.value[i]);
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            Items_[i] = Children_[i]->GetScalarItem(*structScalar.value[i]);
         }
 
-        return TBlockItem(Items.data());
+        return TBlockItem(Items_.data());
     }
 
     size_t GetDataWeightImpl(const TBlockItem& item) const {
@@ -374,8 +374,8 @@ public:
             items = item.GetElements();
         }
 
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            size += Children[i]->GetDataWeight(items[i]);
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            size += Children_[i]->GetDataWeight(items[i]);
         }
 
         return size;
@@ -383,8 +383,8 @@ public:
 
     size_t GetChildrenDataWeight(const arrow::ArrayData& data) const {
         size_t size = 0;
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            size += Children[i]->GetDataWeight(*data.child_data[i]);
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            size += Children_[i]->GetDataWeight(*data.child_data[i]);
         }
 
         return size;
@@ -392,35 +392,35 @@ public:
 
     size_t GetChildrenDataWeight(const arrow::ArrayData& data, int64_t offset, int64_t length) const {
         size_t size = 0;
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            size += Children[i]->GetSliceDataWeight(*data.child_data[i], offset, length);
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            size += Children_[i]->GetSliceDataWeight(*data.child_data[i], offset, length);
         }
         return size;
     }
 
     size_t GetChildrenDefaultDataWeight() const {
         size_t size = 0;
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            size += Children[i]->GetDefaultValueWeight();
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            size += Children_[i]->GetDefaultValueWeight();
         }
         return size;
     }
 
     void SaveChildrenItems(const arrow::ArrayData& data, size_t index, TOutputBuffer& out) const {
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            Children[i]->SaveItem(*data.child_data[i], index, out);
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            Children_[i]->SaveItem(*data.child_data[i], index, out);
         }
     }
 
     void SaveChildrenScalarItems(const arrow::StructScalar& structScalar, TOutputBuffer& out) const {
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            Children[i]->SaveScalarItem(*structScalar.value[i], out);
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            Children_[i]->SaveScalarItem(*structScalar.value[i], out);
         }
     }
 
 private:
-    const TVector<std::unique_ptr<IBlockReader>> Children;
-    TVector<TBlockItem> Items;
+    const TVector<std::unique_ptr<IBlockReader>> Children_;
+    TVector<TBlockItem> Items_;
 };
 
 template<typename TTzDate, bool Nullable>
@@ -541,7 +541,7 @@ public:
 class TExternalOptionalBlockReader final : public TBlockReaderBase {
 public:
     TExternalOptionalBlockReader(std::unique_ptr<IBlockReader>&& inner)
-        : Inner(std::move(inner))
+        : Inner_(std::move(inner))
     {}
 
     TBlockItem GetItem(const arrow::ArrayData& data, size_t index) final {
@@ -549,7 +549,7 @@ public:
             return {};
         }
 
-        return Inner->GetItem(*data.child_data.front(), index).MakeOptional();
+        return Inner_->GetItem(*data.child_data.front(), index).MakeOptional();
     }
 
     TBlockItem GetScalarItem(const arrow::Scalar& scalar) final {
@@ -558,26 +558,26 @@ public:
         }
 
         const auto& structScalar = arrow::internal::checked_cast<const arrow::StructScalar&>(scalar);
-        return Inner->GetScalarItem(*structScalar.value.front()).MakeOptional();
+        return Inner_->GetScalarItem(*structScalar.value.front()).MakeOptional();
     }
 
     ui64 GetDataWeight(const arrow::ArrayData& data) const final {
-        return GetBitmaskDataWeight(data.length) + Inner->GetDataWeight(*data.child_data.front());
+        return GetBitmaskDataWeight(data.length) + Inner_->GetDataWeight(*data.child_data.front());
     }
 
     ui64 DoGetSliceDataWeight(const arrow::ArrayData& data, int64_t offset, int64_t length) const final {
-        return GetBitmaskDataWeight(length) + Inner->GetSliceDataWeight(*data.child_data.front(), offset, length);
+        return GetBitmaskDataWeight(length) + Inner_->GetSliceDataWeight(*data.child_data.front(), offset, length);
     }
 
     ui64 GetDataWeight(TBlockItem item) const final {
         if (!item) {
             return GetDefaultValueWeight();
         }
-        return 1 + Inner->GetDataWeight(item.GetOptionalValue());
+        return 1 + Inner_->GetDataWeight(item.GetOptionalValue());
     }
 
     ui64 GetDefaultValueWeight() const final {
-        return 1 + Inner->GetDefaultValueWeight();
+        return 1 + Inner_->GetDefaultValueWeight();
     }
 
     void SaveItem(const arrow::ArrayData& data, size_t index, TOutputBuffer& out) const final {
@@ -586,7 +586,7 @@ public:
         }
         out.PushChar(1);
 
-        Inner->SaveItem(*data.child_data.front(), index, out);
+        Inner_->SaveItem(*data.child_data.front(), index, out);
     }
 
     void SaveScalarItem(const arrow::Scalar& scalar, TOutputBuffer& out) const final {
@@ -596,11 +596,11 @@ public:
         out.PushChar(1);
 
         const auto& structScalar = arrow::internal::checked_cast<const arrow::StructScalar&>(scalar);
-        Inner->SaveScalarItem(*structScalar.value.front(), out);
+        Inner_->SaveScalarItem(*structScalar.value.front(), out);
     }
 
 private:
-    const std::unique_ptr<IBlockReader> Inner;
+    const std::unique_ptr<IBlockReader> Inner_;
 };
 
 struct TReaderTraits {
diff --git a/yql/essentials/public/udf/arrow/memory_pool.cpp b/yql/essentials/public/udf/arrow/memory_pool.cpp
index df85f62bb14..5a074b60aba 100644
--- a/yql/essentials/public/udf/arrow/memory_pool.cpp
+++ b/yql/essentials/public/udf/arrow/memory_pool.cpp
@@ -30,18 +30,18 @@ class TYqlMemoryPool : public arrow::MemoryPool {
     }
 
     int64_t max_memory() const final {
-        return max_memory_.load();
+        return MaxMemory_.load();
     }
 
     int64_t bytes_allocated() const final {
-        return bytes_allocated_.load();
+        return BytesAllocated_.load();
     }
 
     inline void UpdateAllocatedBytes(int64_t diff) {
         // inspired by arrow/memory_pool.h impl.
-        int64_t allocated = bytes_allocated_.fetch_add(diff) + diff;
-        if (diff > 0 && allocated > max_memory_) {
-            max_memory_ = allocated;
+        int64_t allocated = BytesAllocated_.fetch_add(diff) + diff;
+        if (diff > 0 && allocated > MaxMemory_) {
+            MaxMemory_ = allocated;
         }
     }
 
@@ -50,8 +50,8 @@ class TYqlMemoryPool : public arrow::MemoryPool {
     }
 
 private:
-    std::atomic<int64_t> bytes_allocated_{0};
-    std::atomic<int64_t> max_memory_{0};
+    std::atomic<int64_t> BytesAllocated_{0};
+    std::atomic<int64_t> MaxMemory_{0};
 };
 
 arrow::MemoryPool* GetYqlMemoryPool() {
diff --git a/yql/essentials/public/udf/arrow/udf_arrow_helpers.h b/yql/essentials/public/udf/arrow/udf_arrow_helpers.h
index af7ce958d0f..cd4cd4b06bf 100644
--- a/yql/essentials/public/udf/arrow/udf_arrow_helpers.h
+++ b/yql/essentials/public/udf/arrow/udf_arrow_helpers.h
@@ -332,7 +332,7 @@ TBuilder* CastToArrayBuilderImpl(IArrayBuilder& builder) {
     static_assert(std::is_base_of_v<IArrayBuilder, TBuilder>);
 
     auto* builderImpl = dynamic_cast<TBuilder*>(&builder);
-    Y_ENSURE(builderImpl, TStringBuilder() << "Got " << typeid(builder).name() << " as ArrayBuilder");
+    Y_ENSURE(builderImpl, TStringBuilder() << "Got " << TypeName(builder) << " as ArrayBuilder");
     return builderImpl;
 }
 
@@ -341,7 +341,7 @@ TScalarBuilderImpl* CastToScalarBuilderImpl(IScalarBuilder& builder) {
     static_assert(std::is_base_of_v<IScalarBuilder, TScalarBuilderImpl>);
 
     auto* builderImpl = dynamic_cast<TScalarBuilderImpl*>(&builder);
-    Y_ENSURE(builderImpl, TStringBuilder() << "Got " << typeid(builder).name() << " as ArrayBuilder");
+    Y_ENSURE(builderImpl, TStringBuilder() << "Got " << TypeName(builder) << " as ScalarBuilder");
     return builderImpl;
 }
 
@@ -350,7 +350,7 @@ TReader* CastToBlockReaderImpl(IBlockReader& reader) {
     static_assert(std::is_base_of_v<IBlockReader, TReader>);
 
     auto* readerImpl = dynamic_cast<TReader*>(&reader);
-    Y_ENSURE(readerImpl, TStringBuilder() << "Got " << typeid(reader).name() << " as BlockReader");
+    Y_ENSURE(readerImpl, TStringBuilder() << "Got " << TypeName(reader) << " as BlockReader");
     return readerImpl;
 }
 
diff --git a/yql/essentials/public/udf/arrow/util.h b/yql/essentials/public/udf/arrow/util.h
index a7d5018b558..ba0e16f5f1c 100644
--- a/yql/essentials/public/udf/arrow/util.h
+++ b/yql/essentials/public/udf/arrow/util.h
@@ -56,13 +56,13 @@ class TResizeableBuffer : public arrow::ResizableBuffer {
 public:
     explicit TResizeableBuffer(arrow::MemoryPool* pool)
         : ResizableBuffer(nullptr, 0, arrow::CPUDevice::memory_manager(pool))
-        , Pool(pool)
+        , Pool_(pool)
     {
     }
     ~TResizeableBuffer() override {
         uint8_t* ptr = mutable_data();
         if (ptr) {
-            Pool->Free(ptr, capacity_);
+            Pool_->Free(ptr, capacity_);
         }
     }
 
@@ -74,9 +74,9 @@ public:
         if (!ptr || capacity > capacity_) {
             int64_t newCapacity = arrow::BitUtil::RoundUpToMultipleOf64(capacity);
             if (ptr) {
-                ARROW_RETURN_NOT_OK(Pool->Reallocate(capacity_, newCapacity, &ptr));
+                ARROW_RETURN_NOT_OK(Pool_->Reallocate(capacity_, newCapacity, &ptr));
             } else {
-                ARROW_RETURN_NOT_OK(Pool->Allocate(newCapacity, &ptr));
+                ARROW_RETURN_NOT_OK(Pool_->Allocate(newCapacity, &ptr));
             }
             data_ = ptr;
             capacity_ = newCapacity;
@@ -92,7 +92,7 @@ public:
         if (ptr && shrink_to_fit) {
             int64_t newCapacity = arrow::BitUtil::RoundUpToMultipleOf64(newSize);
             if (capacity_ != newCapacity) {
-                ARROW_RETURN_NOT_OK(Pool->Reallocate(capacity_, newCapacity, &ptr));
+                ARROW_RETURN_NOT_OK(Pool_->Reallocate(capacity_, newCapacity, &ptr));
                 data_ = ptr;
                 capacity_ = newCapacity;
             }
@@ -105,7 +105,7 @@ public:
     }
 
 private:
-    arrow::MemoryPool* Pool;
+    arrow::MemoryPool* Pool_;
 };
 
 /// \brief same as arrow::AllocateResizableBuffer, but allows to control zero padding
@@ -146,36 +146,36 @@ class TTypedBufferBuilder {
     using TArrowBuffer = std::conditional_t<std::is_trivially_destructible_v<T>, TResizeableBuffer, TResizableManagedBuffer<T>>;
 public:
     explicit TTypedBufferBuilder(arrow::MemoryPool* pool, TMaybe<ui8> minFillPercentage = {})
-        : MinFillPercentage(minFillPercentage)
-        , Pool(pool)
+        : MinFillPercentage_(minFillPercentage)
+        , Pool_(pool)
     {
-        Y_ENSURE(!MinFillPercentage || *MinFillPercentage <= 100);
+        Y_ENSURE(!MinFillPercentage_ || *MinFillPercentage_ <= 100);
     }
 
     inline void Reserve(size_t size) {
-        if (!Buffer) {
+        if (!Buffer_) {
             bool zeroPad = false;
-            Buffer = AllocateResizableBuffer<TArrowBuffer>(size * sizeof(T), Pool, zeroPad);
+            Buffer_ = AllocateResizableBuffer<TArrowBuffer>(size * sizeof(T), Pool_, zeroPad);
         } else {
             size_t requiredBytes = (size + Length()) * sizeof(T);
-            size_t currentCapacity = Buffer->capacity();
+            size_t currentCapacity = Buffer_->capacity();
             if (requiredBytes > currentCapacity) {
                 size_t newCapacity = std::max(requiredBytes, currentCapacity * 2);
-                ARROW_OK(Buffer->Reserve(newCapacity));
+                ARROW_OK(Buffer_->Reserve(newCapacity));
             }
         }
     }
 
     inline size_t Length() const {
-        return Len;
+        return Len_;
     }
 
     inline size_t Capacity() const {
-        return Buffer ? size_t(Buffer->capacity()) : 0;
+        return Buffer_ ? size_t(Buffer_->capacity()) : 0;
     }
 
     inline T* MutableData() {
-        return reinterpret_cast<T*>(Buffer->mutable_data());
+        return reinterpret_cast<T*>(Buffer_->mutable_data());
     }
 
     inline T* End() {
@@ -183,49 +183,49 @@ public:
     }
 
     inline const T* Data() const {
-        return reinterpret_cast<const T*>(Buffer->data());
+        return reinterpret_cast<const T*>(Buffer_->data());
     }
 
     inline void UnsafeAppend(const T* values, size_t count) {
-        Y_DEBUG_ABORT_UNLESS(count + Length() <= Buffer->capacity() / sizeof(T));
+        Y_DEBUG_ABORT_UNLESS(count + Length() <= Buffer_->capacity() / sizeof(T));
         std::memcpy(End(), values, count * sizeof(T));
         UnsafeAdvance(count);
     }
 
     inline void UnsafeAppend(size_t count, const T& value) {
-        Y_DEBUG_ABORT_UNLESS(count + Length() <= Buffer->capacity() / sizeof(T));
+        Y_DEBUG_ABORT_UNLESS(count + Length() <= Buffer_->capacity() / sizeof(T));
         T* target = End();
         std::fill(target, target + count, value);
         UnsafeAdvance(count);
     }
 
     inline void UnsafeAppend(T&& value) {
-        Y_DEBUG_ABORT_UNLESS(1 + Length() <= Buffer->capacity() / sizeof(T));
+        Y_DEBUG_ABORT_UNLESS(1 + Length() <= Buffer_->capacity() / sizeof(T));
         *End() = std::move(value);
         UnsafeAdvance(1);
     }
 
     inline void UnsafeAdvance(size_t count) {
-        Y_DEBUG_ABORT_UNLESS(count + Length() <= Buffer->capacity() / sizeof(T));
-        Len += count;
+        Y_DEBUG_ABORT_UNLESS(count + Length() <= Buffer_->capacity() / sizeof(T));
+        Len_ += count;
     }
 
     inline std::shared_ptr<arrow::Buffer> Finish() {
-        int64_t newSize = Len * sizeof(T);
-        bool shrinkToFit = MinFillPercentage
-            ? newSize <= Buffer->capacity() * *MinFillPercentage / 100
+        int64_t newSize = Len_ * sizeof(T);
+        bool shrinkToFit = MinFillPercentage_
+            ? newSize <= Buffer_->capacity() * *MinFillPercentage_ / 100
             : false;
-        ARROW_OK(Buffer->Resize(newSize, shrinkToFit));
+        ARROW_OK(Buffer_->Resize(newSize, shrinkToFit));
         std::shared_ptr<arrow::ResizableBuffer> result;
-        std::swap(result, Buffer);
-        Len = 0;
+        std::swap(result, Buffer_);
+        Len_ = 0;
         return result;
     }
 private:
-    const TMaybe<ui8> MinFillPercentage;
-    arrow::MemoryPool* const Pool;
-    std::shared_ptr<arrow::ResizableBuffer> Buffer;
-    size_t Len = 0;
+    const TMaybe<ui8> MinFillPercentage_;
+    arrow::MemoryPool* const Pool_;
+    std::shared_ptr<arrow::ResizableBuffer> Buffer_;
+    size_t Len_ = 0;
 };
 
 inline void* GetMemoryContext(const void* ptr) {
diff --git a/yql/essentials/public/udf/udf_allocator.h b/yql/essentials/public/udf/udf_allocator.h
index 147ea08a7dc..7818b49f10f 100644
--- a/yql/essentials/public/udf/udf_allocator.h
+++ b/yql/essentials/public/udf/udf_allocator.h
@@ -39,11 +39,11 @@ struct TStdAllocatorForUdf
     ~TStdAllocatorForUdf() noexcept = default;
 
     template<typename U> TStdAllocatorForUdf(const TStdAllocatorForUdf<U>&) noexcept {};
-    template<typename U> struct rebind { typedef TStdAllocatorForUdf<U> other; };
+    template<typename U> struct rebind { typedef TStdAllocatorForUdf<U> other; }; // NOLINT(readability-identifier-naming)
     template<typename U> bool operator==(const TStdAllocatorForUdf<U>&) const { return true; };
     template<typename U> bool operator!=(const TStdAllocatorForUdf<U>&) const { return false; }
 
-    static pointer allocate(size_type n, const void* = nullptr)
+    static pointer allocate(size_type n, const void* = nullptr) // NOLINT(readability-identifier-naming)
     {
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 8)
         return static_cast<pointer>(UdfAllocateWithSize(n * sizeof(value_type)));
@@ -52,7 +52,7 @@ struct TStdAllocatorForUdf
 #endif
     }
 
-    static void deallocate(const_pointer p, size_type n) noexcept
+    static void deallocate(const_pointer p, size_type n) noexcept // NOLINT(readability-identifier-naming)
     {
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 8)
         (void)(n);
diff --git a/yql/essentials/public/udf/udf_string.h b/yql/essentials/public/udf/udf_string.h
index 96e97a71b51..3416f4dce9c 100644
--- a/yql/essentials/public/udf/udf_string.h
+++ b/yql/essentials/public/udf/udf_string.h
@@ -219,6 +219,7 @@ public:
 #endif
     }
 
+private:
     TData* Data_;
 };
 
diff --git a/yql/essentials/public/udf/udf_type_builder.h b/yql/essentials/public/udf/udf_type_builder.h
index 9507b4bfe3b..5c9e06b22f3 100644
--- a/yql/essentials/public/udf/udf_type_builder.h
+++ b/yql/essentials/public/udf/udf_type_builder.h
@@ -448,20 +448,20 @@ template <typename... TArgs> struct TCallableArgsHelper;
 
 struct TSourcePosition {
     TSourcePosition(ui32 row = 0, ui32 column = 0, TStringRef file = {})
-        : Row_(row)
-        , Column_(column)
-        , File_(file)
+        : Row(row)
+        , Column(column)
+        , File(file)
     {}
 
-    ui32 Row_;
-    ui32 Column_;
-    TStringRef File_;
+    ui32 Row;
+    ui32 Column;
+    TStringRef File;
 };
 
 UDF_ASSERT_TYPE_SIZE(TSourcePosition, 24);
 
 inline IOutputStream& operator<<(IOutputStream& os, const TSourcePosition& pos) {
-    os << (pos.File_.Size() ? TStringBuf(pos.File_) : TStringBuf("<main>")) << ':' << pos.Row_ << ':' << pos.Column_ << ':';
+    os << (pos.File.Size() ? TStringBuf(pos.File) : TStringBuf("<main>")) << ':' << pos.Row << ':' << pos.Column << ':';
     return os;
 }
 
diff --git a/yql/essentials/public/udf/udf_ut_helpers.h b/yql/essentials/public/udf/udf_ut_helpers.h
index fd6caf20ee6..af95e727dc3 100644
--- a/yql/essentials/public/udf/udf_ut_helpers.h
+++ b/yql/essentials/public/udf/udf_ut_helpers.h
@@ -16,28 +16,28 @@ template<bool HasLength = true>
 class TLazyList: public NUdf::TBoxedValue {
     struct TIterator: public NUdf::TBoxedValue {
         TIterator(i32 from, i32 to)
-            : From(from), To(to), Curr(Max<i32>())
+            : From_(from), To_(to), Curr_(Max<i32>())
         {
-            if (To >= From) {
-                To--; // exclude last
+            if (To_ >= From_) {
+                To_--; // exclude last
             } else {
-                From--; // exclude first
+                From_--; // exclude first
             }
         }
     private:
         bool Skip() override {
-            if (Curr == Max<i32>()) {
-                Curr = From;
+            if (Curr_ == Max<i32>()) {
+                Curr_ = From_;
                 return true;
             }
-            if (To >= From) {
-                if (Curr < To) {
-                    ++Curr;
+            if (To_ >= From_) {
+                if (Curr_ < To_) {
+                    ++Curr_;
                     return true;
                 }
             } else {
-                if (Curr > To) {
-                    --Curr;
+                if (Curr_ > To_) {
+                    --Curr_;
                     return true;
                 }
             }
@@ -47,10 +47,10 @@ class TLazyList: public NUdf::TBoxedValue {
         bool Next(NUdf::TUnboxedValue& value) override {
             if (!Skip())
                 return false;
-            value = NUdf::TUnboxedValuePod(Curr);
+            value = NUdf::TUnboxedValuePod(Curr_);
             return true;
         }
-        i32 From, To, Curr;
+        i32 From_, To_, Curr_;
     };
 public:
     TLazyList(i32 from, i32 to)
diff --git a/yql/essentials/public/udf/udf_value.h b/yql/essentials/public/udf/udf_value.h
index 8c2a01acde3..a895d0f8ea7 100644
--- a/yql/essentials/public/udf/udf_value.h
+++ b/yql/essentials/public/udf/udf_value.h
@@ -718,12 +718,12 @@ class TBoxedValueLink: public TBoxedValueBase
 public:
     void Link(TBoxedValueLink* root);
     void Unlink();
-    void InitLinks() { Left = Right = this; }
-    TBoxedValueLink* GetLeft() const { return Left; }
-    TBoxedValueLink* GetRight() const { return Right; }
+    void InitLinks() { Left_ = Right_ = this; }
+    TBoxedValueLink* GetLeft() const { return Left_; }
+    TBoxedValueLink* GetRight() const { return Right_; }
 private:
-    TBoxedValueLink *Left = nullptr;
-    TBoxedValueLink *Right = nullptr;
+    TBoxedValueLink *Left_ = nullptr;
+    TBoxedValueLink *Right_ = nullptr;
 };
 
 class TBoxedValue: public TBoxedValueLink, public TWithUdfAllocator
@@ -925,9 +925,9 @@ protected:
         ui64 Halfs[2] = {0, 0};
 
         TRawEmbeddedValue Embedded;
-        
+
         TRawBoxedValue Boxed;
-        
+
         TRawStringValue String;
 
         struct {
@@ -1127,14 +1127,14 @@ inline TBoxedValue::~TBoxedValue()
 }
 
 inline void TBoxedValueLink::Link(TBoxedValueLink* root) {
-    Left = root;
-    Right = root->Right;
-    Right->Left = Left->Right = this;
+    Left_ = root;
+    Right_ = root->Right_;
+    Right_->Left_ = Left_->Right_ = this;
 }
 
 inline void TBoxedValueLink::Unlink() {
-    std::tie(Right->Left, Left->Right) = std::make_pair(Left, Right);
-    Left = Right = nullptr;
+    std::tie(Right_->Left_, Left_->Right_) = std::make_pair(Left_, Right_);
+    Left_ = Right_ = nullptr;
 }
 
 inline TUnboxedValue TBoxedValueBase::GetDictIterator() const
diff --git a/yql/essentials/public/udf/udf_value_builder.h b/yql/essentials/public/udf/udf_value_builder.h
index 78cb03390da..a1c48016447 100644
--- a/yql/essentials/public/udf/udf_value_builder.h
+++ b/yql/essentials/public/udf/udf_value_builder.h
@@ -336,12 +336,12 @@ public:
 
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 39)
 class IValueBuilder: public IValueBuilder8 {
-protected:    
+protected:
     IValueBuilder();
 };
 #elif UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 27)
 class IValueBuilder: public IValueBuilder7 {
-protected:    
+protected:
     IValueBuilder();
 };
 
@@ -372,7 +372,7 @@ protected:
 };
 #else
 class IValueBuilder: public IValueBuilder1 {
-protected:    
+protected:
     IValueBuilder();
 };
 #endif
@@ -381,12 +381,12 @@ UDF_ASSERT_TYPE_SIZE(IValueBuilder, 8);
 
 class TPlainArrayCache {
 private:
-    const ui32 Size;
-    std::array<TUnboxedValue, 2U> Cached;
-    std::array<TUnboxedValue*, 2U> CachedItems;
-    ui8 CacheIndex = 0U;
+    const ui32 Size_;
+    std::array<TUnboxedValue, 2U> Cached_;
+    std::array<TUnboxedValue*, 2U> CachedItems_;
+    ui8 CacheIndex_ = 0U;
 public:
-    TPlainArrayCache(ui32 size): Size(size) { Clear(); }
+    TPlainArrayCache(ui32 size): Size_(size) { Clear(); }
 
     TPlainArrayCache(TPlainArrayCache&&) = delete;
     TPlainArrayCache(const TPlainArrayCache&) = delete;
@@ -394,23 +394,23 @@ public:
     TPlainArrayCache& operator=(const TPlainArrayCache&) = delete;
 
     void Clear() {
-        Cached.fill(TUnboxedValue());
-        CachedItems.fill(nullptr);
+        Cached_.fill(TUnboxedValue());
+        CachedItems_.fill(nullptr);
     }
 
     TUnboxedValue NewArray(const IValueBuilder& builder, TUnboxedValue*& items) {
-        if (!CachedItems[CacheIndex] || !Cached[CacheIndex].UniqueBoxed()) {
-            CacheIndex ^= 1U;
-            if (!CachedItems[CacheIndex] || !Cached[CacheIndex].UniqueBoxed()) {
-                Cached[CacheIndex] = builder.NewArray(Size, CachedItems[CacheIndex]);
-                items = CachedItems[CacheIndex];
-                return Cached[CacheIndex];
+        if (!CachedItems_[CacheIndex_] || !Cached_[CacheIndex_].UniqueBoxed()) {
+            CacheIndex_ ^= 1U;
+            if (!CachedItems_[CacheIndex_] || !Cached_[CacheIndex_].UniqueBoxed()) {
+                Cached_[CacheIndex_] = builder.NewArray(Size_, CachedItems_[CacheIndex_]);
+                items = CachedItems_[CacheIndex_];
+                return Cached_[CacheIndex_];
             }
         }
 
-        items = CachedItems[CacheIndex];
-        std::fill_n(items, Size, TUnboxedValue());
-        return Cached[CacheIndex];
+        items = CachedItems_[CacheIndex_];
+        std::fill_n(items, Size_, TUnboxedValue());
+        return Cached_[CacheIndex_];
     }
 };
 
diff --git a/yql/essentials/public/udf/udf_version.h b/yql/essentials/public/udf/udf_version.h
index 78aaa7e3404..18a86b69096 100644
--- a/yql/essentials/public/udf/udf_version.h
+++ b/yql/essentials/public/udf/udf_version.h
@@ -22,15 +22,15 @@ namespace NUdf {
 
 inline const char* CurrentAbiVersionStr()
 {
-#define str(s) #s
-#define xstr(s) str(s)
+#define STR(s) #s
+#define XSTR(s) STR(s)
 
-    return xstr(UDF_ABI_VERSION_MAJOR) "."
-            xstr(UDF_ABI_VERSION_MINOR) "."
-            xstr(UDF_ABI_VERSION_PATCH);
+    return XSTR(UDF_ABI_VERSION_MAJOR) "."
+            XSTR(UDF_ABI_VERSION_MINOR) "."
+            XSTR(UDF_ABI_VERSION_PATCH);
 
-#undef str
-#undef xstr
+#undef STR
+#undef XSTR
 }
 
 #define UDF_ABI_COMPATIBILITY_VERSION(MAJOR, MINOR) ((MAJOR) * 100 + (MINOR))