Little refactoring

2 files changed, 54 insertions, 71 deletions

diff --git a/ydb/core/tx/datashard/change_collector_async_index.cpp b/ydb/core/tx/datashard/change_collector_async_index.cpp
index 8f899d93216..031c04beee0 100644
--- a/ydb/core/tx/datashard/change_collector_async_index.cpp
+++ b/ydb/core/tx/datashard/change_collector_async_index.cpp
@@ -111,24 +111,28 @@ bool TAsyncIndexChangeCollector::Collect(const TTableId& tableId, ERowOp rop,
         }
 
         if (generateDeletions) {
-            bool needDeletion = false;
+            bool needDeletion = rop == ERowOp::Erase || rop == ERowOp::Reset;
 
             for (const auto tag : index.KeyColumnIds) {
-                if (updatedTagToPos.contains(tag) || rop == ERowOp::Erase || rop == ERowOp::Reset) {
+                if (updatedTagToPos.contains(tag)) {
                     needDeletion = true;
                 }
 
                 Y_VERIFY(tagToPos.contains(tag));
                 Y_VERIFY(userTable->Columns.contains(tag));
-                FillKeyFromRowState(tag, tagToPos.at(tag), row, userTable->Columns.at(tag).Type);
+                AddCellValue(KeyVals, tag, row.Get(tagToPos.at(tag)), userTable->Columns.at(tag).Type);
+                KeyTagsSeen.insert(tag);
             }
 
             for (TPos pos = 0; pos < userTable->KeyColumnIds.size(); ++pos) {
-                FillKeyFromKey(userTable->KeyColumnIds.at(pos), pos, key);
+                const auto& tag = userTable->KeyColumnIds.at(pos);
+                if (!KeyTagsSeen.contains(tag)) {
+                    AddRawValue(KeyVals, tag, key.at(pos));
+                }
             }
 
             if (needDeletion) {
-                Persist(tableId, pathId, ERowOp::Erase, IndexKeyVals, IndexKeyTags, {});
+                Persist(tableId, pathId, ERowOp::Erase, KeyVals, {});
             }
 
             Clear();
@@ -140,43 +144,49 @@ bool TAsyncIndexChangeCollector::Collect(const TTableId& tableId, ERowOp rop,
             for (const auto tag : index.KeyColumnIds) {
                 if (updatedTagToPos.contains(tag)) {
                     needUpdate = true;
-                    FillKeyFromUpdate(tag, updatedTagToPos.at(tag), updates);
+                    AddValue(KeyVals, updates.at(updatedTagToPos.at(tag)));
+                    KeyTagsSeen.insert(tag);
                 } else {
                     Y_VERIFY(userTable->Columns.contains(tag));
                     const auto& column = userTable->Columns.at(tag);
 
                     if (rop == ERowOp::Reset && !column.IsKey) {
-                        FillKeyWithNull(tag, column.Type);
+                        AddNullValue(KeyVals, tag, column.Type);
+                        KeyTagsSeen.insert(tag);
                     } else {
                         Y_VERIFY(tagToPos.contains(tag));
-                        FillKeyFromRowState(tag, tagToPos.at(tag), row, column.Type);
+                        AddCellValue(KeyVals, tag, row.Get(tagToPos.at(tag)), column.Type);
+                        KeyTagsSeen.insert(tag);
                     }
                 }
             }
 
             for (TPos pos = 0; pos < userTable->KeyColumnIds.size(); ++pos) {
-                FillKeyFromKey(userTable->KeyColumnIds.at(pos), pos, key);
+                const auto& tag = userTable->KeyColumnIds.at(pos);
+                if (!KeyTagsSeen.contains(tag)) {
+                    AddRawValue(KeyVals, tag, key.at(pos));
+                }
             }
 
             for (const auto tag : index.DataColumnIds) {
                 if (updatedTagToPos.contains(tag)) {
                     needUpdate = true;
-                    FillDataFromUpdate(tag, updatedTagToPos.at(tag), updates);
+                    AddValue(DataVals, updates.at(updatedTagToPos.at(tag)));
                 } else {
                     Y_VERIFY(userTable->Columns.contains(tag));
                     const auto& column = userTable->Columns.at(tag);
 
                     if (rop == ERowOp::Reset && !column.IsKey) {
-                        FillDataWithNull(tag, column.Type);
+                        AddNullValue(DataVals, tag, column.Type);
                     } else {
                         Y_VERIFY(tagToPos.contains(tag));
-                        FillDataFromRowState(tag, tagToPos.at(tag), row, column.Type);
+                        AddCellValue(DataVals, tag, row.Get(tagToPos.at(tag)), column.Type);
                     }
                 }
             }
 
             if (needUpdate) {
-                Persist(tableId, pathId, ERowOp::Upsert, IndexKeyVals, IndexKeyTags, IndexDataVals);
+                Persist(tableId, pathId, ERowOp::Upsert, KeyVals, DataVals);
             }
 
             Clear();
@@ -221,58 +231,34 @@ TArrayRef<TTag> TAsyncIndexChangeCollector::GetTagsToSelect(const TTableId& tabl
     }
 }
 
-void TAsyncIndexChangeCollector::FillKeyFromRowState(TTag tag, TPos pos, const TRowState& rowState, NScheme::TTypeInfo type) {
-    Y_VERIFY(pos < rowState.Size());
-
-    IndexKeyVals.emplace_back(rowState.Get(pos).AsRef(), type);
-    IndexKeyTags.emplace_back(tag);
-    TagsSeen.insert(tag);
-}
-
-void TAsyncIndexChangeCollector::FillKeyFromKey(TTag tag, TPos pos, TArrayRef<const TRawTypeValue> key) {
-    Y_VERIFY(pos < key.size());
-
-    if (TagsSeen.contains(tag)) {
-        return;
-    }
-
-    IndexKeyVals.emplace_back(key.at(pos));
-    IndexKeyTags.emplace_back(tag);
-}
-
-void TAsyncIndexChangeCollector::FillKeyFromUpdate(TTag tag, TPos pos, TArrayRef<const TUpdateOp> updates) {
-    Y_VERIFY(pos < updates.size());
-
-    const auto& update = updates.at(pos);
+void TAsyncIndexChangeCollector::AddValue(TVector<TUpdateOp>& out, const TUpdateOp& update) {
     Y_VERIFY_S(update.Op == ECellOp::Set, "Unexpected op: " << update.Op.Raw());
-
-    IndexKeyVals.emplace_back(update.Value);
-    IndexKeyTags.emplace_back(tag);
-    TagsSeen.insert(tag);
+    out.push_back(update);
 }
 
-void TAsyncIndexChangeCollector::FillKeyWithNull(TTag tag, NScheme::TTypeInfo type) {
-    IndexKeyVals.emplace_back(TRawTypeValue({}, type));
-    IndexKeyTags.emplace_back(tag);
-    TagsSeen.insert(tag);
+void TAsyncIndexChangeCollector::AddRawValue(TVector<TUpdateOp>& out, TTag tag, const TRawTypeValue& value) {
+    AddValue(out, TUpdateOp(tag, ECellOp::Set, value));
 }
 
-void TAsyncIndexChangeCollector::FillDataFromRowState(TTag tag, TPos pos, const TRowState& rowState, NScheme::TTypeInfo type) {
-    Y_VERIFY(pos < rowState.Size());
-    IndexDataVals.emplace_back(tag, ECellOp::Set, TRawTypeValue(rowState.Get(pos).AsRef(), type));
+void TAsyncIndexChangeCollector::AddCellValue(TVector<TUpdateOp>& out, TTag tag, const TCell& cell, NScheme::TTypeInfo type) {
+    AddRawValue(out, tag, TRawTypeValue(cell.AsRef(), type));
 }
 
-void TAsyncIndexChangeCollector::FillDataFromUpdate(TTag tag, TPos pos, TArrayRef<const TUpdateOp> updates) {
-    Y_VERIFY(pos < updates.size());
-
-    const auto& update = updates.at(pos);
-    Y_VERIFY_S(update.Op == ECellOp::Set, "Unexpected op: " << update.Op.Raw());
-
-    IndexDataVals.emplace_back(tag, ECellOp::Set, update.Value);
+void TAsyncIndexChangeCollector::AddNullValue(TVector<TUpdateOp>& out, TTag tag, NScheme::TTypeInfo type) {
+    AddCellValue(out, tag, {}, type);
 }
 
-void TAsyncIndexChangeCollector::FillDataWithNull(TTag tag, NScheme::TTypeInfo type) {
-    IndexDataVals.emplace_back(tag, ECellOp::Set, TRawTypeValue({}, type));
+void TAsyncIndexChangeCollector::Persist(const TTableId& tableId, const TPathId& pathId, ERowOp rop,
+        TArrayRef<const TUpdateOp> keyVals, TArrayRef<const TUpdateOp> dataVals)
+{
+    TVector<TRawTypeValue> key(Reserve(keyVals.size()));
+    TVector<TTag> keyTags(Reserve(keyVals.size()));
+    for (const auto& v : keyVals) {
+        key.push_back(v.Value);
+        keyTags.push_back(v.Tag);
+    }
+
+    Persist(tableId, pathId, rop, key, keyTags, dataVals);
 }
 
 void TAsyncIndexChangeCollector::Persist(const TTableId& tableId, const TPathId& pathId, ERowOp rop,
@@ -284,10 +270,9 @@ void TAsyncIndexChangeCollector::Persist(const TTableId& tableId, const TPathId&
 }
 
 void TAsyncIndexChangeCollector::Clear() {
-    TagsSeen.clear();
-    IndexKeyTags.clear();
-    IndexKeyVals.clear();
-    IndexDataVals.clear();
+    KeyTagsSeen.clear();
+    KeyVals.clear();
+    DataVals.clear();
 }
 
 } // NDataShard
diff --git a/ydb/core/tx/datashard/change_collector_async_index.h b/ydb/core/tx/datashard/change_collector_async_index.h
index 6090674814a..ff1667f979b 100644
--- a/ydb/core/tx/datashard/change_collector_async_index.h
+++ b/ydb/core/tx/datashard/change_collector_async_index.h
@@ -30,15 +30,14 @@ class TAsyncIndexChangeCollector: public TBaseChangeCollector {
     auto CacheTags(const TTableId& tableId) const;
     TArrayRef<NTable::TTag> GetTagsToSelect(const TTableId& tableId, NTable::ERowOp rop) const;
 
-    void FillKeyFromRowState(NTable::TTag tag, NTable::TPos pos, const NTable::TRowState& rowState, NScheme::TTypeInfo type);
-    void FillKeyFromKey(NTable::TTag tag, NTable::TPos pos, TArrayRef<const TRawTypeValue> key);
-    void FillKeyFromUpdate(NTable::TTag tag, NTable::TPos pos, TArrayRef<const NTable::TUpdateOp> updates);
-    void FillKeyWithNull(NTable::TTag tag, NScheme::TTypeInfo type);
-    void FillDataFromRowState(NTable::TTag tag, NTable::TPos pos, const NTable::TRowState& rowState, NScheme::TTypeInfo type);
-    void FillDataFromUpdate(NTable::TTag tag, NTable::TPos pos, TArrayRef<const NTable::TUpdateOp> updates);
-    void FillDataWithNull(NTable::TTag tag, NScheme::TTypeInfo type);
+    void AddValue(TVector<NTable::TUpdateOp>& out, const NTable::TUpdateOp& update);
+    void AddRawValue(TVector<NTable::TUpdateOp>& out, NTable::TTag tag, const TRawTypeValue& value);
+    void AddCellValue(TVector<NTable::TUpdateOp>& out, NTable::TTag tag, const TCell& cell, NScheme::TTypeInfo type);
+    void AddNullValue(TVector<NTable::TUpdateOp>& out, NTable::TTag tag, NScheme::TTypeInfo type);
 
     void Persist(const TTableId& tableId, const TPathId& pathId, NTable::ERowOp rop,
+        TArrayRef<const NTable::TUpdateOp> key, TArrayRef<const NTable::TUpdateOp> data);
+    void Persist(const TTableId& tableId, const TPathId& pathId, NTable::ERowOp rop,
         TArrayRef<const TRawTypeValue> key, TArrayRef<const NTable::TTag> keyTags,
         TArrayRef<const NTable::TUpdateOp> updates);
 
@@ -57,10 +56,9 @@ private:
     mutable THashMap<TTableId, TCachedTags> CachedTags;
 
     // reused between Collect() calls, cleared after every Clear() call
-    THashSet<NTable::TTag> TagsSeen;
-    TVector<NTable::TTag> IndexKeyTags;
-    TVector<TRawTypeValue> IndexKeyVals;
-    TVector<NTable::TUpdateOp> IndexDataVals;
+    THashSet<NTable::TTag> KeyTagsSeen;
+    TVector<NTable::TUpdateOp> KeyVals;
+    TVector<NTable::TUpdateOp> DataVals;
 
 }; // TAsyncIndexChangeCollector