@nxtedition/rocksdb 13.1.4 → 13.2.0

package/deps/rocksdb/rocksdb/memtable/wbwi_memtable.h

@@ -0,0 +1,400 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  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).
+
+#pragma once
+#include "db/memtable.h"
+#include "rocksdb/utilities/write_batch_with_index.h"
+
+namespace ROCKSDB_NAMESPACE {
+// An implementation of the ReadOnlyMemTable interface based on the content
+// of the given write batch with index (WBWI) object. This can be used to ingest
+// a transaction (which is based on WBWI) into the DB as an immutable memtable.
+//
+// REQUIRE overwrite_key to be true for the WBWI
+// Since the keys in WBWI do not have sequence number, the memtable needs to be
+// assigned a range of sequence numbers through AssignSequenceNumbers(seqno)
+// before being available for reads.
+// With overwrite_key = true, WBWI keeps track of the most recent update for
+// each key, and each such key will be assigned seqno.upper_bound during reads.
+// One exception is during flush, consider the following scenario:
+// - WBWI has SD(k) then PUT(k, v1)
+// - DB has PUT(k, v2) in L1
+// - flush WBWI adds PUT(k, v1) into L0
+// - live memtable contains SD(k)
+// - flush live memtable and compact it with L0 will drop SD(k) and PUT(k, v1)
+// - the PUT(k, v2) in L1 incorrectly becomes visible
+// So during flush, iterator from this memtable will need emit overwritten
+// single deletion. These single deletion entries will be
+// assigned seqno.upper_bound - 1.
+class WBWIMemTable final : public ReadOnlyMemTable {
+ public:
+  struct SeqnoRange {
+    SequenceNumber lower_bound = kMaxSequenceNumber;
+    SequenceNumber upper_bound = kMaxSequenceNumber;
+  };
+  WBWIMemTable(const std::shared_ptr<WriteBatchWithIndex>& wbwi,
+               const Comparator* cmp, uint32_t cf_id,
+               const ImmutableOptions* immutable_options,
+               const MutableCFOptions* cf_options,
+               const WriteBatchWithIndex::CFStat& stat)
+      : wbwi_(wbwi),
+        comparator_(cmp),
+        ikey_comparator_(comparator_),
+        moptions_(*immutable_options, *cf_options),
+        clock_(immutable_options->clock),
+        // We need to include overwritten_sd_count in num_entries_ since flush
+        // verifies number of entries processed and that iterator for this
+        // memtable will emit overwritten SingleDelete entries during flush, See
+        // comment above WBWIMemTableIterator for more detail.
+        num_entries_(stat.entry_count + stat.overwritten_sd_count),
+        cf_id_(cf_id) {
+    assert(wbwi->GetOverwriteKey());
+  }
+
+  // No copying allowed
+  WBWIMemTable(const WBWIMemTable&) = delete;
+  WBWIMemTable& operator=(const WBWIMemTable&) = delete;
+
+  ~WBWIMemTable() override { assert(refs_ == 0); }
+
+  const char* Name() const override { return "WBWIMemTable"; }
+
+  size_t ApproximateMemoryUsage() override {
+    // FIXME: we can calculate for each CF or just divide evenly among CFs
+    // Used in ReportFlushInputSize(), MemPurgeDecider, flush job event logging,
+    // and InternalStats::HandleCurSizeAllMemTables
+    return 0;
+  }
+
+  size_t MemoryAllocatedBytes() const override {
+    // FIXME: similar to ApproximateMemoryUsage().
+    //   Used in MemTableList to trim memtable history.
+    return 0;
+  }
+
+  void UniqueRandomSample(
+      const uint64_t& /* target_sample_size */,
+      std::unordered_set<const char*>* /* entries */) override {
+    // TODO: support mempurge
+    assert(false);
+  }
+
+  InternalIterator* NewIterator(const ReadOptions&,
+                                UnownedPtr<const SeqnoToTimeMapping>,
+                                Arena* arena,
+                                const SliceTransform* /* prefix_extractor */,
+                                bool for_flush) override;
+
+  // Returns an iterator that wraps a MemTableIterator and logically strips the
+  // user-defined timestamp of each key. This API is only used by flush when
+  // user-defined timestamps in MemTable only feature is enabled.
+  InternalIterator* NewTimestampStrippingIterator(
+      const ReadOptions&, UnownedPtr<const SeqnoToTimeMapping>, Arena* arena,
+      const SliceTransform*, size_t) override {
+    // TODO: support UDT
+    assert(false);
+    return NewErrorInternalIterator(
+        Status::NotSupported(
+            "WBWIMemTable does not support NewTimestampStrippingIterator."),
+        arena);
+  }
+
+  FragmentedRangeTombstoneIterator* NewRangeTombstoneIterator(
+      const ReadOptions&, SequenceNumber, bool) override {
+    // TODO: support DeleteRange
+    assert(!wbwi_->GetWriteBatch()->HasDeleteRange());
+    return nullptr;
+  }
+
+  FragmentedRangeTombstoneIterator* NewTimestampStrippingRangeTombstoneIterator(
+      const ReadOptions&, SequenceNumber, size_t) override {
+    // TODO: support UDT
+    assert(false);
+    return nullptr;
+  }
+
+  // FIXME: not a good practice to use default parameter with virtual function
+  using ReadOnlyMemTable::Get;
+  bool Get(const LookupKey& key, std::string* value,
+           PinnableWideColumns* columns, std::string* timestamp, Status* s,
+           MergeContext* merge_context,
+           SequenceNumber* max_covering_tombstone_seq, SequenceNumber* seq,
+           const ReadOptions& read_opts, bool immutable_memtable,
+           ReadCallback* callback = nullptr, bool* is_blob_index = nullptr,
+           bool do_merge = true) override;
+
+  void MultiGet(const ReadOptions& read_options, MultiGetRange* range,
+                ReadCallback* callback, bool immutable_memtable) override;
+
+  uint64_t NumEntries() const override { return num_entries_; }
+
+  uint64_t NumDeletion() const override {
+    // FIXME: this is used for stats and event logging
+    return 0;
+  }
+
+  uint64_t NumRangeDeletion() const override {
+    // FIXME
+    assert(!wbwi_->GetWriteBatch()->HasDeleteRange());
+    return 0;
+  }
+
+  uint64_t GetDataSize() const override {
+    // FIXME: used in event logging in flush_job
+    return 0;
+  }
+
+  SequenceNumber GetEarliestSequenceNumber() override {
+    return assigned_seqno_.lower_bound;
+  }
+
+  bool IsEmpty() const override {
+    // Ideally also check that wbwi contains updates from this CF. For now, we
+    // only create WBWIMemTable for CFs with updates in wbwi.
+    return wbwi_->GetWriteBatch()->Count() == 0;
+  }
+
+  SequenceNumber GetFirstSequenceNumber() override {
+    return assigned_seqno_.lower_bound;
+  }
+
+  uint64_t GetMinLogContainingPrepSection() override {
+    // FIXME: used to retain WAL with pending Prepare
+    return min_prep_log_referenced_;
+  }
+
+  void MarkImmutable() override {}
+
+  void MarkFlushed() override {}
+
+  MemTableStats ApproximateStats(const Slice&, const Slice&) override {
+    // FIXME: used for query planning
+    return {};
+  }
+
+  const InternalKeyComparator& GetInternalKeyComparator() const override {
+    return ikey_comparator_;
+  }
+
+  uint64_t ApproximateOldestKeyTime() const override {
+    // FIXME: can use the time when this is added to the DB.
+    return kUnknownOldestAncesterTime;
+  }
+
+  bool IsFragmentedRangeTombstonesConstructed() const override {
+    assert(!wbwi_->GetWriteBatch()->HasDeleteRange());
+    return true;
+  }
+
+  const Slice& GetNewestUDT() const override {
+    // FIXME: support UDT
+    assert(false);
+    return newest_udt_;
+  }
+
+  // Assign a sequence number to the entries in this memtable.
+  void AssignSequenceNumbers(const SeqnoRange& seqno_range) {
+    // Not expecting to assign seqno multiple times.
+    assert(assigned_seqno_.lower_bound == kMaxSequenceNumber);
+    assert(assigned_seqno_.upper_bound == kMaxSequenceNumber);
+
+    assigned_seqno_ = seqno_range;
+
+    assert(assigned_seqno_.lower_bound <= assigned_seqno_.upper_bound);
+    assert(assigned_seqno_.upper_bound != kMaxSequenceNumber);
+  }
+
+  void SetMinPrepLog(uint64_t min_prep_log) {
+    min_prep_log_referenced_ = min_prep_log;
+  }
+
+ private:
+  inline InternalIterator* NewIterator() const;
+
+  Slice newest_udt_;
+  std::shared_ptr<WriteBatchWithIndex> wbwi_;
+  const Comparator* comparator_;
+  InternalKeyComparator ikey_comparator_;
+  SeqnoRange assigned_seqno_;
+  const ImmutableMemTableOptions moptions_;
+  SystemClock* clock_;
+  uint64_t min_prep_log_referenced_{0};
+  uint64_t num_entries_;
+  // WBWI can contains updates to multiple CFs. `cf_id_` determines which CF
+  // this memtable is for.
+  uint32_t cf_id_;
+};
+
+class WBWIMemTableIterator final : public InternalIterator {
+ public:
+  WBWIMemTableIterator(std::unique_ptr<WBWIIterator>&& it,
+                       const WBWIMemTable::SeqnoRange& assigned_seqno,
+                       const Comparator* comparator, bool for_flush)
+      : it_(std::move(it)),
+        assigned_seqno_(assigned_seqno),
+        comparator_(comparator),
+        emit_overwritten_single_del_(for_flush) {
+    assert(assigned_seqno_.lower_bound <= assigned_seqno_.upper_bound);
+    assert(assigned_seqno_.upper_bound < kMaxSequenceNumber);
+    s_.PermitUncheckedError();
+  }
+
+  // No copying allowed
+  WBWIMemTableIterator(const WBWIMemTableIterator&) = delete;
+  WBWIMemTableIterator& operator=(const WBWIMemTableIterator&) = delete;
+
+  bool Valid() const override { return valid_; }
+
+  void SeekToFirst() override {
+    it_->SeekToFirst();
+    UpdateKey();
+  }
+
+  void SeekToLast() override {
+    it_->SeekToLast();
+    UpdateKey();
+  }
+
+  void Seek(const Slice& target) override {
+    Slice target_user_key = ExtractUserKey(target);
+    it_->Seek(target_user_key);
+    if (it_->Valid()) {
+      // compare seqno
+      SequenceNumber seqno = GetInternalKeySeqno(target);
+      assert(!emit_overwritten_single_del_);
+      // For now all keys are assigned seqno_ub_, this may change after merge
+      // is supported.
+      assert(seqno <= assigned_seqno_.lower_bound ||
+             seqno >= assigned_seqno_.upper_bound);
+      if (seqno < assigned_seqno_.upper_bound &&
+          comparator_->Compare(it_->Entry().key, target_user_key) == 0) {
+        it_->Next();
+        // TODO: cannot assume distinct keys once Merge is supported
+        if (it_->Valid()) {
+          assert(comparator_->Compare(it_->Entry().key, target_user_key) > 0);
+        }
+      }
+    }
+    UpdateKey();
+  }
+
+  void SeekForPrev(const Slice& target) override {
+    Slice target_user_key = ExtractUserKey(target);
+    it_->SeekForPrev(target_user_key);
+    if (it_->Valid()) {
+      SequenceNumber seqno = GetInternalKeySeqno(target);
+      assert(seqno <= assigned_seqno_.lower_bound ||
+             seqno >= assigned_seqno_.upper_bound);
+      if (seqno > assigned_seqno_.upper_bound &&
+          comparator_->Compare(it_->Entry().key, target_user_key) == 0) {
+        it_->Prev();
+        if (it_->Valid()) {
+          // TODO: cannot assume distinct keys once Merge is supported
+          assert(comparator_->Compare(it_->Entry().key, target_user_key) < 0);
+        }
+      }
+    }
+    UpdateKey();
+  }
+
+  void Next() override {
+    // Only need to emit single deletion during flush. Since Flush does
+    // sequential forward scan, we only need to emit single deletion in Next(),
+    // and do not need to consider iterator direction change.
+    assert(Valid());
+    if (emit_overwritten_single_del_) {
+      if (it_->HasOverWrittenSingleDel() && !at_overwritten_single_del_) {
+        UpdateSingleDeleteKey();
+        return;
+      }
+      at_overwritten_single_del_ = false;
+    }
+
+    it_->Next();
+    UpdateKey();
+  }
+
+  bool NextAndGetResult(IterateResult* result) override {
+    assert(Valid());
+    Next();
+    bool is_valid = Valid();
+    if (is_valid) {
+      result->key = key();
+      result->bound_check_result = IterBoundCheck::kUnknown;
+      result->value_prepared = true;
+    }
+    return is_valid;
+  }
+
+  void Prev() override {
+    assert(Valid());
+    it_->Prev();
+    UpdateKey();
+  }
+
+  Slice key() const override {
+    assert(Valid());
+    return key_;
+  }
+
+  Slice value() const override {
+    assert(Valid());
+    // TODO: it_->Entry() is not trivial, cache it
+    return it_->Entry().value;
+  }
+
+  Status status() const override {
+    assert(it_->status().ok());
+    return s_;
+  }
+
+  bool IsValuePinned() const override { return true; }
+
+ private:
+  static const std::unordered_map<WriteType, ValueType> WriteTypeToValueTypeMap;
+
+  void UpdateKey() {
+    valid_ = it_->Valid();
+    if (!Valid()) {
+      key_.clear();
+      return;
+    }
+    auto t = WriteTypeToValueTypeMap.find(it_->Entry().type);
+    assert(t != WriteTypeToValueTypeMap.end());
+    if (t == WriteTypeToValueTypeMap.end()) {
+      key_.clear();
+      valid_ = false;
+      s_ = Status::Corruption("Unexpected write_batch_with_index entry type " +
+                              std::to_string(t->second));
+      return;
+    }
+    key_buf_.SetInternalKey(it_->Entry().key, assigned_seqno_.upper_bound,
+                            t->second);
+    key_ = key_buf_.GetInternalKey();
+  }
+
+  void UpdateSingleDeleteKey() {
+    assert(it_->Valid());
+    assert(Valid());
+    assert(assigned_seqno_.lower_bound < assigned_seqno_.upper_bound);
+    key_buf_.SetInternalKey(it_->Entry().key, assigned_seqno_.upper_bound - 1,
+                            kTypeSingleDeletion);
+    key_ = key_buf_.GetInternalKey();
+    at_overwritten_single_del_ = true;
+  }
+
+  std::unique_ptr<WBWIIterator> it_;
+  const WBWIMemTable::SeqnoRange assigned_seqno_;
+  const Comparator* comparator_;
+  IterKey key_buf_;
+  // The current internal key.
+  Slice key_;
+  Status s_;
+  bool valid_ = false;
+  bool at_overwritten_single_del_ = false;
+  bool emit_overwritten_single_del_ = false;
+};
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/monitoring/thread_status_util_debug.cc

@@ -50,6 +50,8 @@ Env::IOActivity ThreadStatusUtil::TEST_GetExpectedIOActivity(
       return Env::IOActivity::kGetEntity;
     case ThreadStatus::OperationType::OP_MULTIGETENTITY:
       return Env::IOActivity::kMultiGetEntity;
+    case ThreadStatus::OperationType::OP_READ_MANIFEST:
+      return Env::IOActivity::kReadManifest;
     default:
       return Env::IOActivity::kUnknown;
   }

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

@@ -7,6 +7,7 @@
 
 #include <cassert>
 #include <cinttypes>
+#include <iostream>
 #include <limits>
 #include <string>
 
@@ -132,6 +133,92 @@ static Status ParseCompressionOptions(const std::string& value,
   return Status::OK();
 }
 
+static Status TableFactoryParseFn(const ConfigOptions& opts,
+                                  const std::string& name,
+                                  const std::string& value, void* addr) {
+  assert(addr);
+  auto table_factory = static_cast<std::shared_ptr<TableFactory>*>(addr);
+
+  // The general approach to mutating a table factory is to clone it, then
+  // mutate and save the clone. This avoids race conditions between SetOptions
+  // and consumers of table_factory/table options by leveraging
+  // MutableCFOptions infrastructure to track the table_factory pointer.
+
+  // However, in the atypical case of setting an option that is safely mutable
+  // under something pointed to by the table factory, we should avoid cloning.
+  // The simple way to detect that case is to try with "mutable_options_only"
+  // and see if it works. If it does, we are finished. If not, we proceed to
+  // cloning etc.
+  //
+  // The canonical example of what is handled here is
+  // table_factory.filter_policy.bloom_before_level for RibbonFilterPolicy.
+  if (table_factory->get() != nullptr && !EndsWith(name, "table_factory")) {
+    ConfigOptions opts_mutable_only{opts};
+    opts_mutable_only.mutable_options_only = true;
+    Status s =
+        table_factory->get()->ConfigureOption(opts_mutable_only, name, value);
+    if (s.ok()) {
+      return s;
+    }
+    s.PermitUncheckedError();
+  }
+
+  std::shared_ptr<TableFactory> new_factory;
+  Status s;
+  if (name == "block_based_table_factory") {
+    if (table_factory->get() != nullptr) {
+      std::string factory_name = table_factory->get()->Name();
+      if (factory_name == TableFactory::kBlockBasedTableName()) {
+        new_factory = table_factory->get()->Clone();
+      } else {
+        s = Status::InvalidArgument("Cannot modify " + factory_name + " as " +
+                                    name);
+        return s;
+      }
+    } else {
+      new_factory.reset(NewBlockBasedTableFactory());
+    }
+    // Passing an object string to configure/instantiate a table factory
+    s = new_factory->ConfigureFromString(opts, value);
+  } else if (name == "plain_table_factory") {
+    if (table_factory->get() != nullptr) {
+      std::string factory_name = table_factory->get()->Name();
+      if (factory_name == TableFactory::kPlainTableName()) {
+        new_factory = table_factory->get()->Clone();
+      } else {
+        s = Status::InvalidArgument("Cannot modify " + factory_name + " as " +
+                                    name);
+        return s;
+      }
+    } else {
+      new_factory.reset(NewPlainTableFactory());
+    }
+    // Passing an object string to configure/instantiate a table factory
+    s = new_factory->ConfigureFromString(opts, value);
+  } else if (name == "table_factory" || name == OptionTypeInfo::kIdPropName()) {
+    // Related to OptionTypeInfo::AsCustomSharedPtr
+    if (value.empty()) {
+      new_factory = nullptr;
+    } else {
+      s = TableFactory::CreateFromString(opts, value, &new_factory);
+    }
+  } else if (table_factory->get() != nullptr) {
+    new_factory = table_factory->get()->Clone();
+    // Presumably passing a value for a specific field of the table factory
+    s = new_factory->ConfigureOption(opts, name, value);
+  } else {
+    s = Status::NotFound("Unable to instantiate a table factory from option: ",
+                         name);
+    return s;
+  }
+
+  // Only keep the modified clone if everything went OK
+  if (s.ok()) {
+    *table_factory = std::move(new_factory);
+  }
+  return s;
+}
+
 const std::string kOptNameBMCompOpts = "bottommost_compression_opts";
 const std::string kOptNameCompOpts = "compression_opts";
 
@@ -266,6 +353,25 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct MutableCFOptions, disable_auto_compactions),
           OptionType::kBoolean, OptionVerificationType::kNormal,
           OptionTypeFlags::kMutable}},
+        {"table_factory",
+         {offsetof(struct MutableCFOptions, table_factory),
+          OptionType::kCustomizable, OptionVerificationType::kByName,
+          OptionTypeFlags::kShared | OptionTypeFlags::kCompareLoose |
+              OptionTypeFlags::kStringNameOnly | OptionTypeFlags::kDontPrepare |
+              OptionTypeFlags::kMutable,
+          TableFactoryParseFn}},
+        {"block_based_table_factory",
+         {offsetof(struct MutableCFOptions, table_factory),
+          OptionType::kCustomizable, OptionVerificationType::kAlias,
+          OptionTypeFlags::kShared | OptionTypeFlags::kCompareLoose |
+              OptionTypeFlags::kMutable,
+          TableFactoryParseFn}},
+        {"plain_table_factory",
+         {offsetof(struct MutableCFOptions, table_factory),
+          OptionType::kCustomizable, OptionVerificationType::kAlias,
+          OptionTypeFlags::kShared | OptionTypeFlags::kCompareLoose |
+              OptionTypeFlags::kMutable,
+          TableFactoryParseFn}},
         {"filter_deletes",
          {0, OptionType::kBoolean, OptionVerificationType::kDeprecated,
           OptionTypeFlags::kMutable}},
@@ -446,6 +552,14 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct MutableCFOptions, periodic_compaction_seconds),
           OptionType::kUInt64T, OptionVerificationType::kNormal,
           OptionTypeFlags::kMutable}},
+        {"preclude_last_level_data_seconds",
+         {offsetof(struct MutableCFOptions, preclude_last_level_data_seconds),
+          OptionType::kUInt64T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
+        {"preserve_internal_time_seconds",
+         {offsetof(struct MutableCFOptions, preserve_internal_time_seconds),
+          OptionType::kUInt64T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
         {"bottommost_temperature",
          {0, OptionType::kTemperature, OptionVerificationType::kDeprecated,
           OptionTypeFlags::kMutable}},
@@ -626,14 +740,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct ImmutableCFOptions, default_temperature),
           OptionType::kTemperature, OptionVerificationType::kNormal,
           OptionTypeFlags::kCompareNever}},
-        {"preclude_last_level_data_seconds",
-         {offsetof(struct ImmutableCFOptions, preclude_last_level_data_seconds),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"preserve_internal_time_seconds",
-         {offsetof(struct ImmutableCFOptions, preserve_internal_time_seconds),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
         // Need to keep this around to be able to read old OPTIONS files.
         {"max_mem_compaction_level",
          {0, OptionType::kInt, OptionVerificationType::kDeprecated,
@@ -713,76 +819,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
                 MemTableRepFactory::CreateFromString(opts, value, shared);
             return s;
           }}},
-        {"table_factory",
-         OptionTypeInfo::AsCustomSharedPtr<TableFactory>(
-             offsetof(struct ImmutableCFOptions, table_factory),
-             OptionVerificationType::kByName,
-             (OptionTypeFlags::kCompareLoose |
-              OptionTypeFlags::kStringNameOnly |
-              OptionTypeFlags::kDontPrepare))},
-        {"block_based_table_factory",
-         {offsetof(struct ImmutableCFOptions, table_factory),
-          OptionType::kCustomizable, OptionVerificationType::kAlias,
-          OptionTypeFlags::kShared | OptionTypeFlags::kCompareLoose,
-          // Parses the input value and creates a BlockBasedTableFactory
-          [](const ConfigOptions& opts, const std::string& name,
-             const std::string& value, void* addr) {
-            BlockBasedTableOptions* old_opts = nullptr;
-            auto table_factory =
-                static_cast<std::shared_ptr<TableFactory>*>(addr);
-            if (table_factory->get() != nullptr) {
-              old_opts =
-                  table_factory->get()->GetOptions<BlockBasedTableOptions>();
-            }
-            if (name == "block_based_table_factory") {
-              std::unique_ptr<TableFactory> new_factory;
-              if (old_opts != nullptr) {
-                new_factory.reset(NewBlockBasedTableFactory(*old_opts));
-              } else {
-                new_factory.reset(NewBlockBasedTableFactory());
-              }
-              Status s = new_factory->ConfigureFromString(opts, value);
-              if (s.ok()) {
-                table_factory->reset(new_factory.release());
-              }
-              return s;
-            } else if (old_opts != nullptr) {
-              return table_factory->get()->ConfigureOption(opts, name, value);
-            } else {
-              return Status::NotFound("Mismatched table option: ", name);
-            }
-          }}},
-        {"plain_table_factory",
-         {offsetof(struct ImmutableCFOptions, table_factory),
-          OptionType::kCustomizable, OptionVerificationType::kAlias,
-          OptionTypeFlags::kShared | OptionTypeFlags::kCompareLoose,
-          // Parses the input value and creates a PlainTableFactory
-          [](const ConfigOptions& opts, const std::string& name,
-             const std::string& value, void* addr) {
-            PlainTableOptions* old_opts = nullptr;
-            auto table_factory =
-                static_cast<std::shared_ptr<TableFactory>*>(addr);
-            if (table_factory->get() != nullptr) {
-              old_opts = table_factory->get()->GetOptions<PlainTableOptions>();
-            }
-            if (name == "plain_table_factory") {
-              std::unique_ptr<TableFactory> new_factory;
-              if (old_opts != nullptr) {
-                new_factory.reset(NewPlainTableFactory(*old_opts));
-              } else {
-                new_factory.reset(NewPlainTableFactory());
-              }
-              Status s = new_factory->ConfigureFromString(opts, value);
-              if (s.ok()) {
-                table_factory->reset(new_factory.release());
-              }
-              return s;
-            } else if (old_opts != nullptr) {
-              return table_factory->get()->ConfigureOption(opts, name, value);
-            } else {
-              return Status::NotFound("Mismatched table option: ", name);
-            }
-          }}},
         {"table_properties_collectors",
          OptionTypeInfo::Vector<
              std::shared_ptr<TablePropertiesCollectorFactory>>(
@@ -954,7 +990,6 @@ ImmutableCFOptions::ImmutableCFOptions(const ColumnFamilyOptions& cf_options)
       inplace_update_support(cf_options.inplace_update_support),
       inplace_callback(cf_options.inplace_callback),
       memtable_factory(cf_options.memtable_factory),
-      table_factory(cf_options.table_factory),
       table_properties_collector_factories(
           cf_options.table_properties_collector_factories),
       bloom_locality(cf_options.bloom_locality),
@@ -964,9 +999,6 @@ ImmutableCFOptions::ImmutableCFOptions(const ColumnFamilyOptions& cf_options)
       optimize_filters_for_hits(cf_options.optimize_filters_for_hits),
       force_consistency_checks(cf_options.force_consistency_checks),
       default_temperature(cf_options.default_temperature),
-      preclude_last_level_data_seconds(
-          cf_options.preclude_last_level_data_seconds),
-      preserve_internal_time_seconds(cf_options.preserve_internal_time_seconds),
       memtable_insert_with_hint_prefix_extractor(
           cf_options.memtable_insert_with_hint_prefix_extractor),
       cf_paths(cf_options.cf_paths),
@@ -1108,6 +1140,11 @@ void MutableCFOptions::Dump(Logger* log) const {
                  ttl);
   ROCKS_LOG_INFO(log, "              periodic_compaction_seconds: %" PRIu64,
                  periodic_compaction_seconds);
+  ROCKS_LOG_INFO(log,
+                 "              preclude_last_level_data_seconds: %" PRIu64,
+                 preclude_last_level_data_seconds);
+  ROCKS_LOG_INFO(log, "              preserve_internal_time_seconds: %" PRIu64,
+                 preserve_internal_time_seconds);
   ROCKS_LOG_INFO(log, "                   paranoid_memory_checks: %d",
                  paranoid_memory_checks);
   std::string result;
@@ -1221,4 +1258,22 @@ Status GetStringFromMutableCFOptions(const ConfigOptions& config_options,
   return OptionTypeInfo::SerializeType(
       config_options, cf_mutable_options_type_info, &mutable_opts, opt_string);
 }
+
+#ifndef NDEBUG
+std::vector<std::string> TEST_GetImmutableInMutableCFOptions() {
+  std::vector<std::string> result;
+  for (const auto& opt : cf_mutable_options_type_info) {
+    if (!opt.second.IsMutable()) {
+      result.emplace_back(opt.first);
+    }
+  }
+  if (result.size() > 0) {
+    std::cerr << "Warning: " << result.size() << " immutable options in "
+              << "MutableCFOptions" << std::endl;
+  }
+  return result;
+}
+
+bool TEST_allowSetOptionsImmutableInMutable = false;
+#endif  // !NDEBUG
 }  // namespace ROCKSDB_NAMESPACE