@nxtedition/rocksdb 5.2.21 → 5.2.28

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

@@ -10,15 +10,19 @@
 #ifndef ROCKSDB_LITE
 
 #include "rocksdb/utilities/write_batch_with_index.h"
+
 #include <map>
 #include <memory>
+
 #include "db/column_family.h"
 #include "port/stack_trace.h"
 #include "test_util/testharness.h"
+#include "test_util/testutil.h"
 #include "util/random.h"
 #include "util/string_util.h"
 #include "utilities/merge_operators.h"
 #include "utilities/merge_operators/string_append/stringappend.h"
+#include "utilities/write_batch_with_index/write_batch_with_index_internal.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -73,9 +77,242 @@ struct TestHandler : public WriteBatch::Handler {
     return Status::OK();
   }
 };
+
+using KVMap = std::map<std::string, std::string>;
+
+class KVIter : public Iterator {
+ public:
+  explicit KVIter(const KVMap* map) : map_(map), iter_(map_->end()) {}
+  bool Valid() const override { return iter_ != map_->end(); }
+  void SeekToFirst() override { iter_ = map_->begin(); }
+  void SeekToLast() override {
+    if (map_->empty()) {
+      iter_ = map_->end();
+    } else {
+      iter_ = map_->find(map_->rbegin()->first);
+    }
+  }
+  void Seek(const Slice& k) override {
+    iter_ = map_->lower_bound(k.ToString());
+  }
+  void SeekForPrev(const Slice& k) override {
+    iter_ = map_->upper_bound(k.ToString());
+    Prev();
+  }
+  void Next() override { ++iter_; }
+  void Prev() override {
+    if (iter_ == map_->begin()) {
+      iter_ = map_->end();
+      return;
+    }
+    --iter_;
+  }
+  Slice key() const override { return iter_->first; }
+  Slice value() const override { return iter_->second; }
+  Status status() const override { return Status::OK(); }
+
+ private:
+  const KVMap* const map_;
+  KVMap::const_iterator iter_;
+};
+
+static std::string PrintContents(WriteBatchWithIndex* batch,
+                                 ColumnFamilyHandle* column_family,
+                                 bool hex = false) {
+  std::string result;
+
+  WBWIIterator* iter;
+  if (column_family == nullptr) {
+    iter = batch->NewIterator();
+  } else {
+    iter = batch->NewIterator(column_family);
+  }
+
+  iter->SeekToFirst();
+  while (iter->Valid()) {
+    WriteEntry e = iter->Entry();
+
+    if (e.type == kPutRecord) {
+      result.append("PUT(");
+      result.append(e.key.ToString(hex));
+      result.append("):");
+      result.append(e.value.ToString(hex));
+    } else if (e.type == kMergeRecord) {
+      result.append("MERGE(");
+      result.append(e.key.ToString(hex));
+      result.append("):");
+      result.append(e.value.ToString(hex));
+    } else if (e.type == kSingleDeleteRecord) {
+      result.append("SINGLE-DEL(");
+      result.append(e.key.ToString(hex));
+      result.append(")");
+    } else {
+      assert(e.type == kDeleteRecord);
+      result.append("DEL(");
+      result.append(e.key.ToString(hex));
+      result.append(")");
+    }
+
+    result.append(",");
+    iter->Next();
+  }
+
+  delete iter;
+  return result;
+}
+
+static std::string PrintContents(WriteBatchWithIndex* batch, KVMap* base_map,
+                                 ColumnFamilyHandle* column_family) {
+  std::string result;
+
+  Iterator* iter;
+  if (column_family == nullptr) {
+    iter = batch->NewIteratorWithBase(new KVIter(base_map));
+  } else {
+    iter = batch->NewIteratorWithBase(column_family, new KVIter(base_map));
+  }
+
+  iter->SeekToFirst();
+  while (iter->Valid()) {
+    assert(iter->status().ok());
+
+    Slice key = iter->key();
+    Slice value = iter->value();
+
+    result.append(key.ToString());
+    result.append(":");
+    result.append(value.ToString());
+    result.append(",");
+
+    iter->Next();
+  }
+
+  delete iter;
+  return result;
+}
+
+void AssertIter(Iterator* iter, const std::string& key,
+                const std::string& value) {
+  ASSERT_OK(iter->status());
+  ASSERT_TRUE(iter->Valid());
+  ASSERT_EQ(key, iter->key().ToString());
+  ASSERT_EQ(value, iter->value().ToString());
+}
+
+void AssertItersMatch(Iterator* iter1, Iterator* iter2) {
+  ASSERT_EQ(iter1->Valid(), iter2->Valid());
+  if (iter1->Valid()) {
+    ASSERT_EQ(iter1->key().ToString(), iter2->key().ToString());
+    ASSERT_EQ(iter1->value().ToString(), iter2->value().ToString());
+  }
+}
+
+void AssertItersEqual(Iterator* iter1, Iterator* iter2) {
+  iter1->SeekToFirst();
+  iter2->SeekToFirst();
+  while (iter1->Valid()) {
+    ASSERT_EQ(iter1->Valid(), iter2->Valid());
+    ASSERT_EQ(iter1->key().ToString(), iter2->key().ToString());
+    ASSERT_EQ(iter1->value().ToString(), iter2->value().ToString());
+    iter1->Next();
+    iter2->Next();
+  }
+  ASSERT_EQ(iter1->Valid(), iter2->Valid());
+}
+
+void AssertIterEqual(WBWIIteratorImpl* wbwii,
+                     const std::vector<std::string>& keys) {
+  wbwii->SeekToFirst();
+  for (auto k : keys) {
+    ASSERT_TRUE(wbwii->Valid());
+    ASSERT_EQ(wbwii->Entry().key, k);
+    wbwii->NextKey();
+  }
+  ASSERT_FALSE(wbwii->Valid());
+  wbwii->SeekToLast();
+  for (auto kit = keys.rbegin(); kit != keys.rend(); ++kit) {
+    ASSERT_TRUE(wbwii->Valid());
+    ASSERT_EQ(wbwii->Entry().key, *kit);
+    wbwii->PrevKey();
+  }
+  ASSERT_FALSE(wbwii->Valid());
+}
 }  // namespace anonymous
 
-class WriteBatchWithIndexTest : public testing::Test {};
+class WBWIBaseTest : public testing::Test {
+ public:
+  explicit WBWIBaseTest(bool overwrite) : db_(nullptr) {
+    options_.merge_operator =
+        MergeOperators::CreateFromStringId("stringappend");
+    options_.create_if_missing = true;
+    dbname_ = test::PerThreadDBPath("write_batch_with_index_test");
+    DestroyDB(dbname_, options_);
+    batch_.reset(new WriteBatchWithIndex(BytewiseComparator(), 20, overwrite));
+  }
+
+  virtual ~WBWIBaseTest() {
+    if (db_ != nullptr) {
+      ReleaseSnapshot();
+      delete db_;
+      DestroyDB(dbname_, options_);
+    }
+  }
+
+  std::string AddToBatch(ColumnFamilyHandle* cf, const std::string& key) {
+    std::string result;
+    for (size_t i = 0; i < key.size(); i++) {
+      if (key[i] == 'd') {
+        batch_->Delete(cf, key);
+        result = "";
+      } else if (key[i] == 'p') {
+        result = key + ToString(i);
+        batch_->Put(cf, key, result);
+      } else if (key[i] == 'm') {
+        std::string value = key + ToString(i);
+        batch_->Merge(cf, key, value);
+        if (result.empty()) {
+          result = value;
+        } else {
+          result = result + "," + value;
+        }
+      }
+    }
+    return result;
+  }
+
+  virtual Status OpenDB() { return DB::Open(options_, dbname_, &db_); }
+
+  void ReleaseSnapshot() {
+    if (read_opts_.snapshot != nullptr) {
+      EXPECT_NE(db_, nullptr);
+      db_->ReleaseSnapshot(read_opts_.snapshot);
+      read_opts_.snapshot = nullptr;
+    }
+  }
+
+ public:
+  DB* db_;
+  std::string dbname_;
+  Options options_;
+  WriteOptions write_opts_;
+  ReadOptions read_opts_;
+  std::unique_ptr<WriteBatchWithIndex> batch_;
+};
+
+class WBWIKeepTest : public WBWIBaseTest {
+ public:
+  WBWIKeepTest() : WBWIBaseTest(false) {}
+};
+
+class WBWIOverwriteTest : public WBWIBaseTest {
+ public:
+  WBWIOverwriteTest() : WBWIBaseTest(true) {}
+};
+class WriteBatchWithIndexTest : public WBWIBaseTest,
+                                public testing::WithParamInterface<bool> {
+ public:
+  WriteBatchWithIndexTest() : WBWIBaseTest(GetParam()) {}
+};
 
 void TestValueAsSecondaryIndexHelper(std::vector<Entry> entries,
                                      WriteBatchWithIndex* batch) {
@@ -273,7 +510,7 @@ void TestValueAsSecondaryIndexHelper(std::vector<Entry> entries,
   }
 }
 
-TEST_F(WriteBatchWithIndexTest, TestValueAsSecondaryIndex) {
+TEST_F(WBWIKeepTest, TestValueAsSecondaryIndex) {
   Entry entries[] = {
       {"aaa", "0005", kPutRecord},
       {"b", "0002", kPutRecord},
@@ -286,12 +523,12 @@ TEST_F(WriteBatchWithIndexTest, TestValueAsSecondaryIndex) {
   };
   std::vector<Entry> entries_list(entries, entries + 8);
 
-  WriteBatchWithIndex batch(nullptr, 20);
+  batch_.reset(new WriteBatchWithIndex(nullptr, 20, false));
 
-  TestValueAsSecondaryIndexHelper(entries_list, &batch);
+  TestValueAsSecondaryIndexHelper(entries_list, batch_.get());
 
   // Clear batch and re-run test with new values
-  batch.Clear();
+  batch_->Clear();
 
   Entry new_entries[] = {
       {"aaa", "0005", kPutRecord},
@@ -306,30 +543,29 @@ TEST_F(WriteBatchWithIndexTest, TestValueAsSecondaryIndex) {
 
   entries_list = std::vector<Entry>(new_entries, new_entries + 8);
 
-  TestValueAsSecondaryIndexHelper(entries_list, &batch);
+  TestValueAsSecondaryIndexHelper(entries_list, batch_.get());
 }
 
-TEST_F(WriteBatchWithIndexTest, TestComparatorForCF) {
+TEST_P(WriteBatchWithIndexTest, TestComparatorForCF) {
   ColumnFamilyHandleImplDummy cf1(6, nullptr);
   ColumnFamilyHandleImplDummy reverse_cf(66, ReverseBytewiseComparator());
   ColumnFamilyHandleImplDummy cf2(88, BytewiseComparator());
-  WriteBatchWithIndex batch(BytewiseComparator(), 20);
 
-  ASSERT_OK(batch.Put(&cf1, "ddd", ""));
-  ASSERT_OK(batch.Put(&cf2, "aaa", ""));
-  ASSERT_OK(batch.Put(&cf2, "eee", ""));
-  ASSERT_OK(batch.Put(&cf1, "ccc", ""));
-  ASSERT_OK(batch.Put(&reverse_cf, "a11", ""));
-  ASSERT_OK(batch.Put(&cf1, "bbb", ""));
+  ASSERT_OK(batch_->Put(&cf1, "ddd", ""));
+  ASSERT_OK(batch_->Put(&cf2, "aaa", ""));
+  ASSERT_OK(batch_->Put(&cf2, "eee", ""));
+  ASSERT_OK(batch_->Put(&cf1, "ccc", ""));
+  ASSERT_OK(batch_->Put(&reverse_cf, "a11", ""));
+  ASSERT_OK(batch_->Put(&cf1, "bbb", ""));
 
   Slice key_slices[] = {"a", "3", "3"};
   Slice value_slice = "";
-  ASSERT_OK(batch.Put(&reverse_cf, SliceParts(key_slices, 3),
-                      SliceParts(&value_slice, 1)));
-  ASSERT_OK(batch.Put(&reverse_cf, "a22", ""));
+  ASSERT_OK(batch_->Put(&reverse_cf, SliceParts(key_slices, 3),
+                        SliceParts(&value_slice, 1)));
+  ASSERT_OK(batch_->Put(&reverse_cf, "a22", ""));
 
   {
-    std::unique_ptr<WBWIIterator> iter(batch.NewIterator(&cf1));
+    std::unique_ptr<WBWIIterator> iter(batch_->NewIterator(&cf1));
     iter->Seek("");
     ASSERT_OK(iter->status());
     ASSERT_TRUE(iter->Valid());
@@ -348,7 +584,7 @@ TEST_F(WriteBatchWithIndexTest, TestComparatorForCF) {
   }
 
   {
-    std::unique_ptr<WBWIIterator> iter(batch.NewIterator(&cf2));
+    std::unique_ptr<WBWIIterator> iter(batch_->NewIterator(&cf2));
     iter->Seek("");
     ASSERT_OK(iter->status());
     ASSERT_TRUE(iter->Valid());
@@ -363,7 +599,7 @@ TEST_F(WriteBatchWithIndexTest, TestComparatorForCF) {
   }
 
   {
-    std::unique_ptr<WBWIIterator> iter(batch.NewIterator(&reverse_cf));
+    std::unique_ptr<WBWIIterator> iter(batch_->NewIterator(&reverse_cf));
     iter->Seek("");
     ASSERT_OK(iter->status());
     ASSERT_TRUE(!iter->Valid());
@@ -396,29 +632,28 @@ TEST_F(WriteBatchWithIndexTest, TestComparatorForCF) {
   }
 }
 
-TEST_F(WriteBatchWithIndexTest, TestOverwriteKey) {
+TEST_F(WBWIOverwriteTest, TestOverwriteKey) {
   ColumnFamilyHandleImplDummy cf1(6, nullptr);
   ColumnFamilyHandleImplDummy reverse_cf(66, ReverseBytewiseComparator());
   ColumnFamilyHandleImplDummy cf2(88, BytewiseComparator());
-  WriteBatchWithIndex batch(BytewiseComparator(), 20, true);
-
-  ASSERT_OK(batch.Put(&cf1, "ddd", ""));
-  ASSERT_OK(batch.Merge(&cf1, "ddd", ""));
-  ASSERT_OK(batch.Delete(&cf1, "ddd"));
-  ASSERT_OK(batch.Put(&cf2, "aaa", ""));
-  ASSERT_OK(batch.Delete(&cf2, "aaa"));
-  ASSERT_OK(batch.Put(&cf2, "aaa", "aaa"));
-  ASSERT_OK(batch.Put(&cf2, "eee", "eee"));
-  ASSERT_OK(batch.Put(&cf1, "ccc", ""));
-  ASSERT_OK(batch.Put(&reverse_cf, "a11", ""));
-  ASSERT_OK(batch.Delete(&cf1, "ccc"));
-  ASSERT_OK(batch.Put(&reverse_cf, "a33", "a33"));
-  ASSERT_OK(batch.Put(&reverse_cf, "a11", "a11"));
+
+  ASSERT_OK(batch_->Merge(&cf1, "ddd", ""));
+  ASSERT_OK(batch_->Put(&cf1, "ddd", ""));
+  ASSERT_OK(batch_->Delete(&cf1, "ddd"));
+  ASSERT_OK(batch_->Put(&cf2, "aaa", ""));
+  ASSERT_OK(batch_->Delete(&cf2, "aaa"));
+  ASSERT_OK(batch_->Put(&cf2, "aaa", "aaa"));
+  ASSERT_OK(batch_->Put(&cf2, "eee", "eee"));
+  ASSERT_OK(batch_->Put(&cf1, "ccc", ""));
+  ASSERT_OK(batch_->Put(&reverse_cf, "a11", ""));
+  ASSERT_OK(batch_->Delete(&cf1, "ccc"));
+  ASSERT_OK(batch_->Put(&reverse_cf, "a33", "a33"));
+  ASSERT_OK(batch_->Put(&reverse_cf, "a11", "a11"));
   Slice slices[] = {"a", "3", "3"};
-  ASSERT_OK(batch.Delete(&reverse_cf, SliceParts(slices, 3)));
+  ASSERT_OK(batch_->Delete(&reverse_cf, SliceParts(slices, 3)));
 
   {
-    std::unique_ptr<WBWIIterator> iter(batch.NewIterator(&cf1));
+    std::unique_ptr<WBWIIterator> iter(batch_->NewIterator(&cf1));
     iter->Seek("");
     ASSERT_OK(iter->status());
     ASSERT_TRUE(iter->Valid());
@@ -435,7 +670,7 @@ TEST_F(WriteBatchWithIndexTest, TestOverwriteKey) {
   }
 
   {
-    std::unique_ptr<WBWIIterator> iter(batch.NewIterator(&cf2));
+    std::unique_ptr<WBWIIterator> iter(batch_->NewIterator(&cf2));
     iter->SeekToLast();
     ASSERT_OK(iter->status());
     ASSERT_TRUE(iter->Valid());
@@ -466,7 +701,7 @@ TEST_F(WriteBatchWithIndexTest, TestOverwriteKey) {
   }
 
   {
-    std::unique_ptr<WBWIIterator> iter(batch.NewIterator(&reverse_cf));
+    std::unique_ptr<WBWIIterator> iter(batch_->NewIterator(&reverse_cf));
     iter->Seek("");
     ASSERT_OK(iter->status());
     ASSERT_TRUE(!iter->Valid());
@@ -500,64 +735,33 @@ TEST_F(WriteBatchWithIndexTest, TestOverwriteKey) {
   }
 }
 
-namespace {
-typedef std::map<std::string, std::string> KVMap;
-
-class KVIter : public Iterator {
- public:
-  explicit KVIter(const KVMap* map) : map_(map), iter_(map_->end()) {}
-  bool Valid() const override { return iter_ != map_->end(); }
-  void SeekToFirst() override { iter_ = map_->begin(); }
-  void SeekToLast() override {
-    if (map_->empty()) {
-      iter_ = map_->end();
-    } else {
-      iter_ = map_->find(map_->rbegin()->first);
-    }
-  }
-  void Seek(const Slice& k) override {
-    iter_ = map_->lower_bound(k.ToString());
-  }
-  void SeekForPrev(const Slice& k) override {
-    iter_ = map_->upper_bound(k.ToString());
-    Prev();
-  }
-  void Next() override { ++iter_; }
-  void Prev() override {
-    if (iter_ == map_->begin()) {
-      iter_ = map_->end();
-      return;
-    }
-    --iter_;
-  }
-
-  Slice key() const override { return iter_->first; }
-  Slice value() const override { return iter_->second; }
-  Status status() const override { return Status::OK(); }
-
- private:
-  const KVMap* const map_;
-  KVMap::const_iterator iter_;
-};
-
-void AssertIter(Iterator* iter, const std::string& key,
-                const std::string& value) {
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(key, iter->key().ToString());
-  ASSERT_EQ(value, iter->value().ToString());
-}
-
-void AssertItersEqual(Iterator* iter1, Iterator* iter2) {
-  ASSERT_EQ(iter1->Valid(), iter2->Valid());
-  if (iter1->Valid()) {
-    ASSERT_EQ(iter1->key().ToString(), iter2->key().ToString());
-    ASSERT_EQ(iter1->value().ToString(), iter2->value().ToString());
-  }
+TEST_P(WriteBatchWithIndexTest, TestWBWIIterator) {
+  ColumnFamilyHandleImplDummy cf1(1, BytewiseComparator());
+  ColumnFamilyHandleImplDummy cf2(2, BytewiseComparator());
+  ASSERT_OK(batch_->Put(&cf1, "a", "a1"));
+  ASSERT_OK(batch_->Put(&cf1, "c", "c1"));
+  ASSERT_OK(batch_->Put(&cf1, "c", "c2"));
+  ASSERT_OK(batch_->Put(&cf1, "e", "e1"));
+  ASSERT_OK(batch_->Put(&cf1, "e", "e2"));
+  ASSERT_OK(batch_->Put(&cf1, "e", "e3"));
+  std::unique_ptr<WBWIIteratorImpl> iter1(
+      static_cast<WBWIIteratorImpl*>(batch_->NewIterator(&cf1)));
+  std::unique_ptr<WBWIIteratorImpl> iter2(
+      static_cast<WBWIIteratorImpl*>(batch_->NewIterator(&cf2)));
+  AssertIterEqual(iter1.get(), {"a", "c", "e"});
+  AssertIterEqual(iter2.get(), {});
+  ASSERT_OK(batch_->Put(&cf2, "a", "a2"));
+  ASSERT_OK(batch_->Merge(&cf2, "b", "b1"));
+  ASSERT_OK(batch_->Merge(&cf2, "b", "b2"));
+  ASSERT_OK(batch_->Delete(&cf2, "d"));
+  ASSERT_OK(batch_->Merge(&cf2, "d", "d2"));
+  ASSERT_OK(batch_->Merge(&cf2, "d", "d3"));
+  ASSERT_OK(batch_->Delete(&cf2, "f"));
+  AssertIterEqual(iter1.get(), {"a", "c", "e"});
+  AssertIterEqual(iter2.get(), {"a", "b", "d", "f"});
 }
-}  // namespace
 
-TEST_F(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) {
+TEST_P(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) {
   std::vector<std::string> source_strings = {"a", "b", "c", "d", "e",
                                              "f", "g", "h", "i", "j"};
   for (int rand_seed = 301; rand_seed < 366; rand_seed++) {
@@ -566,14 +770,13 @@ TEST_F(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) {
     ColumnFamilyHandleImplDummy cf1(6, BytewiseComparator());
     ColumnFamilyHandleImplDummy cf2(2, BytewiseComparator());
     ColumnFamilyHandleImplDummy cf3(8, BytewiseComparator());
-
-    WriteBatchWithIndex batch(BytewiseComparator(), 20, true);
+    batch_->Clear();
 
     if (rand_seed % 2 == 0) {
-      ASSERT_OK(batch.Put(&cf2, "zoo", "bar"));
+      ASSERT_OK(batch_->Put(&cf2, "zoo", "bar"));
     }
     if (rand_seed % 4 == 1) {
-      ASSERT_OK(batch.Put(&cf3, "zoo", "bar"));
+      ASSERT_OK(batch_->Put(&cf3, "zoo", "bar"));
     }
 
     KVMap map;
@@ -589,24 +792,24 @@ TEST_F(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) {
           break;
         case 1:
           // only delta has it
-          ASSERT_OK(batch.Put(&cf1, key, value));
+          ASSERT_OK(batch_->Put(&cf1, key, value));
           map[key] = value;
           merged_map[key] = value;
           break;
         case 2:
           // both has it. Delta should win
-          ASSERT_OK(batch.Put(&cf1, key, value));
+          ASSERT_OK(batch_->Put(&cf1, key, value));
           map[key] = "wrong_value";
           merged_map[key] = value;
           break;
         case 3:
           // both has it. Delta is delete
-          ASSERT_OK(batch.Delete(&cf1, key));
+          ASSERT_OK(batch_->Delete(&cf1, key));
           map[key] = "wrong_value";
           break;
         case 4:
           // only delta has it. Delta is delete
-          ASSERT_OK(batch.Delete(&cf1, key));
+          ASSERT_OK(batch_->Delete(&cf1, key));
           map[key] = "wrong_value";
           break;
         default:
@@ -616,7 +819,7 @@ TEST_F(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) {
     }
 
     std::unique_ptr<Iterator> iter(
-        batch.NewIteratorWithBase(&cf1, new KVIter(&map)));
+        batch_->NewIteratorWithBase(&cf1, new KVIter(&map)));
     std::unique_ptr<Iterator> result_iter(new KVIter(&merged_map));
 
     bool is_valid = false;
@@ -672,7 +875,7 @@ TEST_F(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) {
           }
           break;
       }
-      AssertItersEqual(iter.get(), result_iter.get());
+      AssertItersMatch(iter.get(), result_iter.get());
       is_valid = iter->Valid();
     }
 
@@ -680,18 +883,16 @@ TEST_F(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) {
   }
 }
 
-TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBase) {
+TEST_P(WriteBatchWithIndexTest, TestIteraratorWithBase) {
   ColumnFamilyHandleImplDummy cf1(6, BytewiseComparator());
   ColumnFamilyHandleImplDummy cf2(2, BytewiseComparator());
-  WriteBatchWithIndex batch(BytewiseComparator(), 20, true);
-
   {
     KVMap map;
     map["a"] = "aa";
     map["c"] = "cc";
     map["e"] = "ee";
     std::unique_ptr<Iterator> iter(
-        batch.NewIteratorWithBase(&cf1, new KVIter(&map)));
+        batch_->NewIteratorWithBase(&cf1, new KVIter(&map)));
 
     iter->SeekToFirst();
     AssertIter(iter.get(), "a", "aa");
@@ -724,12 +925,12 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBase) {
   }
 
   // Test the case that there is one element in the write batch
-  ASSERT_OK(batch.Put(&cf2, "zoo", "bar"));
-  ASSERT_OK(batch.Put(&cf1, "a", "aa"));
+  ASSERT_OK(batch_->Put(&cf2, "zoo", "bar"));
+  ASSERT_OK(batch_->Put(&cf1, "a", "aa"));
   {
     KVMap empty_map;
     std::unique_ptr<Iterator> iter(
-        batch.NewIteratorWithBase(&cf1, new KVIter(&empty_map)));
+        batch_->NewIteratorWithBase(&cf1, new KVIter(&empty_map)));
 
     iter->SeekToFirst();
     AssertIter(iter.get(), "a", "aa");
@@ -738,10 +939,10 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBase) {
     ASSERT_TRUE(!iter->Valid());
   }
 
-  ASSERT_OK(batch.Delete(&cf1, "b"));
-  ASSERT_OK(batch.Put(&cf1, "c", "cc"));
-  ASSERT_OK(batch.Put(&cf1, "d", "dd"));
-  ASSERT_OK(batch.Delete(&cf1, "e"));
+  ASSERT_OK(batch_->Delete(&cf1, "b"));
+  ASSERT_OK(batch_->Put(&cf1, "c", "cc"));
+  ASSERT_OK(batch_->Put(&cf1, "d", "dd"));
+  ASSERT_OK(batch_->Delete(&cf1, "e"));
 
   {
     KVMap map;
@@ -749,7 +950,7 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBase) {
     map["cc"] = "cccc";
     map["f"] = "ff";
     std::unique_ptr<Iterator> iter(
-        batch.NewIteratorWithBase(&cf1, new KVIter(&map)));
+        batch_->NewIteratorWithBase(&cf1, new KVIter(&map)));
 
     iter->SeekToFirst();
     AssertIter(iter.get(), "a", "aa");
@@ -807,7 +1008,7 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBase) {
   {
     KVMap empty_map;
     std::unique_ptr<Iterator> iter(
-        batch.NewIteratorWithBase(&cf1, new KVIter(&empty_map)));
+        batch_->NewIteratorWithBase(&cf1, new KVIter(&empty_map)));
 
     iter->SeekToFirst();
     AssertIter(iter.get(), "a", "aa");
@@ -843,18 +1044,17 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBase) {
   }
 }
 
-TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBaseReverseCmp) {
+TEST_P(WriteBatchWithIndexTest, TestIteraratorWithBaseReverseCmp) {
   ColumnFamilyHandleImplDummy cf1(6, ReverseBytewiseComparator());
   ColumnFamilyHandleImplDummy cf2(2, ReverseBytewiseComparator());
-  WriteBatchWithIndex batch(BytewiseComparator(), 20, true);
 
   // Test the case that there is one element in the write batch
-  ASSERT_OK(batch.Put(&cf2, "zoo", "bar"));
-  ASSERT_OK(batch.Put(&cf1, "a", "aa"));
+  ASSERT_OK(batch_->Put(&cf2, "zoo", "bar"));
+  ASSERT_OK(batch_->Put(&cf1, "a", "aa"));
   {
     KVMap empty_map;
     std::unique_ptr<Iterator> iter(
-        batch.NewIteratorWithBase(&cf1, new KVIter(&empty_map)));
+        batch_->NewIteratorWithBase(&cf1, new KVIter(&empty_map)));
 
     iter->SeekToFirst();
     AssertIter(iter.get(), "a", "aa");
@@ -863,11 +1063,11 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBaseReverseCmp) {
     ASSERT_TRUE(!iter->Valid());
   }
 
-  ASSERT_OK(batch.Put(&cf1, "c", "cc"));
+  ASSERT_OK(batch_->Put(&cf1, "c", "cc"));
   {
     KVMap map;
     std::unique_ptr<Iterator> iter(
-        batch.NewIteratorWithBase(&cf1, new KVIter(&map)));
+        batch_->NewIteratorWithBase(&cf1, new KVIter(&map)));
 
     iter->SeekToFirst();
     AssertIter(iter.get(), "c", "cc");
@@ -896,11 +1096,12 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBaseReverseCmp) {
   }
 
   // default column family
-  ASSERT_OK(batch.Put("a", "b"));
+  ASSERT_OK(batch_->Put("a", "b"));
   {
     KVMap map;
     map["b"] = "";
-    std::unique_ptr<Iterator> iter(batch.NewIteratorWithBase(new KVIter(&map)));
+    std::unique_ptr<Iterator> iter(
+        batch_->NewIteratorWithBase(new KVIter(&map)));
 
     iter->SeekToFirst();
     AssertIter(iter.get(), "a", "b");
@@ -929,416 +1130,331 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBaseReverseCmp) {
   }
 }
 
-TEST_F(WriteBatchWithIndexTest, TestGetFromBatch) {
+TEST_P(WriteBatchWithIndexTest, TestGetFromBatch) {
   Options options;
-  WriteBatchWithIndex batch;
   Status s;
   std::string value;
 
-  s = batch.GetFromBatch(options, "b", &value);
+  s = batch_->GetFromBatch(options_, "b", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  ASSERT_OK(batch.Put("a", "a"));
-  ASSERT_OK(batch.Put("b", "b"));
-  ASSERT_OK(batch.Put("c", "c"));
-  ASSERT_OK(batch.Put("a", "z"));
-  ASSERT_OK(batch.Delete("c"));
-  ASSERT_OK(batch.Delete("d"));
-  ASSERT_OK(batch.Delete("e"));
-  ASSERT_OK(batch.Put("e", "e"));
+  ASSERT_OK(batch_->Put("a", "a"));
+  ASSERT_OK(batch_->Put("b", "b"));
+  ASSERT_OK(batch_->Put("c", "c"));
+  ASSERT_OK(batch_->Put("a", "z"));
+  ASSERT_OK(batch_->Delete("c"));
+  ASSERT_OK(batch_->Delete("d"));
+  ASSERT_OK(batch_->Delete("e"));
+  ASSERT_OK(batch_->Put("e", "e"));
 
-  s = batch.GetFromBatch(options, "b", &value);
+  s = batch_->GetFromBatch(options_, "b", &value);
   ASSERT_OK(s);
   ASSERT_EQ("b", value);
 
-  s = batch.GetFromBatch(options, "a", &value);
+  s = batch_->GetFromBatch(options_, "a", &value);
   ASSERT_OK(s);
   ASSERT_EQ("z", value);
 
-  s = batch.GetFromBatch(options, "c", &value);
+  s = batch_->GetFromBatch(options_, "c", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  s = batch.GetFromBatch(options, "d", &value);
+  s = batch_->GetFromBatch(options_, "d", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  s = batch.GetFromBatch(options, "x", &value);
+  s = batch_->GetFromBatch(options_, "x", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  s = batch.GetFromBatch(options, "e", &value);
+  s = batch_->GetFromBatch(options_, "e", &value);
   ASSERT_OK(s);
   ASSERT_EQ("e", value);
 
-  ASSERT_OK(batch.Merge("z", "z"));
+  ASSERT_OK(batch_->Merge("z", "z"));
 
-  s = batch.GetFromBatch(options, "z", &value);
+  s = batch_->GetFromBatch(options_, "z", &value);
   ASSERT_NOK(s);  // No merge operator specified.
 
-  s = batch.GetFromBatch(options, "b", &value);
+  s = batch_->GetFromBatch(options_, "b", &value);
   ASSERT_OK(s);
   ASSERT_EQ("b", value);
 }
 
-TEST_F(WriteBatchWithIndexTest, TestGetFromBatchMerge) {
-  DB* db;
-  Options options;
-  options.merge_operator = MergeOperators::CreateFromStringId("stringappend");
-  options.create_if_missing = true;
-
-  std::string dbname = test::PerThreadDBPath("write_batch_with_index_test");
-
-  EXPECT_OK(DestroyDB(dbname, options));
-  Status s = DB::Open(options, dbname, &db);
+TEST_P(WriteBatchWithIndexTest, TestGetFromBatchMerge) {
+  Status s = OpenDB();
   ASSERT_OK(s);
 
-  ColumnFamilyHandle* column_family = db->DefaultColumnFamily();
-  WriteBatchWithIndex batch;
+  ColumnFamilyHandle* column_family = db_->DefaultColumnFamily();
   std::string value;
 
-  s = batch.GetFromBatch(options, "x", &value);
+  s = batch_->GetFromBatch(options_, "x", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  ASSERT_OK(batch.Put("x", "X"));
+  ASSERT_OK(batch_->Put("x", "X"));
   std::string expected = "X";
 
   for (int i = 0; i < 5; i++) {
-    ASSERT_OK(batch.Merge("x", ToString(i)));
+    ASSERT_OK(batch_->Merge("x", ToString(i)));
     expected = expected + "," + ToString(i);
 
     if (i % 2 == 0) {
-      ASSERT_OK(batch.Put("y", ToString(i / 2)));
+      ASSERT_OK(batch_->Put("y", ToString(i / 2)));
     }
 
-    ASSERT_OK(batch.Merge("z", "z"));
+    ASSERT_OK(batch_->Merge("z", "z"));
 
-    s = batch.GetFromBatch(column_family, options, "x", &value);
+    s = batch_->GetFromBatch(column_family, options_, "x", &value);
     ASSERT_OK(s);
     ASSERT_EQ(expected, value);
 
-    s = batch.GetFromBatch(column_family, options, "y", &value);
+    s = batch_->GetFromBatch(column_family, options_, "y", &value);
     ASSERT_OK(s);
     ASSERT_EQ(ToString(i / 2), value);
 
-    s = batch.GetFromBatch(column_family, options, "z", &value);
+    s = batch_->GetFromBatch(column_family, options_, "z", &value);
     ASSERT_TRUE(s.IsMergeInProgress());
   }
-
-  delete db;
-  EXPECT_OK(DestroyDB(dbname, options));
 }
 
-TEST_F(WriteBatchWithIndexTest, TestGetFromBatchMerge2) {
-  DB* db;
-  Options options;
-  options.merge_operator = MergeOperators::CreateFromStringId("stringappend");
-  options.create_if_missing = true;
-
-  std::string dbname = test::PerThreadDBPath("write_batch_with_index_test");
-
-  EXPECT_OK(DestroyDB(dbname, options));
-  Status s = DB::Open(options, dbname, &db);
+TEST_F(WBWIOverwriteTest, TestGetFromBatchMerge2) {
+  Status s = OpenDB();
   ASSERT_OK(s);
 
-  ColumnFamilyHandle* column_family = db->DefaultColumnFamily();
-
-  // Test batch with overwrite_key=true
-  WriteBatchWithIndex batch(BytewiseComparator(), 0, true);
+  ColumnFamilyHandle* column_family = db_->DefaultColumnFamily();
   std::string value;
 
-  s = batch.GetFromBatch(column_family, options, "X", &value);
+  s = batch_->GetFromBatch(column_family, options_, "X", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  ASSERT_OK(batch.Put(column_family, "X", "x"));
-  s = batch.GetFromBatch(column_family, options, "X", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->Put(column_family, "X", "x"));
+  ASSERT_OK(batch_->GetFromBatch(column_family, options_, "X", &value));
   ASSERT_EQ("x", value);
 
-  ASSERT_OK(batch.Put(column_family, "X", "x2"));
-  s = batch.GetFromBatch(column_family, options, "X", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->Put(column_family, "X", "x2"));
+  ASSERT_OK(batch_->GetFromBatch(column_family, options_, "X", &value));
   ASSERT_EQ("x2", value);
 
-  ASSERT_OK(batch.Merge(column_family, "X", "aaa"));
-  s = batch.GetFromBatch(column_family, options, "X", &value);
-  ASSERT_TRUE(s.IsMergeInProgress());
+  ASSERT_OK(batch_->Merge(column_family, "X", "aaa"));
+  ASSERT_OK(batch_->GetFromBatch(column_family, options_, "X", &value));
+  ASSERT_EQ("x2,aaa", value);
 
-  ASSERT_OK(batch.Merge(column_family, "X", "bbb"));
-  s = batch.GetFromBatch(column_family, options, "X", &value);
-  ASSERT_TRUE(s.IsMergeInProgress());
+  ASSERT_OK(batch_->Merge(column_family, "X", "bbb"));
+  ASSERT_OK(batch_->GetFromBatch(column_family, options_, "X", &value));
+  ASSERT_EQ("x2,aaa,bbb", value);
 
-  ASSERT_OK(batch.Put(column_family, "X", "x3"));
-  s = batch.GetFromBatch(column_family, options, "X", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->Put(column_family, "X", "x3"));
+  ASSERT_OK(batch_->GetFromBatch(column_family, options_, "X", &value));
   ASSERT_EQ("x3", value);
 
-  ASSERT_OK(batch.Merge(column_family, "X", "ccc"));
-  s = batch.GetFromBatch(column_family, options, "X", &value);
-  ASSERT_TRUE(s.IsMergeInProgress());
+  ASSERT_OK(batch_->Merge(column_family, "X", "ccc"));
+  ASSERT_OK(batch_->GetFromBatch(column_family, options_, "X", &value));
+  ASSERT_EQ("x3,ccc", value);
 
-  ASSERT_OK(batch.Delete(column_family, "X"));
-  s = batch.GetFromBatch(column_family, options, "X", &value);
+  ASSERT_OK(batch_->Delete(column_family, "X"));
+  s = batch_->GetFromBatch(column_family, options_, "X", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  ASSERT_OK(batch.Merge(column_family, "X", "ddd"));
-  s = batch.GetFromBatch(column_family, options, "X", &value);
-  ASSERT_TRUE(s.IsMergeInProgress());
-
-  delete db;
-  EXPECT_OK(DestroyDB(dbname, options));
+  batch_->Merge(column_family, "X", "ddd");
+  ASSERT_OK(batch_->GetFromBatch(column_family, options_, "X", &value));
+  ASSERT_EQ("ddd", value);
 }
 
-TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDB) {
-  DB* db;
-  Options options;
-  options.create_if_missing = true;
-  std::string dbname = test::PerThreadDBPath("write_batch_with_index_test");
-
-  EXPECT_OK(DestroyDB(dbname, options));
-  Status s = DB::Open(options, dbname, &db);
-  ASSERT_OK(s);
+TEST_P(WriteBatchWithIndexTest, TestGetFromBatchAndDB) {
+  ASSERT_OK(OpenDB());
 
-  WriteBatchWithIndex batch;
-  ReadOptions read_options;
-  WriteOptions write_options;
   std::string value;
 
-  s = db->Put(write_options, "a", "a");
-  ASSERT_OK(s);
+  ASSERT_OK(db_->Put(write_opts_, "a", "a"));
+  ASSERT_OK(db_->Put(write_opts_, "b", "b"));
+  ASSERT_OK(db_->Put(write_opts_, "c", "c"));
 
-  s = db->Put(write_options, "b", "b");
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->Put("a", "batch_->a"));
+  ASSERT_OK(batch_->Delete("b"));
 
-  s = db->Put(write_options, "c", "c");
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "a", &value));
+  ASSERT_EQ("batch_->a", value);
 
-  ASSERT_OK(batch.Put("a", "batch.a"));
-  ASSERT_OK(batch.Delete("b"));
-
-  s = batch.GetFromBatchAndDB(db, read_options, "a", &value);
-  ASSERT_OK(s);
-  ASSERT_EQ("batch.a", value);
-
-  s = batch.GetFromBatchAndDB(db, read_options, "b", &value);
+  Status s = batch_->GetFromBatchAndDB(db_, read_opts_, "b", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  s = batch.GetFromBatchAndDB(db, read_options, "c", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "c", &value));
   ASSERT_EQ("c", value);
 
-  s = batch.GetFromBatchAndDB(db, read_options, "x", &value);
+  s = batch_->GetFromBatchAndDB(db_, read_opts_, "x", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  ASSERT_OK(db->Delete(write_options, "x"));
+  ASSERT_OK(db_->Delete(write_opts_, "x"));
 
-  s = batch.GetFromBatchAndDB(db, read_options, "x", &value);
+  s = batch_->GetFromBatchAndDB(db_, read_opts_, "x", &value);
   ASSERT_TRUE(s.IsNotFound());
-
-  delete db;
-  EXPECT_OK(DestroyDB(dbname, options));
 }
 
-TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge) {
-  DB* db;
-  Options options;
-
-  options.create_if_missing = true;
-  std::string dbname = test::PerThreadDBPath("write_batch_with_index_test");
-
-  options.merge_operator = MergeOperators::CreateFromStringId("stringappend");
-
-  EXPECT_OK(DestroyDB(dbname, options));
-  Status s = DB::Open(options, dbname, &db);
+TEST_P(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge) {
+  Status s = OpenDB();
   ASSERT_OK(s);
 
-  WriteBatchWithIndex batch;
-  ReadOptions read_options;
-  WriteOptions write_options;
   std::string value;
 
-  s = db->Put(write_options, "a", "a0");
-  ASSERT_OK(s);
-
-  s = db->Put(write_options, "b", "b0");
-  ASSERT_OK(s);
-
-  s = db->Merge(write_options, "b", "b1");
-  ASSERT_OK(s);
+  ASSERT_OK(db_->Put(write_opts_, "a", "a0"));
+  ASSERT_OK(db_->Put(write_opts_, "b", "b0"));
+  ASSERT_OK(db_->Merge(write_opts_, "b", "b1"));
+  ASSERT_OK(db_->Merge(write_opts_, "c", "c0"));
+  ASSERT_OK(db_->Merge(write_opts_, "d", "d0"));
 
-  s = db->Merge(write_options, "c", "c0");
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->Merge("a", "a1"));
+  ASSERT_OK(batch_->Merge("a", "a2"));
+  ASSERT_OK(batch_->Merge("b", "b2"));
+  ASSERT_OK(batch_->Merge("d", "d1"));
+  ASSERT_OK(batch_->Merge("e", "e0"));
 
-  s = db->Merge(write_options, "d", "d0");
-  ASSERT_OK(s);
-
-  ASSERT_OK(batch.Merge("a", "a1"));
-  ASSERT_OK(batch.Merge("a", "a2"));
-  ASSERT_OK(batch.Merge("b", "b2"));
-  ASSERT_OK(batch.Merge("d", "d1"));
-  ASSERT_OK(batch.Merge("e", "e0"));
-
-  s = batch.GetFromBatchAndDB(db, read_options, "a", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "a", &value));
   ASSERT_EQ("a0,a1,a2", value);
 
-  s = batch.GetFromBatchAndDB(db, read_options, "b", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "b", &value));
   ASSERT_EQ("b0,b1,b2", value);
 
-  s = batch.GetFromBatchAndDB(db, read_options, "c", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "c", &value));
   ASSERT_EQ("c0", value);
 
-  s = batch.GetFromBatchAndDB(db, read_options, "d", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "d", &value));
   ASSERT_EQ("d0,d1", value);
 
-  s = batch.GetFromBatchAndDB(db, read_options, "e", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "e", &value));
   ASSERT_EQ("e0", value);
 
-  s = db->Delete(write_options, "x");
-  ASSERT_OK(s);
+  ASSERT_OK(db_->Delete(write_opts_, "x"));
 
-  s = batch.GetFromBatchAndDB(db, read_options, "x", &value);
+  s = batch_->GetFromBatchAndDB(db_, read_opts_, "x", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  const Snapshot* snapshot = db->GetSnapshot();
+  const Snapshot* snapshot = db_->GetSnapshot();
   ReadOptions snapshot_read_options;
   snapshot_read_options.snapshot = snapshot;
 
-  s = db->Delete(write_options, "a");
-  ASSERT_OK(s);
+  ASSERT_OK(db_->Delete(write_opts_, "a"));
 
-  s = batch.GetFromBatchAndDB(db, read_options, "a", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "a", &value));
   ASSERT_EQ("a1,a2", value);
 
-  s = batch.GetFromBatchAndDB(db, snapshot_read_options, "a", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(
+      s = batch_->GetFromBatchAndDB(db_, snapshot_read_options, "a", &value));
   ASSERT_EQ("a0,a1,a2", value);
 
-  ASSERT_OK(batch.Delete("a"));
+  ASSERT_OK(batch_->Delete("a"));
 
-  s = batch.GetFromBatchAndDB(db, read_options, "a", &value);
+  s = batch_->GetFromBatchAndDB(db_, read_opts_, "a", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  s = batch.GetFromBatchAndDB(db, snapshot_read_options, "a", &value);
+  s = batch_->GetFromBatchAndDB(db_, snapshot_read_options, "a", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  s = db->Merge(write_options, "c", "c1");
-  ASSERT_OK(s);
+  ASSERT_OK(s = db_->Merge(write_opts_, "c", "c1"));
 
-  s = batch.GetFromBatchAndDB(db, read_options, "c", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(s = batch_->GetFromBatchAndDB(db_, read_opts_, "c", &value));
   ASSERT_EQ("c0,c1", value);
 
-  s = batch.GetFromBatchAndDB(db, snapshot_read_options, "c", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(
+      s = batch_->GetFromBatchAndDB(db_, snapshot_read_options, "c", &value));
   ASSERT_EQ("c0", value);
 
-  s = db->Put(write_options, "e", "e1");
-  ASSERT_OK(s);
-
-  s = batch.GetFromBatchAndDB(db, read_options, "e", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(db_->Put(write_opts_, "e", "e1"));
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "e", &value));
   ASSERT_EQ("e1,e0", value);
 
-  s = batch.GetFromBatchAndDB(db, snapshot_read_options, "e", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, snapshot_read_options, "e", &value));
   ASSERT_EQ("e0", value);
 
-  s = db->Delete(write_options, "e");
-  ASSERT_OK(s);
-
-  s = batch.GetFromBatchAndDB(db, read_options, "e", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(s = db_->Delete(write_opts_, "e"));
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "e", &value));
   ASSERT_EQ("e0", value);
 
-  s = batch.GetFromBatchAndDB(db, snapshot_read_options, "e", &value);
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, snapshot_read_options, "e", &value));
   ASSERT_EQ("e0", value);
 
-  db->ReleaseSnapshot(snapshot);
-  delete db;
-  EXPECT_OK(DestroyDB(dbname, options));
+  db_->ReleaseSnapshot(snapshot);
 }
 
-TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge2) {
-  DB* db;
-  Options options;
-
-  options.create_if_missing = true;
-  std::string dbname = test::PerThreadDBPath("write_batch_with_index_test");
-
-  options.merge_operator = MergeOperators::CreateFromStringId("stringappend");
-
-  EXPECT_OK(DestroyDB(dbname, options));
-  Status s = DB::Open(options, dbname, &db);
+TEST_F(WBWIOverwriteTest, TestGetFromBatchAndDBMerge2) {
+  Status s = OpenDB();
   ASSERT_OK(s);
 
-  // Test batch with overwrite_key=true
-  WriteBatchWithIndex batch(BytewiseComparator(), 0, true);
-
-  ReadOptions read_options;
-  WriteOptions write_options;
   std::string value;
 
-  s = batch.GetFromBatchAndDB(db, read_options, "A", &value);
+  s = batch_->GetFromBatchAndDB(db_, read_opts_, "A", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  ASSERT_OK(batch.Merge("A", "xxx"));
+  ASSERT_OK(batch_->Merge("A", "xxx"));
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "A", &value));
+  ASSERT_EQ(value, "xxx");
 
-  s = batch.GetFromBatchAndDB(db, read_options, "A", &value);
-  ASSERT_TRUE(s.IsMergeInProgress());
+  ASSERT_OK(batch_->Merge("A", "yyy"));
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "A", &value));
+  ASSERT_EQ(value, "xxx,yyy");
 
-  ASSERT_OK(batch.Merge("A", "yyy"));
+  ASSERT_OK(db_->Put(write_opts_, "A", "a0"));
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "A", &value));
+  ASSERT_EQ(value, "a0,xxx,yyy");
 
-  s = batch.GetFromBatchAndDB(db, read_options, "A", &value);
-  ASSERT_TRUE(s.IsMergeInProgress());
-
-  s = db->Put(write_options, "A", "a0");
-  ASSERT_OK(s);
+  ASSERT_OK(batch_->Delete("A"));
 
-  s = batch.GetFromBatchAndDB(db, read_options, "A", &value);
-  ASSERT_TRUE(s.IsMergeInProgress());
-
-  ASSERT_OK(batch.Delete("A"));
-
-  s = batch.GetFromBatchAndDB(db, read_options, "A", &value);
+  s = batch_->GetFromBatchAndDB(db_, read_opts_, "A", &value);
   ASSERT_TRUE(s.IsNotFound());
-
-  delete db;
-  EXPECT_OK(DestroyDB(dbname, options));
 }
 
-TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge3) {
-  DB* db;
-  Options options;
+TEST_P(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge3) {
+  Status s = OpenDB();
+  ASSERT_OK(s);
 
-  options.create_if_missing = true;
-  std::string dbname = test::PerThreadDBPath("write_batch_with_index_test");
+  FlushOptions flush_options;
+  std::string value;
 
-  options.merge_operator = MergeOperators::CreateFromStringId("stringappend");
+  ASSERT_OK(db_->Put(write_opts_, "A", "1"));
+  ASSERT_OK(db_->Flush(flush_options, db_->DefaultColumnFamily()));
+  ASSERT_OK(batch_->Merge("A", "2"));
 
-  EXPECT_OK(DestroyDB(dbname, options));
-  Status s = DB::Open(options, dbname, &db);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "A", &value));
+  ASSERT_EQ(value, "1,2");
+}
+
+TEST_P(WriteBatchWithIndexTest, TestPinnedGetFromBatchAndDB) {
+  Status s = OpenDB();
   ASSERT_OK(s);
 
-  ReadOptions read_options;
-  WriteOptions write_options;
-  FlushOptions flush_options;
-  std::string value;
+  PinnableSlice value;
+
+  ASSERT_OK(db_->Put(write_opts_, "a", "a0"));
+  ASSERT_OK(db_->Put(write_opts_, "b", "b0"));
+  ASSERT_OK(db_->Merge(write_opts_, "b", "b1"));
+  ASSERT_OK(db_->Merge(write_opts_, "c", "c0"));
+  ASSERT_OK(db_->Merge(write_opts_, "d", "d0"));
+  ASSERT_OK(batch_->Merge("a", "a1"));
+  ASSERT_OK(batch_->Merge("a", "a2"));
+  ASSERT_OK(batch_->Merge("b", "b2"));
+  ASSERT_OK(batch_->Merge("d", "d1"));
+  ASSERT_OK(batch_->Merge("e", "e0"));
+
+  for (int i = 0; i < 2; i++) {
+    if (i == 1) {
+      // Do it again with a flushed DB...
+      ASSERT_OK(db_->Flush(FlushOptions(), db_->DefaultColumnFamily()));
+    }
+    ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "a", &value));
+    ASSERT_EQ("a0,a1,a2", value.ToString());
 
-  WriteBatchWithIndex batch;
+    ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "b", &value));
+    ASSERT_EQ("b0,b1,b2", value.ToString());
 
-  ASSERT_OK(db->Put(write_options, "A", "1"));
-  ASSERT_OK(db->Flush(flush_options, db->DefaultColumnFamily()));
-  ASSERT_OK(batch.Merge("A", "2"));
+    ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "c", &value));
+    ASSERT_EQ("c0", value.ToString());
 
-  ASSERT_OK(batch.GetFromBatchAndDB(db, read_options, "A", &value));
-  ASSERT_EQ(value, "1,2");
+    ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "d", &value));
+    ASSERT_EQ("d0,d1", value.ToString());
+
+    ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "e", &value));
+    ASSERT_EQ("e0", value.ToString());
+    ASSERT_OK(db_->Delete(write_opts_, "x"));
 
-  delete db;
-  EXPECT_OK(DestroyDB(dbname, options));
+    s = batch_->GetFromBatchAndDB(db_, read_opts_, "x", &value);
+    ASSERT_TRUE(s.IsNotFound());
+  }
 }
 
 void AssertKey(std::string key, WBWIIterator* iter) {
@@ -1353,25 +1469,24 @@ void AssertValue(std::string value, WBWIIterator* iter) {
 
 // Tests that we can write to the WBWI while we iterate (from a single thread).
 // iteration should see the newest writes
-TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingCorrectnessTest) {
-  WriteBatchWithIndex batch(BytewiseComparator(), 0, true);
+TEST_F(WBWIOverwriteTest, MutateWhileIteratingCorrectnessTest) {
   for (char c = 'a'; c <= 'z'; ++c) {
-    ASSERT_OK(batch.Put(std::string(1, c), std::string(1, c)));
+    ASSERT_OK(batch_->Put(std::string(1, c), std::string(1, c)));
   }
 
-  std::unique_ptr<WBWIIterator> iter(batch.NewIterator());
+  std::unique_ptr<WBWIIterator> iter(batch_->NewIterator());
   iter->Seek("k");
   AssertKey("k", iter.get());
   iter->Next();
   AssertKey("l", iter.get());
-  ASSERT_OK(batch.Put("ab", "cc"));
+  ASSERT_OK(batch_->Put("ab", "cc"));
   iter->Next();
   AssertKey("m", iter.get());
-  ASSERT_OK(batch.Put("mm", "kk"));
+  ASSERT_OK(batch_->Put("mm", "kk"));
   iter->Next();
   AssertKey("mm", iter.get());
   AssertValue("kk", iter.get());
-  ASSERT_OK(batch.Delete("mm"));
+  ASSERT_OK(batch_->Delete("mm"));
 
   iter->Next();
   AssertKey("n", iter.get());
@@ -1381,7 +1496,7 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingCorrectnessTest) {
 
   iter->Seek("ab");
   AssertKey("ab", iter.get());
-  ASSERT_OK(batch.Delete("x"));
+  ASSERT_OK(batch_->Delete("x"));
   iter->Seek("x");
   AssertKey("x", iter.get());
   ASSERT_EQ(kDeleteRecord, iter->Entry().type);
@@ -1400,10 +1515,10 @@ void AssertIterValue(std::string value, Iterator* iter) {
 }
 
 // same thing as above, but testing IteratorWithBase
-TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) {
+TEST_F(WBWIOverwriteTest, MutateWhileIteratingBaseCorrectnessTest) {
   WriteBatchWithIndex batch(BytewiseComparator(), 0, true);
   for (char c = 'a'; c <= 'z'; ++c) {
-    ASSERT_OK(batch.Put(std::string(1, c), std::string(1, c)));
+    ASSERT_OK(batch_->Put(std::string(1, c), std::string(1, c)));
   }
 
   KVMap map;
@@ -1412,20 +1527,19 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) {
   map["ee"] = "ee";
   map["em"] = "me";
 
-  std::unique_ptr<Iterator> iter(
-      batch.NewIteratorWithBase(new KVIter(&map)));
+  std::unique_ptr<Iterator> iter(batch_->NewIteratorWithBase(new KVIter(&map)));
   iter->Seek("k");
   AssertIterKey("k", iter.get());
   iter->Next();
   AssertIterKey("l", iter.get());
-  ASSERT_OK(batch.Put("ab", "cc"));
+  ASSERT_OK(batch_->Put("ab", "cc"));
   iter->Next();
   AssertIterKey("m", iter.get());
-  ASSERT_OK(batch.Put("mm", "kk"));
+  ASSERT_OK(batch_->Put("mm", "kk"));
   iter->Next();
   AssertIterKey("mm", iter.get());
   AssertIterValue("kk", iter.get());
-  ASSERT_OK(batch.Delete("mm"));
+  ASSERT_OK(batch_->Delete("mm"));
   iter->Next();
   AssertIterKey("n", iter.get());
   iter->Prev();
@@ -1438,13 +1552,13 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) {
   AssertIterKey("aa", iter.get());
   iter->Prev();
   AssertIterKey("a", iter.get());
-  ASSERT_OK(batch.Delete("aa"));
+  ASSERT_OK(batch_->Delete("aa"));
   iter->Next();
   AssertIterKey("ab", iter.get());
   iter->Prev();
   AssertIterKey("a", iter.get());
 
-  ASSERT_OK(batch.Delete("x"));
+  ASSERT_OK(batch_->Delete("x"));
   iter->Seek("x");
   AssertIterKey("y", iter.get());
   iter->Next();
@@ -1453,11 +1567,11 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) {
   iter->Prev();
   AssertIterKey("w", iter.get());
 
-  ASSERT_OK(batch.Delete("e"));
+  ASSERT_OK(batch_->Delete("e"));
   iter->Seek("e");
   AssertIterKey("ee", iter.get());
   AssertIterValue("ee", iter.get());
-  ASSERT_OK(batch.Put("ee", "xx"));
+  ASSERT_OK(batch_->Put("ee", "xx"));
   // still the same value
   AssertIterValue("ee", iter.get());
   iter->Next();
@@ -1470,10 +1584,9 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) {
 }
 
 // stress testing mutations with IteratorWithBase
-TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseStressTest) {
-  WriteBatchWithIndex batch(BytewiseComparator(), 0, true);
+TEST_F(WBWIOverwriteTest, MutateWhileIteratingBaseStressTest) {
   for (char c = 'a'; c <= 'z'; ++c) {
-    ASSERT_OK(batch.Put(std::string(1, c), std::string(1, c)));
+    ASSERT_OK(batch_->Put(std::string(1, c), std::string(1, c)));
   }
 
   KVMap map;
@@ -1481,8 +1594,7 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseStressTest) {
     map[std::string(2, c)] = std::string(2, c);
   }
 
-  std::unique_ptr<Iterator> iter(
-      batch.NewIteratorWithBase(new KVIter(&map)));
+  std::unique_ptr<Iterator> iter(batch_->NewIteratorWithBase(new KVIter(&map)));
 
   Random rnd(301);
   for (int i = 0; i < 1000000; ++i) {
@@ -1490,16 +1602,16 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseStressTest) {
     char c = static_cast<char>(rnd.Uniform(26) + 'a');
     switch (random) {
       case 0:
-        ASSERT_OK(batch.Put(std::string(1, c), "xxx"));
+        ASSERT_OK(batch_->Put(std::string(1, c), "xxx"));
         break;
       case 1:
-        ASSERT_OK(batch.Put(std::string(2, c), "xxx"));
+        ASSERT_OK(batch_->Put(std::string(2, c), "xxx"));
         break;
       case 2:
-        ASSERT_OK(batch.Delete(std::string(1, c)));
+        ASSERT_OK(batch_->Delete(std::string(1, c)));
         break;
       case 3:
-        ASSERT_OK(batch.Delete(std::string(2, c)));
+        ASSERT_OK(batch_->Delete(std::string(2, c)));
         break;
       case 4:
         iter->Seek(std::string(1, c));
@@ -1524,330 +1636,758 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseStressTest) {
   ASSERT_OK(iter->status());
 }
 
-static void PrintContents(WriteBatchWithIndex* batch,
-                          ColumnFamilyHandle* column_family,
-                          std::string* result) {
-  WBWIIterator* iter;
-  if (column_family == nullptr) {
-    iter = batch->NewIterator();
-  } else {
-    iter = batch->NewIterator(column_family);
-  }
-
-  iter->SeekToFirst();
-  while (iter->Valid()) {
-    ASSERT_OK(iter->status());
-
-    WriteEntry e = iter->Entry();
-
-    if (e.type == kPutRecord) {
-      result->append("PUT(");
-      result->append(e.key.ToString());
-      result->append("):");
-      result->append(e.value.ToString());
-    } else if (e.type == kMergeRecord) {
-      result->append("MERGE(");
-      result->append(e.key.ToString());
-      result->append("):");
-      result->append(e.value.ToString());
-    } else if (e.type == kSingleDeleteRecord) {
-      result->append("SINGLE-DEL(");
-      result->append(e.key.ToString());
-      result->append(")");
-    } else {
-      assert(e.type == kDeleteRecord);
-      result->append("DEL(");
-      result->append(e.key.ToString());
-      result->append(")");
-    }
-
-    result->append(",");
-    iter->Next();
-  }
-
-  ASSERT_OK(iter->status());
-
-  delete iter;
-}
-
-static std::string PrintContents(WriteBatchWithIndex* batch,
-                                 ColumnFamilyHandle* column_family) {
-  std::string result;
-  PrintContents(batch, column_family, &result);
-  return result;
-}
-
-static void PrintContents(WriteBatchWithIndex* batch, KVMap* base_map,
-                          ColumnFamilyHandle* column_family,
-                          std::string* result) {
-  Iterator* iter;
-  if (column_family == nullptr) {
-    iter = batch->NewIteratorWithBase(new KVIter(base_map));
-  } else {
-    iter = batch->NewIteratorWithBase(column_family, new KVIter(base_map));
-  }
-
+TEST_P(WriteBatchWithIndexTest, TestNewIteratorWithBaseFromWbwi) {
+  ColumnFamilyHandleImplDummy cf1(6, BytewiseComparator());
+  KVMap map;
+  map["a"] = "aa";
+  map["c"] = "cc";
+  map["e"] = "ee";
+  std::unique_ptr<Iterator> iter(
+      batch_->NewIteratorWithBase(&cf1, new KVIter(&map)));
+  ASSERT_NE(nullptr, iter);
   iter->SeekToFirst();
-  while (iter->Valid()) {
-    ASSERT_OK(iter->status());
-
-    Slice key = iter->key();
-    Slice value = iter->value();
-
-    result->append(key.ToString());
-    result->append(":");
-    result->append(value.ToString());
-    result->append(",");
-
-    iter->Next();
-  }
-
+  ASSERT_TRUE(iter->Valid());
   ASSERT_OK(iter->status());
-
-  delete iter;
-}
-
-static std::string PrintContents(WriteBatchWithIndex* batch, KVMap* base_map,
-                                 ColumnFamilyHandle* column_family) {
-  std::string result;
-  PrintContents(batch, base_map, column_family, &result);
-  return result;
 }
 
-TEST_F(WriteBatchWithIndexTest, SavePointTest) {
-  WriteBatchWithIndex batch;
+TEST_P(WriteBatchWithIndexTest, SavePointTest) {
   ColumnFamilyHandleImplDummy cf1(1, BytewiseComparator());
+  KVMap empty_map;
+  std::unique_ptr<Iterator> cf0_iter(
+      batch_->NewIteratorWithBase(new KVIter(&empty_map)));
+  std::unique_ptr<Iterator> cf1_iter(
+      batch_->NewIteratorWithBase(&cf1, new KVIter(&empty_map)));
   Status s;
-
-  ASSERT_OK(batch.Put("A", "a"));
-  ASSERT_OK(batch.Put("B", "b"));
-  ASSERT_OK(batch.Put("A", "aa"));
-  ASSERT_OK(batch.Put(&cf1, "A", "a1"));
-  ASSERT_OK(batch.Delete(&cf1, "B"));
-  ASSERT_OK(batch.Put(&cf1, "C", "c1"));
-  ASSERT_OK(batch.Put(&cf1, "E", "e1"));
-
-  batch.SetSavePoint();  // 1
-
-  ASSERT_OK(batch.Put("C", "cc"));
-  ASSERT_OK(batch.Put("B", "bb"));
-  ASSERT_OK(batch.Delete("A"));
-  ASSERT_OK(batch.Put(&cf1, "B", "b1"));
-  ASSERT_OK(batch.Delete(&cf1, "A"));
-  ASSERT_OK(batch.SingleDelete(&cf1, "E"));
-  batch.SetSavePoint();  // 2
-
-  ASSERT_OK(batch.Put("A", "aaa"));
-  ASSERT_OK(batch.Put("A", "xxx"));
-  ASSERT_OK(batch.Delete("B"));
-  ASSERT_OK(batch.Put(&cf1, "B", "b2"));
-  ASSERT_OK(batch.Delete(&cf1, "C"));
-  batch.SetSavePoint();  // 3
-  batch.SetSavePoint();  // 4
-  ASSERT_OK(batch.SingleDelete("D"));
-  ASSERT_OK(batch.Delete(&cf1, "D"));
-  ASSERT_OK(batch.Delete(&cf1, "E"));
-
-  ASSERT_EQ(
-      "PUT(A):a,PUT(A):aa,DEL(A),PUT(A):aaa,PUT(A):xxx,PUT(B):b,PUT(B):bb,DEL("
-      "B)"
-      ",PUT(C):cc,SINGLE-DEL(D),",
-      PrintContents(&batch, nullptr));
-
-  ASSERT_EQ(
-      "PUT(A):a1,DEL(A),DEL(B),PUT(B):b1,PUT(B):b2,PUT(C):c1,DEL(C),"
-      "DEL(D),PUT(E):e1,SINGLE-DEL(E),DEL(E),",
-      PrintContents(&batch, &cf1));
-
-  ASSERT_OK(batch.RollbackToSavePoint());  // rollback to 4
-  ASSERT_EQ(
-      "PUT(A):a,PUT(A):aa,DEL(A),PUT(A):aaa,PUT(A):xxx,PUT(B):b,PUT(B):bb,DEL("
-      "B)"
-      ",PUT(C):cc,",
-      PrintContents(&batch, nullptr));
-
-  ASSERT_EQ(
-      "PUT(A):a1,DEL(A),DEL(B),PUT(B):b1,PUT(B):b2,PUT(C):c1,DEL(C),"
-      "PUT(E):e1,SINGLE-DEL(E),",
-      PrintContents(&batch, &cf1));
-
-  ASSERT_OK(batch.RollbackToSavePoint());  // rollback to 3
-  ASSERT_EQ(
-      "PUT(A):a,PUT(A):aa,DEL(A),PUT(A):aaa,PUT(A):xxx,PUT(B):b,PUT(B):bb,DEL("
-      "B)"
-      ",PUT(C):cc,",
-      PrintContents(&batch, nullptr));
-
-  ASSERT_EQ(
-      "PUT(A):a1,DEL(A),DEL(B),PUT(B):b1,PUT(B):b2,PUT(C):c1,DEL(C),"
-      "PUT(E):e1,SINGLE-DEL(E),",
-      PrintContents(&batch, &cf1));
-
-  ASSERT_OK(batch.RollbackToSavePoint());  // rollback to 2
-  ASSERT_EQ("PUT(A):a,PUT(A):aa,DEL(A),PUT(B):b,PUT(B):bb,PUT(C):cc,",
-            PrintContents(&batch, nullptr));
-
-  ASSERT_EQ(
-      "PUT(A):a1,DEL(A),DEL(B),PUT(B):b1,PUT(C):c1,"
-      "PUT(E):e1,SINGLE-DEL(E),",
-      PrintContents(&batch, &cf1));
-
-  batch.SetSavePoint();  // 5
-  ASSERT_OK(batch.Put("X", "x"));
-
-  ASSERT_EQ("PUT(A):a,PUT(A):aa,DEL(A),PUT(B):b,PUT(B):bb,PUT(C):cc,PUT(X):x,",
-            PrintContents(&batch, nullptr));
-
-  ASSERT_OK(batch.RollbackToSavePoint());  // rollback to 5
-  ASSERT_EQ("PUT(A):a,PUT(A):aa,DEL(A),PUT(B):b,PUT(B):bb,PUT(C):cc,",
-            PrintContents(&batch, nullptr));
-
-  ASSERT_EQ(
-      "PUT(A):a1,DEL(A),DEL(B),PUT(B):b1,PUT(C):c1,"
-      "PUT(E):e1,SINGLE-DEL(E),",
-      PrintContents(&batch, &cf1));
-
-  ASSERT_OK(batch.RollbackToSavePoint());  // rollback to 1
-  ASSERT_EQ("PUT(A):a,PUT(A):aa,PUT(B):b,", PrintContents(&batch, nullptr));
-
-  ASSERT_EQ("PUT(A):a1,DEL(B),PUT(C):c1,PUT(E):e1,",
-            PrintContents(&batch, &cf1));
-
-  s = batch.RollbackToSavePoint();  // no savepoint found
+  KVMap kvm_cf0_0 = {{"A", "aa"}, {"B", "b"}};
+  KVMap kvm_cf1_0 = {{"A", "a1"}, {"C", "c1"}, {"E", "e1"}};
+  KVIter kvi_cf0_0(&kvm_cf0_0);
+  KVIter kvi_cf1_0(&kvm_cf1_0);
+
+  ASSERT_OK(batch_->Put("A", "a"));
+  ASSERT_OK(batch_->Put("B", "b"));
+  ASSERT_OK(batch_->Put("A", "aa"));
+  ASSERT_OK(batch_->Put(&cf1, "A", "a1"));
+  ASSERT_OK(batch_->Delete(&cf1, "B"));
+  ASSERT_OK(batch_->Put(&cf1, "C", "c1"));
+  ASSERT_OK(batch_->Put(&cf1, "E", "e1"));
+
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_0);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_0);
+  batch_->SetSavePoint();  // 1
+
+  KVMap kvm_cf0_1 = {{"B", "bb"}, {"C", "cc"}};
+  KVMap kvm_cf1_1 = {{"B", "b1"}, {"C", "c1"}};
+  KVIter kvi_cf0_1(&kvm_cf0_1);
+  KVIter kvi_cf1_1(&kvm_cf1_1);
+
+  ASSERT_OK(batch_->Put("C", "cc"));
+  ASSERT_OK(batch_->Put("B", "bb"));
+  ASSERT_OK(batch_->Delete("A"));
+  ASSERT_OK(batch_->Put(&cf1, "B", "b1"));
+  ASSERT_OK(batch_->Delete(&cf1, "A"));
+  ASSERT_OK(batch_->SingleDelete(&cf1, "E"));
+  batch_->SetSavePoint();  // 2
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_1);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_1);
+
+  KVMap kvm_cf0_2 = {{"A", "xxx"}, {"C", "cc"}};
+  KVMap kvm_cf1_2 = {{"B", "b2"}};
+  KVIter kvi_cf0_2(&kvm_cf0_2);
+  KVIter kvi_cf1_2(&kvm_cf1_2);
+
+  ASSERT_OK(batch_->Put("A", "aaa"));
+  ASSERT_OK(batch_->Put("A", "xxx"));
+  ASSERT_OK(batch_->Delete("B"));
+  ASSERT_OK(batch_->Put(&cf1, "B", "b2"));
+  ASSERT_OK(batch_->Delete(&cf1, "C"));
+  batch_->SetSavePoint();  // 3
+  batch_->SetSavePoint();  // 4
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_2);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_2);
+
+  KVMap kvm_cf0_4 = {{"A", "xxx"}, {"C", "cc"}};
+  KVMap kvm_cf1_4 = {{"B", "b2"}};
+  KVIter kvi_cf0_4(&kvm_cf0_4);
+  KVIter kvi_cf1_4(&kvm_cf1_4);
+  ASSERT_OK(batch_->SingleDelete("D"));
+  ASSERT_OK(batch_->Delete(&cf1, "D"));
+  ASSERT_OK(batch_->Delete(&cf1, "E"));
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_4);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_4);
+
+  ASSERT_OK(batch_->RollbackToSavePoint());  // rollback to 4
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_2);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_2);
+
+  ASSERT_OK(batch_->RollbackToSavePoint());  // rollback to 3
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_2);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_2);
+
+  ASSERT_OK(batch_->RollbackToSavePoint());  // rollback to 2
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_1);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_1);
+
+  batch_->SetSavePoint();  // 5
+  ASSERT_OK(batch_->Put("X", "x"));
+
+  KVMap kvm_cf0_5 = {{"B", "bb"}, {"C", "cc"}, {"X", "x"}};
+  KVIter kvi_cf0_5(&kvm_cf0_5);
+  KVIter kvi_cf1_5(&kvm_cf1_1);
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_5);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_5);
+
+  ASSERT_OK(batch_->RollbackToSavePoint());  // rollback to 5
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_1);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_1);
+
+  ASSERT_OK(batch_->RollbackToSavePoint());  // rollback to 1
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_0);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_0);
+
+  s = batch_->RollbackToSavePoint();  // no savepoint found
   ASSERT_TRUE(s.IsNotFound());
-  ASSERT_EQ("PUT(A):a,PUT(A):aa,PUT(B):b,", PrintContents(&batch, nullptr));
-
-  ASSERT_EQ("PUT(A):a1,DEL(B),PUT(C):c1,PUT(E):e1,",
-            PrintContents(&batch, &cf1));
+  AssertItersEqual(cf0_iter.get(), &kvi_cf0_0);
+  AssertItersEqual(cf1_iter.get(), &kvi_cf1_0);
 
-  batch.SetSavePoint();  // 6
+  batch_->SetSavePoint();  // 6
 
-  batch.Clear();
-  ASSERT_EQ("", PrintContents(&batch, nullptr));
-  ASSERT_EQ("", PrintContents(&batch, &cf1));
+  batch_->Clear();
+  ASSERT_EQ("", PrintContents(batch_.get(), nullptr));
+  ASSERT_EQ("", PrintContents(batch_.get(), &cf1));
 
-  s = batch.RollbackToSavePoint();  // rollback to 6
+  s = batch_->RollbackToSavePoint();  // rollback to 6
   ASSERT_TRUE(s.IsNotFound());
 }
 
-TEST_F(WriteBatchWithIndexTest, SingleDeleteTest) {
-  WriteBatchWithIndex batch;
+TEST_P(WriteBatchWithIndexTest, SingleDeleteTest) {
   Status s;
   std::string value;
-  DBOptions db_options;
 
-  ASSERT_OK(batch.SingleDelete("A"));
+  ASSERT_OK(batch_->SingleDelete("A"));
 
-  s = batch.GetFromBatch(db_options, "A", &value);
+  s = batch_->GetFromBatch(options_, "A", &value);
   ASSERT_TRUE(s.IsNotFound());
-  s = batch.GetFromBatch(db_options, "B", &value);
+  s = batch_->GetFromBatch(options_, "B", &value);
   ASSERT_TRUE(s.IsNotFound());
-  value = PrintContents(&batch, nullptr);
-  ASSERT_EQ("SINGLE-DEL(A),", value);
 
-  batch.Clear();
-  ASSERT_OK(batch.Put("A", "a"));
-  ASSERT_OK(batch.Put("A", "a2"));
-  ASSERT_OK(batch.Put("B", "b"));
-  ASSERT_OK(batch.SingleDelete("A"));
+  batch_->Clear();
+  ASSERT_OK(batch_->Put("A", "a"));
+  ASSERT_OK(batch_->Put("A", "a2"));
+  ASSERT_OK(batch_->Put("B", "b"));
+  ASSERT_OK(batch_->SingleDelete("A"));
 
-  s = batch.GetFromBatch(db_options, "A", &value);
+  s = batch_->GetFromBatch(options_, "A", &value);
   ASSERT_TRUE(s.IsNotFound());
-  s = batch.GetFromBatch(db_options, "B", &value);
+  s = batch_->GetFromBatch(options_, "B", &value);
   ASSERT_OK(s);
   ASSERT_EQ("b", value);
 
-  value = PrintContents(&batch, nullptr);
-  ASSERT_EQ("PUT(A):a,PUT(A):a2,SINGLE-DEL(A),PUT(B):b,", value);
+  ASSERT_OK(batch_->Put("C", "c"));
+  ASSERT_OK(batch_->Put("A", "a3"));
+  ASSERT_OK(batch_->Delete("B"));
+  ASSERT_OK(batch_->SingleDelete("B"));
+  ASSERT_OK(batch_->SingleDelete("C"));
 
-  ASSERT_OK(batch.Put("C", "c"));
-  ASSERT_OK(batch.Put("A", "a3"));
-  ASSERT_OK(batch.Delete("B"));
-  ASSERT_OK(batch.SingleDelete("B"));
-  ASSERT_OK(batch.SingleDelete("C"));
-
-  s = batch.GetFromBatch(db_options, "A", &value);
+  s = batch_->GetFromBatch(options_, "A", &value);
   ASSERT_OK(s);
   ASSERT_EQ("a3", value);
-  s = batch.GetFromBatch(db_options, "B", &value);
+  s = batch_->GetFromBatch(options_, "B", &value);
   ASSERT_TRUE(s.IsNotFound());
-  s = batch.GetFromBatch(db_options, "C", &value);
+  s = batch_->GetFromBatch(options_, "C", &value);
   ASSERT_TRUE(s.IsNotFound());
-  s = batch.GetFromBatch(db_options, "D", &value);
+  s = batch_->GetFromBatch(options_, "D", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  value = PrintContents(&batch, nullptr);
-  ASSERT_EQ(
-      "PUT(A):a,PUT(A):a2,SINGLE-DEL(A),PUT(A):a3,PUT(B):b,DEL(B),SINGLE-DEL(B)"
-      ",PUT(C):c,SINGLE-DEL(C),",
-      value);
-
-  ASSERT_OK(batch.Put("B", "b4"));
-  ASSERT_OK(batch.Put("C", "c4"));
-  ASSERT_OK(batch.Put("D", "d4"));
-  ASSERT_OK(batch.SingleDelete("D"));
-  ASSERT_OK(batch.SingleDelete("D"));
-  ASSERT_OK(batch.Delete("A"));
+  ASSERT_OK(batch_->Put("B", "b4"));
+  ASSERT_OK(batch_->Put("C", "c4"));
+  ASSERT_OK(batch_->Put("D", "d4"));
+  ASSERT_OK(batch_->SingleDelete("D"));
+  ASSERT_OK(batch_->SingleDelete("D"));
+  ASSERT_OK(batch_->Delete("A"));
 
-  s = batch.GetFromBatch(db_options, "A", &value);
+  s = batch_->GetFromBatch(options_, "A", &value);
   ASSERT_TRUE(s.IsNotFound());
-  s = batch.GetFromBatch(db_options, "B", &value);
+  s = batch_->GetFromBatch(options_, "B", &value);
   ASSERT_OK(s);
   ASSERT_EQ("b4", value);
-  s = batch.GetFromBatch(db_options, "C", &value);
+  s = batch_->GetFromBatch(options_, "C", &value);
   ASSERT_OK(s);
   ASSERT_EQ("c4", value);
-  s = batch.GetFromBatch(db_options, "D", &value);
+  s = batch_->GetFromBatch(options_, "D", &value);
   ASSERT_TRUE(s.IsNotFound());
-
-  value = PrintContents(&batch, nullptr);
-  ASSERT_EQ(
-      "PUT(A):a,PUT(A):a2,SINGLE-DEL(A),PUT(A):a3,DEL(A),PUT(B):b,DEL(B),"
-      "SINGLE-DEL(B),PUT(B):b4,PUT(C):c,SINGLE-DEL(C),PUT(C):c4,PUT(D):d4,"
-      "SINGLE-DEL(D),SINGLE-DEL(D),",
-      value);
 }
 
-TEST_F(WriteBatchWithIndexTest, SingleDeleteDeltaIterTest) {
+TEST_P(WriteBatchWithIndexTest, SingleDeleteDeltaIterTest) {
   std::string value;
-  DBOptions db_options;
-  WriteBatchWithIndex batch(BytewiseComparator(), 20, true /* overwrite_key */);
-
-  ASSERT_OK(batch.Put("A", "a"));
-  ASSERT_OK(batch.Put("A", "a2"));
-  ASSERT_OK(batch.Put("B", "b"));
-  ASSERT_OK(batch.SingleDelete("A"));
-  ASSERT_OK(batch.Delete("B"));
+  ASSERT_OK(batch_->Put("A", "a"));
+  ASSERT_OK(batch_->Put("A", "a2"));
+  ASSERT_OK(batch_->Put("B", "b"));
+  ASSERT_OK(batch_->SingleDelete("A"));
+  ASSERT_OK(batch_->Delete("B"));
 
   KVMap map;
-  value = PrintContents(&batch, &map, nullptr);
+  value = PrintContents(batch_.get(), &map, nullptr);
   ASSERT_EQ("", value);
 
   map["A"] = "aa";
   map["C"] = "cc";
   map["D"] = "dd";
 
-  ASSERT_OK(batch.SingleDelete("B"));
-  ASSERT_OK(batch.SingleDelete("C"));
-  ASSERT_OK(batch.SingleDelete("Z"));
+  ASSERT_OK(batch_->SingleDelete("B"));
+  ASSERT_OK(batch_->SingleDelete("C"));
+  ASSERT_OK(batch_->SingleDelete("Z"));
 
-  value = PrintContents(&batch, &map, nullptr);
+  value = PrintContents(batch_.get(), &map, nullptr);
   ASSERT_EQ("D:dd,", value);
 
-  ASSERT_OK(batch.Put("A", "a3"));
-  ASSERT_OK(batch.Put("B", "b3"));
-  ASSERT_OK(batch.SingleDelete("A"));
-  ASSERT_OK(batch.SingleDelete("A"));
-  ASSERT_OK(batch.SingleDelete("D"));
-  ASSERT_OK(batch.SingleDelete("D"));
-  ASSERT_OK(batch.Delete("D"));
+  ASSERT_OK(batch_->Put("A", "a3"));
+  ASSERT_OK(batch_->Put("B", "b3"));
+  ASSERT_OK(batch_->SingleDelete("A"));
+  ASSERT_OK(batch_->SingleDelete("A"));
+  ASSERT_OK(batch_->SingleDelete("D"));
+  ASSERT_OK(batch_->SingleDelete("D"));
+  ASSERT_OK(batch_->Delete("D"));
 
   map["E"] = "ee";
 
-  value = PrintContents(&batch, &map, nullptr);
+  value = PrintContents(batch_.get(), &map, nullptr);
   ASSERT_EQ("B:b3,E:ee,", value);
 }
 
+TEST_P(WriteBatchWithIndexTest, MultiGetTest) {
+  // MultiGet a lot of keys in order to force std::vector reallocations
+  std::vector<std::string> keys;
+  for (int i = 0; i < 100; ++i) {
+    keys.emplace_back(std::to_string(i));
+  }
+
+  ASSERT_OK(OpenDB());
+  ColumnFamilyHandle* cf0 = db_->DefaultColumnFamily();
+
+  // Write some data to the db for the even numbered keys
+  {
+    WriteBatch wb;
+    for (size_t i = 0; i < keys.size(); i += 2) {
+      std::string val = "val" + std::to_string(i);
+      ASSERT_OK(wb.Put(cf0, keys[i], val));
+    }
+    ASSERT_OK(db_->Write(write_opts_, &wb));
+    for (size_t i = 0; i < keys.size(); i += 2) {
+      std::string value;
+      ASSERT_OK(db_->Get(read_opts_, cf0, keys[i], &value));
+    }
+  }
+
+  // Write some data to the batch
+  for (size_t i = 0; i < keys.size(); ++i) {
+    if ((i % 5) == 0) {
+      ASSERT_OK(batch_->Delete(cf0, keys[i]));
+    } else if ((i % 7) == 0) {
+      std::string val = "new" + std::to_string(i);
+      ASSERT_OK(batch_->Put(cf0, keys[i], val));
+    }
+    if (i > 0 && (i % 3) == 0) {
+      ASSERT_OK(batch_->Merge(cf0, keys[i], "merge"));
+    }
+  }
+
+  std::vector<Slice> key_slices;
+  for (size_t i = 0; i < keys.size(); ++i) {
+    key_slices.emplace_back(keys[i]);
+  }
+  std::vector<PinnableSlice> values(keys.size());
+  std::vector<Status> statuses(keys.size());
+
+  batch_->MultiGetFromBatchAndDB(db_, read_opts_, cf0, key_slices.size(),
+                                 key_slices.data(), values.data(),
+                                 statuses.data(), false);
+  for (size_t i = 0; i < keys.size(); ++i) {
+    if (i == 0) {
+      ASSERT_TRUE(statuses[i].IsNotFound());
+    } else if ((i % 3) == 0) {
+      ASSERT_OK(statuses[i]);
+      if ((i % 5) == 0) {  // Merge after Delete
+        ASSERT_EQ(values[i], "merge");
+      } else if ((i % 7) == 0) {  // Merge after Put
+        std::string val = "new" + std::to_string(i);
+        ASSERT_EQ(values[i], val + ",merge");
+      } else if ((i % 2) == 0) {
+        std::string val = "val" + std::to_string(i);
+        ASSERT_EQ(values[i], val + ",merge");
+      } else {
+        ASSERT_EQ(values[i], "merge");
+      }
+    } else if ((i % 5) == 0) {
+      ASSERT_TRUE(statuses[i].IsNotFound());
+    } else if ((i % 7) == 0) {
+      ASSERT_OK(statuses[i]);
+      ASSERT_EQ(values[i], "new" + std::to_string(i));
+    } else if ((i % 2) == 0) {
+      ASSERT_OK(statuses[i]);
+      ASSERT_EQ(values[i], "val" + std::to_string(i));
+    } else {
+      ASSERT_TRUE(statuses[i].IsNotFound());
+    }
+  }
+}
+TEST_P(WriteBatchWithIndexTest, MultiGetTest2) {
+  // MultiGet a lot of keys in order to force std::vector reallocations
+  const int num_keys = 700;
+  const int keys_per_pass = 100;
+  std::vector<std::string> keys;
+  for (size_t i = 0; i < num_keys; ++i) {
+    keys.emplace_back(std::to_string(i));
+  }
+  ASSERT_OK(OpenDB());
+  ColumnFamilyHandle* cf0 = db_->DefaultColumnFamily();
+
+  // Keys   0- 99 have a PUT in the batch but not DB
+  // Keys 100-199 have a PUT in the DB
+  // Keys 200-299 Have a PUT/DELETE
+  // Keys 300-399 Have a PUT/DELETE/MERGE
+  // Keys 400-499 have a PUT/MERGE
+  // Keys 500-599 have a MERGE only
+  // Keys 600-699 were never written
+  {
+    WriteBatch wb;
+    for (size_t i = 100; i < 500; i++) {
+      std::string val = std::to_string(i);
+      ASSERT_OK(wb.Put(cf0, keys[i], val));
+    }
+    ASSERT_OK(db_->Write(write_opts_, &wb));
+  }
+  ASSERT_OK(db_->Flush(FlushOptions(), cf0));
+  for (size_t i = 0; i < 100; i++) {
+    ASSERT_OK(batch_->Put(cf0, keys[i], keys[i]));
+  }
+  for (size_t i = 200; i < 400; i++) {
+    ASSERT_OK(batch_->Delete(cf0, keys[i]));
+  }
+  for (size_t i = 300; i < 600; i++) {
+    std::string val = std::to_string(i) + "m";
+    ASSERT_OK(batch_->Merge(cf0, keys[i], val));
+  }
+
+  Random rnd(301);
+  std::vector<PinnableSlice> values(keys_per_pass);
+  std::vector<Status> statuses(keys_per_pass);
+  for (int pass = 0; pass < 40; pass++) {
+    std::vector<Slice> key_slices;
+    for (size_t i = 0; i < keys_per_pass; i++) {
+      int random = rnd.Uniform(num_keys);
+      key_slices.emplace_back(keys[random]);
+    }
+    batch_->MultiGetFromBatchAndDB(db_, read_opts_, cf0, keys_per_pass,
+                                   key_slices.data(), values.data(),
+                                   statuses.data(), false);
+    for (size_t i = 0; i < keys_per_pass; i++) {
+      int key = ParseInt(key_slices[i].ToString());
+      switch (key / 100) {
+        case 0:  // 0-99 PUT only
+          ASSERT_OK(statuses[i]);
+          ASSERT_EQ(values[i], key_slices[i].ToString());
+          break;
+        case 1:  // 100-199 PUT only
+          ASSERT_OK(statuses[i]);
+          ASSERT_EQ(values[i], key_slices[i].ToString());
+          break;
+        case 2:  // 200-299 Deleted
+          ASSERT_TRUE(statuses[i].IsNotFound());
+          break;
+        case 3:  // 300-399 Delete+Merge
+          ASSERT_OK(statuses[i]);
+          ASSERT_EQ(values[i], key_slices[i].ToString() + "m");
+          break;
+        case 4:  // 400-400 Put+ Merge
+          ASSERT_OK(statuses[i]);
+          ASSERT_EQ(values[i], key_slices[i].ToString() + "," +
+                                   key_slices[i].ToString() + "m");
+          break;
+        case 5:  // Merge only
+          ASSERT_OK(statuses[i]);
+          ASSERT_EQ(values[i], key_slices[i].ToString() + "m");
+          break;
+        case 6:  // Never written
+          ASSERT_TRUE(statuses[i].IsNotFound());
+          break;
+        default:
+          assert(false);
+      }  // end switch
+    }    // End for each key
+  }      // end for passes
+}
+
+// This test has merges, but the merge does not play into the final result
+TEST_P(WriteBatchWithIndexTest, FakeMergeWithIteratorTest) {
+  ASSERT_OK(OpenDB());
+  ColumnFamilyHandle* cf0 = db_->DefaultColumnFamily();
+
+  // The map we are starting with
+  KVMap input = {
+      {"odm", "odm0"},
+      {"omd", "omd0"},
+      {"omp", "omp0"},
+  };
+  KVMap result = {
+      {"odm", "odm2"},  // Orig, Delete, Merge
+      {"mp", "mp1"},    // Merge, Put
+      {"omp", "omp2"},  // Origi, Merge, Put
+      {"mmp", "mmp2"}   // Merge, Merge, Put
+  };
+
+  for (auto& iter : result) {
+    EXPECT_EQ(AddToBatch(cf0, iter.first), iter.second);
+  }
+  AddToBatch(cf0, "md");   // Merge, Delete
+  AddToBatch(cf0, "mmd");  // Merge, Merge, Delete
+  AddToBatch(cf0, "omd");  // Orig, Merge, Delete
+
+  KVIter kvi(&result);
+  // First try just the batch
+  std::unique_ptr<Iterator> iter(
+      batch_->NewIteratorWithBase(cf0, new KVIter(&input)));
+  AssertItersEqual(iter.get(), &kvi);
+}
+
+TEST_P(WriteBatchWithIndexTest, IteratorMergeTest) {
+  ASSERT_OK(OpenDB());
+  ColumnFamilyHandle* cf0 = db_->DefaultColumnFamily();
+
+  KVMap result = {
+      {"m", "m0"},                // Merge
+      {"mm", "mm0,mm1"},          // Merge, Merge
+      {"dm", "dm1"},              // Delete, Merge
+      {"dmm", "dmm1,dmm2"},       // Delete, Merge, Merge
+      {"mdm", "mdm2"},            // Merge, Delete, Merge
+      {"mpm", "mpm1,mpm2"},       // Merge, Put, Merge
+      {"pm", "pm0,pm1"},          // Put, Merge
+      {"pmm", "pmm0,pmm1,pmm2"},  // Put, Merge, Merge
+  };
+
+  for (auto& iter : result) {
+    EXPECT_EQ(AddToBatch(cf0, iter.first), iter.second);
+  }
+
+  KVIter kvi(&result);
+  // First try just the batch
+  KVMap empty_map;
+  std::unique_ptr<Iterator> iter(
+      batch_->NewIteratorWithBase(cf0, new KVIter(&empty_map)));
+  AssertItersEqual(iter.get(), &kvi);
+}
+
+TEST_P(WriteBatchWithIndexTest, IteratorMergeTestWithOrig) {
+  ASSERT_OK(OpenDB());
+  ColumnFamilyHandle* cf0 = db_->DefaultColumnFamily();
+  KVMap original;
+  KVMap results = {
+      {"m", "om,m0"},             // Merge
+      {"mm", "omm,mm0,mm1"},      // Merge, Merge
+      {"dm", "dm1"},              // Delete, Merge
+      {"dmm", "dmm1,dmm2"},       // Delete, Merge, Merge
+      {"mdm", "mdm2"},            // Merge, Delete, Merge
+      {"mpm", "mpm1,mpm2"},       // Merge, Put, Merge
+      {"pm", "pm0,pm1"},          // Put, Merge
+      {"pmm", "pmm0,pmm1,pmm2"},  // Put, Merge, Merge
+  };
+
+  for (auto& iter : results) {
+    AddToBatch(cf0, iter.first);
+    original[iter.first] = "o" + iter.first;
+  }
+
+  KVIter kvi(&results);
+  // First try just the batch
+  std::unique_ptr<Iterator> iter(
+      batch_->NewIteratorWithBase(cf0, new KVIter(&original)));
+  AssertItersEqual(iter.get(), &kvi);
+}
+
+TEST_P(WriteBatchWithIndexTest, GetFromBatchAfterMerge) {
+  std::string value;
+  Status s;
+
+  ASSERT_OK(OpenDB());
+  ASSERT_OK(db_->Put(write_opts_, "o", "aa"));
+  batch_->Merge("o", "bb");  // Merging bb under key "o"
+  batch_->Merge("m", "cc");  // Merging bc under key "m"
+  s = batch_->GetFromBatch(options_, "m", &value);
+  ASSERT_EQ(s.code(), Status::Code::kMergeInProgress);
+  s = batch_->GetFromBatch(options_, "o", &value);
+  ASSERT_EQ(s.code(), Status::Code::kMergeInProgress);
+
+  ASSERT_OK(db_->Write(write_opts_, batch_->GetWriteBatch()));
+  ASSERT_OK(db_->Get(read_opts_, "o", &value));
+  ASSERT_EQ(value, "aa,bb");
+  ASSERT_OK(db_->Get(read_opts_, "m", &value));
+  ASSERT_EQ(value, "cc");
+}
+
+TEST_P(WriteBatchWithIndexTest, GetFromBatchAndDBAfterMerge) {
+  std::string value;
+
+  ASSERT_OK(OpenDB());
+  ASSERT_OK(db_->Put(write_opts_, "o", "aa"));
+  ASSERT_OK(batch_->Merge("o", "bb"));  // Merging bb under key "o"
+  ASSERT_OK(batch_->Merge("m", "cc"));  // Merging bc under key "m"
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "o", &value));
+  ASSERT_EQ(value, "aa,bb");
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "m", &value));
+  ASSERT_EQ(value, "cc");
+}
+
+TEST_F(WBWIKeepTest, GetAfterPut) {
+  std::string value;
+  ASSERT_OK(OpenDB());
+  ColumnFamilyHandle* cf0 = db_->DefaultColumnFamily();
+
+  ASSERT_OK(db_->Put(write_opts_, "key", "orig"));
+
+  ASSERT_OK(batch_->Put("key", "aa"));  // Writing aa under key
+  ASSERT_OK(batch_->GetFromBatch(cf0, options_, "key", &value));
+  ASSERT_EQ(value, "aa");
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "aa");
+
+  ASSERT_OK(batch_->Merge("key", "bb"));  // Merging bb under key
+  ASSERT_OK(batch_->GetFromBatch(cf0, options_, "key", &value));
+  ASSERT_EQ(value, "aa,bb");
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "aa,bb");
+
+  ASSERT_OK(batch_->Merge("key", "cc"));  // Merging cc under key
+  ASSERT_OK(batch_->GetFromBatch(cf0, options_, "key", &value));
+  ASSERT_EQ(value, "aa,bb,cc");
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "aa,bb,cc");
+}
+
+TEST_P(WriteBatchWithIndexTest, GetAfterMergePut) {
+  std::string value;
+  ASSERT_OK(OpenDB());
+  ColumnFamilyHandle* cf0 = db_->DefaultColumnFamily();
+  ASSERT_OK(db_->Put(write_opts_, "key", "orig"));
+
+  ASSERT_OK(batch_->Merge("key", "aa"));  // Merging aa under key
+  Status s = batch_->GetFromBatch(cf0, options_, "key", &value);
+  ASSERT_EQ(s.code(), Status::Code::kMergeInProgress);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "orig,aa");
+
+  ASSERT_OK(batch_->Merge("key", "bb"));  // Merging bb under key
+  s = batch_->GetFromBatch(cf0, options_, "key", &value);
+  ASSERT_EQ(s.code(), Status::Code::kMergeInProgress);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "orig,aa,bb");
+
+  ASSERT_OK(batch_->Put("key", "cc"));  // Writing cc under key
+  ASSERT_OK(batch_->GetFromBatch(cf0, options_, "key", &value));
+  ASSERT_EQ(value, "cc");
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "cc");
+
+  ASSERT_OK(batch_->Merge("key", "dd"));  // Merging dd under key
+  ASSERT_OK(batch_->GetFromBatch(cf0, options_, "key", &value));
+  ASSERT_EQ(value, "cc,dd");
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "cc,dd");
+}
+
+TEST_P(WriteBatchWithIndexTest, GetAfterMergeDelete) {
+  std::string value;
+  ASSERT_OK(OpenDB());
+  ColumnFamilyHandle* cf0 = db_->DefaultColumnFamily();
+
+  ASSERT_OK(batch_->Merge("key", "aa"));  // Merging aa under key
+  Status s = batch_->GetFromBatch(cf0, options_, "key", &value);
+  ASSERT_EQ(s.code(), Status::Code::kMergeInProgress);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "aa");
+
+  ASSERT_OK(batch_->Merge("key", "bb"));  // Merging bb under key
+  s = batch_->GetFromBatch(cf0, options_, "key", &value);
+  ASSERT_EQ(s.code(), Status::Code::kMergeInProgress);
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "aa,bb");
+
+  ASSERT_OK(batch_->Delete("key"));  // Delete key from batch
+  s = batch_->GetFromBatch(cf0, options_, "key", &value);
+  ASSERT_TRUE(s.IsNotFound());
+  s = batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value);
+  ASSERT_TRUE(s.IsNotFound());
+
+  ASSERT_OK(batch_->Merge("key", "cc"));  // Merging cc under key
+  ASSERT_OK(batch_->GetFromBatch(cf0, options_, "key", &value));
+  ASSERT_EQ(value, "cc");
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "cc");
+  ASSERT_OK(batch_->Merge("key", "dd"));  // Merging dd under key
+  ASSERT_OK(batch_->GetFromBatch(cf0, options_, "key", &value));
+  ASSERT_EQ(value, "cc,dd");
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "key", &value));
+  ASSERT_EQ(value, "cc,dd");
+}
+
+TEST_F(WBWIOverwriteTest, TestBadMergeOperator) {
+  class FailingMergeOperator : public MergeOperator {
+   public:
+    FailingMergeOperator() {}
+
+    bool FullMergeV2(const MergeOperationInput& /*merge_in*/,
+                     MergeOperationOutput* /*merge_out*/) const override {
+      return false;
+    }
+
+    const char* Name() const override { return "Failing"; }
+  };
+  options_.merge_operator.reset(new FailingMergeOperator());
+  ASSERT_OK(OpenDB());
+
+  ColumnFamilyHandle* column_family = db_->DefaultColumnFamily();
+  std::string value;
+
+  ASSERT_OK(db_->Put(write_opts_, "a", "a0"));
+  ASSERT_OK(batch_->Put("b", "b0"));
+
+  ASSERT_OK(batch_->Merge("a", "a1"));
+  ASSERT_NOK(batch_->GetFromBatchAndDB(db_, read_opts_, "a", &value));
+  ASSERT_NOK(batch_->GetFromBatch(column_family, options_, "a", &value));
+  ASSERT_OK(batch_->GetFromBatchAndDB(db_, read_opts_, "b", &value));
+  ASSERT_OK(batch_->GetFromBatch(column_family, options_, "b", &value));
+}
+
+TEST_P(WriteBatchWithIndexTest, ColumnFamilyWithTimestamp) {
+  ColumnFamilyHandleImplDummy cf2(2,
+                                  test::BytewiseComparatorWithU64TsWrapper());
+
+  // Sanity checks
+  ASSERT_TRUE(batch_->Put(&cf2, "key", "ts", "value").IsNotSupported());
+  ASSERT_TRUE(batch_->Put(/*column_family=*/nullptr, "key", "ts", "value")
+                  .IsInvalidArgument());
+  ASSERT_TRUE(batch_->Delete(&cf2, "key", "ts").IsNotSupported());
+  ASSERT_TRUE(batch_->Delete(/*column_family=*/nullptr, "key", "ts")
+                  .IsInvalidArgument());
+  ASSERT_TRUE(batch_->SingleDelete(&cf2, "key", "ts").IsNotSupported());
+  ASSERT_TRUE(batch_->SingleDelete(/*column_family=*/nullptr, "key", "ts")
+                  .IsInvalidArgument());
+  {
+    std::string value;
+    ASSERT_TRUE(batch_
+                    ->GetFromBatchAndDB(
+                        /*db=*/nullptr, ReadOptions(), &cf2, "key", &value)
+                    .IsInvalidArgument());
+  }
+  {
+    constexpr size_t num_keys = 2;
+    std::array<Slice, num_keys> keys{{Slice(), Slice()}};
+    std::array<PinnableSlice, num_keys> pinnable_vals{
+        {PinnableSlice(), PinnableSlice()}};
+    std::array<Status, num_keys> statuses{{Status(), Status()}};
+    constexpr bool sorted_input = false;
+    batch_->MultiGetFromBatchAndDB(/*db=*/nullptr, ReadOptions(), &cf2,
+                                   num_keys, keys.data(), pinnable_vals.data(),
+                                   statuses.data(), sorted_input);
+    for (const auto& s : statuses) {
+      ASSERT_TRUE(s.IsInvalidArgument());
+    }
+  }
+
+  constexpr uint32_t kMaxKey = 10;
+
+  const auto ts_sz_lookup = [&cf2](uint32_t id) {
+    if (cf2.GetID() == id) {
+      return sizeof(uint64_t);
+    } else {
+      return std::numeric_limits<size_t>::max();
+    }
+  };
+
+  // Put keys
+  for (uint32_t i = 0; i < kMaxKey; ++i) {
+    std::string key;
+    PutFixed32(&key, i);
+    Status s = batch_->Put(&cf2, key, "value" + std::to_string(i));
+    ASSERT_OK(s);
+  }
+
+  WriteBatch* wb = batch_->GetWriteBatch();
+  assert(wb);
+  ASSERT_OK(
+      wb->UpdateTimestamps(std::string(sizeof(uint64_t), '\0'), ts_sz_lookup));
+
+  // Point lookup
+  for (uint32_t i = 0; i < kMaxKey; ++i) {
+    std::string value;
+    std::string key;
+    PutFixed32(&key, i);
+    Status s = batch_->GetFromBatch(&cf2, Options(), key, &value);
+    ASSERT_OK(s);
+    ASSERT_EQ("value" + std::to_string(i), value);
+  }
+
+  // Iterator
+  {
+    std::unique_ptr<WBWIIterator> it(batch_->NewIterator(&cf2));
+    uint32_t start = 0;
+    for (it->SeekToFirst(); it->Valid(); it->Next(), ++start) {
+      std::string key;
+      PutFixed32(&key, start);
+      ASSERT_OK(it->status());
+      ASSERT_EQ(key, it->Entry().key);
+      ASSERT_EQ("value" + std::to_string(start), it->Entry().value);
+      ASSERT_EQ(WriteType::kPutRecord, it->Entry().type);
+    }
+    ASSERT_EQ(kMaxKey, start);
+  }
+
+  // Delete the keys with Delete() or SingleDelete()
+  for (uint32_t i = 0; i < kMaxKey; ++i) {
+    std::string key;
+    PutFixed32(&key, i);
+    Status s;
+    if (0 == (i % 2)) {
+      s = batch_->Delete(&cf2, key);
+    } else {
+      s = batch_->SingleDelete(&cf2, key);
+    }
+    ASSERT_OK(s);
+  }
+
+  ASSERT_OK(wb->UpdateTimestamps(std::string(sizeof(uint64_t), '\xfe'),
+                                 ts_sz_lookup));
+
+  for (uint32_t i = 0; i < kMaxKey; ++i) {
+    std::string value;
+    std::string key;
+    PutFixed32(&key, i);
+    Status s = batch_->GetFromBatch(&cf2, Options(), key, &value);
+    ASSERT_TRUE(s.IsNotFound());
+  }
+
+  // Iterator
+  {
+    const bool overwrite = GetParam();
+    std::unique_ptr<WBWIIterator> it(batch_->NewIterator(&cf2));
+    uint32_t start = 0;
+    for (it->SeekToFirst(); it->Valid(); it->Next(), ++start) {
+      std::string key;
+      PutFixed32(&key, start);
+      ASSERT_EQ(key, it->Entry().key);
+      if (!overwrite) {
+        ASSERT_EQ(WriteType::kPutRecord, it->Entry().type);
+        it->Next();
+        ASSERT_TRUE(it->Valid());
+      }
+      if (0 == (start % 2)) {
+        ASSERT_EQ(WriteType::kDeleteRecord, it->Entry().type);
+      } else {
+        ASSERT_EQ(WriteType::kSingleDeleteRecord, it->Entry().type);
+      }
+    }
+  }
+}
+
+INSTANTIATE_TEST_CASE_P(WBWI, WriteBatchWithIndexTest, testing::Bool());
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {