@nxtedition/rocksdb 8.1.7 → 8.1.9

package/deps/rocksdb/rocksdb/db_stress_tool/expected_state.cc

@@ -254,7 +254,6 @@ Status FileExpectedStateManager::Open() {
   return s;
 }
 
-#ifndef ROCKSDB_LITE
 Status FileExpectedStateManager::SaveAtAndAfter(DB* db) {
   SequenceNumber seqno = db->GetLatestSequenceNumber();
 
@@ -322,17 +321,11 @@ Status FileExpectedStateManager::SaveAtAndAfter(DB* db) {
   }
   return s;
 }
-#else   // ROCKSDB_LITE
-Status FileExpectedStateManager::SaveAtAndAfter(DB* /* db */) {
-  return Status::NotSupported();
-}
-#endif  // ROCKSDB_LITE
 
 bool FileExpectedStateManager::HasHistory() {
   return saved_seqno_ != kMaxSequenceNumber;
 }
 
-#ifndef ROCKSDB_LITE
 
 namespace {
 
@@ -683,11 +676,6 @@ Status FileExpectedStateManager::Restore(DB* db) {
   }
   return s;
 }
-#else   // ROCKSDB_LITE
-Status FileExpectedStateManager::Restore(DB* /* db */) {
-  return Status::NotSupported();
-}
-#endif  // ROCKSDB_LITE
 
 Status FileExpectedStateManager::Clean() {
   std::vector<std::string> expected_state_dir_children;

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

@@ -329,9 +329,7 @@ void MultiOpsTxnsStressTest::FinishInitDb(SharedState* shared) {
   if (FLAGS_enable_compaction_filter) {
     // TODO (yanqin) enable compaction filter
   }
-#ifndef ROCKSDB_LITE
   ProcessRecoveredPreparedTxns(shared);
-#endif
 
   ReopenAndPreloadDbIfNeeded(shared);
   // TODO (yanqin) parallelize if key space is large
@@ -348,7 +346,6 @@ void MultiOpsTxnsStressTest::FinishInitDb(SharedState* shared) {
 
 void MultiOpsTxnsStressTest::ReopenAndPreloadDbIfNeeded(SharedState* shared) {
   (void)shared;
-#ifndef ROCKSDB_LITE
   bool db_empty = false;
   {
     std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
@@ -369,7 +366,6 @@ void MultiOpsTxnsStressTest::ReopenAndPreloadDbIfNeeded(SharedState* shared) {
     fflush(stdout);
     ScanExistingDb(shared, FLAGS_threads);
   }
-#endif  // !ROCKSDB_LITE
 }
 
 // Used for point-lookup transaction
@@ -477,7 +473,6 @@ Status MultiOpsTxnsStressTest::TestCheckpoint(
   return Status::OK();
 }
 
-#ifndef ROCKSDB_LITE
 Status MultiOpsTxnsStressTest::TestApproximateSize(
     ThreadState* thread, uint64_t iteration,
     const std::vector<int>& rand_column_families,
@@ -488,7 +483,6 @@ Status MultiOpsTxnsStressTest::TestApproximateSize(
   (void)rand_column_families;
   return Status::OK();
 }
-#endif  // !ROCKSDB_LITE
 
 Status MultiOpsTxnsStressTest::TestCustomOperations(
     ThreadState* thread, const std::vector<int>& rand_column_families) {
@@ -529,7 +523,6 @@ void MultiOpsTxnsStressTest::RegisterAdditionalListeners() {
   options_.listeners.emplace_back(new MultiOpsTxnsStressListener(this));
 }
 
-#ifndef ROCKSDB_LITE
 void MultiOpsTxnsStressTest::PrepareTxnDbOptions(
     SharedState* /*shared*/, TransactionDBOptions& txn_db_opts) {
   // MultiOpsTxnStressTest uses SingleDelete to delete secondary keys, thus we
@@ -548,19 +541,11 @@ void MultiOpsTxnsStressTest::PrepareTxnDbOptions(
         return index_id == Record::kSecondaryIndexId;
       };
 }
-#endif  // !ROCKSDB_LITE
 
 Status MultiOpsTxnsStressTest::PrimaryKeyUpdateTxn(ThreadState* thread,
                                                    uint32_t old_a,
                                                    uint32_t old_a_pos,
                                                    uint32_t new_a) {
-#ifdef ROCKSDB_LITE
-  (void)thread;
-  (void)old_a;
-  (void)old_a_pos;
-  (void)new_a;
-  return Status::NotSupported();
-#else
   std::string old_pk = Record::EncodePrimaryKey(old_a);
   std::string new_pk = Record::EncodePrimaryKey(new_a);
   Transaction* txn = nullptr;
@@ -678,20 +663,12 @@ Status MultiOpsTxnsStressTest::PrimaryKeyUpdateTxn(ThreadState* thread,
     key_gen->Replace(old_a, old_a_pos, new_a);
   }
   return s;
-#endif  // !ROCKSDB_LITE
 }
 
 Status MultiOpsTxnsStressTest::SecondaryKeyUpdateTxn(ThreadState* thread,
                                                      uint32_t old_c,
                                                      uint32_t old_c_pos,
                                                      uint32_t new_c) {
-#ifdef ROCKSDB_LITE
-  (void)thread;
-  (void)old_c;
-  (void)old_c_pos;
-  (void)new_c;
-  return Status::NotSupported();
-#else
   Transaction* txn = nullptr;
   WriteOptions wopts;
   Status s = NewTxn(wopts, &txn);
@@ -885,18 +862,11 @@ Status MultiOpsTxnsStressTest::SecondaryKeyUpdateTxn(ThreadState* thread,
   }
 
   return s;
-#endif  // !ROCKSDB_LITE
 }
 
 Status MultiOpsTxnsStressTest::UpdatePrimaryIndexValueTxn(ThreadState* thread,
                                                           uint32_t a,
                                                           uint32_t b_delta) {
-#ifdef ROCKSDB_LITE
-  (void)thread;
-  (void)a;
-  (void)b_delta;
-  return Status::NotSupported();
-#else
   std::string pk_str = Record::EncodePrimaryKey(a);
   Transaction* txn = nullptr;
   WriteOptions wopts;
@@ -974,17 +944,10 @@ Status MultiOpsTxnsStressTest::UpdatePrimaryIndexValueTxn(ThreadState* thread,
     delete txn;
   }
   return s;
-#endif  // !ROCKSDB_LITE
 }
 
 Status MultiOpsTxnsStressTest::PointLookupTxn(ThreadState* thread,
                                               ReadOptions ropts, uint32_t a) {
-#ifdef ROCKSDB_LITE
-  (void)thread;
-  (void)ropts;
-  (void)a;
-  return Status::NotSupported();
-#else
   std::string pk_str = Record::EncodePrimaryKey(a);
   // pk may or may not exist
   PinnableSlice value;
@@ -1030,17 +993,10 @@ Status MultiOpsTxnsStressTest::PointLookupTxn(ThreadState* thread,
     delete txn;
   }
   return s;
-#endif  // !ROCKSDB_LITE
 }
 
 Status MultiOpsTxnsStressTest::RangeScanTxn(ThreadState* thread,
                                             ReadOptions ropts, uint32_t c) {
-#ifdef ROCKSDB_LITE
-  (void)thread;
-  (void)ropts;
-  (void)c;
-  return Status::NotSupported();
-#else
   std::string sk = Record::EncodeSecondaryKey(c);
 
   Transaction* txn = nullptr;
@@ -1093,7 +1049,6 @@ Status MultiOpsTxnsStressTest::RangeScanTxn(ThreadState* thread,
   }
 
   return s;
-#endif  // !ROCKSDB_LITE
 }
 
 void MultiOpsTxnsStressTest::VerifyDb(ThreadState* thread) const {
@@ -1356,7 +1311,6 @@ uint32_t MultiOpsTxnsStressTest::GenerateNextC(ThreadState* thread) {
   return key_gen->Allocate();
 }
 
-#ifndef ROCKSDB_LITE
 void MultiOpsTxnsStressTest::ProcessRecoveredPreparedTxnsHelper(
     Transaction* txn, SharedState*) {
   thread_local Random rand(static_cast<uint32_t>(FLAGS_seed));
@@ -1418,7 +1372,6 @@ void MultiOpsTxnsStressTest::SetupSnapshot(
     read_opts.snapshot = txn.GetSnapshot();
   }
 }
-#endif  // !ROCKSDB_LITE
 
 std::string MultiOpsTxnsStressTest::KeySpaces::EncodeTo() const {
   std::string result;
@@ -1489,14 +1442,6 @@ MultiOpsTxnsStressTest::KeySpaces MultiOpsTxnsStressTest::ReadKeySpacesDesc(
 void MultiOpsTxnsStressTest::PreloadDb(SharedState* shared, int threads,
                                        uint32_t lb_a, uint32_t ub_a,
                                        uint32_t lb_c, uint32_t ub_c) {
-#ifdef ROCKSDB_LITE
-  (void)shared;
-  (void)threads;
-  (void)lb_a;
-  (void)ub_a;
-  (void)lb_c;
-  (void)ub_c;
-#else
   key_gen_for_a_.resize(threads);
   key_gen_for_c_.resize(threads);
 
@@ -1599,7 +1544,6 @@ void MultiOpsTxnsStressTest::PreloadDb(SharedState* shared, int threads,
         my_seed, low, high, std::move(existing_c_uniqs[i]),
         std::move(non_existing_c_uniqs[i]));
   }
-#endif  // !ROCKSDB_LITE
 }
 
 // Scan an existing, non-empty database.
@@ -1739,7 +1683,6 @@ StressTest* CreateMultiOpsTxnsStressTest() {
 }
 
 void CheckAndSetOptionsForMultiOpsTxnStressTest() {
-#ifndef ROCKSDB_LITE
   if (FLAGS_test_batches_snapshots || FLAGS_test_cf_consistency) {
     fprintf(stderr,
             "-test_multi_ops_txns is not compatible with "
@@ -1798,10 +1741,6 @@ void CheckAndSetOptionsForMultiOpsTxnStressTest() {
             "-test_multi_ops_txns\n");
     exit(1);
   }
-#else
-  fprintf(stderr, "-test_multi_ops_txns not supported in ROCKSDB_LITE mode\n");
-  exit(1);
-#endif  // !ROCKSDB_LITE
 }
 }  // namespace ROCKSDB_NAMESPACE
 

package/deps/rocksdb/rocksdb/db_stress_tool/multi_ops_txns_stress.h

@@ -248,11 +248,9 @@ class MultiOpsTxnsStressTest : public StressTest {
                         const std::vector<int>& rand_column_families,
                         const std::vector<int64_t>& rand_keys) override;
 
-#ifndef ROCKSDB_LITE
   Status TestApproximateSize(ThreadState* thread, uint64_t iteration,
                              const std::vector<int>& rand_column_families,
                              const std::vector<int64_t>& rand_keys) override;
-#endif  // !ROCKSDB_LITE
 
   Status TestCustomOperations(
       ThreadState* thread,
@@ -260,10 +258,8 @@ class MultiOpsTxnsStressTest : public StressTest {
 
   void RegisterAdditionalListeners() override;
 
-#ifndef ROCKSDB_LITE
   void PrepareTxnDbOptions(SharedState* /*shared*/,
                            TransactionDBOptions& txn_db_opts) override;
-#endif  // !ROCKSDB_LITE
 
   Status PrimaryKeyUpdateTxn(ThreadState* thread, uint32_t old_a,
                              uint32_t old_a_pos, uint32_t new_a);
@@ -344,7 +340,6 @@ class MultiOpsTxnsStressTest : public StressTest {
 
   uint32_t GenerateNextC(ThreadState* thread);
 
-#ifndef ROCKSDB_LITE
   // Randomly commit or rollback `txn`
   void ProcessRecoveredPreparedTxnsHelper(Transaction* txn,
                                           SharedState*) override;
@@ -363,7 +358,6 @@ class MultiOpsTxnsStressTest : public StressTest {
   void SetupSnapshot(ThreadState* thread, ReadOptions& read_opts,
                      Transaction& txn,
                      std::shared_ptr<const Snapshot>& snapshot);
-#endif  //! ROCKSDB_LITE
 
   std::vector<std::unique_ptr<KeyGenerator>> key_gen_for_a_;
   std::vector<std::unique_ptr<KeyGenerator>> key_gen_for_c_;
@@ -414,7 +408,6 @@ class MultiOpsTxnsStressListener : public EventListener {
     assert(stress_test_);
   }
 
-#ifndef ROCKSDB_LITE
   ~MultiOpsTxnsStressListener() override {}
 
   void OnFlushCompleted(DB* db, const FlushJobInfo& info) override {
@@ -434,7 +427,6 @@ class MultiOpsTxnsStressListener : public EventListener {
     assert(info.cf_id == 0);
     stress_test_->VerifyPkSkFast(info.job_id);
   }
-#endif  //! ROCKSDB_LITE
 
  private:
   MultiOpsTxnsStressTest* const stress_test_ = nullptr;

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

@@ -51,7 +51,9 @@ class NonBatchedOpsStressTest : public StressTest {
       enum class VerificationMethod {
         kIterator,
         kGet,
+        kGetEntity,
         kMultiGet,
+        kMultiGetEntity,
         kGetMergeOperands,
         // Add any new items above kNumberOfMethods
         kNumberOfMethods
@@ -105,7 +107,6 @@ class NonBatchedOpsStressTest : public StressTest {
                 VerificationAbort(shared, static_cast<int>(cf), i,
                                   iter->value(), iter->columns(),
                                   expected_columns);
-                break;
               }
 
               from_db = iter->value().ToString();
@@ -123,7 +124,8 @@ class NonBatchedOpsStressTest : public StressTest {
           }
 
           VerifyOrSyncValue(static_cast<int>(cf), i, options, shared, from_db,
-                            s, /* strict */ true);
+                            /* msg_prefix */ "Iterator verification", s,
+                            /* strict */ true);
 
           if (!from_db.empty()) {
             PrintKeyValue(static_cast<int>(cf), static_cast<uint32_t>(i),
@@ -142,7 +144,47 @@ class NonBatchedOpsStressTest : public StressTest {
           Status s = db_->Get(options, column_families_[cf], key, &from_db);
 
           VerifyOrSyncValue(static_cast<int>(cf), i, options, shared, from_db,
-                            s, /* strict */ true);
+                            /* msg_prefix */ "Get verification", s,
+                            /* strict */ true);
+
+          if (!from_db.empty()) {
+            PrintKeyValue(static_cast<int>(cf), static_cast<uint32_t>(i),
+                          from_db.data(), from_db.size());
+          }
+        }
+      } else if (method == VerificationMethod::kGetEntity) {
+        for (int64_t i = start; i < end; ++i) {
+          if (thread->shared->HasVerificationFailedYet()) {
+            break;
+          }
+
+          const std::string key = Key(i);
+          PinnableWideColumns columns;
+
+          Status s =
+              db_->GetEntity(options, column_families_[cf], key, &columns);
+
+          std::string from_db;
+
+          if (s.ok()) {
+            const WideColumns& columns_from_db = columns.columns();
+
+            if (!columns_from_db.empty() &&
+                columns_from_db[0].name() == kDefaultWideColumnName) {
+              from_db = columns_from_db[0].value().ToString();
+            }
+
+            const WideColumns expected_columns =
+                GenerateExpectedWideColumns(GetValueBase(from_db), from_db);
+            if (columns_from_db != expected_columns) {
+              VerificationAbort(shared, static_cast<int>(cf), i, from_db,
+                                columns_from_db, expected_columns);
+            }
+          }
+
+          VerifyOrSyncValue(static_cast<int>(cf), i, options, shared, from_db,
+                            /* msg_prefix */ "GetEntity verification", s,
+                            /* strict */ true);
 
           if (!from_db.empty()) {
             PrintKeyValue(static_cast<int>(cf), static_cast<uint32_t>(i),
@@ -159,14 +201,14 @@ class NonBatchedOpsStressTest : public StressTest {
           size_t batch_size = thread->rand.Uniform(128) + 1;
           batch_size = std::min<size_t>(batch_size, end - i);
 
-          std::vector<std::string> keystrs(batch_size);
+          std::vector<std::string> key_strs(batch_size);
           std::vector<Slice> keys(batch_size);
           std::vector<PinnableSlice> values(batch_size);
           std::vector<Status> statuses(batch_size);
 
           for (size_t j = 0; j < batch_size; ++j) {
-            keystrs[j] = Key(i + j);
-            keys[j] = Slice(keystrs[j].data(), keystrs[j].size());
+            key_strs[j] = Key(i + j);
+            keys[j] = Slice(key_strs[j]);
           }
 
           db_->MultiGet(options, column_families_[cf], batch_size, keys.data(),
@@ -176,7 +218,63 @@ class NonBatchedOpsStressTest : public StressTest {
             const std::string from_db = values[j].ToString();
 
             VerifyOrSyncValue(static_cast<int>(cf), i + j, options, shared,
-                              from_db, statuses[j], /* strict */ true);
+                              from_db, /* msg_prefix */ "MultiGet verification",
+                              statuses[j], /* strict */ true);
+
+            if (!from_db.empty()) {
+              PrintKeyValue(static_cast<int>(cf), static_cast<uint32_t>(i + j),
+                            from_db.data(), from_db.size());
+            }
+          }
+
+          i += batch_size;
+        }
+      } else if (method == VerificationMethod::kMultiGetEntity) {
+        for (int64_t i = start; i < end;) {
+          if (thread->shared->HasVerificationFailedYet()) {
+            break;
+          }
+
+          // Keep the batch size to some reasonable value
+          size_t batch_size = thread->rand.Uniform(128) + 1;
+          batch_size = std::min<size_t>(batch_size, end - i);
+
+          std::vector<std::string> key_strs(batch_size);
+          std::vector<Slice> keys(batch_size);
+          std::vector<PinnableWideColumns> results(batch_size);
+          std::vector<Status> statuses(batch_size);
+
+          for (size_t j = 0; j < batch_size; ++j) {
+            key_strs[j] = Key(i + j);
+            keys[j] = Slice(key_strs[j]);
+          }
+
+          db_->MultiGetEntity(options, column_families_[cf], batch_size,
+                              keys.data(), results.data(), statuses.data());
+
+          for (size_t j = 0; j < batch_size; ++j) {
+            std::string from_db;
+
+            if (statuses[j].ok()) {
+              const WideColumns& columns_from_db = results[j].columns();
+
+              if (!columns_from_db.empty() &&
+                  columns_from_db[0].name() == kDefaultWideColumnName) {
+                from_db = columns_from_db[0].value().ToString();
+              }
+
+              const WideColumns expected_columns =
+                  GenerateExpectedWideColumns(GetValueBase(from_db), from_db);
+              if (columns_from_db != expected_columns) {
+                VerificationAbort(shared, static_cast<int>(cf), i, from_db,
+                                  columns_from_db, expected_columns);
+              }
+            }
+
+            VerifyOrSyncValue(static_cast<int>(cf), i + j, options, shared,
+                              from_db,
+                              /* msg_prefix */ "MultiGetEntity verification",
+                              statuses[j], /* strict */ true);
 
             if (!from_db.empty()) {
               PrintKeyValue(static_cast<int>(cf), static_cast<uint32_t>(i + j),
@@ -228,7 +326,8 @@ class NonBatchedOpsStressTest : public StressTest {
           }
 
           VerifyOrSyncValue(static_cast<int>(cf), i, options, shared, from_db,
-                            s, /* strict */ true);
+                            /* msg_prefix */ "GetMergeOperands verification", s,
+                            /* strict */ true);
 
           if (!from_db.empty()) {
             PrintKeyValue(static_cast<int>(cf), static_cast<uint32_t>(i),
@@ -239,7 +338,6 @@ class NonBatchedOpsStressTest : public StressTest {
     }
   }
 
-#ifndef ROCKSDB_LITE
   void ContinuouslyVerifyDb(ThreadState* thread) const override {
     if (!cmp_db_) {
       return;
@@ -333,9 +431,6 @@ class NonBatchedOpsStressTest : public StressTest {
       }
     }
   }
-#else
-  void ContinuouslyVerifyDb(ThreadState* /*thread*/) const override {}
-#endif  // ROCKSDB_LITE
 
   void MaybeClearOneColumnFamily(ThreadState* thread) override {
     if (FLAGS_column_families > 1) {
@@ -493,7 +588,6 @@ class NonBatchedOpsStressTest : public StressTest {
     // Create a transaction in order to write some data. The purpose is to
     // exercise WriteBatchWithIndex::MultiGetFromBatchAndDB. The transaction
     // will be rolled back once MultiGet returns.
-#ifndef ROCKSDB_LITE
     Transaction* txn = nullptr;
     if (use_txn) {
       WriteOptions wo;
@@ -506,11 +600,9 @@ class NonBatchedOpsStressTest : public StressTest {
         std::terminate();
       }
     }
-#endif
     for (size_t i = 0; i < num_keys; ++i) {
       key_str.emplace_back(Key(rand_keys[i]));
       keys.emplace_back(key_str.back());
-#ifndef ROCKSDB_LITE
       if (use_txn) {
         // With a 1 in 10 probability, insert the just added key in the batch
         // into the transaction. This will create an overlap with the MultiGet
@@ -545,7 +637,6 @@ class NonBatchedOpsStressTest : public StressTest {
           }
         }
       }
-#endif
     }
 
     if (!use_txn) {
@@ -559,10 +650,8 @@ class NonBatchedOpsStressTest : public StressTest {
         error_count = fault_fs_guard->GetAndResetErrorCount();
       }
     } else {
-#ifndef ROCKSDB_LITE
       txn->MultiGet(readoptionscopy, cfh, num_keys, keys.data(), values.data(),
                     statuses.data());
-#endif
     }
 
     if (fault_fs_guard && error_count && !SharedState::ignore_read_error) {
@@ -599,9 +688,7 @@ class NonBatchedOpsStressTest : public StressTest {
         std::string value;
 
         if (use_txn) {
-#ifndef ROCKSDB_LITE
           tmp_s = txn->Get(readoptionscopy, cfh, keys[i], &value);
-#endif  // ROCKSDB_LITE
         } else {
           tmp_s = db_->Get(readoptionscopy, cfh, keys[i], &value);
         }
@@ -659,9 +746,7 @@ class NonBatchedOpsStressTest : public StressTest {
       db_->ReleaseSnapshot(readoptionscopy.snapshot);
     }
     if (use_txn) {
-#ifndef ROCKSDB_LITE
       RollbackTxn(txn);
-#endif
     }
     return statuses;
   }
@@ -803,6 +888,7 @@ class NonBatchedOpsStressTest : public StressTest {
       std::string from_db;
       Status s = db_->Get(read_opts, cfh, k, &from_db);
       if (!VerifyOrSyncValue(rand_column_family, rand_key, read_opts, shared,
+                             /* msg_prefix */ "Pre-Put Get verification",
                              from_db, s, /* strict */ true)) {
         return s;
       }
@@ -824,7 +910,6 @@ class NonBatchedOpsStressTest : public StressTest {
           s = db_->Merge(write_opts, cfh, k, write_ts, v);
         }
       } else {
-#ifndef ROCKSDB_LITE
         Transaction* txn;
         s = NewTxn(write_opts, &txn);
         if (s.ok()) {
@@ -833,7 +918,6 @@ class NonBatchedOpsStressTest : public StressTest {
             s = CommitTxn(txn, thread);
           }
         }
-#endif
       }
     } else if (FLAGS_use_put_entity_one_in > 0 &&
                (value_base % FLAGS_use_put_entity_one_in) == 0) {
@@ -847,7 +931,6 @@ class NonBatchedOpsStressTest : public StressTest {
           s = db_->Put(write_opts, cfh, k, write_ts, v);
         }
       } else {
-#ifndef ROCKSDB_LITE
         Transaction* txn;
         s = NewTxn(write_opts, &txn);
         if (s.ok()) {
@@ -856,7 +939,6 @@ class NonBatchedOpsStressTest : public StressTest {
             s = CommitTxn(txn, thread);
           }
         }
-#endif
       }
     }
 
@@ -913,7 +995,6 @@ class NonBatchedOpsStressTest : public StressTest {
           s = db_->Delete(write_opts, cfh, key, write_ts);
         }
       } else {
-#ifndef ROCKSDB_LITE
         Transaction* txn;
         s = NewTxn(write_opts, &txn);
         if (s.ok()) {
@@ -922,7 +1003,6 @@ class NonBatchedOpsStressTest : public StressTest {
             s = CommitTxn(txn, thread);
           }
         }
-#endif
       }
       shared->Delete(rand_column_family, rand_key, false /* pending */);
       thread->stats.AddDeletes(1);
@@ -950,7 +1030,6 @@ class NonBatchedOpsStressTest : public StressTest {
           s = db_->SingleDelete(write_opts, cfh, key, write_ts);
         }
       } else {
-#ifndef ROCKSDB_LITE
         Transaction* txn;
         s = NewTxn(write_opts, &txn);
         if (s.ok()) {
@@ -959,7 +1038,6 @@ class NonBatchedOpsStressTest : public StressTest {
             s = CommitTxn(txn, thread);
           }
         }
-#endif
       }
       shared->SingleDelete(rand_column_family, rand_key, false /* pending */);
       thread->stats.AddSingleDeletes(1);
@@ -1047,18 +1125,6 @@ class NonBatchedOpsStressTest : public StressTest {
     return s;
   }
 
-#ifdef ROCKSDB_LITE
-  void TestIngestExternalFile(
-      ThreadState* /* thread */,
-      const std::vector<int>& /* rand_column_families */,
-      const std::vector<int64_t>& /* rand_keys */) override {
-    assert(false);
-    fprintf(stderr,
-            "RocksDB lite does not support "
-            "TestIngestExternalFile\n");
-    std::terminate();
-  }
-#else
   void TestIngestExternalFile(ThreadState* thread,
                               const std::vector<int>& rand_column_families,
                               const std::vector<int64_t>& rand_keys) override {
@@ -1132,7 +1198,6 @@ class NonBatchedOpsStressTest : public StressTest {
       shared->Put(column_family, keys[i], values[i], false /* pending */);
     }
   }
-#endif  // ROCKSDB_LITE
 
   // Given a key K, this creates an iterator which scans the range
   // [K, K + FLAGS_num_iterations) forward and backward.
@@ -1441,10 +1506,12 @@ class NonBatchedOpsStressTest : public StressTest {
 
   bool VerifyOrSyncValue(int cf, int64_t key, const ReadOptions& /*opts*/,
                          SharedState* shared, const std::string& value_from_db,
-                         const Status& s, bool strict = false) const {
+                         std::string msg_prefix, const Status& s,
+                         bool strict = false) const {
     if (shared->HasVerificationFailedYet()) {
       return false;
     }
+
     // compare value_from_db with the value in the shared state
     uint32_t value_base = shared->Get(cf, key);
     if (value_base == SharedState::UNKNOWN_SENTINEL) {
@@ -1466,34 +1533,36 @@ class NonBatchedOpsStressTest : public StressTest {
     if (s.ok()) {
       char value[kValueMaxLen];
       if (value_base == SharedState::DELETION_SENTINEL) {
-        VerificationAbort(shared, "Unexpected value found", cf, key,
-                          value_from_db, "");
+        VerificationAbort(shared, msg_prefix + ": Unexpected value found", cf,
+                          key, value_from_db, "");
         return false;
       }
       size_t sz = GenerateValue(value_base, value, sizeof(value));
       if (value_from_db.length() != sz) {
-        VerificationAbort(shared, "Length of value read is not equal", cf, key,
-                          value_from_db, Slice(value, sz));
+        VerificationAbort(shared,
+                          msg_prefix + ": Length of value read is not equal",
+                          cf, key, value_from_db, Slice(value, sz));
         return false;
       }
       if (memcmp(value_from_db.data(), value, sz) != 0) {
-        VerificationAbort(shared, "Contents of value read don't match", cf, key,
-                          value_from_db, Slice(value, sz));
+        VerificationAbort(shared,
+                          msg_prefix + ": Contents of value read don't match",
+                          cf, key, value_from_db, Slice(value, sz));
         return false;
       }
     } else {
       if (value_base != SharedState::DELETION_SENTINEL) {
         char value[kValueMaxLen];
         size_t sz = GenerateValue(value_base, value, sizeof(value));
-        VerificationAbort(shared, "Value not found: " + s.ToString(), cf, key,
-                          "", Slice(value, sz));
+        VerificationAbort(shared,
+                          msg_prefix + ": Value not found: " + s.ToString(), cf,
+                          key, "", Slice(value, sz));
         return false;
       }
     }
     return true;
   }
 
-#ifndef ROCKSDB_LITE
   void PrepareTxnDbOptions(SharedState* shared,
                            TransactionDBOptions& txn_db_opts) override {
     txn_db_opts.rollback_deletion_type_callback =
@@ -1506,7 +1575,6 @@ class NonBatchedOpsStressTest : public StressTest {
           return !shared->AllowsOverwrite(key_num);
         };
   }
-#endif  // ROCKSDB_LITE
 };
 
 StressTest* CreateNonBatchedOpsStressTest() {