@nxtedition/rocksdb 13.1.4 → 13.2.0

package/deps/rocksdb/rocksdb/db/multi_cf_iterator_test.cc

@@ -15,53 +15,74 @@ class CoalescingIteratorTest : public DBTestBase {
 
   // Verify Iteration of CoalescingIterator
   // by SeekToFirst() + Next() and SeekToLast() + Prev()
-  void verifyCoalescingIterator(const std::vector<ColumnFamilyHandle*>& cfhs,
+  void VerifyCoalescingIterator(const std::vector<ColumnFamilyHandle*>& cfhs,
                                 const std::vector<Slice>& expected_keys,
                                 const std::vector<Slice>& expected_values,
                                 const std::optional<std::vector<WideColumns>>&
                                     expected_wide_columns = std::nullopt,
                                 const Slice* lower_bound = nullptr,
-                                const Slice* upper_bound = nullptr) {
-    int i = 0;
+                                const Slice* upper_bound = nullptr,
+                                bool allow_unprepared_value = false) {
+    const size_t num_keys = expected_keys.size();
+
     ReadOptions read_options;
     read_options.iterate_lower_bound = lower_bound;
     read_options.iterate_upper_bound = upper_bound;
+    read_options.allow_unprepared_value = allow_unprepared_value;
+
     std::unique_ptr<Iterator> iter =
         db_->NewCoalescingIterator(read_options, cfhs);
-    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-      ASSERT_EQ(expected_keys[i], iter->key());
-      ASSERT_EQ(expected_values[i], iter->value());
+
+    auto check_iter_entry = [&](size_t idx) {
+      ASSERT_EQ(iter->key(), expected_keys[idx]);
+
+      if (allow_unprepared_value) {
+        ASSERT_TRUE(iter->value().empty());
+        ASSERT_TRUE(iter->PrepareValue());
+        ASSERT_TRUE(iter->Valid());
+      }
+
+      ASSERT_EQ(iter->value(), expected_values[idx]);
       if (expected_wide_columns.has_value()) {
-        ASSERT_EQ(expected_wide_columns.value()[i], iter->columns());
+        ASSERT_EQ(iter->columns(), expected_wide_columns.value()[idx]);
       }
-      ++i;
+    };
+
+    {
+      size_t i = 0;
+      for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
+        check_iter_entry(i);
+        ++i;
+      }
+
+      ASSERT_EQ(num_keys, i);
+      ASSERT_OK(iter->status());
     }
-    ASSERT_EQ(expected_keys.size(), i);
-    ASSERT_OK(iter->status());
 
-    int rev_i = i - 1;
-    for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
-      ASSERT_EQ(expected_keys[rev_i], iter->key());
-      ASSERT_EQ(expected_values[rev_i], iter->value());
-      if (expected_wide_columns.has_value()) {
-        ASSERT_EQ(expected_wide_columns.value()[rev_i], iter->columns());
+    {
+      size_t i = 0;
+      for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
+        check_iter_entry(num_keys - 1 - i);
+        ++i;
       }
-      rev_i--;
+
+      ASSERT_EQ(num_keys, i);
+      ASSERT_OK(iter->status());
     }
-    ASSERT_OK(iter->status());
   }
 
-  void verifyExpectedKeys(ColumnFamilyHandle* cfh,
+  void VerifyExpectedKeys(ColumnFamilyHandle* cfh,
                           const std::vector<Slice>& expected_keys) {
-    int i = 0;
-    Iterator* iter = db_->NewIterator(ReadOptions(), cfh);
+    std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions(), cfh));
+
+    size_t i = 0;
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-      ASSERT_EQ(expected_keys[i], iter->key());
+      ASSERT_EQ(iter->key(), expected_keys[i]);
       ++i;
     }
-    ASSERT_EQ(expected_keys.size(), i);
+
+    ASSERT_EQ(i, expected_keys.size());
     ASSERT_OK(iter->status());
-    delete iter;
   }
 };
 
@@ -96,7 +117,7 @@ TEST_F(CoalescingIteratorTest, SimpleValues) {
     // Test for iteration over CF default->1->2->3
     std::vector<ColumnFamilyHandle*> cfhs_order_0_1_2_3 = {
         handles_[0], handles_[1], handles_[2], handles_[3]};
-    verifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
+    VerifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
                              expected_values);
 
     // Test for iteration over CF 3->1->default_cf->2
@@ -104,7 +125,7 @@ TEST_F(CoalescingIteratorTest, SimpleValues) {
         handles_[3], handles_[1], handles_[0], handles_[2]};
     // Iteration order and the return values should be the same since keys are
     // unique per CF
-    verifyCoalescingIterator(cfhs_order_3_1_0_2, expected_keys,
+    VerifyCoalescingIterator(cfhs_order_3_1_0_2, expected_keys,
                              expected_values);
 
     // Verify Seek()
@@ -163,14 +184,14 @@ TEST_F(CoalescingIteratorTest, SimpleValues) {
         handles_[0], handles_[1], handles_[2], handles_[3]};
     std::vector<Slice> expected_values = {"key_1_cf_3_val", "key_2_cf_2_val",
                                           "key_3_cf_3_val"};
-    verifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
+    VerifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
                              expected_values);
 
     // Test for iteration over CFs 3->2->default_cf->1
     std::vector<ColumnFamilyHandle*> cfhs_order_3_2_0_1 = {
         handles_[3], handles_[2], handles_[0], handles_[1]};
     expected_values = {"key_1_cf_0_val", "key_2_cf_1_val", "key_3_cf_1_val"};
-    verifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys,
+    VerifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys,
                              expected_values);
 
     // Verify Seek()
@@ -227,7 +248,7 @@ TEST_F(CoalescingIteratorTest, LowerAndUpperBounds) {
       std::vector<Slice> expected_keys = {"key_2", "key_3", "key_4"};
       std::vector<Slice> expected_values = {"key_2_cf_1_val", "key_3_cf_2_val",
                                             "key_4_cf_3_val"};
-      verifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
+      VerifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
                                expected_values, std::nullopt, &lb);
     }
     // with upper_bound
@@ -236,7 +257,7 @@ TEST_F(CoalescingIteratorTest, LowerAndUpperBounds) {
       Slice ub = Slice("key_3");
       std::vector<Slice> expected_keys = {"key_1", "key_2"};
       std::vector<Slice> expected_values = {"key_1_cf_0_val", "key_2_cf_1_val"};
-      verifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
+      VerifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
                                expected_values, std::nullopt, nullptr, &ub);
     }
     // with lower and upper bound
@@ -245,7 +266,7 @@ TEST_F(CoalescingIteratorTest, LowerAndUpperBounds) {
       Slice ub = Slice("key_4");
       std::vector<Slice> expected_keys = {"key_2", "key_3"};
       std::vector<Slice> expected_values = {"key_2_cf_1_val", "key_3_cf_2_val"};
-      verifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
+      VerifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
                                expected_values, std::nullopt, &lb, &ub);
     }
 
@@ -312,7 +333,7 @@ TEST_F(CoalescingIteratorTest, LowerAndUpperBounds) {
       Slice lb = Slice("key_2");
       std::vector<Slice> expected_keys = {"key_2", "key_3"};
       std::vector<Slice> expected_values = {"key_2_cf_2_val", "key_3_cf_3_val"};
-      verifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
+      VerifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
                                expected_values, std::nullopt, &lb);
     }
     // with upper_bound
@@ -321,7 +342,7 @@ TEST_F(CoalescingIteratorTest, LowerAndUpperBounds) {
       Slice ub = Slice("key_3");
       std::vector<Slice> expected_keys = {"key_1", "key_2"};
       std::vector<Slice> expected_values = {"key_1_cf_3_val", "key_2_cf_2_val"};
-      verifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
+      VerifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
                                expected_values, std::nullopt, nullptr, &ub);
     }
     // with lower and upper bound
@@ -330,7 +351,7 @@ TEST_F(CoalescingIteratorTest, LowerAndUpperBounds) {
       Slice ub = Slice("key_3");
       std::vector<Slice> expected_keys = {"key_2"};
       std::vector<Slice> expected_values = {"key_2_cf_2_val"};
-      verifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
+      VerifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys,
                                expected_values, std::nullopt, &lb, &ub);
     }
 
@@ -342,7 +363,7 @@ TEST_F(CoalescingIteratorTest, LowerAndUpperBounds) {
       Slice lb = Slice("key_2");
       std::vector<Slice> expected_keys = {"key_2", "key_3"};
       std::vector<Slice> expected_values = {"key_2_cf_1_val", "key_3_cf_1_val"};
-      verifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys,
+      VerifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys,
                                expected_values, std::nullopt, &lb);
     }
     // with upper_bound
@@ -351,7 +372,7 @@ TEST_F(CoalescingIteratorTest, LowerAndUpperBounds) {
       Slice ub = Slice("key_3");
       std::vector<Slice> expected_keys = {"key_1", "key_2"};
       std::vector<Slice> expected_values = {"key_1_cf_0_val", "key_2_cf_1_val"};
-      verifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys,
+      VerifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys,
                                expected_values, std::nullopt, nullptr, &ub);
     }
     // with lower and upper bound
@@ -360,7 +381,7 @@ TEST_F(CoalescingIteratorTest, LowerAndUpperBounds) {
       Slice ub = Slice("key_3");
       std::vector<Slice> expected_keys = {"key_2"};
       std::vector<Slice> expected_values = {"key_2_cf_1_val"};
-      verifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys,
+      VerifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys,
                                expected_values, std::nullopt, &lb, &ub);
     }
     {
@@ -662,7 +683,7 @@ TEST_F(CoalescingIteratorTest, WideColumns) {
         key_2_expected_columns_cfh_order_1_2, key_3_expected_columns,
         key_4_expected_columns};
 
-    verifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys, expected_values,
+    VerifyCoalescingIterator(cfhs_order_0_1_2_3, expected_keys, expected_values,
                              expected_wide_columns_0_1_2_3);
   }
 
@@ -677,7 +698,7 @@ TEST_F(CoalescingIteratorTest, WideColumns) {
         key_2_expected_columns_cfh_order_2_1, key_3_expected_columns,
         key_4_expected_columns};
 
-    verifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys, expected_values,
+    VerifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys, expected_values,
                              expected_wide_columns_3_2_0_1);
   }
 }
@@ -700,8 +721,8 @@ TEST_F(CoalescingIteratorTest, DifferentComparatorsInMultiCFs) {
   ASSERT_OK(Put(1, "key_2", "value_2"));
   ASSERT_OK(Put(1, "key_3", "value_3"));
 
-  verifyExpectedKeys(handles_[0], {"key_1", "key_2", "key_3"});
-  verifyExpectedKeys(handles_[1], {"key_3", "key_2", "key_1"});
+  VerifyExpectedKeys(handles_[0], {"key_1", "key_2", "key_3"});
+  VerifyExpectedKeys(handles_[1], {"key_3", "key_2", "key_1"});
 
   std::unique_ptr<Iterator> iter =
       db_->NewCoalescingIterator(ReadOptions(), handles_);
@@ -742,10 +763,10 @@ TEST_F(CoalescingIteratorTest, CustomComparatorsInMultiCFs) {
   ASSERT_OK(Put(1, "key_003_005", "value_1_5"));
   ASSERT_OK(Put(1, "key_003_006", "value_1_4"));
 
-  verifyExpectedKeys(
+  VerifyExpectedKeys(
       handles_[0], {"key_001_003", "key_001_002", "key_001_001", "key_002_003",
                     "key_002_002", "key_002_001"});
-  verifyExpectedKeys(
+  VerifyExpectedKeys(
       handles_[1], {"key_001_003", "key_001_002", "key_001_001", "key_003_006",
                     "key_003_005", "key_003_004"});
 
@@ -755,66 +776,205 @@ TEST_F(CoalescingIteratorTest, CustomComparatorsInMultiCFs) {
   std::vector<Slice> expected_values = {"value_1_1", "value_1_2", "value_1_3",
                                         "value_0_4", "value_0_5", "value_0_6",
                                         "value_1_4", "value_1_5", "value_1_6"};
-  int i = 0;
   std::unique_ptr<Iterator> iter =
       db_->NewCoalescingIterator(ReadOptions(), handles_);
+
+  size_t i = 0;
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
     ASSERT_EQ(expected_keys[i], iter->key());
     ASSERT_EQ(expected_values[i], iter->value());
     ++i;
   }
+
+  ASSERT_EQ(expected_keys.size(), i);
   ASSERT_OK(iter->status());
 }
 
+TEST_F(CoalescingIteratorTest, AllowUnpreparedValue) {
+  Options options = GetDefaultOptions();
+  options.enable_blob_files = true;
+
+  CreateAndReopenWithCF({"cf_1", "cf_2", "cf_3"}, options);
+
+  ASSERT_OK(Put(0, "key_1", "key_1_cf_0_val"));
+  ASSERT_OK(Put(3, "key_1", "key_1_cf_3_val"));
+  ASSERT_OK(Put(1, "key_2", "key_2_cf_1_val"));
+  ASSERT_OK(Put(2, "key_2", "key_2_cf_2_val"));
+  ASSERT_OK(Put(0, "key_3", "key_3_cf_0_val"));
+  ASSERT_OK(Put(1, "key_3", "key_3_cf_1_val"));
+  ASSERT_OK(Put(3, "key_3", "key_3_cf_3_val"));
+
+  ASSERT_OK(Flush());
+
+  std::vector<ColumnFamilyHandle*> cfhs_order_3_2_0_1{handles_[3], handles_[2],
+                                                      handles_[0], handles_[1]};
+  std::vector<Slice> expected_keys{"key_1", "key_2", "key_3"};
+  std::vector<Slice> expected_values{"key_1_cf_0_val", "key_2_cf_1_val",
+                                     "key_3_cf_1_val"};
+
+  VerifyCoalescingIterator(cfhs_order_3_2_0_1, expected_keys, expected_values,
+                           /* expected_wide_columns */ std::nullopt,
+                           /* lower_bound */ nullptr, /* upper_bound */ nullptr,
+                           /* allow_unprepared_value */ true);
+
+  ReadOptions read_options;
+  read_options.allow_unprepared_value = true;
+
+  {
+    std::unique_ptr<Iterator> iter =
+        db_->NewCoalescingIterator(read_options, cfhs_order_3_2_0_1);
+    iter->Seek("");
+    ASSERT_EQ(IterStatus(iter.get()), "key_1->");
+    ASSERT_TRUE(iter->PrepareValue());
+    ASSERT_EQ(IterStatus(iter.get()), "key_1->key_1_cf_0_val");
+
+    iter->Seek("key_1");
+    ASSERT_EQ(IterStatus(iter.get()), "key_1->");
+    ASSERT_TRUE(iter->PrepareValue());
+    ASSERT_EQ(IterStatus(iter.get()), "key_1->key_1_cf_0_val");
+
+    iter->Seek("key_2");
+    ASSERT_EQ(IterStatus(iter.get()), "key_2->");
+    ASSERT_TRUE(iter->PrepareValue());
+    ASSERT_EQ(IterStatus(iter.get()), "key_2->key_2_cf_1_val");
+
+    iter->Next();
+    ASSERT_EQ(IterStatus(iter.get()), "key_3->");
+    ASSERT_TRUE(iter->PrepareValue());
+    ASSERT_EQ(IterStatus(iter.get()), "key_3->key_3_cf_1_val");
+
+    iter->Seek("key_x");
+    ASSERT_EQ(IterStatus(iter.get()), "(invalid)");
+  }
+
+  {
+    std::unique_ptr<Iterator> iter =
+        db_->NewCoalescingIterator(read_options, cfhs_order_3_2_0_1);
+    iter->SeekForPrev("");
+    ASSERT_EQ(IterStatus(iter.get()), "(invalid)");
+
+    iter->SeekForPrev("key_1");
+    ASSERT_EQ(IterStatus(iter.get()), "key_1->");
+    ASSERT_TRUE(iter->PrepareValue());
+    ASSERT_EQ(IterStatus(iter.get()), "key_1->key_1_cf_0_val");
+
+    iter->Next();
+    ASSERT_EQ(IterStatus(iter.get()), "key_2->");
+    ASSERT_TRUE(iter->PrepareValue());
+    ASSERT_EQ(IterStatus(iter.get()), "key_2->key_2_cf_1_val");
+
+    iter->SeekForPrev("key_x");
+    ASSERT_EQ(IterStatus(iter.get()), "key_3->");
+    ASSERT_TRUE(iter->PrepareValue());
+    ASSERT_EQ(IterStatus(iter.get()), "key_3->key_3_cf_1_val");
+
+    iter->Next();
+    ASSERT_EQ(IterStatus(iter.get()), "(invalid)");
+  }
+}
+
+TEST_F(CoalescingIteratorTest, AllowUnpreparedValue_Corruption) {
+  Options options = GetDefaultOptions();
+  options.enable_blob_files = true;
+
+  CreateAndReopenWithCF({"cf_1", "cf_2", "cf_3"}, options);
+
+  ASSERT_OK(Put(0, "key_1", "key_1_cf_0_val"));
+  ASSERT_OK(Put(3, "key_1", "key_1_cf_3_val"));
+  ASSERT_OK(Put(1, "key_2", "key_2_cf_1_val"));
+  ASSERT_OK(Put(2, "key_2", "key_2_cf_2_val"));
+  ASSERT_OK(Put(0, "key_3", "key_3_cf_0_val"));
+  ASSERT_OK(Put(1, "key_3", "key_3_cf_1_val"));
+  ASSERT_OK(Put(3, "key_3", "key_3_cf_3_val"));
+
+  ASSERT_OK(Flush());
+
+  ReadOptions read_options;
+  read_options.allow_unprepared_value = true;
+
+  std::vector<ColumnFamilyHandle*> cfhs_order_3_2_0_1{handles_[3], handles_[2],
+                                                      handles_[0], handles_[1]};
+
+  std::unique_ptr<Iterator> iter =
+      db_->NewCoalescingIterator(read_options, cfhs_order_3_2_0_1);
+  iter->SeekToFirst();
+
+  ASSERT_TRUE(iter->Valid());
+  ASSERT_OK(iter->status());
+  ASSERT_EQ(iter->key(), "key_1");
+  ASSERT_TRUE(iter->value().empty());
+
+  SyncPoint::GetInstance()->SetCallBack(
+      "BlobFileReader::GetBlob:TamperWithResult", [](void* arg) {
+        Slice* const blob_index = static_cast<Slice*>(arg);
+        assert(blob_index);
+        assert(!blob_index->empty());
+        blob_index->remove_prefix(1);
+      });
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  ASSERT_FALSE(iter->PrepareValue());
+  ASSERT_FALSE(iter->Valid());
+  ASSERT_TRUE(iter->status().IsCorruption());
+
+  SyncPoint::GetInstance()->DisableProcessing();
+  SyncPoint::GetInstance()->ClearAllCallBacks();
+}
+
 class AttributeGroupIteratorTest : public DBTestBase {
  public:
   AttributeGroupIteratorTest()
       : DBTestBase("attribute_group_iterator_test", /*env_do_fsync=*/true) {}
 
-  void verifyAttributeGroupIterator(
+  void VerifyAttributeGroupIterator(
       const std::vector<ColumnFamilyHandle*>& cfhs,
       const std::vector<Slice>& expected_keys,
-      const std::vector<AttributeGroups>& expected_attribute_groups,
-      const Slice* lower_bound = nullptr, const Slice* upper_bound = nullptr) {
-    int i = 0;
+      const std::vector<IteratorAttributeGroups>& expected_attribute_groups,
+      const Slice* lower_bound = nullptr, const Slice* upper_bound = nullptr,
+      bool allow_unprepared_value = false) {
+    const size_t num_keys = expected_keys.size();
+
     ReadOptions read_options;
     read_options.iterate_lower_bound = lower_bound;
     read_options.iterate_upper_bound = upper_bound;
+    read_options.allow_unprepared_value = allow_unprepared_value;
+
     std::unique_ptr<AttributeGroupIterator> iter =
         db_->NewAttributeGroupIterator(read_options, cfhs);
-    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-      ASSERT_EQ(expected_keys[i], iter->key());
-      auto iterator_attribute_groups = iter->attribute_groups();
-      ASSERT_EQ(expected_attribute_groups[i].size(),
-                iterator_attribute_groups.size());
-      for (size_t cfh_i = 0; cfh_i < iterator_attribute_groups.size();
-           cfh_i++) {
-        ASSERT_EQ(expected_attribute_groups[i][cfh_i].column_family(),
-                  iterator_attribute_groups[cfh_i].column_family());
-        ASSERT_EQ(expected_attribute_groups[i][cfh_i].columns(),
-                  iterator_attribute_groups[cfh_i].columns());
+
+    auto check_iter_entry = [&](size_t idx) {
+      ASSERT_EQ(iter->key(), expected_keys[idx]);
+
+      if (allow_unprepared_value) {
+        ASSERT_TRUE(iter->attribute_groups().empty());
+        ASSERT_TRUE(iter->PrepareValue());
+        ASSERT_TRUE(iter->Valid());
       }
-      ++i;
+
+      ASSERT_EQ(iter->attribute_groups(), expected_attribute_groups[idx]);
+    };
+
+    {
+      size_t i = 0;
+      for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
+        check_iter_entry(i);
+        ++i;
+      }
+
+      ASSERT_EQ(i, num_keys);
+      ASSERT_OK(iter->status());
     }
-    ASSERT_EQ(expected_keys.size(), i);
-    ASSERT_OK(iter->status());
 
-    int rev_i = i - 1;
-    for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
-      ASSERT_EQ(expected_keys[rev_i], iter->key());
-      auto iterator_attribute_groups = iter->attribute_groups();
-      ASSERT_EQ(expected_attribute_groups[rev_i].size(),
-                iterator_attribute_groups.size());
-      for (size_t cfh_i = 0; cfh_i < iterator_attribute_groups.size();
-           cfh_i++) {
-        ASSERT_EQ(expected_attribute_groups[rev_i][cfh_i].column_family(),
-                  iterator_attribute_groups[cfh_i].column_family());
-        ASSERT_EQ(expected_attribute_groups[rev_i][cfh_i].columns(),
-                  iterator_attribute_groups[cfh_i].columns());
+    {
+      size_t i = 0;
+      for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
+        check_iter_entry(num_keys - 1 - i);
+        ++i;
       }
-      rev_i--;
+
+      ASSERT_EQ(i, num_keys);
+      ASSERT_OK(iter->status());
     }
-    ASSERT_OK(iter->status());
   }
 };
 
@@ -870,45 +1030,140 @@ TEST_F(AttributeGroupIteratorTest, IterateAttributeGroups) {
   ASSERT_OK(db_->PutEntity(WriteOptions(), key_3, key_3_attribute_groups));
   ASSERT_OK(db_->PutEntity(WriteOptions(), key_4, key_4_attribute_groups));
 
+  IteratorAttributeGroups key_1_expected_attribute_groups{
+      IteratorAttributeGroup(key_1_attribute_groups[0]),
+      IteratorAttributeGroup(key_1_attribute_groups[1])};
+  IteratorAttributeGroups key_2_expected_attribute_groups{
+      IteratorAttributeGroup(key_2_attribute_groups[0]),
+      IteratorAttributeGroup(key_2_attribute_groups[1])};
+  IteratorAttributeGroups key_3_expected_attribute_groups{
+      IteratorAttributeGroup(key_3_attribute_groups[0]),
+      IteratorAttributeGroup(key_3_attribute_groups[1])};
+  IteratorAttributeGroups key_4_expected_attribute_groups{
+      IteratorAttributeGroup(key_4_attribute_groups[0]),
+      IteratorAttributeGroup(key_4_attribute_groups[1])};
+
   // Test for iteration over CF default->1->2->3
   std::vector<ColumnFamilyHandle*> cfhs_order_0_1_2_3 = {
       handles_[0], handles_[1], handles_[2], handles_[3]};
   {
     std::vector<Slice> expected_keys = {key_1, key_2, key_3, key_4};
-    std::vector<AttributeGroups> expected_attribute_groups = {
-        key_1_attribute_groups, key_2_attribute_groups, key_3_attribute_groups,
-        key_4_attribute_groups};
-    verifyAttributeGroupIterator(cfhs_order_0_1_2_3, expected_keys,
+    std::vector<IteratorAttributeGroups> expected_attribute_groups{
+        key_1_expected_attribute_groups, key_2_expected_attribute_groups,
+        key_3_expected_attribute_groups, key_4_expected_attribute_groups};
+    VerifyAttributeGroupIterator(cfhs_order_0_1_2_3, expected_keys,
                                  expected_attribute_groups);
   }
+
   Slice lb = Slice("key_2");
   Slice ub = Slice("key_4");
+
   // Test for lower bound only
   {
     std::vector<Slice> expected_keys = {key_2, key_3, key_4};
-    std::vector<AttributeGroups> expected_attribute_groups = {
-        key_2_attribute_groups, key_3_attribute_groups, key_4_attribute_groups};
-    verifyAttributeGroupIterator(cfhs_order_0_1_2_3, expected_keys,
+    std::vector<IteratorAttributeGroups> expected_attribute_groups{
+        key_2_expected_attribute_groups, key_3_expected_attribute_groups,
+        key_4_expected_attribute_groups};
+    VerifyAttributeGroupIterator(cfhs_order_0_1_2_3, expected_keys,
                                  expected_attribute_groups, &lb);
   }
+
   // Test for upper bound only
   {
     std::vector<Slice> expected_keys = {key_1, key_2, key_3};
-    std::vector<AttributeGroups> expected_attribute_groups = {
-        key_1_attribute_groups, key_2_attribute_groups, key_3_attribute_groups};
-    verifyAttributeGroupIterator(cfhs_order_0_1_2_3, expected_keys,
+    std::vector<IteratorAttributeGroups> expected_attribute_groups{
+        key_1_expected_attribute_groups, key_2_expected_attribute_groups,
+        key_3_expected_attribute_groups};
+    VerifyAttributeGroupIterator(cfhs_order_0_1_2_3, expected_keys,
                                  expected_attribute_groups, nullptr, &ub);
   }
+
   // Test for lower and upper bound
   {
     std::vector<Slice> expected_keys = {key_2, key_3};
-    std::vector<AttributeGroups> expected_attribute_groups = {
-        key_2_attribute_groups, key_3_attribute_groups};
-    verifyAttributeGroupIterator(cfhs_order_0_1_2_3, expected_keys,
+    std::vector<IteratorAttributeGroups> expected_attribute_groups{
+        key_2_expected_attribute_groups, key_3_expected_attribute_groups};
+    VerifyAttributeGroupIterator(cfhs_order_0_1_2_3, expected_keys,
                                  expected_attribute_groups, &lb, &ub);
   }
 }
 
+TEST_F(AttributeGroupIteratorTest, AllowUnpreparedValue) {
+  Options options = GetDefaultOptions();
+  CreateAndReopenWithCF({"cf_1", "cf_2", "cf_3"}, options);
+
+  constexpr char key_1[] = "key_1";
+  WideColumns key_1_columns_in_cf_2{
+      {kDefaultWideColumnName, "cf_2_col_val_0_key_1"},
+      {"cf_2_col_name_1", "cf_2_col_val_1_key_1"},
+      {"cf_2_col_name_2", "cf_2_col_val_2_key_1"}};
+  WideColumns key_1_columns_in_cf_3{
+      {"cf_3_col_name_1", "cf_3_col_val_1_key_1"},
+      {"cf_3_col_name_2", "cf_3_col_val_2_key_1"},
+      {"cf_3_col_name_3", "cf_3_col_val_3_key_1"}};
+
+  constexpr char key_2[] = "key_2";
+  WideColumns key_2_columns_in_cf_1{
+      {"cf_1_col_name_1", "cf_1_col_val_1_key_2"}};
+  WideColumns key_2_columns_in_cf_2{
+      {"cf_2_col_name_1", "cf_2_col_val_1_key_2"},
+      {"cf_2_col_name_2", "cf_2_col_val_2_key_2"}};
+
+  constexpr char key_3[] = "key_3";
+  WideColumns key_3_columns_in_cf_1{
+      {"cf_1_col_name_1", "cf_1_col_val_1_key_3"}};
+  WideColumns key_3_columns_in_cf_3{
+      {"cf_3_col_name_1", "cf_3_col_val_1_key_3"}};
+
+  constexpr char key_4[] = "key_4";
+  WideColumns key_4_columns_in_cf_0{
+      {"cf_0_col_name_1", "cf_0_col_val_1_key_4"}};
+  WideColumns key_4_columns_in_cf_2{
+      {"cf_2_col_name_1", "cf_2_col_val_1_key_4"}};
+
+  AttributeGroups key_1_attribute_groups{
+      AttributeGroup(handles_[2], key_1_columns_in_cf_2),
+      AttributeGroup(handles_[3], key_1_columns_in_cf_3)};
+  AttributeGroups key_2_attribute_groups{
+      AttributeGroup(handles_[1], key_2_columns_in_cf_1),
+      AttributeGroup(handles_[2], key_2_columns_in_cf_2)};
+  AttributeGroups key_3_attribute_groups{
+      AttributeGroup(handles_[1], key_3_columns_in_cf_1),
+      AttributeGroup(handles_[3], key_3_columns_in_cf_3)};
+  AttributeGroups key_4_attribute_groups{
+      AttributeGroup(handles_[0], key_4_columns_in_cf_0),
+      AttributeGroup(handles_[2], key_4_columns_in_cf_2)};
+
+  ASSERT_OK(db_->PutEntity(WriteOptions(), key_1, key_1_attribute_groups));
+  ASSERT_OK(db_->PutEntity(WriteOptions(), key_2, key_2_attribute_groups));
+  ASSERT_OK(db_->PutEntity(WriteOptions(), key_3, key_3_attribute_groups));
+  ASSERT_OK(db_->PutEntity(WriteOptions(), key_4, key_4_attribute_groups));
+
+  IteratorAttributeGroups key_1_expected_attribute_groups{
+      IteratorAttributeGroup(key_1_attribute_groups[0]),
+      IteratorAttributeGroup(key_1_attribute_groups[1])};
+  IteratorAttributeGroups key_2_expected_attribute_groups{
+      IteratorAttributeGroup(key_2_attribute_groups[0]),
+      IteratorAttributeGroup(key_2_attribute_groups[1])};
+  IteratorAttributeGroups key_3_expected_attribute_groups{
+      IteratorAttributeGroup(key_3_attribute_groups[0]),
+      IteratorAttributeGroup(key_3_attribute_groups[1])};
+  IteratorAttributeGroups key_4_expected_attribute_groups{
+      IteratorAttributeGroup(key_4_attribute_groups[0]),
+      IteratorAttributeGroup(key_4_attribute_groups[1])};
+
+  std::vector<ColumnFamilyHandle*> cfhs_order_0_1_2_3{handles_[0], handles_[1],
+                                                      handles_[2], handles_[3]};
+  std::vector<Slice> expected_keys{key_1, key_2, key_3, key_4};
+  std::vector<IteratorAttributeGroups> expected_attribute_groups{
+      key_1_expected_attribute_groups, key_2_expected_attribute_groups,
+      key_3_expected_attribute_groups, key_4_expected_attribute_groups};
+  VerifyAttributeGroupIterator(
+      cfhs_order_0_1_2_3, expected_keys, expected_attribute_groups,
+      /* lower_bound */ nullptr, /* upper_bound */ nullptr,
+      /* allow_unprepared_value */ true);
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/db/range_tombstone_fragmenter.h

@@ -197,11 +197,10 @@ class FragmentedRangeTombstoneIterator : public InternalIterator {
     pinned_seq_pos_ = tombstones_->seq_end();
   }
 
-  RangeTombstone Tombstone(bool logical_strip_timestamp = false) const {
+  RangeTombstone Tombstone() const {
     assert(Valid());
     if (icmp_->user_comparator()->timestamp_size()) {
-      return RangeTombstone(start_key(), end_key(), seq(), timestamp(),
-                            logical_strip_timestamp);
+      return RangeTombstone(start_key(), end_key(), seq(), timestamp());
     }
     return RangeTombstone(start_key(), end_key(), seq());
   }