Remove TTypeInfo from TRawTypeValue (ydb-platform#10026)

ydb/core/engine/minikql/flat_local_tx_read_columns.h

@@ -68,14 +68,14 @@ class TFlatLocalReadColumns : public NTabletFlatExecutor::ITransaction {
         TSerializedCellVec fromKeyCells(Ev->Get()->Record.GetFromKey());
         keyFrom.clear();
         for (ui32 i = 0; i < fromKeyCells.GetCells().size(); ++i) {
-            keyFrom.push_back(TRawTypeValue(fromKeyCells.GetCells()[i].AsRef(), keyColumnTypes[i]));
+            keyFrom.push_back(TRawTypeValue(fromKeyCells.GetCells()[i].AsRef(), keyColumnTypes[i].GetTypeId()));
         }
         keyFrom.resize(tableInfo->KeyColumns.size());
 
         TSerializedCellVec toKeyCells(Ev->Get()->Record.GetToKey());
         keyTo.clear();
         for (ui32 i = 0; i < toKeyCells.GetCells().size(); ++i) {
-            keyTo.push_back(TRawTypeValue(toKeyCells.GetCells()[i].AsRef(), keyColumnTypes[i]));
+            keyTo.push_back(TRawTypeValue(toKeyCells.GetCells()[i].AsRef(), keyColumnTypes[i].GetTypeId()));
         }
 
         TVector<NTable::TTag> valueColumns;

ydb/core/engine/minikql/minikql_engine_host.cpp

@@ -23,12 +23,12 @@ void ConvertTableKeys(const TScheme& scheme, const TScheme::TTableInfo* tableInf
     for (size_t keyIdx = 0; keyIdx < row.size(); keyIdx++) {
         const TCell& cell = row[keyIdx];
         ui32 keyCol = tableInfo->KeyColumns[keyIdx];
-        NScheme::TTypeInfo vtypeInfo = scheme.GetColumnInfo(tableInfo, keyCol)->PType;
+        NScheme::TTypeId vtypeId = scheme.GetColumnInfo(tableInfo, keyCol)->PType.GetTypeId();
         if (cell.IsNull()) {
             key.emplace_back();
             bytes += 1;
         } else {
-            key.emplace_back(cell.Data(), cell.Size(), vtypeInfo);
+            key.emplace_back(cell.Data(), cell.Size(), vtypeId);
             bytes += cell.Size();
         }
     }
@@ -42,8 +42,8 @@ void ConvertTableValues(const TScheme& scheme, const TScheme::TTableInfo* tableI
     for (size_t i = 0; i < commands.size(); i++) {
         const IEngineFlatHost::TUpdateCommand& upd = commands[i];
         Y_ABORT_UNLESS(upd.Operation == TKeyDesc::EColumnOperation::Set);
-        auto vtypeinfo = scheme.GetColumnInfo(tableInfo, upd.Column)->PType;
-        ops.emplace_back(upd.Column, NTable::ECellOp::Set, upd.Value.IsNull() ? TRawTypeValue() : TRawTypeValue(upd.Value.Data(), upd.Value.Size(), vtypeinfo));
+        NScheme::TTypeId vtypeId = scheme.GetColumnInfo(tableInfo, upd.Column)->PType.GetTypeId();
+        ops.emplace_back(upd.Column, NTable::ECellOp::Set, upd.Value.IsNull() ? TRawTypeValue() : TRawTypeValue(upd.Value.Data(), upd.Value.Size(), vtypeId));
         bytes += upd.Value.IsNull() ? 1 : upd.Value.Size();
     }
     if (valueBytes)

ydb/core/scheme/scheme_tablecell.h

@@ -182,7 +182,7 @@ inline int CompareCellsAsByteString(const TCell& a, const TCell& b, bool isDesce
 
 // NULL is considered equal to another NULL and less than non-NULL
 // ATTENTION!!! return value is int!! (NOT just -1,0,1)
-inline int CompareTypedCells(const TCell& a, const TCell& b, NScheme::TTypeInfoOrder type) {
+inline int CompareTypedCells(const TCell& a, const TCell& b, const NScheme::TTypeInfoOrder& type) {
     using TPair = std::pair<ui64, ui64>;
     if (a.IsNull())
         return b.IsNull() ? 0 : -1;

ydb/core/scheme/scheme_types_defs.cpp

@@ -15,10 +15,10 @@ namespace NNames {
         ::TString result;
 
         if (value) {
-            const ui32 fixedSize = GetFixedSize(value.TypeInfo());
+            const ui32 fixedSize = GetFixedSize(value.Type());
             if (fixedSize > 0 && value.Size() != fixedSize) {
                 result = ::TStringBuilder()
-                    << "Value with declared type " << NScheme::TypeName(value.TypeInfo())
+                    << "Value with declared type " << NScheme::TypeName(value.Type())
                     << " has unexpected size " << value.Size()
                     << " (expected " << fixedSize << ")";
             }
@@ -27,7 +27,7 @@ namespace NNames {
         return result;
     }
 
-    ::TString HasUnexpectedValueSize(const ::NKikimr::TCell& value, TTypeInfo typeInfo) {
+    ::TString HasUnexpectedValueSize(const ::NKikimr::TCell& value, const TTypeInfo& typeInfo) {
         ::TString result;
 
         if (value) {

ydb/core/scheme/scheme_types_defs.h

@@ -54,7 +54,17 @@ class TStepOrderId : public IIntegerPair<ui64, ui64, NTypeIds::StepOrderId, NNam
 
 ////////////////////////////////////////////////////////
 
-inline ui32 GetFixedSize(TTypeInfo typeInfo) {
+inline ui32 GetFixedSize(TTypeId typeId) {
+    switch (typeId) {
+#define KIKIMR_TYPE_MACRO(typeEnum, typeType, ...) case NTypeIds::typeEnum: return typeType::GetFixedSize();
+    KIKIMR_FOREACH_TYPE(KIKIMR_TYPE_MACRO)
+#undef KIKIMR_TYPE_MACRO
+    default:
+        return 0;
+    }
+}
+
+inline ui32 GetFixedSize(const TTypeInfo& typeInfo) {
     switch (typeInfo.GetTypeId()) {
 #define KIKIMR_TYPE_MACRO(typeEnum, typeType, ...) case NTypeIds::typeEnum: return typeType::GetFixedSize();
     KIKIMR_FOREACH_TYPE(KIKIMR_TYPE_MACRO)
@@ -78,7 +88,7 @@ ::TString HasUnexpectedValueSize(const ::NKikimr::TRawTypeValue& value);
  * 
  * Returns empty string on success or an error description in case of failure
  */
-::TString HasUnexpectedValueSize(const ::NKikimr::TCell& value, TTypeInfo typeInfo);
+::TString HasUnexpectedValueSize(const ::NKikimr::TCell& value, const TTypeInfo& typeInfo);
 
 } // namespace NScheme
 } // namespace NKikimr

ydb/core/scheme_types/scheme_raw_type_value.h

@@ -17,22 +17,21 @@ class TRawTypeValue
         , ValueType()
     {}
 
-    TRawTypeValue(const void* buf, ui32 bufSize, NScheme::TTypeInfo vtype)
+    TRawTypeValue(const void* buf, ui32 bufSize, NScheme::TTypeId vtype)
         : Buffer(buf)
         , BufferSize(bufSize)
         , ValueType(vtype)
     {
-        Y_DEBUG_ABORT_UNLESS(!buf || vtype.GetTypeId() != 0);
+        Y_DEBUG_ABORT_UNLESS(!buf || vtype != 0);
     }
 
-    TRawTypeValue(TArrayRef<const char> ref, NScheme::TTypeInfo vtype)
+    TRawTypeValue(TArrayRef<const char> ref, NScheme::TTypeId vtype)
         : TRawTypeValue((void*)ref.data(), ref.size(), vtype)
     {}
 
     const void* Data() const { return Buffer; }
     ui32 Size() const { return BufferSize; }
-    NScheme::TTypeId Type() const { return ValueType.GetTypeId(); }
-    NScheme::TTypeInfo TypeInfo() const { return ValueType; }
+    NScheme::TTypeId Type() const { return ValueType; }
 
     // we must distinguish empty raw type value (nothing, buffer == nullptr)
     // and zero-length string (value exists, but zero-length)
@@ -41,7 +40,7 @@ class TRawTypeValue
 
     TString ToString() const {
         TStringBuilder builder;
-        builder << "(type:" << ValueType.GetTypeId();
+        builder << "(type:" << ValueType;
         if (!IsEmpty()) {
             builder << ", value:" << TString((const char*)Buffer, BufferSize).Quote();
         }
@@ -60,7 +59,7 @@ class TRawTypeValue
 private:
     const void* Buffer;
     ui32 BufferSize;
-    NScheme::TTypeInfo ValueType;
+    NScheme::TTypeId ValueType;
 };
 
 } // namspace NKikimr

ydb/core/scheme_types/scheme_types_defs.h

@@ -49,7 +49,7 @@ class TTypedType : public IType {
     }
     TTypeId GetTypeId() const override { return TypeId; }
     static TRawTypeValue ToRawTypeValue(const T& value) {
-        return TRawTypeValue((void*)&value, sizeof(T), TTypeInfo(TypeId));
+        return TRawTypeValue((void*)&value, sizeof(T), TypeId);
     }
 
     static const char* TypeName() {
@@ -166,7 +166,7 @@ class TStringBase : public TTypedType<::TString, TDerived, TypeId, Name>
     }
 
     static TRawTypeValue ToRawTypeValue(const ::TString& value) {
-        return TRawTypeValue((const void*)value.data(), value.size(), TTypeInfo(TypeId));
+        return TRawTypeValue((const void*)value.data(), value.size(), TypeId);
     }
 };
 
@@ -213,7 +213,7 @@ class TBoundedString : public TStringBase<TBoundedString<TMaxSize, TypeId, Name>
 
     static TRawTypeValue ToRawTypeValue(const ::TString& value) {
         Y_ABORT_UNLESS(value.size() <= MaxSize);
-        return TRawTypeValue((const void*)value.data(), value.size(), TTypeInfo(TypeId));
+        return TRawTypeValue((const void*)value.data(), value.size(), TypeId);
     }
 };
 

ydb/core/tablet_flat/flat_cxx_database.h

@@ -25,64 +25,64 @@ class TTypeValue : public TRawTypeValue {
     {}
 
     TTypeValue(const ui64& value, NScheme::TTypeId type = NScheme::NTypeIds::Uint64)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const i64& value, NScheme::TTypeId type = NScheme::NTypeIds::Int64)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const ui32& value, NScheme::TTypeId type = NScheme::NTypeIds::Uint32)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const i32& value, NScheme::TTypeId type = NScheme::NTypeIds::Int32)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const ui16& value, NScheme::TTypeId type = NScheme::NTypeIds::Date)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const ui8& value, NScheme::TTypeId type = NScheme::NTypeIds::Byte)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const bool& value, NScheme::TTypeId type = NScheme::NTypeIds::Bool)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const double& value, NScheme::TTypeId type = NScheme::NTypeIds::Double)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     template <typename ElementType>
     TTypeValue(const TVector<ElementType> &value, NScheme::TTypeId type = NScheme::NTypeIds::String)
-        : TRawTypeValue(value.empty() ? (const ElementType*)0xDEADBEEFDEADBEEF : value.data(), value.size() * sizeof(ElementType), NScheme::TTypeInfo(type))
+        : TRawTypeValue(value.empty() ? (const ElementType*)0xDEADBEEFDEADBEEF : value.data(), value.size() * sizeof(ElementType), type)
     {}
 
     TTypeValue(const TActorId& value, NScheme::TTypeId type = NScheme::NTypeIds::ActorId)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const std::pair<ui64, ui64>& value, NScheme::TTypeId type = NScheme::NTypeIds::PairUi64Ui64)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const std::pair<ui64, i64>& value, NScheme::TTypeId type = NScheme::NTypeIds::Decimal)
-        : TRawTypeValue(&value, sizeof(value), NScheme::TTypeInfo(type))
+        : TRawTypeValue(&value, sizeof(value), type)
     {}
 
     TTypeValue(const TString& value, NScheme::TTypeId type = NScheme::NTypeIds::Utf8)
-        : TRawTypeValue(value.data(), value.size(), NScheme::TTypeInfo(type))
+        : TRawTypeValue(value.data(), value.size(), type)
     {}
 
     TTypeValue(const TBuffer& value, NScheme::TTypeId type = NScheme::NTypeIds::String)
-        : TRawTypeValue(value.Empty() ? (const char*)0xDEADBEEFDEADBEEF : value.Data(), value.Size(), NScheme::TTypeInfo(type))
+        : TRawTypeValue(value.Empty() ? (const char*)0xDEADBEEFDEADBEEF : value.Data(), value.Size(), type)
     {}
 
     TTypeValue(const TStringBuf& value, NScheme::TTypeId type = NScheme::NTypeIds::String)
-        : TRawTypeValue(value.empty() ? (const char*)0xDEADBEEFDEADBEEF : value.data(), value.size(), NScheme::TTypeInfo(type))
+        : TRawTypeValue(value.empty() ? (const char*)0xDEADBEEFDEADBEEF : value.data(), value.size(), type)
     {}
 
     explicit TTypeValue(const TRawTypeValue& rawTypeValue)
@@ -244,7 +244,7 @@ template <NScheme::TTypeId ValType>
 class TConvertTypeValue : public TRawTypeValue {
 public:
     TConvertTypeValue(const TRawTypeValue& value)
-        : TRawTypeValue(value.Data(), value.Size(), value.IsEmpty() ? NScheme::TTypeInfo() : NScheme::TTypeInfo(ValType))
+        : TRawTypeValue(value.Data(), value.Size(), value.IsEmpty() ? 0 : ValType)
     {}
 
     template <typename ValueType> static typename NSchemeTypeMapper<ValType>::Type ConvertFrom(ValueType value) {
@@ -257,7 +257,7 @@ template <>
 class TConvertTypeValue<NScheme::NTypeIds::String> : public TRawTypeValue {
 public:
     TConvertTypeValue(const TRawTypeValue& value)
-        : TRawTypeValue(value.Data(), value.Size(), value.IsEmpty() ? NScheme::TTypeInfo() : NScheme::TTypeInfo(NScheme::NTypeIds::String))
+        : TRawTypeValue(value.Data(), value.Size(), value.IsEmpty() ? 0 : NScheme::NTypeIds::String)
     {}
 
     static typename NSchemeTypeMapper<NScheme::NTypeIds::String>::Type ConvertFrom(const TString& value) {
@@ -530,7 +530,7 @@ struct TConvertValue<TColumnType, TRawTypeValue, TStringBuf> {
     TRawTypeValue Value;
 
     TConvertValue(TStringBuf value)
-        : Value(value.data(), value.size(), NScheme::TTypeInfo(TColumnType::ColumnType))
+        : Value(value.data(), value.size(), TColumnType::ColumnType)
     {
         static_assert(TColumnType::ColumnType == NScheme::NTypeIds::String
                       || TColumnType::ColumnType == NScheme::NTypeIds::Utf8,
@@ -1499,7 +1499,7 @@ struct Schema {
                     auto type = tuple.Types[index];
                     if (cell.IsNull())
                         return GetNullValue<ColumnType>(SFINAE::special());
-                    return TConvert<ColumnType, typename ColumnType::Type>::Convert(TRawTypeValue(cell.Data(), cell.Size(), type));
+                    return TConvert<ColumnType, typename ColumnType::Type>::Convert(TRawTypeValue(cell.Data(), cell.Size(), type.GetTypeId()));
                 }
 
                 KeyIterator Iterator;

ydb/core/tablet_flat/flat_database.cpp

@@ -323,7 +323,7 @@ void TDatabase::Update(ui32 table, ERowOp rop, TRawVals key, TArrayRef<const TUp
             if (auto got = annex->Place(table, op.Tag, raw)) {
                 ModifiedRefs[index] = got.Ref;
                 const auto payload = NUtil::NBin::ToRef(ModifiedRefs[index]);
-                op.Value = TRawTypeValue(payload, NScheme::TTypeInfo(op.Value.Type()));
+                op.Value = TRawTypeValue(payload, op.Value.Type());
                 op.Op = ELargeObj::Extern;
             }
         }

ydb/core/tablet_flat/flat_executor_db_mon.cpp

@@ -86,7 +86,7 @@ class TExecutor::TTxExecutorDbMon : public TTransactionBase<TExecutor> {
                                 vals.emplace_back();
                                 TBuffer& buf = vals.back();
                                 buf.Assign(reinterpret_cast<const char*>(&v), sizeof(v));
-                                key.emplace_back(buf.Data(), buf.Size(), NScheme::TTypeInfo(type));
+                                key.emplace_back(buf.Data(), buf.Size(), type);
                                 break;
                             }
                             case NScheme::NTypeIds::Uint64:
@@ -95,7 +95,7 @@ class TExecutor::TTxExecutorDbMon : public TTransactionBase<TExecutor> {
                                 vals.emplace_back();
                                 TBuffer& buf = vals.back();
                                 buf.Assign(reinterpret_cast<const char*>(&v), sizeof(v));
-                                key.emplace_back(buf.Data(), buf.Size(), NScheme::TTypeInfo(type));
+                                key.emplace_back(buf.Data(), buf.Size(), type);
                                 break;
                             }
                             case NScheme::NTypeIds::String:
@@ -104,7 +104,7 @@ class TExecutor::TTxExecutorDbMon : public TTransactionBase<TExecutor> {
                                 vals.emplace_back();
                                 TBuffer& buf = vals.back();
                                 buf.Assign(val.data(), val.size());
-                                key.emplace_back(buf.Data(), buf.Size(), NScheme::TTypeInfo(type));
+                                key.emplace_back(buf.Data(), buf.Size(), type);
                                 break;
                             }
                             default:

ydb/core/tablet_flat/flat_executor_ut.cpp

@@ -695,7 +695,7 @@ Y_UNIT_TEST_SUITE(TFlatTableReschedule) {
                 TVector<NTable::TTag> tags;
                 tags.push_back(TRowsModel::ColumnValueId);
                 TVector<TRawTypeValue> key;
-                key.emplace_back(&keyId, sizeof(keyId), NScheme::TTypeInfo(NScheme::TInt64::TypeId));
+                key.emplace_back(&keyId, sizeof(keyId), NScheme::TInt64::TypeId);
                 NTable::TRowState row;
                 auto ready = txc.DB.Select(TRowsModel::TableId, key, tags, row);
                 if (ready == NTable::EReady::Page) {
@@ -1347,7 +1347,7 @@ Y_UNIT_TEST_SUITE(TFlatTableExecutorResourceProfile) {
             if (!req.Keys.empty()) {
                 for (auto val : req.Keys) {
                     ui64 key1 = val;
-                    TRawTypeValue key[] = {TRawTypeValue(&key1, sizeof(key1), NScheme::TTypeInfo(NScheme::NTypeIds::Int64))};
+                    TRawTypeValue key[] = {TRawTypeValue(&key1, sizeof(key1), NScheme::NTypeIds::Int64)};
                     NTable::TTag tags[] = {TRowsModel::ColumnKeyId};
                     NTable::TRowState row;
                     txc.DB.Select(TRowsModel::TableId, {key, 1}, {tags, 1}, row);
@@ -2048,7 +2048,7 @@ Y_UNIT_TEST_SUITE(TFlatTableExecutorCompressedSelectRows) {
             TVector<NTable::TTag> tags;
             tags.push_back(TRowsModel::ColumnValueId);
             TVector<TRawTypeValue> key;
-            key.emplace_back(&keyId, sizeof(keyId), NScheme::TTypeInfo(NScheme::TInt64::TypeId));
+            key.emplace_back(&keyId, sizeof(keyId), NScheme::TInt64::TypeId);
 
             for (keyId = 1000000; keyId < 1000512; ++keyId) {
                 NTable::TRowState row;
@@ -2696,7 +2696,7 @@ Y_UNIT_TEST_SUITE(TFlatTableExecutorKeepEraseMarkers) {
             TVector<NTable::TTag> tags;
             tags.push_back(TRowsModel::ColumnValueId);
             TVector<TRawTypeValue> key;
-            key.emplace_back(&keyId, sizeof(keyId), NScheme::TTypeInfo(NScheme::TInt64::TypeId));
+            key.emplace_back(&keyId, sizeof(keyId), NScheme::TInt64::TypeId);
 
             for (keyId = 100; keyId <= 400; keyId += 100) {
                 NTable::TRowState row;
@@ -4933,7 +4933,7 @@ Y_UNIT_TEST_SUITE(TFlatTableSnapshotWithCommits) {
             TVector<NTable::TTag> tags;
             tags.push_back(TRowsModel::ColumnValueId);
             TVector<TRawTypeValue> key;
-            key.emplace_back(&keyId, sizeof(keyId), NScheme::TTypeInfo(NScheme::TInt64::TypeId));
+            key.emplace_back(&keyId, sizeof(keyId), NScheme::TInt64::TypeId);
 
             for (keyId = 1; keyId <= 104; ++keyId) {
                 NTable::TRowState row;