@nxtedition/rocksdb 8.1.6 → 8.1.8

package/deps/rocksdb/rocksdb/utilities/merge_operators/put_operator.h

@@ -0,0 +1,56 @@
+//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+//
+// A merge operator that mimics Put semantics
+// Since this merge-operator will not be used in production,
+// it is implemented as a non-associative merge operator to illustrate the
+// new interface and for testing purposes. (That is, we inherit from
+// the MergeOperator class rather than the AssociativeMergeOperator
+// which would be simpler in this case).
+//
+// From the client-perspective, semantics are the same.
+
+#pragma once
+
+#include "rocksdb/merge_operator.h"
+
+namespace ROCKSDB_NAMESPACE {
+class Logger;
+class Slice;
+
+class PutOperator : public MergeOperator {
+ public:
+  static const char* kClassName() { return "PutOperator"; }
+  static const char* kNickName() { return "put_v1"; }
+  const char* Name() const override { return kClassName(); }
+  const char* NickName() const override { return kNickName(); }
+
+  bool FullMerge(const Slice& /*key*/, const Slice* /*existing_value*/,
+                 const std::deque<std::string>& operand_sequence,
+                 std::string* new_value, Logger* /*logger*/) const override;
+  bool PartialMerge(const Slice& /*key*/, const Slice& left_operand,
+                    const Slice& right_operand, std::string* new_value,
+                    Logger* /*logger*/) const override;
+  using MergeOperator::PartialMergeMulti;
+  bool PartialMergeMulti(const Slice& /*key*/,
+                         const std::deque<Slice>& operand_list,
+                         std::string* new_value,
+                         Logger* /*logger*/) const override;
+};
+
+class PutOperatorV2 : public PutOperator {
+ public:
+  static const char* kNickName() { return "put"; }
+  const char* NickName() const override { return kNickName(); }
+
+  bool FullMerge(const Slice& /*key*/, const Slice* /*existing_value*/,
+                 const std::deque<std::string>& /*operand_sequence*/,
+                 std::string* /*new_value*/, Logger* /*logger*/) const override;
+
+  bool FullMergeV2(const MergeOperationInput& merge_in,
+                   MergeOperationOutput* merge_out) const override;
+};
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/merge_operators/string_append/stringappend.cc

@@ -19,11 +19,9 @@ namespace ROCKSDB_NAMESPACE {
 namespace {
 static std::unordered_map<std::string, OptionTypeInfo>
     stringappend_merge_type_info = {
-#ifndef ROCKSDB_LITE
         {"delimiter",
          {0, OptionType::kString, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };
 }  // namespace
 // Constructor: also specify the delimiter character.

package/deps/rocksdb/rocksdb/utilities/merge_operators/string_append/stringappend2.cc

@@ -19,11 +19,9 @@ namespace ROCKSDB_NAMESPACE {
 namespace {
 static std::unordered_map<std::string, OptionTypeInfo>
     stringappend2_merge_type_info = {
-#ifndef ROCKSDB_LITE
         {"delimiter",
          {0, OptionType::kString, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };
 }  // namespace
 

package/deps/rocksdb/rocksdb/utilities/merge_operators/string_append/stringappend_test.cc

@@ -49,7 +49,6 @@ std::shared_ptr<DB> OpenNormalDb(const std::string& delim) {
   return std::shared_ptr<DB>(db);
 }
 
-#ifndef ROCKSDB_LITE  // TtlDb is not supported in Lite
 // Open a TtlDB with a non-associative StringAppendTESTOperator
 std::shared_ptr<DB> OpenTtlDb(const std::string& delim) {
   DBWithTTL* db;
@@ -65,7 +64,6 @@ std::shared_ptr<DB> OpenTtlDb(const std::string& delim) {
   EXPECT_OK(DBWithTTL::Open(options, kDbName, &db, 123456));
   return std::shared_ptr<DB>(db);
 }
-#endif  // !ROCKSDB_LITE
 }  // namespace
 
 /// StringLists represents a set of string-lists, each with a key-index.
@@ -130,14 +128,12 @@ class StringAppendOperatorTest : public testing::Test,
   }
 
   void SetUp() override {
-#ifndef ROCKSDB_LITE  // TtlDb is not supported in Lite
     bool if_use_ttl = GetParam();
     if (if_use_ttl) {
       fprintf(stderr, "Running tests with ttl db and generic operator.\n");
       StringAppendOperatorTest::SetOpenDbFunction(&OpenTtlDb);
       return;
     }
-#endif  // !ROCKSDB_LITE
     fprintf(stderr, "Running tests with regular db and operator.\n");
     StringAppendOperatorTest::SetOpenDbFunction(&OpenNormalDb);
   }

package/deps/rocksdb/rocksdb/utilities/merge_operators/uint64add.cc

@@ -3,6 +3,8 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
+#include "utilities/merge_operators/uint64add.h"
+
 #include <memory>
 
 #include "logging/logging.h"
@@ -12,61 +14,40 @@
 #include "util/coding.h"
 #include "utilities/merge_operators.h"
 
-namespace {  // anonymous namespace
-
-using ROCKSDB_NAMESPACE::AssociativeMergeOperator;
-using ROCKSDB_NAMESPACE::InfoLogLevel;
-using ROCKSDB_NAMESPACE::Logger;
-using ROCKSDB_NAMESPACE::Slice;
-
-// A 'model' merge operator with uint64 addition semantics
-// Implemented as an AssociativeMergeOperator for simplicity and example.
-class UInt64AddOperator : public AssociativeMergeOperator {
- public:
-  bool Merge(const Slice& /*key*/, const Slice* existing_value,
-             const Slice& value, std::string* new_value,
-             Logger* logger) const override {
-    uint64_t orig_value = 0;
-    if (existing_value) {
-      orig_value = DecodeInteger(*existing_value, logger);
-    }
-    uint64_t operand = DecodeInteger(value, logger);
-
-    assert(new_value);
-    new_value->clear();
-    ROCKSDB_NAMESPACE::PutFixed64(new_value, orig_value + operand);
+namespace ROCKSDB_NAMESPACE {  // anonymous namespace
 
-    return true;  // Return true always since corruption will be treated as 0
+bool UInt64AddOperator::Merge(const Slice& /*key*/, const Slice* existing_value,
+                              const Slice& value, std::string* new_value,
+                              Logger* logger) const {
+  uint64_t orig_value = 0;
+  if (existing_value) {
+    orig_value = DecodeInteger(*existing_value, logger);
   }
+  uint64_t operand = DecodeInteger(value, logger);
 
-  static const char* kClassName() { return "UInt64AddOperator"; }
-  static const char* kNickName() { return "uint64add"; }
-  const char* Name() const override { return kClassName(); }
-  const char* NickName() const override { return kNickName(); }
+  assert(new_value);
+  new_value->clear();
+  PutFixed64(new_value, orig_value + operand);
 
- private:
-  // Takes the string and decodes it into a uint64_t
-  // On error, prints a message and returns 0
-  uint64_t DecodeInteger(const Slice& value, Logger* logger) const {
-    uint64_t result = 0;
-
-    if (value.size() == sizeof(uint64_t)) {
-      result = ROCKSDB_NAMESPACE::DecodeFixed64(value.data());
-    } else if (logger != nullptr) {
-      // If value is corrupted, treat it as 0
-      ROCKS_LOG_ERROR(logger,
-                      "uint64 value corruption, size: %" ROCKSDB_PRIszt
-                      " > %" ROCKSDB_PRIszt,
-                      value.size(), sizeof(uint64_t));
-    }
+  return true;  // Return true always since corruption will be treated as 0
+}
 
-    return result;
+uint64_t UInt64AddOperator::DecodeInteger(const Slice& value,
+                                          Logger* logger) const {
+  uint64_t result = 0;
+
+  if (value.size() == sizeof(uint64_t)) {
+    result = DecodeFixed64(value.data());
+  } else if (logger != nullptr) {
+    // If value is corrupted, treat it as 0
+    ROCKS_LOG_ERROR(logger,
+                    "uint64 value corruption, size: %" ROCKSDB_PRIszt
+                    " > %" ROCKSDB_PRIszt,
+                    value.size(), sizeof(uint64_t));
   }
-};
 
-}  // anonymous namespace
-
-namespace ROCKSDB_NAMESPACE {
+  return result;
+}
 
 std::shared_ptr<MergeOperator> MergeOperators::CreateUInt64AddOperator() {
   return std::make_shared<UInt64AddOperator>();

package/deps/rocksdb/rocksdb/utilities/merge_operators/uint64add.h

@@ -0,0 +1,35 @@
+//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+//
+// A 'model' merge operator with uint64 addition semantics
+// Implemented as an AssociativeMergeOperator for simplicity and example.
+
+#pragma once
+
+#include "rocksdb/merge_operator.h"
+#include "utilities/merge_operators.h"
+
+namespace ROCKSDB_NAMESPACE {
+class Logger;
+class Slice;
+
+class UInt64AddOperator : public AssociativeMergeOperator {
+ public:
+  static const char* kClassName() { return "UInt64AddOperator"; }
+  static const char* kNickName() { return "uint64add"; }
+  const char* Name() const override { return kClassName(); }
+  const char* NickName() const override { return kNickName(); }
+
+  bool Merge(const Slice& /*key*/, const Slice* existing_value,
+             const Slice& value, std::string* new_value,
+             Logger* logger) const override;
+
+ private:
+  // Takes the string and decodes it into a uint64_t
+  // On error, prints a message and returns 0
+  uint64_t DecodeInteger(const Slice& value, Logger* logger) const;
+};
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/merge_operators.cc

@@ -12,46 +12,14 @@
 #include "rocksdb/utilities/customizable_util.h"
 #include "rocksdb/utilities/object_registry.h"
 #include "utilities/merge_operators/bytesxor.h"
+#include "utilities/merge_operators/max_operator.h"
+#include "utilities/merge_operators/put_operator.h"
 #include "utilities/merge_operators/sortlist.h"
 #include "utilities/merge_operators/string_append/stringappend.h"
 #include "utilities/merge_operators/string_append/stringappend2.h"
+#include "utilities/merge_operators/uint64add.h"
 
 namespace ROCKSDB_NAMESPACE {
-static bool LoadMergeOperator(const std::string& id,
-                              std::shared_ptr<MergeOperator>* result) {
-  bool success = true;
-  // TODO: Hook the "name" up to the actual Name() of the MergeOperators?
-  // Requires these classes be moved into a header file...
-  if (id == "put" || id == "PutOperator") {
-    *result = MergeOperators::CreatePutOperator();
-  } else if (id == "put_v1") {
-    *result = MergeOperators::CreateDeprecatedPutOperator();
-  } else if (id == "uint64add" || id == "UInt64AddOperator") {
-    *result = MergeOperators::CreateUInt64AddOperator();
-  } else if (id == "max" || id == "MaxOperator") {
-    *result = MergeOperators::CreateMaxOperator();
-#ifdef ROCKSDB_LITE
-    // The remainder of the classes are handled by the ObjectRegistry in
-    // non-LITE mode
-  } else if (id == StringAppendOperator::kNickName() ||
-             id == StringAppendOperator::kClassName()) {
-    *result = MergeOperators::CreateStringAppendOperator();
-  } else if (id == StringAppendTESTOperator::kNickName() ||
-             id == StringAppendTESTOperator::kClassName()) {
-    *result = MergeOperators::CreateStringAppendTESTOperator();
-  } else if (id == BytesXOROperator::kNickName() ||
-             id == BytesXOROperator::kClassName()) {
-    *result = MergeOperators::CreateBytesXOROperator();
-  } else if (id == SortList::kNickName() || id == SortList::kClassName()) {
-    *result = MergeOperators::CreateSortOperator();
-#endif  // ROCKSDB_LITE
-  } else {
-    success = false;
-  }
-  return success;
-}
-
-#ifndef ROCKSDB_LITE
 static int RegisterBuiltinMergeOperators(ObjectLibrary& library,
                                          const std::string& /*arg*/) {
   size_t num_types;
@@ -87,22 +55,49 @@ static int RegisterBuiltinMergeOperators(ObjectLibrary& library,
         guard->reset(new BytesXOROperator());
         return guard->get();
       });
+  library.AddFactory<MergeOperator>(
+      ObjectLibrary::PatternEntry(UInt64AddOperator::kClassName())
+          .AnotherName(UInt64AddOperator::kNickName()),
+      [](const std::string& /*uri*/, std::unique_ptr<MergeOperator>* guard,
+         std::string* /*errmsg*/) {
+        guard->reset(new UInt64AddOperator());
+        return guard->get();
+      });
+  library.AddFactory<MergeOperator>(
+      ObjectLibrary::PatternEntry(MaxOperator::kClassName())
+          .AnotherName(MaxOperator::kNickName()),
+      [](const std::string& /*uri*/, std::unique_ptr<MergeOperator>* guard,
+         std::string* /*errmsg*/) {
+        guard->reset(new MaxOperator());
+        return guard->get();
+      });
+  library.AddFactory<MergeOperator>(
+      ObjectLibrary::PatternEntry(PutOperatorV2::kClassName())
+          .AnotherName(PutOperatorV2::kNickName()),
+      [](const std::string& /*uri*/, std::unique_ptr<MergeOperator>* guard,
+         std::string* /*errmsg*/) {
+        guard->reset(new PutOperatorV2());
+        return guard->get();
+      });
+  library.AddFactory<MergeOperator>(
+      ObjectLibrary::PatternEntry(PutOperator::kNickName()),
+      [](const std::string& /*uri*/, std::unique_ptr<MergeOperator>* guard,
+         std::string* /*errmsg*/) {
+        guard->reset(new PutOperator());
+        return guard->get();
+      });
 
   return static_cast<int>(library.GetFactoryCount(&num_types));
 }
-#endif  // ROCKSDB_LITE
 
 Status MergeOperator::CreateFromString(const ConfigOptions& config_options,
                                        const std::string& value,
                                        std::shared_ptr<MergeOperator>* result) {
-#ifndef ROCKSDB_LITE
   static std::once_flag once;
   std::call_once(once, [&]() {
     RegisterBuiltinMergeOperators(*(ObjectLibrary::Default().get()), "");
   });
-#endif  // ROCKSDB_LITE
-  return LoadSharedObject<MergeOperator>(config_options, value,
-                                         LoadMergeOperator, result);
+  return LoadSharedObject<MergeOperator>(config_options, value, result);
 }
 
 std::shared_ptr<MergeOperator> MergeOperators::CreateFromStringId(

package/deps/rocksdb/rocksdb/utilities/object_registry.cc

@@ -14,7 +14,6 @@
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
-#ifndef ROCKSDB_LITE
 namespace {
 bool MatchesInteger(const std::string &target, size_t start, size_t pos) {
   // If it is numeric, everything up to the match must be a number
@@ -379,5 +378,4 @@ int ObjectRegistry::RegisterPlugin(const std::string &name,
   }
 }
 
-#endif  // ROCKSDB_LITE
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/object_registry_test.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "rocksdb/utilities/object_registry.h"
 
@@ -861,12 +860,3 @@ int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }
 
-#else  // ROCKSDB_LITE
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr, "SKIPPED as ObjRegistry is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/option_change_migration/option_change_migration.cc

@@ -5,7 +5,6 @@
 
 #include "rocksdb/utilities/option_change_migration.h"
 
-#ifndef ROCKSDB_LITE
 #include "rocksdb/db.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -175,12 +174,3 @@ Status OptionChangeMigration(std::string dbname, const Options& old_opts,
   }
 }
 }  // namespace ROCKSDB_NAMESPACE
-#else
-namespace ROCKSDB_NAMESPACE {
-Status OptionChangeMigration(std::string /*dbname*/,
-                             const Options& /*old_opts*/,
-                             const Options& /*new_opts*/) {
-  return Status::NotSupported();
-}
-}  // namespace ROCKSDB_NAMESPACE
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/option_change_migration/option_change_migration_test.cc

@@ -49,7 +49,6 @@ class DBOptionChangeMigrationTests
   uint64_t fifo_max_table_files_size_;
 };
 
-#ifndef ROCKSDB_LITE
 TEST_P(DBOptionChangeMigrationTests, Migrate1) {
   Options old_options = CurrentOptions();
   old_options.compaction_style =
@@ -540,7 +539,6 @@ TEST_F(DBOptionChangeMigrationTest, CompactedSrcToUniversal) {
   }
 }
 
-#endif  // ROCKSDB_LITE
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/utilities/options/options_util.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "rocksdb/utilities/options_util.h"
 
@@ -14,20 +13,6 @@
 #include "table/block_based/block_based_table_factory.h"
 
 namespace ROCKSDB_NAMESPACE {
-Status LoadOptionsFromFile(const std::string& file_name, Env* env,
-                           DBOptions* db_options,
-                           std::vector<ColumnFamilyDescriptor>* cf_descs,
-                           bool ignore_unknown_options,
-                           std::shared_ptr<Cache>* cache) {
-  ConfigOptions config_options;
-  config_options.ignore_unknown_options = ignore_unknown_options;
-  config_options.input_strings_escaped = true;
-  config_options.env = env;
-
-  return LoadOptionsFromFile(config_options, file_name, db_options, cf_descs,
-                             cache);
-}
-
 Status LoadOptionsFromFile(const ConfigOptions& config_options,
                            const std::string& file_name, DBOptions* db_options,
                            std::vector<ColumnFamilyDescriptor>* cf_descs,
@@ -90,19 +75,6 @@ Status GetLatestOptionsFileName(const std::string& dbpath, Env* env,
   return Status::OK();
 }
 
-Status LoadLatestOptions(const std::string& dbpath, Env* env,
-                         DBOptions* db_options,
-                         std::vector<ColumnFamilyDescriptor>* cf_descs,
-                         bool ignore_unknown_options,
-                         std::shared_ptr<Cache>* cache) {
-  ConfigOptions config_options;
-  config_options.ignore_unknown_options = ignore_unknown_options;
-  config_options.input_strings_escaped = true;
-  config_options.env = env;
-
-  return LoadLatestOptions(config_options, dbpath, db_options, cf_descs, cache);
-}
-
 Status LoadLatestOptions(const ConfigOptions& config_options,
                          const std::string& dbpath, DBOptions* db_options,
                          std::vector<ColumnFamilyDescriptor>* cf_descs,
@@ -117,19 +89,6 @@ Status LoadLatestOptions(const ConfigOptions& config_options,
                              db_options, cf_descs, cache);
 }
 
-Status CheckOptionsCompatibility(
-    const std::string& dbpath, Env* env, const DBOptions& db_options,
-    const std::vector<ColumnFamilyDescriptor>& cf_descs,
-    bool ignore_unknown_options) {
-  ConfigOptions config_options(db_options);
-  config_options.sanity_level = ConfigOptions::kSanityLevelLooselyCompatible;
-  config_options.ignore_unknown_options = ignore_unknown_options;
-  config_options.input_strings_escaped = true;
-  config_options.env = env;
-  return CheckOptionsCompatibility(config_options, dbpath, db_options,
-                                   cf_descs);
-}
-
 Status CheckOptionsCompatibility(
     const ConfigOptions& config_options, const std::string& dbpath,
     const DBOptions& db_options,
@@ -156,4 +115,3 @@ Status CheckOptionsCompatibility(
 }
 
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // !ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/options/options_util_test.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "rocksdb/utilities/options_util.h"
 
@@ -63,7 +62,11 @@ TEST_F(OptionsUtilTest, SaveAndLoad) {
 
   DBOptions loaded_db_opt;
   std::vector<ColumnFamilyDescriptor> loaded_cf_descs;
-  ASSERT_OK(LoadOptionsFromFile(kFileName, env_.get(), &loaded_db_opt,
+  ConfigOptions config_options;
+  config_options.ignore_unknown_options = false;
+  config_options.input_strings_escaped = true;
+  config_options.env = env_.get();
+  ASSERT_OK(LoadOptionsFromFile(config_options, kFileName, &loaded_db_opt,
                                 &loaded_cf_descs));
   ConfigOptions exact;
   exact.sanity_level = ConfigOptions::kSanityLevelExactMatch;
@@ -142,19 +145,6 @@ TEST_F(OptionsUtilTest, SaveAndLoadWithCacheCheck) {
       ASSERT_EQ(loaded_bbt_opt->block_cache.get(), cache.get());
     }
   }
-
-  // Test the old interface
-  ASSERT_OK(LoadOptionsFromFile(kFileName, env_.get(), &loaded_db_opt,
-                                &loaded_cf_descs, false, &cache));
-  for (size_t i = 0; i < loaded_cf_descs.size(); i++) {
-    auto* loaded_bbt_opt =
-        loaded_cf_descs[i]
-            .options.table_factory->GetOptions<BlockBasedTableOptions>();
-    // Expect the same cache will be loaded
-    if (loaded_bbt_opt != nullptr) {
-      ASSERT_EQ(loaded_bbt_opt->block_cache.get(), cache.get());
-    }
-  }
   ASSERT_OK(DestroyDB(dbname_, Options(loaded_db_opt, cf_opts[0])));
 }
 
@@ -386,11 +376,8 @@ TEST_F(OptionsUtilTest, LatestOptionsNotFound) {
   ASSERT_TRUE(s.IsNotFound());
   ASSERT_TRUE(s.IsPathNotFound());
 
-  s = LoadLatestOptions(dbname_, options.env, &options, &cf_descs);
-  ASSERT_TRUE(s.IsNotFound());
-  ASSERT_TRUE(s.IsPathNotFound());
-
   s = LoadLatestOptions(config_opts, dbname_, &options, &cf_descs);
+  ASSERT_TRUE(s.IsNotFound());
   ASSERT_TRUE(s.IsPathNotFound());
 
   s = GetLatestOptionsFileName(dbname_, options.env, &options_file_name);
@@ -404,7 +391,7 @@ TEST_F(OptionsUtilTest, LatestOptionsNotFound) {
   ASSERT_TRUE(s.IsNotFound());
   ASSERT_TRUE(s.IsPathNotFound());
 
-  s = LoadLatestOptions(dbname_, options.env, &options, &cf_descs);
+  s = LoadLatestOptions(config_opts, dbname_, &options, &cf_descs);
   ASSERT_TRUE(s.IsNotFound());
   ASSERT_TRUE(s.IsPathNotFound());
 
@@ -641,6 +628,9 @@ TEST_F(OptionsUtilTest, RenameDatabaseDirectory) {
   DBOptions db_opts;
   std::vector<ColumnFamilyDescriptor> cf_descs;
   std::vector<ColumnFamilyHandle*> handles;
+  ConfigOptions ignore_opts;
+  ignore_opts.ignore_unknown_options = false;
+  ignore_opts.env = options.env;
 
   options.create_if_missing = true;
 
@@ -651,7 +641,7 @@ TEST_F(OptionsUtilTest, RenameDatabaseDirectory) {
   auto new_dbname = dbname_ + "_2";
 
   ASSERT_OK(options.env->RenameFile(dbname_, new_dbname));
-  ASSERT_OK(LoadLatestOptions(new_dbname, options.env, &db_opts, &cf_descs));
+  ASSERT_OK(LoadLatestOptions(ignore_opts, new_dbname, &db_opts, &cf_descs));
   ASSERT_EQ(cf_descs.size(), 1U);
 
   db_opts.create_if_missing = false;
@@ -675,20 +665,23 @@ TEST_F(OptionsUtilTest, WalDirSettings) {
   DBOptions db_opts;
   std::vector<ColumnFamilyDescriptor> cf_descs;
   std::vector<ColumnFamilyHandle*> handles;
+  ConfigOptions ignore_opts;
+  ignore_opts.ignore_unknown_options = false;
+  ignore_opts.env = options.env;
 
   options.create_if_missing = true;
 
   // Open a DB with no wal dir set.  The wal_dir should stay empty
   ASSERT_OK(DB::Open(options, dbname_, &db));
   delete db;
-  ASSERT_OK(LoadLatestOptions(dbname_, options.env, &db_opts, &cf_descs));
+  ASSERT_OK(LoadLatestOptions(ignore_opts, dbname_, &db_opts, &cf_descs));
   ASSERT_EQ(db_opts.wal_dir, "");
 
   // Open a DB with wal_dir == dbname.  The wal_dir should be set to empty
   options.wal_dir = dbname_;
   ASSERT_OK(DB::Open(options, dbname_, &db));
   delete db;
-  ASSERT_OK(LoadLatestOptions(dbname_, options.env, &db_opts, &cf_descs));
+  ASSERT_OK(LoadLatestOptions(ignore_opts, dbname_, &db_opts, &cf_descs));
   ASSERT_EQ(db_opts.wal_dir, "");
 
   // Open a DB with no wal_dir but a db_path==dbname_.  The wal_dir should be
@@ -697,7 +690,7 @@ TEST_F(OptionsUtilTest, WalDirSettings) {
   options.db_paths.emplace_back(dbname_, std::numeric_limits<uint64_t>::max());
   ASSERT_OK(DB::Open(options, dbname_, &db));
   delete db;
-  ASSERT_OK(LoadLatestOptions(dbname_, options.env, &db_opts, &cf_descs));
+  ASSERT_OK(LoadLatestOptions(ignore_opts, dbname_, &db_opts, &cf_descs));
   ASSERT_EQ(db_opts.wal_dir, "");
 
   // Open a DB with no wal_dir==dbname_ and db_path==dbname_.  The wal_dir
@@ -706,7 +699,7 @@ TEST_F(OptionsUtilTest, WalDirSettings) {
   options.db_paths.emplace_back(dbname_, std::numeric_limits<uint64_t>::max());
   ASSERT_OK(DB::Open(options, dbname_, &db));
   delete db;
-  ASSERT_OK(LoadLatestOptions(dbname_, options.env, &db_opts, &cf_descs));
+  ASSERT_OK(LoadLatestOptions(ignore_opts, dbname_, &db_opts, &cf_descs));
   ASSERT_EQ(db_opts.wal_dir, "");
   ASSERT_OK(DestroyDB(dbname_, options));
 
@@ -717,7 +710,7 @@ TEST_F(OptionsUtilTest, WalDirSettings) {
                                 std::numeric_limits<uint64_t>::max());
   ASSERT_OK(DB::Open(options, dbname_, &db));
   delete db;
-  ASSERT_OK(LoadLatestOptions(dbname_, options.env, &db_opts, &cf_descs));
+  ASSERT_OK(LoadLatestOptions(ignore_opts, dbname_, &db_opts, &cf_descs));
   ASSERT_EQ(db_opts.wal_dir, dbname_);
   ASSERT_OK(DestroyDB(dbname_, options));
 
@@ -726,7 +719,7 @@ TEST_F(OptionsUtilTest, WalDirSettings) {
   options.db_paths.clear();
   ASSERT_OK(DB::Open(options, dbname_, &db));
   delete db;
-  ASSERT_OK(LoadLatestOptions(dbname_, options.env, &db_opts, &cf_descs));
+  ASSERT_OK(LoadLatestOptions(ignore_opts, dbname_, &db_opts, &cf_descs));
   ASSERT_EQ(db_opts.wal_dir, dbname_ + "/wal");
   ASSERT_OK(DestroyDB(dbname_, options));
 }
@@ -737,6 +730,9 @@ TEST_F(OptionsUtilTest, WalDirInOptins) {
   DBOptions db_opts;
   std::vector<ColumnFamilyDescriptor> cf_descs;
   std::vector<ColumnFamilyHandle*> handles;
+  ConfigOptions ignore_opts;
+  ignore_opts.ignore_unknown_options = false;
+  ignore_opts.env = options.env;
 
   // Store an options file with wal_dir=dbname_ and make sure it still loads
   // when the input wal_dir is empty
@@ -750,12 +746,12 @@ TEST_F(OptionsUtilTest, WalDirInOptins) {
   ASSERT_OK(PersistRocksDBOptions(options, {"default"}, {options},
                                   dbname_ + "/" + options_file,
                                   options.env->GetFileSystem().get()));
-  ASSERT_OK(LoadLatestOptions(dbname_, options.env, &db_opts, &cf_descs));
+  ASSERT_OK(LoadLatestOptions(ignore_opts, dbname_, &db_opts, &cf_descs));
   ASSERT_EQ(db_opts.wal_dir, dbname_);
   options.wal_dir = "";
   ASSERT_OK(DB::Open(options, dbname_, &db));
   delete db;
-  ASSERT_OK(LoadLatestOptions(dbname_, options.env, &db_opts, &cf_descs));
+  ASSERT_OK(LoadLatestOptions(ignore_opts, dbname_, &db_opts, &cf_descs));
   ASSERT_EQ(db_opts.wal_dir, "");
 }
 }  // namespace ROCKSDB_NAMESPACE
@@ -769,11 +765,3 @@ int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }
 
-#else
-#include <cstdio>
-
-int main(int /*argc*/, char** /*argv*/) {
-  printf("Skipped in RocksDBLite as utilities are not supported.\n");
-  return 0;
-}
-#endif  // !ROCKSDB_LITE