YT-21987: Support build of yt/yt/client with system stl

62e80da5fdcbdae723b31312339e204116847e9f

10 files changed, 69 insertions, 51 deletions

diff --git a/yt/yt/client/table_client/composite_compare.cpp b/yt/yt/client/table_client/composite_compare.cpp
index 5b1a610c1a0..2285b2c9716 100644
--- a/yt/yt/client/table_client/composite_compare.cpp
+++ b/yt/yt/client/table_client/composite_compare.cpp
@@ -12,6 +12,8 @@
 
 #include <util/stream/mem.h>
 
+#include <cmath>
+
 namespace NYT::NTableClient {
 
 using namespace NYson;
diff --git a/yt/yt/client/table_client/row_base.h b/yt/yt/client/table_client/row_base.h
index 1907e7082f4..51e84f89540 100644
--- a/yt/yt/client/table_client/row_base.h
+++ b/yt/yt/client/table_client/row_base.h
@@ -350,7 +350,7 @@ struct TTypeErasedRow
     }
 };
 
-static_assert(std::is_pod<TTypeErasedRow>::value, "TTypeErasedRow must be POD.");
+static_assert((std::is_standard_layout_v<TTypeErasedRow> && std::is_trivial_v<TTypeErasedRow>), "TTypeErasedRow must be POD.");
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/yt/yt/client/table_client/unversioned_value.cpp b/yt/yt/client/table_client/unversioned_value.cpp
index 33b04514637..178c8bc74dc 100644
--- a/yt/yt/client/table_client/unversioned_value.cpp
+++ b/yt/yt/client/table_client/unversioned_value.cpp
@@ -11,6 +11,8 @@
 
 #endif
 
+#include <yt/yt/library/numeric/util.h>
+
 namespace NYT::NTableClient {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -33,13 +35,15 @@ TFingerprint GetFarmFingerprint(const TUnversionedValue& value)
             return NYT::FarmFingerprint(value.Data.String, value.Length);
 
         case EValueType::Int64:
-            return NYT::FarmFingerprint(std::bit_cast<ui64>(value.Data.Int64));
+            // NB: We use BitCast here instead of std::bit_cast for supporting build with C++17.
+            return NYT::FarmFingerprint(BitCast<ui64>(value.Data.Int64));
 
         case EValueType::Uint64:
             return NYT::FarmFingerprint(value.Data.Uint64);
 
         case EValueType::Double:
-            return NYT::FarmFingerprint(std::bit_cast<ui64>(value.Data.Double));
+            // NB: We use BitCast here instead of std::bit_cast for supporting build with C++17.
+            return NYT::FarmFingerprint(BitCast<ui64>(value.Data.Double));
 
         case EValueType::Boolean:
             return NYT::FarmFingerprint(static_cast<ui64>(value.Data.Boolean));
diff --git a/yt/yt/client/table_client/unversioned_value.h b/yt/yt/client/table_client/unversioned_value.h
index 6bca3e490ff..15bbbdab36d 100644
--- a/yt/yt/client/table_client/unversioned_value.h
+++ b/yt/yt/client/table_client/unversioned_value.h
@@ -61,7 +61,7 @@ static_assert(
     sizeof(TUnversionedValue) == 16,
     "TUnversionedValue has to be exactly 16 bytes.");
 static_assert(
-    std::is_pod_v<TUnversionedValue>,
+    (std::is_standard_layout_v<TUnversionedValue> && std::is_trivial_v<TUnversionedValue>),
     "TUnversionedValue must be a POD type.");
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/yt/yt/library/column_converters/boolean_column_converter.cpp b/yt/yt/library/column_converters/boolean_column_converter.cpp
index abfe730d7a1..20a038f62dc 100644
--- a/yt/yt/library/column_converters/boolean_column_converter.cpp
+++ b/yt/yt/library/column_converters/boolean_column_converter.cpp
@@ -7,6 +7,8 @@
 
 namespace NYT::NColumnConverters {
 
+using namespace NTableClient;
+
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
@@ -20,7 +22,9 @@ void FillColumnarBooleanValues(
     column->StartIndex = startIndex;
     column->ValueCount = valueCount;
 
-    auto& values = column->Values.emplace();
+    column->Values = IUnversionedColumnarRowBatch::TValueBuffer{};
+    auto& values = *column->Values;
+
     values.BitWidth = 1;
     values.Data = bitmap;
 }
@@ -33,7 +37,7 @@ class TBooleanColumnConverter
 public:
     TBooleanColumnConverter(
         int columnIndex,
-        const NTableClient::TColumnSchema& columnSchema,
+        const TColumnSchema& columnSchema,
         int columnOffset)
         : ColumnIndex_(columnIndex)
         , ColumnSchema_(columnSchema)
@@ -67,7 +71,7 @@ public:
 
 private:
     const int ColumnIndex_;
-    const NTableClient::TColumnSchema ColumnSchema_;
+    const TColumnSchema ColumnSchema_;
     const int ColumnOffset_;
 
     TBitmapOutput Values_;
@@ -83,7 +87,7 @@ private:
     {
         for (const auto& rowValues : rowsValues) {
             auto value = rowValues[ColumnOffset_];
-            bool isNull = !value || value->Type == NTableClient::EValueType::Null;
+            bool isNull = !value || value->Type == EValueType::Null;
             bool data = isNull ? false : value->Data.Boolean;
             NullBitmap_.Append(isNull);
             Values_.Append(data);
@@ -95,7 +99,7 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-IColumnConverterPtr CreateBooleanColumnConverter(int columnId, const NTableClient::TColumnSchema& columnSchema, int columnOffset)
+IColumnConverterPtr CreateBooleanColumnConverter(int columnId, const TColumnSchema& columnSchema, int columnOffset)
 {
     return std::make_unique<TBooleanColumnConverter>(columnId, columnSchema, columnOffset);
 }
diff --git a/yt/yt/library/column_converters/column_converter.cpp b/yt/yt/library/column_converters/column_converter.cpp
index b177657daab..e798c4c022a 100644
--- a/yt/yt/library/column_converters/column_converter.cpp
+++ b/yt/yt/library/column_converters/column_converter.cpp
@@ -17,7 +17,7 @@ using namespace NTableClient;
 ////////////////////////////////////////////////////////////////////////////////
 
 IColumnConverterPtr CreateColumnConvert(
-    const NTableClient::TColumnSchema& columnSchema,
+    const TColumnSchema& columnSchema,
     int columnId,
     int columnOffset)
 {
@@ -30,7 +30,7 @@ IColumnConverterPtr CreateColumnConvert(
 
         case EValueType::Double:
             switch (columnSchema.CastToV1Type()) {
-                case NTableClient::ESimpleLogicalValueType::Float:
+                case ESimpleLogicalValueType::Float:
                     return CreateFloatingPoint32ColumnConverter(columnId, columnSchema, columnOffset);
                 default:
                     return CreateFloatingPoint64ColumnConverter(columnId, columnSchema, columnOffset);
diff --git a/yt/yt/library/column_converters/floating_point_column_converter.cpp b/yt/yt/library/column_converters/floating_point_column_converter.cpp
index 3613a6ba9a9..9d4db838f42 100644
--- a/yt/yt/library/column_converters/floating_point_column_converter.cpp
+++ b/yt/yt/library/column_converters/floating_point_column_converter.cpp
@@ -16,7 +16,7 @@ namespace {
 
 template <typename T>
 void FillColumnarFloatingPointValues(
-    NTableClient::IUnversionedColumnarRowBatch::TColumn* column,
+    IUnversionedColumnarRowBatch::TColumn* column,
     i64 startIndex,
     i64 valueCount,
     TRef data)
@@ -24,7 +24,8 @@ void FillColumnarFloatingPointValues(
     column->StartIndex = startIndex;
     column->ValueCount = valueCount;
 
-    auto& values = column->Values.emplace();
+    column->Values = IUnversionedColumnarRowBatch::TValueBuffer{};
+    auto& values = *column->Values;
     values.BitWidth = sizeof(T) * 8;
     values.Data = data;
 }
@@ -45,7 +46,7 @@ TSharedRef SerializeFloatingPointVector(const std::vector<T>& values)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class TValue, NTableClient::EValueType ValueType>
+template <class TValue, EValueType ValueType>
 class TFloatingPointColumnConverter
     : public IColumnConverter
 {
@@ -54,7 +55,7 @@ public:
 
     TFloatingPointColumnConverter(
         int columnId,
-        const NTableClient::TColumnSchema& columnSchema,
+        const TColumnSchema& columnSchema,
         int columnOffset)
         : ColumnId_(columnId)
         , ColumnSchema_(columnSchema)
@@ -113,7 +114,7 @@ private:
     {
         for (const auto& rowValues : rowsValues) {
             auto value = rowValues[ColumnOffset_];
-            bool isNull = !value || value->Type == NTableClient::EValueType::Null;
+            bool isNull = !value || value->Type == EValueType::Null;
             TValue valueData = isNull ? 0 : value->Data.Double;
             NullBitmap_.Append(isNull);
             Values_.push_back(valueData);
@@ -125,14 +126,14 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-IColumnConverterPtr CreateFloatingPoint32ColumnConverter(int columnId, const NTableClient::TColumnSchema& columnSchema, int columnOffset)
+IColumnConverterPtr CreateFloatingPoint32ColumnConverter(int columnId, const TColumnSchema& columnSchema, int columnOffset)
 {
-    return std::make_unique<TFloatingPointColumnConverter<float, NTableClient::EValueType::Double>>(columnId, columnSchema, columnOffset);
+    return std::make_unique<TFloatingPointColumnConverter<float, EValueType::Double>>(columnId, columnSchema, columnOffset);
 }
 
-IColumnConverterPtr CreateFloatingPoint64ColumnConverter(int columnId, const NTableClient::TColumnSchema& columnSchema, int columnOffset)
+IColumnConverterPtr CreateFloatingPoint64ColumnConverter(int columnId, const TColumnSchema& columnSchema, int columnOffset)
 {
-    return std::make_unique<TFloatingPointColumnConverter<double, NTableClient::EValueType::Double>>(columnId, columnSchema, columnOffset);
+    return std::make_unique<TFloatingPointColumnConverter<double, EValueType::Double>>(columnId, columnSchema, columnOffset);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/yt/yt/library/column_converters/helpers.cpp b/yt/yt/library/column_converters/helpers.cpp
index cddac06d797..f43c2e184d6 100644
--- a/yt/yt/library/column_converters/helpers.cpp
+++ b/yt/yt/library/column_converters/helpers.cpp
@@ -15,7 +15,7 @@ using namespace NTableClient;
 ////////////////////////////////////////////////////////////////////////////////
 
 void FillColumnarNullBitmap(
-    NTableClient::IUnversionedColumnarRowBatch::TColumn* column,
+    IUnversionedColumnarRowBatch::TColumn* column,
     i64 startIndex,
     i64 valueCount,
     TRef bitmap)
@@ -23,16 +23,16 @@ void FillColumnarNullBitmap(
     column->StartIndex = startIndex;
     column->ValueCount = valueCount;
 
-    auto& nullBitmap = column->NullBitmap.emplace();
+    column->NullBitmap = IUnversionedColumnarRowBatch::TBitmap{};
+    auto& nullBitmap = *column->NullBitmap;
     nullBitmap.Data = bitmap;
 }
 
-
 void FillColumnarDictionary(
-    NTableClient::IUnversionedColumnarRowBatch::TColumn* primaryColumn,
-    NTableClient::IUnversionedColumnarRowBatch::TColumn* dictionaryColumn,
-    NTableClient::IUnversionedColumnarRowBatch::TDictionaryId dictionaryId,
-    NTableClient::TLogicalTypePtr type,
+    IUnversionedColumnarRowBatch::TColumn* primaryColumn,
+    IUnversionedColumnarRowBatch::TColumn* dictionaryColumn,
+    IUnversionedColumnarRowBatch::TDictionaryId dictionaryId,
+    TLogicalTypePtr type,
     i64 startIndex,
     i64 valueCount,
     TRef ids)
@@ -44,11 +44,13 @@ void FillColumnarDictionary(
         ? type->AsOptionalTypeRef().GetElement()
         : type;
 
-    auto& primaryValues = primaryColumn->Values.emplace();
+    primaryColumn->Values = IUnversionedColumnarRowBatch::TValueBuffer{};
+    auto& primaryValues = *primaryColumn->Values;
     primaryValues.BitWidth = 32;
     primaryValues.Data = ids;
 
-    auto& dictionary = primaryColumn->Dictionary.emplace();
+    primaryColumn->Dictionary = IUnversionedColumnarRowBatch::TDictionaryEncoding{};
+    auto& dictionary = *primaryColumn->Dictionary;
     dictionary.DictionaryId = dictionaryId;
     dictionary.ZeroMeansNull = true;
     dictionary.ValueColumn = dictionaryColumn;
diff --git a/yt/yt/library/column_converters/integer_column_converter.cpp b/yt/yt/library/column_converters/integer_column_converter.cpp
index f29f8ec1081..ad8b0427574 100644
--- a/yt/yt/library/column_converters/integer_column_converter.cpp
+++ b/yt/yt/library/column_converters/integer_column_converter.cpp
@@ -9,6 +9,8 @@
 
 namespace NYT::NColumnConverters {
 
+using namespace NTableClient;
+
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
@@ -25,14 +27,14 @@ ui64 EncodeValue(ui64 value)
 
 template <class TValue>
 typename std::enable_if<std::is_signed<TValue>::value, TValue>::type
-GetValue(const NTableClient::TUnversionedValue& value)
+GetValue(const TUnversionedValue& value)
 {
     return value.Data.Int64;
 }
 
 template <class TValue>
 typename std::enable_if<std::is_unsigned<TValue>::value, TValue>::type
-GetValue(const NTableClient::TUnversionedValue& value)
+GetValue(const TUnversionedValue& value)
 {
     return value.Data.Uint64;
 }
@@ -40,20 +42,21 @@ GetValue(const NTableClient::TUnversionedValue& value)
 ////////////////////////////////////////////////////////////////////////////////
 
 void FillColumnarIntegerValues(
-    NTableClient::IUnversionedColumnarRowBatch::TColumn* column,
+    IUnversionedColumnarRowBatch::TColumn* column,
     i64 startIndex,
     i64 valueCount,
-    NTableClient::EValueType valueType,
+    EValueType valueType,
     ui64 baseValue,
     TRef data)
 {
     column->StartIndex = startIndex;
     column->ValueCount = valueCount;
 
-    auto& values = column->Values.emplace();
+    column->Values = IUnversionedColumnarRowBatch::TValueBuffer{};
+    auto& values = *column->Values;
     values.BaseValue = baseValue;
     values.BitWidth = 64;
-    values.ZigZagEncoded = (valueType == NTableClient::EValueType::Int64);
+    values.ZigZagEncoded = (valueType == EValueType::Int64);
     values.Data = data;
 }
 
@@ -69,8 +72,8 @@ public:
 
     TIntegerColumnConverter(
         int columnId,
-        NTableClient::EValueType ValueType,
-        NTableClient::TColumnSchema columnSchema,
+        EValueType ValueType,
+        TColumnSchema columnSchema,
         int columnOffset)
         : ColumnId_(columnId)
         , ColumnSchema_(columnSchema)
@@ -121,8 +124,8 @@ public:
 
 private:
     const int ColumnId_;
-    const NTableClient::TColumnSchema ColumnSchema_;
-    const NTableClient::EValueType ValueType_;
+    const TColumnSchema ColumnSchema_;
+    const EValueType ValueType_;
     const int ColumnOffset_;
 
     i64 RowCount_ = 0;
@@ -145,7 +148,7 @@ private:
     {
         for (const auto& rowValues : rowsValues) {
             auto value = rowValues[ColumnOffset_];
-            bool isNull = !value || value->Type == NTableClient::EValueType::Null;
+            bool isNull = !value || value->Type == EValueType::Null;
             ui64 data = 0;
             if (!isNull) {
                 YT_VERIFY(value);
@@ -162,15 +165,15 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-IColumnConverterPtr CreateInt64ColumnConverter(int columnId, const NTableClient::TColumnSchema& columnSchema, int columnOffset)
+IColumnConverterPtr CreateInt64ColumnConverter(int columnId, const TColumnSchema& columnSchema, int columnOffset)
 {
-    return std::make_unique<TIntegerColumnConverter<i64>>(columnId, NTableClient::EValueType::Int64, columnSchema, columnOffset);
+    return std::make_unique<TIntegerColumnConverter<i64>>(columnId, EValueType::Int64, columnSchema, columnOffset);
 }
 
 
-IColumnConverterPtr CreateUint64ColumnConverter(int columnId, const NTableClient::TColumnSchema& columnSchema, int columnOffset)
+IColumnConverterPtr CreateUint64ColumnConverter(int columnId, const TColumnSchema& columnSchema, int columnOffset)
 {
-    return std::make_unique<TIntegerColumnConverter<ui64>>(columnId, NTableClient::EValueType::Uint64, columnSchema, columnOffset);
+    return std::make_unique<TIntegerColumnConverter<ui64>>(columnId, EValueType::Uint64, columnSchema, columnOffset);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/yt/yt/library/column_converters/string_column_converter.cpp b/yt/yt/library/column_converters/string_column_converter.cpp
index f943d02e1c5..60b4e28337f 100644
--- a/yt/yt/library/column_converters/string_column_converter.cpp
+++ b/yt/yt/library/column_converters/string_column_converter.cpp
@@ -20,7 +20,7 @@ using namespace NTableClient;
 namespace {
 
 void FillColumnarStringValues(
-    NTableClient::IUnversionedColumnarRowBatch::TColumn* column,
+    IUnversionedColumnarRowBatch::TColumn* column,
     i64 startIndex,
     i64 valueCount,
     ui32 avgLength,
@@ -30,12 +30,14 @@ void FillColumnarStringValues(
     column->StartIndex = startIndex;
     column->ValueCount = valueCount;
 
-    auto& values = column->Values.emplace();
+    column->Values = IUnversionedColumnarRowBatch::TValueBuffer{};
+    auto& values = *column->Values;
     values.BitWidth = 32;
     values.ZigZagEncoded = true;
     values.Data = offsets;
 
-    auto& strings = column->Strings.emplace();
+    column->Strings = IUnversionedColumnarRowBatch::TStringBuffer{};
+    auto& strings = *column->Strings;
     strings.AvgLength = avgLength;
     strings.Data = stringData;
 }
@@ -230,7 +232,7 @@ private:
         FillColumnarDictionary(
             primaryColumn.get(),
             dictionaryColumn.get(),
-            NTableClient::IUnversionedColumnarRowBatch::GenerateDictionaryId(),
+            IUnversionedColumnarRowBatch::GenerateDictionaryId(),
             primaryColumn->Type,
             0,
             RowCount_,
@@ -370,7 +372,7 @@ private:
 
 IColumnConverterPtr CreateStringConverter(
     int columnId,
-    const NTableClient::TColumnSchema& columnSchema,
+    const TColumnSchema& columnSchema,
     int columnOffset)
 {
     return std::make_unique<TStringConverter<EValueType::String>>(columnId, columnSchema, columnOffset);
@@ -378,7 +380,7 @@ IColumnConverterPtr CreateStringConverter(
 
 IColumnConverterPtr CreateAnyConverter(
     int columnId,
-    const NTableClient::TColumnSchema& columnSchema,
+    const TColumnSchema& columnSchema,
     int columnOffset)
 {
     return std::make_unique<TStringConverter<EValueType::Any>>(columnId, columnSchema, columnOffset);
@@ -386,7 +388,7 @@ IColumnConverterPtr CreateAnyConverter(
 
 IColumnConverterPtr CreateCompositeConverter(
     int columnId,
-    const NTableClient::TColumnSchema& columnSchema,
+    const TColumnSchema& columnSchema,
     int columnOffset)
 {
     return std::make_unique<TStringConverter<EValueType::Composite>>(columnId, columnSchema, columnOffset);