YQL-20086 minikql

commit_hash:c35c972d6708fb1b3f34fa34a42cdae1ddf11cdc

20 files changed, 356 insertions, 354 deletions

diff --git a/yql/essentials/minikql/jsonpath/executor.cpp b/yql/essentials/minikql/jsonpath/executor.cpp
index 786e25aaf14..54a82cefcb1 100644
--- a/yql/essentials/minikql/jsonpath/executor.cpp
+++ b/yql/essentials/minikql/jsonpath/executor.cpp
@@ -35,34 +35,34 @@ TIssue MakeError(const TJsonPathItem& item, TIssueCode code, const TStringBuf me
 }
 
 TResult::TResult(TJsonNodes&& nodes)
-    : Result(std::move(nodes))
+    : Result_(std::move(nodes))
 {
 }
 
 TResult::TResult(const TJsonNodes& nodes)
-    : Result(nodes)
+    : Result_(nodes)
 {
 }
 
 TResult::TResult(TIssue&& issue)
-    : Result(std::move(issue))
+    : Result_(std::move(issue))
 {
 }
 
 const TJsonNodes& TResult::GetNodes() const {
-    return std::get<TJsonNodes>(Result);
+    return std::get<TJsonNodes>(Result_);
 }
 
 TJsonNodes& TResult::GetNodes() {
-    return std::get<TJsonNodes>(Result);
+    return std::get<TJsonNodes>(Result_);
 }
 
 const TIssue& TResult::GetError() const {
-    return std::get<TIssue>(Result);
+    return std::get<TIssue>(Result_);
 }
 
 bool TResult::IsError() const {
-    return std::holds_alternative<TIssue>(Result);
+    return std::holds_alternative<TIssue>(Result_);
 }
 
 TExecutor::TExecutor(
@@ -70,10 +70,10 @@ TExecutor::TExecutor(
     const TJsonNodes& input,
     const TVariablesMap& variables,
     const IValueBuilder* valueBuilder)
-    : Reader(path)
-    , Input(input)
-    , Variables(variables)
-    , ValueBuilder(valueBuilder)
+    : Reader_(path)
+    , Input_(input)
+    , Variables_(variables)
+    , ValueBuilder_(valueBuilder)
 {
 }
 
@@ -94,15 +94,15 @@ bool TExecutor::IsEqual(double a, double b) {
 }
 
 bool TExecutor::IsStrict() const {
-    return Reader.GetMode() == EJsonPathMode::Strict;
+    return Reader_.GetMode() == EJsonPathMode::Strict;
 }
 
 bool TExecutor::IsLax() const {
-    return Reader.GetMode() == EJsonPathMode::Lax;
+    return Reader_.GetMode() == EJsonPathMode::Lax;
 }
 
 TResult TExecutor::Execute() {
-    return Execute(Reader.ReadFirst());
+    return Execute(Reader_.ReadFirst());
 }
 
 TResult TExecutor::Execute(const TJsonPathItem& item) {
@@ -178,12 +178,12 @@ TResult TExecutor::Execute(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::ContextObject() {
-    return Input;
+    return Input_;
 }
 
 TResult TExecutor::Variable(const TJsonPathItem& item) {
-    const auto it = Variables.find(item.GetString());
-    if (it == Variables.end()) {
+    const auto it = Variables_.find(item.GetString());
+    if (it == Variables_.end()) {
         return MakeError(item, TIssuesIds::JSONPATH_UNDEFINED_VARIABLE, TStringBuilder() << "Undefined variable '" << item.GetString() << "'");
     }
 
@@ -191,11 +191,11 @@ TResult TExecutor::Variable(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::LastArrayIndex(const TJsonPathItem& item) {
-    if (ArraySubscriptSource.empty()) {
+    if (ArraySubscriptSource_.empty()) {
         return MakeError(item, TIssuesIds::JSONPATH_LAST_OUTSIDE_OF_ARRAY_SUBSCRIPT, "'last' is only allowed inside array subscripts");
     }
 
-    const auto& array = ArraySubscriptSource.top();
+    const auto& array = ArraySubscriptSource_.top();
     const i64 arraySize = array.GetSize();
 
     // NOTE: For empty arrays `last` equals `-1`. This is intended, PostgreSQL 12 has the same behaviour
@@ -207,7 +207,7 @@ TResult TExecutor::NumberLiteral(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::MemberAccess(const TJsonPathItem& item) {
-    const auto input = Execute(Reader.ReadInput(item));
+    const auto input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -235,7 +235,7 @@ TResult TExecutor::MemberAccess(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::WildcardMemberAccess(const TJsonPathItem& item) {
-    const auto input = Execute(Reader.ReadInput(item));
+    const auto input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -276,7 +276,7 @@ TMaybe<TIssue> TExecutor::EnsureSingleSubscript(TPosition pos, const TJsonNodes&
 
 TMaybe<TIssue> TExecutor::EnsureArraySubscripts(const TJsonPathItem& item, TVector<TArraySubscript>& result) {
     for (const auto& subscript : item.GetSubscripts()) {
-        const auto& fromItem = Reader.ReadFromSubscript(subscript);
+        const auto& fromItem = Reader_.ReadFromSubscript(subscript);
         const auto fromResult = Execute(fromItem);
         if (fromResult.IsError()) {
             return fromResult.GetError();
@@ -293,7 +293,7 @@ TMaybe<TIssue> TExecutor::EnsureArraySubscripts(const TJsonPathItem& item, TVect
             continue;
         }
 
-        const auto& toItem = Reader.ReadToSubscript(subscript);
+        const auto& toItem = Reader_.ReadToSubscript(subscript);
         const auto toResult = Execute(toItem);
         if (toResult.IsError()) {
             return toResult.GetError();
@@ -311,7 +311,7 @@ TMaybe<TIssue> TExecutor::EnsureArraySubscripts(const TJsonPathItem& item, TVect
 }
 
 TResult TExecutor::ArrayAccess(const TJsonPathItem& item) {
-    const auto input = Execute(Reader.ReadInput(item));
+    const auto input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -321,9 +321,9 @@ TResult TExecutor::ArrayAccess(const TJsonPathItem& item) {
             return MakeError(item, TIssuesIds::JSONPATH_EXPECTED_ARRAY, "Expected array");
         }
 
-        ArraySubscriptSource.push(node);
+        ArraySubscriptSource_.push(node);
         Y_DEFER {
-            ArraySubscriptSource.pop();
+            ArraySubscriptSource_.pop();
         };
 
         // Check for "hard" errors in array subscripts. These are forbidden even in lax mode
@@ -375,7 +375,7 @@ TResult TExecutor::ArrayAccess(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::WildcardArrayAccess(const TJsonPathItem& item) {
-    const auto input = Execute(Reader.ReadInput(item));
+    const auto input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -395,7 +395,7 @@ TResult TExecutor::WildcardArrayAccess(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::UnaryArithmeticOp(const TJsonPathItem& item) {
-    const auto& operandItem = Reader.ReadInput(item);
+    const auto& operandItem = Reader_.ReadInput(item);
     const auto operandsResult = Execute(operandItem);
     if (operandsResult.IsError()) {
         return operandsResult;
@@ -442,7 +442,7 @@ TMaybe<TIssue> TExecutor::EnsureBinaryArithmeticOpArgument(TPosition pos, const
 }
 
 TResult TExecutor::BinaryArithmeticOp(const TJsonPathItem& item) {
-    const auto& leftItem = Reader.ReadLeftOperand(item);
+    const auto& leftItem = Reader_.ReadLeftOperand(item);
     const auto leftResult = Execute(leftItem);
     if (leftResult.IsError()) {
         return leftResult;
@@ -454,7 +454,7 @@ TResult TExecutor::BinaryArithmeticOp(const TJsonPathItem& item) {
         return std::move(*error);
     }
 
-    const auto& rightItem = Reader.ReadRightOperand(item);
+    const auto& rightItem = Reader_.ReadRightOperand(item);
     const auto rightResult = Execute(rightItem);
     if (rightResult.IsError()) {
         return rightResult;
@@ -518,7 +518,7 @@ TMaybe<TIssue> TExecutor::EnsureLogicalOpArgument(TPosition pos, const TJsonNode
 }
 
 TResult TExecutor::BinaryLogicalOp(const TJsonPathItem& item) {
-    const auto& leftItem = Reader.ReadLeftOperand(item);
+    const auto& leftItem = Reader_.ReadLeftOperand(item);
     const auto leftResult = Execute(leftItem);
     if (leftResult.IsError()) {
         return leftResult;
@@ -530,7 +530,7 @@ TResult TExecutor::BinaryLogicalOp(const TJsonPathItem& item) {
         return std::move(*error);
     }
 
-    const auto& rightItem = Reader.ReadRightOperand(item);
+    const auto& rightItem = Reader_.ReadRightOperand(item);
     const auto rightResult = Execute(rightItem);
     if (rightResult.IsError()) {
         return rightResult;
@@ -600,7 +600,7 @@ TResult TExecutor::UnaryLogicalOp(const TJsonPathItem& item) {
         | false | true  |
         | null  | null  |
     */
-    const auto& operandItem = Reader.ReadInput(item);
+    const auto& operandItem = Reader_.ReadInput(item);
     const auto operandResult = Execute(operandItem);
     if (operandResult.IsError()) {
         return operandResult;
@@ -628,7 +628,7 @@ TResult TExecutor::NullLiteral() {
 }
 
 TResult TExecutor::StringLiteral(const TJsonPathItem& item) {
-    return TJsonNodes({TValue(MakeString(item.GetString(), ValueBuilder))});
+    return TJsonNodes({TValue(MakeString(item.GetString(), ValueBuilder_))});
 }
 
 TMaybe<bool> TExecutor::CompareValues(const TValue& left, const TValue& right, EJsonPathItemType operation) {
@@ -706,13 +706,13 @@ TMaybe<bool> TExecutor::CompareValues(const TValue& left, const TValue& right, E
 }
 
 TResult TExecutor::CompareOp(const TJsonPathItem& item) {
-    const auto& leftItem = Reader.ReadLeftOperand(item);
+    const auto& leftItem = Reader_.ReadLeftOperand(item);
     const auto leftResult = Execute(leftItem);
     if (leftResult.IsError()) {
         return TJsonNodes({TValue(MakeEntity())});
     }
 
-    const auto& rightItem = Reader.ReadRightOperand(item);
+    const auto& rightItem = Reader_.ReadRightOperand(item);
     const auto rightResult = Execute(rightItem);
     if (rightResult.IsError()) {
         return TJsonNodes({TValue(MakeEntity())});
@@ -748,24 +748,24 @@ TResult TExecutor::CompareOp(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::FilterObject(const TJsonPathItem& item) {
-    if (CurrentFilterObject.empty()) {
+    if (CurrentFilterObject_.empty()) {
         return MakeError(item, TIssuesIds::JSONPATH_FILTER_OBJECT_OUTSIDE_OF_FILTER, "'@' is only allowed inside filters");
     }
 
-    return TJsonNodes({CurrentFilterObject.top()});
+    return TJsonNodes({CurrentFilterObject_.top()});
 }
 
 TResult TExecutor::FilterPredicate(const TJsonPathItem& item) {
-    const auto input = Execute(Reader.ReadInput(item));
+    const auto input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
-    const auto& predicateItem = Reader.ReadFilterPredicate(item);
+    const auto& predicateItem = Reader_.ReadFilterPredicate(item);
     TJsonNodes result;
     for (const auto& node : OptionalUnwrapArrays(input.GetNodes())) {
-        CurrentFilterObject.push(node);
+        CurrentFilterObject_.push(node);
         Y_DEFER {
-            CurrentFilterObject.pop();
+            CurrentFilterObject_.pop();
         };
 
         const auto predicateResult = Execute(predicateItem);
@@ -788,7 +788,7 @@ TResult TExecutor::FilterPredicate(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::NumericMethod(const TJsonPathItem& item) {
-    const auto& input = Execute(Reader.ReadInput(item));
+    const auto& input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -818,7 +818,7 @@ TResult TExecutor::NumericMethod(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::DoubleMethod(const TJsonPathItem& item) {
-    const auto& input = Execute(Reader.ReadInput(item));
+    const auto& input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -843,7 +843,7 @@ TResult TExecutor::DoubleMethod(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::TypeMethod(const TJsonPathItem& item) {
-    const auto& input = Execute(Reader.ReadInput(item));
+    const auto& input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -870,13 +870,13 @@ TResult TExecutor::TypeMethod(const TJsonPathItem& item) {
                 type = "object";
                 break;
         }
-        result.push_back(TValue(MakeString(type, ValueBuilder)));
+        result.push_back(TValue(MakeString(type, ValueBuilder_)));
     }
     return std::move(result);
 }
 
 TResult TExecutor::SizeMethod(const TJsonPathItem& item) {
-    const auto& input = Execute(Reader.ReadInput(item));
+    const auto& input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -892,7 +892,7 @@ TResult TExecutor::SizeMethod(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::KeyValueMethod(const TJsonPathItem& item) {
-    const auto& input = Execute(Reader.ReadInput(item));
+    const auto& input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -909,11 +909,11 @@ TResult TExecutor::KeyValueMethod(const TJsonPathItem& item) {
         TValue value;
         auto it = node.GetObjectIterator();
         while (it.Next(key, value)) {
-            nameEntry.first = MakeString("name", ValueBuilder);
-            nameEntry.second = key.ConvertToUnboxedValue(ValueBuilder);
+            nameEntry.first = MakeString("name", ValueBuilder_);
+            nameEntry.second = key.ConvertToUnboxedValue(ValueBuilder_);
 
-            valueEntry.first = MakeString("value", ValueBuilder);
-            valueEntry.second = value.ConvertToUnboxedValue(ValueBuilder);
+            valueEntry.first = MakeString("value", ValueBuilder_);
+            valueEntry.second = value.ConvertToUnboxedValue(ValueBuilder_);
 
             result.push_back(TValue(MakeDict(row, 2)));
         }
@@ -922,7 +922,7 @@ TResult TExecutor::KeyValueMethod(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::StartsWithPredicate(const TJsonPathItem& item) {
-    const auto& input = Execute(Reader.ReadInput(item));
+    const auto& input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -937,7 +937,7 @@ TResult TExecutor::StartsWithPredicate(const TJsonPathItem& item) {
         return MakeError(item, TIssuesIds::JSONPATH_INVALID_STARTS_WITH_ARGUMENT, "Type of input argument for starts with predicate must be string");
     }
 
-    const auto prefix = Execute(Reader.ReadPrefix(item));
+    const auto prefix = Execute(Reader_.ReadPrefix(item));
     if (prefix.IsError()) {
         return prefix;
     }
@@ -963,7 +963,7 @@ TResult TExecutor::StartsWithPredicate(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::IsUnknownPredicate(const TJsonPathItem& item) {
-    const auto input = Execute(Reader.ReadInput(item));
+    const auto input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -985,7 +985,7 @@ TResult TExecutor::IsUnknownPredicate(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::ExistsPredicate(const TJsonPathItem& item) {
-    const auto input = Execute(Reader.ReadInput(item));
+    const auto input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return TJsonNodes({TValue(MakeEntity())});
     }
@@ -995,7 +995,7 @@ TResult TExecutor::ExistsPredicate(const TJsonPathItem& item) {
 }
 
 TResult TExecutor::LikeRegexPredicate(const TJsonPathItem& item) {
-    const auto input = Execute(Reader.ReadInput(item));
+    const auto input = Execute(Reader_.ReadInput(item));
     if (input.IsError()) {
         return input;
     }
@@ -1054,8 +1054,8 @@ TJsonNodes TExecutor::OptionalArrayWrapNodes(const TJsonNodes& input) {
             continue;
         }
 
-        TUnboxedValue nodeCopy(node.ConvertToUnboxedValue(ValueBuilder));
-        result.push_back(TValue(MakeList(&nodeCopy, 1, ValueBuilder)));
+        TUnboxedValue nodeCopy(node.ConvertToUnboxedValue(ValueBuilder_));
+        result.push_back(TValue(MakeList(&nodeCopy, 1, ValueBuilder_)));
     }
     return result;
 }
diff --git a/yql/essentials/minikql/jsonpath/executor.h b/yql/essentials/minikql/jsonpath/executor.h
index d09f7ee4437..f591abed7ae 100644
--- a/yql/essentials/minikql/jsonpath/executor.h
+++ b/yql/essentials/minikql/jsonpath/executor.h
@@ -40,54 +40,54 @@ public:
     bool IsError() const;
 
 private:
-    std::variant<TJsonNodes, TIssue> Result;
+    std::variant<TJsonNodes, TIssue> Result_;
 };
 
 class TArraySubscript {
 public:
     TArraySubscript(i64 from, TPosition fromPos)
-        : From(from)
-        , FromPos(fromPos)
-        , HasTo(false)
+        : From_(from)
+        , FromPos_(fromPos)
+        , HasTo_(false)
     {
     }
 
     TArraySubscript(i64 from, TPosition fromPos, i64 to, TPosition toPos)
-        : From(from)
-        , FromPos(fromPos)
-        , To(to)
-        , ToPos(toPos)
-        , HasTo(true)
+        : From_(from)
+        , FromPos_(fromPos)
+        , To_(to)
+        , ToPos_(toPos)
+        , HasTo_(true)
     {
     }
 
     i64 GetFrom() const {
-        return From;
+        return From_;
     }
 
     TPosition GetFromPos() const {
-        return FromPos;
+        return FromPos_;
     }
 
     i64 GetTo() const {
         YQL_ENSURE(IsRange());
-        return To;
+        return To_;
     }
 
     TPosition GetToPos() const {
-        return ToPos;
+        return ToPos_;
     }
 
     bool IsRange() const {
-        return HasTo;
+        return HasTo_;
     }
 
 private:
-    i64 From = 0;
-    TPosition FromPos;
-    i64 To = 0;
-    TPosition ToPos;
-    bool HasTo;
+    i64 From_ = 0;
+    TPosition FromPos_;
+    i64 To_ = 0;
+    TPosition ToPos_;
+    bool HasTo_;
 };
 
 using TVariablesMap = THashMap<TString, TValue>;
@@ -187,12 +187,12 @@ private:
 
     TJsonNodes OptionalArrayWrapNodes(const TJsonNodes& input);
 
-    TStack<TValue> ArraySubscriptSource;
-    TStack<TValue> CurrentFilterObject;
-    TJsonPathReader Reader;
-    TJsonNodes Input;
-    const TVariablesMap& Variables;
-    const NUdf::IValueBuilder* ValueBuilder;
+    TStack<TValue> ArraySubscriptSource_;
+    TStack<TValue> CurrentFilterObject_;
+    TJsonPathReader Reader_;
+    TJsonNodes Input_;
+    const TVariablesMap& Variables_;
+    const NUdf::IValueBuilder* ValueBuilder_;
 };
 
 }
diff --git a/yql/essentials/minikql/jsonpath/parser/ast_builder.cpp b/yql/essentials/minikql/jsonpath/parser/ast_builder.cpp
index 2cfecb94310..2b630fda8b7 100644
--- a/yql/essentials/minikql/jsonpath/parser/ast_builder.cpp
+++ b/yql/essentials/minikql/jsonpath/parser/ast_builder.cpp
@@ -63,13 +63,13 @@ bool TryStringContent(const TString& str, TString& result, TString& error, bool
 }
 
 TAstBuilder::TAstBuilder(TIssues& issues)
-    : Issues(issues)
+    : Issues_(issues)
 {
 }
 
 void TAstBuilder::Error(TPosition pos, const TStringBuf message) {
-    Issues.AddIssue(pos, message);
-    Issues.back().SetCode(TIssuesIds::JSONPATH_PARSE_ERROR, TSeverityIds::S_ERROR);
+    Issues_.AddIssue(pos, message);
+    Issues_.back().SetCode(TIssuesIds::JSONPATH_PARSE_ERROR, TSeverityIds::S_ERROR);
 }
 
 TArrayAccessNode::TSubscript TAstBuilder::BuildArraySubscript(const TRule_array_subscript& node) {
diff --git a/yql/essentials/minikql/jsonpath/parser/ast_builder.h b/yql/essentials/minikql/jsonpath/parser/ast_builder.h
index 66a47483b34..6f5e2d72c7b 100644
--- a/yql/essentials/minikql/jsonpath/parser/ast_builder.h
+++ b/yql/essentials/minikql/jsonpath/parser/ast_builder.h
@@ -46,7 +46,7 @@ private:
 
     void Error(TPosition pos, const TStringBuf message);
 
-    TIssues& Issues;
+    TIssues& Issues_;
 };
 
 }
diff --git a/yql/essentials/minikql/jsonpath/parser/ast_nodes.cpp b/yql/essentials/minikql/jsonpath/parser/ast_nodes.cpp
index 5a51c2e90e2..b89bc87ddb8 100644
--- a/yql/essentials/minikql/jsonpath/parser/ast_nodes.cpp
+++ b/yql/essentials/minikql/jsonpath/parser/ast_nodes.cpp
@@ -3,12 +3,12 @@
 namespace NYql::NJsonPath {
 
 TAstNode::TAstNode(TPosition pos)
-    : Pos(pos)
+    : Pos_(pos)
 {
 }
 
 TPosition TAstNode::GetPos() const {
-    return Pos;
+    return Pos_;
 }
 
 EReturnType TAstNode::GetReturnType() const {
@@ -17,17 +17,17 @@ EReturnType TAstNode::GetReturnType() const {
 
 TRootNode::TRootNode(TPosition pos, TAstNodePtr expr, EJsonPathMode mode)
     : TAstNode(pos)
-    , Expr(expr)
-    , Mode(mode)
+    , Expr_(expr)
+    , Mode_(mode)
 {
 }
 
 const TAstNodePtr TRootNode::GetExpr() const {
-    return Expr;
+    return Expr_;
 }
 
 EJsonPathMode TRootNode::GetMode() const {
-    return Mode;
+    return Mode_;
 }
 
 void TRootNode::Accept(IAstNodeVisitor& visitor) const {
@@ -35,7 +35,7 @@ void TRootNode::Accept(IAstNodeVisitor& visitor) const {
 }
 
 EReturnType TRootNode::GetReturnType() const {
-    return Expr->GetReturnType();
+    return Expr_->GetReturnType();
 }
 
 TContextObjectNode::TContextObjectNode(TPosition pos)
@@ -49,12 +49,12 @@ void TContextObjectNode::Accept(IAstNodeVisitor& visitor) const {
 
 TVariableNode::TVariableNode(TPosition pos, const TString& name)
     : TAstNode(pos)
-    , Name(name)
+    , Name_(name)
 {
 }
 
 const TString& TVariableNode::GetName() const {
-    return Name;
+    return Name_;
 }
 
 void TVariableNode::Accept(IAstNodeVisitor& visitor) const {
@@ -72,12 +72,12 @@ void TLastArrayIndexNode::Accept(IAstNodeVisitor& visitor) const {
 
 TNumberLiteralNode::TNumberLiteralNode(TPosition pos, double value)
     : TAstNode(pos)
-    , Value(value)
+    , Value_(value)
 {
 }
 
 double TNumberLiteralNode::GetValue() const {
-    return Value;
+    return Value_;
 }
 
 void TNumberLiteralNode::Accept(IAstNodeVisitor& visitor) const {
@@ -86,17 +86,17 @@ void TNumberLiteralNode::Accept(IAstNodeVisitor& visitor) const {
 
 TMemberAccessNode::TMemberAccessNode(TPosition pos, const TString& member, TAstNodePtr input)
     : TAstNode(pos)
-    , Member(member)
-    , Input(input)
+    , Member_(member)
+    , Input_(input)
 {
 }
 
 const TStringBuf TMemberAccessNode::GetMember() const {
-    return Member;
+    return Member_;
 }
 
 const TAstNodePtr TMemberAccessNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 void TMemberAccessNode::Accept(IAstNodeVisitor& visitor) const {
@@ -105,12 +105,12 @@ void TMemberAccessNode::Accept(IAstNodeVisitor& visitor) const {
 
 TWildcardMemberAccessNode::TWildcardMemberAccessNode(TPosition pos, TAstNodePtr input)
     : TAstNode(pos)
-    , Input(input)
+    , Input_(input)
 {
 }
 
 const TAstNodePtr TWildcardMemberAccessNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 void TWildcardMemberAccessNode::Accept(IAstNodeVisitor& visitor) const {
@@ -119,17 +119,17 @@ void TWildcardMemberAccessNode::Accept(IAstNodeVisitor& visitor) const {
 
 TArrayAccessNode::TArrayAccessNode(TPosition pos, TVector<TSubscript> subscripts, TAstNodePtr input)
     : TAstNode(pos)
-    , Subscripts(subscripts)
-    , Input(input)
+    , Subscripts_(subscripts)
+    , Input_(input)
 {
 }
 
 const TVector<TArrayAccessNode::TSubscript>& TArrayAccessNode::GetSubscripts() const {
-    return Subscripts;
+    return Subscripts_;
 }
 
 const TAstNodePtr TArrayAccessNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 void TArrayAccessNode::Accept(IAstNodeVisitor& visitor) const {
@@ -138,12 +138,12 @@ void TArrayAccessNode::Accept(IAstNodeVisitor& visitor) const {
 
 TWildcardArrayAccessNode::TWildcardArrayAccessNode(TPosition pos, TAstNodePtr input)
     : TAstNode(pos)
-    , Input(input)
+    , Input_(input)
 {
 }
 
 const TAstNodePtr TWildcardArrayAccessNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 void TWildcardArrayAccessNode::Accept(IAstNodeVisitor& visitor) const {
@@ -152,17 +152,17 @@ void TWildcardArrayAccessNode::Accept(IAstNodeVisitor& visitor) const {
 
 TUnaryOperationNode::TUnaryOperationNode(TPosition pos, EUnaryOperation op, TAstNodePtr expr)
     : TAstNode(pos)
-    , Operation(op)
-    , Expr(expr)
+    , Operation_(op)
+    , Expr_(expr)
 {
 }
 
 EUnaryOperation TUnaryOperationNode::GetOp() const {
-    return Operation;
+    return Operation_;
 }
 
 const TAstNodePtr TUnaryOperationNode::GetExpr() const {
-    return Expr;
+    return Expr_;
 }
 
 void TUnaryOperationNode::Accept(IAstNodeVisitor& visitor) const {
@@ -170,27 +170,27 @@ void TUnaryOperationNode::Accept(IAstNodeVisitor& visitor) const {
 }
 
 EReturnType TUnaryOperationNode::GetReturnType() const {
-    return Operation == EUnaryOperation::Not ? EReturnType::Bool : EReturnType::Any;
+    return Operation_ == EUnaryOperation::Not ? EReturnType::Bool : EReturnType::Any;
 }
 
 TBinaryOperationNode::TBinaryOperationNode(TPosition pos, EBinaryOperation op, TAstNodePtr leftExpr, TAstNodePtr rightExpr)
     : TAstNode(pos)
-    , Operation(op)
-    , LeftExpr(leftExpr)
-    , RightExpr(rightExpr)
+    , Operation_(op)
+    , LeftExpr_(leftExpr)
+    , RightExpr_(rightExpr)
 {
 }
 
 EBinaryOperation TBinaryOperationNode::GetOp() const {
-    return Operation;
+    return Operation_;
 }
 
 const TAstNodePtr TBinaryOperationNode::GetLeftExpr() const {
-    return LeftExpr;
+    return LeftExpr_;
 }
 
 const TAstNodePtr TBinaryOperationNode::GetRightExpr() const {
-    return RightExpr;
+    return RightExpr_;
 }
 
 void TBinaryOperationNode::Accept(IAstNodeVisitor& visitor) const {
@@ -198,7 +198,7 @@ void TBinaryOperationNode::Accept(IAstNodeVisitor& visitor) const {
 }
 
 EReturnType TBinaryOperationNode::GetReturnType() const {
-    switch (Operation) {
+    switch (Operation_) {
         case EBinaryOperation::Less:
         case EBinaryOperation::LessEqual:
         case EBinaryOperation::Greater:
@@ -216,12 +216,12 @@ EReturnType TBinaryOperationNode::GetReturnType() const {
 
 TBooleanLiteralNode::TBooleanLiteralNode(TPosition pos, bool value)
     : TAstNode(pos)
-    , Value(value)
+    , Value_(value)
 {
 }
 
 bool TBooleanLiteralNode::GetValue() const {
-    return Value;
+    return Value_;
 }
 
 void TBooleanLiteralNode::Accept(IAstNodeVisitor& visitor) const {
@@ -239,12 +239,12 @@ void TNullLiteralNode::Accept(IAstNodeVisitor& visitor) const {
 
 TStringLiteralNode::TStringLiteralNode(TPosition pos, const TString& value)
     : TAstNode(pos)
-    , Value(value)
+    , Value_(value)
 {
 }
 
 const TString& TStringLiteralNode::GetValue() const {
-    return Value;
+    return Value_;
 }
 
 void TStringLiteralNode::Accept(IAstNodeVisitor& visitor) const {
@@ -262,17 +262,17 @@ void TFilterObjectNode::Accept(IAstNodeVisitor& visitor) const {
 
 TFilterPredicateNode::TFilterPredicateNode(TPosition pos, TAstNodePtr predicate, TAstNodePtr input)
     : TAstNode(pos)
-    , Predicate(predicate)
-    , Input(input)
+    , Predicate_(predicate)
+    , Input_(input)
 {
 }
 
 const TAstNodePtr TFilterPredicateNode::GetPredicate() const {
-    return Predicate;
+    return Predicate_;
 }
 
 const TAstNodePtr TFilterPredicateNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 void TFilterPredicateNode::Accept(IAstNodeVisitor& visitor) const {
@@ -281,17 +281,17 @@ void TFilterPredicateNode::Accept(IAstNodeVisitor& visitor) const {
 
 TMethodCallNode::TMethodCallNode(TPosition pos, EMethodType type, TAstNodePtr input)
     : TAstNode(pos)
-    , Type(type)
-    , Input(input)
+    , Type_(type)
+    , Input_(input)
 {
 }
 
 EMethodType TMethodCallNode::GetType() const {
-    return Type;
+    return Type_;
 }
 
 const TAstNodePtr TMethodCallNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 void TMethodCallNode::Accept(IAstNodeVisitor& visitor) const {
@@ -300,17 +300,17 @@ void TMethodCallNode::Accept(IAstNodeVisitor& visitor) const {
 
 TStartsWithPredicateNode::TStartsWithPredicateNode(TPosition pos, TAstNodePtr input, TAstNodePtr prefix)
     : TAstNode(pos)
-    , Input(input)
-    , Prefix(prefix)
+    , Input_(input)
+    , Prefix_(prefix)
 {
 }
 
 const TAstNodePtr TStartsWithPredicateNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 const TAstNodePtr TStartsWithPredicateNode::GetPrefix() const {
-    return Prefix;
+    return Prefix_;
 }
 
 EReturnType TStartsWithPredicateNode::GetReturnType() const {
@@ -323,12 +323,12 @@ void TStartsWithPredicateNode::Accept(IAstNodeVisitor& visitor) const {
 
 TExistsPredicateNode::TExistsPredicateNode(TPosition pos, TAstNodePtr input)
     : TAstNode(pos)
-    , Input(input)
+    , Input_(input)
 {
 }
 
 const TAstNodePtr TExistsPredicateNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 EReturnType TExistsPredicateNode::GetReturnType() const {
@@ -341,12 +341,12 @@ void TExistsPredicateNode::Accept(IAstNodeVisitor& visitor) const {
 
 TIsUnknownPredicateNode::TIsUnknownPredicateNode(TPosition pos, TAstNodePtr input)
     : TAstNode(pos)
-    , Input(input)
+    , Input_(input)
 {
 }
 
 const TAstNodePtr TIsUnknownPredicateNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 EReturnType TIsUnknownPredicateNode::GetReturnType() const {
@@ -359,17 +359,17 @@ void TIsUnknownPredicateNode::Accept(IAstNodeVisitor& visitor) const {
 
 TLikeRegexPredicateNode::TLikeRegexPredicateNode(TPosition pos, TAstNodePtr input, NReWrapper::IRePtr&& regex)
     : TAstNode(pos)
-    , Input(input)
-    , Regex(std::move(regex))
+    , Input_(input)
+    , Regex_(std::move(regex))
 {
 }
 
 const TAstNodePtr TLikeRegexPredicateNode::GetInput() const {
-    return Input;
+    return Input_;
 }
 
 const NReWrapper::IRePtr& TLikeRegexPredicateNode::GetRegex() const {
-    return Regex;
+    return Regex_;
 }
 
 EReturnType TLikeRegexPredicateNode::GetReturnType() const {
diff --git a/yql/essentials/minikql/jsonpath/parser/ast_nodes.h b/yql/essentials/minikql/jsonpath/parser/ast_nodes.h
index 6ccb8a56ea8..07021d973ce 100644
--- a/yql/essentials/minikql/jsonpath/parser/ast_nodes.h
+++ b/yql/essentials/minikql/jsonpath/parser/ast_nodes.h
@@ -80,7 +80,7 @@ public:
     virtual ~TAstNode() = default;
 
 private:
-    TPosition Pos;
+    TPosition Pos_;
 };
 
 using TAstNodePtr = TIntrusivePtr<TAstNode>;
@@ -98,8 +98,8 @@ public:
     EReturnType GetReturnType() const override;
 
 private:
-    TAstNodePtr Expr;
-    EJsonPathMode Mode;
+    TAstNodePtr Expr_;
+    EJsonPathMode Mode_;
 };
 
 class TContextObjectNode : public TAstNode {
@@ -118,7 +118,7 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TString Name;
+    TString Name_;
 };
 
 class TLastArrayIndexNode : public TAstNode {
@@ -137,7 +137,7 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    double Value;
+    double Value_;
 };
 
 class TMemberAccessNode : public TAstNode {
@@ -151,8 +151,8 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TString Member;
-    TAstNodePtr Input;
+    TString Member_;
+    TAstNodePtr Input_;
 };
 
 class TWildcardMemberAccessNode : public TAstNode {
@@ -164,7 +164,7 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TAstNodePtr Input;
+    TAstNodePtr Input_;
 };
 
 class TArrayAccessNode : public TAstNode {
@@ -183,8 +183,8 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TVector<TSubscript> Subscripts;
-    TAstNodePtr Input;
+    TVector<TSubscript> Subscripts_;
+    TAstNodePtr Input_;
 };
 
 class TWildcardArrayAccessNode : public TAstNode {
@@ -196,7 +196,7 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TAstNodePtr Input;
+    TAstNodePtr Input_;
 };
 
 enum class EUnaryOperation {
@@ -218,8 +218,8 @@ public:
     EReturnType GetReturnType() const override;
 
 private:
-    EUnaryOperation Operation;
-    TAstNodePtr Expr;
+    EUnaryOperation Operation_;
+    TAstNodePtr Expr_;
 };
 
 enum class EBinaryOperation {
@@ -253,9 +253,9 @@ public:
     EReturnType GetReturnType() const override;
 
 private:
-    EBinaryOperation Operation;
-    TAstNodePtr LeftExpr;
-    TAstNodePtr RightExpr;
+    EBinaryOperation Operation_;
+    TAstNodePtr LeftExpr_;
+    TAstNodePtr RightExpr_;
 };
 
 class TBooleanLiteralNode : public TAstNode {
@@ -267,7 +267,7 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    bool Value;
+    bool Value_;
 };
 
 class TNullLiteralNode : public TAstNode {
@@ -286,7 +286,7 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TString Value;
+    TString Value_;
 };
 
 class TFilterObjectNode : public TAstNode {
@@ -307,8 +307,8 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TAstNodePtr Predicate;
-    TAstNodePtr Input;
+    TAstNodePtr Predicate_;
+    TAstNodePtr Input_;
 };
 
 enum class EMethodType {
@@ -332,8 +332,8 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    EMethodType Type;
-    TAstNodePtr Input;
+    EMethodType Type_;
+    TAstNodePtr Input_;
 };
 
 class TStartsWithPredicateNode : public TAstNode {
@@ -349,8 +349,8 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TAstNodePtr Input;
-    TAstNodePtr Prefix;
+    TAstNodePtr Input_;
+    TAstNodePtr Prefix_;
 };
 
 class TExistsPredicateNode : public TAstNode {
@@ -364,7 +364,7 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TAstNodePtr Input;
+    TAstNodePtr Input_;
 };
 
 class TIsUnknownPredicateNode : public TAstNode {
@@ -378,7 +378,7 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TAstNodePtr Input;
+    TAstNodePtr Input_;
 };
 
 class TLikeRegexPredicateNode : public TAstNode {
@@ -394,8 +394,8 @@ public:
     void Accept(IAstNodeVisitor& visitor) const override;
 
 private:
-    TAstNodePtr Input;
-    NReWrapper::IRePtr Regex;
+    TAstNodePtr Input_;
+    NReWrapper::IRePtr Regex_;
 };
 
 }
diff --git a/yql/essentials/minikql/jsonpath/parser/binary.cpp b/yql/essentials/minikql/jsonpath/parser/binary.cpp
index 8d75a6d3b90..cf966e29a63 100644
--- a/yql/essentials/minikql/jsonpath/parser/binary.cpp
+++ b/yql/essentials/minikql/jsonpath/parser/binary.cpp
@@ -41,14 +41,14 @@ const NReWrapper::IRePtr& TJsonPathItem::GetRegex() const {
 }
 
 TJsonPathReader::TJsonPathReader(const TJsonPathPtr path)
-    : Path(path)
-    , InitialPos(0)
-    , Mode(ReadMode(InitialPos))
+    : Path_(path)
+    , InitialPos_(0)
+    , Mode_(ReadMode(InitialPos_))
 {
 }
 
 const TJsonPathItem& TJsonPathReader::ReadFirst() {
-    return ReadFromPos(InitialPos);
+    return ReadFromPos(InitialPos_);
 }
 
 const TJsonPathItem& TJsonPathReader::ReadInput(const TJsonPathItem& item) {
@@ -82,18 +82,18 @@ const TJsonPathItem& TJsonPathReader::ReadPrefix(const TJsonPathItem& node) {
 }
 
 EJsonPathMode TJsonPathReader::GetMode() const {
-    return Mode;
+    return Mode_;
 }
 
 const TJsonPathItem& TJsonPathReader::ReadFromPos(TUint pos) {
-    YQL_ENSURE(pos < Path->Size());
+    YQL_ENSURE(pos < Path_->Size());
 
-    const auto it = ItemCache.find(pos);
-    if (it != ItemCache.end()) {
+    const auto it = ItemCache_.find(pos);
+    if (it != ItemCache_.end()) {
         return it->second;
     }
 
-    TJsonPathItem& result = ItemCache[pos];
+    TJsonPathItem& result = ItemCache_[pos];
     result.Type = ReadType(pos);
 
     const auto row = ReadUint(pos);
@@ -214,7 +214,7 @@ EJsonPathMode TJsonPathReader::ReadMode(TUint& pos) {
 
 const TStringBuf TJsonPathReader::ReadString(TUint& pos) {
     TUint length = ReadUint(pos);
-    TStringBuf result(Path->Begin() + pos, length);
+    TStringBuf result(Path_->Begin() + pos, length);
     pos += length;
     return result;
 }
@@ -448,8 +448,8 @@ void TJsonPathBuilder::VisitMethodCall(const TMethodCallNode& node) {
 }
 
 TJsonPathPtr TJsonPathBuilder::ShrinkAndGetResult() {
-    Result->ShrinkToFit();
-    return Result;
+    Result_->ShrinkToFit();
+    return Result_;
 }
 
 void TJsonPathBuilder::VisitStartsWithPredicate(const TStartsWithPredicateNode& node) {
@@ -563,25 +563,25 @@ void TJsonPathBuilder::WriteFinishPosition() {
 
 void TJsonPathBuilder::WriteString(TStringBuf value) {
     WriteUint(value.size());
-    Result->Append(value.data(), value.size());
+    Result_->Append(value.data(), value.size());
 }
 
 void TJsonPathBuilder::RewriteUintSequence(const TVector<TUint>& sequence, TUint offset) {
     const auto length = sequence.size() * sizeof(TUint);
     Y_ASSERT(offset + length < CurrentEndPos());
 
-    MemCopy(Result->Data() + offset, reinterpret_cast<const char*>(sequence.data()), length);
+    MemCopy(Result_->Data() + offset, reinterpret_cast<const char*>(sequence.data()), length);
 }
 
 void TJsonPathBuilder::WriteUintSequence(const TVector<TUint>& sequence) {
     const auto length = sequence.size() * sizeof(TUint);
-    Result->Append(reinterpret_cast<const char*>(sequence.data()), length);
+    Result_->Append(reinterpret_cast<const char*>(sequence.data()), length);
 }
 
 void TJsonPathBuilder::RewriteUint(TUint value, TUint offset) {
     Y_ASSERT(offset + sizeof(TUint) < CurrentEndPos());
 
-    MemCopy(Result->Data() + offset, reinterpret_cast<const char*>(&value), sizeof(TUint));
+    MemCopy(Result_->Data() + offset, reinterpret_cast<const char*>(&value), sizeof(TUint));
 }
 
 void TJsonPathBuilder::WriteUint(TUint value) {
@@ -597,7 +597,7 @@ void TJsonPathBuilder::WriteBool(bool value) {
 }
 
 TUint TJsonPathBuilder::CurrentEndPos() const {
-    return Result->Size();
+    return Result_->Size();
 }
 
 
diff --git a/yql/essentials/minikql/jsonpath/parser/binary.h b/yql/essentials/minikql/jsonpath/parser/binary.h
index 7ce26261527..4390996fb30 100644
--- a/yql/essentials/minikql/jsonpath/parser/binary.h
+++ b/yql/essentials/minikql/jsonpath/parser/binary.h
@@ -129,7 +129,7 @@ struct TJsonPathItem {
 class TJsonPathBuilder : public IAstNodeVisitor {
 public:
     TJsonPathBuilder()
-        : Result(new TJsonPath())
+        : Result_(new TJsonPath())
     {
     }
 
@@ -211,12 +211,12 @@ private:
     template <typename T>
     void WritePOD(const T& value) {
         static_assert(std::is_pod_v<T>, "Type must be POD");
-        Result->Append(reinterpret_cast<const char*>(&value), sizeof(T));
+        Result_->Append(reinterpret_cast<const char*>(&value), sizeof(T));
     }
 
     TUint CurrentEndPos() const;
 
-    TJsonPathPtr Result;
+    TJsonPathPtr Result_;
 };
 
 class TJsonPathReader {
@@ -261,15 +261,15 @@ private:
     template <typename T>
     T ReadPOD(TUint& pos) {
         static_assert(std::is_pod_v<T>, "Type must be POD");
-        T value = ReadUnaligned<T>(Path->Begin() + pos);
+        T value = ReadUnaligned<T>(Path_->Begin() + pos);
         pos += sizeof(T);
         return std::move(value);
     }
 
-    const TJsonPathPtr Path;
-    TUint InitialPos;
-    EJsonPathMode Mode;
-    THashMap<TUint, TJsonPathItem> ItemCache;
+    const TJsonPathPtr Path_;
+    TUint InitialPos_;
+    EJsonPathMode Mode_;
+    THashMap<TUint, TJsonPathItem> ItemCache_;
 };
 
 }
diff --git a/yql/essentials/minikql/jsonpath/parser/parser.cpp b/yql/essentials/minikql/jsonpath/parser/parser.cpp
index 105305ea3c5..39105a0c731 100644
--- a/yql/essentials/minikql/jsonpath/parser/parser.cpp
+++ b/yql/essentials/minikql/jsonpath/parser/parser.cpp
@@ -29,17 +29,17 @@ class TParseErrorsCollector : public NProtoAST::IErrorCollector {
 public:
     TParseErrorsCollector(TIssues& issues, size_t maxErrors)
         : IErrorCollector(maxErrors)
-        , Issues(issues)
+        , Issues_(issues)
     {
     }
 
 private:
     void AddError(ui32 line, ui32 column, const TString& message) override {
-        Issues.AddIssue(TPosition(column, line, "jsonpath"), StripString(message));
-        Issues.back().SetCode(TIssuesIds::JSONPATH_PARSE_ERROR, TSeverityIds::S_ERROR);
+        Issues_.AddIssue(TPosition(column, line, "jsonpath"), StripString(message));
+        Issues_.back().SetCode(TIssuesIds::JSONPATH_PARSE_ERROR, TSeverityIds::S_ERROR);
     }
 
-    TIssues& Issues;
+    TIssues& Issues_;
 };
 
 }
diff --git a/yql/essentials/minikql/jsonpath/parser/type_check.cpp b/yql/essentials/minikql/jsonpath/parser/type_check.cpp
index f6ef00c9b24..db1c2cb5866 100644
--- a/yql/essentials/minikql/jsonpath/parser/type_check.cpp
+++ b/yql/essentials/minikql/jsonpath/parser/type_check.cpp
@@ -5,7 +5,7 @@
 namespace NYql::NJsonPath {
 
 TJsonPathTypeChecker::TJsonPathTypeChecker(TIssues& issues)
-    : Issues(issues)
+    : Issues_(issues)
 {
 }
 
@@ -125,8 +125,8 @@ void TJsonPathTypeChecker::VisitLikeRegexPredicate(const TLikeRegexPredicateNode
 }
 
 void TJsonPathTypeChecker::Error(const TAstNodePtr node, const TStringBuf message) {
-    Issues.AddIssue(node->GetPos(), message);
-    Issues.back().SetCode(TIssuesIds::JSONPATH_TYPE_CHECK_ERROR, TSeverityIds::S_ERROR);
+    Issues_.AddIssue(node->GetPos(), message);
+    Issues_.back().SetCode(TIssuesIds::JSONPATH_TYPE_CHECK_ERROR, TSeverityIds::S_ERROR);
 }
 
 }
diff --git a/yql/essentials/minikql/jsonpath/parser/type_check.h b/yql/essentials/minikql/jsonpath/parser/type_check.h
index 4c56a8a72ae..6565b59182c 100644
--- a/yql/essentials/minikql/jsonpath/parser/type_check.h
+++ b/yql/essentials/minikql/jsonpath/parser/type_check.h
@@ -53,7 +53,7 @@ public:
     void Error(const TAstNodePtr node, const TStringBuf message);
 
 private:
-    TIssues& Issues;
+    TIssues& Issues_;
 };
 
 }
diff --git a/yql/essentials/minikql/jsonpath/rewrapper/hyperscan/hyperscan.cpp b/yql/essentials/minikql/jsonpath/rewrapper/hyperscan/hyperscan.cpp
index 2fc490b6f41..a4c0fa3a13a 100644
--- a/yql/essentials/minikql/jsonpath/rewrapper/hyperscan/hyperscan.cpp
+++ b/yql/essentials/minikql/jsonpath/rewrapper/hyperscan/hyperscan.cpp
@@ -12,19 +12,19 @@ namespace {
 class THyperscan : public IRe {
 public:
     THyperscan(::NHyperscan::TDatabase&& db)
-        : Database(std::move(db))
+        : Database_(std::move(db))
     { }
 
     bool Matches(const TStringBuf& text) const override {
-        if (!Scratch) {
-            Scratch = ::NHyperscan::MakeScratch(Database);
+        if (!Scratch_) {
+            Scratch_ = ::NHyperscan::MakeScratch(Database_);
         }
-        return ::NHyperscan::Matches(Database, Scratch, text);
+        return ::NHyperscan::Matches(Database_, Scratch_, text);
     }
 
     TString Serialize() const override {
         // Compatibility with old versions
-        return ::NHyperscan::Serialize(Database);
+        return ::NHyperscan::Serialize(Database_);
 /*
  *       TSerialization proto;
  *       proto.SetHyperscan(::NHyperscan::Serialize(Database));
@@ -35,8 +35,8 @@ public:
  */
     }
 private:
-    ::NHyperscan::TDatabase Database;
-    mutable ::NHyperscan::TScratch Scratch;
+    ::NHyperscan::TDatabase Database_;
+    mutable ::NHyperscan::TScratch Scratch_;
 };
 
 }
diff --git a/yql/essentials/minikql/jsonpath/rewrapper/re2/re2.cpp b/yql/essentials/minikql/jsonpath/rewrapper/re2/re2.cpp
index 694472f6326..42deaa1835e 100644
--- a/yql/essentials/minikql/jsonpath/rewrapper/re2/re2.cpp
+++ b/yql/essentials/minikql/jsonpath/rewrapper/re2/re2.cpp
@@ -27,44 +27,44 @@ RE2::Options CreateOptions(const TStringBuf& regex, unsigned int flags) {
 class TRe2 : public IRe {
 public:
     TRe2(const TStringBuf& regex, unsigned int flags)
-        : Regexp(StringPiece(regex.data(), regex.size()), CreateOptions(regex, flags))
+        : Regexp_(StringPiece(regex.data(), regex.size()), CreateOptions(regex, flags))
     {
-        auto re2 = RawRegexp.MutableRe2();
+        auto re2 = RawRegexp_.MutableRe2();
         re2->set_regexp(TString(regex));
         re2->set_flags(flags);
     }
 
     TRe2(const TSerialization& proto)
-        : Regexp(StringPiece(proto.GetRe2().GetRegexp().data(), proto.GetRe2().GetRegexp().size()),
+        : Regexp_(StringPiece(proto.GetRe2().GetRegexp().data(), proto.GetRe2().GetRegexp().size()),
             CreateOptions(proto.GetRe2().GetRegexp(), proto.GetRe2().GetFlags()))
-        , RawRegexp(proto)
+        , RawRegexp_(proto)
     { }
 
     bool Matches(const TStringBuf& text) const override {
         const StringPiece piece(text.data(), text.size());
         RE2::Anchor anchor = RE2::UNANCHORED;
 
-        return Regexp.Match(piece, 0, text.size(), anchor, nullptr, 0);
+        return Regexp_.Match(piece, 0, text.size(), anchor, nullptr, 0);
     }
 
     TString Serialize() const override {
         TString data;
-        auto res = RawRegexp.SerializeToString(&data);
+        auto res = RawRegexp_.SerializeToString(&data);
         Y_ABORT_UNLESS(res);
         return data;
     }
 
     bool Ok(TString* error) const {
-        if (Regexp.ok()) {
+        if (Regexp_.ok()) {
             return true;
         } else {
-            *error = Regexp.error();
+            *error = Regexp_.error();
             return false;
         }
     }
 private:
-    RE2 Regexp;
-    TSerialization RawRegexp;
+    RE2 Regexp_;
+    TSerialization RawRegexp_;
 };
 
 }
diff --git a/yql/essentials/minikql/jsonpath/ut/common_ut.cpp b/yql/essentials/minikql/jsonpath/ut/common_ut.cpp
index a32389a7689..36308d013cd 100644
--- a/yql/essentials/minikql/jsonpath/ut/common_ut.cpp
+++ b/yql/essentials/minikql/jsonpath/ut/common_ut.cpp
@@ -95,7 +95,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -130,7 +130,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -158,7 +158,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -204,7 +204,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -247,7 +247,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -259,7 +259,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -277,7 +277,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -298,7 +298,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -343,7 +343,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -357,7 +357,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -391,7 +391,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -409,7 +409,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -466,7 +466,7 @@ public:
             {"123", {{"to", "1"}, {"strict", "2"}}, "$to + $strict", {"3"}},
         };
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunVariablesTestCase(testCase.Json, testCase.Variables, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -479,7 +479,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -505,7 +505,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -549,7 +549,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -658,7 +658,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -726,7 +726,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -738,7 +738,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -753,7 +753,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -767,7 +767,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -788,7 +788,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -801,7 +801,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -824,7 +824,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -847,7 +847,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -872,7 +872,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -885,7 +885,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -899,7 +899,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -912,7 +912,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -928,7 +928,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -943,7 +943,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -962,7 +962,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : ALL_MODES) {
+            for (const auto mode : AllModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
diff --git a/yql/essentials/minikql/jsonpath/ut/lax_ut.cpp b/yql/essentials/minikql/jsonpath/ut/lax_ut.cpp
index 4d5dda83ac9..0fe3ed15a6c 100644
--- a/yql/essentials/minikql/jsonpath/ut/lax_ut.cpp
+++ b/yql/essentials/minikql/jsonpath/ut/lax_ut.cpp
@@ -52,7 +52,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -65,7 +65,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -109,7 +109,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -127,7 +127,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -156,7 +156,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -174,7 +174,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -189,7 +189,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -210,7 +210,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -227,7 +227,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -241,7 +241,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -258,7 +258,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -273,11 +273,12 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : LAX_MODES) {
+            for (const auto mode : LaxModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
     }
 };
 
-UNIT_TEST_SUITE_REGISTRATION(TJsonPathLaxTest);
\ No newline at end of file
+UNIT_TEST_SUITE_REGISTRATION(TJsonPathLaxTest);
+
diff --git a/yql/essentials/minikql/jsonpath/ut/strict_ut.cpp b/yql/essentials/minikql/jsonpath/ut/strict_ut.cpp
index c8414581e4a..54a9f6c4fd2 100644
--- a/yql/essentials/minikql/jsonpath/ut/strict_ut.cpp
+++ b/yql/essentials/minikql/jsonpath/ut/strict_ut.cpp
@@ -61,7 +61,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : STRICT_MODES) {
+            for (const auto mode : StrictModes_) {
                 RunRuntimeErrorTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Error);
             }
         }
@@ -80,7 +80,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : STRICT_MODES) {
+            for (const auto mode : StrictModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -93,7 +93,7 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : STRICT_MODES) {
+            for (const auto mode : StrictModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
@@ -108,11 +108,12 @@ public:
         };
 
         for (const auto& testCase : testCases) {
-            for (const auto mode : STRICT_MODES) {
+            for (const auto mode : StrictModes_) {
                 RunTestCase(testCase.Json, mode + testCase.JsonPath, testCase.Result);
             }
         }
     }
 };
 
-UNIT_TEST_SUITE_REGISTRATION(TJsonPathStrictTest);
\ No newline at end of file
+UNIT_TEST_SUITE_REGISTRATION(TJsonPathStrictTest);
+
diff --git a/yql/essentials/minikql/jsonpath/ut/test_base.cpp b/yql/essentials/minikql/jsonpath/ut/test_base.cpp
index c9b4f5669d1..1882f137190 100644
--- a/yql/essentials/minikql/jsonpath/ut/test_base.cpp
+++ b/yql/essentials/minikql/jsonpath/ut/test_base.cpp
@@ -5,12 +5,12 @@
 using namespace NKikimr::NBinaryJson;
 
 TJsonPathTestBase::TJsonPathTestBase()
-    : FunctionRegistry(CreateFunctionRegistry(CreateBuiltinRegistry()))
-    , Alloc(__LOCATION__)
-    , Env(Alloc)
-    , MemInfo("Memory")
-    , HolderFactory(Alloc.Ref(), MemInfo, FunctionRegistry.Get())
-    , ValueBuilder(HolderFactory)
+    : FunctionRegistry_(CreateFunctionRegistry(CreateBuiltinRegistry()))
+    , Alloc_(__LOCATION__)
+    , Env_(Alloc_)
+    , MemInfo_("Memory")
+    , HolderFactory_(Alloc_.Ref(), MemInfo_, FunctionRegistry_.Get())
+    , ValueBuilder_(HolderFactory_)
 {
 }
 
@@ -19,7 +19,7 @@ TIssueCode TJsonPathTestBase::C(TIssuesIds::EIssueCode code) {
 }
 
 TUnboxedValue TJsonPathTestBase::ParseJson(TStringBuf raw) {
-    return TryParseJsonDom(raw, &ValueBuilder);
+    return TryParseJsonDom(raw, &ValueBuilder_);
 }
 
 void TJsonPathTestBase::RunTestCase(const TString& rawJson, const TString& rawJsonPath, const TVector<TString>& expectedResult) {
@@ -31,17 +31,17 @@ void TJsonPathTestBase::RunTestCase(const TString& rawJson, const TString& rawJs
         auto binaryJsonRoot = TValue(reader->GetRootCursor());
 
         TIssues issues;
-        const TJsonPathPtr jsonPath = ParseJsonPath(rawJsonPath, issues, MAX_PARSE_ERRORS);
+        const TJsonPathPtr jsonPath = ParseJsonPath(rawJsonPath, issues, MaxParseErrors_);
         UNIT_ASSERT_C(issues.Empty(), "Parse errors found");
 
         for (const auto& json : {unboxedValueJson, binaryJsonRoot}) {
-            const auto result = ExecuteJsonPath(jsonPath, json, TVariablesMap{}, &ValueBuilder);
+            const auto result = ExecuteJsonPath(jsonPath, json, TVariablesMap{}, &ValueBuilder_);
             UNIT_ASSERT_C(!result.IsError(), "Runtime errors found");
 
             const auto& nodes = result.GetNodes();
             UNIT_ASSERT_VALUES_EQUAL(nodes.size(), expectedResult.size());
             for (size_t i = 0; i < nodes.size(); i++) {
-                const auto converted = nodes[i].ConvertToUnboxedValue(&ValueBuilder);
+                const auto converted = nodes[i].ConvertToUnboxedValue(&ValueBuilder_);
                 UNIT_ASSERT_VALUES_EQUAL(SerializeJsonDom(converted), expectedResult[i]);
             }
         }
@@ -82,11 +82,11 @@ void TJsonPathTestBase::RunRuntimeErrorTestCase(const TString& rawJson, const TS
         auto binaryJsonRoot = TValue(reader->GetRootCursor());
 
         TIssues issues;
-        const TJsonPathPtr jsonPath = ParseJsonPath(rawJsonPath, issues, MAX_PARSE_ERRORS);
+        const TJsonPathPtr jsonPath = ParseJsonPath(rawJsonPath, issues, MaxParseErrors_);
         UNIT_ASSERT_C(issues.Empty(), "Parse errors found");
 
         for (const auto& json : {unboxedValueJson, binaryJsonRoot}) {
-            const auto result = ExecuteJsonPath(jsonPath, json, TVariablesMap{}, &ValueBuilder);
+            const auto result = ExecuteJsonPath(jsonPath, json, TVariablesMap{}, &ValueBuilder_);
             UNIT_ASSERT_C(result.IsError(), "Expected runtime error");
             UNIT_ASSERT_VALUES_EQUAL(result.GetError().GetCode(), error);
         }
@@ -126,7 +126,7 @@ void TJsonPathTestBase::RunVariablesTestCase(const TString& rawJson, const THash
         }
 
         TIssues issues;
-        const TJsonPathPtr jsonPath = ParseJsonPath(rawJsonPath, issues, MAX_PARSE_ERRORS);
+        const TJsonPathPtr jsonPath = ParseJsonPath(rawJsonPath, issues, MaxParseErrors_);
         UNIT_ASSERT_C(issues.Empty(), "Parse errors found");
 
         TVector<std::pair<TValue, TVariablesMap>> testCases = {
@@ -134,13 +134,13 @@ void TJsonPathTestBase::RunVariablesTestCase(const TString& rawJson, const THash
             {binaryJsonRoot, binaryJsonVariables},
         };
         for (const auto& testCase : testCases) {
-            const auto result = ExecuteJsonPath(jsonPath, testCase.first, testCase.second, &ValueBuilder);
+            const auto result = ExecuteJsonPath(jsonPath, testCase.first, testCase.second, &ValueBuilder_);
             UNIT_ASSERT_C(!result.IsError(), "Runtime errors found");
 
             const auto& nodes = result.GetNodes();
             UNIT_ASSERT_VALUES_EQUAL(nodes.size(), expectedResult.size());
             for (size_t i = 0; i < nodes.size(); i++) {
-                const auto converted = nodes[i].ConvertToUnboxedValue(&ValueBuilder);
+                const auto converted = nodes[i].ConvertToUnboxedValue(&ValueBuilder_);
                 UNIT_ASSERT_VALUES_EQUAL(SerializeJsonDom(converted), expectedResult[i]);
             }
         }
diff --git a/yql/essentials/minikql/jsonpath/ut/test_base.h b/yql/essentials/minikql/jsonpath/ut/test_base.h
index dbc4686ed8b..98e12c3cdce 100644
--- a/yql/essentials/minikql/jsonpath/ut/test_base.h
+++ b/yql/essentials/minikql/jsonpath/ut/test_base.h
@@ -29,18 +29,18 @@ public:
     TJsonPathTestBase();
 
 protected:
-    const TVector<TStringBuf> LAX_MODES = {"", "lax "};
-    const TVector<TStringBuf> STRICT_MODES = {"strict "};
-    const TVector<TStringBuf> ALL_MODES = {"", "lax ", "strict "};
-
-    TIntrusivePtr<IFunctionRegistry> FunctionRegistry;
-    TScopedAlloc Alloc;
-    TTypeEnvironment Env;
-    TMemoryUsageInfo MemInfo;
-    THolderFactory HolderFactory;
-    TDefaultValueBuilder ValueBuilder;
-
-    const int MAX_PARSE_ERRORS = 100;
+    const TVector<TStringBuf> LaxModes_ = {"", "lax "};
+    const TVector<TStringBuf> StrictModes_ = {"strict "};
+    const TVector<TStringBuf> AllModes_ = {"", "lax ", "strict "};
+
+    TIntrusivePtr<IFunctionRegistry> FunctionRegistry_;
+    TScopedAlloc Alloc_;
+    TTypeEnvironment Env_;
+    TMemoryUsageInfo MemInfo_;
+    THolderFactory HolderFactory_;
+    TDefaultValueBuilder ValueBuilder_;
+
+    const int MaxParseErrors_ = 100;
 
     TIssueCode C(TIssuesIds::EIssueCode code);
 
diff --git a/yql/essentials/minikql/jsonpath/value.cpp b/yql/essentials/minikql/jsonpath/value.cpp
index 356543baf8b..bb06dea990f 100644
--- a/yql/essentials/minikql/jsonpath/value.cpp
+++ b/yql/essentials/minikql/jsonpath/value.cpp
@@ -10,40 +10,40 @@ using namespace NKikimr;
 using namespace NKikimr::NBinaryJson;
 
 TArrayIterator::TArrayIterator()
-    : Iterator(TEmptyMarker())
+    : Iterator_(TEmptyMarker())
 {
 }
 
 TArrayIterator::TArrayIterator(const TUnboxedValue& iterator)
-    : Iterator(iterator)
+    : Iterator_(iterator)
 {
 }
 
 TArrayIterator::TArrayIterator(TUnboxedValue&& iterator)
-    : Iterator(std::move(iterator))
+    : Iterator_(std::move(iterator))
 {
 }
 
 TArrayIterator::TArrayIterator(const NBinaryJson::TArrayIterator& iterator)
-    : Iterator(iterator)
+    : Iterator_(iterator)
 {
 }
 
 TArrayIterator::TArrayIterator(NBinaryJson::TArrayIterator&& iterator)
-    : Iterator(std::move(iterator))
+    : Iterator_(std::move(iterator))
 {
 }
 
 bool TArrayIterator::Next(TValue& value) {
-    if (std::holds_alternative<TEmptyMarker>(Iterator)) {
+    if (std::holds_alternative<TEmptyMarker>(Iterator_)) {
         return false;
-    } else if (auto* iterator = std::get_if<NBinaryJson::TArrayIterator>(&Iterator)) {
+    } else if (auto* iterator = std::get_if<NBinaryJson::TArrayIterator>(&Iterator_)) {
         if (!iterator->HasNext()) {
             return false;
         }
         value = TValue(iterator->Next());
         return true;
-    } else if (auto* iterator = std::get_if<TUnboxedValue>(&Iterator)) {
+    } else if (auto* iterator = std::get_if<TUnboxedValue>(&Iterator_)) {
         TUnboxedValue result;
         const bool success = iterator->Next(result);
         if (success) {
@@ -56,34 +56,34 @@ bool TArrayIterator::Next(TValue& value) {
 }
 
 TObjectIterator::TObjectIterator()
-    : Iterator(TEmptyMarker())
+    : Iterator_(TEmptyMarker())
 {
 }
 
 TObjectIterator::TObjectIterator(const TUnboxedValue& iterator)
-    : Iterator(iterator)
+    : Iterator_(iterator)
 {
 }
 
 TObjectIterator::TObjectIterator(TUnboxedValue&& iterator)
-    : Iterator(std::move(iterator))
+    : Iterator_(std::move(iterator))
 {
 }
 
 TObjectIterator::TObjectIterator(const NBinaryJson::TObjectIterator& iterator)
-    : Iterator(iterator)
+    : Iterator_(iterator)
 {
 }
 
 TObjectIterator::TObjectIterator(NBinaryJson::TObjectIterator&& iterator)
-    : Iterator(std::move(iterator))
+    : Iterator_(std::move(iterator))
 {
 }
 
 bool TObjectIterator::Next(TValue& key, TValue& value) {
-    if (std::holds_alternative<TEmptyMarker>(Iterator)) {
+    if (std::holds_alternative<TEmptyMarker>(Iterator_)) {
         return false;
-    } else if (auto* iterator = std::get_if<NBinaryJson::TObjectIterator>(&Iterator)) {
+    } else if (auto* iterator = std::get_if<NBinaryJson::TObjectIterator>(&Iterator_)) {
         if (!iterator->HasNext()) {
             return false;
         }
@@ -91,7 +91,7 @@ bool TObjectIterator::Next(TValue& key, TValue& value) {
         key = TValue(itKey);
         value = TValue(itValue);
         return true;
-    } else if (auto* iterator = std::get_if<TUnboxedValue>(&Iterator)) {
+    } else if (auto* iterator = std::get_if<TUnboxedValue>(&Iterator_)) {
         TUnboxedValue itKey;
         TUnboxedValue itValue;
         const bool success = iterator->NextPair(itKey, itValue);
@@ -106,46 +106,46 @@ bool TObjectIterator::Next(TValue& key, TValue& value) {
 }
 
 TValue::TValue()
-    : Value(MakeEntity())
+    : Value_(MakeEntity())
 {
 }
 
 TValue::TValue(const TUnboxedValue& value)
-    : Value(value)
+    : Value_(value)
 {
 }
 
 TValue::TValue(TUnboxedValue&& value)
-    : Value(std::move(value))
+    : Value_(std::move(value))
 {
 }
 
 TValue::TValue(const TEntryCursor& value)
-    : Value(value)
+    : Value_(value)
 {
     UnpackInnerValue();
 }
 
 TValue::TValue(TEntryCursor&& value)
-    : Value(std::move(value))
+    : Value_(std::move(value))
 {
     UnpackInnerValue();
 }
 
 TValue::TValue(const TContainerCursor& value)
-    : Value(value)
+    : Value_(value)
 {
     UnpackInnerValue();
 }
 
 TValue::TValue(TContainerCursor&& value)
-    : Value(std::move(value))
+    : Value_(std::move(value))
 {
     UnpackInnerValue();
 }
 
 EValueType TValue::GetType() const {
-    if (const auto* value = std::get_if<TEntryCursor>(&Value)) {
+    if (const auto* value = std::get_if<TEntryCursor>(&Value_)) {
         switch (value->GetType()) {
             case EEntryType::BoolFalse:
             case EEntryType::BoolTrue:
@@ -159,7 +159,7 @@ EValueType TValue::GetType() const {
             case EEntryType::Container:
                 Y_ABORT("Logical error: TEntryCursor with Container type must be converted to TContainerCursor");
         }
-    } else if (const auto* value = std::get_if<TContainerCursor>(&Value)) {
+    } else if (const auto* value = std::get_if<TContainerCursor>(&Value_)) {
         switch (value->GetType()) {
             case EContainerType::Array:
                 return EValueType::Array;
@@ -168,7 +168,7 @@ EValueType TValue::GetType() const {
             case EContainerType::TopLevelScalar:
                 Y_ABORT("Logical error: TContainerCursor with TopLevelScalar type must be converted to TEntryCursor");
         }
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         switch (GetNodeType(*value)) {
             case ENodeType::Bool:
                 return EValueType::Bool;
@@ -222,9 +222,9 @@ bool TValue::IsArray() const {
 double TValue::GetNumber() const {
     Y_DEBUG_ABORT_UNLESS(IsNumber());
 
-    if (const auto* value = std::get_if<TEntryCursor>(&Value)) {
+    if (const auto* value = std::get_if<TEntryCursor>(&Value_)) {
         return value->GetNumber();
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         if (IsNodeType(*value, ENodeType::Double)) {
             return value->Get<double>();
         } else if (IsNodeType(*value, ENodeType::Int64)) {
@@ -240,9 +240,9 @@ double TValue::GetNumber() const {
 bool TValue::GetBool() const {
     Y_DEBUG_ABORT_UNLESS(IsBool());
 
-    if (const auto* value = std::get_if<TEntryCursor>(&Value)) {
+    if (const auto* value = std::get_if<TEntryCursor>(&Value_)) {
         return value->GetType() == EEntryType::BoolTrue;
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         return value->Get<bool>();
     } else {
         Y_ABORT("Unexpected variant case in GetBool");
@@ -252,9 +252,9 @@ bool TValue::GetBool() const {
 const TStringBuf TValue::GetString() const {
     Y_DEBUG_ABORT_UNLESS(IsString());
 
-    if (const auto* value = std::get_if<TEntryCursor>(&Value)) {
+    if (const auto* value = std::get_if<TEntryCursor>(&Value_)) {
         return value->GetString();
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         return value->AsStringRef();
     } else {
         Y_ABORT("Unexpected variant case in GetString");
@@ -264,9 +264,9 @@ const TStringBuf TValue::GetString() const {
 ui32 TValue::GetSize() const {
     Y_DEBUG_ABORT_UNLESS(IsArray() || IsObject());
 
-    if (const auto* value = std::get_if<TContainerCursor>(&Value)) {
+    if (const auto* value = std::get_if<TContainerCursor>(&Value_)) {
         return value->GetSize();
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         if (value->IsEmbedded()) {
             return 0;
         }
@@ -284,9 +284,9 @@ ui32 TValue::GetSize() const {
 TValue TValue::GetElement(ui32 index) const {
     Y_DEBUG_ABORT_UNLESS(IsArray());
 
-    if (const auto* value = std::get_if<TContainerCursor>(&Value)) {
+    if (const auto* value = std::get_if<TContainerCursor>(&Value_)) {
         return TValue(value->GetElement(index));
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         return TValue(value->Lookup(TUnboxedValuePod(index)));
     } else {
         Y_ABORT("Unexpected variant case in GetElement");
@@ -296,9 +296,9 @@ TValue TValue::GetElement(ui32 index) const {
 TArrayIterator TValue::GetArrayIterator() const {
     Y_DEBUG_ABORT_UNLESS(IsArray());
 
-    if (const auto* value = std::get_if<TContainerCursor>(&Value)) {
+    if (const auto* value = std::get_if<TContainerCursor>(&Value_)) {
         return TArrayIterator(value->GetArrayIterator());
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         if (value->IsEmbedded()) {
             return TArrayIterator();
         }
@@ -311,13 +311,13 @@ TArrayIterator TValue::GetArrayIterator() const {
 TMaybe<TValue> TValue::Lookup(const TStringBuf key) const {
     Y_DEBUG_ABORT_UNLESS(IsObject());
 
-    if (const auto* value = std::get_if<TContainerCursor>(&Value)) {
+    if (const auto* value = std::get_if<TContainerCursor>(&Value_)) {
         const auto payload = value->Lookup(key);
         if (!payload.Defined()) {
             return Nothing();
         }
         return TValue(*payload);
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         if (value->IsEmbedded()) {
             return Nothing();
         }
@@ -339,9 +339,9 @@ TMaybe<TValue> TValue::Lookup(const TStringBuf key) const {
 TObjectIterator TValue::GetObjectIterator() const {
     Y_DEBUG_ABORT_UNLESS(IsObject());
 
-    if (const auto* value = std::get_if<TContainerCursor>(&Value)) {
+    if (const auto* value = std::get_if<TContainerCursor>(&Value_)) {
         return TObjectIterator(value->GetObjectIterator());
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         if (value->IsEmbedded()) {
             return TObjectIterator();
         }
@@ -352,11 +352,11 @@ TObjectIterator TValue::GetObjectIterator() const {
 }
 
 TUnboxedValue TValue::ConvertToUnboxedValue(const NUdf::IValueBuilder* valueBuilder) const {
-    if (const auto* value = std::get_if<TEntryCursor>(&Value)) {
+    if (const auto* value = std::get_if<TEntryCursor>(&Value_)) {
         return ReadElementToJsonDom(*value, valueBuilder);
-    } else if (const auto* value = std::get_if<TContainerCursor>(&Value)) {
+    } else if (const auto* value = std::get_if<TContainerCursor>(&Value_)) {
         return ReadContainerToJsonDom(*value, valueBuilder);
-    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value)) {
+    } else if (const auto* value = std::get_if<TUnboxedValue>(&Value_)) {
         return *value;
     } else {
         Y_ABORT("Unexpected variant case in ConvertToUnboxedValue");
@@ -365,16 +365,16 @@ TUnboxedValue TValue::ConvertToUnboxedValue(const NUdf::IValueBuilder* valueBuil
 
 void TValue::UnpackInnerValue() {
     // If TEntryCursor points to container, we need to extract TContainerCursor
-    if (const auto* value = std::get_if<TEntryCursor>(&Value)) {
+    if (const auto* value = std::get_if<TEntryCursor>(&Value_)) {
         if (value->GetType() == EEntryType::Container) {
-            Value = value->GetContainer();
+            Value_ = value->GetContainer();
         }
     }
 
     // If TContainerCursor points to top level scalar, we need to extract TEntryCursor
-    if (const auto* value = std::get_if<TContainerCursor>(&Value)) {
+    if (const auto* value = std::get_if<TContainerCursor>(&Value_)) {
         if (value->GetType() == EContainerType::TopLevelScalar) {
-            Value = value->GetElement(0);
+            Value_ = value->GetElement(0);
         }
     }
 }
diff --git a/yql/essentials/minikql/jsonpath/value.h b/yql/essentials/minikql/jsonpath/value.h
index ca663ad5c43..cc5b98e9912 100644
--- a/yql/essentials/minikql/jsonpath/value.h
+++ b/yql/essentials/minikql/jsonpath/value.h
@@ -36,7 +36,7 @@ public:
     bool Next(TValue& value);
 
 private:
-    std::variant<TEmptyMarker, NUdf::TUnboxedValue, NKikimr::NBinaryJson::TArrayIterator> Iterator;
+    std::variant<TEmptyMarker, NUdf::TUnboxedValue, NKikimr::NBinaryJson::TArrayIterator> Iterator_;
 };
 
 class TObjectIterator {
@@ -51,7 +51,7 @@ public:
     bool Next(TValue& key, TValue& value);
 
 private:
-    std::variant<TEmptyMarker, NUdf::TUnboxedValue, NKikimr::NBinaryJson::TObjectIterator> Iterator;
+    std::variant<TEmptyMarker, NUdf::TUnboxedValue, NKikimr::NBinaryJson::TObjectIterator> Iterator_;
 };
 
 class TValue {
@@ -95,7 +95,7 @@ public:
 private:
     void UnpackInnerValue();
 
-    std::variant<NUdf::TUnboxedValue, NKikimr::NBinaryJson::TEntryCursor, NKikimr::NBinaryJson::TContainerCursor> Value;
+    std::variant<NUdf::TUnboxedValue, NKikimr::NBinaryJson::TEntryCursor, NKikimr::NBinaryJson::TContainerCursor> Value_;
 };
 
 }