YQL-20086 minikql

commit_hash:c35c972d6708fb1b3f34fa34a42cdae1ddf11cdc

1 files changed, 76 insertions, 76 deletions

diff --git a/yql/essentials/minikql/computation/mkql_value_builder_ut.cpp b/yql/essentials/minikql/computation/mkql_value_builder_ut.cpp
index 127c55bc9b2..a22800590ec 100644
--- a/yql/essentials/minikql/computation/mkql_value_builder_ut.cpp
+++ b/yql/essentials/minikql/computation/mkql_value_builder_ut.cpp
@@ -37,32 +37,32 @@ namespace {
 class TMiniKQLValueBuilderTest: public TTestBase {
 public:
     TMiniKQLValueBuilderTest()
-        : FunctionRegistry(CreateFunctionRegistry(CreateBuiltinRegistry()))
-        , Alloc(__LOCATION__)
-        , Env(Alloc)
-        , MemInfo("Memory")
-        , HolderFactory(Alloc.Ref(), MemInfo, FunctionRegistry.Get())
-        , Builder(HolderFactory, NUdf::EValidatePolicy::Exception)
-        , TypeInfoHelper(new TTypeInfoHelper())
-        , FunctionTypeInfoBuilder(NYql::UnknownLangVersion, Env, TypeInfoHelper, "", nullptr, {})
+        : FunctionRegistry_(CreateFunctionRegistry(CreateBuiltinRegistry()))
+        , Alloc_(__LOCATION__)
+        , Env_(Alloc_)
+        , MemInfo_("Memory")
+        , HolderFactory_(Alloc_.Ref(), MemInfo_, FunctionRegistry_.Get())
+        , Builder_(HolderFactory_, NUdf::EValidatePolicy::Exception)
+        , TypeInfoHelper_(new TTypeInfoHelper())
+        , FunctionTypeInfoBuilder_(NYql::UnknownLangVersion, Env_, TypeInfoHelper_, "", nullptr, {})
     {
-        BoolOid = NYql::NPg::LookupType("bool").TypeId;
+        BoolOid_ = NYql::NPg::LookupType("bool").TypeId;
     }
 
     const IPgBuilder& GetPgBuilder() const {
-        return Builder.GetPgBuilder();
+        return Builder_.GetPgBuilder();
     }
 
 private:
-    TIntrusivePtr<NMiniKQL::IFunctionRegistry> FunctionRegistry;
-    TScopedAlloc Alloc;
-    TTypeEnvironment Env;
-    TMemoryUsageInfo MemInfo;
-    THolderFactory HolderFactory;
-    TDefaultValueBuilder Builder;
-    NUdf::ITypeInfoHelper::TPtr TypeInfoHelper;
-    TFunctionTypeInfoBuilder FunctionTypeInfoBuilder;
-    ui32 BoolOid = 0;
+    TIntrusivePtr<NMiniKQL::IFunctionRegistry> FunctionRegistry_;
+    TScopedAlloc Alloc_;
+    TTypeEnvironment Env_;
+    TMemoryUsageInfo MemInfo_;
+    THolderFactory HolderFactory_;
+    TDefaultValueBuilder Builder_;
+    NUdf::ITypeInfoHelper::TPtr TypeInfoHelper_;
+    TFunctionTypeInfoBuilder FunctionTypeInfoBuilder_;
+    ui32 BoolOid_ = 0;
 
     UNIT_TEST_SUITE(TMiniKQLValueBuilderTest);
         UNIT_TEST(TestEmbeddedVariant);
@@ -79,7 +79,7 @@ private:
 
 
     void TestEmbeddedVariant() {
-        const auto v = Builder.NewVariant(62, TUnboxedValuePod((ui64) 42));
+        const auto v = Builder_.NewVariant(62, TUnboxedValuePod((ui64) 42));
         UNIT_ASSERT(v);
         UNIT_ASSERT(!v.IsBoxed());
         UNIT_ASSERT_VALUES_EQUAL(62, v.GetVariantIndex());
@@ -87,7 +87,7 @@ private:
     }
 
     void TestBoxedVariant() {
-        const auto v = Builder.NewVariant(63, TUnboxedValuePod((ui64) 42));
+        const auto v = Builder_.NewVariant(63, TUnboxedValuePod((ui64) 42));
         UNIT_ASSERT(v);
         UNIT_ASSERT(v.IsBoxed());
         UNIT_ASSERT_VALUES_EQUAL(63, v.GetVariantIndex());
@@ -95,137 +95,137 @@ private:
     }
 
     void TestSubstring() {
-        const auto string = Builder.NewString("0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM");
+        const auto string = Builder_.NewString("0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM");
         UNIT_ASSERT(string);
 
-        const auto zero = Builder.SubString(string, 7, 0);
+        const auto zero = Builder_.SubString(string, 7, 0);
         UNIT_ASSERT_VALUES_EQUAL(TStringBuf(""), TStringBuf(zero.AsStringRef()));
 
-        const auto tail = Builder.SubString(string, 60, 8);
+        const auto tail = Builder_.SubString(string, 60, 8);
         UNIT_ASSERT_VALUES_EQUAL(TStringBuf("NM"), TStringBuf(tail.AsStringRef()));
 
-        const auto small = Builder.SubString(string, 2, 14);
+        const auto small = Builder_.SubString(string, 2, 14);
         UNIT_ASSERT_VALUES_EQUAL(TStringBuf("23456789qwerty"), TStringBuf(small.AsStringRef()));
 
-        const auto one = Builder.SubString(string, 3, 15);
+        const auto one = Builder_.SubString(string, 3, 15);
         UNIT_ASSERT_VALUES_EQUAL(TStringBuf("3456789qwertyui"), TStringBuf(one.AsStringRef()));
         UNIT_ASSERT_VALUES_EQUAL(string.AsStringValue().Data(), one.AsStringValue().Data());
 
-        const auto two = Builder.SubString(string, 10, 30);
+        const auto two = Builder_.SubString(string, 10, 30);
         UNIT_ASSERT_VALUES_EQUAL(TStringBuf("qwertyuiopasdfghjklzxcvbnmQWER"), TStringBuf(two.AsStringRef()));
         UNIT_ASSERT_VALUES_EQUAL(string.AsStringValue().Data(), two.AsStringValue().Data());
     }
 
     void TestPgValueFromErrors() {
-        const TBindTerminator bind(&Builder); // to raise exception instead of abort
+        const TBindTerminator bind(&Builder_); // to raise exception instead of abort
         {
             TStringValue error("");
-            auto r = GetPgBuilder().ValueFromText(BoolOid, "", error);
+            auto r = GetPgBuilder().ValueFromText(BoolOid_, "", error);
             UNIT_ASSERT(!r);
             UNIT_ASSERT_STRING_CONTAINS(AsString(error), "ERROR:  invalid input syntax for type boolean: \"\"");
         }
 
         {
             TStringValue error("");
-            auto r = GetPgBuilder().ValueFromText(BoolOid, "zzzz", error);
+            auto r = GetPgBuilder().ValueFromText(BoolOid_, "zzzz", error);
             UNIT_ASSERT(!r);
             UNIT_ASSERT_STRING_CONTAINS(AsString(error), "ERROR:  invalid input syntax for type boolean: \"zzzz\"");
         }
 
         {
             TStringValue error("");
-            auto r = GetPgBuilder().ValueFromBinary(BoolOid, "", error);
+            auto r = GetPgBuilder().ValueFromBinary(BoolOid_, "", error);
             UNIT_ASSERT(!r);
             UNIT_ASSERT_STRING_CONTAINS(AsString(error), "ERROR:  no data left in message");
         }
 
         {
             TStringValue error("");
-            auto r = GetPgBuilder().ValueFromBinary(BoolOid, "zzzz", error);
+            auto r = GetPgBuilder().ValueFromBinary(BoolOid_, "zzzz", error);
             UNIT_ASSERT(!r);
             UNIT_ASSERT_STRING_CONTAINS(AsString(error), "Not all data has been consumed by 'recv' function: boolrecv, data size: 4, consumed size: 1");
         }
     }
 
     void TestPgValueFromText() {
-        const TBindTerminator bind(&Builder);
+        const TBindTerminator bind(&Builder_);
         for (auto validTrue : { "t"sv, "true"sv }) {
             TStringValue error("");
-            auto r = GetPgBuilder().ValueFromText(BoolOid, validTrue, error);
+            auto r = GetPgBuilder().ValueFromText(BoolOid_, validTrue, error);
             UNIT_ASSERT(r);
             UNIT_ASSERT_VALUES_EQUAL(AsString(error), "");
-            auto s = PgValueToNativeText(r, BoolOid);
+            auto s = PgValueToNativeText(r, BoolOid_);
             UNIT_ASSERT_VALUES_EQUAL(s, "t");
         }
 
         for (auto validFalse : { "f"sv, "false"sv }) {
             TStringValue error("");
-            auto r = GetPgBuilder().ValueFromText(BoolOid, validFalse, error);
+            auto r = GetPgBuilder().ValueFromText(BoolOid_, validFalse, error);
             UNIT_ASSERT(r);
             UNIT_ASSERT_VALUES_EQUAL(AsString(error), "");
-            auto s = PgValueToNativeText(r, BoolOid);
+            auto s = PgValueToNativeText(r, BoolOid_);
             UNIT_ASSERT_VALUES_EQUAL(s, "f");
         }
     }
 
     void TestPgValueFromBinary() {
-        const TBindTerminator bind(&Builder);
+        const TBindTerminator bind(&Builder_);
         TStringValue error("");
-        auto t = GetPgBuilder().ValueFromText(BoolOid, "true", error);
+        auto t = GetPgBuilder().ValueFromText(BoolOid_, "true", error);
         UNIT_ASSERT(t);
-        auto f = GetPgBuilder().ValueFromText(BoolOid, "false", error);
+        auto f = GetPgBuilder().ValueFromText(BoolOid_, "false", error);
         UNIT_ASSERT(f);
 
-        auto ts = PgValueToNativeBinary(t, BoolOid);
-        auto fs = PgValueToNativeBinary(f, BoolOid);
+        auto ts = PgValueToNativeBinary(t, BoolOid_);
+        auto fs = PgValueToNativeBinary(f, BoolOid_);
         {
-            auto r = GetPgBuilder().ValueFromBinary(BoolOid, ts, error);
+            auto r = GetPgBuilder().ValueFromBinary(BoolOid_, ts, error);
             UNIT_ASSERT(r);
-            auto s = PgValueToNativeText(r, BoolOid);
+            auto s = PgValueToNativeText(r, BoolOid_);
             UNIT_ASSERT_VALUES_EQUAL(s, "t");
         }
 
         {
-            auto r = GetPgBuilder().ValueFromBinary(BoolOid, fs, error);
+            auto r = GetPgBuilder().ValueFromBinary(BoolOid_, fs, error);
             UNIT_ASSERT(r);
-            auto s = PgValueToNativeText(r, BoolOid);
+            auto s = PgValueToNativeText(r, BoolOid_);
             UNIT_ASSERT_VALUES_EQUAL(s, "f");
         }
     }
 
     void TestConvertToFromPg() {
-        const TBindTerminator bind(&Builder);
-        auto boolType = FunctionTypeInfoBuilder.SimpleType<bool>();
+        const TBindTerminator bind(&Builder_);
+        auto boolType = FunctionTypeInfoBuilder_.SimpleType<bool>();
         {
-            auto v = GetPgBuilder().ConvertToPg(TUnboxedValuePod(true), boolType, BoolOid);
-            auto s = PgValueToNativeText(v, BoolOid);
+            auto v = GetPgBuilder().ConvertToPg(TUnboxedValuePod(true), boolType, BoolOid_);
+            auto s = PgValueToNativeText(v, BoolOid_);
             UNIT_ASSERT_VALUES_EQUAL(s, "t");
 
-            auto from = GetPgBuilder().ConvertFromPg(v, BoolOid, boolType);
+            auto from = GetPgBuilder().ConvertFromPg(v, BoolOid_, boolType);
             UNIT_ASSERT_VALUES_EQUAL(from.Get<bool>(), true);
         }
 
         {
-            auto v = GetPgBuilder().ConvertToPg(TUnboxedValuePod(false), boolType, BoolOid);
-            auto s = PgValueToNativeText(v, BoolOid);
+            auto v = GetPgBuilder().ConvertToPg(TUnboxedValuePod(false), boolType, BoolOid_);
+            auto s = PgValueToNativeText(v, BoolOid_);
             UNIT_ASSERT_VALUES_EQUAL(s, "f");
 
-            auto from = GetPgBuilder().ConvertFromPg(v, BoolOid, boolType);
+            auto from = GetPgBuilder().ConvertFromPg(v, BoolOid_, boolType);
             UNIT_ASSERT_VALUES_EQUAL(from.Get<bool>(), false);
         }
     }
 
     void TestConvertToFromPgNulls() {
-        const TBindTerminator bind(&Builder);
-        auto boolOptionalType = FunctionTypeInfoBuilder.Optional()->Item<bool>().Build();
+        const TBindTerminator bind(&Builder_);
+        auto boolOptionalType = FunctionTypeInfoBuilder_.Optional()->Item<bool>().Build();
 
         {
-            auto v = GetPgBuilder().ConvertToPg(TUnboxedValuePod(), boolOptionalType, BoolOid);
+            auto v = GetPgBuilder().ConvertToPg(TUnboxedValuePod(), boolOptionalType, BoolOid_);
             UNIT_ASSERT(!v);
         }
 
         {
-            auto v = GetPgBuilder().ConvertFromPg(TUnboxedValuePod(), BoolOid, boolOptionalType);
+            auto v = GetPgBuilder().ConvertFromPg(TUnboxedValuePod(), BoolOid_, boolOptionalType);
             UNIT_ASSERT(!v);
         }
     }
@@ -236,7 +236,7 @@ private:
             UNIT_ASSERT_VALUES_EQUAL(pgText.TypeLen, -1);
 
             auto s = GetPgBuilder().NewString(pgText.TypeLen, pgText.TypeId, "ABC");
-            auto utf8Type = FunctionTypeInfoBuilder.SimpleType<TUtf8>();
+            auto utf8Type = FunctionTypeInfoBuilder_.SimpleType<TUtf8>();
             auto from = GetPgBuilder().ConvertFromPg(s, pgText.TypeId, utf8Type);
             UNIT_ASSERT_VALUES_EQUAL((TStringBuf)from.AsStringRef(), "ABC"sv);
         }
@@ -246,7 +246,7 @@ private:
             UNIT_ASSERT_VALUES_EQUAL(pgCString.TypeLen, -2);
 
             auto s = GetPgBuilder().NewString(pgCString.TypeLen, pgCString.TypeId, "ABC");
-            auto utf8Type = FunctionTypeInfoBuilder.SimpleType<TUtf8>();
+            auto utf8Type = FunctionTypeInfoBuilder_.SimpleType<TUtf8>();
             auto from = GetPgBuilder().ConvertFromPg(s, pgCString.TypeId, utf8Type);
             UNIT_ASSERT_VALUES_EQUAL((TStringBuf)from.AsStringRef(), "ABC"sv);
         }
@@ -256,29 +256,29 @@ private:
             UNIT_ASSERT_VALUES_EQUAL(byteaString.TypeLen, -1);
 
             auto s = GetPgBuilder().NewString(byteaString.TypeLen, byteaString.TypeId, "ABC");
-            auto stringType = FunctionTypeInfoBuilder.SimpleType<char*>();
+            auto stringType = FunctionTypeInfoBuilder_.SimpleType<char*>();
             auto from = GetPgBuilder().ConvertFromPg(s, byteaString.TypeId, stringType);
             UNIT_ASSERT_VALUES_EQUAL((TStringBuf)from.AsStringRef(), "ABC"sv);
         }
     }
 
     void TestArrowBlock() {
-        auto type = FunctionTypeInfoBuilder.SimpleType<ui64>();
-        auto atype = TypeInfoHelper->MakeArrowType(type);
+        auto type = FunctionTypeInfoBuilder_.SimpleType<ui64>();
+        auto atype = TypeInfoHelper_->MakeArrowType(type);
 
         {
             arrow::Datum d1(std::make_shared<arrow::UInt64Scalar>(123));
-            NUdf::TUnboxedValue val1 = HolderFactory.CreateArrowBlock(std::move(d1));
+            NUdf::TUnboxedValue val1 = HolderFactory_.CreateArrowBlock(std::move(d1));
             bool isScalar;
             ui64 length;
-            auto chunks = Builder.GetArrowBlockChunks(val1, isScalar, length);
+            auto chunks = Builder_.GetArrowBlockChunks(val1, isScalar, length);
             UNIT_ASSERT_VALUES_EQUAL(chunks, 1);
             UNIT_ASSERT(isScalar);
             UNIT_ASSERT_VALUES_EQUAL(length, 1);
 
             ArrowArray arr1;
-            Builder.ExportArrowBlock(val1, 0, &arr1);
-            NUdf::TUnboxedValue val2 = Builder.ImportArrowBlock(&arr1, 1, isScalar, *atype);
+            Builder_.ExportArrowBlock(val1, 0, &arr1);
+            NUdf::TUnboxedValue val2 = Builder_.ImportArrowBlock(&arr1, 1, isScalar, *atype);
             const auto& d2 = TArrowBlock::From(val2).GetDatum();
             UNIT_ASSERT(d2.is_scalar());
             UNIT_ASSERT_VALUES_EQUAL(d2.scalar_as<arrow::UInt64Scalar>().value, 123);
@@ -293,18 +293,18 @@ private:
             std::shared_ptr<arrow::ArrayData> builderResult;
             UNIT_ASSERT(builder.FinishInternal(&builderResult).ok());
             arrow::Datum d1(builderResult);
-            NUdf::TUnboxedValue val1 = HolderFactory.CreateArrowBlock(std::move(d1));
+            NUdf::TUnboxedValue val1 = HolderFactory_.CreateArrowBlock(std::move(d1));
 
             bool isScalar;
             ui64 length;
-            auto chunks = Builder.GetArrowBlockChunks(val1, isScalar, length);
+            auto chunks = Builder_.GetArrowBlockChunks(val1, isScalar, length);
             UNIT_ASSERT_VALUES_EQUAL(chunks, 1);
             UNIT_ASSERT(!isScalar);
             UNIT_ASSERT_VALUES_EQUAL(length, 3);
 
             ArrowArray arr1;
-            Builder.ExportArrowBlock(val1, 0, &arr1);
-            NUdf::TUnboxedValue val2 = Builder.ImportArrowBlock(&arr1, 1, isScalar, *atype);
+            Builder_.ExportArrowBlock(val1, 0, &arr1);
+            NUdf::TUnboxedValue val2 = Builder_.ImportArrowBlock(&arr1, 1, isScalar, *atype);
             const auto& d2 = TArrowBlock::From(val2).GetDatum();
             UNIT_ASSERT(d2.is_array());
             UNIT_ASSERT_VALUES_EQUAL(d2.array()->length, 3);
@@ -333,19 +333,19 @@ private:
 
             auto chunked = arrow::ChunkedArray::Make({ builder1Result, builder2Result }).ValueOrDie();
             arrow::Datum d1(chunked);
-            NUdf::TUnboxedValue val1 = HolderFactory.CreateArrowBlock(std::move(d1));
+            NUdf::TUnboxedValue val1 = HolderFactory_.CreateArrowBlock(std::move(d1));
 
             bool isScalar;
             ui64 length;
-            auto chunks = Builder.GetArrowBlockChunks(val1, isScalar, length);
+            auto chunks = Builder_.GetArrowBlockChunks(val1, isScalar, length);
             UNIT_ASSERT_VALUES_EQUAL(chunks, 2);
             UNIT_ASSERT(!isScalar);
             UNIT_ASSERT_VALUES_EQUAL(length, 5);
 
             ArrowArray arrs[2];
-            Builder.ExportArrowBlock(val1, 0, &arrs[0]);
-            Builder.ExportArrowBlock(val1, 1, &arrs[1]);
-            NUdf::TUnboxedValue val2 = Builder.ImportArrowBlock(arrs, 2, isScalar, *atype);
+            Builder_.ExportArrowBlock(val1, 0, &arrs[0]);
+            Builder_.ExportArrowBlock(val1, 1, &arrs[1]);
+            NUdf::TUnboxedValue val2 = Builder_.ImportArrowBlock(arrs, 2, isScalar, *atype);
             const auto& d2 = TArrowBlock::From(val2).GetDatum();
             UNIT_ASSERT(d2.is_arraylike() && !d2.is_array());
             UNIT_ASSERT_VALUES_EQUAL(d2.length(), 5);