@nxtedition/rocksdb 13.5.7 → 13.5.9

package/deps/rocksdb/rocksdb/utilities/transactions/transaction_test.h

@@ -163,7 +163,7 @@ class TransactionTestBase : public ::testing::Test {
                              std::vector<ColumnFamilyHandle*>* handles) {
     std::vector<size_t> compaction_enabled_cf_indices;
     TransactionDB::PrepareWrap(&options, &cfs, &compaction_enabled_cf_indices);
-    DB* root_db = nullptr;
+    std::unique_ptr<DB> root_db;
     Options options_copy(options);
     const bool use_seq_per_batch =
         txn_db_options.write_policy == WRITE_PREPARED ||
@@ -174,9 +174,8 @@ class TransactionTestBase : public ::testing::Test {
     Status s = DBImpl::Open(options_copy, dbname, cfs, handles, &root_db,
                             use_seq_per_batch, use_batch_per_txn,
                             /*is_retry=*/false, /*can_retry=*/nullptr);
-    auto stackable_db = std::make_unique<StackableDB>(root_db);
+    auto stackable_db = std::make_unique<StackableDB>(std::move(root_db));
     if (s.ok()) {
-      assert(root_db != nullptr);
       // If WrapStackableDB() returns non-ok, then stackable_db is already
       // deleted within WrapStackableDB().
       s = TransactionDB::WrapStackableDB(stackable_db.release(), txn_db_options,
@@ -194,7 +193,7 @@ class TransactionTestBase : public ::testing::Test {
     TransactionDB::PrepareWrap(&options, &column_families,
                                &compaction_enabled_cf_indices);
     std::vector<ColumnFamilyHandle*> handles;
-    DB* root_db = nullptr;
+    std::unique_ptr<DB> root_db;
     Options options_copy(options);
     const bool use_seq_per_batch =
         txn_db_options.write_policy == WRITE_PREPARED ||
@@ -206,11 +205,9 @@ class TransactionTestBase : public ::testing::Test {
                             &root_db, use_seq_per_batch, use_batch_per_txn,
                             /*is_retry=*/false, /*can_retry=*/nullptr);
     if (!s.ok()) {
-      delete root_db;
       return s;
     }
-    StackableDB* stackable_db = new StackableDB(root_db);
-    assert(root_db != nullptr);
+    StackableDB* stackable_db = new StackableDB(std::move(root_db));
     assert(handles.size() == 1);
     s = TransactionDB::WrapStackableDB(stackable_db, txn_db_options,
                                        compaction_enabled_cf_indices, handles,

package/deps/rocksdb/rocksdb/utilities/transactions/transaction_util.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-
 #include "utilities/transactions/transaction_util.h"
 
 #include <cinttypes>
@@ -204,4 +203,3 @@ Status TransactionUtil::CheckKeysForConflicts(DBImpl* db_impl,
 }
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/utilities/transactions/transaction_util.h

@@ -5,7 +5,6 @@
 
 #pragma once
 
-
 #include <string>
 #include <unordered_map>
 
@@ -83,4 +82,3 @@ class TransactionUtil {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/utilities/transactions/write_prepared_transaction_test.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-
 #include <algorithm>
 #include <atomic>
 #include <cinttypes>
@@ -792,7 +791,8 @@ TEST_P(WritePreparedTransactionTest, CheckKeySkipOldMemtable) {
   const int kAttemptImmMemTable = 1;
   for (int attempt = kAttemptHistoryMemtable; attempt <= kAttemptImmMemTable;
        attempt++) {
-    options.max_write_buffer_number_to_maintain = 3;
+    options.max_write_buffer_size_to_maintain =
+        3 * static_cast<int>(options.write_buffer_size);
     ASSERT_OK(ReOpen());
 
     WriteOptions write_options;
@@ -3596,7 +3596,7 @@ TEST_P(WritePreparedTransactionTest, NonAtomicCommitOfDelayedPrepared) {
       ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
       ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
     }  // for split_before_mutex
-  }    // for split_read
+  }  // for split_read
 }
 
 // When max evicted seq advances a prepared seq, it involves two updates: i)

package/deps/rocksdb/rocksdb/utilities/transactions/write_prepared_txn_db.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-
 #include "utilities/transactions/write_prepared_txn_db.h"
 
 #include <algorithm>

package/deps/rocksdb/rocksdb/utilities/transactions/write_unprepared_transaction_test.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-
 #include "utilities/transactions/transaction_test.h"
 #include "utilities/transactions/write_unprepared_txn.h"
 #include "utilities/transactions/write_unprepared_txn_db.h"
@@ -729,4 +728,3 @@ int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-

package/deps/rocksdb/rocksdb/utilities/transactions/write_unprepared_txn.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-
 #include "utilities/transactions/write_unprepared_txn.h"
 
 #include "db/db_impl/db_impl.h"
@@ -375,7 +374,7 @@ Status WriteUnpreparedTxn::FlushWriteBatchToDBInternal(bool prepared) {
   uint64_t seq_used = kMaxSequenceNumber;
   // log_number_ should refer to the oldest log containing uncommitted data
   // from the current transaction. This means that if log_number_ is set,
-  // WriteImpl should not overwrite that value, so set log_used to nullptr if
+  // WriteImpl should not overwrite that value, so set wal_used to nullptr if
   // log_number_ is already set.
   s = db_impl_->WriteImpl(write_options, GetWriteBatch()->GetWriteBatch(),
                           /*callback*/ nullptr, /*user_write_cb=*/nullptr,

package/deps/rocksdb/rocksdb/utilities/transactions/write_unprepared_txn.h

@@ -5,7 +5,6 @@
 
 #pragma once
 
-
 #include <set>
 
 #include "utilities/transactions/write_prepared_txn.h"
@@ -272,7 +271,7 @@ class WriteUnpreparedTxn : public WritePreparedTxn {
 
     SavePoint(const std::map<SequenceNumber, size_t>& seqs,
               ManagedSnapshot* snapshot)
-        : unprep_seqs_(seqs), snapshot_(snapshot){}
+        : unprep_seqs_(seqs), snapshot_(snapshot) {}
   };
 
   // We have 3 data structures holding savepoint information:

package/deps/rocksdb/rocksdb/utilities/transactions/write_unprepared_txn_db.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-
 #include "utilities/transactions/write_unprepared_txn_db.h"
 
 #include "db/arena_wrapped_db_iter.h"

package/deps/rocksdb/rocksdb/utilities/ttl/ttl_test.cc

@@ -3,7 +3,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
-
 #include <map>
 #include <memory>
 
@@ -618,7 +617,6 @@ TEST_F(TtlTest, UnregisteredMergeOperator) {
    public:
     const char* Name() const override { return "UnregisteredMergeOperator"; }
   };
-  options_.fail_if_options_file_error = true;
   options_.merge_operator = std::make_shared<UnregisteredMergeOperator>();
   OpenTtl();
   CloseTtl();
@@ -931,4 +929,3 @@ int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-

package/deps/rocksdb/rocksdb/utilities/write_batch_with_index/write_batch_with_index.cc

@@ -15,8 +15,6 @@
 #include "db/merge_helper.h"
 #include "db/wide/wide_columns_helper.h"
 #include "memory/arena.h"
-#include "memtable/skiplist.h"
-#include "options/db_options.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/iterator.h"
 #include "util/cast_util.h"
@@ -32,17 +30,13 @@ struct WriteBatchWithIndex::Rep {
                     index_comparator ? index_comparator->timestamp_size() : 0),
         comparator(index_comparator, &write_batch),
         skip_list(comparator, &arena),
-        overwrite_key(_overwrite_key),
-        last_entry_offset(0),
         last_sub_batch_offset(0),
         sub_batch_cnt(1),
-        track_cf_stat(false) {}
+        overwrite_key(_overwrite_key) {}
   ReadableWriteBatch write_batch;
   WriteBatchEntryComparator comparator;
   Arena arena;
   WriteBatchEntrySkipList skip_list;
-  bool overwrite_key;
-  size_t last_entry_offset;
   // The starting offset of the last sub-batch. A sub-batch starts right before
   // inserting a key that is a duplicate of a key in the last sub-batch. Zero,
   // the default, means that no duplicate key is detected so far.
@@ -50,32 +44,51 @@ struct WriteBatchWithIndex::Rep {
   // Total number of sub-batches in the write batch. Default is 1.
   size_t sub_batch_cnt;
 
-  bool track_cf_stat;
+  const bool overwrite_key;
   // Tracks ids of CFs that have updates in this WBWI, number of updates and
-  // number of overwritten single deletions per cf.
+  // number of overwritten single deletions per cf. Useful for WBWIMemTable
+  // when this WBWI is ingested into a DB.
   std::unordered_map<uint32_t, CFStat> cf_id_to_stat;
 
-  // Remember current offset of internal write batch, which is used as
-  // the starting offset of the next record.
-  void SetLastEntryOffset() { last_entry_offset = write_batch.GetDataSize(); }
-
   // In overwrite mode, find the existing entry for the same key and update it
-  // to point to the current entry.
+  // to point to the current entry if this is not a Merge operation.
   // Return true if the key is found and updated.
-  bool UpdateExistingEntry(ColumnFamilyHandle* column_family, const Slice& key,
-                           WriteType type);
+  // most_recent_entry_update_count will be set to the update count of the
+  // most recent index entry for `key` if exists.
   bool UpdateExistingEntryWithCfId(uint32_t column_family_id, const Slice& key,
-                                   WriteType type);
+                                   WriteType type, size_t last_entry_offset,
+                                   uint32_t* most_recent_entry_update_count);
+
+  // Add or update the index for the given `key` of `type`
+  // at `last_entry_offset` in the write batch.
+  //
+  // The index is updated in place if this WBWI is in overwrite mode
+  // and this is not a Merge operation.
+  //
+  // If `cf_cmp` is provided and there is no compartor stored
+  // for this cf, it will be stored as the comparator to use for this cf.
+  void AddOrUpdateIndexWithCfId(uint32_t cf_id, const Slice& key,
+                                WriteType type, size_t last_entry_offset,
+                                const Comparator* cf_cmp = nullptr);
+
+  void AddOrUpdateIndex(ColumnFamilyHandle* cfh, const Slice& key,
+                        WriteType type, size_t last_entry_offset) {
+    AddOrUpdateIndexWithCfId(GetColumnFamilyID(cfh), key, type,
+                             last_entry_offset,
+                             GetColumnFamilyUserComparator(cfh));
+  }
 
-  // Add the recent entry to the update.
-  // In overwrite mode, if key already exists in the index, update it.
-  void AddOrUpdateIndex(ColumnFamilyHandle* column_family, const Slice& key,
-                        WriteType type);
-  void AddOrUpdateIndex(const Slice& key, WriteType type);
+  void AddOrUpdateIndex(const Slice& key, WriteType type,
+                        size_t last_entry_offset) {
+    AddOrUpdateIndexWithCfId(0, key, type, last_entry_offset);
+  }
 
-  // Allocate an index entry pointing to the last entry in the write batch and
-  // put it to skip list.
-  void AddNewEntry(uint32_t column_family_id, WriteType type);
+  // Add a new index entry pointing to the the entry at `last_entry_offset`
+  // in the write batch. `most_recent_entry_update_count` will be used to
+  // initialize the update count of the new index entry.
+  void AddNewEntry(uint32_t column_family_id, WriteType type,
+                   size_t last_entry_offset,
+                   uint32_t most_recent_entry_update_count);
 
   // Clear all updates buffered in this batch.
   void Clear();
@@ -86,14 +99,10 @@ struct WriteBatchWithIndex::Rep {
   Status ReBuildIndex();
 };
 
-bool WriteBatchWithIndex::Rep::UpdateExistingEntry(
-    ColumnFamilyHandle* column_family, const Slice& key, WriteType type) {
-  uint32_t cf_id = GetColumnFamilyID(column_family);
-  return UpdateExistingEntryWithCfId(cf_id, key, type);
-}
-
 bool WriteBatchWithIndex::Rep::UpdateExistingEntryWithCfId(
-    uint32_t column_family_id, const Slice& key, WriteType type) {
+    uint32_t column_family_id, const Slice& key, WriteType type,
+    size_t last_entry_offset, uint32_t* most_recent_entry_update_count) {
+  assert(most_recent_entry_update_count);
   if (!overwrite_key) {
     return false;
   }
@@ -105,60 +114,60 @@ bool WriteBatchWithIndex::Rep::UpdateExistingEntryWithCfId(
     return false;
   } else if (!iter.MatchesKey(column_family_id, key)) {
     return false;
-  } else {
-    // Move to the end of this key (NextKey-Prev)
-    iter.NextKey();  // Move to the next key
-    if (iter.Valid()) {
-      iter.Prev();  // Move back one entry
-    } else {
-      iter.SeekToLast();
-    }
   }
-  WriteBatchIndexEntry* non_const_entry =
+  // Seek() and MatchesKey() guarantees that we are at the first entry with
+  // key == `key`, which is the most recently update to `key`.
+  WriteBatchIndexEntry* most_recent_entry =
       const_cast<WriteBatchIndexEntry*>(iter.GetRawEntry());
-  if (LIKELY(last_sub_batch_offset <= non_const_entry->offset)) {
+  *most_recent_entry_update_count = most_recent_entry->update_count;
+
+  if (LIKELY(last_sub_batch_offset <= most_recent_entry->offset)) {
     last_sub_batch_offset = last_entry_offset;
     sub_batch_cnt++;
   }
-  if (track_cf_stat) {
-    if (non_const_entry->has_single_del &&
-        !non_const_entry->has_overwritten_single_del) {
-      cf_id_to_stat[column_family_id].overwritten_sd_count++;
-      non_const_entry->has_overwritten_single_del = true;
-    }
-    if (type == kSingleDeleteRecord) {
-      non_const_entry->has_single_del = true;
-    }
+  if (most_recent_entry->has_single_del &&
+      !most_recent_entry->has_overwritten_single_del) {
+    cf_id_to_stat[column_family_id].overwritten_sd_count++;
+    most_recent_entry->has_overwritten_single_del = true;
+  }
+  if (type == kSingleDeleteRecord) {
+    most_recent_entry->has_single_del = true;
+  }
+  // Some sanity check for using Merge and SD on the same key.
+  if (iter.Entry().type == kSingleDeleteRecord) {
+    assert(type != kMergeRecord);
   }
   if (type == kMergeRecord) {
+    assert(iter.Entry().type != kSingleDeleteRecord);
     return false;
   } else {
-    non_const_entry->offset = last_entry_offset;
+    // We still increment the update count when updating in-place. This is
+    // useful for WBWIMemTable when it needs to emit overwritten SingleDeletes.
+    // The overwritten SingleDelete will be assigned sequence number as if
+    // update_count is 0. So any later update should have update_count > 0.
+    most_recent_entry->update_count++;
+    most_recent_entry->offset = last_entry_offset;
     return true;
   }
 }
 
-void WriteBatchWithIndex::Rep::AddOrUpdateIndex(
-    ColumnFamilyHandle* column_family, const Slice& key, WriteType type) {
-  if (!UpdateExistingEntry(column_family, key, type)) {
-    uint32_t cf_id = GetColumnFamilyID(column_family);
-    const auto* cf_cmp = GetColumnFamilyUserComparator(column_family);
-    if (cf_cmp != nullptr) {
+void WriteBatchWithIndex::Rep::AddOrUpdateIndexWithCfId(
+    uint32_t cf_id, const Slice& key, WriteType type, size_t last_entry_offset,
+    const Comparator* cf_cmp) {
+  uint32_t update_count = 0;
+  if (!UpdateExistingEntryWithCfId(cf_id, key, type, last_entry_offset,
+                                   &update_count)) {
+    if (cf_cmp) {
       comparator.SetComparatorForCF(cf_id, cf_cmp);
     }
-    AddNewEntry(cf_id, type);
-  }
-}
-
-void WriteBatchWithIndex::Rep::AddOrUpdateIndex(const Slice& key,
-                                                WriteType type) {
-  if (!UpdateExistingEntryWithCfId(0, key, type)) {
-    AddNewEntry(0, type);
+    AddNewEntry(cf_id, type, last_entry_offset, update_count + 1);
   }
 }
 
 void WriteBatchWithIndex::Rep::AddNewEntry(uint32_t column_family_id,
-                                           WriteType type) {
+                                           WriteType type,
+                                           size_t last_entry_offset,
+                                           uint32_t update_count) {
   const std::string& wb_data = write_batch.Data();
   Slice entry_ptr = Slice(wb_data.data() + last_entry_offset,
                           wb_data.size() - last_entry_offset);
@@ -179,17 +188,15 @@ void WriteBatchWithIndex::Rep::AddNewEntry(uint32_t column_family_id,
   }
 
   auto* mem = arena.Allocate(sizeof(WriteBatchIndexEntry));
-  auto* index_entry =
-      new (mem) WriteBatchIndexEntry(last_entry_offset, column_family_id,
-                                     key.data() - wb_data.data(), key.size());
+  auto* index_entry = new (mem) WriteBatchIndexEntry(
+      last_entry_offset, column_family_id, key.data() - wb_data.data(),
+      key.size(), update_count);
   skip_list.Insert(index_entry);
 
-  if (track_cf_stat) {
-    if (type == kSingleDeleteRecord) {
-      index_entry->has_single_del = true;
-    }
-    cf_id_to_stat[column_family_id].entry_count++;
+  if (type == kSingleDeleteRecord) {
+    index_entry->has_single_del = true;
   }
+  cf_id_to_stat[column_family_id].entry_count++;
 }
 
 void WriteBatchWithIndex::Rep::Clear() {
@@ -203,7 +210,6 @@ void WriteBatchWithIndex::Rep::ClearIndex() {
   arena.~Arena();
   new (&arena) Arena();
   new (&skip_list) WriteBatchEntrySkipList(comparator, &arena);
-  last_entry_offset = 0;
   last_sub_batch_offset = 0;
   sub_batch_cnt = 1;
 }
@@ -232,7 +238,7 @@ Status WriteBatchWithIndex::Rep::ReBuildIndex() {
     char tag = 0;
 
     // set offset of current entry for call to AddNewEntry()
-    last_entry_offset = input.data() - write_batch.Data().data();
+    size_t last_entry_offset = input.data() - write_batch.Data().data();
 
     s = ReadRecordFromWriteBatch(&input, &tag, &column_family_id, &key, &value,
                                  &blob, &xid, &unix_write_time);
@@ -244,32 +250,26 @@ Status WriteBatchWithIndex::Rep::ReBuildIndex() {
       case kTypeColumnFamilyValue:
       case kTypeValue:
         found++;
-        if (!UpdateExistingEntryWithCfId(column_family_id, key, kPutRecord)) {
-          AddNewEntry(column_family_id, kPutRecord);
-        }
+        AddOrUpdateIndexWithCfId(column_family_id, key, kPutRecord,
+                                 last_entry_offset);
         break;
       case kTypeColumnFamilyDeletion:
       case kTypeDeletion:
         found++;
-        if (!UpdateExistingEntryWithCfId(column_family_id, key,
-                                         kDeleteRecord)) {
-          AddNewEntry(column_family_id, kDeleteRecord);
-        }
+        AddOrUpdateIndexWithCfId(column_family_id, key, kDeleteRecord,
+                                 last_entry_offset);
         break;
       case kTypeColumnFamilySingleDeletion:
       case kTypeSingleDeletion:
         found++;
-        if (!UpdateExistingEntryWithCfId(column_family_id, key,
-                                         kSingleDeleteRecord)) {
-          AddNewEntry(column_family_id, kSingleDeleteRecord);
-        }
+        AddOrUpdateIndexWithCfId(column_family_id, key, kSingleDeleteRecord,
+                                 last_entry_offset);
         break;
       case kTypeColumnFamilyMerge:
       case kTypeMerge:
         found++;
-        if (!UpdateExistingEntryWithCfId(column_family_id, key, kMergeRecord)) {
-          AddNewEntry(column_family_id, kMergeRecord);
-        }
+        AddOrUpdateIndexWithCfId(column_family_id, key, kMergeRecord,
+                                 last_entry_offset);
         break;
       case kTypeLogData:
       case kTypeBeginPrepareXID:
@@ -284,10 +284,8 @@ Status WriteBatchWithIndex::Rep::ReBuildIndex() {
       case kTypeColumnFamilyWideColumnEntity:
       case kTypeWideColumnEntity:
         found++;
-        if (!UpdateExistingEntryWithCfId(column_family_id, key,
-                                         kPutEntityRecord)) {
-          AddNewEntry(column_family_id, kPutEntityRecord);
-        }
+        AddOrUpdateIndexWithCfId(column_family_id, key, kPutEntityRecord,
+                                 last_entry_offset);
         break;
       case kTypeColumnFamilyValuePreferredSeqno:
       case kTypeValuePreferredSeqno:
@@ -363,10 +361,19 @@ Iterator* WriteBatchWithIndex::NewIteratorWithBase(
                                read_options);
 }
 
-Iterator* WriteBatchWithIndex::NewIteratorWithBase(Iterator* base_iterator) {
+Iterator* WriteBatchWithIndex::NewIteratorWithBase(
+    Iterator* base_iterator, const ReadOptions* read_options) {
+  WBWIIteratorImpl* wbwiii;
   // default column family's comparator
-  auto wbwiii = new WBWIIteratorImpl(0, &(rep->skip_list), &rep->write_batch,
-                                     &rep->comparator);
+  if (read_options != nullptr) {
+    wbwiii = new WBWIIteratorImpl(
+        0, &(rep->skip_list), &rep->write_batch, &rep->comparator,
+        read_options->iterate_lower_bound, read_options->iterate_upper_bound);
+  } else {
+    wbwiii = new WBWIIteratorImpl(0, &(rep->skip_list), &rep->write_batch,
+                                  &rep->comparator);
+  }
+
   return new BaseDeltaIterator(nullptr, base_iterator, wbwiii,
                                rep->comparator.default_comparator(),
                                /* read_options */ nullptr);
@@ -374,19 +381,19 @@ Iterator* WriteBatchWithIndex::NewIteratorWithBase(Iterator* base_iterator) {
 
 Status WriteBatchWithIndex::Put(ColumnFamilyHandle* column_family,
                                 const Slice& key, const Slice& value) {
-  rep->SetLastEntryOffset();
+  size_t last_entry_offset = rep->write_batch.GetDataSize();
   auto s = rep->write_batch.Put(column_family, key, value);
   if (s.ok()) {
-    rep->AddOrUpdateIndex(column_family, key, kPutRecord);
+    rep->AddOrUpdateIndex(column_family, key, kPutRecord, last_entry_offset);
   }
   return s;
 }
 
 Status WriteBatchWithIndex::Put(const Slice& key, const Slice& value) {
-  rep->SetLastEntryOffset();
+  size_t last_entry_offset = rep->write_batch.GetDataSize();
   auto s = rep->write_batch.Put(key, value);
   if (s.ok()) {
-    rep->AddOrUpdateIndex(key, kPutRecord);
+    rep->AddOrUpdateIndex(key, kPutRecord, last_entry_offset);
   }
   return s;
 }
@@ -405,33 +412,30 @@ Status WriteBatchWithIndex::PutEntity(ColumnFamilyHandle* column_family,
                                       const Slice& key,
                                       const WideColumns& columns) {
   assert(rep);
-
-  rep->SetLastEntryOffset();
-
+  size_t last_entry_offset = rep->write_batch.GetDataSize();
   const Status s = rep->write_batch.PutEntity(column_family, key, columns);
-
   if (s.ok()) {
-    rep->AddOrUpdateIndex(column_family, key, kPutEntityRecord);
+    rep->AddOrUpdateIndex(column_family, key, kPutEntityRecord,
+                          last_entry_offset);
   }
-
   return s;
 }
 
 Status WriteBatchWithIndex::Delete(ColumnFamilyHandle* column_family,
                                    const Slice& key) {
-  rep->SetLastEntryOffset();
+  size_t last_entry_offset = rep->write_batch.GetDataSize();
   auto s = rep->write_batch.Delete(column_family, key);
   if (s.ok()) {
-    rep->AddOrUpdateIndex(column_family, key, kDeleteRecord);
+    rep->AddOrUpdateIndex(column_family, key, kDeleteRecord, last_entry_offset);
   }
   return s;
 }
 
 Status WriteBatchWithIndex::Delete(const Slice& key) {
-  rep->SetLastEntryOffset();
+  size_t last_entry_offset = rep->write_batch.GetDataSize();
   auto s = rep->write_batch.Delete(key);
   if (s.ok()) {
-    rep->AddOrUpdateIndex(key, kDeleteRecord);
+    rep->AddOrUpdateIndex(key, kDeleteRecord, last_entry_offset);
   }
   return s;
 }
@@ -447,19 +451,20 @@ Status WriteBatchWithIndex::Delete(ColumnFamilyHandle* column_family,
 
 Status WriteBatchWithIndex::SingleDelete(ColumnFamilyHandle* column_family,
                                          const Slice& key) {
-  rep->SetLastEntryOffset();
+  size_t last_entry_offset = rep->write_batch.GetDataSize();
   auto s = rep->write_batch.SingleDelete(column_family, key);
   if (s.ok()) {
-    rep->AddOrUpdateIndex(column_family, key, kSingleDeleteRecord);
+    rep->AddOrUpdateIndex(column_family, key, kSingleDeleteRecord,
+                          last_entry_offset);
   }
   return s;
 }
 
 Status WriteBatchWithIndex::SingleDelete(const Slice& key) {
-  rep->SetLastEntryOffset();
+  size_t last_entry_offset = rep->write_batch.GetDataSize();
   auto s = rep->write_batch.SingleDelete(key);
   if (s.ok()) {
-    rep->AddOrUpdateIndex(key, kSingleDeleteRecord);
+    rep->AddOrUpdateIndex(key, kSingleDeleteRecord, last_entry_offset);
   }
   return s;
 }
@@ -476,19 +481,19 @@ Status WriteBatchWithIndex::SingleDelete(ColumnFamilyHandle* column_family,
 
 Status WriteBatchWithIndex::Merge(ColumnFamilyHandle* column_family,
                                   const Slice& key, const Slice& value) {
-  rep->SetLastEntryOffset();
+  size_t last_entry_offset = rep->write_batch.GetDataSize();
   auto s = rep->write_batch.Merge(column_family, key, value);
   if (s.ok()) {
-    rep->AddOrUpdateIndex(column_family, key, kMergeRecord);
+    rep->AddOrUpdateIndex(column_family, key, kMergeRecord, last_entry_offset);
   }
   return s;
 }
 
 Status WriteBatchWithIndex::Merge(const Slice& key, const Slice& value) {
-  rep->SetLastEntryOffset();
+  size_t last_entry_offset = rep->write_batch.GetDataSize();
   auto s = rep->write_batch.Merge(key, value);
   if (s.ok()) {
-    rep->AddOrUpdateIndex(key, kMergeRecord);
+    rep->AddOrUpdateIndex(key, kMergeRecord, last_entry_offset);
   }
   return s;
 }
@@ -1163,15 +1168,8 @@ const Comparator* WriteBatchWithIndexInternal::GetUserComparator(
   return ucmps.GetComparator(cf_id);
 }
 
-void WriteBatchWithIndex::SetTrackPerCFStat(bool track) {
-  // Should be set when the wbwi contains no update.
-  assert(GetWriteBatch()->Count() == 0);
-  rep->track_cf_stat = track;
-}
-
 const std::unordered_map<uint32_t, WriteBatchWithIndex::CFStat>&
 WriteBatchWithIndex::GetCFStats() const {
-  assert(rep->track_cf_stat);
   return rep->cf_id_to_stat;
 }