@nxtedition/rocksdb 13.1.4 → 13.2.0

package/deps/rocksdb/rocksdb/db_stress_tool/multi_ops_txns_stress.cc

@@ -544,6 +544,11 @@ Status MultiOpsTxnsStressTest::TestCustomOperations(
     // Should never reach here.
     assert(false);
   }
+  if (!s.ok()) {
+    fprintf(stderr, "Transaction failed %s\n", s.ToString().c_str());
+    fflush(stderr);
+    thread->shared->SafeTerminate();
+  }
 
   return s;
 }
@@ -579,7 +584,7 @@ Status MultiOpsTxnsStressTest::PrimaryKeyUpdateTxn(ThreadState* thread,
   std::string new_pk = Record::EncodePrimaryKey(new_a);
   std::unique_ptr<Transaction> txn;
   WriteOptions wopts;
-  Status s = NewTxn(wopts, &txn);
+  Status s = NewTxn(wopts, thread, &txn);
   if (!s.ok()) {
     assert(!txn);
     thread->stats.AddErrors(1);
@@ -611,7 +616,12 @@ Status MultiOpsTxnsStressTest::PrimaryKeyUpdateTxn(ThreadState* thread,
     }
     auto& key_gen = key_gen_for_a_[thread->tid];
     key_gen->UndoAllocation(new_a);
-    txn->Rollback().PermitUncheckedError();
+    s = txn->Rollback();
+    if (!s.ok()) {
+      fprintf(stderr, "Transaction rollback failed %s\n", s.ToString().c_str());
+      fflush(stderr);
+      assert(false);
+    }
   });
 
   ReadOptions ropts;
@@ -699,7 +709,7 @@ Status MultiOpsTxnsStressTest::SecondaryKeyUpdateTxn(ThreadState* thread,
                                                      uint32_t new_c) {
   std::unique_ptr<Transaction> txn;
   WriteOptions wopts;
-  Status s = NewTxn(wopts, &txn);
+  Status s = NewTxn(wopts, thread, &txn);
   if (!s.ok()) {
     assert(!txn);
     thread->stats.AddErrors(1);
@@ -735,7 +745,12 @@ Status MultiOpsTxnsStressTest::SecondaryKeyUpdateTxn(ThreadState* thread,
     }
     auto& key_gen = key_gen_for_c_[thread->tid];
     key_gen->UndoAllocation(new_c);
-    txn->Rollback().PermitUncheckedError();
+    s = txn->Rollback();
+    if (!s.ok()) {
+      fprintf(stderr, "Transaction rollback failed %s\n", s.ToString().c_str());
+      fflush(stderr);
+      assert(false);
+    }
   });
 
   // TODO (yanqin) try SetSnapshotOnNextOperation(). We currently need to take
@@ -901,7 +916,7 @@ Status MultiOpsTxnsStressTest::UpdatePrimaryIndexValueTxn(ThreadState* thread,
   std::string pk_str = Record::EncodePrimaryKey(a);
   std::unique_ptr<Transaction> txn;
   WriteOptions wopts;
-  Status s = NewTxn(wopts, &txn);
+  Status s = NewTxn(wopts, thread, &txn);
   if (!s.ok()) {
     assert(!txn);
     thread->stats.AddErrors(1);
@@ -927,7 +942,12 @@ Status MultiOpsTxnsStressTest::UpdatePrimaryIndexValueTxn(ThreadState* thread,
     } else {
       thread->stats.AddErrors(1);
     }
-    txn->Rollback().PermitUncheckedError();
+    s = txn->Rollback();
+    if (!s.ok()) {
+      fprintf(stderr, "Transaction rollback failed %s\n", s.ToString().c_str());
+      fflush(stderr);
+      assert(false);
+    }
   });
   ReadOptions ropts;
   ropts.rate_limiter_priority =
@@ -982,7 +1002,7 @@ Status MultiOpsTxnsStressTest::PointLookupTxn(ThreadState* thread,
 
   std::unique_ptr<Transaction> txn;
   WriteOptions wopts;
-  Status s = NewTxn(wopts, &txn);
+  Status s = NewTxn(wopts, thread, &txn);
   if (!s.ok()) {
     assert(!txn);
     thread->stats.AddErrors(1);
@@ -1026,7 +1046,7 @@ Status MultiOpsTxnsStressTest::RangeScanTxn(ThreadState* thread,
 
   std::unique_ptr<Transaction> txn;
   WriteOptions wopts;
-  Status s = NewTxn(wopts, &txn);
+  Status s = NewTxn(wopts, thread, &txn);
   if (!s.ok()) {
     assert(!txn);
     thread->stats.AddErrors(1);
@@ -1384,6 +1404,12 @@ Status MultiOpsTxnsStressTest::CommitAndCreateTimestampedSnapshotIfNeeded(
   } else {
     s = txn.Commit();
   }
+  if (!s.ok()) {
+    fprintf(stderr, "Txn %s commit failed with %s\n", txn.GetName().c_str(),
+            s.ToString().c_str());
+    fflush(stderr);
+  }
+
   assert(txn_db_);
   if (FLAGS_create_timestamped_snapshot_one_in > 0 &&
       thread->rand.OneInOpt(50000)) {

package/deps/rocksdb/rocksdb/db_stress_tool/no_batched_ops_stress.cc

@@ -568,9 +568,11 @@ class NonBatchedOpsStressTest : public StressTest {
                                                     post_read_expected_value)) {
           thread->shared->SetVerificationFailure();
           fprintf(stderr,
-                  "error : inconsistent values for key %s: Get returns %s, "
+                  "error : inconsistent values for key %s (%" PRIi64
+                  "): Get returns %s, "
                   "but expected state is \"deleted\".\n",
-                  key.ToString(true).c_str(), StringToHex(from_db).c_str());
+                  key.ToString(true).c_str(), rand_keys[0],
+                  StringToHex(from_db).c_str());
         }
         Slice from_db_slice(from_db);
         uint32_t value_base_from_db = GetValueBase(from_db_slice);
@@ -579,11 +581,12 @@ class NonBatchedOpsStressTest : public StressTest {
                 post_read_expected_value)) {
           thread->shared->SetVerificationFailure();
           fprintf(stderr,
-                  "error : inconsistent values for key %s: Get returns %s with "
+                  "error : inconsistent values for key %s (%" PRIi64
+                  "): Get returns %s with "
                   "value base %d that falls out of expected state's value base "
                   "range.\n",
-                  key.ToString(true).c_str(), StringToHex(from_db).c_str(),
-                  value_base_from_db);
+                  key.ToString(true).c_str(), rand_keys[0],
+                  StringToHex(from_db).c_str(), value_base_from_db);
         }
       }
     } else if (s.IsNotFound()) {
@@ -594,15 +597,16 @@ class NonBatchedOpsStressTest : public StressTest {
                                                  post_read_expected_value)) {
           thread->shared->SetVerificationFailure();
           fprintf(stderr,
-                  "error : inconsistent values for key %s: expected state has "
+                  "error : inconsistent values for key %s (%" PRIi64
+                  "): expected state has "
                   "the key, Get() returns NotFound.\n",
-                  key.ToString(true).c_str());
+                  key.ToString(true).c_str(), rand_keys[0]);
         }
       }
     } else if (injected_error_count == 0 || !IsErrorInjectedAndRetryable(s)) {
       thread->shared->SetVerificationFailure();
-      fprintf(stderr, "error : Get() returns %s for key: %s.\n",
-              s.ToString().c_str(), key.ToString(true).c_str());
+      fprintf(stderr, "error : Get() returns %s for key: %s (%" PRIi64 ").\n",
+              s.ToString().c_str(), key.ToString(true).c_str(), rand_keys[0]);
     }
     return s;
   }
@@ -662,7 +666,7 @@ class NonBatchedOpsStressTest : public StressTest {
       if (FLAGS_rate_limit_auto_wal_flush) {
         wo.rate_limiter_priority = Env::IO_USER;
       }
-      Status s = NewTxn(wo, &txn);
+      Status s = NewTxn(wo, thread, &txn);
       if (!s.ok()) {
         fprintf(stderr, "NewTxn error: %s\n", s.ToString().c_str());
         shared->SafeTerminate();
@@ -1031,17 +1035,18 @@ class NonBatchedOpsStressTest : public StressTest {
           shared->SetVerificationFailure();
           fprintf(stderr,
                   "error : inconsistent columns returned by GetEntity for key "
-                  "%s: %s\n",
-                  StringToHex(key_str).c_str(),
+                  "%s (%" PRIi64 "): %s\n",
+                  StringToHex(key_str).c_str(), rand_keys[0],
                   WideColumnsToHex(columns).c_str());
         } else if (ExpectedValueHelper::MustHaveNotExisted(
                        pre_read_expected_value, post_read_expected_value)) {
           shared->SetVerificationFailure();
-          fprintf(
-              stderr,
-              "error : inconsistent values for key %s: GetEntity returns %s, "
-              "expected state does not have the key.\n",
-              StringToHex(key_str).c_str(), WideColumnsToHex(columns).c_str());
+          fprintf(stderr,
+                  "error : inconsistent values for key %s (%" PRIi64
+                  "): GetEntity returns %s, "
+                  "expected state does not have the key.\n",
+                  StringToHex(key_str).c_str(), rand_keys[0],
+                  WideColumnsToHex(columns).c_str());
         } else {
           const uint32_t value_base_from_db =
               GetValueBase(WideColumnsHelper::GetDefaultColumn(columns));
@@ -1051,11 +1056,12 @@ class NonBatchedOpsStressTest : public StressTest {
             shared->SetVerificationFailure();
             fprintf(
                 stderr,
-                "error : inconsistent values for key %s: GetEntity returns %s "
+                "error : inconsistent values for key %s (%" PRIi64
+                "): GetEntity returns %s "
                 "with value base %d that falls out of expected state's value "
                 "base range.\n",
-                StringToHex(key_str).c_str(), WideColumnsToHex(columns).c_str(),
-                value_base_from_db);
+                StringToHex(key_str).c_str(), rand_keys[0],
+                WideColumnsToHex(columns).c_str(), value_base_from_db);
           }
         }
       }
@@ -1067,14 +1073,16 @@ class NonBatchedOpsStressTest : public StressTest {
                                                  post_read_expected_value)) {
           shared->SetVerificationFailure();
           fprintf(stderr,
-                  "error : inconsistent values for key %s: expected state has "
+                  "error : inconsistent values for key %s (%" PRIi64
+                  "): expected state has "
                   "the key, GetEntity returns NotFound.\n",
-                  StringToHex(key_str).c_str());
+                  StringToHex(key_str).c_str(), rand_keys[0]);
         }
       }
     } else if (injected_error_count == 0 || !IsErrorInjectedAndRetryable(s)) {
-      fprintf(stderr, "error : GetEntity() returns %s for key: %s.\n",
-              s.ToString().c_str(), StringToHex(key_str).c_str());
+      fprintf(stderr,
+              "error : GetEntity() returns %s for key: %s (%" PRIi64 ").\n",
+              s.ToString().c_str(), StringToHex(key_str).c_str(), rand_keys[0]);
       thread->shared->SetVerificationFailure();
     }
   }
@@ -1119,7 +1127,7 @@ class NonBatchedOpsStressTest : public StressTest {
         write_options.rate_limiter_priority = Env::IO_USER;
       }
 
-      const Status s = NewTxn(write_options, &txn);
+      const Status s = NewTxn(write_options, thread, &txn);
       if (!s.ok()) {
         fprintf(stderr, "NewTxn error: %s\n", s.ToString().c_str());
         thread->shared->SafeTerminate();
@@ -1450,8 +1458,10 @@ class NonBatchedOpsStressTest : public StressTest {
     Slice ub_slice;
     ReadOptions ro_copy = read_opts;
 
-    // Get the next prefix first and then see if we want to set upper bound.
-    // We'll use the next prefix in an assertion later on
+    // Randomly test with `iterate_upper_bound` and `prefix_same_as_start`
+    //
+    // Get the next prefix first and then see if we want to set it to be the
+    // upper bound. We'll use the next prefix in an assertion later on
     if (GetNextPrefix(prefix, &upper_bound) && thread->rand.OneIn(2)) {
       // For half of the time, set the upper bound to the next prefix
       ub_slice = Slice(upper_bound);
@@ -1460,6 +1470,8 @@ class NonBatchedOpsStressTest : public StressTest {
         ro_copy.table_filter =
             sqfc_factory_->GetTableFilterForRangeQuery(prefix, ub_slice);
       }
+    } else if (options_.prefix_extractor && thread->rand.OneIn(2)) {
+      ro_copy.prefix_same_as_start = true;
     }
 
     std::string read_ts_str;
@@ -1480,8 +1492,16 @@ class NonBatchedOpsStressTest : public StressTest {
     uint64_t count = 0;
     Status s;
 
-    for (iter->Seek(prefix); iter->Valid() && iter->key().starts_with(prefix);
-         iter->Next()) {
+    for (iter->Seek(prefix); iter->Valid(); iter->Next()) {
+      // If upper or prefix bounds is specified, only keys of the target
+      // prefix should show up. Otherwise, we need to manual exit the loop when
+      // we see the first key that is not in the target prefix show up.
+      if (ro_copy.iterate_upper_bound != nullptr ||
+          ro_copy.prefix_same_as_start) {
+        assert(iter->key().starts_with(prefix));
+      } else if (!iter->key().starts_with(prefix)) {
+        break;
+      }
       ++count;
 
       // When iter_start_ts is set, iterator exposes internal keys, including
@@ -1495,6 +1515,13 @@ class NonBatchedOpsStressTest : public StressTest {
         }
       }
 
+      if (ro_copy.allow_unprepared_value) {
+        if (!iter->PrepareValue()) {
+          s = iter->status();
+          break;
+        }
+      }
+
       if (!VerifyWideColumns(iter->value(), iter->columns())) {
         s = Status::Corruption("Value and columns inconsistent",
                                DebugString(iter->value(), iter->columns()));
@@ -1535,7 +1562,14 @@ class NonBatchedOpsStressTest : public StressTest {
     if (s.ok()) {
       thread->stats.AddPrefixes(1, count);
     } else if (injected_error_count == 0 || !IsErrorInjectedAndRetryable(s)) {
-      fprintf(stderr, "TestPrefixScan error: %s\n", s.ToString().c_str());
+      fprintf(stderr,
+              "TestPrefixScan error: %s with ReadOptions::iterate_upper_bound: "
+              "%s, prefix_same_as_start: %s \n",
+              s.ToString().c_str(),
+              ro_copy.iterate_upper_bound
+                  ? ro_copy.iterate_upper_bound->ToString(true).c_str()
+                  : "nullptr",
+              ro_copy.prefix_same_as_start ? "true" : "false");
       thread->shared->SetVerificationFailure();
     }
 
@@ -1618,6 +1652,7 @@ class NonBatchedOpsStressTest : public StressTest {
     // To track whether WAL write may have succeeded during the initial failed
     // write
     bool initial_wal_write_may_succeed = true;
+    bool commit_bypass_memtable = false;
 
     PendingExpectedValue pending_expected_value =
         shared->PreparePut(rand_column_family, rand_key);
@@ -1679,9 +1714,10 @@ class NonBatchedOpsStressTest : public StressTest {
             s = db_->Put(write_opts, cfh, k, write_ts, v);
           }
         } else {
-          s = ExecuteTransaction(write_opts, thread, [&](Transaction& txn) {
-            return txn.Put(cfh, k, v);
-          });
+          s = ExecuteTransaction(
+              write_opts, thread,
+              [&](Transaction& txn) { return txn.Put(cfh, k, v); },
+              &commit_bypass_memtable);
         }
       }
       UpdateIfInitialWriteFails(db_stress_env, s, &initial_write_s,
@@ -1745,6 +1781,7 @@ class NonBatchedOpsStressTest : public StressTest {
     // To track whether WAL write may have succeeded during the initial failed
     // write
     bool initial_wal_write_may_succeed = true;
+    bool commit_bypass_memtable = false;
 
     // Use delete if the key may be overwritten and a single deletion
     // otherwise.
@@ -1769,13 +1806,14 @@ class NonBatchedOpsStressTest : public StressTest {
             s = db_->Delete(write_opts, cfh, key, write_ts);
           }
         } else {
-          s = ExecuteTransaction(write_opts, thread, [&](Transaction& txn) {
-            return txn.Delete(cfh, key);
-          });
+          s = ExecuteTransaction(
+              write_opts, thread,
+              [&](Transaction& txn) { return txn.Delete(cfh, key); },
+              &commit_bypass_memtable);
         }
-        UpdateIfInitialWriteFails(db_stress_env, s, &initial_write_s,
-                                  &initial_wal_write_may_succeed,
-                                  &wait_for_recover_start_time);
+        UpdateIfInitialWriteFails(
+            db_stress_env, s, &initial_write_s, &initial_wal_write_may_succeed,
+            &wait_for_recover_start_time, commit_bypass_memtable);
       } while (!s.ok() && IsErrorInjectedAndRetryable(s) &&
                initial_wal_write_may_succeed);
 
@@ -1825,13 +1863,14 @@ class NonBatchedOpsStressTest : public StressTest {
             s = db_->SingleDelete(write_opts, cfh, key, write_ts);
           }
         } else {
-          s = ExecuteTransaction(write_opts, thread, [&](Transaction& txn) {
-            return txn.SingleDelete(cfh, key);
-          });
+          s = ExecuteTransaction(
+              write_opts, thread,
+              [&](Transaction& txn) { return txn.SingleDelete(cfh, key); },
+              &commit_bypass_memtable);
         }
-        UpdateIfInitialWriteFails(db_stress_env, s, &initial_write_s,
-                                  &initial_wal_write_may_succeed,
-                                  &wait_for_recover_start_time);
+        UpdateIfInitialWriteFails(
+            db_stress_env, s, &initial_write_s, &initial_wal_write_may_succeed,
+            &wait_for_recover_start_time, commit_bypass_memtable);
       } while (!s.ok() && IsErrorInjectedAndRetryable(s) &&
                initial_wal_write_may_succeed);
 
@@ -1963,8 +2002,23 @@ class NonBatchedOpsStressTest : public StressTest {
   void TestIngestExternalFile(ThreadState* thread,
                               const std::vector<int>& rand_column_families,
                               const std::vector<int64_t>& rand_keys) override {
+    // When true, we create two sst files, the first one with regular puts for
+    // a continuous range of keys, the second one with a standalone range
+    // deletion for all the keys. This is to exercise the standalone range
+    // deletion file's compaction input optimization.
+    bool test_standalone_range_deletion = thread->rand.OneInOpt(
+        FLAGS_test_ingest_standalone_range_deletion_one_in);
+    std::vector<std::string> external_files;
     const std::string sst_filename =
         FLAGS_db + "/." + std::to_string(thread->tid) + ".sst";
+    external_files.push_back(sst_filename);
+    std::string standalone_rangedel_filename;
+    if (test_standalone_range_deletion) {
+      standalone_rangedel_filename = FLAGS_db + "/." +
+                                     std::to_string(thread->tid) +
+                                     "_standalone_rangedel.sst";
+      external_files.push_back(standalone_rangedel_filename);
+    }
     Status s;
     std::ostringstream ingest_options_oss;
 
@@ -1976,10 +2030,15 @@ class NonBatchedOpsStressTest : public StressTest {
           FaultInjectionIOType::kMetadataWrite);
     }
 
-    if (db_stress_env->FileExists(sst_filename).ok()) {
-      // Maybe we terminated abnormally before, so cleanup to give this file
-      // ingestion a clean slate
-      s = db_stress_env->DeleteFile(sst_filename);
+    for (const auto& filename : external_files) {
+      if (db_stress_env->FileExists(filename).ok()) {
+        // Maybe we terminated abnormally before, so cleanup to give this file
+        // ingestion a clean slate
+        s = db_stress_env->DeleteFile(filename);
+      }
+      if (!s.ok()) {
+        return;
+      }
     }
 
     if (fault_fs_guard) {
@@ -1990,9 +2049,19 @@ class NonBatchedOpsStressTest : public StressTest {
     }
 
     SstFileWriter sst_file_writer(EnvOptions(options_), options_);
+    SstFileWriter standalone_rangedel_sst_file_writer(EnvOptions(options_),
+                                                      options_);
     if (s.ok()) {
       s = sst_file_writer.Open(sst_filename);
     }
+    if (s.ok() && test_standalone_range_deletion) {
+      s = standalone_rangedel_sst_file_writer.Open(
+          standalone_rangedel_filename);
+    }
+    if (!s.ok()) {
+      return;
+    }
+
     int64_t key_base = rand_keys[0];
     int column_family = rand_column_families[0];
     std::vector<std::unique_ptr<MutexLock>> range_locks;
@@ -2005,51 +2074,93 @@ class NonBatchedOpsStressTest : public StressTest {
     pending_expected_values.reserve(FLAGS_ingest_external_file_width);
     SharedState* shared = thread->shared;
 
+    // Grab locks, add keys
     assert(FLAGS_nooverwritepercent < 100);
-    // Grab locks, set pending state on expected values, and add keys
     for (int64_t key = key_base;
-         s.ok() && key < shared->GetMaxKey() &&
-         static_cast<int32_t>(keys.size()) < FLAGS_ingest_external_file_width;
+         key < shared->GetMaxKey() &&
+         key < key_base + FLAGS_ingest_external_file_width;
          ++key) {
       if (key == key_base ||
           (key & ((1 << FLAGS_log2_keys_per_lock) - 1)) == 0) {
         range_locks.emplace_back(
             new MutexLock(shared->GetMutexForKey(column_family, key)));
       }
-      if (!shared->AllowsOverwrite(key)) {
-        // We could alternatively include `key` that is deleted.
-        continue;
+      if (test_standalone_range_deletion) {
+        // Testing standalone range deletion needs a continuous range of keys.
+        if (shared->AllowsOverwrite(key)) {
+          if (keys.empty() || (!keys.empty() && keys.back() == key - 1)) {
+            keys.push_back(key);
+          } else {
+            keys.clear();
+            keys.push_back(key);
+          }
+        } else {
+          if (keys.size() > 0) {
+            break;
+          } else {
+            continue;
+          }
+        }
+      } else {
+        if (!shared->AllowsOverwrite(key)) {
+          // We could alternatively include `key` that is deleted.
+          continue;
+        }
+        keys.push_back(key);
       }
-      keys.push_back(key);
-
-      PendingExpectedValue pending_expected_value =
-          shared->PreparePut(column_family, key);
+    }
 
-      const uint32_t value_base = pending_expected_value.GetFinalValueBase();
-      values.push_back(value_base);
-      pending_expected_values.push_back(pending_expected_value);
+    if (s.ok() && keys.empty()) {
+      return;
+    }
 
+    // set pending state on expected values, create and ingest files.
+    size_t total_keys = keys.size();
+    for (size_t i = 0; s.ok() && i < total_keys; i++) {
+      int64_t key = keys.at(i);
       char value[100];
       auto key_str = Key(key);
-      const size_t value_len = GenerateValue(value_base, value, sizeof(value));
       const Slice k(key_str);
-      const Slice v(value, value_len);
-
-      if (FLAGS_use_put_entity_one_in > 0 &&
-          (value_base % FLAGS_use_put_entity_one_in) == 0) {
-        WideColumns columns = GenerateWideColumns(value_base, v);
-        s = sst_file_writer.PutEntity(k, columns);
-      } else {
+      Slice v;
+      if (test_standalone_range_deletion) {
+        assert(i == 0 || keys.at(i - 1) == key - 1);
         s = sst_file_writer.Put(k, v);
+      } else {
+        PendingExpectedValue pending_expected_value =
+            shared->PreparePut(column_family, key);
+        const uint32_t value_base = pending_expected_value.GetFinalValueBase();
+        const size_t value_len =
+            GenerateValue(value_base, value, sizeof(value));
+        v = Slice(value, value_len);
+        values.push_back(value_base);
+        pending_expected_values.push_back(pending_expected_value);
+        if (FLAGS_use_put_entity_one_in > 0 &&
+            (value_base % FLAGS_use_put_entity_one_in) == 0) {
+          WideColumns columns = GenerateWideColumns(values.back(), v);
+          s = sst_file_writer.PutEntity(k, columns);
+        } else {
+          s = sst_file_writer.Put(k, v);
+        }
       }
     }
-
-    if (s.ok() && keys.empty()) {
-      return;
+    if (s.ok() && !keys.empty()) {
+      s = sst_file_writer.Finish();
     }
 
-    if (s.ok()) {
-      s = sst_file_writer.Finish();
+    if (s.ok() && total_keys != 0 && test_standalone_range_deletion) {
+      int64_t start_key = keys.at(0);
+      int64_t end_key = keys.back() + 1;
+      pending_expected_values =
+          shared->PrepareDeleteRange(column_family, start_key, end_key);
+      auto start_key_str = Key(start_key);
+      const Slice start_key_slice(start_key_str);
+      auto end_key_str = Key(end_key);
+      const Slice end_key_slice(end_key_str);
+      s = standalone_rangedel_sst_file_writer.DeleteRange(start_key_slice,
+                                                          end_key_slice);
+      if (s.ok()) {
+        s = standalone_rangedel_sst_file_writer.Finish();
+      }
     }
     if (s.ok()) {
       IngestExternalFileOptions ingest_options;
@@ -2057,13 +2168,17 @@ class NonBatchedOpsStressTest : public StressTest {
       ingest_options.verify_checksums_before_ingest = thread->rand.OneInOpt(2);
       ingest_options.verify_checksums_readahead_size =
           thread->rand.OneInOpt(2) ? 1024 * 1024 : 0;
+      ingest_options.fill_cache = thread->rand.OneInOpt(4);
       ingest_options_oss << "move_files: " << ingest_options.move_files
                          << ", verify_checksums_before_ingest: "
                          << ingest_options.verify_checksums_before_ingest
                          << ", verify_checksums_readahead_size: "
-                         << ingest_options.verify_checksums_readahead_size;
+                         << ingest_options.verify_checksums_readahead_size
+                         << ", fill_cache: " << ingest_options.fill_cache
+                         << ", test_standalone_range_deletion: "
+                         << test_standalone_range_deletion;
       s = db_->IngestExternalFile(column_families_[column_family],
-                                  {sst_filename}, ingest_options);
+                                  external_files, ingest_options);
     }
     if (!s.ok()) {
       for (PendingExpectedValue& pending_expected_value :
@@ -2258,6 +2373,16 @@ class NonBatchedOpsStressTest : public StressTest {
     uint64_t curr = 0;
     while (true) {
       assert(last_key < ub);
+
+      if (iter->Valid() && ro.allow_unprepared_value) {
+        op_logs += "*";
+
+        if (!iter->PrepareValue()) {
+          assert(!iter->Valid());
+          assert(!iter->status().ok());
+        }
+      }
+
       if (!iter->Valid()) {
         if (!iter->status().ok()) {
           if (IsErrorInjectedAndRetryable(iter->status())) {
@@ -2320,6 +2445,16 @@ class NonBatchedOpsStressTest : public StressTest {
     last_key = ub;
     while (true) {
       assert(lb < last_key);
+
+      if (iter->Valid() && ro.allow_unprepared_value) {
+        op_logs += "*";
+
+        if (!iter->PrepareValue()) {
+          assert(!iter->Valid());
+          assert(!iter->status().ok());
+        }
+      }
+
       if (!iter->Valid()) {
         if (!iter->status().ok()) {
           if (IsErrorInjectedAndRetryable(iter->status())) {
@@ -2458,6 +2593,16 @@ class NonBatchedOpsStressTest : public StressTest {
     }
 
     for (int64_t i = 0; i < num_iter && iter->Valid(); ++i) {
+      if (ro.allow_unprepared_value) {
+        op_logs += "*";
+
+        if (!iter->PrepareValue()) {
+          assert(!iter->Valid());
+          assert(!iter->status().ok());
+          break;
+        }
+      }
+
       if (!check_columns()) {
         return Status::OK();
       }
@@ -2735,7 +2880,7 @@ class NonBatchedOpsStressTest : public StressTest {
           const size_t sz = GenerateValue(value_base, value, sizeof(value));
           const Slice v(value, sz);
 
-          if (op == Op::PutOrPutEntity) {
+          if (op == Op::PutOrPutEntity || !FLAGS_use_merge) {
             if (FLAGS_use_put_entity_one_in > 0 &&
                 (value_base % FLAGS_use_put_entity_one_in) == 0) {
               s = txn->PutEntity(cfh, k, GenerateWideColumns(value_base, v));

package/deps/rocksdb/rocksdb/env/file_system.cc

@@ -200,6 +200,11 @@ IOStatus WriteStringToFile(FileSystem* fs, const Slice& data,
 
 IOStatus ReadFileToString(FileSystem* fs, const std::string& fname,
                           std::string* data) {
+  return ReadFileToString(fs, fname, IOOptions(), data);
+}
+
+IOStatus ReadFileToString(FileSystem* fs, const std::string& fname,
+                          const IOOptions& opts, std::string* data) {
   FileOptions soptions;
   data->clear();
   std::unique_ptr<FSSequentialFile> file;
@@ -212,7 +217,7 @@ IOStatus ReadFileToString(FileSystem* fs, const std::string& fname,
   char* space = new char[kBufferSize];
   while (true) {
     Slice fragment;
-    s = file->Read(kBufferSize, IOOptions(), &fragment, space, nullptr);
+    s = file->Read(kBufferSize, opts, &fragment, space, nullptr);
     if (!s.ok()) {
       break;
     }