YQL-20086 types

commit_hash:8ae966ebbc56f0c7af1cc2fbb1c29bd1ad49ec40

8 files changed, 188 insertions, 188 deletions

diff --git a/yql/essentials/types/binary_json/read.cpp b/yql/essentials/types/binary_json/read.cpp
index d50f8b82d8c..2d4b40c04b8 100644
--- a/yql/essentials/types/binary_json/read.cpp
+++ b/yql/essentials/types/binary_json/read.cpp
@@ -15,115 +15,115 @@ using namespace NYql::NDom;
 using namespace NJson;
 
 TEntryCursor::TEntryCursor(const TBinaryJsonReaderPtr reader, TEntry entry)
-    : Reader(reader)
-    , Entry(entry)
+    : Reader_(reader)
+    , Entry_(entry)
 {
 }
 
 EEntryType TEntryCursor::GetType() const {
-    return Entry.Type;
+    return Entry_.Type;
 }
 
 TContainerCursor TEntryCursor::GetContainer() const {
-    Y_DEBUG_ABORT_UNLESS(Entry.Type == EEntryType::Container, "Expected container type");
-    return TContainerCursor(Reader, Entry.Value);
+    Y_DEBUG_ABORT_UNLESS(Entry_.Type == EEntryType::Container, "Expected container type");
+    return TContainerCursor(Reader_, Entry_.Value);
 }
 
 TStringBuf TEntryCursor::GetString() const {
-    Y_DEBUG_ABORT_UNLESS(Entry.Type == EEntryType::String, "Expected string type");
-    return Reader->ReadString(Entry.Value);
+    Y_DEBUG_ABORT_UNLESS(Entry_.Type == EEntryType::String, "Expected string type");
+    return Reader_->ReadString(Entry_.Value);
 }
 
 double TEntryCursor::GetNumber() const {
-    Y_DEBUG_ABORT_UNLESS(Entry.Type == EEntryType::Number, "Expected number type");
-    return Reader->ReadNumber(Entry.Value);
+    Y_DEBUG_ABORT_UNLESS(Entry_.Type == EEntryType::Number, "Expected number type");
+    return Reader_->ReadNumber(Entry_.Value);
 }
 
 TArrayIterator::TArrayIterator(const TBinaryJsonReaderPtr reader, ui32 startOffset, ui32 count)
-    : Reader(reader)
-    , Offset(startOffset)
+    : Reader_(reader)
+    , Offset_(startOffset)
 {
-    EndOffset = Offset + count * sizeof(TEntry);
+    EndOffset_ = Offset_ + count * sizeof(TEntry);
 }
 
 TEntryCursor TArrayIterator::Next() {
     Y_DEBUG_ABORT_UNLESS(HasNext());
-    TEntryCursor element(Reader, Reader->ReadEntry(Offset));
-    Offset += sizeof(TEntry);
+    TEntryCursor element(Reader_, Reader_->ReadEntry(Offset_));
+    Offset_ += sizeof(TEntry);
     return element;
 }
 
 bool TArrayIterator::HasNext() const {
-    return Offset < EndOffset;
+    return Offset_ < EndOffset_;
 }
 
 TObjectIterator::TObjectIterator(const TBinaryJsonReaderPtr reader, ui32 startOffset, ui32 count)
-    : Reader(reader)
+    : Reader_(reader)
 {
-    KeyOffset = startOffset;
-    ValueOffset = KeyOffset + count * sizeof(TKeyEntry);
-    ValueEndOffset = ValueOffset + count * sizeof(TEntry);
+    KeyOffset_ = startOffset;
+    ValueOffset_ = KeyOffset_ + count * sizeof(TKeyEntry);
+    ValueEndOffset_ = ValueOffset_ + count * sizeof(TEntry);
 }
 
 std::pair<TEntryCursor, TEntryCursor> TObjectIterator::Next() {
     Y_DEBUG_ABORT_UNLESS(HasNext());
     // Here we create fake Entry to return Entry cursor
-    const auto stringOffset = static_cast<ui32>(Reader->ReadKeyEntry(KeyOffset));
-    TEntryCursor key(Reader, TEntry(EEntryType::String, stringOffset));
-    TEntryCursor value(Reader, Reader->ReadEntry(ValueOffset));
-    KeyOffset += sizeof(TKeyEntry);
-    ValueOffset += sizeof(TEntry);
+    const auto stringOffset = static_cast<ui32>(Reader_->ReadKeyEntry(KeyOffset_));
+    TEntryCursor key(Reader_, TEntry(EEntryType::String, stringOffset));
+    TEntryCursor value(Reader_, Reader_->ReadEntry(ValueOffset_));
+    KeyOffset_ += sizeof(TKeyEntry);
+    ValueOffset_ += sizeof(TEntry);
     return std::make_pair(std::move(key), std::move(value));
 }
 
 bool TObjectIterator::HasNext() const {
-    return ValueOffset < ValueEndOffset;
+    return ValueOffset_ < ValueEndOffset_;
 }
 
 TContainerCursor::TContainerCursor(const TBinaryJsonReaderPtr reader, ui32 startOffset)
-    : Reader(reader)
-    , StartOffset(startOffset)
+    : Reader_(reader)
+    , StartOffset_(startOffset)
 {
-    Meta = Reader->ReadMeta(StartOffset);
-    StartOffset += sizeof(Meta);
+    Meta_ = Reader_->ReadMeta(StartOffset_);
+    StartOffset_ += sizeof(Meta_);
 }
 
 EContainerType TContainerCursor::GetType() const {
-    return Meta.Type;
+    return Meta_.Type;
 }
 
 ui32 TContainerCursor::GetSize() const {
-    return Meta.Size;
+    return Meta_.Size;
 }
 
 TEntryCursor TContainerCursor::GetElement(ui32 index) const {
-    Y_DEBUG_ABORT_UNLESS(Meta.Type == EContainerType::Array || Meta.Type == EContainerType::TopLevelScalar, "Expected array");
+    Y_DEBUG_ABORT_UNLESS(Meta_.Type == EContainerType::Array || Meta_.Type == EContainerType::TopLevelScalar, "Expected array");
     Y_DEBUG_ABORT_UNLESS(index < GetSize(), "Invalid index");
-    const ui32 offset = StartOffset + index * sizeof(TEntry);
-    return TEntryCursor(Reader, Reader->ReadEntry(offset));
+    const ui32 offset = StartOffset_ + index * sizeof(TEntry);
+    return TEntryCursor(Reader_, Reader_->ReadEntry(offset));
 }
 
 TArrayIterator TContainerCursor::GetArrayIterator() const {
-    Y_DEBUG_ABORT_UNLESS(Meta.Type == EContainerType::Array || Meta.Type == EContainerType::TopLevelScalar, "Expected array");
-    return TArrayIterator(Reader, StartOffset, Meta.Size);
+    Y_DEBUG_ABORT_UNLESS(Meta_.Type == EContainerType::Array || Meta_.Type == EContainerType::TopLevelScalar, "Expected array");
+    return TArrayIterator(Reader_, StartOffset_, Meta_.Size);
 }
 
 TMaybe<TEntryCursor> TContainerCursor::Lookup(const TStringBuf key) const {
-    if (Meta.Size == 0) {
+    if (Meta_.Size == 0) {
         return Nothing();
     }
 
     i32 left = 0;
-    i32 right = Meta.Size - 1;
+    i32 right = Meta_.Size - 1;
     while (left <= right) {
         const i32 middle = (left + right) / 2;
-        const ui32 keyEntryOffset = StartOffset + middle * sizeof(TKeyEntry);
-        const auto keyStringOffset = Reader->ReadKeyEntry(keyEntryOffset);
+        const ui32 keyEntryOffset = StartOffset_ + middle * sizeof(TKeyEntry);
+        const auto keyStringOffset = Reader_->ReadKeyEntry(keyEntryOffset);
 
-        const int compare = Reader->ReadString(keyStringOffset).compare(key);
+        const int compare = Reader_->ReadString(keyStringOffset).compare(key);
         if (compare == 0) {
-            const ui32 entryOffset = StartOffset + Meta.Size * sizeof(TKeyEntry) + middle * sizeof(TEntry);
-            return TEntryCursor(Reader, Reader->ReadEntry(entryOffset));
+            const ui32 entryOffset = StartOffset_ + Meta_.Size * sizeof(TKeyEntry) + middle * sizeof(TEntry);
+            return TEntryCursor(Reader_, Reader_->ReadEntry(entryOffset));
         } else if (compare < 0) {
             left = middle + 1;
         } else {
@@ -134,8 +134,8 @@ TMaybe<TEntryCursor> TContainerCursor::Lookup(const TStringBuf key) const {
 }
 
 TObjectIterator TContainerCursor::GetObjectIterator() const {
-    Y_DEBUG_ABORT_UNLESS(Meta.Type == EContainerType::Object, "Expected object");
-    return TObjectIterator(Reader, StartOffset, Meta.Size);
+    Y_DEBUG_ABORT_UNLESS(Meta_.Type == EContainerType::Object, "Expected object");
+    return TObjectIterator(Reader_, StartOffset_, Meta_.Size);
 }
 
 TBinaryJsonReader::TBinaryJsonReader(const TBinaryJson& buffer)
@@ -144,54 +144,54 @@ TBinaryJsonReader::TBinaryJsonReader(const TBinaryJson& buffer)
 }
 
 TBinaryJsonReader::TBinaryJsonReader(TStringBuf buffer)
-    : Buffer(buffer)
+    : Buffer_(buffer)
 {
     // Header is stored at the beginning of BinaryJson
-    Header = ReadPOD<THeader>(0);
+    Header_ = ReadPOD<THeader>(0);
 
     Y_ENSURE(
-        Header.Version == CURRENT_VERSION,
-        TStringBuilder() << "Version in BinaryJson `" << static_cast<ui64>(Header.Version) << "` "
+        Header_.Version == CURRENT_VERSION,
+        TStringBuilder() << "Version in BinaryJson `" << static_cast<ui64>(Header_.Version) << "` "
         << "does not match current version `" << static_cast<ui64>(CURRENT_VERSION) << "`"
     );
 
     Y_ENSURE(
-        Header.StringOffset < Buffer.size(),
+        Header_.StringOffset < Buffer_.size(),
         "StringOffset must be inside buffer"
     );
 
     // Tree starts right after Header
-    TreeStart = sizeof(Header);
+    TreeStart_ = sizeof(Header_);
 
     // SEntry sequence starts right after count of strings
-    StringCount = ReadPOD<ui32>(Header.StringOffset);
-    StringSEntryStart = Header.StringOffset + sizeof(ui32);
+    StringCount_ = ReadPOD<ui32>(Header_.StringOffset);
+    StringSEntryStart_ = Header_.StringOffset + sizeof(ui32);
 }
 
 TContainerCursor TBinaryJsonReader::GetRootCursor() {
-    return TContainerCursor(TIntrusivePtr(this), TreeStart);
+    return TContainerCursor(TIntrusivePtr(this), TreeStart_);
 }
 
 TMeta TBinaryJsonReader::ReadMeta(ui32 offset) const {
-    Y_DEBUG_ABORT_UNLESS(TreeStart <= offset && offset < Header.StringOffset, "Offset is not inside Tree section");
+    Y_DEBUG_ABORT_UNLESS(TreeStart_ <= offset && offset < Header_.StringOffset, "Offset is not inside Tree section");
     return ReadPOD<TMeta>(offset);
 }
 
 TEntry TBinaryJsonReader::ReadEntry(ui32 offset) const {
-    Y_DEBUG_ABORT_UNLESS(TreeStart <= offset && offset < Header.StringOffset, "Offset is not inside Tree section");
+    Y_DEBUG_ABORT_UNLESS(TreeStart_ <= offset && offset < Header_.StringOffset, "Offset is not inside Tree section");
     return ReadPOD<TEntry>(offset);
 }
 
 TKeyEntry TBinaryJsonReader::ReadKeyEntry(ui32 offset) const {
-    Y_DEBUG_ABORT_UNLESS(TreeStart <= offset && offset < Header.StringOffset, "Offset is not inside Tree section");
+    Y_DEBUG_ABORT_UNLESS(TreeStart_ <= offset && offset < Header_.StringOffset, "Offset is not inside Tree section");
     return ReadPOD<TKeyEntry>(offset);
 }
 
 const TStringBuf TBinaryJsonReader::ReadString(ui32 offset) const {
-    Y_DEBUG_ABORT_UNLESS(StringSEntryStart <= offset && offset < StringSEntryStart + StringCount * sizeof(TSEntry), "Offset is not inside string index");
+    Y_DEBUG_ABORT_UNLESS(StringSEntryStart_ <= offset && offset < StringSEntryStart_ + StringCount_ * sizeof(TSEntry), "Offset is not inside string index");
     ui32 startOffset = 0;
-    if (offset == StringSEntryStart) {
-        startOffset = StringSEntryStart + StringCount * sizeof(TSEntry);
+    if (offset == StringSEntryStart_) {
+        startOffset = StringSEntryStart_ + StringCount_ * sizeof(TSEntry);
     } else {
         ui32 previousOffset = offset - sizeof(TSEntry);
         const auto previousEntry = ReadPOD<TSEntry>(previousOffset);
@@ -199,14 +199,14 @@ const TStringBuf TBinaryJsonReader::ReadString(ui32 offset) const {
     }
     const auto entry = ReadPOD<TSEntry>(offset);
     const ui32 endOffset = entry.Value - 1;
-    Y_ENSURE(startOffset <= endOffset && startOffset <= Buffer.size() && endOffset <= Buffer.size(), "Incorrect string bounds");
-    return TStringBuf(Buffer.data() + startOffset, endOffset - startOffset);
+    Y_ENSURE(startOffset <= endOffset && startOffset <= Buffer_.size() && endOffset <= Buffer_.size(), "Incorrect string bounds");
+    return TStringBuf(Buffer_.data() + startOffset, endOffset - startOffset);
 }
 
 double TBinaryJsonReader::ReadNumber(ui32 offset) const {
     double result;
-    Y_ENSURE(offset <= Buffer.size() && offset + sizeof(result) <= Buffer.size(), "Incorrect number bounds");
-    MemCopy(reinterpret_cast<char*>(&result), Buffer.data() + offset, sizeof(result));
+    Y_ENSURE(offset <= Buffer_.size() && offset + sizeof(result) <= Buffer_.size(), "Incorrect number bounds");
+    MemCopy(reinterpret_cast<char*>(&result), Buffer_.data() + offset, sizeof(result));
     return result;
 }
 
@@ -388,13 +388,13 @@ struct TPODReader {
 
 struct TBinaryJsonValidator {
     TBinaryJsonValidator(TStringBuf buffer)
-        : Buffer(buffer)
+        : Buffer_(buffer)
     {
     }
 
     TMaybe<TStringBuf> ValidateWithError() && {
         // Validate Header
-        TPODReader reader(Buffer);
+        TPODReader reader(Buffer_);
         const auto header = reader.Read<THeader>();
         if (!header.Defined()) {
             return "Missing header"sv;
@@ -405,22 +405,22 @@ struct TBinaryJsonValidator {
         if (header->Version > EVersion::MaxVersion) {
             return "Invalid version"sv;
         }
-        if (header->StringOffset >= Buffer.size()) {
+        if (header->StringOffset >= Buffer_.size()) {
             return "String index offset points outside of buffer"sv;
         }
-        StringIndexStart = header->StringOffset;
+        StringIndexStart_ = header->StringOffset;
 
         // Validate String index
-        TPODReader stringReader(Buffer, /* start */ StringIndexStart, /* end */ Buffer.size());
+        TPODReader stringReader(Buffer_, /* start */ StringIndexStart_, /* end */ Buffer_.size());
         const auto stringCount = stringReader.Read<ui32>();
         if (!stringCount.Defined()) {
             return "Missing string index size"sv;
         }
-        StringEntryStart = StringIndexStart + sizeof(ui32);
-        StringDataStart = StringEntryStart + (*stringCount) * sizeof(TSEntry);
+        StringEntryStart_ = StringIndexStart_ + sizeof(ui32);
+        StringDataStart_ = StringEntryStart_ + (*stringCount) * sizeof(TSEntry);
 
         ui32 totalLength = 0;
-        ui32 lastStringOffset = StringDataStart;
+        ui32 lastStringOffset = StringDataStart_;
         for (ui32 i = 0; i < *stringCount; i++) {
             const auto entry = stringReader.Read<TSEntry>();
             if (!entry.Defined()) {
@@ -436,17 +436,17 @@ struct TBinaryJsonValidator {
             lastStringOffset = entry->Value;
         }
 
-        NumberIndexStart = StringDataStart + totalLength;
-        if (NumberIndexStart > Buffer.size()) {
+        NumberIndexStart_ = StringDataStart_ + totalLength;
+        if (NumberIndexStart_ > Buffer_.size()) {
             return "Total length of strings in String index exceeds Buffer size"sv;
         }
 
         // Validate Number index
-        if ((Buffer.size() - NumberIndexStart) % sizeof(double) != 0) {
+        if ((Buffer_.size() - NumberIndexStart_) % sizeof(double) != 0) {
             return "Number index cannot be split into doubles"sv;
         }
 
-        TPODReader numberReader(Buffer, /* start */ NumberIndexStart, /* end */ Buffer.size());
+        TPODReader numberReader(Buffer_, /* start */ NumberIndexStart_, /* end */ Buffer_.size());
         TMaybe<double> current;
         while (current = numberReader.Read<double>()) {
             if (std::isnan(*current)) {
@@ -463,10 +463,10 @@ struct TBinaryJsonValidator {
 
 private:
     TMaybe<TStringBuf> IsValidStringOffset(ui32 offset) {
-        if (offset < StringEntryStart || offset >= StringDataStart) {
+        if (offset < StringEntryStart_ || offset >= StringDataStart_) {
             return "String offset is out of String index entries section"sv;
         }
-        if ((offset - StringEntryStart) % sizeof(TSEntry) != 0) {
+        if ((offset - StringEntryStart_) % sizeof(TSEntry) != 0) {
             return "String offset does not point to the start of entry"sv;
         }
         return Nothing();
@@ -488,10 +488,10 @@ private:
                 return IsValidStringOffset(entry->Value);
             case EEntryType::Number: {
                 const auto numberOffset = entry->Value;
-                if (numberOffset < NumberIndexStart || numberOffset >= Buffer.size()) {
+                if (numberOffset < NumberIndexStart_ || numberOffset >= Buffer_.size()) {
                     return "Number offset cannot point outside of Number index"sv;
                 }
-                if ((numberOffset - NumberIndexStart) % sizeof(double) != 0) {
+                if ((numberOffset - NumberIndexStart_) % sizeof(double) != 0) {
                     return "Number offset does not point to the start of number"sv;
                 }
                 break;
@@ -504,10 +504,10 @@ private:
                 if (metaOffset < reader.Pos) {
                     return "Offset to container cannot point before element"sv;
                 }
-                if (metaOffset >= StringIndexStart) {
+                if (metaOffset >= StringIndexStart_) {
                     return "Offset to container cannot point outside of Tree section"sv;
                 }
-                TPODReader containerReader(reader.Buffer, metaOffset, StringIndexStart);
+                TPODReader containerReader(reader.Buffer, metaOffset, StringIndexStart_);
                 return IsValidContainer(containerReader, depth + 1);
             }
             default:
@@ -568,11 +568,11 @@ private:
         return Nothing();
     }
 
-    ui32 StringIndexStart = 0;
-    ui32 StringEntryStart = 0;
-    ui32 StringDataStart = 0;
-    ui32 NumberIndexStart = 0;
-    TStringBuf Buffer;
+    ui32 StringIndexStart_ = 0;
+    ui32 StringEntryStart_ = 0;
+    ui32 StringDataStart_ = 0;
+    ui32 NumberIndexStart_ = 0;
+    TStringBuf Buffer_;
 };
 
 }
diff --git a/yql/essentials/types/binary_json/read.h b/yql/essentials/types/binary_json/read.h
index a0fdf931bf1..5bdeac34fb7 100644
--- a/yql/essentials/types/binary_json/read.h
+++ b/yql/essentials/types/binary_json/read.h
@@ -54,16 +54,16 @@ private:
     template <typename T>
     T ReadPOD(ui32 offset) const {
         static_assert(std::is_pod_v<T>, "Type must be POD");
-        Y_ENSURE(offset + sizeof(T) <= Buffer.size(),
-            TStringBuilder() << "Not enough space in buffer to read value (" << offset << " + " << sizeof(T) << " > " << Buffer.size() << ")");
-        return ReadUnaligned<T>(Buffer.data() + offset);
+        Y_ENSURE(offset + sizeof(T) <= Buffer_.size(),
+            TStringBuilder() << "Not enough space in buffer to read value (" << offset << " + " << sizeof(T) << " > " << Buffer_.size() << ")");
+        return ReadUnaligned<T>(Buffer_.data() + offset);
     }
 
-    TStringBuf Buffer;
-    THeader Header;
-    ui32 TreeStart;
-    ui32 StringSEntryStart;
-    ui32 StringCount;
+    TStringBuf Buffer_;
+    THeader Header_;
+    ui32 TreeStart_;
+    ui32 StringSEntryStart_;
+    ui32 StringCount_;
 };
 
 using TBinaryJsonReaderPtr = TIntrusivePtr<TBinaryJsonReader>;
@@ -84,8 +84,8 @@ public:
     double GetNumber() const;
 
 private:
-    TBinaryJsonReaderPtr Reader;
-    TEntry Entry;
+    TBinaryJsonReaderPtr Reader_;
+    TEntry Entry_;
 };
 
 /**
@@ -100,9 +100,9 @@ public:
     bool HasNext() const;
 
 private:
-    TBinaryJsonReaderPtr Reader;
-    ui32 Offset;
-    ui32 EndOffset;
+    TBinaryJsonReaderPtr Reader_;
+    ui32 Offset_;
+    ui32 EndOffset_;
 };
 
 /**
@@ -117,10 +117,10 @@ public:
     bool HasNext() const;
 
 private:
-    TBinaryJsonReaderPtr Reader;
-    ui32 KeyOffset;
-    ui32 ValueOffset;
-    ui32 ValueEndOffset;
+    TBinaryJsonReaderPtr Reader_;
+    ui32 KeyOffset_;
+    ui32 ValueOffset_;
+    ui32 ValueEndOffset_;
 };
 
 /**
@@ -158,9 +158,9 @@ public:
     TObjectIterator GetObjectIterator() const;
 
 private:
-    TBinaryJsonReaderPtr Reader;
-    ui32 StartOffset;
-    TMeta Meta;
+    TBinaryJsonReaderPtr Reader_;
+    ui32 StartOffset_;
+    TMeta Meta_;
 };
 
 NUdf::TUnboxedValue ReadContainerToJsonDom(const TContainerCursor& cursor, const NUdf::IValueBuilder* valueBuilder);
diff --git a/yql/essentials/types/binary_json/ut/identity_ut.cpp b/yql/essentials/types/binary_json/ut/identity_ut.cpp
index 50c4299d5cc..4179293287b 100644
--- a/yql/essentials/types/binary_json/ut/identity_ut.cpp
+++ b/yql/essentials/types/binary_json/ut/identity_ut.cpp
@@ -41,7 +41,7 @@ public:
     void TestReadToJsonDom() {
         for (const TStringBuf json : TestCases) {
             const auto binaryJson = std::get<TBinaryJson>(NBinaryJson::SerializeToBinaryJson(json));
-            const auto value = NBinaryJson::ReadToJsonDom(binaryJson, &ValueBuilder);
+            const auto value = NBinaryJson::ReadToJsonDom(binaryJson, &ValueBuilder_);
             const auto jsonAfterBinaryJson = NDom::SerializeJsonDom(value);
 
             UNIT_ASSERT_VALUES_EQUAL(json, jsonAfterBinaryJson);
@@ -59,7 +59,7 @@ public:
 
     void TestSerializeDomToBinaryJson() {
         for (const TStringBuf json : TestCases) {
-            const auto dom = NDom::TryParseJsonDom(json, &ValueBuilder);
+            const auto dom = NDom::TryParseJsonDom(json, &ValueBuilder_);
             const auto binaryJson = NBinaryJson::SerializeToBinaryJson(dom);
             const auto jsonAfterBinaryJson = NBinaryJson::SerializeToJson(binaryJson);
 
diff --git a/yql/essentials/types/binary_json/ut/test_base.cpp b/yql/essentials/types/binary_json/ut/test_base.cpp
index 2b9f523010d..6688a31658c 100644
--- a/yql/essentials/types/binary_json/ut/test_base.cpp
+++ b/yql/essentials/types/binary_json/ut/test_base.cpp
@@ -5,12 +5,12 @@
 using namespace NYql::NDom;
 
 TBinaryJsonTestBase::TBinaryJsonTestBase()
-    : 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,11 +19,11 @@ TString TBinaryJsonTestBase::EntryToJsonText(const TEntryCursor& cursor) {
         return ContainerToJsonText(cursor.GetContainer());
     }
 
-    TUnboxedValue result = ReadElementToJsonDom(cursor, &ValueBuilder);
+    TUnboxedValue result = ReadElementToJsonDom(cursor, &ValueBuilder_);
     return SerializeJsonDom(result);
 }
 
 TString TBinaryJsonTestBase::ContainerToJsonText(const TContainerCursor& cursor) {
-    TUnboxedValue result = ReadContainerToJsonDom(cursor, &ValueBuilder);
+    TUnboxedValue result = ReadContainerToJsonDom(cursor, &ValueBuilder_);
     return SerializeJsonDom(result);
 }
diff --git a/yql/essentials/types/binary_json/ut/test_base.h b/yql/essentials/types/binary_json/ut/test_base.h
index 5877d3572cb..d97f64b1f57 100644
--- a/yql/essentials/types/binary_json/ut/test_base.h
+++ b/yql/essentials/types/binary_json/ut/test_base.h
@@ -36,10 +36,10 @@ public:
     TString ContainerToJsonText(const TContainerCursor& cursor);
 
 protected:
-    TIntrusivePtr<IFunctionRegistry> FunctionRegistry;
-    TScopedAlloc Alloc;
-    TTypeEnvironment Env;
-    TMemoryUsageInfo MemInfo;
-    THolderFactory HolderFactory;
-    TDefaultValueBuilder ValueBuilder;
+    TIntrusivePtr<IFunctionRegistry> FunctionRegistry_;
+    TScopedAlloc Alloc_;
+    TTypeEnvironment Env_;
+    TMemoryUsageInfo MemInfo_;
+    THolderFactory HolderFactory_;
+    TDefaultValueBuilder ValueBuilder_;
 };
diff --git a/yql/essentials/types/binary_json/write.cpp b/yql/essentials/types/binary_json/write.cpp
index 39cd05949db..225e54c23e2 100644
--- a/yql/essentials/types/binary_json/write.cpp
+++ b/yql/essentials/types/binary_json/write.cpp
@@ -185,7 +185,7 @@ struct TPODWriter {
 class TBinaryJsonSerializer {
 public:
     TBinaryJsonSerializer(TJsonIndex&& json)
-        : Json(std::move(json))
+        : Json_(std::move(json))
     {
     }
 
@@ -208,20 +208,20 @@ public:
         // Header consists only of THeader
         const ui32 headerSize = sizeof(THeader);
         // Each container consists of 1 TMeta and multiple TEntry. Objects also have multiple TKeyEntry
-        const ui32 keysSize = Json.TotalKeysCount * sizeof(TKeyEntry);
-        const ui32 entriesSize = (Json.TotalEntriesCount - Json.TotalKeysCount) * sizeof(TEntry);
-        const ui32 treeSize = Json.Containers.size() * sizeof(TMeta) + entriesSize + keysSize;
+        const ui32 keysSize = Json_.TotalKeysCount * sizeof(TKeyEntry);
+        const ui32 entriesSize = (Json_.TotalEntriesCount - Json_.TotalKeysCount) * sizeof(TEntry);
+        const ui32 treeSize = Json_.Containers.size() * sizeof(TMeta) + entriesSize + keysSize;
 
         // String index consists of Count and TSEntry/string body pair for each string
-        const ui32 stringIndexSize = sizeof(ui32) + (Json.Strings.size() + Json.Keys.size()) * sizeof(TSEntry) + (Json.TotalStringLength + Json.TotalKeyLength);
+        const ui32 stringIndexSize = sizeof(ui32) + (Json_.Strings.size() + Json_.Keys.size()) * sizeof(TSEntry) + (Json_.TotalStringLength + Json_.TotalKeyLength);
         // Number index consists of multiple doubles
-        const ui32 numberIndexSize = Json.Numbers.size() * sizeof(double);
+        const ui32 numberIndexSize = Json_.Numbers.size() * sizeof(double);
 
         // Allocate space for all sections
         const ui32 totalSize = headerSize + treeSize + stringIndexSize + numberIndexSize;
-        Buffer.Advance(totalSize);
+        Buffer_.Advance(totalSize);
 
-        TPODWriter writer(Buffer, 0);
+        TPODWriter writer(Buffer_, 0);
 
         // Write Header
         const ui32 stringIndexStart = headerSize + treeSize;
@@ -241,7 +241,7 @@ public:
         // Write Tree
         WriteContainer(treeWriter, 0);
 
-        return std::move(Buffer);
+        return std::move(Buffer_);
     }
 
 private:
@@ -249,8 +249,8 @@ private:
      * @brief Writes container and all its children recursively
      */
     void WriteContainer(TPODWriter& valueWriter, ui32 index) {
-        Y_DEBUG_ABORT_UNLESS(index < Json.Containers.size());
-        const auto& container = Json.Containers[index];
+        Y_DEBUG_ABORT_UNLESS(index < Json_.Containers.size());
+        const auto& container = Json_.Containers[index];
 
         switch (container.Type) {
             case EContainerType::Array:
@@ -301,7 +301,7 @@ private:
         keyValuePairs.reserve(size);
         for (ui32 i = 0; i < entriesCount; i += 2) {
             const auto keyIndex = container.Header[i].Value;
-            const auto keyOffset = StringOffsets[keyIndex];
+            const auto keyOffset = StringOffsets_[keyIndex];
             const auto& value = container.Header[i + 1];
             keyValuePairs.emplace_back(TKeyEntry(keyOffset), value);
         }
@@ -332,10 +332,10 @@ private:
             WriteContainer(valueWriter, childIndex);
         } else if (entry.Type == EEntryType::String) {
             const ui32 stringIndex = entry.Value;
-            result.Value = StringOffsets[stringIndex];
+            result.Value = StringOffsets_[stringIndex];
         } else if (entry.Type == EEntryType::Number) {
             const ui32 numberIndex = entry.Value;
-            result.Value = NumberOffsets[numberIndex];
+            result.Value = NumberOffsets_[numberIndex];
         }
 
         entryWriter.Write(result);
@@ -350,20 +350,20 @@ private:
      *  +----------------+----------+-----+--------------+---------+-----+-------------+
      */
     void WriteStringIndex(TPODWriter& writer) {
-        const ui32 stringCount = Json.Keys.size() + Json.Strings.size();
+        const ui32 stringCount = Json_.Keys.size() + Json_.Strings.size();
         writer.Write(stringCount);
 
         TPODWriter entryWriter(writer);
         writer.Skip<TSEntry>(stringCount);
 
         // Write SData and SEntry for each string
-        StringOffsets.resize(stringCount);
+        StringOffsets_.resize(stringCount);
 
-        for (const auto& it : Json.Keys) {
+        for (const auto& it : Json_.Keys) {
             const auto& currentString = it.first;
             const auto currentIndex = it.second;
 
-            StringOffsets[currentIndex] = entryWriter.Offset;
+            StringOffsets_[currentIndex] = entryWriter.Offset;
 
             // Append SData to the end of the buffer
             writer.Write(currentString.data(), currentString.length());
@@ -373,11 +373,11 @@ private:
             entryWriter.Write(TSEntry(EStringType::RawNullTerminated, writer.Offset));
         }
 
-        for (const auto& it : Json.Strings) {
+        for (const auto& it : Json_.Strings) {
             const auto& currentString = it.first;
             const auto currentIndex = it.second;
 
-            StringOffsets[currentIndex] = entryWriter.Offset;
+            StringOffsets_[currentIndex] = entryWriter.Offset;
 
             // Append SData to the end of the buffer
             writer.Write(currentString.data(), currentString.length());
@@ -397,19 +397,19 @@ private:
      *  +----------+-----+----------+
      */
     void WriteNumberIndex(TPODWriter& writer) {
-        const ui32 numberCount = Json.Numbers.size();
+        const ui32 numberCount = Json_.Numbers.size();
 
-        NumberOffsets.resize(numberCount);
-        for (const auto it : Json.Numbers) {
-            NumberOffsets[it.second] = writer.Offset;
+        NumberOffsets_.resize(numberCount);
+        for (const auto it : Json_.Numbers) {
+            NumberOffsets_[it.second] = writer.Offset;
             writer.Write(it.first);
         }
     }
 
-    TJsonIndex Json;
-    TBinaryJson Buffer;
-    TVector<ui32> StringOffsets;
-    TVector<ui32> NumberOffsets;
+    TJsonIndex Json_;
+    TBinaryJson Buffer_;
+    TVector<ui32> StringOffsets_;
+    TVector<ui32> NumberOffsets_;
 };
 
 /**
@@ -418,11 +418,11 @@ private:
 class TBinaryJsonCallbacks : public TJsonCallbacks {
 public:
     TBinaryJsonCallbacks(bool throwException, bool allowInf)
-        : TJsonCallbacks(/* throwException */ throwException), AllowInf(allowInf) {
+        : TJsonCallbacks(/* throwException */ throwException), AllowInf_(allowInf) {
     }
 
     bool OnNull() override {
-        Json.AddEntry(TEntry(EEntryType::Null), /* createTopLevel */ true);
+        Json_.AddEntry(TEntry(EEntryType::Null), /* createTopLevel */ true);
         return true;
     }
 
@@ -431,69 +431,69 @@ public:
         if (value) {
             type = EEntryType::BoolTrue;
         }
-        Json.AddEntry(TEntry(type), /* createTopLevel */ true);
+        Json_.AddEntry(TEntry(type), /* createTopLevel */ true);
         return true;
     }
 
     bool OnInteger(long long value) override {
-        Json.AddEntry(TEntry(EEntryType::Number, Json.InternNumber(static_cast<double>(value))), /* createTopLevel */ true);
+        Json_.AddEntry(TEntry(EEntryType::Number, Json_.InternNumber(static_cast<double>(value))), /* createTopLevel */ true);
         return true;
     }
 
     bool OnUInteger(unsigned long long value) override {
-        Json.AddEntry(TEntry(EEntryType::Number, Json.InternNumber(static_cast<double>(value))), /* createTopLevel */ true);
+        Json_.AddEntry(TEntry(EEntryType::Number, Json_.InternNumber(static_cast<double>(value))), /* createTopLevel */ true);
         return true;
     }
 
     bool OnDouble(double value) override {
-        if (Y_UNLIKELY(std::isinf(value) && !AllowInf)) {
+        if (Y_UNLIKELY(std::isinf(value) && !AllowInf_)) {
             if (ThrowException) {
                 ythrow yexception() << "JSON number is infinite";
             } else {
                 return false;
             }
         }
-        Json.AddEntry(TEntry(EEntryType::Number, Json.InternNumber(value)), /* createTopLevel */ true);
+        Json_.AddEntry(TEntry(EEntryType::Number, Json_.InternNumber(value)), /* createTopLevel */ true);
         return true;
     }
 
     bool OnString(const TStringBuf& value) override {
-        Json.AddEntry(TEntry(EEntryType::String, Json.InternString(value)), /* createTopLevel */ true);
+        Json_.AddEntry(TEntry(EEntryType::String, Json_.InternString(value)), /* createTopLevel */ true);
         return true;
     }
 
     bool OnOpenMap() override {
-        Json.AddContainer(EContainerType::Object);
+        Json_.AddContainer(EContainerType::Object);
         return true;
     }
 
     bool OnMapKey(const TStringBuf& value) override {
-        Json.AddEntry(TEntry(EEntryType::String, Json.InternKey(value)));
+        Json_.AddEntry(TEntry(EEntryType::String, Json_.InternKey(value)));
         return true;
     }
 
     bool OnCloseMap() override {
-        Json.RemoveContainer();
+        Json_.RemoveContainer();
         return true;
     }
 
     bool OnOpenArray() override {
-        Json.AddContainer(EContainerType::Array);
+        Json_.AddContainer(EContainerType::Array);
         return true;
     }
 
     bool OnCloseArray() override {
-        Json.RemoveContainer();
+        Json_.RemoveContainer();
         return true;
     }
 
     TJsonIndex GetResult() && {
-        return std::move(Json);
+        return std::move(Json_);
     }
 
 private:
-    TJsonIndex Json;
-    bool AllowInf;
+    TJsonIndex Json_;
+    bool AllowInf_;
 };
 
 void DomToJsonIndex(const NUdf::TUnboxedValue& value, TBinaryJsonCallbacks& callbacks) {
diff --git a/yql/essentials/types/uuid/uuid.cpp b/yql/essentials/types/uuid/uuid.cpp
index 59e3bfbc410..4a7f2bd406d 100644
--- a/yql/essentials/types/uuid/uuid.cpp
+++ b/yql/essentials/types/uuid/uuid.cpp
@@ -30,7 +30,7 @@ static void WriteHex(ui16 bytes, IOutputStream& out, bool reverseBytes = false)
 
 TString UuidBytesToString(const TString& in) {
     TStringStream ss;
-    
+
     UuidBytesToString(in, ss);
 
     return ss.Str();
@@ -44,12 +44,12 @@ void UuidBytesToString(const TString& in, IOutputStream& out) {
 
 void UuidHalfsToString(ui64 low, ui64 hi, IOutputStream& out) {
     union {
-        ui16 dw[8];
-        ui64 half[2];
+        ui16 Dw[8];
+        ui64 Half[2];
     } buf;
-    buf.half[0] = low;
-    buf.half[1] = hi;
-    NUuid::UuidToString(buf.dw, out);
+    buf.Half[0] = low;
+    buf.Half[1] = hi;
+    NUuid::UuidToString(buf.Dw, out);
 }
 
 void UuidToString(ui16 dw[8], IOutputStream& out) {
@@ -69,12 +69,12 @@ void UuidToString(ui16 dw[8], IOutputStream& out) {
 
 void UuidHalfsToByteString(ui64 low, ui64 hi, IOutputStream& out) {
     union {
-        char bytes[16];
-        ui64 half[2];
+        char Bytes[16];
+        ui64 Half[2];
     } buf;
-    buf.half[0] = low;
-    buf.half[1] = hi;
-    out.Write(buf.bytes, 16);
+    buf.Half[0] = low;
+    buf.Half[1] = hi;
+    out.Write(buf.Bytes, 16);
 }
 
 }
diff --git a/yql/essentials/types/uuid/uuid.h b/yql/essentials/types/uuid/uuid.h
index 4364318091a..8f771d3753d 100644
--- a/yql/essentials/types/uuid/uuid.h
+++ b/yql/essentials/types/uuid/uuid.h
@@ -101,24 +101,24 @@ bool ParseUuidToArray(const T& buf, ui16* dw, bool shortForm) {
 
 inline void UuidHalfsToBytes(char *dst, size_t dstSize, ui64 hi, ui64 low) {
     union {
-        char bytes[UUID_LEN];
-        ui64 half[2];
+        char Bytes[UUID_LEN];
+        ui64 Half[2];
     } buf;
     Y_ABORT_UNLESS(UUID_LEN == dstSize);
-    buf.half[0] = low;
-    buf.half[1] = hi;
-    memcpy(dst, buf.bytes, sizeof(buf));
+    buf.Half[0] = low;
+    buf.Half[1] = hi;
+    memcpy(dst, buf.Bytes, sizeof(buf));
 }
 
 inline void UuidBytesToHalfs(const char *str, size_t sz, ui64 &high, ui64 &low) {
     union {
-        char bytes[UUID_LEN];
-        ui64 half[2];
+        char Bytes[UUID_LEN];
+        ui64 Half[2];
     } buf;
     Y_ABORT_UNLESS(UUID_LEN == sz);
-    memcpy(buf.bytes, str, sizeof(buf));
-    low = buf.half[0];
-    high = buf.half[1];
+    memcpy(buf.Bytes, str, sizeof(buf));
+    low = buf.Half[0];
+    high = buf.Half[1];
 }
 
 }