Add detailed diff to 'Row differs in input and output chunks'

commit_hash:f08566636493f766d50bc0f25336e8dc021399ef

Author: babenko

yt/yt/client/table_client/unversioned_row.cpp

@@ -2186,6 +2186,24 @@ bool TBitwiseUnversionedValueRangeEqual::operator()(TUnversionedValueRange lhs,
     return true;
 }
 
+void TBitwiseUnversionedValueRangeEqual::FormatDiff(TStringBuilderBase* builder, TUnversionedValueRange lhs, TUnversionedValueRange rhs)
+{
+    if (lhs.size() != rhs.size()) {
+        builder->AppendFormat("Value count mismatch: %v vs %v\n",
+            lhs.size(),
+            rhs.size());
+        return;
+    }
+    for (size_t index = 0; index < lhs.size(); ++index) {
+        if (!TBitwiseUnversionedValueEqual()(lhs[index], rhs[index])) {
+            builder->AppendFormat("Value mismatch at index %v\n",
+                index);
+            TBitwiseUnversionedValueEqual::FormatDiff(builder, lhs[index], rhs[index]);
+            break;
+        }
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 size_t TBitwiseUnversionedRowHash::operator()(TUnversionedRow row) const
@@ -2198,6 +2216,11 @@ bool TBitwiseUnversionedRowEqual::operator()(TUnversionedRow lhs, TUnversionedRo
     return TBitwiseUnversionedValueRangeEqual()(lhs.Elements(), rhs.Elements());
 }
 
+void TBitwiseUnversionedRowEqual::FormatDiff(TStringBuilderBase* builder, TUnversionedRow lhs, TUnversionedRow rhs)
+{
+    TBitwiseUnversionedValueRangeEqual::FormatDiff(builder, lhs.Elements(), rhs.Elements());
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT::NTableClient

yt/yt/client/table_client/unversioned_row.h

@@ -966,6 +966,7 @@ struct TBitwiseUnversionedValueRangeHash
 struct TBitwiseUnversionedValueRangeEqual
 {
     bool operator()(TUnversionedValueRange lhs, TUnversionedValueRange rhs) const;
+    static void FormatDiff(TStringBuilderBase* builder, TUnversionedValueRange lhs, TUnversionedValueRange rhs);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -978,6 +979,7 @@ struct TBitwiseUnversionedRowHash
 struct TBitwiseUnversionedRowEqual
 {
     bool operator()(TUnversionedRow lhs, TUnversionedRow rhs) const;
+    static void FormatDiff(TStringBuilderBase* builder, TUnversionedRow lhs, TUnversionedRow rhs);
 };
 
 ////////////////////////////////////////////////////////////////////////////////

yt/yt/client/table_client/unversioned_value.cpp

@@ -239,6 +239,80 @@ bool TBitwiseUnversionedValueEqual::operator()(const TUnversionedValue& lhs, con
     }
 }
 
+void TBitwiseUnversionedValueEqual::FormatDiff(
+    TStringBuilderBase* builder,
+    const TUnversionedValue& lhs,
+    const TUnversionedValue& rhs)
+{
+    if (lhs.Id != rhs.Id) {
+        builder->AppendFormat("Value id mismatch: %v vs %v\n",
+            lhs.Id,
+            rhs.Id);
+        return;
+    }
+    if (lhs.Flags != rhs.Flags) {
+        builder->AppendFormat("Value flags mismatch: %v vs %v\n",
+            lhs.Flags,
+            rhs.Flags);
+        return;
+    }
+    if (lhs.Type != rhs.Type) {
+        builder->AppendFormat("Value type mismatch: %v vs %v\n",
+            lhs.Type,
+            rhs.Type);
+        return;
+    }
+    switch (lhs.Type) {
+        case EValueType::Int64:
+            if (lhs.Data.Int64 != rhs.Data.Int64) {
+                builder->AppendFormat("\"int64\" value mismatch: %v vs %v\n",
+                    lhs.Data.Int64,
+                    rhs.Data.Int64);
+            }
+            break;
+        case EValueType::Uint64:
+            if (lhs.Data.Uint64 != rhs.Data.Uint64) {
+                builder->AppendFormat("\"uint64\" value mismatch: %v vs %v\n",
+                    lhs.Data.Uint64,
+                    rhs.Data.Uint64);
+            }
+            break;
+        case EValueType::Double:
+            if (lhs.Data.Double != rhs.Data.Double) {
+                builder->AppendFormat("\"double\" value mismatch: %v vs %v\n",
+                    lhs.Data.Double,
+                    rhs.Data.Double);
+            }
+            break;
+        case EValueType::Boolean:
+            if (lhs.Data.Boolean != rhs.Data.Boolean) {
+                builder->AppendFormat("\"boolean\" value mismatch: %v vs %v\n",
+                    lhs.Data.Boolean,
+                    rhs.Data.Boolean);
+            }
+            break;
+        case EValueType::String:
+        case EValueType::Any:
+        case EValueType::Composite:
+            if (lhs.Length != rhs.Length) {
+                builder->AppendFormat("%Qlv value length mismatch: %v vs %v\n",
+                    lhs.Type,
+                    lhs.Length,
+                    rhs.Length);
+                break;
+            }
+            if (::memcmp(lhs.Data.String, rhs.Data.String, lhs.Length) != 0) {
+                builder->AppendFormat("%Qlv value mismatch: %v vs %v\n",
+                    lhs.Type,
+                    DumpRangeToHex(TRef::FromStringBuf(lhs.AsStringBuf())),
+                    DumpRangeToHex(TRef::FromStringBuf(rhs.AsStringBuf())));
+            }
+            break;
+        default:
+            break;
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT::NTableClient

yt/yt/client/table_client/unversioned_value.h

@@ -100,6 +100,7 @@ struct TBitwiseUnversionedValueHash
 struct TBitwiseUnversionedValueEqual
 {
     bool operator()(const TUnversionedValue& lhs, const TUnversionedValue& rhs) const;
+    static void FormatDiff(TStringBuilderBase* builder, const TUnversionedValue& lhs, const TUnversionedValue& rhs);
 };
 
 ////////////////////////////////////////////////////////////////////////////////