@nxtedition/rocksdb 8.1.7 → 8.1.8

package/deps/rocksdb/rocksdb/monitoring/statistics.cc

@@ -28,13 +28,11 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {BLOCK_CACHE_INDEX_HIT, "rocksdb.block.cache.index.hit"},
     {BLOCK_CACHE_INDEX_ADD, "rocksdb.block.cache.index.add"},
     {BLOCK_CACHE_INDEX_BYTES_INSERT, "rocksdb.block.cache.index.bytes.insert"},
-    {BLOCK_CACHE_INDEX_BYTES_EVICT, "rocksdb.block.cache.index.bytes.evict"},
     {BLOCK_CACHE_FILTER_MISS, "rocksdb.block.cache.filter.miss"},
     {BLOCK_CACHE_FILTER_HIT, "rocksdb.block.cache.filter.hit"},
     {BLOCK_CACHE_FILTER_ADD, "rocksdb.block.cache.filter.add"},
     {BLOCK_CACHE_FILTER_BYTES_INSERT,
      "rocksdb.block.cache.filter.bytes.insert"},
-    {BLOCK_CACHE_FILTER_BYTES_EVICT, "rocksdb.block.cache.filter.bytes.evict"},
     {BLOCK_CACHE_DATA_MISS, "rocksdb.block.cache.data.miss"},
     {BLOCK_CACHE_DATA_HIT, "rocksdb.block.cache.data.hit"},
     {BLOCK_CACHE_DATA_ADD, "rocksdb.block.cache.data.add"},
@@ -45,7 +43,6 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {BLOOM_FILTER_FULL_POSITIVE, "rocksdb.bloom.filter.full.positive"},
     {BLOOM_FILTER_FULL_TRUE_POSITIVE,
      "rocksdb.bloom.filter.full.true.positive"},
-    {BLOOM_FILTER_MICROS, "rocksdb.bloom.filter.micros"},
     {PERSISTENT_CACHE_HIT, "rocksdb.persistent.cache.hit"},
     {PERSISTENT_CACHE_MISS, "rocksdb.persistent.cache.miss"},
     {SIM_BLOCK_CACHE_HIT, "rocksdb.sim.block.cache.hit"},
@@ -76,35 +73,22 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {NUMBER_DB_NEXT_FOUND, "rocksdb.number.db.next.found"},
     {NUMBER_DB_PREV_FOUND, "rocksdb.number.db.prev.found"},
     {ITER_BYTES_READ, "rocksdb.db.iter.bytes.read"},
-    {NO_FILE_CLOSES, "rocksdb.no.file.closes"},
     {NO_FILE_OPENS, "rocksdb.no.file.opens"},
     {NO_FILE_ERRORS, "rocksdb.no.file.errors"},
-    {STALL_L0_SLOWDOWN_MICROS, "rocksdb.l0.slowdown.micros"},
-    {STALL_MEMTABLE_COMPACTION_MICROS, "rocksdb.memtable.compaction.micros"},
-    {STALL_L0_NUM_FILES_MICROS, "rocksdb.l0.num.files.stall.micros"},
     {STALL_MICROS, "rocksdb.stall.micros"},
     {DB_MUTEX_WAIT_MICROS, "rocksdb.db.mutex.wait.micros"},
-    {RATE_LIMIT_DELAY_MILLIS, "rocksdb.rate.limit.delay.millis"},
-    {NO_ITERATORS, "rocksdb.num.iterators"},
     {NUMBER_MULTIGET_CALLS, "rocksdb.number.multiget.get"},
     {NUMBER_MULTIGET_KEYS_READ, "rocksdb.number.multiget.keys.read"},
     {NUMBER_MULTIGET_BYTES_READ, "rocksdb.number.multiget.bytes.read"},
-    {NUMBER_FILTERED_DELETES, "rocksdb.number.deletes.filtered"},
     {NUMBER_MERGE_FAILURES, "rocksdb.number.merge.failures"},
     {BLOOM_FILTER_PREFIX_CHECKED, "rocksdb.bloom.filter.prefix.checked"},
     {BLOOM_FILTER_PREFIX_USEFUL, "rocksdb.bloom.filter.prefix.useful"},
     {NUMBER_OF_RESEEKS_IN_ITERATION, "rocksdb.number.reseeks.iteration"},
     {GET_UPDATES_SINCE_CALLS, "rocksdb.getupdatessince.calls"},
-    {BLOCK_CACHE_COMPRESSED_MISS, "rocksdb.block.cachecompressed.miss"},
-    {BLOCK_CACHE_COMPRESSED_HIT, "rocksdb.block.cachecompressed.hit"},
-    {BLOCK_CACHE_COMPRESSED_ADD, "rocksdb.block.cachecompressed.add"},
-    {BLOCK_CACHE_COMPRESSED_ADD_FAILURES,
-     "rocksdb.block.cachecompressed.add.failures"},
     {WAL_FILE_SYNCED, "rocksdb.wal.synced"},
     {WAL_FILE_BYTES, "rocksdb.wal.bytes"},
     {WRITE_DONE_BY_SELF, "rocksdb.write.self"},
     {WRITE_DONE_BY_OTHER, "rocksdb.write.other"},
-    {WRITE_TIMEDOUT, "rocksdb.write.timeout"},
     {WRITE_WITH_WAL, "rocksdb.write.wal"},
     {COMPACT_READ_BYTES, "rocksdb.compact.read.bytes"},
     {COMPACT_WRITE_BYTES, "rocksdb.compact.write.bytes"},
@@ -158,11 +142,7 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {BLOB_DB_GC_NUM_FILES, "rocksdb.blobdb.gc.num.files"},
     {BLOB_DB_GC_NUM_NEW_FILES, "rocksdb.blobdb.gc.num.new.files"},
     {BLOB_DB_GC_FAILURES, "rocksdb.blobdb.gc.failures"},
-    {BLOB_DB_GC_NUM_KEYS_OVERWRITTEN, "rocksdb.blobdb.gc.num.keys.overwritten"},
-    {BLOB_DB_GC_NUM_KEYS_EXPIRED, "rocksdb.blobdb.gc.num.keys.expired"},
     {BLOB_DB_GC_NUM_KEYS_RELOCATED, "rocksdb.blobdb.gc.num.keys.relocated"},
-    {BLOB_DB_GC_BYTES_OVERWRITTEN, "rocksdb.blobdb.gc.bytes.overwritten"},
-    {BLOB_DB_GC_BYTES_EXPIRED, "rocksdb.blobdb.gc.bytes.expired"},
     {BLOB_DB_GC_BYTES_RELOCATED, "rocksdb.blobdb.gc.bytes.relocated"},
     {BLOB_DB_FIFO_NUM_FILES_EVICTED, "rocksdb.blobdb.fifo.num.files.evicted"},
     {BLOB_DB_FIFO_NUM_KEYS_EVICTED, "rocksdb.blobdb.fifo.num.keys.evicted"},
@@ -184,8 +164,6 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
      "rocksdb.block.cache.compression.dict.add"},
     {BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT,
      "rocksdb.block.cache.compression.dict.bytes.insert"},
-    {BLOCK_CACHE_COMPRESSION_DICT_BYTES_EVICT,
-     "rocksdb.block.cache.compression.dict.bytes.evict"},
     {BLOCK_CACHE_ADD_REDUNDANT, "rocksdb.block.cache.add.redundant"},
     {BLOCK_CACHE_INDEX_ADD_REDUNDANT,
      "rocksdb.block.cache.index.add.redundant"},
@@ -252,11 +230,6 @@ const std::vector<std::pair<Histograms, std::string>> HistogramsNameMap = {
     {READ_BLOCK_COMPACTION_MICROS, "rocksdb.read.block.compaction.micros"},
     {READ_BLOCK_GET_MICROS, "rocksdb.read.block.get.micros"},
     {WRITE_RAW_BLOCK_MICROS, "rocksdb.write.raw.block.micros"},
-    {STALL_L0_SLOWDOWN_COUNT, "rocksdb.l0.slowdown.count"},
-    {STALL_MEMTABLE_COMPACTION_COUNT, "rocksdb.memtable.compaction.count"},
-    {STALL_L0_NUM_FILES_COUNT, "rocksdb.num.files.stall.count"},
-    {HARD_RATE_LIMIT_DELAY_COUNT, "rocksdb.hard.rate.limit.delay.count"},
-    {SOFT_RATE_LIMIT_DELAY_COUNT, "rocksdb.soft.rate.limit.delay.count"},
     {NUM_FILES_IN_SINGLE_COMPACTION, "rocksdb.numfiles.in.singlecompaction"},
     {DB_SEEK, "rocksdb.db.seek.micros"},
     {WRITE_STALL, "rocksdb.db.write.stall"},
@@ -281,14 +254,12 @@ const std::vector<std::pair<Histograms, std::string>> HistogramsNameMap = {
     {BLOB_DB_BLOB_FILE_WRITE_MICROS, "rocksdb.blobdb.blob.file.write.micros"},
     {BLOB_DB_BLOB_FILE_READ_MICROS, "rocksdb.blobdb.blob.file.read.micros"},
     {BLOB_DB_BLOB_FILE_SYNC_MICROS, "rocksdb.blobdb.blob.file.sync.micros"},
-    {BLOB_DB_GC_MICROS, "rocksdb.blobdb.gc.micros"},
     {BLOB_DB_COMPRESSION_MICROS, "rocksdb.blobdb.compression.micros"},
     {BLOB_DB_DECOMPRESSION_MICROS, "rocksdb.blobdb.decompression.micros"},
     {FLUSH_TIME, "rocksdb.db.flush.micros"},
     {SST_BATCH_SIZE, "rocksdb.sst.batch.size"},
     {NUM_INDEX_AND_FILTER_BLOCKS_READ_PER_LEVEL,
      "rocksdb.num.index.and.filter.blocks.read.per.level"},
-    {NUM_DATA_BLOCKS_READ_PER_LEVEL, "rocksdb.num.data.blocks.read.per.level"},
     {NUM_SST_READ_PER_LEVEL, "rocksdb.num.sst.read.per.level"},
     {ERROR_HANDLER_AUTORESUME_RETRY_COUNT,
      "rocksdb.error.handler.autoresume.retry.count"},
@@ -304,7 +275,6 @@ std::shared_ptr<Statistics> CreateDBStatistics() {
   return std::make_shared<StatisticsImpl>(nullptr);
 }
 
-#ifndef ROCKSDB_LITE
 static int RegisterBuiltinStatistics(ObjectLibrary& library,
                                      const std::string& /*arg*/) {
   library.AddFactory<Statistics>(
@@ -316,34 +286,29 @@ static int RegisterBuiltinStatistics(ObjectLibrary& library,
       });
   return 1;
 }
-#endif  // ROCKSDB_LITE
 
 Status Statistics::CreateFromString(const ConfigOptions& config_options,
                                     const std::string& id,
                                     std::shared_ptr<Statistics>* result) {
-#ifndef ROCKSDB_LITE
   static std::once_flag once;
   std::call_once(once, [&]() {
     RegisterBuiltinStatistics(*(ObjectLibrary::Default().get()), "");
   });
-#endif  // ROCKSDB_LITE
   Status s;
   if (id == "" || id == StatisticsImpl::kClassName()) {
     result->reset(new StatisticsImpl(nullptr));
   } else if (id == kNullptrString) {
     result->reset();
   } else {
-    s = LoadSharedObject<Statistics>(config_options, id, nullptr, result);
+    s = LoadSharedObject<Statistics>(config_options, id, result);
   }
   return s;
 }
 
 static std::unordered_map<std::string, OptionTypeInfo> stats_type_info = {
-#ifndef ROCKSDB_LITE
     {"inner", OptionTypeInfo::AsCustomSharedPtr<Statistics>(
                   0, OptionVerificationType::kByNameAllowFromNull,
                   OptionTypeFlags::kCompareNever)},
-#endif  // !ROCKSDB_LITE
 };
 
 StatisticsImpl::StatisticsImpl(std::shared_ptr<Statistics> stats)

package/deps/rocksdb/rocksdb/monitoring/statistics_test.cc

@@ -42,12 +42,10 @@ TEST_F(StatisticsTest, SanityHistograms) {
 
 TEST_F(StatisticsTest, NoNameStats) {
   static std::unordered_map<std::string, OptionTypeInfo> no_name_opt_info = {
-#ifndef ROCKSDB_LITE
       {"inner",
        OptionTypeInfo::AsCustomSharedPtr<Statistics>(
            0, OptionVerificationType::kByName,
            OptionTypeFlags::kAllowNull | OptionTypeFlags::kCompareNever)},
-#endif  // ROCKSDB_LITE
   };
 
   class DefaultNameStatistics : public Statistics {
@@ -73,7 +71,6 @@ TEST_F(StatisticsTest, NoNameStats) {
   options.ignore_unsupported_options = false;
   auto stats = std::make_shared<DefaultNameStatistics>();
   ASSERT_STREQ(stats->Name(), "");
-#ifndef ROCKSDB_LITE
   ASSERT_EQ("", stats->ToString(
                     options));  // A stats with no name with have no options...
   ASSERT_OK(stats->ConfigureFromString(options, "inner="));
@@ -81,7 +78,6 @@ TEST_F(StatisticsTest, NoNameStats) {
                     options));  // A stats with no name with have no options...
   ASSERT_NE(stats->inner, nullptr);
   ASSERT_NE("", stats->inner->ToString(options));  // ... even if it does...
-#endif                                             // ROCKSDB_LITE
 }
 }  // namespace ROCKSDB_NAMESPACE
 

package/deps/rocksdb/rocksdb/monitoring/stats_history_test.cc

@@ -29,7 +29,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-#ifndef ROCKSDB_LITE
 class StatsHistoryTest : public DBTestBase {
  public:
   StatsHistoryTest() : DBTestBase("stats_history_test", /*env_do_fsync=*/true) {
@@ -654,7 +653,6 @@ TEST_F(StatsHistoryTest, ForceManualFlushStatsCF) {
   Close();
 }
 
-#endif  // !ROCKSDB_LITE
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/options/cf_options.cc

@@ -16,6 +16,7 @@
 #include "options/options_helper.h"
 #include "options/options_parser.h"
 #include "port/port.h"
+#include "rocksdb/advanced_cache.h"
 #include "rocksdb/compaction_filter.h"
 #include "rocksdb/concurrent_task_limiter.h"
 #include "rocksdb/configurable.h"
@@ -36,7 +37,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-#ifndef ROCKSDB_LITE
 static Status ParseCompressionOptions(const std::string& value,
                                       const std::string& name,
                                       CompressionOptions& compression_opts) {
@@ -879,7 +879,6 @@ std::unique_ptr<Configurable> CFOptionsAsConfigurable(
   std::unique_ptr<Configurable> ptr(new ConfigurableCFOptions(opts, opt_map));
   return ptr;
 }
-#endif  // ROCKSDB_LITE
 
 ImmutableCFOptions::ImmutableCFOptions() : ImmutableCFOptions(Options()) {}
 
@@ -1138,7 +1137,6 @@ void MutableCFOptions::Dump(Logger* log) const {
 MutableCFOptions::MutableCFOptions(const Options& options)
     : MutableCFOptions(ColumnFamilyOptions(options)) {}
 
-#ifndef ROCKSDB_LITE
 Status GetMutableOptionsFromStrings(
     const MutableCFOptions& base_options,
     const std::unordered_map<std::string, std::string>& options_map,
@@ -1162,5 +1160,4 @@ Status GetStringFromMutableCFOptions(const ConfigOptions& config_options,
   return OptionTypeInfo::SerializeType(
       config_options, cf_mutable_options_type_info, &mutable_opts, opt_string);
 }
-#endif  // ROCKSDB_LITE
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/options/cf_options.h

@@ -330,7 +330,6 @@ uint64_t MaxFileSizeForLevel(const MutableCFOptions& cf_options,
 // `pin_l0_filter_and_index_blocks_in_cache` is set.
 size_t MaxFileSizeForL0MetaPin(const MutableCFOptions& cf_options);
 
-#ifndef ROCKSDB_LITE
 Status GetStringFromMutableCFOptions(const ConfigOptions& config_options,
                                      const MutableCFOptions& mutable_opts,
                                      std::string* opt_string);
@@ -339,6 +338,5 @@ Status GetMutableOptionsFromStrings(
     const MutableCFOptions& base_options,
     const std::unordered_map<std::string, std::string>& options_map,
     Logger* info_log, MutableCFOptions* new_options);
-#endif  // ROCKSDB_LITE
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/options/configurable.cc

@@ -22,11 +22,7 @@ void Configurable::RegisterOptions(
     const std::unordered_map<std::string, OptionTypeInfo>* type_map) {
   RegisteredOptions opts;
   opts.name = name;
-#ifndef ROCKSDB_LITE
   opts.type_map = type_map;
-#else
-  (void)type_map;
-#endif  // ROCKSDB_LITE
   opts.opt_ptr = opt_ptr;
   options_.emplace_back(opts);
 }
@@ -41,7 +37,6 @@ Status Configurable::PrepareOptions(const ConfigOptions& opts) {
   // We ignore the invoke_prepare_options here intentionally,
   // as if you are here, you must have called PrepareOptions explicitly.
   Status status = Status::OK();
-#ifndef ROCKSDB_LITE
   for (auto opt_iter : options_) {
     if (opt_iter.type_map != nullptr) {
       for (auto map_iter : *(opt_iter.type_map)) {
@@ -55,16 +50,12 @@ Status Configurable::PrepareOptions(const ConfigOptions& opts) {
       }
     }
   }
-#else
-  (void)opts;
-#endif  // ROCKSDB_LITE
   return status;
 }
 
 Status Configurable::ValidateOptions(const DBOptions& db_opts,
                                      const ColumnFamilyOptions& cf_opts) const {
   Status status;
-#ifndef ROCKSDB_LITE
   for (auto opt_iter : options_) {
     if (opt_iter.type_map != nullptr) {
       for (auto map_iter : *(opt_iter.type_map)) {
@@ -79,10 +70,6 @@ Status Configurable::ValidateOptions(const DBOptions& db_opts,
       }
     }
   }
-#else
-  (void)db_opts;
-  (void)cf_opts;
-#endif  // ROCKSDB_LITE
   return status;
 }
 
@@ -105,7 +92,6 @@ std::string Configurable::GetOptionName(const std::string& opt_name) const {
   return opt_name;
 }
 
-#ifndef ROCKSDB_LITE
 const OptionTypeInfo* ConfigurableHelper::FindOption(
     const std::vector<Configurable::RegisteredOptions>& options,
     const std::string& short_name, std::string* opt_name, void** opt_ptr) {
@@ -121,7 +107,6 @@ const OptionTypeInfo* ConfigurableHelper::FindOption(
   }
   return nullptr;
 }
-#endif  // ROCKSDB_LITE
 
 //*************************************************************************
 //
@@ -156,7 +141,6 @@ Status Configurable::ConfigureOptions(
     // the configuration is complete.
     ConfigOptions copy = config_options;
     copy.invoke_prepare_options = false;
-#ifndef ROCKSDB_LITE
     if (!config_options.ignore_unknown_options) {
       // If we are not ignoring unused, get the defaults in case we need to
       // reset
@@ -164,14 +148,12 @@ Status Configurable::ConfigureOptions(
       copy.delimiter = "; ";
       GetOptionString(copy, &curr_opts).PermitUncheckedError();
     }
-#endif  // ROCKSDB_LITE
 
     s = ConfigurableHelper::ConfigureOptions(copy, *this, opts_map, unused);
   }
   if (config_options.invoke_prepare_options && s.ok()) {
     s = PrepareOptions(config_options);
   }
-#ifndef ROCKSDB_LITE
   if (!s.ok() && !curr_opts.empty()) {
     ConfigOptions reset = config_options;
     reset.ignore_unknown_options = true;
@@ -180,7 +162,6 @@ Status Configurable::ConfigureOptions(
     // There are some options to reset from this current error
     ConfigureFromString(reset, curr_opts).PermitUncheckedError();
   }
-#endif  // ROCKSDB_LITE
   return s;
 }
 
@@ -193,7 +174,6 @@ Status Configurable::ConfigureFromString(const ConfigOptions& config_options,
                                          const std::string& opts_str) {
   Status s;
   if (!opts_str.empty()) {
-#ifndef ROCKSDB_LITE
     if (opts_str.find(';') != std::string::npos ||
         opts_str.find('=') != std::string::npos) {
       std::unordered_map<std::string, std::string> opt_map;
@@ -202,14 +182,11 @@ Status Configurable::ConfigureFromString(const ConfigOptions& config_options,
         s = ConfigureFromMap(config_options, opt_map, nullptr);
       }
     } else {
-#endif  // ROCKSDB_LITE
       s = ParseStringOptions(config_options, opts_str);
       if (s.ok() && config_options.invoke_prepare_options) {
         s = PrepareOptions(config_options);
       }
-#ifndef ROCKSDB_LITE
     }
-#endif  // ROCKSDB_LITE
   } else if (config_options.invoke_prepare_options) {
     s = PrepareOptions(config_options);
   } else {
@@ -218,7 +195,6 @@ Status Configurable::ConfigureFromString(const ConfigOptions& config_options,
   return s;
 }
 
-#ifndef ROCKSDB_LITE
 /**
  * Sets the value of the named property to the input value, returning OK on
  * succcess.
@@ -257,7 +233,6 @@ Status Configurable::ParseOption(const ConfigOptions& config_options,
   }
 }
 
-#endif  // ROCKSDB_LITE
 
 Status ConfigurableHelper::ConfigureOptions(
     const ConfigOptions& config_options, Configurable& configurable,
@@ -266,7 +241,6 @@ Status ConfigurableHelper::ConfigureOptions(
   std::unordered_map<std::string, std::string> remaining = opts_map;
   Status s = Status::OK();
   if (!opts_map.empty()) {
-#ifndef ROCKSDB_LITE
     for (const auto& iter : configurable.options_) {
       if (iter.type_map != nullptr) {
         s = ConfigureSomeOptions(config_options, configurable, *(iter.type_map),
@@ -278,12 +252,6 @@ Status ConfigurableHelper::ConfigureOptions(
         }
       }
     }
-#else
-    (void)configurable;
-    if (!config_options.ignore_unknown_options) {
-      s = Status::NotSupported("ConfigureFromMap not supported in LITE mode");
-    }
-#endif  // ROCKSDB_LITE
   }
   if (unused != nullptr && !remaining.empty()) {
     unused->insert(remaining.begin(), remaining.end());
@@ -296,7 +264,6 @@ Status ConfigurableHelper::ConfigureOptions(
   return s;
 }
 
-#ifndef ROCKSDB_LITE
 /**
  * Updates the object with the named-value property values, returning OK on
  * succcess. Any properties that were found are removed from the options list;
@@ -480,7 +447,6 @@ Status ConfigurableHelper::ConfigureOption(
     return Status::NotFound("Could not find option: ", name);
   }
 }
-#endif  // ROCKSDB_LITE
 
 //*******************************************************************************
 //
@@ -492,16 +458,10 @@ Status Configurable::GetOptionString(const ConfigOptions& config_options,
                                      std::string* result) const {
   assert(result);
   result->clear();
-#ifndef ROCKSDB_LITE
   return ConfigurableHelper::SerializeOptions(config_options, *this, "",
                                               result);
-#else
-  (void)config_options;
-  return Status::NotSupported("GetOptionString not supported in LITE mode");
-#endif  // ROCKSDB_LITE
 }
 
-#ifndef ROCKSDB_LITE
 std::string Configurable::ToString(const ConfigOptions& config_options,
                                    const std::string& prefix) const {
   std::string result = SerializeOptions(config_options, prefix);
@@ -601,14 +561,12 @@ Status ConfigurableHelper::SerializeOptions(const ConfigOptions& config_options,
   }
   return Status::OK();
 }
-#endif  // ROCKSDB_LITE
 
 //********************************************************************************
 //
 // Methods for listing the options from Configurables
 //
 //********************************************************************************
-#ifndef ROCKSDB_LITE
 Status Configurable::GetOptionNames(
     const ConfigOptions& config_options,
     std::unordered_set<std::string>* result) const {
@@ -639,7 +597,6 @@ Status ConfigurableHelper::ListOptions(
   }
   return status;
 }
-#endif  // ROCKSDB_LITE
 
 //*******************************************************************************
 //
@@ -655,18 +612,13 @@ bool Configurable::AreEquivalent(const ConfigOptions& config_options,
   if (this == other || config_options.IsCheckDisabled()) {
     return true;
   } else if (other != nullptr) {
-#ifndef ROCKSDB_LITE
     return ConfigurableHelper::AreEquivalent(config_options, *this, *other,
                                              name);
-#else
-    return true;
-#endif  // ROCKSDB_LITE
   } else {
     return false;
   }
 }
 
-#ifndef ROCKSDB_LITE
 bool Configurable::OptionsAreEqual(const ConfigOptions& config_options,
                                    const OptionTypeInfo& opt_info,
                                    const std::string& opt_name,
@@ -722,7 +674,6 @@ bool ConfigurableHelper::AreEquivalent(const ConfigOptions& config_options,
   }
   return true;
 }
-#endif  // ROCKSDB_LITE
 
 Status Configurable::GetOptionsMap(
     const std::string& value, const std::string& default_id, std::string* id,
@@ -734,7 +685,6 @@ Status Configurable::GetOptionsMap(
     *id = default_id;
   } else if (value.find('=') == std::string::npos) {
     *id = value;
-#ifndef ROCKSDB_LITE
   } else {
     status = StringToMap(value, props);
     if (!status.ok()) {       // There was an error creating the map.
@@ -756,11 +706,6 @@ Status Configurable::GetOptionsMap(
         props->clear();  // Clear the properties
       }
     }
-#else
-  } else {
-    *id = value;
-    props->clear();
-#endif
   }
   return status;
 }

package/deps/rocksdb/rocksdb/options/configurable_helper.h

@@ -46,7 +46,6 @@ class ConfigurableHelper {
       const std::unordered_map<std::string, std::string>& options,
       std::unordered_map<std::string, std::string>* unused);
 
-#ifndef ROCKSDB_LITE
   // Internal method to configure a set of options for this object.
   // Classes may override this value to change its behavior.
   // @param config_options Controls how the options are being configured
@@ -181,7 +180,6 @@ class ConfigurableHelper {
       const ConfigOptions& config_options, Configurable& configurable,
       const OptionTypeInfo& opt_info, const std::string& opt_name,
       const std::string& name, const std::string& value, void* opt_ptr);
-#endif  // ROCKSDB_LITE
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/options/configurable_test.cc

@@ -46,20 +46,16 @@ class StringLogger : public Logger {
   std::string string_;
 };
 static std::unordered_map<std::string, OptionTypeInfo> struct_option_info = {
-#ifndef ROCKSDB_LITE
     {"struct", OptionTypeInfo::Struct("struct", &simple_option_info, 0,
                                       OptionVerificationType::kNormal,
                                       OptionTypeFlags::kMutable)},
-#endif  // ROCKSDB_LITE
 };
 
 static std::unordered_map<std::string, OptionTypeInfo> imm_struct_option_info =
     {
-#ifndef ROCKSDB_LITE
         {"struct", OptionTypeInfo::Struct("struct", &simple_option_info, 0,
                                           OptionVerificationType::kNormal,
                                           OptionTypeFlags::kNone)},
-#endif  // ROCKSDB_LITE
 };
 
 class SimpleConfigurable : public TestConfigurable<Configurable> {
@@ -113,14 +109,12 @@ TEST_F(ConfigurableTest, ConfigureFromMapTest) {
   auto* opts = configurable->GetOptions<TestOptions>("simple");
   ASSERT_OK(configurable->ConfigureFromMap(config_options_, {}));
   ASSERT_NE(opts, nullptr);
-#ifndef ROCKSDB_LITE
   std::unordered_map<std::string, std::string> options_map = {
       {"int", "1"}, {"bool", "true"}, {"string", "string"}};
   ASSERT_OK(configurable->ConfigureFromMap(config_options_, options_map));
   ASSERT_EQ(opts->i, 1);
   ASSERT_EQ(opts->b, true);
   ASSERT_EQ(opts->s, "string");
-#endif
 }
 
 TEST_F(ConfigurableTest, ConfigureFromStringTest) {
@@ -128,16 +122,13 @@ TEST_F(ConfigurableTest, ConfigureFromStringTest) {
   auto* opts = configurable->GetOptions<TestOptions>("simple");
   ASSERT_OK(configurable->ConfigureFromString(config_options_, ""));
   ASSERT_NE(opts, nullptr);
-#ifndef ROCKSDB_LITE  // GetOptionsFromMap is not supported in ROCKSDB_LITE
   ASSERT_OK(configurable->ConfigureFromString(config_options_,
                                               "int=1;bool=true;string=s"));
   ASSERT_EQ(opts->i, 1);
   ASSERT_EQ(opts->b, true);
   ASSERT_EQ(opts->s, "s");
-#endif
 }
 
-#ifndef ROCKSDB_LITE  // GetOptionsFromMap is not supported in ROCKSDB_LITE
 TEST_F(ConfigurableTest, ConfigureIgnoreTest) {
   std::unique_ptr<Configurable> configurable(SimpleConfigurable::Create());
   std::unordered_map<std::string, std::string> options_map = {{"unused", "u"}};
@@ -217,27 +208,21 @@ TEST_F(ConfigurableTest, InvalidOptionTest) {
 }
 
 static std::unordered_map<std::string, OptionTypeInfo> validated_option_info = {
-#ifndef ROCKSDB_LITE
     {"validated",
      {0, OptionType::kBoolean, OptionVerificationType::kNormal,
       OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };
 static std::unordered_map<std::string, OptionTypeInfo> prepared_option_info = {
-#ifndef ROCKSDB_LITE
     {"prepared",
      {0, OptionType::kInt, OptionVerificationType::kNormal,
       OptionTypeFlags::kMutable}},
-#endif  // ROCKSDB_LITE
 };
 static std::unordered_map<std::string, OptionTypeInfo>
     dont_prepare_option_info = {
-#ifndef ROCKSDB_LITE
         {"unique",
          {0, OptionType::kConfigurable, OptionVerificationType::kNormal,
           (OptionTypeFlags::kUnique | OptionTypeFlags::kDontPrepare)}},
 
-#endif  // ROCKSDB_LITE
 };
 
 class ValidatedConfigurable : public SimpleConfigurable {
@@ -367,11 +352,9 @@ TEST_F(ConfigurableTest, CopyObjectTest) {
 
 TEST_F(ConfigurableTest, MutableOptionsTest) {
   static std::unordered_map<std::string, OptionTypeInfo> imm_option_info = {
-#ifndef ROCKSDB_LITE
       {"imm", OptionTypeInfo::Struct("imm", &simple_option_info, 0,
                                      OptionVerificationType::kNormal,
                                      OptionTypeFlags::kNone)},
-#endif  // ROCKSDB_LITE
   };
 
   class MutableConfigurable : public SimpleConfigurable {
@@ -610,7 +593,6 @@ TEST_F(ConfigurableTest, ConfigurableEnumTest) {
   ASSERT_NOK(base->ConfigureOption(config_options_, "unknown", "bad"));
 }
 
-#ifndef ROCKSDB_LITE
 static std::unordered_map<std::string, OptionTypeInfo> noserialize_option_info =
     {
         {"int",
@@ -680,7 +662,6 @@ TEST_F(ConfigurableTest, NullOptionMapTest) {
   ASSERT_OK(copy->ConfigureFromString(config_options_, str));
   ASSERT_TRUE(base->AreEquivalent(config_options_, copy.get(), &str));
 }
-#endif
 
 static std::unordered_map<std::string, ConfigTestFactoryFunc> TestFactories = {
     {"Simple", []() { return SimpleConfigurable::Create("simple"); }},
@@ -867,7 +848,6 @@ INSTANTIATE_TEST_CASE_P(
         std::pair<std::string, std::string>("BlockBased",
                                             "block_size=1024;"
                                             "no_block_cache=true;")));
-#endif  // ROCKSDB_LITE
 
 }  // namespace test
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/options/configurable_test.h

@@ -38,7 +38,6 @@ struct TestOptions {
 };
 
 static std::unordered_map<std::string, OptionTypeInfo> simple_option_info = {
-#ifndef ROCKSDB_LITE
     {"int",
      {offsetof(struct TestOptions, i), OptionType::kInt,
       OptionVerificationType::kNormal, OptionTypeFlags::kMutable}},
@@ -48,37 +47,28 @@ static std::unordered_map<std::string, OptionTypeInfo> simple_option_info = {
     {"string",
      {offsetof(struct TestOptions, s), OptionType::kString,
       OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };
 
 static std::unordered_map<std::string, OptionTypeInfo> enum_option_info = {
-#ifndef ROCKSDB_LITE
     {"enum",
      OptionTypeInfo::Enum(offsetof(struct TestOptions, e), &test_enum_map)}
-#endif
 };
 
 static std::unordered_map<std::string, OptionTypeInfo> unique_option_info = {
-#ifndef ROCKSDB_LITE
     {"unique",
      {0, OptionType::kConfigurable, OptionVerificationType::kNormal,
       (OptionTypeFlags::kUnique | OptionTypeFlags::kMutable)}},
-#endif  // ROCKSDB_LITE
 };
 
 static std::unordered_map<std::string, OptionTypeInfo> shared_option_info = {
-#ifndef ROCKSDB_LITE
     {"shared",
      {0, OptionType::kConfigurable, OptionVerificationType::kNormal,
       (OptionTypeFlags::kShared)}},
-#endif  // ROCKSDB_LITE
 };
 static std::unordered_map<std::string, OptionTypeInfo> pointer_option_info = {
-#ifndef ROCKSDB_LITE
     {"pointer",
      {0, OptionType::kConfigurable, OptionVerificationType::kNormal,
       OptionTypeFlags::kRawPointer}},
-#endif  // ROCKSDB_LITE
 };
 
 enum TestConfigMode {