Add deltaiterator upperbound check

utilities/transactions/transaction_test.cc

@@ -6657,6 +6657,61 @@ TEST_P(TransactionTest, StallTwoWriteQueues) {
   ASSERT_TRUE(t2_completed);
 }
 
+TEST_P(TransactionTest, TnxIteratorWithUpperBound) {
+  if (txn_db_options.write_policy != WRITE_COMMITTED) {
+    return;
+  }
+
+  WriteOptions write_options;
+  ReadOptions read_options;
+
+  Transaction* txn = db->BeginTransaction(write_options);
+  ASSERT_TRUE(txn);
+
+  ASSERT_OK(txn->Put("2", "2"));
+  ASSERT_OK(txn->Put("1", "1"));
+  ASSERT_OK(txn->Put("3", "3"));
+
+  {
+    Slice upper_bound = "2";
+    read_options.iterate_upper_bound = &upper_bound;
+    Iterator* iter = txn->GetIterator(read_options);
+    ASSERT_OK(iter->status());
+
+    iter->SeekToFirst();
+    while (iter->Valid()) {
+      ASSERT_EQ("1", iter->key().ToString());
+      iter->Next();
+    }
+
+    // iter is reusable
+    iter->SeekToFirst();
+    ASSERT_TRUE(iter->Valid());
+    delete iter;
+  }
+
+  {
+    Slice upper_bound = "4";
+    read_options.iterate_upper_bound = &upper_bound;
+
+    std::string results[] = {"1", "2", "3"};
+
+    Iterator* forward_iter = txn->GetIterator(read_options);
+
+    forward_iter->SeekToFirst();
+    for (int i = 0; i < 3; i++) {
+      ASSERT_TRUE(forward_iter->Valid());
+      ASSERT_EQ(results[i], forward_iter->key().ToString());
+
+      forward_iter->Next();
+    }
+
+    delete forward_iter;
+  }
+
+  delete txn;
+}
+
 // Make sure UnlockWAL does not return until the stall it controls is cleared.
 TEST_P(TransactionTest, UnlockWALStallCleared) {
   auto dbimpl = static_cast_with_check<DBImpl>(db->GetRootDB());

utilities/write_batch_with_index/write_batch_with_index.cc

@@ -299,9 +299,10 @@ WBWIIterator* WriteBatchWithIndex::NewIterator(
 Iterator* WriteBatchWithIndex::NewIteratorWithBase(
     ColumnFamilyHandle* column_family, Iterator* base_iterator,
     const ReadOptions* read_options) {
-  auto wbwiii =
-      new WBWIIteratorImpl(GetColumnFamilyID(column_family), &(rep->skip_list),
-                           &rep->write_batch, &rep->comparator);
+  auto wbwiii = new WBWIIteratorImpl(
+      GetColumnFamilyID(column_family), &(rep->skip_list), &rep->write_batch,
+      &rep->comparator,
+      read_options == nullptr ? nullptr : read_options->iterate_upper_bound);
   return new BaseDeltaIterator(column_family, base_iterator, wbwiii,
                                GetColumnFamilyUserComparator(column_family),
                                read_options);

utilities/write_batch_with_index/write_batch_with_index_internal.cc

@@ -273,6 +273,7 @@ void BaseDeltaIterator::AdvanceBase() {
 
 bool BaseDeltaIterator::BaseValid() const { return base_iterator_->Valid(); }
 bool BaseDeltaIterator::DeltaValid() const { return delta_iterator_->Valid(); }
+
 void BaseDeltaIterator::UpdateCurrent() {
 // Suppress false positive clang analyzer warnings.
 #ifndef __clang_analyzer__
@@ -307,7 +308,7 @@ void BaseDeltaIterator::UpdateCurrent() {
         if (comparator_->CompareWithoutTimestamp(
                 delta_entry.key, /*a_has_ts=*/false, *iterate_upper_bound_,
                 /*b_has_ts=*/false) >= 0) {
-          // out of upper bound -> finished.
+          // out of upper bound -> delta finished.
           return;
         }
       }

utilities/write_batch_with_index/write_batch_with_index_internal.h

@@ -200,6 +200,18 @@ class WBWIIteratorImpl : public WBWIIterator {
       : column_family_id_(column_family_id),
         skip_list_iter_(skip_list),
         write_batch_(write_batch),
+        iterate_upper_bound_(nullptr),
+        comparator_(comparator) {}
+
+  WBWIIteratorImpl(uint32_t column_family_id,
+                   WriteBatchEntrySkipList* skip_list,
+                   const ReadableWriteBatch* write_batch,
+                   WriteBatchEntryComparator* comparator,
+                   const Slice* iterate_upper_bound)
+      : column_family_id_(column_family_id),
+        skip_list_iter_(skip_list),
+        write_batch_(write_batch),
+        iterate_upper_bound_(iterate_upper_bound),
         comparator_(comparator) {}
 
   ~WBWIIteratorImpl() override {}
@@ -209,8 +221,18 @@ class WBWIIteratorImpl : public WBWIIterator {
       return false;
     }
     const WriteBatchIndexEntry* iter_entry = skip_list_iter_.key();
-    return (iter_entry != nullptr &&
-            iter_entry->column_family == column_family_id_);
+
+    if (iter_entry == nullptr ||
+        iter_entry->column_family != column_family_id_) {
+      return false;
+    }
+
+    if (iterate_upper_bound_ == nullptr) {
+      return true;
+    } else {
+      return comparator_->CompareKey(column_family_id_, *iterate_upper_bound_,
+                                     Entry().key) > 0;
+    }
   }
 
   void SeekToFirst() override {
@@ -288,6 +310,7 @@ class WBWIIteratorImpl : public WBWIIterator {
   uint32_t column_family_id_;
   WriteBatchEntrySkipList::Iterator skip_list_iter_;
   const ReadableWriteBatch* write_batch_;
+  const Slice* iterate_upper_bound_;
   WriteBatchEntryComparator* comparator_;
 };