YQL-20086 minikql

commit_hash:c35c972d6708fb1b3f34fa34a42cdae1ddf11cdc

1 files changed, 32 insertions, 32 deletions

diff --git a/yql/essentials/minikql/computation/mkql_block_reader.cpp b/yql/essentials/minikql/computation/mkql_block_reader.cpp
index 5886e121c40..9104c6e70ed 100644
--- a/yql/essentials/minikql/computation/mkql_block_reader.cpp
+++ b/yql/essentials/minikql/computation/mkql_block_reader.cpp
@@ -108,9 +108,9 @@ class TStringBlockItemConverter : public IBlockItemConverter {
 public:
     void SetPgBuilder(const NUdf::IPgBuilder* pgBuilder, ui32 pgTypeId, i32 typeLen) {
         Y_ENSURE(PgString != NUdf::EPgStringType::None);
-        PgBuilder = pgBuilder;
-        PgTypeId = pgTypeId;
-        TypeLen = typeLen;
+        PgBuilder_ = pgBuilder;
+        PgTypeId_ = pgTypeId;
+        TypeLen_ = typeLen;
     }
 
     NUdf::TUnboxedValuePod MakeValue(TBlockItem item, const THolderFactory& holderFactory) const final {
@@ -122,14 +122,14 @@ public:
         }
 
         if constexpr (PgString == NUdf::EPgStringType::CString) {
-             return PgBuilder->MakeCString(item.AsStringRef().Data() + sizeof(void*)).Release();
+             return PgBuilder_->MakeCString(item.AsStringRef().Data() + sizeof(void*)).Release();
         } else if constexpr (PgString == NUdf::EPgStringType::Text) {
-             return PgBuilder->MakeText(item.AsStringRef().Data() + sizeof(void*)).Release();
+             return PgBuilder_->MakeText(item.AsStringRef().Data() + sizeof(void*)).Release();
         } else if constexpr (PgString == NUdf::EPgStringType::Fixed) {
             auto str = item.AsStringRef().Data() + sizeof(void*);
             auto len = item.AsStringRef().Size() - sizeof(void*);
-            Y_DEBUG_ABORT_UNLESS(ui32(TypeLen) <= len);
-            return PgBuilder->NewString(TypeLen, PgTypeId, NUdf::TStringRef(str, TypeLen)).Release();
+            Y_DEBUG_ABORT_UNLESS(ui32(TypeLen_) <= len);
+            return PgBuilder_->NewString(TypeLen_, PgTypeId_, NUdf::TStringRef(str, TypeLen_)).Release();
         } else {
             return MakeString(item.AsStringRef());
         }
@@ -143,13 +143,13 @@ public:
         }
 
         if constexpr (PgString == NUdf::EPgStringType::CString) {
-            auto buf = PgBuilder->AsCStringBuffer(value);
+            auto buf = PgBuilder_->AsCStringBuffer(value);
             return TBlockItem(NYql::NUdf::TStringRef(buf.Data() - sizeof(void*), buf.Size() + sizeof(void*)));
         } else if constexpr (PgString == NUdf::EPgStringType::Text) {
-            auto buf = PgBuilder->AsTextBuffer(value);
+            auto buf = PgBuilder_->AsTextBuffer(value);
             return TBlockItem(NYql::NUdf::TStringRef(buf.Data() - sizeof(void*), buf.Size() + sizeof(void*)));
         } else if constexpr (PgString == NUdf::EPgStringType::Fixed) {
-            auto buf = PgBuilder->AsFixedStringBuffer(value, (ui32)TypeLen);
+            auto buf = PgBuilder_->AsFixedStringBuffer(value, (ui32)TypeLen_);
             return TBlockItem(NYql::NUdf::TStringRef(buf.Data() - sizeof(void*), buf.Size() + sizeof(void*)));
         } else {
             return TBlockItem(value.AsStringRef());
@@ -157,9 +157,9 @@ public:
     }
 
 private:
-    const NUdf::IPgBuilder* PgBuilder = nullptr;
-    ui32 PgTypeId = 0;
-    i32 TypeLen = 0;
+    const NUdf::IPgBuilder* PgBuilder_ = nullptr;
+    ui32 PgTypeId_ = 0;
+    i32 TypeLen_ = 0;
 };
 
 class TSingularTypeItemConverter: public IBlockItemConverter {
@@ -179,10 +179,10 @@ template <bool Nullable>
 class TTupleBlockItemConverter : public IBlockItemConverter {
 public:
     TTupleBlockItemConverter(TVector<std::unique_ptr<IBlockItemConverter>>&& children)
-        : Children(std::move(children))
+        : Children_(std::move(children))
     {
-        Items.resize(Children.size());
-        Unboxed.resize(Children.size());
+        Items_.resize(Children_.size());
+        Unboxed_.resize(Children_.size());
     }
 
     NUdf::TUnboxedValuePod MakeValue(TBlockItem item, const THolderFactory& holderFactory) const final {
@@ -193,10 +193,10 @@ public:
         }
 
         NUdf::TUnboxedValue* values;
-        auto result = holderFactory.CreateDirectArrayHolder(Children.size(), values);
+        auto result = holderFactory.CreateDirectArrayHolder(Children_.size(), values);
         const TBlockItem* childItems = item.AsTuple();
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            values[i] = Children[i]->MakeValue(childItems[i], holderFactory);
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            values[i] = Children_[i]->MakeValue(childItems[i], holderFactory);
         }
 
         return result;
@@ -211,24 +211,24 @@ public:
 
         auto elements = value.GetElements();
         if (!elements) {
-            for (ui32 i = 0; i < Children.size(); ++i) {
-                Unboxed[i] = value.GetElement(i);
+            for (ui32 i = 0; i < Children_.size(); ++i) {
+                Unboxed_[i] = value.GetElement(i);
             }
 
-            elements = Unboxed.data();
+            elements = Unboxed_.data();
         }
 
-        for (ui32 i = 0; i < Children.size(); ++i) {
-            Items[i] = Children[i]->MakeItem(elements[i]);
+        for (ui32 i = 0; i < Children_.size(); ++i) {
+            Items_[i] = Children_[i]->MakeItem(elements[i]);
         }
 
-        return TBlockItem{ Items.data() };
+        return TBlockItem{ Items_.data() };
     }
 
 private:
-    const TVector<std::unique_ptr<IBlockItemConverter>> Children;
-    mutable TVector<NUdf::TUnboxedValue> Unboxed;
-    mutable TVector<TBlockItem> Items;
+    const TVector<std::unique_ptr<IBlockItemConverter>> Children_;
+    mutable TVector<NUdf::TUnboxedValue> Unboxed_;
+    mutable TVector<TBlockItem> Items_;
 };
 
 template <typename TTzDate, bool Nullable>
@@ -265,14 +265,14 @@ public:
 class TExternalOptionalBlockItemConverter : public IBlockItemConverter {
 public:
     TExternalOptionalBlockItemConverter(std::unique_ptr<IBlockItemConverter>&& inner)
-        : Inner(std::move(inner))
+        : Inner_(std::move(inner))
     {}
 
     NUdf::TUnboxedValuePod MakeValue(TBlockItem item, const THolderFactory& holderFactory) const final {
         if (!item) {
             return {};
         }
-        return Inner->MakeValue(item.GetOptionalValue(), holderFactory).MakeOptional();
+        return Inner_->MakeValue(item.GetOptionalValue(), holderFactory).MakeOptional();
     }
 
     TBlockItem MakeItem(const NUdf::TUnboxedValuePod& value) const final {
@@ -280,11 +280,11 @@ public:
             return {};
         }
 
-        return Inner->MakeItem(value.GetOptionalValue()).MakeOptional();
+        return Inner_->MakeItem(value.GetOptionalValue()).MakeOptional();
     }
 
 private:
-    const std::unique_ptr<IBlockItemConverter> Inner;
+    const std::unique_ptr<IBlockItemConverter> Inner_;
 };
 
 struct TConverterTraits {