@nxtedition/rocksdb 13.5.7 → 13.5.9

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

@@ -42,7 +42,8 @@ BaseDeltaIterator::BaseDeltaIterator(ColumnFamilyHandle* column_family,
 BaseDeltaIterator::~BaseDeltaIterator() = default;
 
 bool BaseDeltaIterator::Valid() const {
-  return status_.ok() ? (current_at_base_ ? BaseValid() : DeltaValid()) : false;
+  return status().ok() ? (current_at_base_ ? BaseValid() : DeltaValid())
+                       : false;
 }
 
 void BaseDeltaIterator::SeekToFirst() {
@@ -89,14 +90,22 @@ void BaseDeltaIterator::Next() {
     equal_keys_ = false;
     if (!BaseValid()) {
       assert(DeltaValid());
+      // During reverse scan, base iter was exhausted. This means the
+      // base iter has no smaller key than the current key at delta iter.
+      // So seeking to the first key of base iter will point to base iter's
+      // first key that is at least the current key.
       base_iterator_->SeekToFirst();
     } else if (!DeltaValid()) {
+      // Similar to the base iter case above, position delta iter to the first
+      // entry that is at least the current key.
       delta_iterator_->SeekToFirst();
     } else if (current_at_base_) {
-      // Change delta from larger than base to smaller
+      // current_at_base_ means delta iter is at its first key that is less
+      // than current key. So advance delta one step moves it to the first
+      // key that is at least the current key.
       AdvanceDelta();
     } else {
-      // Change base from larger than delta to smaller
+      // Similar to the case above.
       AdvanceBase();
     }
     if (DeltaValid() && BaseValid()) {
@@ -289,6 +298,9 @@ void BaseDeltaIterator::SetValueAndColumnsFromDelta() {
   WriteEntry delta_entry = delta_iterator_->Entry();
 
   if (merge_context_.GetNumOperands() == 0) {
+    // delete case is handled at callsites, see UpdateCurrent().
+    assert(delta_entry.type == kPutRecord ||
+           delta_entry.type == kPutEntityRecord);
     if (delta_entry.type == kPutRecord) {
       value_ = delta_entry.value;
       columns_.emplace_back(kDefaultWideColumnName, value_);
@@ -411,13 +423,14 @@ void BaseDeltaIterator::UpdateCurrent() {
         return;
       }
 
-      // Base has finished.
       if (!DeltaValid()) {
-        // Finished
+        // Finished, neither base nor delta is valid.
         return;
       }
+      // Base is done, delta has value.
       if (delta_result == WBWIIteratorImpl::kDeleted &&
           merge_context_.GetNumOperands() == 0) {
+        // This key is deleted and no Merge is done after Delete.
         AdvanceDelta();
       } else {
         current_at_base_ = false;
@@ -425,13 +438,14 @@ void BaseDeltaIterator::UpdateCurrent() {
         return;
       }
     } else if (!DeltaValid()) {
-      // Delta has finished.
+      // Delta is done, base has value.
       current_at_base_ = true;
       if (!allow_unprepared_value_) {
         SetValueAndColumnsFromBase();
       }
       return;
     } else {
+      // Both are valid.
       int compare =
           (forward_ ? 1 : -1) * comparator_->CompareWithoutTimestamp(
                                     delta_entry.key, /*a_has_ts=*/false,
@@ -442,6 +456,7 @@ void BaseDeltaIterator::UpdateCurrent() {
         }
         if (delta_result != WBWIIteratorImpl::kDeleted ||
             merge_context_.GetNumOperands() > 0) {
+          // delta is visible
           current_at_base_ = false;
           SetValueAndColumnsFromDelta();
           return;
@@ -452,6 +467,7 @@ void BaseDeltaIterator::UpdateCurrent() {
           AdvanceBase();
         }
       } else {
+        // base smaller than delta
         current_at_base_ = true;
         if (!allow_unprepared_value_) {
           SetValueAndColumnsFromBase();
@@ -459,12 +475,15 @@ void BaseDeltaIterator::UpdateCurrent() {
         return;
       }
     }
+    // delta <= base and is not visible (most recent update is delete)
+    // move on to the next key
   }
 
   AssertInvariants();
 #endif  // __clang_analyzer__
 }
 
+// Move forward/backward until the iterator is at a different key.
 void WBWIIteratorImpl::AdvanceKey(bool forward) {
   if (Valid()) {
     Slice key = Entry().key;
@@ -515,18 +534,17 @@ WBWIIteratorImpl::Result WBWIIteratorImpl::FindLatestUpdate(
              0) {
     return result;
   } else {
-    // We want to iterate in the reverse order that the writes were added to the
-    // batch.  Since we don't have a reverse iterator, we must seek past the
-    // end. We do this by seeking to the next key, and then back one step
-    NextKey();
+    // Need to move to the first entry of the current key
+    // We may not always be at the first entry, e.g., after SeekToLast() or a
+    // SeekForPrev().
+    AdvanceKey(false);
     if (Valid()) {
-      Prev();
+      Next();
     } else {
-      SeekToLast();
+      SeekToFirst();
     }
-
-    // We are at the end of the iterator for this key.  Search backwards for the
-    // last Put or Delete, accumulating merges along the way.
+    // We are at the first and most recent entry for this key, search forward
+    // until a non-Merge entry, accumulating merges along the way.
     while (Valid()) {
       const WriteEntry entry = Entry();
       if (comparator_->CompareKey(column_family_id_, entry.key, key) != 0) {
@@ -551,18 +569,21 @@ WBWIIteratorImpl::Result WBWIIteratorImpl::FindLatestUpdate(
         case kPutEntityRecord:
           return WBWIIteratorImpl::kFound;
         default:
+          assert(false);
           return WBWIIteratorImpl::kError;
       }  // end switch statement
-      Prev();
+      Next();
     }  // End while Valid()
     // At this point, we have been through the whole list and found no Puts or
-    // Deletes. The iterator points to the previous key.  Move the iterator back
-    // onto this one.
+    // Deletes. The iterator points to the next key.  Move the iterator back
+    // to the last entry of this key (see comment for FindLatestUpdate()).
     if (Valid()) {
-      Next();
+      Prev();
     } else {
-      SeekToFirst();
+      SeekToLast();
     }
+    assert(Valid());
+    assert(comparator_->CompareKey(column_family_id_, Entry().key, key) == 0);
   }
   return result;
 }
@@ -650,7 +671,8 @@ Status ReadableWriteBatch::GetEntryFromDataOffset(size_t data_offset,
 // 2. Inside the same CF, we first decode the entry to find the key of the entry
 //    and the entry with larger key will be larger;
 // 3. If two entries are of the same CF and key, the one with larger offset
-//    will be larger.
+//    will be smaller. This follows the internal key order where keys
+//    with larger sequence number (larger offset here) will be ordered first.
 // Some times either `entry1` or `entry2` is dummy entry, which is actually
 // a search key. In this case, in step 2, we don't go ahead and decode the
 // entry but use the value in WriteBatchIndexEntry::search_key.
@@ -691,9 +713,9 @@ int WriteBatchEntryComparator::operator()(
   int cmp = CompareKey(entry1->column_family, key1, key2);
   if (cmp != 0) {
     return cmp;
-  } else if (entry1->offset > entry2->offset) {
-    return 1;
   } else if (entry1->offset < entry2->offset) {
+    return 1;
+  } else if (entry1->offset > entry2->offset) {
     return -1;
   }
   return 0;

package/deps/rocksdb/rocksdb/utilities/write_batch_with_index/write_batch_with_index_internal.h

@@ -74,6 +74,8 @@ class BaseDeltaIterator : public Iterator {
 
  private:
   void AssertInvariants();
+  // Advance the current iterator to the next/prev key depending on forward_.
+  // If equal_keys_ is true, advance both base and delta iterators.
   void Advance();
   void AdvanceDelta();
   void AdvanceBase();
@@ -81,10 +83,17 @@ class BaseDeltaIterator : public Iterator {
   bool DeltaValid() const;
   void ResetValueAndColumns();
   void SetValueAndColumnsFromBase();
+  // Requires calling delta_iterator_->FindLatestUpdate() before this call.
+  // Will update value_ and column_ accordingly and assumes that delta iterator
+  // is visible.
   void SetValueAndColumnsFromDelta();
+  // Determine the current key and value for the iterator from base and delta
+  // iterators. Advance base or delta iters if needed.
   void UpdateCurrent();
 
   bool forward_;
+  // The non-current iterator, if valid, is at its first key that is ahead of
+  // the current iterator.
   bool current_at_base_;
   bool equal_keys_;
   bool allow_unprepared_value_;
@@ -101,9 +110,10 @@ class BaseDeltaIterator : public Iterator {
 
 // Key used by skip list, as the binary searchable index of WriteBatchWithIndex.
 struct WriteBatchIndexEntry {
-  WriteBatchIndexEntry(size_t o, uint32_t c, size_t ko, size_t ksz)
+  WriteBatchIndexEntry(size_t o, uint32_t c, size_t ko, size_t ksz, uint32_t uc)
       : offset(o),
         column_family(c),
+        update_count(uc),
         has_single_del(false),
         has_overwritten_single_del(false),
         key_offset(ko),
@@ -119,10 +129,12 @@ struct WriteBatchIndexEntry {
   //                    _search_key should be null in this case.
   WriteBatchIndexEntry(const Slice* _search_key, uint32_t _column_family,
                        bool is_forward_direction, bool is_seek_to_first)
-      // For SeekForPrev(), we need to make the dummy entry larger than any
+      // For SeekForPrev(), we need to make the dummy entry no smaller than any
       // entry who has the same search key. Otherwise, we'll miss those entries.
-      : offset(is_forward_direction ? 0 : std::numeric_limits<size_t>::max()),
+      // Keys are ordered by descending offset.
+      : offset(is_forward_direction ? std::numeric_limits<size_t>::max() : 0),
         column_family(_column_family),
+        update_count(1),
         has_single_del(false),
         has_overwritten_single_del(false),
         key_offset(0),
@@ -141,25 +153,30 @@ struct WriteBatchIndexEntry {
     return key_size == kFlagMinInCf;
   }
 
-  // offset of an entry in write batch's string buffer. If this is a dummy
+  // The offset of an entry in write batch's string buffer. If this is a dummy
   // lookup key, in which case search_key != nullptr, offset is set to either
   // 0 or max, only for comparison purpose. Because when entries have the same
-  // key, the entry with larger offset is larger, offset = 0 will make a seek
-  // key small or equal than all the entries with the seek key, so that Seek()
-  // will find all the entries of the same key. Similarly, offset = MAX will
-  // make the entry just larger than all entries with the search key so
+  // key, the entry with larger offset is smaller, offset = MAX will make a seek
+  // key smaller than all the entries with the seek key, so that Seek()
+  // will find all the entries of the same key. Similarly, offset = 0 will
+  // make the entry larger than or equal to all entries with the seek key so
   // SeekForPrev() will see all the keys with the same key.
   size_t offset;
   uint32_t column_family;  // column family of the entry.
+  // The following three fields are only maintained when the WBWI is created
+  // with overwrite_key = true.
+  uint32_t update_count;   // The number of updates (1-based) for this key up to
+                           // this entry.
   bool has_single_del;     // whether single del was issued for this key
   bool has_overwritten_single_del;  // whether a single del for this key was
                                     // overwritten by another key
-  size_t key_offset;       // offset of the key in write batch's string buffer.
-  size_t key_size;         // size of the key. kFlagMinInCf indicates
-                           // that this is a dummy look up entry for
-                           // SeekToFirst() to the beginning of the column
-                           // family. We use the flag here to save a boolean
-                           // in the struct.
+  // The following two fields are used when search_key is null.
+  size_t key_offset;  // offset of the key in write batch's string buffer.
+  size_t key_size;    // size of the key. kFlagMinInCf indicates
+                      // that this is a dummy look up entry for
+                      // SeekToFirst() to the beginning of the column
+                      // family. We use the flag here to save a boolean
+                      // in the struct.
 
   const Slice* search_key;  // if not null, instead of reading keys from
                             // write batch, use it to compare. This is used
@@ -337,6 +354,11 @@ class WBWIIteratorImpl final : public WBWIIterator {
     return skip_list_iter_.key()->has_overwritten_single_del;
   }
 
+  uint32_t GetUpdateCount() const override {
+    assert(Valid());
+    return skip_list_iter_.key()->update_count;
+  }
+
   Status status() const override {
     // this is in-memory data structure, so the only way status can be non-ok is
     // through memory corruption
@@ -354,16 +376,21 @@ class WBWIIteratorImpl final : public WBWIIterator {
   // Moves the iterator to first entry of the next key.
   void NextKey();
 
-  // Moves the iterator to the Update (Put, PutEntity or Delete) for the current
-  // key. If there is no Put/PutEntity/Delete, the Iterator will point to the
-  // first entry for this key.
-  // @return kFound if a Put/PutEntity was found for the key
-  // @return kDeleted if a delete was found for the key
-  // @return kMergeInProgress if only merges were found for the key
-  // @return kError if an unsupported operation was found for the key
-  // @return kNotFound if no operations were found for this key
+  // If the iterator's current entry equals to `key`, then
+  // - moves the iterator to the most recent update (Put, PutEntity or Delete)
+  // for `key`.
+  // - if there is no update (only Merge), the iterator will point to the last
+  // (oldest) Merge for `key`.
+  // - merge operands will be accumulated in merge_context.
+  // Else, the iterator will not move.
   //
+  // @return kFound if a Put/PutEntity was found for `key`.
+  // @return kDeleted if a Delete was found for `key`
+  // @return kMergeInProgress if only Merges were found for `key`
+  // @return kError if an unsupported operation was found for `key`
+  // @return kNotFound if no operations were found for `key`
   Result FindLatestUpdate(const Slice& key, MergeContext* merge_context);
+  // Find the latest update for iterator's current key.
   Result FindLatestUpdate(MergeContext* merge_context);
 
  protected:
@@ -379,6 +406,11 @@ class WBWIIteratorImpl final : public WBWIIterator {
   bool out_of_bound_ = false;
 
   bool TestOutOfBound() const {
+    if (!iterate_lower_bound_ && !iterate_upper_bound_) {
+      // The Entry() call below is non-trivial, tests the common and cheaper
+      // no bound case first.
+      return false;
+    }
     const Slice& curKey = Entry().key;
     return AtOrAfterUpperBound(&curKey) || BeforeLowerBound(&curKey);
   }