@nxtedition/rocksdb 8.1.7 → 8.1.8

package/deps/rocksdb/rocksdb/options/customizable.cc

@@ -35,7 +35,6 @@ std::string Customizable::GenerateIndividualId() const {
   return ostr.str();
 }
 
-#ifndef ROCKSDB_LITE
 Status Customizable::GetOption(const ConfigOptions& config_options,
                                const std::string& opt_name,
                                std::string* value) const {
@@ -68,7 +67,6 @@ std::string Customizable::SerializeOptions(const ConfigOptions& config_options,
   return result;
 }
 
-#endif  // ROCKSDB_LITE
 
 bool Customizable::AreEquivalent(const ConfigOptions& config_options,
                                  const Configurable* other,
@@ -102,9 +100,6 @@ Status Customizable::GetOptionsMap(
   } else if (customizable != nullptr) {
     status =
         Configurable::GetOptionsMap(value, customizable->GetId(), id, props);
-#ifdef ROCKSDB_LITE
-    (void)config_options;
-#else
     if (status.ok() && customizable->IsInstanceOf(*id)) {
       // The new ID and the old ID match, so the objects are the same type.
       // Try to get the existing options, ignoring any errors
@@ -118,7 +113,6 @@ Status Customizable::GetOptionsMap(
         }
       }
     }
-#endif  // ROCKSDB_LITE
   } else {
     status = Configurable::GetOptionsMap(value, "", id, props);
   }

package/deps/rocksdb/rocksdb/options/customizable_test.cc

@@ -84,7 +84,6 @@ class TestCustomizable : public Customizable {
 
   const char* Name() const override { return name_.c_str(); }
   static const char* Type() { return "test.custom"; }
-#ifndef ROCKSDB_LITE
   static Status CreateFromString(const ConfigOptions& opts,
                                  const std::string& value,
                                  std::unique_ptr<TestCustomizable>* result);
@@ -94,7 +93,6 @@ class TestCustomizable : public Customizable {
   static Status CreateFromString(const ConfigOptions& opts,
                                  const std::string& value,
                                  TestCustomizable** result);
-#endif  // ROCKSDB_LITE
   bool IsInstanceOf(const std::string& name) const override {
     if (name == kClassName()) {
       return true;
@@ -114,14 +112,12 @@ struct AOptions {
 };
 
 static std::unordered_map<std::string, OptionTypeInfo> a_option_info = {
-#ifndef ROCKSDB_LITE
     {"int",
      {offsetof(struct AOptions, i), OptionType::kInt,
       OptionVerificationType::kNormal, OptionTypeFlags::kMutable}},
     {"bool",
      {offsetof(struct AOptions, b), OptionType::kBoolean,
       OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };
 
 class ACustomizable : public TestCustomizable {
@@ -144,14 +140,12 @@ struct BOptions {
 };
 
 static std::unordered_map<std::string, OptionTypeInfo> b_option_info = {
-#ifndef ROCKSDB_LITE
     {"string",
      {offsetof(struct BOptions, s), OptionType::kString,
       OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
     {"bool",
      {offsetof(struct BOptions, b), OptionType::kBoolean,
       OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };
 
 class BCustomizable : public TestCustomizable {
@@ -166,20 +160,6 @@ class BCustomizable : public TestCustomizable {
   BOptions opts_;
 };
 
-#ifndef ROCKSDB_LITE
-static bool LoadSharedB(const std::string& id,
-                        std::shared_ptr<TestCustomizable>* result) {
-  if (id == "B") {
-    result->reset(new BCustomizable(id));
-    return true;
-  } else if (id.empty()) {
-    result->reset();
-    return true;
-  } else {
-    return false;
-  }
-}
-
 static int A_count = 0;
 static int RegisterCustomTestObjects(ObjectLibrary& library,
                                      const std::string& /*arg*/) {
@@ -191,6 +171,12 @@ static int RegisterCustomTestObjects(ObjectLibrary& library,
         A_count++;
         return guard->get();
       });
+  library.AddFactory<TestCustomizable>(
+      "B", [](const std::string& name, std::unique_ptr<TestCustomizable>* guard,
+              std::string* /* msg */) {
+        guard->reset(new BCustomizable(name));
+        return guard->get();
+      });
 
   library.AddFactory<TestCustomizable>(
       "S", [](const std::string& name,
@@ -199,7 +185,6 @@ static int RegisterCustomTestObjects(ObjectLibrary& library,
   size_t num_types;
   return static_cast<int>(library.GetFactoryCount(&num_types));
 }
-#endif  // ROCKSDB_LITE
 
 struct SimpleOptions {
   static const char* kName() { return "simple"; }
@@ -210,7 +195,6 @@ struct SimpleOptions {
 };
 
 static std::unordered_map<std::string, OptionTypeInfo> simple_option_info = {
-#ifndef ROCKSDB_LITE
     {"bool",
      {offsetof(struct SimpleOptions, b), OptionType::kBoolean,
       OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
@@ -226,7 +210,6 @@ static std::unordered_map<std::string, OptionTypeInfo> simple_option_info = {
      OptionTypeInfo::AsCustomRawPtr<TestCustomizable>(
          offsetof(struct SimpleOptions, cp), OptionVerificationType::kNormal,
          OptionTypeFlags::kAllowNull)},
-#endif  // ROCKSDB_LITE
 };
 
 class SimpleConfigurable : public Configurable {
@@ -242,7 +225,6 @@ class SimpleConfigurable : public Configurable {
   }
 };
 
-#ifndef ROCKSDB_LITE
 static void GetMapFromProperties(
     const std::string& props,
     std::unordered_map<std::string, std::string>* map) {
@@ -258,71 +240,37 @@ static void GetMapFromProperties(
     (*map)[name] = value;
   }
 }
-#endif  // ROCKSDB_LITE
 }  // namespace
 
-#ifndef ROCKSDB_LITE
 Status TestCustomizable::CreateFromString(
     const ConfigOptions& config_options, const std::string& value,
     std::shared_ptr<TestCustomizable>* result) {
-  return LoadSharedObject<TestCustomizable>(config_options, value, LoadSharedB,
-                                            result);
+  return LoadSharedObject<TestCustomizable>(config_options, value, result);
 }
 
 Status TestCustomizable::CreateFromString(
     const ConfigOptions& config_options, const std::string& value,
     std::unique_ptr<TestCustomizable>* result) {
-  return LoadUniqueObject<TestCustomizable>(
-      config_options, value,
-      [](const std::string& id, std::unique_ptr<TestCustomizable>* u) {
-        if (id == "B") {
-          u->reset(new BCustomizable(id));
-          return true;
-        } else if (id.empty()) {
-          u->reset();
-          return true;
-        } else {
-          return false;
-        }
-      },
-      result);
+  return LoadUniqueObject<TestCustomizable>(config_options, value, result);
 }
 
 Status TestCustomizable::CreateFromString(const ConfigOptions& config_options,
                                           const std::string& value,
                                           TestCustomizable** result) {
-  return LoadStaticObject<TestCustomizable>(
-      config_options, value,
-      [](const std::string& id, TestCustomizable** ptr) {
-        if (id == "B") {
-          *ptr = new BCustomizable(id);
-          return true;
-        } else if (id.empty()) {
-          *ptr = nullptr;
-          return true;
-        } else {
-          return false;
-        }
-      },
-      result);
+  return LoadStaticObject<TestCustomizable>(config_options, value, result);
 }
-#endif  // ROCKSDB_LITE
 
 class CustomizableTest : public testing::Test {
  public:
   CustomizableTest() {
     config_options_.invoke_prepare_options = false;
-#ifndef ROCKSDB_LITE
-    // GetOptionsFromMap is not supported in ROCKSDB_LITE
     config_options_.registry->AddLibrary("CustomizableTest",
                                          RegisterCustomTestObjects, "");
-#endif  // ROCKSDB_LITE
   }
 
   ConfigOptions config_options_;
 };
 
-#ifndef ROCKSDB_LITE  // GetOptionsFromMap is not supported in ROCKSDB_LITE
 // Tests that a Customizable can be created by:
 //    - a simple name
 //    - a XXX.id option
@@ -584,11 +532,9 @@ TEST_F(CustomizableTest, IsInstanceOfTest) {
 
 TEST_F(CustomizableTest, PrepareOptionsTest) {
   static std::unordered_map<std::string, OptionTypeInfo> p_option_info = {
-#ifndef ROCKSDB_LITE
       {"can_prepare",
        {0, OptionType::kBoolean, OptionVerificationType::kNormal,
         OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
   };
 
   class PrepareCustomizable : public TestCustomizable {
@@ -665,11 +611,9 @@ TEST_F(CustomizableTest, PrepareOptionsTest) {
 
 namespace {
 static std::unordered_map<std::string, OptionTypeInfo> inner_option_info = {
-#ifndef ROCKSDB_LITE
     {"inner",
      OptionTypeInfo::AsCustomSharedPtr<TestCustomizable>(
          0, OptionVerificationType::kNormal, OptionTypeFlags::kStringNameOnly)}
-#endif  // ROCKSDB_LITE
 };
 
 struct InnerOptions {
@@ -947,7 +891,6 @@ TEST_F(CustomizableTest, NewEmptyStaticTest) {
 }
 
 namespace {
-#ifndef ROCKSDB_LITE
 static std::unordered_map<std::string, OptionTypeInfo> vector_option_info = {
     {"vector",
      OptionTypeInfo::Vector<std::shared_ptr<TestCustomizable>>(
@@ -996,7 +939,6 @@ TEST_F(CustomizableTest, NoNameTest) {
   ASSERT_EQ(copts->cu, nullptr);
 }
 
-#endif  // ROCKSDB_LITE
 
 TEST_F(CustomizableTest, IgnoreUnknownObjects) {
   ConfigOptions ignore = config_options_;
@@ -1004,70 +946,34 @@ TEST_F(CustomizableTest, IgnoreUnknownObjects) {
   std::unique_ptr<TestCustomizable> unique;
   TestCustomizable* pointer = nullptr;
   ignore.ignore_unsupported_options = false;
-  ASSERT_NOK(
-      LoadSharedObject<TestCustomizable>(ignore, "Unknown", nullptr, &shared));
-  ASSERT_NOK(
-      LoadUniqueObject<TestCustomizable>(ignore, "Unknown", nullptr, &unique));
-  ASSERT_NOK(
-      LoadStaticObject<TestCustomizable>(ignore, "Unknown", nullptr, &pointer));
+  ASSERT_NOK(LoadSharedObject<TestCustomizable>(ignore, "Unknown", &shared));
+  ASSERT_NOK(LoadUniqueObject<TestCustomizable>(ignore, "Unknown", &unique));
+  ASSERT_NOK(LoadStaticObject<TestCustomizable>(ignore, "Unknown", &pointer));
   ASSERT_EQ(shared.get(), nullptr);
   ASSERT_EQ(unique.get(), nullptr);
   ASSERT_EQ(pointer, nullptr);
   ignore.ignore_unsupported_options = true;
-  ASSERT_OK(
-      LoadSharedObject<TestCustomizable>(ignore, "Unknown", nullptr, &shared));
-  ASSERT_OK(
-      LoadUniqueObject<TestCustomizable>(ignore, "Unknown", nullptr, &unique));
-  ASSERT_OK(
-      LoadStaticObject<TestCustomizable>(ignore, "Unknown", nullptr, &pointer));
+  ASSERT_OK(LoadSharedObject<TestCustomizable>(ignore, "Unknown", &shared));
+  ASSERT_OK(LoadUniqueObject<TestCustomizable>(ignore, "Unknown", &unique));
+  ASSERT_OK(LoadStaticObject<TestCustomizable>(ignore, "Unknown", &pointer));
   ASSERT_EQ(shared.get(), nullptr);
   ASSERT_EQ(unique.get(), nullptr);
   ASSERT_EQ(pointer, nullptr);
-  ASSERT_OK(LoadSharedObject<TestCustomizable>(ignore, "id=Unknown", nullptr,
-                                               &shared));
-  ASSERT_OK(LoadUniqueObject<TestCustomizable>(ignore, "id=Unknown", nullptr,
-                                               &unique));
-  ASSERT_OK(LoadStaticObject<TestCustomizable>(ignore, "id=Unknown", nullptr,
-                                               &pointer));
+  ASSERT_OK(LoadSharedObject<TestCustomizable>(ignore, "id=Unknown", &shared));
+  ASSERT_OK(LoadUniqueObject<TestCustomizable>(ignore, "id=Unknown", &unique));
+  ASSERT_OK(LoadStaticObject<TestCustomizable>(ignore, "id=Unknown", &pointer));
   ASSERT_EQ(shared.get(), nullptr);
   ASSERT_EQ(unique.get(), nullptr);
   ASSERT_EQ(pointer, nullptr);
   ASSERT_OK(LoadSharedObject<TestCustomizable>(ignore, "id=Unknown;option=bad",
-                                               nullptr, &shared));
+                                               &shared));
   ASSERT_OK(LoadUniqueObject<TestCustomizable>(ignore, "id=Unknown;option=bad",
-                                               nullptr, &unique));
+                                               &unique));
   ASSERT_OK(LoadStaticObject<TestCustomizable>(ignore, "id=Unknown;option=bad",
-                                               nullptr, &pointer));
-  ASSERT_EQ(shared.get(), nullptr);
-  ASSERT_EQ(unique.get(), nullptr);
-  ASSERT_EQ(pointer, nullptr);
-}
-
-TEST_F(CustomizableTest, FactoryFunctionTest) {
-  std::shared_ptr<TestCustomizable> shared;
-  std::unique_ptr<TestCustomizable> unique;
-  TestCustomizable* pointer = nullptr;
-  ConfigOptions ignore = config_options_;
-  ignore.ignore_unsupported_options = false;
-  ASSERT_OK(TestCustomizable::CreateFromString(ignore, "B", &shared));
-  ASSERT_OK(TestCustomizable::CreateFromString(ignore, "B", &unique));
-  ASSERT_OK(TestCustomizable::CreateFromString(ignore, "B", &pointer));
-  ASSERT_NE(shared.get(), nullptr);
-  ASSERT_NE(unique.get(), nullptr);
-  ASSERT_NE(pointer, nullptr);
-  delete pointer;
-  pointer = nullptr;
-  ASSERT_OK(TestCustomizable::CreateFromString(ignore, "id=", &shared));
-  ASSERT_OK(TestCustomizable::CreateFromString(ignore, "id=", &unique));
-  ASSERT_OK(TestCustomizable::CreateFromString(ignore, "id=", &pointer));
+                                               &pointer));
   ASSERT_EQ(shared.get(), nullptr);
   ASSERT_EQ(unique.get(), nullptr);
   ASSERT_EQ(pointer, nullptr);
-  ASSERT_NOK(TestCustomizable::CreateFromString(ignore, "option=bad", &shared));
-  ASSERT_NOK(TestCustomizable::CreateFromString(ignore, "option=bad", &unique));
-  ASSERT_NOK(
-      TestCustomizable::CreateFromString(ignore, "option=bad", &pointer));
-  ASSERT_EQ(pointer, nullptr);
 }
 
 TEST_F(CustomizableTest, URLFactoryTest) {
@@ -1317,7 +1223,6 @@ TEST_F(CustomizableTest, CreateManagedObjects) {
   ASSERT_EQ(mc1, obj);
 }
 
-#endif  // !ROCKSDB_LITE
 
 namespace {
 class TestSecondaryCache : public SecondaryCache {
@@ -1385,7 +1290,6 @@ class MockMemoryAllocator : public BaseMemoryAllocator {
   const char* Name() const override { return kClassName(); }
 };
 
-#ifndef ROCKSDB_LITE
 class MockEncryptionProvider : public EncryptionProvider {
  public:
   explicit MockEncryptionProvider(const std::string& id) : id_(id) {}
@@ -1428,7 +1332,6 @@ class MockCipher : public BlockCipher {
   Status Encrypt(char* /*data*/) override { return Status::NotSupported(); }
   Status Decrypt(char* data) override { return Encrypt(data); }
 };
-#endif  // ROCKSDB_LITE
 
 class DummyFileSystem : public FileSystemWrapper {
  public:
@@ -1438,9 +1341,7 @@ class DummyFileSystem : public FileSystemWrapper {
   const char* Name() const override { return kClassName(); }
 };
 
-#ifndef ROCKSDB_LITE
 
-#endif  // ROCKSDB_LITE
 
 class MockTablePropertiesCollectorFactory
     : public TablePropertiesCollectorFactory {
@@ -1489,7 +1390,6 @@ class MockFilterPolicy : public FilterPolicy {
   }
 };
 
-#ifndef ROCKSDB_LITE
 static int RegisterLocalObjects(ObjectLibrary& library,
                                 const std::string& /*arg*/) {
   size_t num_types;
@@ -1615,7 +1515,6 @@ static int RegisterLocalObjects(ObjectLibrary& library,
 
   return static_cast<int>(library.GetFactoryCount(&num_types));
 }
-#endif  // !ROCKSDB_LITE
 }  // namespace
 
 class LoadCustomizableTest : public testing::Test {
@@ -1625,16 +1524,11 @@ class LoadCustomizableTest : public testing::Test {
     config_options_.invoke_prepare_options = false;
   }
   bool RegisterTests(const std::string& arg) {
-#ifndef ROCKSDB_LITE
     config_options_.registry->AddLibrary("custom-tests",
                                          test::RegisterTestObjects, arg);
     config_options_.registry->AddLibrary("local-tests", RegisterLocalObjects,
                                          arg);
     return true;
-#else
-    (void)arg;
-    return false;
-#endif  // !ROCKSDB_LITE
   }
 
   template <typename T, typename U>
@@ -1676,11 +1570,9 @@ class LoadCustomizableTest : public testing::Test {
     std::unordered_set<std::string> factories = expected;
     Status s = T::CreateFromString(config_options_, mock, object);
     EXPECT_NOK(s);
-#ifndef ROCKSDB_LITE
     std::vector<std::string> builtins;
     ObjectLibrary::Default()->GetFactoryNames(T::Type(), &builtins);
     factories.insert(builtins.begin(), builtins.end());
-#endif  // ROCKSDB_LITE
     Status result;
     int created = 0;
     for (const auto& name : factories) {
@@ -1702,7 +1594,6 @@ class LoadCustomizableTest : public testing::Test {
         EXPECT_TRUE(object->get()->IsInstanceOf(name));
       }
     }
-#ifndef ROCKSDB_LITE
     std::vector<std::string> plugins;
     ObjectRegistry::Default()->GetFactoryNames(T::Type(), &plugins);
     if (plugins.size() > builtins.size()) {
@@ -1737,10 +1628,6 @@ class LoadCustomizableTest : public testing::Test {
            T::Type(), created, (int)expected.size(),
            (int)(factories.size() - expected.size()),
            (int)(plugins.size() - builtins.size()), (int)failed->size());
-#else
-    printf("%s: Created %d (expected %d) %d Failed\n", T::Type(), created,
-           (int)expected.size(), (int)failed->size());
-#endif  // ROCKSDB_LITE
     return result;
   }
 
@@ -1771,11 +1658,9 @@ class LoadCustomizableTest : public testing::Test {
     std::unordered_set<std::string> factories = expected;
     Status s = TestCreateStatic<T>(mock, object, delete_objects);
     EXPECT_NOK(s);
-#ifndef ROCKSDB_LITE
     std::vector<std::string> builtins;
     ObjectLibrary::Default()->GetFactoryNames(T::Type(), &builtins);
     factories.insert(builtins.begin(), builtins.end());
-#endif  // ROCKSDB_LITE
     int created = 0;
     Status result;
     for (const auto& name : factories) {
@@ -1786,7 +1671,6 @@ class LoadCustomizableTest : public testing::Test {
         failed->push_back(name);
       }
     }
-#ifndef ROCKSDB_LITE
     std::vector<std::string> plugins;
     ObjectRegistry::Default()->GetFactoryNames(T::Type(), &plugins);
     if (plugins.size() > builtins.size()) {
@@ -1814,10 +1698,6 @@ class LoadCustomizableTest : public testing::Test {
            T::Type(), created, (int)expected.size(),
            (int)(factories.size() - expected.size()),
            (int)(plugins.size() - builtins.size()), (int)failed->size());
-#else
-    printf("%s: Created %d (expected %d) %d Failed\n", T::Type(), created,
-           (int)expected.size(), (int)failed->size());
-#endif  // ROCKSDB_LITE
     return result;
   }
 
@@ -1831,7 +1711,6 @@ TEST_F(LoadCustomizableTest, LoadTableFactoryTest) {
   ASSERT_OK(
       TestSharedBuiltins<TableFactory>(mock::MockTableFactory::kClassName(),
                                        TableFactory::kBlockBasedTableName()));
-#ifndef ROCKSDB_LITE
   std::string opts_str = "table_factory=";
   ASSERT_OK(GetColumnFamilyOptionsFromString(
       config_options_, cf_opts_,
@@ -1839,17 +1718,14 @@ TEST_F(LoadCustomizableTest, LoadTableFactoryTest) {
   ASSERT_NE(cf_opts_.table_factory.get(), nullptr);
   ASSERT_STREQ(cf_opts_.table_factory->Name(),
                TableFactory::kBlockBasedTableName());
-#endif  // ROCKSDB_LITE
   if (RegisterTests("Test")) {
     ExpectCreateShared<TableFactory>(mock::MockTableFactory::kClassName());
-#ifndef ROCKSDB_LITE
     ASSERT_OK(GetColumnFamilyOptionsFromString(
         config_options_, cf_opts_,
         opts_str + mock::MockTableFactory::kClassName(), &cf_opts_));
     ASSERT_NE(cf_opts_.table_factory.get(), nullptr);
     ASSERT_STREQ(cf_opts_.table_factory->Name(),
                  mock::MockTableFactory::kClassName());
-#endif  // ROCKSDB_LITE
   }
 }
 
@@ -1870,7 +1746,6 @@ TEST_F(LoadCustomizableTest, LoadSecondaryCacheTest) {
   }
 }
 
-#ifndef ROCKSDB_LITE
 TEST_F(LoadCustomizableTest, LoadSstPartitionerFactoryTest) {
   ASSERT_OK(TestSharedBuiltins<SstPartitionerFactory>(
       "Mock", SstPartitionerFixedPrefixFactory::kClassName()));
@@ -1878,7 +1753,6 @@ TEST_F(LoadCustomizableTest, LoadSstPartitionerFactoryTest) {
     ExpectCreateShared<SstPartitionerFactory>("Mock");
   }
 }
-#endif  // ROCKSDB_LITE
 
 TEST_F(LoadCustomizableTest, LoadChecksumGenFactoryTest) {
   ASSERT_OK(TestSharedBuiltins<FileChecksumGenFactory>("Mock", ""));
@@ -1945,7 +1819,6 @@ TEST_F(LoadCustomizableTest, LoadStatisticsTest) {
   ASSERT_NE(db_opts_.statistics, nullptr);
   ASSERT_STREQ(db_opts_.statistics->Name(), "BasicStatistics");
 
-#ifndef ROCKSDB_LITE
   ASSERT_NOK(GetDBOptionsFromString(config_options_, db_opts_,
                                     "statistics=Test", &db_opts_));
   ASSERT_OK(GetDBOptionsFromString(config_options_, db_opts_,
@@ -1981,7 +1854,6 @@ TEST_F(LoadCustomizableTest, LoadStatisticsTest) {
     ASSERT_NE(inner->get(), nullptr);
     ASSERT_STREQ(inner->get()->Name(), TestStatistics::kClassName());
   }
-#endif
 }
 
 TEST_F(LoadCustomizableTest, LoadMemTableRepFactoryTest) {
@@ -2011,7 +1883,6 @@ TEST_F(LoadCustomizableTest, LoadMergeOperatorTest) {
       "put", "put_v1",      "PutOperator", "uint64add", "UInt64AddOperator",
       "max", "MaxOperator",
   };
-#ifndef ROCKSDB_LITE
   expected.insert({
       StringAppendOperator::kClassName(),
       StringAppendOperator::kNickName(),
@@ -2022,7 +1893,6 @@ TEST_F(LoadCustomizableTest, LoadMergeOperatorTest) {
       BytesXOROperator::kClassName(),
       BytesXOROperator::kNickName(),
   });
-#endif  // ROCKSDB_LITE
 
   ASSERT_OK(TestExpectedBuiltins<MergeOperator>("Changling", expected, &result,
                                                 &failed));
@@ -2048,7 +1918,6 @@ TEST_F(LoadCustomizableTest, LoadCompactionFilterTest) {
   }
 }
 
-#ifndef ROCKSDB_LITE
 TEST_F(LoadCustomizableTest, LoadEventListenerTest) {
   ASSERT_OK(TestSharedBuiltins<EventListener>(
       OnFileDeletionListener::kClassName(), ""));
@@ -2092,7 +1961,6 @@ TEST_F(LoadCustomizableTest, LoadEncryptionCipherTest) {
     ExpectCreateShared<BlockCipher>("Mock");
   }
 }
-#endif  // !ROCKSDB_LITE
 
 TEST_F(LoadCustomizableTest, LoadSystemClockTest) {
   ASSERT_OK(TestSharedBuiltins<SystemClock>(MockSystemClock::kClassName(),
@@ -2138,20 +2006,17 @@ TEST_F(LoadCustomizableTest, LoadFilterPolicyTest) {
       ReadOnlyBuiltinFilterPolicy::kClassName(),
   };
 
-#ifndef ROCKSDB_LITE
   expected.insert({
       kAutoBloom,
       BloomFilterPolicy::kNickName(),
       kAutoRibbon,
       RibbonFilterPolicy::kNickName(),
   });
-#endif  // ROCKSDB_LITE
   ASSERT_OK(TestExpectedBuiltins<const FilterPolicy>(
       "Mock", expected, &result, &failures, [](const std::string& name) {
         std::vector<std::string> names = {name + ":1.234"};
         return names;
       }));
-#ifndef ROCKSDB_LITE
   ASSERT_OK(FilterPolicy::CreateFromString(
       config_options_, kAutoBloom + ":1.234:false", &result));
   ASSERT_NE(result.get(), nullptr);
@@ -2168,7 +2033,6 @@ TEST_F(LoadCustomizableTest, LoadFilterPolicyTest) {
                                            kAutoRibbon + ":1.234:56", &result));
   ASSERT_NE(result.get(), nullptr);
   ASSERT_TRUE(result->IsInstanceOf(kAutoRibbon));
-#endif  // ROCKSDB_LITE
 
   if (RegisterTests("Test")) {
     ExpectCreateShared<FilterPolicy>(MockFilterPolicy::kClassName(), &result);
@@ -2176,7 +2040,6 @@ TEST_F(LoadCustomizableTest, LoadFilterPolicyTest) {
 
   std::shared_ptr<TableFactory> table;
 
-#ifndef ROCKSDB_LITE
   std::string table_opts = "id=BlockBasedTable; filter_policy=";
   ASSERT_OK(TableFactory::CreateFromString(config_options_,
                                            table_opts + "nullptr", &table));
@@ -2199,7 +2062,6 @@ TEST_F(LoadCustomizableTest, LoadFilterPolicyTest) {
   ASSERT_NE(bbto->filter_policy.get(), nullptr);
   ASSERT_TRUE(
       bbto->filter_policy->IsInstanceOf(MockFilterPolicy::kClassName()));
-#endif  // ROCKSDB_LITE
 }
 
 TEST_F(LoadCustomizableTest, LoadFlushBlockPolicyFactoryTest) {
@@ -2220,7 +2082,6 @@ TEST_F(LoadCustomizableTest, LoadFlushBlockPolicyFactoryTest) {
   ASSERT_NE(result, nullptr);
   ASSERT_STREQ(result->Name(), FlushBlockBySizePolicyFactory::kClassName());
 
-#ifndef ROCKSDB_LITE
   std::string table_opts = "id=BlockBasedTable; flush_block_policy_factory=";
   ASSERT_OK(TableFactory::CreateFromString(
       config_options_,
@@ -2242,7 +2103,6 @@ TEST_F(LoadCustomizableTest, LoadFlushBlockPolicyFactoryTest) {
     ASSERT_STREQ(bbto->flush_block_policy_factory->Name(),
                  TestFlushBlockPolicyFactory::kClassName());
   }
-#endif  // ROCKSDB_LITE
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/options/db_options.cc

@@ -12,6 +12,7 @@
 #include "options/options_helper.h"
 #include "options/options_parser.h"
 #include "port/port.h"
+#include "rocksdb/advanced_cache.h"
 #include "rocksdb/configurable.h"
 #include "rocksdb/env.h"
 #include "rocksdb/file_system.h"
@@ -25,7 +26,6 @@
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
-#ifndef ROCKSDB_LITE
 static std::unordered_map<std::string, WALRecoveryMode>
     wal_recovery_mode_string_map = {
         {"kTolerateCorruptedTailRecords",
@@ -670,7 +670,6 @@ std::unique_ptr<Configurable> DBOptionsAsConfigurable(
   std::unique_ptr<Configurable> ptr(new DBOptionsConfigurable(opts, opt_map));
   return ptr;
 }
-#endif  // ROCKSDB_LITE
 
 ImmutableDBOptions::ImmutableDBOptions() : ImmutableDBOptions(Options()) {}
 
@@ -734,9 +733,7 @@ ImmutableDBOptions::ImmutableDBOptions(const DBOptions& options)
       wal_recovery_mode(options.wal_recovery_mode),
       allow_2pc(options.allow_2pc),
       row_cache(options.row_cache),
-#ifndef ROCKSDB_LITE
       wal_filter(options.wal_filter),
-#endif  // ROCKSDB_LITE
       fail_if_options_file_error(options.fail_if_options_file_error),
       dump_malloc_stats(options.dump_malloc_stats),
       avoid_flush_during_recovery(options.avoid_flush_during_recovery),
@@ -888,10 +885,8 @@ void ImmutableDBOptions::Dump(Logger* log) const {
     ROCKS_LOG_HEADER(log,
                      "                              Options.row_cache: None");
   }
-#ifndef ROCKSDB_LITE
   ROCKS_LOG_HEADER(log, "                             Options.wal_filter: %s",
                    wal_filter ? wal_filter->Name() : "None");
-#endif  // ROCKDB_LITE
 
   ROCKS_LOG_HEADER(log, "            Options.avoid_flush_during_recovery: %d",
                    avoid_flush_during_recovery);
@@ -1051,7 +1046,6 @@ void MutableDBOptions::Dump(Logger* log) const {
                           max_background_flushes);
 }
 
-#ifndef ROCKSDB_LITE
 Status GetMutableDBOptionsFromStrings(
     const MutableDBOptions& base_options,
     const std::unordered_map<std::string, std::string>& options_map,
@@ -1082,5 +1076,4 @@ Status GetStringFromMutableDBOptions(const ConfigOptions& config_options,
   return OptionTypeInfo::SerializeType(
       config_options, db_mutable_options_type_info, &mutable_opts, opt_string);
 }
-#endif  // ROCKSDB_LITE
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/options/db_options.h

@@ -76,9 +76,7 @@ struct ImmutableDBOptions {
   WALRecoveryMode wal_recovery_mode;
   bool allow_2pc;
   std::shared_ptr<Cache> row_cache;
-#ifndef ROCKSDB_LITE
   WalFilter* wal_filter;
-#endif  // ROCKSDB_LITE
   bool fail_if_options_file_error;
   bool dump_malloc_stats;
   bool avoid_flush_during_recovery;
@@ -139,7 +137,6 @@ struct MutableDBOptions {
   int max_background_flushes;
 };
 
-#ifndef ROCKSDB_LITE
 Status GetStringFromMutableDBOptions(const ConfigOptions& config_options,
                                      const MutableDBOptions& mutable_opts,
                                      std::string* opt_string);
@@ -151,6 +148,5 @@ Status GetMutableDBOptionsFromStrings(
 
 bool MutableDBOptionsAreEqual(const MutableDBOptions& this_options,
                               const MutableDBOptions& that_options);
-#endif  // ROCKSDB_LITE
 
 }  // namespace ROCKSDB_NAMESPACE