Version and history for 9.6.2

Fix a leak of open Blob files (#13106 )
Summary: An earlier change (https://github.com/facebook/rocksdb/commit/b34cef57b798520791312f2f40681c4d12d5d33c) removed apparently unused functionality where an obsolete blob file number is passed for removal from TableCache, which manages SST files. This was actually relying on broken/fragile abstractions wherein TableCache and BlobFileCache share the same Cache and using the TableCache interface to manipulate blob file caching. No unit test was actually checking for removal of obsolete blob files from the cache (which is somewhat tricky to check and a second order correctness requirement). Here we fix the leak and add a DEBUG+ASAN-only check in DB::Close() that no obsolete files are lingering in the table/blob file cache. Fixes https://github.com/facebook/rocksdb/issues/13066 Important follow-up (FIXME): The added check discovered some apparent cases of leaked (into table_cache) SST file readers that would stick around until DB::Close(). Need to enable that check, diagnose, and fix. Pull Request resolved: https://github.com/facebook/rocksdb/pull/13106 Test Plan: added a check that is called during DB::Close in ASAN builds (to minimize paying the cost in all unit tests). Without the fix, the check failed in at least these tests: ``` db_blob_basic_test DBBlobBasicTest.DynamicallyWarmCacheDuringFlush db_blob_compaction_test DBBlobCompactionTest.CompactionReadaheadMerge db_blob_compaction_test DBBlobCompactionTest.MergeBlobWithBase db_blob_compaction_test DBBlobCompactionTest.CompactionDoNotFillCache db_blob_compaction_test DBBlobCompactionTest.SkipUntilFilter db_blob_compaction_test DBBlobCompactionTest.CompactionFilter db_blob_compaction_test DBBlobCompactionTest.CompactionReadaheadFilter db_blob_compaction_test DBBlobCompactionTest.CompactionReadaheadGarbageCollection ``` Reviewed By: ltamasi Differential Revision: D65296123 Pulled By: pdillinger fbshipit-source-id: 2276d76482beb2c75c9010bc1bec070bb23a24c0
2026-11-07 11:32:34 -05:00 · 2024-11-01 08:35:24 -07:00 · 2024-11-01 08:34:20 -07:00 · 2024-11-01 08:34:20 -07:00 · 2024-09-17 16:39:01 -07:00 · 2024-08-27 13:39:35 -07:00
316 changed files with 5264 additions and 18832 deletions
@@ -1,13 +1,13 @@
 name: facebook/rocksdb/benchmark-linux
 on: workflow_dispatch
-permissions: {}
-  # FIXME: Disabled temporarily
-  # schedule:
-  # - cron: 7 */2 * * *  # At minute 7 past every 2nd hour
 jobs:
+  # FIXME: when this job is fixed, it should be given a cron schedule like
+  # schedule:
+  # - cron: 0 * * * *
+  # workflow_dispatch:
  benchmark-linux:
    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: ubuntu-latest # FIXME: change this back to self-hosted when ready
+    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4.1.0
    - uses: "./.github/actions/build-for-benchmarks"
@@ -1,6 +1,5 @@
 name: facebook/rocksdb/nightly
 on: workflow_dispatch
-permissions: {}
 jobs:
  # These jobs would be in nightly but are failing or otherwise broken for
  # some reason.
@@ -3,7 +3,6 @@ on:
  schedule:
  - cron: 0 9 * * *
  workflow_dispatch:
-permissions: {}
 jobs:
  build-format-compatible:
    if: ${{ github.repository_owner == 'facebook' }}
@@ -80,7 +79,7 @@ jobs:
    steps:
    - uses: actions/checkout@v4.1.0
    - uses: "./.github/actions/pre-steps"
-    - run: make V=1 -j32 valgrind_test
+    - run: PORTABLE=1 make V=1 -j32 valgrind_test
    - uses: "./.github/actions/post-steps"
  build-windows-vs2022-avx2:
    if: ${{ github.repository_owner == 'facebook' }}
@@ -1,6 +1,5 @@
 name: facebook/rocksdb/pr-jobs-candidate
 on: workflow_dispatch
-permissions: {}
 jobs:
  # These jobs would be in pr-jobs but are failing or otherwise broken for
  # some reason.
@@ -1,6 +1,5 @@
 name: facebook/rocksdb/pr-jobs
 on: [push, pull_request]
-permissions: {}
 jobs:
  # NOTE: multiple workflows would be recommended, but the current GHA UI in
  # PRs doesn't make it clear when there's an overall error with a workflow,
@@ -32,7 +32,7 @@
 # 3. cmake ..
 # 4. make -j

-cmake_minimum_required(VERSION 3.12)
+cmake_minimum_required(VERSION 3.10)

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/modules/")
 include(ReadVersion)
@@ -716,7 +716,6 @@ set(SOURCES
        db/log_reader.cc
        db/log_writer.cc
        db/malloc_stats.cc
-        db/manifest_ops.cc
        db/memtable.cc
        db/memtable_list.cc
        db/merge_helper.cc
@@ -780,7 +779,6 @@ set(SOURCES
        memtable/hash_skiplist_rep.cc
        memtable/skiplistrep.cc
        memtable/vectorrep.cc
-        memtable/wbwi_memtable.cc
        memtable/write_buffer_manager.cc
        monitoring/histogram.cc
        monitoring/histogram_windowing.cc
@@ -1,92 +1,17 @@
 # Rocksdb Change Log
 > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt`

-## 9.10.0 (12/12/2024)
-### New Features
-* Introduce `TransactionOptions::commit_bypass_memtable` to enable transaction commit to bypass memtable insertions. This can be beneficial for transactions with many operations, as it reduces commit time that is mostly spent on memtable insertion.
-
-### Public API Changes
-* Deprecated Remote Compaction APIs (StartV2, WaitForCompleteV2) are completely removed from the codebase
-
-### Behavior Changes
-* DB::KeyMayExist() now follows its function comment, which means `value` parameter can be null, and it will be set only if `value_found` is passed in.
-
+## 9.6.2 (10/31/2024)
 ### Bug Fixes
-* Fix the issue where compaction incorrectly drops a key when there is a snapshot with a sequence number of zero.
-* Honor ConfigOptions.ignore_unknown_options in ParseStruct()
-
-### Performance Improvements
-* Enable reuse of file system allocated buffer for synchronous prefetching.
-* In buffered IO mode, try to align writes on power of 2 if checksum handoff is not enabled for the file type being written.
-
-## 9.9.0 (11/18/2024)
-### New Features
-* Multi-Column-Family-Iterator (CoalescingIterator/AttributeGroupIterator) is no longer marked as experimental
-* Adds a new table property "rocksdb.newest.key.time" which records the unix timestamp of the newest key. Uses this table property for FIFO TTL and temperature change compaction.
-
-### Public API Changes
-* Added a new API `Transaction::GetAttributeGroupIterator` that can be used to create a multi-column-family attribute group iterator over the specified column families, including the data from both the transaction and the underlying database. This API is currently supported for optimistic and write-committed pessimistic transactions.
-* Added a new API `Transaction::GetCoalescingIterator` that can be used to create a multi-column-family coalescing iterator over the specified column families, including the data from both the transaction and the underlying database. This API is currently supported for optimistic and write-committed pessimistic transactions.
-
-### Behavior Changes
-* `BaseDeltaIterator` now honors the read option `allow_unprepared_value`.
-
-### Bug Fixes
-* `BaseDeltaIterator` now calls `PrepareValue` on the base iterator in case it has been created with the `allow_unprepared_value` read option set. Earlier, such base iterators could lead to incorrect values being exposed from `BaseDeltaIterator`.
 * Fix a leak of obsolete blob files left open until DB::Close(). This bug was introduced in version 9.4.0.
-* Fix missing cases of corruption retry during DB open and read API processing.
-* Fix a bug for transaction db with 2pc where an old WAL may be retained longer than needed (#13127).
-* Fix leaks of some open SST files (until `DB::Close()`) that are written but never become live due to various failures. (We now have a check for such leaks with no outstanding issues.)
-* Fix a bug for replaying WALs for WriteCommitted transaction DB when its user-defined timestamps setting is toggled on/off between DB sessions.
-
-### Performance Improvements
-* Fix regression in issue #12038 due to `Options::compaction_readahead_size` greater than `max_sectors_kb` (i.e, largest I/O size that the OS issues to a block device defined in linux)
-
-## 9.8.0 (10/25/2024)
-### New Features
-* All non-`block_cache` options in `BlockBasedTableOptions` are now mutable with `DB::SetOptions()`. See also Bug Fixes below.
-* When using iterators with BlobDB, it is now possible to load large values on an on-demand basis, i.e. only if they are actually needed by the application. This can save I/O in use cases where the values associated with certain keys are not needed. For more details, see the new read option `allow_unprepared_value` and the iterator API `PrepareValue`.
-* Add a new file ingestion option `IngestExternalFileOptions::fill_cache` to support not adding blocks from ingested files into block cache during file ingestion.
-* The option `allow_unprepared_value` is now also supported for multi-column-family iterators (i.e. `CoalescingIterator` and `AttributeGroupIterator`).
-* When a file with just one range deletion (standalone range deletion file) is ingested via bulk loading, it will be marked for compaction. During compaction, this type of files can be used to directly filter out some input files that are not protected by any snapshots and completely deleted by the standalone range deletion file.
-
-### Behavior Changes
-* During file ingestion, overlapping files level assignment are done in multiple batches, so that they can potentially be assigned to lower levels other than always land on L0.
-* OPTIONS file to be loaded by remote worker is now preserved so that it does not get purged by the primary host. A similar technique as how we are preserving new SST files from getting purged is used for this. min_options_file_numbers_ is tracked like pending_outputs_ is tracked.
-* Trim readahead_size during scans so data blocks containing keys that are not in the same prefix as the seek key in `Seek()` are not prefetched when `ReadOptions::auto_readahead_size=true` (default value) and `ReadOptions::prefix_same_as_start = true`
-* Assigning levels for external files are done in the same way for universal compaction and leveled compaction. The old behavior tends to assign files to L0 while the new behavior will assign the files to the lowest level possible.

+## 9.6.1 (08/24/2024)
 ### Bug Fixes
-* Fix a longstanding race condition in SetOptions for `block_based_table_factory` options. The fix has some subtle behavior changes because of copying and replacing the TableFactory on a change with SetOptions, including requiring an Iterator::Refresh() for an existing Iterator to use the latest options.
-* Fix under counting of allocated memory in the compressed secondary cache due to looking at the compressed block size rather than the actual memory allocated, which could be larger due to internal fragmentation.
-* `GetApproximateMemTableStats()` could return disastrously bad estimates 5-25% of the time. The function has been re-engineered to return much better estimates with similar CPU cost.
-* Skip insertion of compressed blocks in the secondary cache if the lowest_used_cache_tier DB option is kVolatileTier.
-* Fix an issue in level compaction where a small CF with small compaction debt can cause the DB to allow parallel compactions. (#13054)
-* Several DB option settings could be lost through `GetOptionsFromString()`, possibly elsewhere as well. Affected options, now fixed:`background_close_inactive_wals`, `write_dbid_to_manifest`, `write_identity_file`, `prefix_seek_opt_in_only`
-
-## 9.7.0 (09/20/2024)
-### New Features
-* Make Cache a customizable class that can be instantiated by the object registry.
-* Add new option `prefix_seek_opt_in_only` that makes iterators generally safer when you might set a `prefix_extractor`. When `prefix_seek_opt_in_only=true`, which is expected to be the future default, prefix seek is only used when `prefix_same_as_start` or `auto_prefix_mode` are set. Also, `prefix_same_as_start` and `auto_prefix_mode` now allow prefix filtering even with `total_order_seek=true`.
-* Add a new table property "rocksdb.key.largest.seqno" which records the largest sequence number of all keys in file. It is verified to be zero during SST file ingestion.
-
-### Behavior Changes
-* Changed the semantics of the BlobDB configuration option `blob_garbage_collection_force_threshold` to define a threshold for the overall garbage ratio of all blob files currently eligible for garbage collection (according to `blob_garbage_collection_age_cutoff`). This can provide better control over space amplification at the cost of slightly higher write amplification.
-* Set `write_dbid_to_manifest=true` by default. This means DB ID will now be preserved through backups, checkpoints, etc. by default. Also add `write_identity_file` option which can be set to false for anticipated future behavior.
-* In FIFO compaction, compactions for changing file temperature (configured by option `file_temperature_age_thresholds`) will compact one file at a time, instead of merging multiple eligible file together (#13018).
-* Support ingesting db generated files using hard link, i.e. IngestExternalFileOptions::move_files/link_files and IngestExternalFileOptions::allow_db_generated_files.
-* Add a new file ingestion option `IngestExternalFileOptions::link_files` to hard link input files and preserve original files links after ingestion.
-* DB::Close now untracks files in SstFileManager, making avaialble any space used
-by them. Prior to this change they would be orphaned until the DB is re-opened.
-
-### Bug Fixes
-* Fix a bug in CompactRange() where result files may not be compacted in any future compaction. This can only happen when users configure CompactRangeOptions::change_level to true and the change level step of manual compaction fails (#13009).
-* Fix handling of dynamic change of `prefix_extractor` with memtable prefix filter. Previously, prefix seek could mix different prefix interpretations between memtable and SST files. Now the latest `prefix_extractor` at the time of iterator creation or refresh is respected.
-* Fix a bug with manual_wal_flush and auto error recovery from WAL failure that may cause CFs to be inconsistent (#12995). The fix will set potential WAL write failure as fatal error when manual_wal_flush is true, and disables auto error recovery from these errors.
+* Fix correctness of MultiGet across column families with user timestamp.

 ## 9.6.0 (08/19/2024)
 ### New Features
-* Best efforts recovery supports recovering to incomplete Version with a clean seqno cut that presents a valid point in time view from the user's perspective, if versioning history doesn't include atomic flush.
+* *Best efforts recovery supports recovering to incomplete Version with a clean seqno cut that presents a valid point in time view from the user's perspective, if versioning history doesn't include atomic flush.
 * New option `BlockBasedTableOptions::decouple_partitioned_filters` should improve efficiency in serving read queries because filter and index partitions can consistently target the configured `metadata_block_size`. This option is currently opt-in.
 * Introduce a new mutable CF option `paranoid_memory_checks`. It enables additional validation on data integrity during reads/scanning. Currently, skip list based memtable will validate key ordering during look up and scans.

@@ -98,11 +23,11 @@ by them. Prior to this change they would be orphaned until the DB is re-opened.
 * There may be less intra-L0 compaction triggered by total L0 size being too small. We now use compensated file size (tombstones are assigned some value size) when calculating L0 size and reduce the threshold for L0 size limit. This is to avoid accumulating too much data/tombstones in L0.

 ### Bug Fixes
-* Make DestroyDB supports slow deletion when it's configured in `SstFileManager`. The slow deletion is subject to the configured `rate_bytes_per_sec`, but not subject to the `max_trash_db_ratio`.
+* *Make DestroyDB supports slow deletion when it's configured in `SstFileManager`. The slow deletion is subject to the configured `rate_bytes_per_sec`, but not subject to the `max_trash_db_ratio`.
 * Fixed a bug where we set unprep_seqs_ even when WriteImpl() fails. This was caught by stress test write fault injection in WriteImpl(). This may have incorrectly caused iteration creation failure for unvalidated writes or returned wrong result for WriteUnpreparedTxn::GetUnpreparedSequenceNumbers().
 * Fixed a bug where successful write right after error recovery for last failed write finishes causes duplicate WAL entries
 * Fixed a data race involving the background error status in `unordered_write` mode.
-* Fix a bug where file snapshot functions like backup, checkpoint may attempt to copy a non-existing manifest file. #12882
+* *Fix a bug where file snapshot functions like backup, checkpoint may attempt to copy a non-existing manifest file. #12882
 * Fix a bug where per kv checksum corruption may be ignored in MultiGet().
 * Fix a race condition in pessimistic transactions that could allow multiple transactions with the same name to be registered simultaneously, resulting in a crash or other unpredictable behavior.

@@ -181,7 +106,7 @@ by them. Prior to this change they would be orphaned until the DB is re-opened.
 * Added a new API `GetEntityFromBatchAndDB` to `WriteBatchWithIndex` that can be used for wide-column point lookups with read-your-own-writes consistency. Similarly to `GetFromBatchAndDB`, the API can combine data from the write batch with data from the underlying database if needed. See the API comments for more details.
 * [Experimental] Introduce two new cross-column-family iterators - CoalescingIterator and AttributeGroupIterator. The CoalescingIterator enables users to iterate over multiple column families and access their values and columns. During this iteration, if the same key exists in more than one column family, the keys in the later column family will overshadow the previous ones. The AttributeGroupIterator allows users to gather wide columns per Column Family and create attribute groups while iterating over keys across all CFs.
 * Added a new API `MultiGetEntityFromBatchAndDB` to `WriteBatchWithIndex` that can be used for batched wide-column point lookups with read-your-own-writes consistency. Similarly to `MultiGetFromBatchAndDB`, the API can combine data from the write batch with data from the underlying database if needed. See the API comments for more details.
-* Adds a `SstFileReader::NewTableIterator` API to support programmatically read a SST file as a raw table file.
+* *Adds a `SstFileReader::NewTableIterator` API to support programmatically read a SST file as a raw table file.
 * Add an option to `WaitForCompactOptions` - `wait_for_purge` to make `WaitForCompact()` API wait for background purge to complete

 ### Public API Changes
@@ -210,24 +135,24 @@ the whole DB to be dropped right after migration if the migrated data is larger
 * Fixed a bug where wrong padded bytes are used to generate file checksum and `DataVerificationInfo::checksum` upon file creation
 * Correctly implemented the move semantics of `PinnableWideColumns`.
 * Fixed a bug when the recycle_log_file_num in DBOptions is changed from 0 to non-zero when a DB is reopened. On a subsequent reopen, if a log file created when recycle_log_file_num==0 was reused previously, is alive and is empty, we could end up inserting stale WAL records into the memtable.
-* Fix a bug where obsolete files' deletion during DB::Open are not rate limited with `SstFilemManager`'s slow deletion feature even if it's configured.
+* *Fix a bug where obsolete files' deletion during DB::Open are not rate limited with `SstFilemManager`'s slow deletion feature even if it's configured.

 ## 9.1.0 (03/22/2024)
 ### New Features
 * Added an option, `GetMergeOperandsOptions::continue_cb`, to give users the ability to end `GetMergeOperands()`'s lookup process before all merge operands were found.
-* Add sanity checks for ingesting external files that currently checks if the user key comparator used to create the file is compatible with the column family's user key comparator.
+* *Add sanity checks for ingesting external files that currently checks if the user key comparator used to create the file is compatible with the column family's user key comparator.
 *Support ingesting external files for column family that has user-defined timestamps in memtable only enabled.
 * On file systems that support storage level data checksum and reconstruction, retry SST block reads for point lookups, scans, and flush and compaction if there's a checksum mismatch on the initial read.
 * Some enhancements and fixes to experimental Temperature handling features, including new `default_write_temperature` CF option and opening an `SstFileWriter` with a temperature.
 * `WriteBatchWithIndex` now supports wide-column point lookups via the `GetEntityFromBatch` API. See the API comments for more details.
-* Implement experimental features: API `Iterator::GetProperty("rocksdb.iterator.write-time")` to allow users to get data's approximate write unix time and write data with a specific write time via `WriteBatch::TimedPut` API.
+* *Implement experimental features: API `Iterator::GetProperty("rocksdb.iterator.write-time")` to allow users to get data's approximate write unix time and write data with a specific write time via `WriteBatch::TimedPut` API.

 ### Public API Changes
 * Best-effort recovery (`best_efforts_recovery == true`) may now be used together with atomic flush (`atomic_flush == true`). The all-or-nothing recovery guarantee for atomically flushed data will be upheld.
 * Remove deprecated option `bottommost_temperature`, already replaced by `last_level_temperature`
 * Added new PerfContext counters for block cache bytes read - block_cache_index_read_byte, block_cache_filter_read_byte, block_cache_compression_dict_read_byte, and block_cache_read_byte.
 * Deprecate experimental Remote Compaction APIs - StartV2() and WaitForCompleteV2() and introduce Schedule() and Wait(). The new APIs essentially does the same thing as the old APIs. They allow taking externally generated unique id to wait for remote compaction to complete.
-* For API `WriteCommittedTransaction::GetForUpdate`, if the column family enables user-defined timestamp, it was mandated that argument `do_validate` cannot be false, and UDT based validation has to be done with a user set read timestamp. It's updated to make the UDT based validation optional if user sets `do_validate` to false and does not set a read timestamp. With this, `GetForUpdate` skips UDT based validation and it's users' responsibility to enforce the UDT invariant. SO DO NOT skip this UDT-based validation if users do not have ways to enforce the UDT invariant. Ways to enforce the invariant on the users side include manage a monotonically increasing timestamp, commit transactions in a single thread etc.
+* *For API `WriteCommittedTransaction::GetForUpdate`, if the column family enables user-defined timestamp, it was mandated that argument `do_validate` cannot be false, and UDT based validation has to be done with a user set read timestamp. It's updated to make the UDT based validation optional if user sets `do_validate` to false and does not set a read timestamp. With this, `GetForUpdate` skips UDT based validation and it's users' responsibility to enforce the UDT invariant. SO DO NOT skip this UDT-based validation if users do not have ways to enforce the UDT invariant. Ways to enforce the invariant on the users side include manage a monotonically increasing timestamp, commit transactions in a single thread etc.
 * Defined a new PerfLevel `kEnableWait` to measure time spent by user threads blocked in RocksDB other than mutex, such as a write thread waiting to be added to a write group, a write thread delayed or stalled etc.
 * `RateLimiter`'s API no longer requires the burst size to be the refill size. Users of `NewGenericRateLimiter()` can now provide burst size in `single_burst_bytes`. Implementors of `RateLimiter::SetSingleBurstBytes()` need to adapt their implementations to match the changed API doc.
 * Add `write_memtable_time` to the newly introduced PerfLevel `kEnableWait`.
@@ -260,7 +185,7 @@ MultiGetBenchmarks.multiGetList10 no_column_family 10000 16 100 1024 thrpt 25 76
 ## 9.0.0 (02/16/2024)
 ### New Features
 * Provide support for FSBuffer for point lookups. Also added support for scans and compactions that don't go through prefetching.
-* Make `SstFileWriter` create SST files without persisting user defined timestamps when the `Option.persist_user_defined_timestamps` flag is set to false.
+* *Make `SstFileWriter` create SST files without persisting user defined timestamps when the `Option.persist_user_defined_timestamps` flag is set to false.
 * Add support for user-defined timestamps in APIs `DeleteFilesInRanges` and `GetPropertiesOfTablesInRange`.
 * Mark wal\_compression feature as production-ready. Currently only compatible with ZSTD compression.

@@ -270,9 +195,9 @@ MultiGetBenchmarks.multiGetList10 no_column_family 10000 16 100 1024 thrpt 25 76
 * Exposed mode option to Rate Limiter via c api.
 * Removed deprecated option `access_hint_on_compaction_start`
 * Removed deprecated option `ColumnFamilyOptions::check_flush_compaction_key_order`
-* Remove the default `WritableFile::GetFileSize` and `FSWritableFile::GetFileSize` implementation that returns 0 and make it pure virtual, so that subclasses are enforced to explicitly provide an implementation.
+* *Remove the default `WritableFile::GetFileSize` and `FSWritableFile::GetFileSize` implementation that returns 0 and make it pure virtual, so that subclasses are enforced to explicitly provide an implementation.
 * Removed deprecated option `ColumnFamilyOptions::level_compaction_dynamic_file_size`
-* Removed tickers with typos "rocksdb.error.handler.bg.errro.count", "rocksdb.error.handler.bg.io.errro.count", "rocksdb.error.handler.bg.retryable.io.errro.count".
+* *Removed tickers with typos "rocksdb.error.handler.bg.errro.count", "rocksdb.error.handler.bg.io.errro.count", "rocksdb.error.handler.bg.retryable.io.errro.count".
 * Remove the force mode for `EnableFileDeletions` API because it is unsafe with no known legitimate use.
 * Removed deprecated option `ColumnFamilyOptions::ignore_max_compaction_bytes_for_input`
 * `sst_dump --command=check` now compares the number of records in a table with `num_entries` in table property, and reports corruption if there is a mismatch. API `SstFileDumper::ReadSequential()` is updated to optionally do this verification. (#12322)
@@ -630,11 +630,6 @@ VALGRIND_VER := $(join $(VALGRIND_VER),valgrind)
 VALGRIND_OPTS = --error-exitcode=$(VALGRIND_ERROR) --leak-check=full
 # Not yet supported: --show-leak-kinds=definite,possible,reachable --errors-for-leak-kinds=definite,possible,reachable

-# Work around valgrind hanging on systems with limited internet access
-ifneq ($(shell which git 2>/dev/null && git config --get https.proxy),)
-  export DEBUGINFOD_URLS=
-endif
-
 TEST_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(TEST_LIB_SOURCES) $(MOCK_LIB_SOURCES)) $(GTEST)
 BENCH_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(BENCH_LIB_SOURCES))
 CACHE_BENCH_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(CACHE_BENCH_LIB_SOURCES))
@@ -659,7 +654,7 @@ ifneq ($(filter check-headers, $(MAKECMDGOALS)),)
 # TODO: add/support JNI headers
 	DEV_HEADER_DIRS := $(sort include/ $(dir $(ALL_SOURCES)))
 # Some headers like in port/ are platform-specific
-	DEV_HEADERS_TO_CHECK := $(shell $(FIND) $(DEV_HEADER_DIRS) -type f -name '*.h' | grep -E -v 'port/|plugin/|lua/|range_tree/|secondary_index/')
+	DEV_HEADERS_TO_CHECK := $(shell $(FIND) $(DEV_HEADER_DIRS) -type f -name '*.h' | grep -E -v 'port/|plugin/|lua/|range_tree/')
 	PUBLIC_HEADERS_TO_CHECK := $(shell $(FIND) include/ -type f -name '*.h' | grep -E -v 'lua/')
 else
 	DEV_HEADERS_TO_CHECK :=
@@ -1169,16 +1164,16 @@ ubsan_crash_test_with_best_efforts_recovery: clean
 	$(MAKE) clean

 full_valgrind_test:
-	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 PORTABLE=1 $(MAKE) valgrind_check
+	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check

 full_valgrind_test_some:
-	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 PORTABLE=1 $(MAKE) valgrind_check_some
+	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check_some

 valgrind_test:
-	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 PORTABLE=1 $(MAKE) valgrind_check
+	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check

 valgrind_test_some:
-	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 PORTABLE=1 $(MAKE) valgrind_check_some
+	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check_some

 valgrind_check: $(TESTS)
 	$(MAKE) DRIVER="$(VALGRIND_VER) $(VALGRIND_OPTS)" gen_parallel_tests
@@ -2489,7 +2484,7 @@ checkout_folly:
 	fi
 	@# Pin to a particular version for public CI, so that PR authors don't
 	@# need to worry about folly breaking our integration. Update periodically
-	cd third-party/folly && git reset --hard 33f5b67fcaeb8705b04fd1b850873a180dc89aaa
+	cd third-party/folly && git reset --hard c48fdd205c1c291651749d532b8055fe822bba25
 	@# NOTE: this hack is required for clang in some cases
 	perl -pi -e 's/int rv = syscall/int rv = (int)syscall/' third-party/folly/folly/detail/Futex.cpp
 	@# NOTE: this hack is required for gcc in some cases
@@ -83,7 +83,6 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "db/log_writer.cc",
        "db/logs_with_prep_tracker.cc",
        "db/malloc_stats.cc",
-        "db/manifest_ops.cc",
        "db/memtable.cc",
        "db/memtable_list.cc",
        "db/merge_helper.cc",
@@ -150,7 +149,6 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "memtable/hash_skiplist_rep.cc",
        "memtable/skiplistrep.cc",
        "memtable/vectorrep.cc",
-        "memtable/wbwi_memtable.cc",
        "memtable/write_buffer_manager.cc",
        "monitoring/histogram.cc",
        "monitoring/histogram_windowing.cc",
@@ -364,14 +362,9 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "//folly/experimental/coro:coroutine",
        "//folly/experimental/coro:task",
        "//folly/synchronization:distributed_mutex",
-    ], headers=glob(["**/*.h"]), link_whole=False, extra_test_libs=False)
+    ], headers=None, link_whole=False, extra_test_libs=False)

-cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[], deps=[":rocksdb_lib"], headers=[], link_whole=True, extra_test_libs=False)
-
-cpp_library_wrapper(name="rocksdb_with_faiss_lib", srcs=["utilities/secondary_index/faiss_ivf_index.cc"], deps=[
-        "//faiss:faiss",
-        ":rocksdb_lib",
-    ], headers=[], link_whole=False, extra_test_libs=False)
+cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[], deps=[":rocksdb_lib"], headers=None, link_whole=True, extra_test_libs=False)

 cpp_library_wrapper(name="rocksdb_test_lib", srcs=[
        "db/db_test_util.cc",
@@ -385,21 +378,7 @@ cpp_library_wrapper(name="rocksdb_test_lib", srcs=[
        "tools/trace_analyzer_tool.cc",
        "utilities/agg_merge/test_agg_merge.cc",
        "utilities/cassandra/test_utils.cc",
-    ], deps=[":rocksdb_lib"], headers=[], link_whole=False, extra_test_libs=True)
-
-cpp_library_wrapper(name="rocksdb_with_faiss_test_lib", srcs=[
-        "db/db_test_util.cc",
-        "db/db_with_timestamp_test_util.cc",
-        "table/mock_table.cc",
-        "test_util/mock_time_env.cc",
-        "test_util/secondary_cache_test_util.cc",
-        "test_util/testharness.cc",
-        "test_util/testutil.cc",
-        "tools/block_cache_analyzer/block_cache_trace_analyzer.cc",
-        "tools/trace_analyzer_tool.cc",
-        "utilities/agg_merge/test_agg_merge.cc",
-        "utilities/cassandra/test_utils.cc",
-    ], deps=[":rocksdb_with_faiss_lib"], headers=[], link_whole=False, extra_test_libs=True)
+    ], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=True)

 cpp_library_wrapper(name="rocksdb_tools_lib", srcs=[
        "test_util/testutil.cc",
@@ -407,9 +386,9 @@ cpp_library_wrapper(name="rocksdb_tools_lib", srcs=[
        "tools/db_bench_tool.cc",
        "tools/simulated_hybrid_file_system.cc",
        "tools/trace_analyzer_tool.cc",
-    ], deps=[":rocksdb_lib"], headers=[], link_whole=False, extra_test_libs=False)
+    ], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=False)

-cpp_library_wrapper(name="rocksdb_cache_bench_tools_lib", srcs=["cache/cache_bench_tool.cc"], deps=[":rocksdb_lib"], headers=[], link_whole=False, extra_test_libs=False)
+cpp_library_wrapper(name="rocksdb_cache_bench_tools_lib", srcs=["cache/cache_bench_tool.cc"], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=False)

 rocks_cpp_library_wrapper(name="rocksdb_stress_lib", srcs=[
        "db_stress_tool/batched_ops_stress.cc",
@@ -431,15 +410,13 @@ rocks_cpp_library_wrapper(name="rocksdb_stress_lib", srcs=[
        "test_util/testutil.cc",
        "tools/block_cache_analyzer/block_cache_trace_analyzer.cc",
        "tools/trace_analyzer_tool.cc",
-    ], headers=[])
+    ], headers=None)


 cpp_binary_wrapper(name="ldb", srcs=["tools/ldb.cc"], deps=[":rocksdb_tools_lib"], extra_preprocessor_flags=[], extra_bench_libs=False)

 cpp_binary_wrapper(name="db_stress", srcs=["db_stress_tool/db_stress.cc"], deps=[":rocksdb_stress_lib"], extra_preprocessor_flags=[], extra_bench_libs=False)

-cpp_binary_wrapper(name="db_bench", srcs=["tools/db_bench.cc"], deps=[":rocksdb_tools_lib"], extra_preprocessor_flags=[], extra_bench_libs=False)
-
 cpp_binary_wrapper(name="cache_bench", srcs=["cache/cache_bench.cc"], deps=[":rocksdb_cache_bench_tools_lib"], extra_preprocessor_flags=[], extra_bench_libs=False)

 cpp_binary_wrapper(name="ribbon_bench", srcs=["microbench/ribbon_bench.cc"], deps=[], extra_preprocessor_flags=[], extra_bench_libs=True)
@@ -5047,7 +5024,7 @@ cpp_unittest_wrapper(name="dynamic_bloom_test",
            extra_compiler_flags=[])


-cpp_library_wrapper(name="env_basic_test_lib", srcs=["env/env_basic_test.cc"], deps=[":rocksdb_test_lib"], headers=[], link_whole=False, extra_test_libs=True)
+cpp_library_wrapper(name="env_basic_test_lib", srcs=["env/env_basic_test.cc"], deps=[":rocksdb_test_lib"], headers=None, link_whole=False, extra_test_libs=True)

 cpp_unittest_wrapper(name="env_basic_test",
            srcs=["env/env_basic_test.cc"],
@@ -5097,12 +5074,6 @@ cpp_unittest_wrapper(name="external_sst_file_test",
            extra_compiler_flags=[])


-cpp_unittest_wrapper(name="faiss_ivf_index_test",
-            srcs=["utilities/secondary_index/faiss_ivf_index_test.cc"],
-            deps=[":rocksdb_with_faiss_test_lib"],
-            extra_compiler_flags=[])
-
-
 cpp_unittest_wrapper(name="fault_injection_test",
            srcs=["db/fault_injection_test.cc"],
            deps=[":rocksdb_test_lib"],
@@ -38,11 +38,12 @@ Snowflake [uses](https://www.snowflake.com/blog/how-foundationdb-powers-snowflak
 The Bing search engine from Microsoft uses RocksDB as the storage engine for its web data platform: https://blogs.bing.com/Engineering-Blog/october-2021/RocksDB-in-Microsoft-Bing

 ## LinkedIn
-1. [Venice](https://venicedb.org/) is a derived data platform using RocksDB as its storage engine. It is LinkedIn's ML feature store, powering thousands of recommender use cases, including the Feed, Video recommendations, and People You May Know.
-2. LinkedIn's follow feed for storing user's activities. Check out the blog post: https://engineering.linkedin.com/blog/2016/03/followfeed--linkedin-s-feed-made-faster-and-smarter
-3. Apache Samza, open source framework for stream processing.
+Two different use cases at Linkedin are using RocksDB as a storage engine:

-Learn more about LinkedIn's follow feed and Apache Samza in a Tech Talk by Ankit Gupta and Naveen Somasundaram: http://www.youtube.com/watch?v=plqVp_OnSzg
+1. LinkedIn's follow feed for storing user's activities. Check out the blog post: https://engineering.linkedin.com/blog/2016/03/followfeed--linkedin-s-feed-made-faster-and-smarter
+2. Apache Samza, open source framework for stream processing
+
+Learn more about those use cases in a Tech Talk by Ankit Gupta and Naveen Somasundaram: http://www.youtube.com/watch?v=plqVp_OnSzg

 ## Yahoo
 Yahoo is using RocksDB as a storage engine for their biggest distributed data store Sherpa. Learn more about it here: http://yahooeng.tumblr.com/post/120730204806/sherpa-scales-new-heights
@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+from __future__ import absolute_import, division, print_function, unicode_literals

 try:
    from builtins import str
@@ -10,14 +11,14 @@ import json
 import os
 import sys

-from targets_builder import TARGETSBuilder, LiteralValue
+from targets_builder import TARGETSBuilder

 from util import ColorString

-# This script generates BUCK file for Buck.
+# This script generates TARGETS file for Buck.
 # Buck is a build tool specifying dependencies among different build targets.
 # User can pass extra dependencies as a JSON object via command line, and this
-# script can include these dependencies in the generate BUCK file.
+# script can include these dependencies in the generate TARGETS file.
 # Usage:
 # $python3 buckifier/buckify_rocksdb.py
 # (This generates a TARGET file without user-specified dependency for unit
@@ -28,7 +29,7 @@ from util import ColorString
 #                      "extra_compiler_flags": ["-DFOO_BAR", "-Os"]
 #                  }
 #         }'
-# (Generated BUCK file has test_dep and mock1 as dependencies for RocksDB
+# (Generated TARGETS file has test_dep and mock1 as dependencies for RocksDB
 # unit tests, and will use the extra_compiler_flags to compile the unit test
 # source.)

@@ -114,9 +115,9 @@ def get_dependencies():
    return deps_map


-# Prepare BUCK file for buck
-def generate_buck(repo_path, deps_map):
-    print(ColorString.info("Generating BUCK"))
+# Prepare TARGETS file for buck
+def generate_targets(repo_path, deps_map):
+    print(ColorString.info("Generating TARGETS"))
    # parsed src.mk file
    src_mk = parse_src_mk(repo_path)
    # get all .cc files
@@ -131,12 +132,12 @@ def generate_buck(repo_path, deps_map):
    if len(sys.argv) >= 2:
        # Heuristically quote and canonicalize whitespace for inclusion
        # in how the file was generated.
-        extra_argv = " '{}'".format(" ".join(sys.argv[1].split()))
+        extra_argv = " '{0}'".format(" ".join(sys.argv[1].split()))

-    BUCK = TARGETSBuilder("%s/BUCK" % repo_path, extra_argv)
+    TARGETS = TARGETSBuilder("%s/TARGETS" % repo_path, extra_argv)

    # rocksdb_lib
-    BUCK.add_library(
+    TARGETS.add_library(
        "rocksdb_lib",
        src_mk["LIB_SOURCES"] +
        # always add range_tree, it's only excluded on ppc64, which we don't use internally
@@ -149,29 +150,20 @@ def generate_buck(repo_path, deps_map):
            "//folly/experimental/coro:task",
            "//folly/synchronization:distributed_mutex",
        ],
-        headers=LiteralValue("glob([\"**/*.h\"])")
    )
    # rocksdb_whole_archive_lib
-    BUCK.add_library(
+    TARGETS.add_library(
        "rocksdb_whole_archive_lib",
        [],
        deps=[
            ":rocksdb_lib",
        ],
+        headers=None,
        extra_external_deps="",
        link_whole=True,
    )
-    # rocksdb_with_faiss_lib
-    BUCK.add_library(
-        "rocksdb_with_faiss_lib",
-        src_mk.get("WITH_FAISS_LIB_SOURCES", []),
-        deps=[
-            "//faiss:faiss",
-            ":rocksdb_lib",
-        ],
-    )
    # rocksdb_test_lib
-    BUCK.add_library(
+    TARGETS.add_library(
        "rocksdb_test_lib",
        src_mk.get("MOCK_LIB_SOURCES", [])
        + src_mk.get("TEST_LIB_SOURCES", [])
@@ -180,20 +172,8 @@ def generate_buck(repo_path, deps_map):
        [":rocksdb_lib"],
        extra_test_libs=True,
    )
-    # rocksdb_with_faiss_test_lib
-    BUCK.add_library(
-        "rocksdb_with_faiss_test_lib",
-        src_mk.get("MOCK_LIB_SOURCES", [])
-        + src_mk.get("TEST_LIB_SOURCES", [])
-        + src_mk.get("EXP_LIB_SOURCES", [])
-        + src_mk.get("ANALYZER_LIB_SOURCES", []),
-        deps=[
-            ":rocksdb_with_faiss_lib",
-        ],
-        extra_test_libs=True,
-    )
    # rocksdb_tools_lib
-    BUCK.add_library(
+    TARGETS.add_library(
        "rocksdb_tools_lib",
        src_mk.get("BENCH_LIB_SOURCES", [])
        + src_mk.get("ANALYZER_LIB_SOURCES", [])
@@ -201,51 +181,47 @@ def generate_buck(repo_path, deps_map):
        [":rocksdb_lib"],
    )
    # rocksdb_cache_bench_tools_lib
-    BUCK.add_library(
+    TARGETS.add_library(
        "rocksdb_cache_bench_tools_lib",
        src_mk.get("CACHE_BENCH_LIB_SOURCES", []),
        [":rocksdb_lib"],
    )
    # rocksdb_stress_lib
-    BUCK.add_rocksdb_library(
+    TARGETS.add_rocksdb_library(
        "rocksdb_stress_lib",
        src_mk.get("ANALYZER_LIB_SOURCES", [])
        + src_mk.get("STRESS_LIB_SOURCES", [])
        + ["test_util/testutil.cc"],
    )
    # ldb binary
-    BUCK.add_binary(
+    TARGETS.add_binary(
        "ldb", ["tools/ldb.cc"], [":rocksdb_tools_lib"]
    )
    # db_stress binary
-    BUCK.add_binary(
+    TARGETS.add_binary(
        "db_stress", ["db_stress_tool/db_stress.cc"], [":rocksdb_stress_lib"]
    )
-    # db_bench binary
-    BUCK.add_binary(
-        "db_bench", ["tools/db_bench.cc"], [":rocksdb_tools_lib"]
-    )
    # cache_bench binary
-    BUCK.add_binary(
+    TARGETS.add_binary(
        "cache_bench", ["cache/cache_bench.cc"], [":rocksdb_cache_bench_tools_lib"]
    )
    # bench binaries
    for src in src_mk.get("MICROBENCH_SOURCES", []):
        name = src.rsplit("/", 1)[1].split(".")[0] if "/" in src else src.split(".")[0]
-        BUCK.add_binary(name, [src], [], extra_bench_libs=True)
-    print(f"Extra dependencies:\n{json.dumps(deps_map)}")
+        TARGETS.add_binary(name, [src], [], extra_bench_libs=True)
+    print("Extra dependencies:\n{0}".format(json.dumps(deps_map)))

    # Dictionary test executable name -> relative source file path
    test_source_map = {}

-    # c_test.c is added through BUCK.add_c_test(). If there
+    # c_test.c is added through TARGETS.add_c_test(). If there
    # are more than one .c test file, we need to extend
-    # BUCK.add_c_test() to include other C tests too.
+    # TARGETS.add_c_test() to include other C tests too.
    for test_src in src_mk.get("TEST_MAIN_SOURCES_C", []):
        if test_src != "db/c_test.c":
            print("Don't know how to deal with " + test_src)
            return False
-    BUCK.add_c_test()
+    TARGETS.add_c_test()

    try:
        with open(f"{repo_path}/buckifier/bench.json") as json_file:
@@ -260,7 +236,7 @@ def generate_buck(repo_path, deps_map):
                        for metric in overloaded_metric_list:
                            if not isinstance(metric, dict):
                                clean_benchmarks[binary][benchmark].append(metric)
-                BUCK.add_fancy_bench_config(
+                TARGETS.add_fancy_bench_config(
                    config_dict["name"],
                    clean_benchmarks,
                    False,
@@ -282,7 +258,7 @@ def generate_buck(repo_path, deps_map):
                            if not isinstance(metric, dict):
                                clean_benchmarks[binary][benchmark].append(metric)
            for config_dict in slow_fancy_bench_config_list:
-                BUCK.add_fancy_bench_config(
+                TARGETS.add_fancy_bench_config(
                    config_dict["name"] + "_slow",
                    clean_benchmarks,
                    True,
@@ -295,20 +271,15 @@ def generate_buck(repo_path, deps_map):
    except Exception:
        pass

-    BUCK.add_test_header()
+    TARGETS.add_test_header()

    for test_src in src_mk.get("TEST_MAIN_SOURCES", []):
        test = test_src.split(".c")[0].strip().split("/")[-1].strip()
-        test_source_map[test] = (test_src, False)
+        test_source_map[test] = test_src
        print("" + test + " " + test_src)

-    for test_src in src_mk.get("WITH_FAISS_TEST_MAIN_SOURCES", []):
-        test = test_src.split(".c")[0].strip().split("/")[-1].strip()
-        test_source_map[test] = (test_src, True)
-        print("" + test + " " + test_src + " [FAISS]")
-
    for target_alias, deps in deps_map.items():
-        for test, (test_src, with_faiss) in sorted(test_source_map.items()):
+        for test, test_src in sorted(test_source_map.items()):
            if len(test) == 0:
                print(ColorString.warning("Failed to get test name for %s" % test_src))
                continue
@@ -317,39 +288,31 @@ def generate_buck(repo_path, deps_map):

            if test in _EXPORTED_TEST_LIBS:
                test_library = "%s_lib" % test_target_name
-                BUCK.add_library(
+                TARGETS.add_library(
                    test_library,
                    [test_src],
                    deps=[":rocksdb_test_lib"],
                    extra_test_libs=True,
                )
-                BUCK.register_test(
+                TARGETS.register_test(
                    test_target_name,
                    test_src,
                    deps=json.dumps(deps["extra_deps"] + [":" + test_library]),
                    extra_compiler_flags=json.dumps(deps["extra_compiler_flags"]),
                )
            else:
-                if with_faiss:
-                    BUCK.register_test(
-                        test_target_name,
-                        test_src,
-                        deps=json.dumps(deps["extra_deps"] + [":rocksdb_with_faiss_test_lib"]),
-                        extra_compiler_flags=json.dumps(deps["extra_compiler_flags"]),
-                    )
-                else:
-                    BUCK.register_test(
-                        test_target_name,
-                        test_src,
-                        deps=json.dumps(deps["extra_deps"] + [":rocksdb_test_lib"]),
-                        extra_compiler_flags=json.dumps(deps["extra_compiler_flags"]),
-                    )
-    BUCK.export_file("tools/db_crashtest.py")
+                TARGETS.register_test(
+                    test_target_name,
+                    test_src,
+                    deps=json.dumps(deps["extra_deps"] + [":rocksdb_test_lib"]),
+                    extra_compiler_flags=json.dumps(deps["extra_compiler_flags"]),
+                )
+    TARGETS.export_file("tools/db_crashtest.py")

-    print(ColorString.info("Generated BUCK Summary:"))
-    print(ColorString.info("- %d libs" % BUCK.total_lib))
-    print(ColorString.info("- %d binarys" % BUCK.total_bin))
-    print(ColorString.info("- %d tests" % BUCK.total_test))
+    print(ColorString.info("Generated TARGETS Summary:"))
+    print(ColorString.info("- %d libs" % TARGETS.total_lib))
+    print(ColorString.info("- %d binarys" % TARGETS.total_bin))
+    print(ColorString.info("- %d tests" % TARGETS.total_test))
    return True


@@ -369,10 +332,10 @@ def exit_with_error(msg):

 def main():
    deps_map = get_dependencies()
-    # Generate BUCK file for buck
-    ok = generate_buck(get_rocksdb_path(), deps_map)
+    # Generate TARGETS file for buck
+    ok = generate_targets(get_rocksdb_path(), deps_map)
    if not ok:
-        exit_with_error("Failed to generate BUCK files")
+        exit_with_error("Failed to generate TARGETS files")


 if __name__ == "__main__":
@@ -1,44 +1,32 @@
 #!/usr/bin/env bash
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+# If clang_format_diff.py command is not specfied, we assume we are able to
+# access directly without any path.

-if [[ ! -f "BUCK" ]]
-then
-  echo "BUCK file is missing!"
-  echo "Please do not remove / rename BUCK file in your commit(s)."
-  exit 1
-fi
-
-TGT_DIFF=`git diff BUCK | head -n 1`
+TGT_DIFF=`git diff TARGETS | head -n 1`

 if [ ! -z "$TGT_DIFF" ]
 then
-  echo "BUCK file has uncommitted changes. Skip this check."
+  echo "TARGETS file has uncommitted changes. Skip this check."
  exit 0
 fi

-echo Backup original BUCK file.
+echo Backup original TARGETS file.

-cp BUCK BUCK.bkp
+cp TARGETS TARGETS.bkp

 ${PYTHON:-python3} buckifier/buckify_rocksdb.py

-if [[ ! -f "BUCK" ]]
-then
-  echo "BUCK file went missing after running buckifier/buckify_rocksdb.py!"
-  echo "Please do not remove the BUCK file."
-  exit 1
-fi
-
-TGT_DIFF=`git diff BUCK | head -n 1`
+TGT_DIFF=`git diff TARGETS | head -n 1`

 if [ -z "$TGT_DIFF" ]
 then
-  mv BUCK.bkp BUCK
+  mv TARGETS.bkp TARGETS
  exit 0
 else
-  echo "Please run '${PYTHON:-python3} buckifier/buckify_rocksdb.py' to update BUCK file."
-  echo "Do not manually update BUCK file."
+  echo "Please run '${PYTHON:-python3} buckifier/buckify_rocksdb.py' to update TARGETS file."
+  echo "Do not manually update TARGETS file."
  ${PYTHON:-python3} --version
-  mv BUCK.bkp BUCK
+  mv TARGETS.bkp TARGETS
  exit 1
 fi
@@ -1,4 +1,5 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+from __future__ import absolute_import, division, print_function, unicode_literals

 try:
    from builtins import object, str
@@ -8,28 +9,17 @@ import pprint

 import targets_cfg

-class LiteralValue:
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return str(self.value)
-
-def smart_quote_value(val):
-    if isinstance(val, LiteralValue):
-        return str(val)
-    return '"%s"' % val

 def pretty_list(lst, indent=8):
    if lst is None or len(lst) == 0:
        return ""

    if len(lst) == 1:
-        return smart_quote_value(lst[0])
+        return '"%s"' % lst[0]

-    separator = ',\n%s' % (" " * indent)
-    res = separator.join(sorted(map(smart_quote_value, lst)))
-    res = "\n" + (" " * indent) + res + ',\n' + (" " * (indent - 4))
+    separator = '",\n%s"' % (" " * indent)
+    res = separator.join(sorted(lst))
+    res = "\n" + (" " * indent) + '"' + res + '",\n' + (" " * (indent - 4))
    return res


@@ -58,12 +48,7 @@ class TARGETSBuilder:
        extra_test_libs=False,
    ):
        if headers is not None:
-            if isinstance(headers, LiteralValue):
-                headers = str(headers)
-            else:
-                headers = "[" + pretty_list(headers) + "]"
-        else:
-            headers = "[]"
+            headers = "[" + pretty_list(headers) + "]"
        with open(self.path, "ab") as targets_file:
            targets_file.write(
                targets_cfg.library_template.format(
@@ -80,7 +65,8 @@ class TARGETSBuilder:
        self.total_lib = self.total_lib + 1

    def add_rocksdb_library(self, name, srcs, headers=None, external_dependencies=None):
-        headers = "[" + pretty_list(headers) + "]"
+        if headers is not None:
+            headers = "[" + pretty_list(headers) + "]"
        with open(self.path, "ab") as targets_file:
            targets_file.write(
                targets_cfg.rocksdb_library_template.format(
@@ -1,4 +1,5 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+from __future__ import absolute_import, division, print_function, unicode_literals

 rocksdb_target_header_template = """# This file \100generated by:
 #$ python3 buckifier/buckify_rocksdb.py{extra_argv}
@@ -2,6 +2,7 @@
 """
 This module keeps commonly used components.
 """
+from __future__ import absolute_import, division, print_function, unicode_literals

 try:
    from builtins import object
@@ -25,6 +25,7 @@
 #
 # The solution is to move the include out of the #ifdef.

+from __future__ import print_function

 import argparse
 import re
@@ -61,7 +62,7 @@ def expand_include(

    included.add(include_path)
    with open(include_path) as f:
-        print(f'#line 1 "{include_path}"', file=source_out)
+        print('#line 1 "{}"'.format(include_path), file=source_out)
        process_file(
            f, include_path, source_out, header_out, include_paths, public_include_paths
        )
@@ -117,7 +118,7 @@ def process_file(
                    )

            if expanded:
-                print(f'#line {line + 1} "{abs_path}"', file=source_out)
+                print('#line {} "{}"'.format(line + 1, abs_path), file=source_out)
        elif text != "#pragma once\n":
            source_out.write(text)

@@ -156,8 +157,8 @@ def main():
    with open(filename) as f, open(args.source_out, "w") as source_out, open(
        args.header_out, "w"
    ) as header_out:
-        print(f'#line 1 "{filename}"', file=source_out)
-        print(f'#include "{header_out.name}"', file=source_out)
+        print('#line 1 "{}"'.format(filename), file=source_out)
+        print('#include "{}"'.format(header_out.name), file=source_out)
        process_file(
            f, abs_path, source_out, header_out, include_paths, public_include_paths
        )
@@ -102,7 +102,7 @@ class BenchmarkUtils:


 class ResultParser:
-    def __init__(self, field=r"(\w|[+-:.%])+", intrafield=r"(\s)+", separator="\t"):
+    def __init__(self, field="(\w|[+-:.%])+", intrafield="(\s)+", separator="\t"):
        self.field = re.compile(field)
        self.intra = re.compile(intrafield)
        self.sep = re.compile(separator)
@@ -159,7 +159,7 @@ class ResultParser:


 def load_report_from_tsv(filename: str):
-    file = open(filename)
+    file = open(filename, "r")
    contents = file.readlines()
    file.close()
    parser = ResultParser()
@@ -9,6 +9,7 @@
    - Prints those error messages to stdout
 """

+from __future__ import absolute_import, division, print_function, unicode_literals

 import re
 import sys
@@ -42,7 +43,7 @@ class GTestErrorParser(ErrorParserBase):
            return None
        gtest_fail_match = self._GTEST_FAIL_PATTERN.match(line)
        if gtest_fail_match:
-            return "{} failed: {}".format(self._last_gtest_name, gtest_fail_match.group(1))
+            return "%s failed: %s" % (self._last_gtest_name, gtest_fail_match.group(1))
        return None


@@ -65,52 +66,52 @@ class CompilerErrorParser(MatchErrorParser):
        # format (link error):
        #   '<filename>:<line #>: error: <error msg>'
        # The below regex catches both
-        super().__init__(r"\S+:\d+: error:")
+        super(CompilerErrorParser, self).__init__(r"\S+:\d+: error:")


 class ScanBuildErrorParser(MatchErrorParser):
    def __init__(self):
-        super().__init__(r"scan-build: \d+ bugs found.$")
+        super(ScanBuildErrorParser, self).__init__(r"scan-build: \d+ bugs found.$")


 class DbCrashErrorParser(MatchErrorParser):
    def __init__(self):
-        super().__init__(r"\*\*\*.*\^$|TEST FAILED.")
+        super(DbCrashErrorParser, self).__init__(r"\*\*\*.*\^$|TEST FAILED.")


 class WriteStressErrorParser(MatchErrorParser):
    def __init__(self):
-        super().__init__(
+        super(WriteStressErrorParser, self).__init__(
            r"ERROR: write_stress died with exitcode=\d+"
        )


 class AsanErrorParser(MatchErrorParser):
    def __init__(self):
-        super().__init__(r"==\d+==ERROR: AddressSanitizer:")
+        super(AsanErrorParser, self).__init__(r"==\d+==ERROR: AddressSanitizer:")


 class UbsanErrorParser(MatchErrorParser):
    def __init__(self):
        # format: '<filename>:<line #>:<column #>: runtime error: <error msg>'
-        super().__init__(r"\S+:\d+:\d+: runtime error:")
+        super(UbsanErrorParser, self).__init__(r"\S+:\d+:\d+: runtime error:")


 class ValgrindErrorParser(MatchErrorParser):
    def __init__(self):
        # just grab the summary, valgrind doesn't clearly distinguish errors
        # from other log messages.
-        super().__init__(r"==\d+== ERROR SUMMARY:")
+        super(ValgrindErrorParser, self).__init__(r"==\d+== ERROR SUMMARY:")


 class CompatErrorParser(MatchErrorParser):
    def __init__(self):
-        super().__init__(r"==== .*[Ee]rror.* ====$")
+        super(CompatErrorParser, self).__init__(r"==== .*[Ee]rror.* ====$")


 class TsanErrorParser(MatchErrorParser):
    def __init__(self):
-        super().__init__(r"WARNING: ThreadSanitizer:")
+        super(TsanErrorParser, self).__init__(r"WARNING: ThreadSanitizer:")


 _TEST_NAME_TO_PARSERS = {
@@ -133,25 +133,19 @@ Status Cache::CreateFromString(const ConfigOptions& config_options,
                               std::shared_ptr<Cache>* result) {
  Status status;
  std::shared_ptr<Cache> cache;
-  if (StartsWith(value, "null")) {
-    cache = nullptr;
-  } else if (value.find("://") == std::string::npos) {
-    if (value.find('=') == std::string::npos) {
-      cache = NewLRUCache(ParseSizeT(value));
-    } else {
-      LRUCacheOptions cache_opts;
-      status = OptionTypeInfo::ParseStruct(config_options, "",
-                                           &lru_cache_options_type_info, "",
-                                           value, &cache_opts);
-      if (status.ok()) {
-        cache = NewLRUCache(cache_opts);
-      }
-    }
-    if (status.ok()) {
-      result->swap(cache);
-    }
+  if (value.find('=') == std::string::npos) {
+    cache = NewLRUCache(ParseSizeT(value));
  } else {
-    status = LoadSharedObject<Cache>(config_options, value, result);
+    LRUCacheOptions cache_opts;
+    status = OptionTypeInfo::ParseStruct(config_options, "",
+                                         &lru_cache_options_type_info, "",
+                                         value, &cache_opts);
+    if (status.ok()) {
+      cache = NewLRUCache(cache_opts);
+    }
+  }
+  if (status.ok()) {
+    result->swap(cache);
  }
  return status;
 }
@@ -886,32 +886,6 @@ TEST_P(CacheTest, ApplyToAllEntriesDuringResize) {
  ASSERT_EQ(special_count, kSpecialCount);
 }

-TEST_P(CacheTest, ApplyToHandleTest) {
-  std::string callback_state;
-  const auto callback = [&](const Slice& key, Cache::ObjectPtr value,
-                            size_t charge,
-                            const Cache::CacheItemHelper* helper) {
-    callback_state = std::to_string(DecodeKey(key)) + "," +
-                     std::to_string(DecodeValue(value)) + "," +
-                     std::to_string(charge);
-    assert(helper == &CacheTest::kHelper);
-  };
-
-  std::vector<std::string> inserted;
-
-  for (int i = 0; i < 10; ++i) {
-    Insert(i, i * 2, i + 1);
-    inserted.push_back(std::to_string(i) + "," + std::to_string(i * 2) + "," +
-                       std::to_string(i + 1));
-  }
-  for (int i = 0; i < 10; ++i) {
-    Cache::Handle* handle = cache_->Lookup(EncodeKey(i));
-    cache_->ApplyToHandle(cache_.get(), handle, callback);
-    EXPECT_EQ(inserted[i], callback_state);
-    cache_->Release(handle);
-  }
-}
-
 TEST_P(CacheTest, DefaultShardBits) {
  // Prevent excessive allocation (to save time & space)
  estimated_value_size_ = 100000;
@@ -1444,22 +1444,6 @@ const Cache::CacheItemHelper* BaseHyperClockCache<Table>::GetCacheItemHelper(
  return h->helper;
 }

-template <class Table>
-void BaseHyperClockCache<Table>::ApplyToHandle(
-    Cache* cache, Handle* handle,
-    const std::function<void(const Slice& key, Cache::ObjectPtr value,
-                             size_t charge, const CacheItemHelper* helper)>&
-        callback) {
-  BaseHyperClockCache<Table>* cache_ptr =
-      static_cast<BaseHyperClockCache<Table>*>(cache);
-  auto h = static_cast<const typename Table::HandleImpl*>(handle);
-  UniqueId64x2 unhashed;
-  auto hash_seed = cache_ptr->GetShard(h->GetHash()).GetTable().GetHashSeed();
-  callback(
-      ClockCacheShard<Table>::ReverseHash(h->hashed_key, &unhashed, hash_seed),
-      h->value, h->GetTotalCharge(), h->helper);
-}
-
 namespace {

 // For each cache shard, estimate what the table load factor would be if
@@ -1128,12 +1128,6 @@ class BaseHyperClockCache : public ShardedCache<ClockCacheShard<Table>> {

  const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override;

-  void ApplyToHandle(
-      Cache* cache, Handle* handle,
-      const std::function<void(const Slice& key, Cache::ObjectPtr obj,
-                               size_t charge, const CacheItemHelper* helper)>&
-          callback) override;
-
  void ReportProblems(
      const std::shared_ptr<Logger>& /*info_log*/) const override;
 };
@@ -79,11 +79,7 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
    data_ptr = GetVarint32Ptr(data_ptr, data_ptr + 1,
                              static_cast<uint32_t*>(&source_32));
    source = static_cast<CacheTier>(source_32);
-    uint64_t data_size = 0;
-    data_ptr = GetVarint64Ptr(data_ptr, ptr->get() + handle_value_charge,
-                              static_cast<uint64_t*>(&data_size));
-    assert(handle_value_charge > data_size);
-    handle_value_charge = data_size;
+    handle_value_charge -= (data_ptr - ptr->get());
  }
  MemoryAllocator* allocator = cache_options_.memory_allocator.get();

@@ -173,15 +169,13 @@ Status CompressedSecondaryCache::InsertInternal(
  }

  auto internal_helper = GetHelper(cache_options_.enable_custom_split_merge);
-  char header[20];
+  char header[10];
  char* payload = header;
  payload = EncodeVarint32(payload, static_cast<uint32_t>(type));
  payload = EncodeVarint32(payload, static_cast<uint32_t>(source));
-  size_t data_size = (*helper->size_cb)(value);
-  char* data_size_ptr = payload;
-  payload = EncodeVarint64(payload, data_size);

  size_t header_size = payload - header;
+  size_t data_size = (*helper->size_cb)(value);
  size_t total_size = data_size + header_size;
  CacheAllocationPtr ptr =
      AllocateBlock(total_size, cache_options_.memory_allocator.get());
@@ -216,8 +210,6 @@ Status CompressedSecondaryCache::InsertInternal(

    val = Slice(compressed_val);
    data_size = compressed_val.size();
-    payload = EncodeVarint64(data_size_ptr, data_size);
-    header_size = payload - header;
    total_size = header_size + data_size;
    PERF_COUNTER_ADD(compressed_sec_cache_compressed_bytes, data_size);

@@ -230,21 +222,14 @@ Status CompressedSecondaryCache::InsertInternal(

  PERF_COUNTER_ADD(compressed_sec_cache_insert_real_count, 1);
  if (cache_options_.enable_custom_split_merge) {
-    size_t split_charge{0};
-    CacheValueChunk* value_chunks_head = SplitValueIntoChunks(
-        val, cache_options_.compression_type, split_charge);
-    return cache_->Insert(key, value_chunks_head, internal_helper,
-                          split_charge);
+    size_t charge{0};
+    CacheValueChunk* value_chunks_head =
+        SplitValueIntoChunks(val, cache_options_.compression_type, charge);
+    return cache_->Insert(key, value_chunks_head, internal_helper, charge);
  } else {
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-    size_t charge = malloc_usable_size(ptr.get());
-#else
-    size_t charge = total_size;
-#endif
    std::memcpy(ptr.get(), header, header_size);
    CacheAllocationPtr* buf = new CacheAllocationPtr(std::move(ptr));
-    charge += sizeof(CacheAllocationPtr);
-    return cache_->Insert(key, buf, internal_helper, charge);
+    return cache_->Insert(key, buf, internal_helper, total_size);
  }
 }

@@ -413,21 +398,6 @@ const Cache::CacheItemHelper* CompressedSecondaryCache::GetHelper(
  }
 }

-size_t CompressedSecondaryCache::TEST_GetCharge(const Slice& key) {
-  Cache::Handle* lru_handle = cache_->Lookup(key);
-  if (lru_handle == nullptr) {
-    return 0;
-  }
-
-  size_t charge = cache_->GetCharge(lru_handle);
-  if (cache_->Value(lru_handle) != nullptr &&
-      !cache_options_.enable_custom_split_merge) {
-    charge -= 10;
-  }
-  cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-  return charge;
-}
-
 std::shared_ptr<SecondaryCache>
 CompressedSecondaryCacheOptions::MakeSharedSecondaryCache() const {
  return std::make_shared<CompressedSecondaryCache>(*this);
@@ -139,8 +139,6 @@ class CompressedSecondaryCache : public SecondaryCache {
                        const Cache::CacheItemHelper* helper,
                        CompressionType type, CacheTier source);

-  size_t TEST_GetCharge(const Slice& key);
-
  // TODO: clean up to use cleaner interfaces in typed_cache.h
  const Cache::CacheItemHelper* GetHelper(bool enable_custom_split_merge) const;
  std::shared_ptr<Cache> cache_;
@@ -39,8 +39,6 @@ class CompressedSecondaryCacheTestBase : public testing::Test,
 protected:
  void BasicTestHelper(std::shared_ptr<SecondaryCache> sec_cache,
                       bool sec_cache_is_compressed) {
-    CompressedSecondaryCache* comp_sec_cache =
-        static_cast<CompressedSecondaryCache*>(sec_cache.get());
    get_perf_context()->Reset();
    bool kept_in_sec_cache{true};
    // Lookup an non-existent key.
@@ -68,8 +66,6 @@ class CompressedSecondaryCacheTestBase : public testing::Test,
    ASSERT_OK(sec_cache->Insert(key1, &item1, GetHelper(), false));
    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 1);

-    ASSERT_GT(comp_sec_cache->TEST_GetCharge(key1), 1000);
-
    std::unique_ptr<SecondaryCacheResultHandle> handle1_2 =
        sec_cache->Lookup(key1, GetHelper(), this, true, /*advise_erase=*/true,
                          /*stats=*/nullptr, kept_in_sec_cache);
@@ -677,17 +677,6 @@ const Cache::CacheItemHelper* LRUCache::GetCacheItemHelper(
  return h->helper;
 }

-void LRUCache::ApplyToHandle(
-    Cache* cache, Handle* handle,
-    const std::function<void(const Slice& key, ObjectPtr value, size_t charge,
-                             const CacheItemHelper* helper)>& callback) {
-  auto cache_ptr = static_cast<LRUCache*>(cache);
-  auto h = static_cast<const LRUHandle*>(handle);
-  callback(h->key(), h->value,
-           h->GetCharge(cache_ptr->GetShard(0).metadata_charge_policy_),
-           h->helper);
-}
-
 size_t LRUCache::TEST_GetLRUSize() {
  return SumOverShards([](LRUCacheShard& cs) { return cs.TEST_GetLRUSize(); });
 }
@@ -452,12 +452,6 @@ class LRUCache
  size_t GetCharge(Handle* handle) const override;
  const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override;

-  void ApplyToHandle(
-      Cache* cache, Handle* handle,
-      const std::function<void(const Slice& key, ObjectPtr obj, size_t charge,
-                               const CacheItemHelper* helper)>& callback)
-      override;
-
  // Retrieves number of elements in LRU, for unit test purpose only.
  size_t TEST_GetLRUSize();
  // Retrieves high pri pool ratio.
@@ -271,8 +271,7 @@ Status CacheWithSecondaryAdapter::Insert(const Slice& key, ObjectPtr value,
  // Warm up the secondary cache with the compressed block. The secondary
  // cache may choose to ignore it based on the admission policy.
  if (value != nullptr && !compressed_value.empty() &&
-      adm_policy_ == TieredAdmissionPolicy::kAdmPolicyThreeQueue &&
-      helper->IsSecondaryCacheCompatible()) {
+      adm_policy_ == TieredAdmissionPolicy::kAdmPolicyThreeQueue) {
    Status status = secondary_cache_->InsertSaved(key, compressed_value, type);
    assert(status.ok() || status.IsNotSupported());
  }
@@ -253,7 +253,6 @@ TEST_F(DBTieredSecondaryCacheTest, BasicTest) {
  table_options.cache_index_and_filter_blocks = false;
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  // Disable paranoid_file_checks so that flush will not read back the newly
@@ -365,7 +364,6 @@ TEST_F(DBTieredSecondaryCacheTest, BasicMultiGetTest) {
  table_options.cache_index_and_filter_blocks = false;
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  options.paranoid_file_checks = false;
@@ -508,7 +506,6 @@ TEST_F(DBTieredSecondaryCacheTest, WaitAllTest) {
  table_options.cache_index_and_filter_blocks = false;
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  options.paranoid_file_checks = false;
@@ -609,7 +606,6 @@ TEST_F(DBTieredSecondaryCacheTest, ReadyBeforeWaitAllTest) {
  table_options.cache_index_and_filter_blocks = false;
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  options.statistics = CreateDBStatistics();

@@ -721,7 +717,6 @@ TEST_F(DBTieredSecondaryCacheTest, IterateTest) {
  table_options.cache_index_and_filter_blocks = false;
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  options.paranoid_file_checks = false;
@@ -765,54 +760,6 @@ TEST_F(DBTieredSecondaryCacheTest, IterateTest) {
  Destroy(options);
 }

-TEST_F(DBTieredSecondaryCacheTest, VolatileTierTest) {
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  BlockBasedTableOptions table_options;
-  // We want a block cache of size 5KB, and a compressed secondary cache of
-  // size 5KB. However, we specify a block cache size of 256KB here in order
-  // to take into account the cache reservation in the block cache on
-  // behalf of the compressed cache. The unit of cache reservation is 256KB.
-  // The effective block cache capacity will be calculated as 256 + 5 = 261KB,
-  // and 256KB will be reserved for the compressed cache, leaving 5KB for
-  // the primary block cache. We only have to worry about this here because
-  // the cache size is so small.
-  table_options.block_cache = NewCache(256 * 1024, 5 * 1024, 256 * 1024);
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-  // Disable paranoid_file_checks so that flush will not read back the newly
-  // written file
-  options.paranoid_file_checks = false;
-  options.lowest_used_cache_tier = CacheTier::kVolatileTier;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  // Since lowest_used_cache_tier is the volatile tier, nothing should be
-  // inserted in the secondary cache.
-  std::string v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 0u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 0u);
-
-  Destroy(options);
-}
-
 class DBTieredAdmPolicyTest
    : public DBTieredSecondaryCacheTest,
      public testing::WithParamInterface<TieredAdmissionPolicy> {};
@@ -837,7 +784,6 @@ TEST_P(DBTieredAdmPolicyTest, CompressedOnlyTest) {
  table_options.cache_index_and_filter_blocks = false;
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  size_t comp_cache_usage = compressed_secondary_cache()->TEST_GetUsage();
@@ -890,7 +836,6 @@ TEST_P(DBTieredAdmPolicyTest, CompressedCacheAdmission) {
  table_options.cache_index_and_filter_blocks = false;
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  size_t comp_cache_usage = compressed_secondary_cache()->TEST_GetUsage();
@@ -992,7 +937,6 @@ TEST_F(DBTieredSecondaryCacheTest, FSBufferTest) {
  table_options.cache_index_and_filter_blocks = false;
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  options.statistics = CreateDBStatistics();
  options.env = wrap_env.get();
@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.

+from __future__ import print_function

 import optparse
 import re
@@ -108,11 +109,11 @@ def report_coverage():

    # Check if we need to display coverage info for interested files.
    if len(interested_files):
-        per_file_coverage = {
-            fname: per_file_coverage[fname]
+        per_file_coverage = dict(
+            (fname, per_file_coverage[fname])
            for fname in interested_files
            if fname in per_file_coverage
-        }
+        )
        # If we only interested in several files, it makes no sense to report
        # the total_coverage
        total_coverage = None
@@ -45,23 +45,20 @@ void ArenaWrappedDBIter::Init(
    const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iteration,
    uint64_t version_number, ReadCallback* read_callback,
    ColumnFamilyHandleImpl* cfh, bool expose_blob_index, bool allow_refresh) {
+  auto mem = arena_.AllocateAligned(sizeof(DBIter));
+  db_iter_ = new (mem) DBIter(
+      env, read_options, ioptions, mutable_cf_options, ioptions.user_comparator,
+      /* iter */ nullptr, version, sequence, true,
+      max_sequential_skip_in_iteration, read_callback, cfh, expose_blob_index);
+  sv_number_ = version_number;
  read_options_ = read_options;
+  allow_refresh_ = allow_refresh;
+  memtable_range_tombstone_iter_ = nullptr;
+
  if (!CheckFSFeatureSupport(env->GetFileSystem().get(),
                             FSSupportedOps::kAsyncIO)) {
    read_options_.async_io = false;
  }
-  read_options_.total_order_seek |= ioptions.prefix_seek_opt_in_only;
-
-  auto mem = arena_.AllocateAligned(sizeof(DBIter));
-  db_iter_ = new (mem) DBIter(env, read_options_, ioptions, mutable_cf_options,
-                              ioptions.user_comparator,
-                              /* iter */ nullptr, version, sequence, true,
-                              max_sequential_skip_in_iteration, read_callback,
-                              cfh, expose_blob_index);
-
-  sv_number_ = version_number;
-  allow_refresh_ = allow_refresh;
-  memtable_range_tombstone_iter_ = nullptr;
 }

 Status ArenaWrappedDBIter::Refresh() { return Refresh(nullptr); }
@@ -83,8 +83,6 @@ class ArenaWrappedDBIter : public Iterator {
  Status Refresh() override;
  Status Refresh(const Snapshot*) override;

-  bool PrepareValue() override { return db_iter_->PrepareValue(); }
-
  void Init(Env* env, const ReadOptions& read_options,
            const ImmutableOptions& ioptions,
            const MutableCFOptions& mutable_cf_options, const Version* version,
@@ -13,11 +13,14 @@ namespace ROCKSDB_NAMESPACE {
 class AttributeGroupIteratorImpl : public AttributeGroupIterator {
 public:
  AttributeGroupIteratorImpl(
-      const ReadOptions& read_options, const Comparator* comparator,
-      std::vector<std::pair<ColumnFamilyHandle*, std::unique_ptr<Iterator>>>&&
-          cfh_iter_pairs)
-      : impl_(read_options, comparator, std::move(cfh_iter_pairs),
-              ResetFunc(this), PopulateFunc(this)) {}
+      const Comparator* comparator,
+      const std::vector<ColumnFamilyHandle*>& column_families,
+      const std::vector<Iterator*>& child_iterators)
+      : impl_(
+            comparator, column_families, child_iterators, [this]() { Reset(); },
+            [this](const autovector<MultiCfIteratorInfo>& items) {
+              AddToAttributeGroups(items);
+            }) {}
  ~AttributeGroupIteratorImpl() override {}

  // No copy allowed
@@ -42,36 +45,8 @@ class AttributeGroupIteratorImpl : public AttributeGroupIterator {

  void Reset() { attribute_groups_.clear(); }

-  bool PrepareValue() override { return impl_.PrepareValue(); }
-
 private:
-  class ResetFunc {
-   public:
-    explicit ResetFunc(AttributeGroupIteratorImpl* iter) : iter_(iter) {}
-
-    void operator()() const {
-      assert(iter_);
-      iter_->Reset();
-    }
-
-   private:
-    AttributeGroupIteratorImpl* iter_;
-  };
-
-  class PopulateFunc {
-   public:
-    explicit PopulateFunc(AttributeGroupIteratorImpl* iter) : iter_(iter) {}
-
-    void operator()(const autovector<MultiCfIteratorInfo>& items) const {
-      assert(iter_);
-      iter_->AddToAttributeGroups(items);
-    }
-
-   private:
-    AttributeGroupIteratorImpl* iter_;
-  };
-
-  MultiCfIteratorImpl<ResetFunc, PopulateFunc> impl_;
+  MultiCfIteratorImpl impl_;
  IteratorAttributeGroups attribute_groups_;
  void AddToAttributeGroups(const autovector<MultiCfIteratorInfo>& items);
 };
@@ -20,24 +20,23 @@

 namespace ROCKSDB_NAMESPACE {

-BlobSource::BlobSource(const ImmutableOptions& immutable_options,
-                       const MutableCFOptions& mutable_cf_options,
+BlobSource::BlobSource(const ImmutableOptions* immutable_options,
                       const std::string& db_id,
                       const std::string& db_session_id,
                       BlobFileCache* blob_file_cache)
    : db_id_(db_id),
      db_session_id_(db_session_id),
-      statistics_(immutable_options.statistics.get()),
+      statistics_(immutable_options->statistics.get()),
      blob_file_cache_(blob_file_cache),
-      blob_cache_(immutable_options.blob_cache),
-      lowest_used_cache_tier_(immutable_options.lowest_used_cache_tier) {
+      blob_cache_(immutable_options->blob_cache),
+      lowest_used_cache_tier_(immutable_options->lowest_used_cache_tier) {
  auto bbto =
-      mutable_cf_options.table_factory->GetOptions<BlockBasedTableOptions>();
+      immutable_options->table_factory->GetOptions<BlockBasedTableOptions>();
  if (bbto &&
      bbto->cache_usage_options.options_overrides.at(CacheEntryRole::kBlobCache)
              .charged == CacheEntryRoleOptions::Decision::kEnabled) {
    blob_cache_ = SharedCacheInterface{std::make_shared<ChargedCache>(
-        immutable_options.blob_cache, bbto->block_cache)};
+        immutable_options->blob_cache, bbto->block_cache)};
  }
 }

@@ -21,7 +21,6 @@
 namespace ROCKSDB_NAMESPACE {

 struct ImmutableOptions;
-struct MutableCFOptions;
 class Status;
 class FilePrefetchBuffer;
 class Slice;
@@ -32,10 +31,7 @@ class Slice;
 // storage with minimal cost.
 class BlobSource {
 public:
-  // NOTE: db_id, db_session_id, and blob_file_cache are saved by reference or
-  // pointer.
-  BlobSource(const ImmutableOptions& immutable_options,
-             const MutableCFOptions& mutable_cf_options,
+  BlobSource(const ImmutableOptions* immutable_options,
             const std::string& db_id, const std::string& db_session_id,
             BlobFileCache* blob_file_cache);

@@ -148,7 +148,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
  DestroyAndReopen(options_);

  ImmutableOptions immutable_options(options_);
-  MutableCFOptions mutable_cf_options(options_);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -194,8 +193,8 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
          backing_cache.get(), &immutable_options, &file_options,
          column_family_id, blob_file_read_hist, nullptr /*IOTracer*/);

-  BlobSource blob_source(immutable_options, mutable_cf_options, db_id_,
-                         db_session_id_, blob_file_cache.get());
+  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
+                         blob_file_cache.get());

  ReadOptions read_options;
  read_options.verify_checksums = true;
@@ -465,7 +464,6 @@ TEST_F(BlobSourceTest, GetCompressedBlobs) {
  DestroyAndReopen(options_);

  ImmutableOptions immutable_options(options_);
-  MutableCFOptions mutable_cf_options(options_);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -500,8 +498,8 @@ TEST_F(BlobSourceTest, GetCompressedBlobs) {
          backing_cache.get(), &immutable_options, &file_options,
          column_family_id, nullptr /*HistogramImpl*/, nullptr /*IOTracer*/);

-  BlobSource blob_source(immutable_options, mutable_cf_options, db_id_,
-                         db_session_id_, blob_file_cache.get());
+  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
+                         blob_file_cache.get());

  ReadOptions read_options;
  read_options.verify_checksums = true;
@@ -591,7 +589,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromMultiFiles) {
  DestroyAndReopen(options_);

  ImmutableOptions immutable_options(options_);
-  MutableCFOptions mutable_cf_options(options_);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -647,8 +644,8 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromMultiFiles) {
          backing_cache.get(), &immutable_options, &file_options,
          column_family_id, blob_file_read_hist, nullptr /*IOTracer*/);

-  BlobSource blob_source(immutable_options, mutable_cf_options, db_id_,
-                         db_session_id_, blob_file_cache.get());
+  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
+                         blob_file_cache.get());

  ReadOptions read_options;
  read_options.verify_checksums = true;
@@ -785,7 +782,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
  DestroyAndReopen(options_);

  ImmutableOptions immutable_options(options_);
-  MutableCFOptions mutable_cf_options(options_);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -831,8 +827,8 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
          backing_cache.get(), &immutable_options, &file_options,
          column_family_id, blob_file_read_hist, nullptr /*IOTracer*/);

-  BlobSource blob_source(immutable_options, mutable_cf_options, db_id_,
-                         db_session_id_, blob_file_cache.get());
+  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
+                         blob_file_cache.get());

  ReadOptions read_options;
  read_options.verify_checksums = true;
@@ -1109,7 +1105,6 @@ TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
  DestroyAndReopen(options_);

  ImmutableOptions immutable_options(options_);
-  MutableCFOptions mutable_cf_options(options_);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -1142,8 +1137,8 @@ TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
      backing_cache.get(), &immutable_options, &file_options, column_family_id,
      blob_file_read_hist, nullptr /*IOTracer*/));

-  BlobSource blob_source(immutable_options, mutable_cf_options, db_id_,
-                         db_session_id_, blob_file_cache.get());
+  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
+                         blob_file_cache.get());

  CacheHandleGuard<BlobFileReader> file_reader;
  ReadOptions read_options;
@@ -1410,7 +1405,6 @@ TEST_F(BlobSourceCacheReservationTest, SimpleCacheReservation) {
  DestroyAndReopen(options_);

  ImmutableOptions immutable_options(options_);
-  MutableCFOptions mutable_cf_options(options_);

  constexpr ExpirationRange expiration_range;

@@ -1432,8 +1426,8 @@ TEST_F(BlobSourceCacheReservationTest, SimpleCacheReservation) {
          backing_cache.get(), &immutable_options, &file_options,
          kColumnFamilyId, blob_file_read_hist, nullptr /*IOTracer*/);

-  BlobSource blob_source(immutable_options, mutable_cf_options, db_id_,
-                         db_session_id_, blob_file_cache.get());
+  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
+                         blob_file_cache.get());

  ConcurrentCacheReservationManager* cache_res_mgr =
      static_cast<ChargedCache*>(blob_source.GetBlobCache())
@@ -1525,8 +1519,6 @@ TEST_F(BlobSourceCacheReservationTest, IncreaseCacheReservation) {
  DestroyAndReopen(options_);

  ImmutableOptions immutable_options(options_);
-  MutableCFOptions mutable_cf_options(options_);
-
  constexpr size_t blob_size = 24 << 10;  // 24KB
  for (size_t i = 0; i < kNumBlobs; ++i) {
    blob_file_size_ -= blobs_[i].size();  // old blob size
@@ -1554,8 +1546,8 @@ TEST_F(BlobSourceCacheReservationTest, IncreaseCacheReservation) {
          backing_cache.get(), &immutable_options, &file_options,
          kColumnFamilyId, blob_file_read_hist, nullptr /*IOTracer*/);

-  BlobSource blob_source(immutable_options, mutable_cf_options, db_id_,
-                         db_session_id_, blob_file_cache.get());
+  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
+                         blob_file_cache.get());

  ConcurrentCacheReservationManager* cache_res_mgr =
      static_cast<ChargedCache*>(blob_source.GetBlobCache())
@@ -374,115 +374,6 @@ TEST_F(DBBlobBasicTest, IterateBlobsFromCachePinning) {
  }
 }

-TEST_F(DBBlobBasicTest, IterateBlobsAllowUnpreparedValue) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-
-  Reopen(options);
-
-  constexpr size_t num_blobs = 5;
-  std::vector<std::string> keys;
-  std::vector<std::string> blobs;
-
-  for (size_t i = 0; i < num_blobs; ++i) {
-    keys.emplace_back("key" + std::to_string(i));
-    blobs.emplace_back("blob" + std::to_string(i));
-    ASSERT_OK(Put(keys[i], blobs[i]));
-  }
-
-  ASSERT_OK(Flush());
-
-  ReadOptions read_options;
-  read_options.allow_unprepared_value = true;
-
-  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
-
-  {
-    size_t i = 0;
-
-    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-      ASSERT_EQ(iter->key(), keys[i]);
-      ASSERT_TRUE(iter->value().empty());
-      ASSERT_OK(iter->status());
-
-      ASSERT_TRUE(iter->PrepareValue());
-
-      ASSERT_EQ(iter->key(), keys[i]);
-      ASSERT_EQ(iter->value(), blobs[i]);
-      ASSERT_OK(iter->status());
-
-      ++i;
-    }
-
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(i, num_blobs);
-  }
-
-  {
-    size_t i = 0;
-
-    for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
-      ASSERT_EQ(iter->key(), keys[num_blobs - 1 - i]);
-      ASSERT_TRUE(iter->value().empty());
-      ASSERT_OK(iter->status());
-
-      ASSERT_TRUE(iter->PrepareValue());
-
-      ASSERT_EQ(iter->key(), keys[num_blobs - 1 - i]);
-      ASSERT_EQ(iter->value(), blobs[num_blobs - 1 - i]);
-      ASSERT_OK(iter->status());
-
-      ++i;
-    }
-
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(i, num_blobs);
-  }
-
-  {
-    size_t i = 1;
-
-    for (iter->Seek(keys[i]); iter->Valid(); iter->Next()) {
-      ASSERT_EQ(iter->key(), keys[i]);
-      ASSERT_TRUE(iter->value().empty());
-      ASSERT_OK(iter->status());
-
-      ASSERT_TRUE(iter->PrepareValue());
-
-      ASSERT_EQ(iter->key(), keys[i]);
-      ASSERT_EQ(iter->value(), blobs[i]);
-      ASSERT_OK(iter->status());
-
-      ++i;
-    }
-
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(i, num_blobs);
-  }
-
-  {
-    size_t i = 1;
-
-    for (iter->SeekForPrev(keys[num_blobs - 1 - i]); iter->Valid();
-         iter->Prev()) {
-      ASSERT_EQ(iter->key(), keys[num_blobs - 1 - i]);
-      ASSERT_TRUE(iter->value().empty());
-      ASSERT_OK(iter->status());
-
-      ASSERT_TRUE(iter->PrepareValue());
-
-      ASSERT_EQ(iter->key(), keys[num_blobs - 1 - i]);
-      ASSERT_EQ(iter->value(), blobs[num_blobs - 1 - i]);
-      ASSERT_OK(iter->status());
-
-      ++i;
-    }
-
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(i, num_blobs);
-  }
-}
-
 TEST_F(DBBlobBasicTest, MultiGetBlobs) {
  constexpr size_t min_blob_size = 6;

@@ -1764,46 +1655,6 @@ TEST_P(DBBlobBasicIOErrorTest, CompactionFilterReadBlob_IOError) {
  SyncPoint::GetInstance()->ClearAllCallBacks();
 }

-TEST_P(DBBlobBasicIOErrorTest, IterateBlobsAllowUnpreparedValue_IOError) {
-  Options options;
-  options.env = fault_injection_env_.get();
-  options.enable_blob_files = true;
-
-  Reopen(options);
-
-  constexpr char key[] = "key";
-  constexpr char blob_value[] = "blob_value";
-
-  ASSERT_OK(Put(key, blob_value));
-
-  ASSERT_OK(Flush());
-
-  SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
-    fault_injection_env_->SetFilesystemActive(false,
-                                              Status::IOError(sync_point_));
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ReadOptions read_options;
-  read_options.allow_unprepared_value = true;
-
-  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
-  iter->SeekToFirst();
-
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(iter->key(), key);
-  ASSERT_TRUE(iter->value().empty());
-  ASSERT_OK(iter->status());
-
-  ASSERT_FALSE(iter->PrepareValue());
-
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_TRUE(iter->status().IsIOError());
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 TEST_F(DBBlobBasicTest, WarmCacheWithBlobsDuringFlush) {
  Options options = GetDefaultOptions();

@@ -53,7 +53,7 @@ TableBuilder* NewTableBuilder(const TableBuilderOptions& tboptions,
  assert((tboptions.column_family_id ==
          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
         tboptions.column_family_name.empty());
-  return tboptions.moptions.table_factory->NewTableBuilder(tboptions, file);
+  return tboptions.ioptions.table_factory->NewTableBuilder(tboptions, file);
 }

 Status BuildTable(
@@ -206,6 +206,10 @@ Status BuildTable(
        /*compaction=*/nullptr, compaction_filter.get(),
        /*shutting_down=*/nullptr, db_options.info_log, full_history_ts_low);

+    const size_t ts_sz = ucmp->timestamp_size();
+    const bool logical_strip_timestamp =
+        ts_sz > 0 && !ioptions.persist_user_defined_timestamps;
+
    SequenceNumber smallest_preferred_seqno = kMaxSequenceNumber;
    std::string key_after_flush_buf;
    std::string value_buf;
@@ -218,6 +222,16 @@ Status BuildTable(
      Slice key_after_flush = key_after_flush_buf;
      Slice value_after_flush = value;

+      // If user defined timestamps will be stripped from user key after flush,
+      // the in memory version of the key act logically the same as one with a
+      // minimum timestamp. We update the timestamp here so file boundary and
+      // output validator, block builder all see the effect of the stripping.
+      if (logical_strip_timestamp) {
+        key_after_flush_buf.clear();
+        ReplaceInternalKeyWithMinTimestamp(&key_after_flush_buf, key, ts_sz);
+        key_after_flush = key_after_flush_buf;
+      }
+
      if (ikey.type == kTypeValuePreferredSeqno) {
        auto [unpacked_value, unix_write_time] =
            ParsePackedValueWithWriteTime(value);
@@ -277,7 +291,11 @@ Status BuildTable(
      Slice last_tombstone_start_user_key{};
      for (range_del_it->SeekToFirst(); range_del_it->Valid();
           range_del_it->Next()) {
-        auto tombstone = range_del_it->Tombstone();
+        // When user timestamp should not be persisted, we logically strip a
+        // range tombstone's start and end key's timestamp (replace it with min
+        // timestamp) before passing them along to table builder and to update
+        // file boundaries.
+        auto tombstone = range_del_it->Tombstone(logical_strip_timestamp);
        std::pair<InternalKey, Slice> kv = tombstone.Serialize();
        builder->Add(kv.first.Encode(), kv.second);
        InternalKey tombstone_end = tombstone.SerializeEndKey();
@@ -420,7 +438,8 @@ Status BuildTable(
      // the goal is to cache it here for further user reads.
      std::unique_ptr<InternalIterator> it(table_cache->NewIterator(
          tboptions.read_options, file_options, tboptions.internal_comparator,
-          *meta, nullptr /* range_del_agg */, mutable_cf_options, nullptr,
+          *meta, nullptr /* range_del_agg */,
+          mutable_cf_options.prefix_extractor, nullptr,
          (internal_stats == nullptr) ? nullptr
                                      : internal_stats->GetFileReadHist(0),
          TableReaderCaller::kFlush, /*arena=*/nullptr,
@@ -428,7 +447,8 @@ Status BuildTable(
          MaxFileSizeForL0MetaPin(mutable_cf_options),
          /*smallest_compaction_key=*/nullptr,
          /*largest_compaction_key*/ nullptr,
-          /*allow_unprepared_value*/ false));
+          /*allow_unprepared_value*/ false,
+          mutable_cf_options.block_protection_bytes_per_key));
      s = it->status();
      if (s.ok() && paranoid_file_checks) {
        OutputValidator file_validator(tboptions.internal_comparator,
@@ -460,18 +480,9 @@ Status BuildTable(
      Status prepare =
          WritableFileWriter::PrepareIOOptions(tboptions.write_options, opts);
      if (prepare.ok()) {
-        // FIXME: track file for "slow" deletion, e.g. into the
-        // VersionSet::obsolete_files_ pipeline
        Status ignored = fs->DeleteFile(fname, opts, dbg);
        ignored.PermitUncheckedError();
      }
-      // Ensure we don't leak table cache entries when throwing away output
-      // files. (The usual logic in PurgeObsoleteFiles is not applicable because
-      // this function deletes the obsolete file itself, while they should
-      // probably go into the VersionSet::obsolete_files_ pipeline.)
-      TableCache::ReleaseObsolete(table_cache->get_cache().get(),
-                                  meta->fd.GetNumber(), nullptr /*handle*/,
-                                  mutable_cf_options.uncache_aggressiveness);
    }

    assert(blob_file_additions || blob_file_paths.empty());
@@ -4075,15 +4075,6 @@ void rocksdb_options_set_write_dbid_to_manifest(
  opt->rep.write_dbid_to_manifest = write_dbid_to_manifest;
 }

-unsigned char rocksdb_options_get_write_identity_file(rocksdb_options_t* opt) {
-  return opt->rep.write_identity_file;
-}
-
-void rocksdb_options_set_write_identity_file(
-    rocksdb_options_t* opt, unsigned char write_identity_file) {
-  opt->rep.write_identity_file = write_identity_file;
-}
-
 unsigned char rocksdb_options_get_track_and_verify_wals_in_manifest(
    rocksdb_options_t* opt) {
  return opt->rep.track_and_verify_wals_in_manifest;
@@ -772,8 +772,6 @@ int main(int argc, char** argv) {
  rocksdb_options_set_write_buffer_size(options, 100000);
  rocksdb_options_set_paranoid_checks(options, 1);
  rocksdb_options_set_max_open_files(options, 10);
-  /* Compatibility with how test was written */
-  rocksdb_options_set_write_dbid_to_manifest(options, 0);

  table_options = rocksdb_block_based_options_create();
  rocksdb_block_based_options_set_block_cache(table_options, cache);
@@ -964,24 +962,15 @@ int main(int argc, char** argv) {
    rocksdb_options_t* options_dbid_in_manifest = rocksdb_options_create();
    rocksdb_options_set_create_if_missing(options_dbid_in_manifest, 1);

-    rocksdb_options_set_write_dbid_to_manifest(options_dbid_in_manifest, false);
    unsigned char write_to_manifest =
        rocksdb_options_get_write_dbid_to_manifest(options_dbid_in_manifest);
    CheckCondition(!write_to_manifest);
    rocksdb_options_set_write_dbid_to_manifest(options_dbid_in_manifest, true);
+    CheckCondition(!write_to_manifest);
    write_to_manifest =
        rocksdb_options_get_write_dbid_to_manifest(options_dbid_in_manifest);
    CheckCondition(write_to_manifest);

-    rocksdb_options_set_write_identity_file(options_dbid_in_manifest, true);
-    unsigned char write_identity_file =
-        rocksdb_options_get_write_identity_file(options_dbid_in_manifest);
-    CheckCondition(write_identity_file);
-    rocksdb_options_set_write_identity_file(options_dbid_in_manifest, false);
-    write_identity_file =
-        rocksdb_options_get_write_identity_file(options_dbid_in_manifest);
-    CheckCondition(!write_identity_file);
-
    db = rocksdb_open(options_dbid_in_manifest, dbbackupname, &err);
    CheckNoError(err);

@@ -9,14 +9,17 @@

 namespace ROCKSDB_NAMESPACE {

+// EXPERIMENTAL
 class CoalescingIterator : public Iterator {
 public:
-  CoalescingIterator(
-      const ReadOptions& read_options, const Comparator* comparator,
-      std::vector<std::pair<ColumnFamilyHandle*, std::unique_ptr<Iterator>>>&&
-          cfh_iter_pairs)
-      : impl_(read_options, comparator, std::move(cfh_iter_pairs),
-              ResetFunc(this), PopulateFunc(this)) {}
+  CoalescingIterator(const Comparator* comparator,
+                     const std::vector<ColumnFamilyHandle*>& column_families,
+                     const std::vector<Iterator*>& child_iterators)
+      : impl_(
+            comparator, column_families, child_iterators, [this]() { Reset(); },
+            [this](const autovector<MultiCfIteratorInfo>& items) {
+              Coalesce(items);
+            }) {}
  ~CoalescingIterator() override {}

  // No copy allowed
@@ -47,36 +50,8 @@ class CoalescingIterator : public Iterator {
    wide_columns_.clear();
  }

-  bool PrepareValue() override { return impl_.PrepareValue(); }
-
 private:
-  class ResetFunc {
-   public:
-    explicit ResetFunc(CoalescingIterator* iter) : iter_(iter) {}
-
-    void operator()() const {
-      assert(iter_);
-      iter_->Reset();
-    }
-
-   private:
-    CoalescingIterator* iter_;
-  };
-
-  class PopulateFunc {
-   public:
-    explicit PopulateFunc(CoalescingIterator* iter) : iter_(iter) {}
-
-    void operator()(const autovector<MultiCfIteratorInfo>& items) const {
-      assert(iter_);
-      iter_->Coalesce(items);
-    }
-
-   private:
-    CoalescingIterator* iter_;
-  };
-
-  MultiCfIteratorImpl<ResetFunc, PopulateFunc> impl_;
+  MultiCfIteratorImpl impl_;
  Slice value_;
  WideColumns wide_columns_;

@@ -466,7 +466,7 @@ void SuperVersion::Cleanup() {
  // decrement reference to the immutable MemtableList
  // this SV object was pointing to.
  imm->Unref(&to_delete);
-  ReadOnlyMemTable* m = mem->Unref();
+  MemTable* m = mem->Unref();
  if (m != nullptr) {
    auto* memory_usage = current->cfd()->imm()->current_memory_usage();
    assert(*memory_usage >= m->ApproximateMemoryUsage());
@@ -595,8 +595,8 @@ ColumnFamilyData::ColumnFamilyData(
    blob_file_cache_.reset(
        new BlobFileCache(_table_cache, ioptions(), soptions(), id_,
                          internal_stats_->GetBlobFileReadHist(), io_tracer));
-    blob_source_.reset(new BlobSource(ioptions_, mutable_cf_options_, db_id,
-                                      db_session_id, blob_file_cache_.get()));
+    blob_source_.reset(new BlobSource(ioptions(), db_id, db_session_id,
+                                      blob_file_cache_.get()));

    if (ioptions_.compaction_style == kCompactionStyleLevel) {
      compaction_picker_.reset(
@@ -693,9 +693,9 @@ ColumnFamilyData::~ColumnFamilyData() {
  if (mem_ != nullptr) {
    delete mem_->Unref();
  }
-  autovector<ReadOnlyMemTable*> to_delete;
+  autovector<MemTable*> to_delete;
  imm_.current()->Unref(&to_delete);
-  for (auto* m : to_delete) {
+  for (MemTable* m : to_delete) {
    delete m;
  }

@@ -901,11 +901,7 @@ uint64_t GetPendingCompactionBytesForCompactionSpeedup(
    return slowdown_threshold;
  }

-  // Prevent a small CF from triggering parallel compactions for other CFs.
-  // Require compaction debt to be more than a full L0 to Lbase compaction.
-  const uint64_t kMinDebtSize = 2 * mutable_cf_options.max_bytes_for_level_base;
-  uint64_t size_threshold =
-      std::max(bottommost_files_size / kBottommostSizeDivisor, kMinDebtSize);
+  uint64_t size_threshold = bottommost_files_size / kBottommostSizeDivisor;
  return std::min(size_threshold, slowdown_threshold);
 }

@@ -1176,12 +1172,10 @@ bool ColumnFamilyData::NeedsCompaction() const {

 Compaction* ColumnFamilyData::PickCompaction(
    const MutableCFOptions& mutable_options,
-    const MutableDBOptions& mutable_db_options,
-    const std::vector<SequenceNumber>& existing_snapshots,
-    const SnapshotChecker* snapshot_checker, LogBuffer* log_buffer) {
+    const MutableDBOptions& mutable_db_options, LogBuffer* log_buffer) {
  auto* result = compaction_picker_->PickCompaction(
-      GetName(), mutable_options, mutable_db_options, existing_snapshots,
-      snapshot_checker, current_->storage_info(), log_buffer);
+      GetName(), mutable_options, mutable_db_options, current_->storage_info(),
+      log_buffer);
  if (result != nullptr) {
    result->FinalizeInputInfo(current_);
  }
@@ -1207,10 +1201,8 @@ Status ColumnFamilyData::RangesOverlapWithMemtables(
  read_opts.total_order_seek = true;
  MergeIteratorBuilder merge_iter_builder(&internal_comparator_, &arena);
  merge_iter_builder.AddIterator(super_version->mem->NewIterator(
-      read_opts, /*seqno_to_time_mapping=*/nullptr, &arena,
-      /*prefix_extractor=*/nullptr, /*for_flush=*/false));
+      read_opts, /*seqno_to_time_mapping=*/nullptr, &arena));
  super_version->imm->AddIterators(read_opts, /*seqno_to_time_mapping=*/nullptr,
-                                   /*prefix_extractor=*/nullptr,
                                   &merge_iter_builder,
                                   false /* add_range_tombstone_iter */);
  ScopedArenaPtr<InternalIterator> memtable_iter(merge_iter_builder.Finish());
@@ -1561,11 +1553,6 @@ Status ColumnFamilyData::SetOptions(
      BuildColumnFamilyOptions(initial_cf_options_, mutable_cf_options_);
  ConfigOptions config_opts;
  config_opts.mutable_options_only = true;
-#ifndef NDEBUG
-  if (TEST_allowSetOptionsImmutableInMutable) {
-    config_opts.mutable_options_only = false;
-  }
-#endif
  Status s = GetColumnFamilyOptionsFromMap(config_opts, cf_opts, options_map,
                                           &cf_opts);
  if (s.ok()) {
@@ -1578,6 +1565,28 @@ Status ColumnFamilyData::SetOptions(
  return s;
 }

+// REQUIRES: DB mutex held
+Env::WriteLifeTimeHint ColumnFamilyData::CalculateSSTWriteHint(int level) {
+  if (initial_cf_options_.compaction_style != kCompactionStyleLevel) {
+    return Env::WLTH_NOT_SET;
+  }
+  if (level == 0) {
+    return Env::WLTH_MEDIUM;
+  }
+  int base_level = current_->storage_info()->base_level();
+
+  // L1: medium, L2: long, ...
+  if (level - base_level >= 2) {
+    return Env::WLTH_EXTREME;
+  } else if (level < base_level) {
+    // There is no restriction which prevents level passed in to be smaller
+    // than base_level.
+    return Env::WLTH_MEDIUM;
+  }
+  return static_cast<Env::WriteLifeTimeHint>(
+      level - base_level + static_cast<int>(Env::WLTH_MEDIUM));
+}
+
 Status ColumnFamilyData::AddDirectories(
    std::map<std::string, std::shared_ptr<FSDirectory>>* created_dirs) {
  Status s;
@@ -1643,9 +1652,6 @@ bool ColumnFamilyData::ShouldPostponeFlushToRetainUDT(
  }
  for (const Slice& table_newest_udt :
       imm()->GetTablesNewestUDT(max_memtable_id)) {
-    if (table_newest_udt.empty()) {
-      continue;
-    }
    assert(table_newest_udt.size() == full_history_ts_low.size());
    // Checking the newest UDT contained in MemTable with ascending ID up to
    // `max_memtable_id`. Return immediately on finding the first MemTable that
@@ -16,7 +16,6 @@

 #include "cache/cache_reservation_manager.h"
 #include "db/memtable_list.h"
-#include "db/snapshot_checker.h"
 #include "db/table_cache.h"
 #include "db/table_properties_collector.h"
 #include "db/write_batch_internal.h"
@@ -207,7 +206,7 @@ struct SuperVersion {
  // Accessing members of this class is not thread-safe and requires external
  // synchronization (ie db mutex held or on write thread).
  ColumnFamilyData* cfd;
-  ReadOnlyMemTable* mem;
+  MemTable* mem;
  MemTableListVersion* imm;
  Version* current;
  MutableCFOptions mutable_cf_options;
@@ -269,7 +268,7 @@ struct SuperVersion {
  // We need to_delete because during Cleanup(), imm->Unref() returns
  // all memtables that we need to free through this vector. We then
  // delete all those memtables outside of mutex, during destruction
-  autovector<ReadOnlyMemTable*> to_delete;
+  autovector<MemTable*> to_delete;
 };

 Status CheckCompressionSupported(const ColumnFamilyOptions& cf_options);
@@ -386,16 +385,12 @@ class ColumnFamilyData {
  uint64_t GetTotalSstFilesSize() const;  // REQUIRE: DB mutex held
  uint64_t GetLiveSstFilesSize() const;   // REQUIRE: DB mutex held
  uint64_t GetTotalBlobFileSize() const;  // REQUIRE: DB mutex held
-  // REQUIRE: DB mutex held
  void SetMemtable(MemTable* new_mem) {
-    AssignMemtableID(new_mem);
+    uint64_t memtable_id = last_memtable_id_.fetch_add(1) + 1;
+    new_mem->SetID(memtable_id);
    mem_ = new_mem;
  }

-  void AssignMemtableID(ReadOnlyMemTable* new_imm) {
-    new_imm->SetID(++last_memtable_id_);
-  }
-
  // calculate the oldest log needed for the durability of this column family
  uint64_t OldestLogToKeep();

@@ -413,11 +408,9 @@ class ColumnFamilyData {
  // REQUIRES: DB mutex held
  bool NeedsCompaction() const;
  // REQUIRES: DB mutex held
-  Compaction* PickCompaction(
-      const MutableCFOptions& mutable_options,
-      const MutableDBOptions& mutable_db_options,
-      const std::vector<SequenceNumber>& existing_snapshots,
-      const SnapshotChecker* snapshot_checker, LogBuffer* log_buffer);
+  Compaction* PickCompaction(const MutableCFOptions& mutable_options,
+                             const MutableDBOptions& mutable_db_options,
+                             LogBuffer* log_buffer);

  // Check if the passed range overlap with any running compactions.
  // REQUIRES: DB mutex held
@@ -519,6 +512,8 @@ class ColumnFamilyData {
    return initial_cf_options_;
  }

+  Env::WriteLifeTimeHint CalculateSSTWriteHint(int level);
+
  // created_dirs remembers directory created, so that we don't need to call
  // the same data creation operation again.
  Status AddDirectories(
@@ -677,7 +672,7 @@ class ColumnFamilyData {
  bool allow_2pc_;

  // Memtable id to track flush.
-  uint64_t last_memtable_id_;
+  std::atomic<uint64_t> last_memtable_id_;

  // Directories corresponding to cf_paths.
  std::vector<std::shared_ptr<FSDirectory>> data_dirs_;
@@ -3012,25 +3012,19 @@ TEST_P(ColumnFamilyTest, CompactionSpeedupForCompactionDebt) {
  ASSERT_OK(db_->Flush(FlushOptions()));

  {
+    // 1MB debt is way bigger than bottommost data so definitely triggers
+    // speedup.
    VersionStorageInfo* vstorage = cfd->current()->storage_info();
+    vstorage->TEST_set_estimated_compaction_needed_bytes(1048576 /* 1MB */,
+                                                         dbmu);
+    RecalculateWriteStallConditions(cfd, mutable_cf_options);
+    ASSERT_EQ(6, dbfull()->TEST_BGCompactionsAllowed());
+
    // Eight bytes is way smaller than bottommost data so definitely does not
    // trigger speedup.
    vstorage->TEST_set_estimated_compaction_needed_bytes(8, dbmu);
    RecalculateWriteStallConditions(cfd, mutable_cf_options);
    ASSERT_EQ(1, dbfull()->TEST_BGCompactionsAllowed());
-
-    // 1MB is much larger than bottommost level size. However, since it's too
-    // small in terms of absolute size, it does not trigger parallel compaction
-    // in this case (see GetPendingCompactionBytesForCompactionSpeedup()).
-    vstorage->TEST_set_estimated_compaction_needed_bytes(1048576 /* 1MB */,
-                                                         dbmu);
-    RecalculateWriteStallConditions(cfd, mutable_cf_options);
-    ASSERT_EQ(1, dbfull()->TEST_BGCompactionsAllowed());
-
-    vstorage->TEST_set_estimated_compaction_needed_bytes(
-        2 * mutable_cf_options.max_bytes_for_level_base, dbmu);
-    RecalculateWriteStallConditions(cfd, mutable_cf_options);
-    ASSERT_EQ(6, dbfull()->TEST_BGCompactionsAllowed());
  }
 }

@@ -3876,91 +3870,6 @@ TEST_F(ManualFlushSkipRetainUDTTest, ManualFlush) {
  Close();
 }

-TEST_F(ManualFlushSkipRetainUDTTest, FlushRemovesStaleEntries) {
-  column_family_options_.max_write_buffer_number = 4;
-  Open();
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(0)));
-
-  ColumnFamilyHandle* cfh = db_->DefaultColumnFamily();
-  ColumnFamilyData* cfd =
-      static_cast_with_check<ColumnFamilyHandleImpl>(cfh)->cfd();
-  for (int version = 0; version < 100; version++) {
-    if (version == 50) {
-      ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_SwitchMemtable(cfd));
-    }
-    ASSERT_OK(
-        Put(0, "foo", EncodeAsUint64(version), "v" + std::to_string(version)));
-  }
-
-  ASSERT_OK(Flush(0));
-  TablePropertiesCollection tables_properties;
-  ASSERT_OK(db_->GetPropertiesOfAllTables(&tables_properties));
-  ASSERT_EQ(1, tables_properties.size());
-  std::shared_ptr<const TableProperties> table_properties =
-      tables_properties.begin()->second;
-  ASSERT_EQ(1, table_properties->num_entries);
-  ASSERT_EQ(0, table_properties->num_deletions);
-  ASSERT_EQ(0, table_properties->num_range_deletions);
-  CheckEffectiveCutoffTime(100);
-  CheckAutomaticFlushRetainUDT(101);
-
-  Close();
-}
-
-TEST_F(ManualFlushSkipRetainUDTTest, RangeDeletionFlushRemovesStaleEntries) {
-  column_family_options_.max_write_buffer_number = 4;
-  Open();
-  // TODO(yuzhangyu): a non 0 full history ts low is needed for this garbage
-  // collection to kick in. This doesn't work well for the very first flush of
-  // the column family. Not a big issue, but would be nice to improve this.
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(9)));
-
-  for (int i = 10; i < 100; i++) {
-    ASSERT_OK(Put(0, "foo" + std::to_string(i), EncodeAsUint64(i),
-                  "val" + std::to_string(i)));
-    if (i % 2 == 1) {
-      ASSERT_OK(db_->DeleteRange(WriteOptions(), "foo" + std::to_string(i - 1),
-                                 "foo" + std::to_string(i), EncodeAsUint64(i)));
-    }
-  }
-
-  ASSERT_OK(Flush(0));
-  CheckEffectiveCutoffTime(100);
-  std::string read_ts = EncodeAsUint64(100);
-  std::string min_ts = EncodeAsUint64(0);
-  ReadOptions ropts;
-  Slice read_ts_slice = read_ts;
-  std::string value;
-  ropts.timestamp = &read_ts_slice;
-  {
-    Iterator* iter = db_->NewIterator(ropts);
-    iter->SeekToFirst();
-    int i = 11;
-    while (iter->Valid()) {
-      ASSERT_TRUE(iter->Valid());
-      ASSERT_EQ("foo" + std::to_string(i), iter->key());
-      ASSERT_EQ("val" + std::to_string(i), iter->value());
-      ASSERT_EQ(min_ts, iter->timestamp());
-      iter->Next();
-      i += 2;
-    }
-    ASSERT_OK(iter->status());
-    delete iter;
-  }
-  TablePropertiesCollection tables_properties;
-  ASSERT_OK(db_->GetPropertiesOfAllTables(&tables_properties));
-  ASSERT_EQ(1, tables_properties.size());
-  std::shared_ptr<const TableProperties> table_properties =
-      tables_properties.begin()->second;
-  // 45 point data + 45 range deletions. 45 obsolete point data are garbage
-  // collected.
-  ASSERT_EQ(90, table_properties->num_entries);
-  ASSERT_EQ(45, table_properties->num_deletions);
-  ASSERT_EQ(45, table_properties->num_range_deletions);
-
-  Close();
-}
-
 TEST_F(ManualFlushSkipRetainUDTTest, ManualCompaction) {
  Open();
  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(0)));
@@ -283,10 +283,9 @@ Compaction::Compaction(
    uint32_t _output_path_id, CompressionType _compression,
    CompressionOptions _compression_opts, Temperature _output_temperature,
    uint32_t _max_subcompactions, std::vector<FileMetaData*> _grandparents,
-    std::optional<SequenceNumber> _earliest_snapshot,
-    const SnapshotChecker* _snapshot_checker, bool _manual_compaction,
-    const std::string& _trim_ts, double _score, bool _deletion_compaction,
-    bool l0_files_might_overlap, CompactionReason _compaction_reason,
+    bool _manual_compaction, const std::string& _trim_ts, double _score,
+    bool _deletion_compaction, bool l0_files_might_overlap,
+    CompactionReason _compaction_reason,
    BlobGarbageCollectionPolicy _blob_garbage_collection_policy,
    double _blob_garbage_collection_age_cutoff)
    : input_vstorage_(vstorage),
@@ -308,8 +307,6 @@ Compaction::Compaction(
      l0_files_might_overlap_(l0_files_might_overlap),
      inputs_(PopulateWithAtomicBoundaries(vstorage, std::move(_inputs))),
      grandparents_(std::move(_grandparents)),
-      earliest_snapshot_(_earliest_snapshot),
-      snapshot_checker_(_snapshot_checker),
      score_(_score),
      bottommost_level_(
          // For simplicity, we don't support the concept of "bottommost level"
@@ -345,9 +342,8 @@ Compaction::Compaction(
          _compaction_reason == CompactionReason::kExternalSstIngestion ||
                  _compaction_reason == CompactionReason::kRefitLevel
              ? Compaction::kInvalidLevel
-              : EvaluatePenultimateLevel(vstorage, mutable_cf_options_,
-                                         immutable_options_, start_level_,
-                                         output_level_)) {
+              : EvaluatePenultimateLevel(vstorage, immutable_options_,
+                                         start_level_, output_level_)) {
  MarkFilesBeingCompacted(true);
  if (is_manual_compaction_) {
    compaction_reason_ = CompactionReason::kManualCompaction;
@@ -368,17 +364,12 @@ Compaction::Compaction(
  }
 #endif

-  // setup input_levels_ and filtered_input_levels_
+  // setup input_levels_
  {
    input_levels_.resize(num_input_levels());
-    filtered_input_levels_.resize(num_input_levels());
-    if (earliest_snapshot_.has_value()) {
-      FilterInputsForCompactionIterator();
-    } else {
-      for (size_t which = 0; which < num_input_levels(); which++) {
-        DoGenerateLevelFilesBrief(&input_levels_[which], inputs_[which].files,
-                                  &arena_);
-      }
+    for (size_t which = 0; which < num_input_levels(); which++) {
+      DoGenerateLevelFilesBrief(&input_levels_[which], inputs_[which].files,
+                                &arena_);
    }
  }

@@ -695,11 +686,12 @@ bool Compaction::KeyRangeNotExistsBeyondOutputLevel(
 };

 // Mark (or clear) each file that is being compacted
-void Compaction::MarkFilesBeingCompacted(bool being_compacted) const {
+void Compaction::MarkFilesBeingCompacted(bool mark_as_compacted) {
  for (size_t i = 0; i < num_input_levels(); i++) {
    for (size_t j = 0; j < inputs_[i].size(); j++) {
-      assert(being_compacted != inputs_[i][j]->being_compacted);
-      inputs_[i][j]->being_compacted = being_compacted;
+      assert(mark_as_compacted ? !inputs_[i][j]->being_compacted
+                               : inputs_[i][j]->being_compacted);
+      inputs_[i][j]->being_compacted = mark_as_compacted;
    }
  }
 }
@@ -743,7 +735,7 @@ uint64_t Compaction::CalculateTotalInputSize() const {
  return size;
 }

-void Compaction::ReleaseCompactionFiles(const Status& status) {
+void Compaction::ReleaseCompactionFiles(Status status) {
  MarkFilesBeingCompacted(false);
  cfd_->compaction_picker()->ReleaseCompactionFiles(this, status);
 }
@@ -754,10 +746,8 @@ void Compaction::ResetNextCompactionIndex() {
 }

 namespace {
-int InputSummary(const std::vector<FileMetaData*>& files,
-                 const std::vector<bool>& files_filtered, char* output,
+int InputSummary(const std::vector<FileMetaData*>& files, char* output,
                 int len) {
-  assert(files_filtered.empty() || (files.size() == files_filtered.size()));
  *output = '\0';
  int write = 0;
  for (size_t i = 0; i < files.size(); i++) {
@@ -765,14 +755,8 @@ int InputSummary(const std::vector<FileMetaData*>& files,
    int ret;
    char sztxt[16];
    AppendHumanBytes(files.at(i)->fd.GetFileSize(), sztxt, 16);
-    if (files_filtered.empty()) {
-      ret = snprintf(output + write, sz, "%" PRIu64 "(%s) ",
-                     files.at(i)->fd.GetNumber(), sztxt);
-    } else {
-      ret = snprintf(output + write, sz, "%" PRIu64 "(%s filtered:%s) ",
-                     files.at(i)->fd.GetNumber(), sztxt,
-                     files_filtered.at(i) ? "true" : "false");
-    }
+    ret = snprintf(output + write, sz, "%" PRIu64 "(%s) ",
+                   files.at(i)->fd.GetNumber(), sztxt);
    if (ret < 0 || ret >= sz) {
      break;
    }
@@ -798,15 +782,8 @@ void Compaction::Summary(char* output, int len) {
        return;
      }
    }
-
-    assert(non_start_level_input_files_filtered_.empty() ||
-           non_start_level_input_files_filtered_.size() == inputs_.size() - 1);
-    write += InputSummary(
-        inputs_[level_iter].files,
-        (level_iter == 0 || non_start_level_input_files_filtered_.empty())
-            ? std::vector<bool>{}
-            : non_start_level_input_files_filtered_[level_iter - 1],
-        output + write, len - write);
+    write +=
+        InputSummary(inputs_[level_iter].files, output + write, len - write);
    if (write < 0 || write >= len) {
      return;
    }
@@ -889,7 +866,7 @@ bool Compaction::ShouldFormSubcompactions() const {
    return false;
  }

-  if (mutable_cf_options_.table_factory->Name() ==
+  if (cfd_->ioptions()->table_factory->Name() ==
      TableFactory::kPlainTableName()) {
    return false;
  }
@@ -937,25 +914,6 @@ bool Compaction::DoesInputReferenceBlobFiles() const {
  return false;
 }

-uint64_t Compaction::MaxInputFileNewestKeyTime(const InternalKey* start,
-                                               const InternalKey* end) const {
-  uint64_t newest_key_time = kUnknownNewestKeyTime;
-  const InternalKeyComparator& icmp =
-      column_family_data()->internal_comparator();
-  for (const auto& level_files : inputs_) {
-    for (const auto& file : level_files.files) {
-      if (start != nullptr && icmp.Compare(file->largest, *start) < 0) {
-        continue;
-      }
-      if (end != nullptr && icmp.Compare(file->smallest, *end) > 0) {
-        continue;
-      }
-      newest_key_time = std::max(newest_key_time, file->TryGetNewestKeyTime());
-    }
-  }
-  return newest_key_time;
-}
-
 uint64_t Compaction::MinInputFileOldestAncesterTime(
    const InternalKey* start, const InternalKey* end) const {
  uint64_t min_oldest_ancester_time = std::numeric_limits<uint64_t>::max();
@@ -991,7 +949,6 @@ uint64_t Compaction::MinInputFileEpochNumber() const {

 int Compaction::EvaluatePenultimateLevel(
    const VersionStorageInfo* vstorage,
-    const MutableCFOptions& mutable_cf_options,
    const ImmutableOptions& immutable_options, const int start_level,
    const int output_level) {
  // TODO: currently per_key_placement feature only support level and universal
@@ -1023,7 +980,7 @@ int Compaction::EvaluatePenultimateLevel(
  }

  bool supports_per_key_placement =
-      mutable_cf_options.preclude_last_level_data_seconds > 0;
+      immutable_options.preclude_last_level_data_seconds > 0;

  // it could be overridden by unittest
  TEST_SYNC_POINT_CALLBACK("Compaction::SupportsPerKeyPlacement:Enabled",
@@ -1035,70 +992,4 @@ int Compaction::EvaluatePenultimateLevel(
  return penultimate_level;
 }

-void Compaction::FilterInputsForCompactionIterator() {
-  assert(earliest_snapshot_.has_value());
-  // cfd_ is not populated at Compaction construction time, get it from
-  // VersionStorageInfo instead.
-  assert(input_vstorage_);
-  const auto* ucmp = input_vstorage_->user_comparator();
-  assert(ucmp);
-  // Simply comparing file boundaries when user-defined timestamp is defined
-  // is not as safe because we need to also compare timestamp to know for
-  // sure. Although entries with higher timestamp is also supposed to have
-  // higher sequence number for the same user key (without timestamp).
-  assert(ucmp->timestamp_size() == 0);
-  size_t num_input_levels = inputs_.size();
-  // TODO(yuzhangyu): filtering of older L0 file by new L0 file is not
-  // supported yet.
-  FileMetaData* rangedel_candidate = inputs_[0].level == 0
-                                         ? inputs_[0].files.back()
-                                         : inputs_[0].files.front();
-  assert(rangedel_candidate);
-  if (!rangedel_candidate->FileIsStandAloneRangeTombstone() ||
-      !DataIsDefinitelyInSnapshot(rangedel_candidate->fd.smallest_seqno,
-                                  earliest_snapshot_.value(),
-                                  snapshot_checker_)) {
-    for (size_t level = 0; level < num_input_levels; level++) {
-      DoGenerateLevelFilesBrief(&input_levels_[level], inputs_[level].files,
-                                &arena_);
-    }
-    return;
-  }
-
-  Slice rangedel_start_ukey = rangedel_candidate->smallest.user_key();
-  Slice rangedel_end_ukey = rangedel_candidate->largest.user_key();
-  SequenceNumber rangedel_seqno = rangedel_candidate->fd.smallest_seqno;
-
-  std::vector<std::vector<FileMetaData*>> non_start_level_input_files;
-  non_start_level_input_files.reserve(num_input_levels - 1);
-  non_start_level_input_files_filtered_.reserve(num_input_levels - 1);
-  for (size_t level = 1; level < num_input_levels; level++) {
-    non_start_level_input_files.emplace_back();
-    non_start_level_input_files_filtered_.emplace_back();
-    for (FileMetaData* file : inputs_[level].files) {
-      non_start_level_input_files_filtered_.back().push_back(false);
-      // When range data and point data has the same sequence number, point
-      // data wins. Range deletion end key is exclusive, so check it's bigger
-      // than file right boundary user key.
-      if (rangedel_seqno > file->fd.largest_seqno &&
-          ucmp->CompareWithoutTimestamp(rangedel_start_ukey,
-                                        file->smallest.user_key()) <= 0 &&
-          ucmp->CompareWithoutTimestamp(rangedel_end_ukey,
-                                        file->largest.user_key()) > 0) {
-        non_start_level_input_files_filtered_.back().back() = true;
-        filtered_input_levels_[level].push_back(file);
-      } else {
-        non_start_level_input_files.back().push_back(file);
-      }
-    }
-  }
-
-  DoGenerateLevelFilesBrief(&input_levels_[0], inputs_[0].files, &arena_);
-  assert(non_start_level_input_files.size() == num_input_levels - 1);
-  for (size_t level = 1; level < num_input_levels; level++) {
-    DoGenerateLevelFilesBrief(&input_levels_[level],
-                              non_start_level_input_files[level - 1], &arena_);
-  }
-}
-
 }  // namespace ROCKSDB_NAMESPACE
@@ -8,8 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #pragma once
-
-#include "db/snapshot_checker.h"
 #include "db/version_set.h"
 #include "memory/arena.h"
 #include "options/cf_options.h"
@@ -92,8 +90,6 @@ class Compaction {
             CompressionOptions compression_opts,
             Temperature output_temperature, uint32_t max_subcompactions,
             std::vector<FileMetaData*> grandparents,
-             std::optional<SequenceNumber> earliest_snapshot,
-             const SnapshotChecker* snapshot_checker,
             bool manual_compaction = false, const std::string& trim_ts = "",
             double score = -1, bool deletion_compaction = false,
             bool l0_files_might_overlap = true,
@@ -184,16 +180,6 @@ class Compaction {
    return &input_levels_[compaction_input_level];
  }

-  // Returns the filtered input files of the specified compaction input level.
-  // For now, only non start level is filtered.
-  const std::vector<FileMetaData*>& filtered_input_levels(
-      size_t compaction_input_level) const {
-    const std::vector<FileMetaData*>& filtered_input_level =
-        filtered_input_levels_[compaction_input_level];
-    assert(compaction_input_level != 0 || filtered_input_level.size() == 0);
-    return filtered_input_level;
-  }
-
  // Maximum size of files to build during this compaction.
  uint64_t max_output_file_size() const { return max_output_file_size_; }

@@ -244,7 +230,7 @@ class Compaction {
  // Delete this compaction from the list of running compactions.
  //
  // Requirement: DB mutex held
-  void ReleaseCompactionFiles(const Status& status);
+  void ReleaseCompactionFiles(Status status);

  // Returns the summary of the compaction in "output" with maximum "len"
  // in bytes.  The caller is responsible for the memory management of
@@ -415,12 +401,6 @@ class Compaction {
    return blob_garbage_collection_age_cutoff_;
  }

-  // start and end are sub compact range. Null if no boundary.
-  // This is used to calculate the newest_key_time table property after
-  // compaction.
-  uint64_t MaxInputFileNewestKeyTime(const InternalKey* start,
-                                     const InternalKey* end) const;
-
  // start and end are sub compact range. Null if no boundary.
  // This is used to filter out some input files' ancester's time range.
  uint64_t MinInputFileOldestAncesterTime(const InternalKey* start,
@@ -450,19 +430,18 @@ class Compaction {
  // penultimate level. The safe key range is populated by
  // `PopulatePenultimateLevelOutputRange()`.
  // Which could potentially disable all penultimate level output.
-  static int EvaluatePenultimateLevel(
-      const VersionStorageInfo* vstorage,
-      const MutableCFOptions& mutable_cf_options,
-      const ImmutableOptions& immutable_options, const int start_level,
-      const int output_level);
-
-  // mark (or clear) all files that are being compacted
-  void MarkFilesBeingCompacted(bool being_compacted) const;
+  static int EvaluatePenultimateLevel(const VersionStorageInfo* vstorage,
+                                      const ImmutableOptions& immutable_options,
+                                      const int start_level,
+                                      const int output_level);

 private:

  Status InitInputTableProperties();

+  // mark (or clear) all files that are being compacted
+  void MarkFilesBeingCompacted(bool mark_as_compacted);
+
  // get the smallest and largest key present in files to be compacted
  static void GetBoundaryKeys(VersionStorageInfo* vstorage,
                              const std::vector<CompactionInputFiles>& inputs,
@@ -481,13 +460,6 @@ class Compaction {
  // `Compaction::WithinPenultimateLevelOutputRange()`.
  void PopulatePenultimateLevelOutputRange();

-  // If oldest snapshot is specified at Compaction construction time, we have
-  // an opportunity to optimize inputs for compaction iterator for this case:
-  // When a standalone range deletion file on the start level is recognized and
-  // can be determined to completely shadow some input files on non-start level.
-  // These files will be filtered out and later not feed to compaction iterator.
-  void FilterInputsForCompactionIterator();
-
  // Get the atomic file boundaries for all files in the compaction. Necessary
  // in order to avoid the scenario described in
  // https://github.com/facebook/rocksdb/pull/4432#discussion_r221072219 and
@@ -538,30 +510,12 @@ class Compaction {
  // Compaction input files organized by level. Constant after construction
  const std::vector<CompactionInputFiles> inputs_;

-  // All files from inputs_ that are not filtered and will be fed to compaction
-  // iterator, organized more closely in memory.
+  // A copy of inputs_, organized more closely in memory
  autovector<LevelFilesBrief, 2> input_levels_;

  // State used to check for number of overlapping grandparent files
  // (grandparent == "output_level_ + 1")
  std::vector<FileMetaData*> grandparents_;
-
-  // The earliest snapshot and snapshot checker at compaction picking time.
-  // These fields are only set for deletion triggered compactions picked in
-  // universal compaction. And when user-defined timestamp is not enabled.
-  // It will be used to possibly filter out some non start level input files.
-  std::optional<SequenceNumber> earliest_snapshot_;
-  const SnapshotChecker* snapshot_checker_;
-
-  // Markers for which non start level input files are filtered out if
-  // applicable. Only applicable if earliest_snapshot_ is provided and input
-  // start level has a standalone range deletion file. Filtered files are
-  // tracked in `filtered_input_levels_`.
-  std::vector<std::vector<bool>> non_start_level_input_files_filtered_;
-
-  // All files from inputs_ that are filtered.
-  std::vector<std::vector<FileMetaData*>> filtered_input_levels_;
-
  const double score_;  // score that was used to pick this compaction.

  // Is this compaction creating a file in the bottom most level?
@@ -872,8 +872,8 @@ void CompactionIterator::NextFromInput() {
      if (Valid()) {
        at_next_ = true;
      }
-    } else if (last_sequence != kMaxSequenceNumber &&
-               (last_snapshot == current_user_key_snapshot_ ||
+    } else if (last_snapshot == current_user_key_snapshot_ ||
+               (last_snapshot > 0 &&
                last_snapshot < current_user_key_snapshot_)) {
      // If the earliest snapshot is which this key is visible in
      // is the same as the visibility of a previous instance of the
@@ -540,12 +540,18 @@ class CompactionIterator {

 inline bool CompactionIterator::DefinitelyInSnapshot(SequenceNumber seq,
                                                     SequenceNumber snapshot) {
-  return DataIsDefinitelyInSnapshot(seq, snapshot, snapshot_checker_);
+  return ((seq) <= (snapshot) &&
+          (snapshot_checker_ == nullptr ||
+           LIKELY(snapshot_checker_->CheckInSnapshot((seq), (snapshot)) ==
+                  SnapshotCheckerResult::kInSnapshot)));
 }

 inline bool CompactionIterator::DefinitelyNotInSnapshot(
    SequenceNumber seq, SequenceNumber snapshot) {
-  return DataIsDefinitelyNotInSnapshot(seq, snapshot, snapshot_checker_);
+  return ((seq) > (snapshot) ||
+          (snapshot_checker_ != nullptr &&
+           UNLIKELY(snapshot_checker_->CheckInSnapshot((seq), (snapshot)) ==
+                    SnapshotCheckerResult::kNotInSnapshot)));
 }

 }  // namespace ROCKSDB_NAMESPACE
@@ -833,14 +833,6 @@ TEST_P(CompactionIteratorTest, ConvertToPutAtBottom) {
          true /*bottomost_level*/);
 }

-TEST_P(CompactionIteratorTest, ZeroSeqOfKeyAndSnapshot) {
-  AddSnapshot(0);
-  const std::vector<std::string> input_keys = {
-      test::KeyStr("a", 0, kTypeValue), test::KeyStr("b", 0, kTypeValue)};
-  const std::vector<std::string> input_values = {"a1", "b1"};
-  RunTest(input_keys, input_values, input_keys, input_values);
-}
-
 INSTANTIATE_TEST_CASE_P(CompactionIteratorTestInstance, CompactionIteratorTest,
                        testing::Values(true, false));

@@ -1854,22 +1846,6 @@ TEST_P(CompactionIteratorTsGcTest, SingleDeleteAllKeysOlderThanThreshold) {
  }
 }

-TEST_P(CompactionIteratorTsGcTest, ZeroSeqOfKeyAndSnapshot) {
-  AddSnapshot(0);
-  std::string full_history_ts_low;
-  PutFixed64(&full_history_ts_low, std::numeric_limits<uint64_t>::max());
-  const std::vector<std::string> input_keys = {
-      test::KeyStr(101, "a", 0, kTypeValue),
-      test::KeyStr(102, "b", 0, kTypeValue)};
-  const std::vector<std::string> input_values = {"a1", "b1"};
-  RunTest(input_keys, input_values, input_keys, input_values,
-          /*last_committed_seq=*/kMaxSequenceNumber,
-          /*merge_operator=*/nullptr, /*compaction_filter=*/nullptr,
-          /*bottommost_level=*/false,
-          /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-          /*key_not_exists_beyond_output_level=*/false, &full_history_ts_low);
-}
-
 INSTANTIATE_TEST_CASE_P(CompactionIteratorTsGcTestInstance,
                        CompactionIteratorTsGcTest,
                        testing::Values(true, false));
@@ -251,13 +251,12 @@ void CompactionJob::Prepare() {

  // Generate file_levels_ for compaction before making Iterator
  auto* c = compact_->compaction;
-  [[maybe_unused]] ColumnFamilyData* cfd = c->column_family_data();
+  ColumnFamilyData* cfd = c->column_family_data();
  assert(cfd != nullptr);
-  const VersionStorageInfo* storage_info = c->input_version()->storage_info();
-  assert(storage_info);
-  assert(storage_info->NumLevelFiles(compact_->compaction->level()) > 0);
+  assert(cfd->current()->storage_info()->NumLevelFiles(
+             compact_->compaction->level()) > 0);

-  write_hint_ = storage_info->CalculateSSTWriteHint(c->output_level());
+  write_hint_ = cfd->CalculateSSTWriteHint(c->output_level());
  bottommost_level_ = c->bottommost_level();

  if (c->ShouldFormSubcompactions()) {
@@ -288,8 +287,8 @@ void CompactionJob::Prepare() {
  // to encode seqno->time to the output files.

  uint64_t preserve_time_duration =
-      std::max(c->mutable_cf_options()->preserve_internal_time_seconds,
-               c->mutable_cf_options()->preclude_last_level_data_seconds);
+      std::max(c->immutable_options()->preserve_internal_time_seconds,
+               c->immutable_options()->preclude_last_level_data_seconds);

  if (preserve_time_duration > 0) {
    const ReadOptions read_options(Env::IOActivity::kCompaction);
@@ -298,8 +297,8 @@ void CompactionJob::Prepare() {
    for (const auto& each_level : *c->inputs()) {
      for (const auto& fmd : each_level.files) {
        std::shared_ptr<const TableProperties> tp;
-        Status s = c->input_version()->GetTableProperties(read_options, &tp,
-                                                          fmd, nullptr);
+        Status s =
+            cfd->current()->GetTableProperties(read_options, &tp, fmd, nullptr);
        if (s.ok()) {
          s = seqno_to_time_mapping_.DecodeFrom(tp->seqno_to_time_mapping);
        }
@@ -326,8 +325,8 @@ void CompactionJob::Prepare() {
      seqno_to_time_mapping_.Enforce(_current_time);
      seqno_to_time_mapping_.GetCurrentTieringCutoffSeqnos(
          static_cast<uint64_t>(_current_time),
-          c->mutable_cf_options()->preserve_internal_time_seconds,
-          c->mutable_cf_options()->preclude_last_level_data_seconds,
+          c->immutable_options()->preserve_internal_time_seconds,
+          c->immutable_options()->preclude_last_level_data_seconds,
          &preserve_time_min_seqno_, &preclude_last_level_min_seqno_);
    }
    // For accuracy of the GetProximalSeqnoBeforeTime queries above, we only
@@ -469,7 +468,7 @@ void CompactionJob::GenSubcompactionBoundaries() {
  ReadOptions read_options(Env::IOActivity::kCompaction);
  read_options.rate_limiter_priority = GetRateLimiterPriority();
  auto* c = compact_->compaction;
-  if (c->mutable_cf_options()->table_factory->Name() ==
+  if (c->immutable_options()->table_factory->Name() ==
      TableFactory::kPlainTableName()) {
    return;
  }
@@ -506,7 +505,9 @@ void CompactionJob::GenSubcompactionBoundaries() {
        FileMetaData* f = flevel->files[i].file_metadata;
        std::vector<TableReader::Anchor> my_anchors;
        Status s = cfd->table_cache()->ApproximateKeyAnchors(
-            read_options, icomp, *f, *c->mutable_cf_options(), my_anchors);
+            read_options, icomp, *f,
+            c->mutable_cf_options()->block_protection_bytes_per_key,
+            my_anchors);
        if (!s.ok() || my_anchors.empty()) {
          my_anchors.emplace_back(f->largest.user_key(), f->fd.GetFileSize());
        }
@@ -709,6 +710,8 @@ Status CompactionJob::Run() {
      }
    }
    ColumnFamilyData* cfd = compact_->compaction->column_family_data();
+    auto& prefix_extractor =
+        compact_->compaction->mutable_cf_options()->prefix_extractor;
    std::atomic<size_t> next_file_idx(0);
    auto verify_table = [&](Status& output_status) {
      while (true) {
@@ -729,8 +732,7 @@ Status CompactionJob::Run() {
        InternalIterator* iter = cfd->table_cache()->NewIterator(
            verify_table_read_options, file_options_,
            cfd->internal_comparator(), files_output[file_idx]->meta,
-            /*range_del_agg=*/nullptr,
-            *compact_->compaction->mutable_cf_options(),
+            /*range_del_agg=*/nullptr, prefix_extractor,
            /*table_reader_ptr=*/nullptr,
            cfd->internal_stats()->GetFileReadHist(
                compact_->compaction->output_level()),
@@ -740,7 +742,9 @@ Status CompactionJob::Run() {
                *compact_->compaction->mutable_cf_options()),
            /*smallest_compaction_key=*/nullptr,
            /*largest_compaction_key=*/nullptr,
-            /*allow_unprepared_value=*/false);
+            /*allow_unprepared_value=*/false,
+            compact_->compaction->mutable_cf_options()
+                ->block_protection_bytes_per_key);
        auto s = iter->status();

        if (s.ok() && paranoid_file_checks_) {
@@ -801,12 +805,6 @@ Status CompactionJob::Run() {
    }
  }

-  // Before the compaction starts, is_remote_compaction was set to true if
-  // compaction_service is set. We now know whether each sub_compaction was
-  // done remotely or not. Reset is_remote_compaction back to false and allow
-  // AggregateCompactionStats() to set the right value.
-  compaction_job_stats_->is_remote_compaction = false;
-
  // Finish up all bookkeeping to unify the subcompaction results.
  compact_->AggregateCompactionStats(compaction_stats_, *compaction_job_stats_);
  uint64_t num_input_range_del = 0;
@@ -911,23 +909,19 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options,
  ROCKS_LOG_BUFFER(
      log_buffer_,
      "[%s] compacted to: %s, MB/sec: %.1f rd, %.1f wr, level %d, "
-      "files in(%d, %d) filtered(%d, %d) out(%d +%d blob) "
-      "MB in(%.1f, %.1f +%.1f blob) filtered(%.1f, %.1f) out(%.1f +%.1f blob), "
+      "files in(%d, %d) out(%d +%d blob) "
+      "MB in(%.1f, %.1f +%.1f blob) out(%.1f +%.1f blob), "
      "read-write-amplify(%.1f) write-amplify(%.1f) %s, records in: %" PRIu64
      ", records dropped: %" PRIu64 " output_compression: %s\n",
      column_family_name.c_str(), vstorage->LevelSummary(&tmp),
      bytes_read_per_sec, bytes_written_per_sec,
      compact_->compaction->output_level(),
      stats.num_input_files_in_non_output_levels,
-      stats.num_input_files_in_output_level,
-      stats.num_filtered_input_files_in_non_output_levels,
-      stats.num_filtered_input_files_in_output_level, stats.num_output_files,
+      stats.num_input_files_in_output_level, stats.num_output_files,
      stats.num_output_files_blob, stats.bytes_read_non_output_levels / kMB,
      stats.bytes_read_output_level / kMB, stats.bytes_read_blob / kMB,
-      stats.bytes_skipped_non_output_levels / kMB,
-      stats.bytes_skipped_output_level / kMB, stats.bytes_written / kMB,
-      stats.bytes_written_blob / kMB, read_write_amp, write_amp,
-      status.ToString().c_str(), stats.num_input_records,
+      stats.bytes_written / kMB, stats.bytes_written_blob / kMB, read_write_amp,
+      write_amp, status.ToString().c_str(), stats.num_input_records,
      stats.num_dropped_records,
      CompressionTypeToString(compact_->compaction->output_compression())
          .c_str());
@@ -1089,7 +1083,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    }
    // fallback to local compaction
    assert(comp_status == CompactionServiceJobStatus::kUseLocal);
-    sub_compact->compaction_job_stats.is_remote_compaction = false;
  }

  uint64_t prev_cpu_micros = db_options_.clock->CPUMicros();
@@ -1586,8 +1579,6 @@ Status CompactionJob::FinishCompactionOutputFile(
  const uint64_t current_entries = outputs.NumEntries();

  s = outputs.Finish(s, seqno_to_time_mapping_);
-  TEST_SYNC_POINT_CALLBACK(
-      "CompactionJob::FinishCompactionOutputFile()::AfterFinish", &s);

  if (s.ok()) {
    // With accurate smallest and largest key, we can get a slightly more
@@ -1920,10 +1911,6 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
    oldest_ancester_time = current_time;
  }

-  uint64_t newest_key_time = sub_compact->compaction->MaxInputFileNewestKeyTime(
-      sub_compact->start.has_value() ? &tmp_start : nullptr,
-      sub_compact->end.has_value() ? &tmp_end : nullptr);
-
  // Initialize a SubcompactionState::Output and add it to sub_compact->outputs
  uint64_t epoch_number = sub_compact->compaction->MinInputFileEpochNumber();
  {
@@ -1973,7 +1960,7 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
      cfd->internal_tbl_prop_coll_factories(),
      sub_compact->compaction->output_compression(),
      sub_compact->compaction->output_compression_opts(), cfd->GetID(),
-      cfd->GetName(), sub_compact->compaction->output_level(), newest_key_time,
+      cfd->GetName(), sub_compact->compaction->output_level(),
      bottommost_level_, TableFileCreationReason::kCompaction,
      0 /* oldest_key_time */, current_time, db_id_, db_session_id_,
      sub_compact->compaction->max_output_file_size(), file_number,
@@ -2016,8 +2003,7 @@ bool CompactionJob::UpdateCompactionStats(uint64_t* num_input_range_del) {
  for (int input_level = 0;
       input_level < static_cast<int>(compaction->num_input_levels());
       ++input_level) {
-    const LevelFilesBrief* flevel = compaction->input_levels(input_level);
-    size_t num_input_files = flevel->num_files;
+    size_t num_input_files = compaction->num_input_files(input_level);
    uint64_t* bytes_read;
    if (compaction->level(input_level) != compaction->output_level()) {
      compaction_stats_.stats.num_input_files_in_non_output_levels +=
@@ -2029,7 +2015,7 @@ bool CompactionJob::UpdateCompactionStats(uint64_t* num_input_range_del) {
      bytes_read = &compaction_stats_.stats.bytes_read_output_level;
    }
    for (size_t i = 0; i < num_input_files; ++i) {
-      const FileMetaData* file_meta = flevel->files[i].file_metadata;
+      const FileMetaData* file_meta = compaction->input(input_level, i);
      *bytes_read += file_meta->fd.GetFileSize();
      uint64_t file_input_entries = file_meta->num_entries;
      uint64_t file_num_range_del = file_meta->num_range_deletions;
@@ -2052,23 +2038,6 @@ bool CompactionJob::UpdateCompactionStats(uint64_t* num_input_range_del) {
        *num_input_range_del += file_num_range_del;
      }
    }
-
-    const std::vector<FileMetaData*>& filtered_flevel =
-        compaction->filtered_input_levels(input_level);
-    size_t num_filtered_input_files = filtered_flevel.size();
-    uint64_t* bytes_skipped;
-    if (compaction->level(input_level) != compaction->output_level()) {
-      compaction_stats_.stats.num_filtered_input_files_in_non_output_levels +=
-          static_cast<int>(num_filtered_input_files);
-      bytes_skipped = &compaction_stats_.stats.bytes_skipped_non_output_levels;
-    } else {
-      compaction_stats_.stats.num_filtered_input_files_in_output_level +=
-          static_cast<int>(num_filtered_input_files);
-      bytes_skipped = &compaction_stats_.stats.bytes_skipped_output_level;
-    }
-    for (const FileMetaData* filtered_file_meta : filtered_flevel) {
-      *bytes_skipped += filtered_file_meta->fd.GetFileSize();
-    }
  }

  assert(compaction_job_stats_);
@@ -2093,13 +2062,6 @@ void CompactionJob::UpdateCompactionJobStats(
      stats.num_input_files_in_output_level;
  compaction_job_stats_->num_input_files_at_output_level =
      stats.num_input_files_in_output_level;
-  compaction_job_stats_->num_filtered_input_files =
-      stats.num_filtered_input_files_in_non_output_levels +
-      stats.num_filtered_input_files_in_output_level;
-  compaction_job_stats_->num_filtered_input_files_at_output_level =
-      stats.num_filtered_input_files_in_output_level;
-  compaction_job_stats_->total_skipped_input_bytes =
-      stats.bytes_skipped_non_output_levels + stats.bytes_skipped_output_level;

  // output information
  compaction_job_stats_->total_output_bytes = stats.bytes_written;
@@ -209,13 +209,12 @@ class CompactionJob {
  // Returns true iff compaction_stats_.stats.num_input_records and
  // num_input_range_del are calculated successfully.
  bool UpdateCompactionStats(uint64_t* num_input_range_del = nullptr);
-  virtual void UpdateCompactionJobStats(
-      const InternalStats::CompactionStats& stats) const;
  void LogCompaction();
  virtual void RecordCompactionIOStats();
  void CleanupCompaction();

-  // Iterate through input and compact the kv-pairs.
+  // Call compaction filter. Then iterate through input and compact the
+  // kv-pairs
  void ProcessKeyValueCompaction(SubcompactionState* sub_compact);

  CompactionState* compact_;
@@ -280,7 +279,8 @@ class CompactionJob {
                                  bool* compaction_released);
  Status OpenCompactionOutputFile(SubcompactionState* sub_compact,
                                  CompactionOutputs& outputs);
-
+  void UpdateCompactionJobStats(
+      const InternalStats::CompactionStats& stats) const;
  void RecordDroppedKeys(const CompactionIterationStats& c_iter_stats,
                         CompactionJobStats* compaction_job_stats = nullptr);

@@ -377,7 +377,9 @@ class CompactionJob {
 // doesn't contain the LSM tree information, which is passed though MANIFEST
 // file.
 struct CompactionServiceInput {
-  std::string cf_name;
+  ColumnFamilyDescriptor column_family;
+
+  DBOptions db_options;

  std::vector<SequenceNumber> snapshots;

@@ -385,7 +387,7 @@ struct CompactionServiceInput {
  // files needed for this compaction, for both input level files and output
  // level files.
  std::vector<std::string> input_files;
-  int output_level = 0;
+  int output_level;

  // db_id is used to generate unique id of sst on the remote compactor
  std::string db_id;
@@ -396,12 +398,13 @@ struct CompactionServiceInput {
  bool has_end = false;
  std::string end;

-  uint64_t options_file_number = 0;
-
  // serialization interface to read and write the object
  static Status Read(const std::string& data_str, CompactionServiceInput* obj);
  Status Write(std::string* output);

+  // Initialize a dummy ColumnFamilyDescriptor
+  CompactionServiceInput() : column_family("", ColumnFamilyOptions()) {}
+
 #ifndef NDEBUG
  bool TEST_Equals(CompactionServiceInput* other);
  bool TEST_Equals(CompactionServiceInput* other, std::string* mismatch);
@@ -415,25 +418,20 @@ struct CompactionServiceOutputFile {
  SequenceNumber largest_seqno;
  std::string smallest_internal_key;
  std::string largest_internal_key;
-  uint64_t oldest_ancester_time = kUnknownOldestAncesterTime;
-  uint64_t file_creation_time = kUnknownFileCreationTime;
-  uint64_t epoch_number = kUnknownEpochNumber;
-  std::string file_checksum = kUnknownFileChecksum;
-  std::string file_checksum_func_name = kUnknownFileChecksumFuncName;
+  uint64_t oldest_ancester_time;
+  uint64_t file_creation_time;
+  uint64_t epoch_number;
  uint64_t paranoid_hash;
  bool marked_for_compaction;
-  UniqueId64x2 unique_id{};
-  TableProperties table_properties;
+  UniqueId64x2 unique_id;

  CompactionServiceOutputFile() = default;
  CompactionServiceOutputFile(
      const std::string& name, SequenceNumber smallest, SequenceNumber largest,
      std::string _smallest_internal_key, std::string _largest_internal_key,
      uint64_t _oldest_ancester_time, uint64_t _file_creation_time,
-      uint64_t _epoch_number, const std::string& _file_checksum,
-      const std::string& _file_checksum_func_name, uint64_t _paranoid_hash,
-      bool _marked_for_compaction, UniqueId64x2 _unique_id,
-      const TableProperties& _table_properties)
+      uint64_t _epoch_number, uint64_t _paranoid_hash,
+      bool _marked_for_compaction, UniqueId64x2 _unique_id)
      : file_name(name),
        smallest_seqno(smallest),
        largest_seqno(largest),
@@ -442,12 +440,9 @@ struct CompactionServiceOutputFile {
        oldest_ancester_time(_oldest_ancester_time),
        file_creation_time(_file_creation_time),
        epoch_number(_epoch_number),
-        file_checksum(_file_checksum),
-        file_checksum_func_name(_file_checksum_func_name),
        paranoid_hash(_paranoid_hash),
        marked_for_compaction(_marked_for_compaction),
-        unique_id(std::move(_unique_id)),
-        table_properties(_table_properties) {}
+        unique_id(std::move(_unique_id)) {}
 };

 // CompactionServiceResult contains the compaction result from a different db
@@ -456,11 +451,14 @@ struct CompactionServiceOutputFile {
 struct CompactionServiceResult {
  Status status;
  std::vector<CompactionServiceOutputFile> output_files;
-  int output_level = 0;
+  int output_level;

  // location of the output files
  std::string output_path;

+  // some statistics about the compaction
+  uint64_t num_output_records = 0;
+  uint64_t total_bytes = 0;
  uint64_t bytes_read = 0;
  uint64_t bytes_written = 0;
  CompactionJobStats stats;
@@ -506,9 +504,6 @@ class CompactionServiceCompactionJob : private CompactionJob {
 protected:
  void RecordCompactionIOStats() override;

-  void UpdateCompactionJobStats(
-      const InternalStats::CompactionStats& stats) const override;
-
 private:
  // Get table file name in output_path
  std::string GetTableFileName(uint64_t file_number) override;
@@ -50,8 +50,7 @@ void VerifyInitializationOfCompactionJobStats(
  ASSERT_EQ(compaction_job_stats.num_output_records, 0U);
  ASSERT_EQ(compaction_job_stats.num_output_files, 0U);

-  ASSERT_TRUE(compaction_job_stats.is_manual_compaction);
-  ASSERT_FALSE(compaction_job_stats.is_remote_compaction);
+  ASSERT_EQ(compaction_job_stats.is_manual_compaction, true);

  ASSERT_EQ(compaction_job_stats.total_input_bytes, 0U);
  ASSERT_EQ(compaction_job_stats.total_output_bytes, 0U);
@@ -250,7 +249,6 @@ class CompactionJobTestBase : public testing::Test {
    } else {
      assert(false);
    }
-    mutable_cf_options_.table_factory = cf_options_.table_factory;
  }

  std::string GenerateFileName(uint64_t file_number) {
@@ -301,13 +299,13 @@ class CompactionJobTestBase : public testing::Test {
    const WriteOptions write_options;
    std::unique_ptr<TableBuilder> table_builder(
        cf_options_.table_factory->NewTableBuilder(
-            TableBuilderOptions(
-                *cfd_->ioptions(), mutable_cf_options_, read_options,
-                write_options, cfd_->internal_comparator(),
-                cfd_->internal_tbl_prop_coll_factories(),
-                CompressionType::kNoCompression, CompressionOptions(),
-                0 /* column_family_id */, kDefaultColumnFamilyName,
-                -1 /* level */, kUnknownNewestKeyTime),
+            TableBuilderOptions(*cfd_->ioptions(), mutable_cf_options_,
+                                read_options, write_options,
+                                cfd_->internal_comparator(),
+                                cfd_->internal_tbl_prop_coll_factories(),
+                                CompressionType::kNoCompression,
+                                CompressionOptions(), 0 /* column_family_id */,
+                                kDefaultColumnFamilyName, -1 /* level */),
            file_writer.get()));
    // Build table.
    for (const auto& kv : contents) {
@@ -547,14 +545,15 @@ class CompactionJobTestBase : public testing::Test {
    ASSERT_OK(s);
    db_options_.info_log = info_log;

-    versions_.reset(
-        new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(),
-                       &write_buffer_manager_, &write_controller_,
-                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
-                       test::kUnitTestDbId, /*db_session_id=*/"",
-                       /*daily_offpeak_time_utc=*/"",
-                       /*error_handler=*/nullptr, /*read_only=*/false));
+    versions_.reset(new VersionSet(
+        dbname_, &db_options_, env_options_, table_cache_.get(),
+        &write_buffer_manager_, &write_controller_,
+        /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
+        /*db_id=*/"", /*db_session_id=*/"", /*daily_offpeak_time_utc=*/"",
+        /*error_handler=*/nullptr, /*read_only=*/false));
    compaction_job_stats_.Reset();
+    ASSERT_OK(
+        SetIdentityFile(WriteOptions(), env_, dbname_, Temperature::kUnknown));

    VersionEdit new_db;
    new_db.SetLogNumber(0);
@@ -652,8 +651,7 @@ class CompactionJobTestBase : public testing::Test {
        mutable_cf_options_.target_file_size_base,
        mutable_cf_options_.max_compaction_bytes, 0, kNoCompression,
        cfd->GetLatestMutableCFOptions()->compression_opts,
-        Temperature::kUnknown, max_subcompactions, grandparents,
-        /*earliest_snapshot*/ std::nullopt, /*snapshot_checker*/ nullptr, true);
+        Temperature::kUnknown, max_subcompactions, grandparents, true);
    compaction.FinalizeInputInfo(cfd->current());

    assert(db_options_.info_log);
@@ -1571,7 +1569,17 @@ TEST_F(CompactionJobTest, InputSerialization) {
  const int kStrMaxLen = 1000;
  Random rnd(static_cast<uint32_t>(time(nullptr)));
  Random64 rnd64(time(nullptr));
-  input.cf_name = rnd.RandomString(rnd.Uniform(kStrMaxLen));
+  input.column_family.name = rnd.RandomString(rnd.Uniform(kStrMaxLen));
+  input.column_family.options.comparator = ReverseBytewiseComparator();
+  input.column_family.options.max_bytes_for_level_base =
+      rnd64.Uniform(UINT64_MAX);
+  input.column_family.options.disable_auto_compactions = rnd.OneIn(2);
+  input.column_family.options.compression = kZSTD;
+  input.column_family.options.compression_opts.level = 4;
+  input.db_options.max_background_flushes = 10;
+  input.db_options.paranoid_checks = rnd.OneIn(2);
+  input.db_options.statistics = CreateDBStatistics();
+  input.db_options.env = env_;
  while (!rnd.OneIn(10)) {
    input.snapshots.emplace_back(rnd64.Uniform(UINT64_MAX));
  }
@@ -1599,10 +1607,10 @@ TEST_F(CompactionJobTest, InputSerialization) {
  ASSERT_TRUE(deserialized1.TEST_Equals(&input));

  // Test mismatch
-  deserialized1.output_level += 10;
+  deserialized1.db_options.max_background_flushes += 10;
  std::string mismatch;
  ASSERT_FALSE(deserialized1.TEST_Equals(&input, &mismatch));
-  ASSERT_EQ(mismatch, "output_level");
+  ASSERT_EQ(mismatch, "db_options.max_background_flushes");

  // Test unknown field
  CompactionServiceInput deserialized2;
@@ -1658,40 +1666,20 @@ TEST_F(CompactionJobTest, ResultSerialization) {
  };
  result.status =
      status_list.at(rnd.Uniform(static_cast<int>(status_list.size())));
-
-  std::string file_checksum = rnd.RandomBinaryString(rnd.Uniform(kStrMaxLen));
-  std::string file_checksum_func_name = "MyAwesomeChecksumGenerator";
  while (!rnd.OneIn(10)) {
-    TableProperties tp;
-    tp.user_collected_properties.emplace(
-        "UCP_Key1", rnd.RandomString(rnd.Uniform(kStrMaxLen)));
-    tp.user_collected_properties.emplace(
-        "UCP_Key2", rnd.RandomString(rnd.Uniform(kStrMaxLen)));
-    tp.readable_properties.emplace("RP_Key1",
-                                   rnd.RandomString(rnd.Uniform(kStrMaxLen)));
-    tp.readable_properties.emplace("RP_K2y2",
-                                   rnd.RandomString(rnd.Uniform(kStrMaxLen)));
-
    UniqueId64x2 id{rnd64.Uniform(UINT64_MAX), rnd64.Uniform(UINT64_MAX)};
    result.output_files.emplace_back(
-        rnd.RandomString(rnd.Uniform(kStrMaxLen)) /* file_name */,
-        rnd64.Uniform(UINT64_MAX) /* smallest_seqno */,
-        rnd64.Uniform(UINT64_MAX) /* largest_seqno */,
-        rnd.RandomBinaryString(
-            rnd.Uniform(kStrMaxLen)) /* smallest_internal_key */,
-        rnd.RandomBinaryString(
-            rnd.Uniform(kStrMaxLen)) /* largest_internal_key */,
-        rnd64.Uniform(UINT64_MAX) /* oldest_ancester_time */,
-        rnd64.Uniform(UINT64_MAX) /* file_creation_time */,
-        rnd64.Uniform(UINT64_MAX) /* epoch_number */,
-        file_checksum /* file_checksum */,
-        file_checksum_func_name /* file_checksum_func_name */,
-        rnd64.Uniform(UINT64_MAX) /* paranoid_hash */,
-        rnd.OneIn(2) /* marked_for_compaction */, id /* unique_id */, tp);
+        rnd.RandomString(rnd.Uniform(kStrMaxLen)), rnd64.Uniform(UINT64_MAX),
+        rnd64.Uniform(UINT64_MAX),
+        rnd.RandomBinaryString(rnd.Uniform(kStrMaxLen)),
+        rnd.RandomBinaryString(rnd.Uniform(kStrMaxLen)),
+        rnd64.Uniform(UINT64_MAX), rnd64.Uniform(UINT64_MAX),
+        rnd64.Uniform(UINT64_MAX), rnd64.Uniform(UINT64_MAX), rnd.OneIn(2), id);
  }
  result.output_level = rnd.Uniform(10);
  result.output_path = rnd.RandomString(rnd.Uniform(kStrMaxLen));
-  result.stats.num_output_records = rnd64.Uniform(UINT64_MAX);
+  result.num_output_records = rnd64.Uniform(UINT64_MAX);
+  result.total_bytes = rnd64.Uniform(UINT64_MAX);
  result.bytes_read = 123;
  result.bytes_written = rnd64.Uniform(UINT64_MAX);
  result.stats.elapsed_micros = rnd64.Uniform(UINT64_MAX);
@@ -1708,21 +1696,6 @@ TEST_F(CompactionJobTest, ResultSerialization) {
  ASSERT_OK(CompactionServiceResult::Read(output, &deserialized1));
  ASSERT_TRUE(deserialized1.TEST_Equals(&result));

-  for (size_t i = 0; i < result.output_files.size(); i++) {
-    for (const auto& prop :
-         result.output_files[i].table_properties.user_collected_properties) {
-      ASSERT_EQ(deserialized1.output_files[i]
-                    .table_properties.user_collected_properties[prop.first],
-                prop.second);
-    }
-    for (const auto& prop :
-         result.output_files[i].table_properties.readable_properties) {
-      ASSERT_EQ(deserialized1.output_files[i]
-                    .table_properties.readable_properties[prop.first],
-                prop.second);
-    }
-  }
-
  // Test mismatch
  deserialized1.stats.num_input_files += 10;
  std::string mismatch;
@@ -1737,10 +1710,6 @@ TEST_F(CompactionJobTest, ResultSerialization) {
    ASSERT_FALSE(deserialized_tmp.TEST_Equals(&result, &mismatch));
    ASSERT_EQ(mismatch, "output_files.unique_id");
    deserialized_tmp.status.PermitUncheckedError();
-
-    ASSERT_EQ(deserialized_tmp.output_files[0].file_checksum, file_checksum);
-    ASSERT_EQ(deserialized_tmp.output_files[0].file_checksum_func_name,
-              file_checksum_func_name);
  }

  // Test unknown field
@@ -62,9 +62,8 @@ class CompactionOutputs {
  }

  // TODO: Remove it when remote compaction support tiered compaction
-  void AddBytesWritten(uint64_t bytes) { stats_.bytes_written += bytes; }
+  void SetTotalBytes(uint64_t bytes) { stats_.bytes_written += bytes; }
  void SetNumOutputRecords(uint64_t num) { stats_.num_output_records = num; }
-  void SetNumOutputFiles(uint64_t num) { stats_.num_output_files = num; }

  // TODO: Move the BlobDB builder into CompactionOutputs
  const std::vector<BlobFileAddition>& GetBlobFileAdditions() const {
@@ -108,12 +107,6 @@ class CompactionOutputs {
  Status Finish(const Status& intput_status,
                const SeqnoToTimeMapping& seqno_to_time_mapping);

-  // Update output table properties from already populated TableProperties.
-  // Used for remote compaction
-  void UpdateTableProperties(const TableProperties& table_properties) {
-    current_output().table_properties =
-        std::make_shared<TableProperties>(table_properties);
-  }
  // Update output table properties from table builder
  void UpdateTableProperties() {
    current_output().table_properties =
@@ -133,8 +133,7 @@ CompactionPicker::CompactionPicker(const ImmutableOptions& ioptions,
 CompactionPicker::~CompactionPicker() = default;

 // Delete this compaction from the list of running compactions.
-void CompactionPicker::ReleaseCompactionFiles(Compaction* c,
-                                              const Status& status) {
+void CompactionPicker::ReleaseCompactionFiles(Compaction* c, Status status) {
  UnregisterCompaction(c);
  if (!status.ok()) {
    c->ResetNextCompactionIndex();
@@ -351,11 +350,11 @@ Compaction* CompactionPicker::CompactFiles(
      break;
    }
  }
-  assert(output_level == 0 || !FilesRangeOverlapWithCompaction(
-                                  input_files, output_level,
-                                  Compaction::EvaluatePenultimateLevel(
-                                      vstorage, mutable_cf_options, ioptions_,
-                                      start_level, output_level)));
+  assert(output_level == 0 ||
+         !FilesRangeOverlapWithCompaction(
+             input_files, output_level,
+             Compaction::EvaluatePenultimateLevel(vstorage, ioptions_,
+                                                  start_level, output_level)));
 #endif /* !NDEBUG */

  CompressionType compression_type;
@@ -380,8 +379,7 @@ Compaction* CompactionPicker::CompactFiles(
      GetCompressionOptions(mutable_cf_options, vstorage, output_level),
      mutable_cf_options.default_write_temperature,
      compact_options.max_subcompactions,
-      /* grandparents */ {}, /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr, true);
+      /* grandparents */ {}, true);
  RegisterCompaction(c);
  return c;
 }
@@ -659,9 +657,8 @@ Compaction* CompactionPicker::CompactRange(
    // overlaping outputs in the same level.
    if (FilesRangeOverlapWithCompaction(
            inputs, output_level,
-            Compaction::EvaluatePenultimateLevel(vstorage, mutable_cf_options,
-                                                 ioptions_, start_level,
-                                                 output_level))) {
+            Compaction::EvaluatePenultimateLevel(vstorage, ioptions_,
+                                                 start_level, output_level))) {
      // This compaction output could potentially conflict with the output
      // of a currently running compaction, we cannot run it.
      *manual_conflict = true;
@@ -679,9 +676,7 @@ Compaction* CompactionPicker::CompactRange(
        GetCompressionOptions(mutable_cf_options, vstorage, output_level),
        mutable_cf_options.default_write_temperature,
        compact_range_options.max_subcompactions,
-        /* grandparents */ {}, /* earliest_snapshot */ std::nullopt,
-        /* snapshot_checker */ nullptr,
-        /* is manual */ true, trim_ts, /* score */ -1,
+        /* grandparents */ {}, /* is manual */ true, trim_ts, /* score */ -1,
        /* deletion_compaction */ false, /* l0_files_might_overlap */ true,
        CompactionReason::kUnknown,
        compact_range_options.blob_garbage_collection_policy,
@@ -847,8 +842,7 @@ Compaction* CompactionPicker::CompactRange(
  // overlaping outputs in the same level.
  if (FilesRangeOverlapWithCompaction(
          compaction_inputs, output_level,
-          Compaction::EvaluatePenultimateLevel(vstorage, mutable_cf_options,
-                                               ioptions_, input_level,
+          Compaction::EvaluatePenultimateLevel(vstorage, ioptions_, input_level,
                                               output_level))) {
    // This compaction output could potentially conflict with the output
    // of a currently running compaction, we cannot run it.
@@ -871,7 +865,6 @@ Compaction* CompactionPicker::CompactRange(
      GetCompressionOptions(mutable_cf_options, vstorage, output_level),
      mutable_cf_options.default_write_temperature,
      compact_range_options.max_subcompactions, std::move(grandparents),
-      /* earliest_snapshot */ std::nullopt, /* snapshot_checker */ nullptr,
      /* is manual */ true, trim_ts, /* score */ -1,
      /* deletion_compaction */ false, /* l0_files_might_overlap */ true,
      CompactionReason::kUnknown,
@@ -1051,12 +1044,10 @@ Status CompactionPicker::SanitizeCompactionInputFilesForAllLevels(
 }

 Status CompactionPicker::SanitizeAndConvertCompactionInputFiles(
-    std::unordered_set<uint64_t>* input_files, const int output_level,
-    Version* version,
+    std::unordered_set<uint64_t>* input_files,
+    const ColumnFamilyMetaData& cf_meta, const int output_level,
+    const VersionStorageInfo* vstorage,
    std::vector<CompactionInputFiles>* converted_input_files) const {
-  ColumnFamilyMetaData cf_meta;
-  version->GetColumnFamilyMetaData(&cf_meta);
-
  assert(static_cast<int>(cf_meta.levels.size()) - 1 ==
         cf_meta.levels[cf_meta.levels.size() - 1].level);
  assert(converted_input_files);
@@ -1127,8 +1118,7 @@ Status CompactionPicker::SanitizeAndConvertCompactionInputFiles(
  }

  s = GetCompactionInputsFromFileNumbers(converted_input_files, input_files,
-                                         version->storage_info(),
-                                         CompactionOptions());
+                                         vstorage, CompactionOptions());
  if (!s.ok()) {
    return s;
  }
@@ -1137,8 +1127,8 @@ Status CompactionPicker::SanitizeAndConvertCompactionInputFiles(
      FilesRangeOverlapWithCompaction(
          *converted_input_files, output_level,
          Compaction::EvaluatePenultimateLevel(
-              version->storage_info(), version->GetMutableCFOptions(),
-              ioptions_, (*converted_input_files)[0].level, output_level))) {
+              vstorage, ioptions_, (*converted_input_files)[0].level,
+              output_level))) {
    return Status::Aborted(
        "A running compaction is writing to the same output level(s) in an "
        "overlapping key range");
@@ -1180,8 +1170,7 @@ void CompactionPicker::UnregisterCompaction(Compaction* c) {

 void CompactionPicker::PickFilesMarkedForCompaction(
    const std::string& cf_name, VersionStorageInfo* vstorage, int* start_level,
-    int* output_level, CompactionInputFiles* start_level_inputs,
-    std::function<bool(const FileMetaData*)> skip_marked_file) {
+    int* output_level, CompactionInputFiles* start_level_inputs) {
  if (vstorage->FilesMarkedForCompaction().empty()) {
    return;
  }
@@ -1191,9 +1180,6 @@ void CompactionPicker::PickFilesMarkedForCompaction(
    // If this assert() fails that means that some function marked some
    // files as being_compacted, but didn't call ComputeCompactionScore()
    assert(!level_file.second->being_compacted);
-    if (skip_marked_file(level_file.second)) {
-      return false;
-    }
    *start_level = level_file.first;
    *output_level =
        (*start_level == 0) ? vstorage->base_level() : *start_level + 1;
@@ -16,7 +16,6 @@
 #include <vector>

 #include "db/compaction/compaction.h"
-#include "db/snapshot_checker.h"
 #include "db/version_set.h"
 #include "options/cf_options.h"
 #include "rocksdb/env.h"
@@ -56,17 +55,17 @@ class CompactionPicker {
  // Returns nullptr if there is no compaction to be done.
  // Otherwise returns a pointer to a heap-allocated object that
  // describes the compaction.  Caller should delete the result.
-  // Currently, only universal compaction will query existing snapshots and
-  // pass it to aid compaction picking. And it's only passed when user-defined
-  // timestamps is not enabled. The other compaction styles do not pass or use
-  // `existing_snapshots` or `snapshot_checker`.
-  virtual Compaction* PickCompaction(
-      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options,
-      const std::vector<SequenceNumber>& existing_snapshots,
-      const SnapshotChecker* snapshot_checker, VersionStorageInfo* vstorage,
-      LogBuffer* log_buffer) = 0;
+  virtual Compaction* PickCompaction(const std::string& cf_name,
+                                     const MutableCFOptions& mutable_cf_options,
+                                     const MutableDBOptions& mutable_db_options,
+                                     VersionStorageInfo* vstorage,
+                                     LogBuffer* log_buffer) = 0;

+  // Return a compaction object for compacting the range [begin,end] in
+  // the specified level.  Returns nullptr if there is nothing in that
+  // level that overlaps the specified range.  Caller should delete
+  // the result.
+  //
  // The returned Compaction might not include the whole requested range.
  // In that case, compaction_end will be set to the next key that needs
  // compacting. In case the compaction will compact the whole range,
@@ -97,14 +96,15 @@ class CompactionPicker {
  // non-ok status with specific reason.
  //
  Status SanitizeAndConvertCompactionInputFiles(
-      std::unordered_set<uint64_t>* input_files, const int output_level,
-      Version* version,
+      std::unordered_set<uint64_t>* input_files,
+      const ColumnFamilyMetaData& cf_meta, const int output_level,
+      const VersionStorageInfo* vstorage,
      std::vector<CompactionInputFiles>* converted_input_files) const;

  // Free up the files that participated in a compaction
  //
  // Requirement: DB mutex held
-  void ReleaseCompactionFiles(Compaction* c, const Status& status);
+  void ReleaseCompactionFiles(Compaction* c, Status status);

  // Returns true if any one of the specified files are being compacted
  bool AreFilesInCompaction(const std::vector<FileMetaData*>& files);
@@ -203,11 +203,10 @@ class CompactionPicker {
                       const CompactionInputFiles& output_level_inputs,
                       std::vector<FileMetaData*>* grandparents);

-  void PickFilesMarkedForCompaction(
-      const std::string& cf_name, VersionStorageInfo* vstorage,
-      int* start_level, int* output_level,
-      CompactionInputFiles* start_level_inputs,
-      std::function<bool(const FileMetaData*)> skip_marked_file);
+  void PickFilesMarkedForCompaction(const std::string& cf_name,
+                                    VersionStorageInfo* vstorage,
+                                    int* start_level, int* output_level,
+                                    CompactionInputFiles* start_level_inputs);

  bool GetOverlappingL0Files(VersionStorageInfo* vstorage,
                             CompactionInputFiles* start_level_inputs,
@@ -258,13 +257,11 @@ class NullCompactionPicker : public CompactionPicker {
  virtual ~NullCompactionPicker() {}

  // Always return "nullptr"
-  Compaction* PickCompaction(
-      const std::string& /*cf_name*/,
-      const MutableCFOptions& /*mutable_cf_options*/,
-      const MutableDBOptions& /*mutable_db_options*/,
-      const std::vector<SequenceNumber>& /*existing_snapshots*/,
-      const SnapshotChecker* /*snapshot_checker*/,
-      VersionStorageInfo* /*vstorage*/, LogBuffer* /* log_buffer */) override {
+  Compaction* PickCompaction(const std::string& /*cf_name*/,
+                             const MutableCFOptions& /*mutable_cf_options*/,
+                             const MutableDBOptions& /*mutable_db_options*/,
+                             VersionStorageInfo* /*vstorage*/,
+                             LogBuffer* /* log_buffer */) override {
    return nullptr;
  }

@@ -79,14 +79,10 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
      FileMetaData* f = *ritr;
      assert(f);
      if (f->fd.table_reader && f->fd.table_reader->GetTableProperties()) {
-        uint64_t newest_key_time = f->TryGetNewestKeyTime();
        uint64_t creation_time =
            f->fd.table_reader->GetTableProperties()->creation_time;
-        uint64_t est_newest_key_time = newest_key_time == kUnknownNewestKeyTime
-                                           ? creation_time
-                                           : newest_key_time;
-        if (est_newest_key_time == kUnknownNewestKeyTime ||
-            est_newest_key_time >= (current_time - mutable_cf_options.ttl)) {
+        if (creation_time == 0 ||
+            creation_time >= (current_time - mutable_cf_options.ttl)) {
          break;
        }
      }
@@ -106,19 +102,15 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
  }

  for (const auto& f : inputs[0].files) {
-    assert(f);
-    uint64_t newest_key_time = f->TryGetNewestKeyTime();
    uint64_t creation_time = 0;
+    assert(f);
    if (f->fd.table_reader && f->fd.table_reader->GetTableProperties()) {
      creation_time = f->fd.table_reader->GetTableProperties()->creation_time;
    }
-    uint64_t est_newest_key_time = newest_key_time == kUnknownNewestKeyTime
-                                       ? creation_time
-                                       : newest_key_time;
    ROCKS_LOG_BUFFER(log_buffer,
                     "[%s] FIFO compaction: picking file %" PRIu64
-                     " with estimated newest key time %" PRIu64 " for deletion",
-                     cf_name.c_str(), f->fd.GetNumber(), est_newest_key_time);
+                     " with creation time %" PRIu64 " for deletion",
+                     cf_name.c_str(), f->fd.GetNumber(), creation_time);
  }

  Compaction* c = new Compaction(
@@ -126,9 +118,7 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
      std::move(inputs), 0, 0, 0, 0, kNoCompression,
      mutable_cf_options.compression_opts,
      mutable_cf_options.default_write_temperature,
-      /* max_subcompactions */ 0, {}, /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr,
-      /* is manual */ false,
+      /* max_subcompactions */ 0, {}, /* is manual */ false,
      /* trim_ts */ "", vstorage->CompactionScore(0),
      /* is deletion compaction */ true, /* l0_files_might_overlap */ true,
      CompactionReason::kFIFOTtl);
@@ -198,9 +188,7 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
            0 /* output path ID */, mutable_cf_options.compression,
            mutable_cf_options.compression_opts,
            mutable_cf_options.default_write_temperature,
-            0 /* max_subcompactions */, {},
-            /* earliest_snapshot */ std::nullopt,
-            /* snapshot_checker */ nullptr, /* is manual */ false,
+            0 /* max_subcompactions */, {}, /* is manual */ false,
            /* trim_ts */ "", vstorage->CompactionScore(0),
            /* is deletion compaction */ false,
            /* l0_files_might_overlap */ true,
@@ -296,9 +284,7 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
      /* output_path_id */ 0, kNoCompression,
      mutable_cf_options.compression_opts,
      mutable_cf_options.default_write_temperature,
-      /* max_subcompactions */ 0, {}, /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr,
-      /* is manual */ false,
+      /* max_subcompactions */ 0, {}, /* is manual */ false,
      /* trim_ts */ "", vstorage->CompactionScore(0),
      /* is deletion compaction */ true,
      /* l0_files_might_overlap */ true, CompactionReason::kFIFOMaxSize);
@@ -308,7 +294,7 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
 Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
    const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-    LogBuffer* log_buffer) const {
+    LogBuffer* log_buffer) {
  const std::vector<FileTemperatureAge>& ages =
      mutable_cf_options.compaction_options_fifo
          .file_temperature_age_thresholds;
@@ -358,47 +344,73 @@ Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(
  Temperature compaction_target_temp = Temperature::kLastTemperature;
  if (current_time > min_age) {
    uint64_t create_time_threshold = current_time - min_age;
+    uint64_t compaction_size = 0;
+    // We will ideally identify a file qualifying for temperature change by
+    // knowing the timestamp for the youngest entry in the file. However, right
+    // now we don't have the information. We infer it by looking at timestamp of
+    // the previous file's (which is just younger) oldest entry's timestamp.
+    Temperature cur_target_temp;
+    // avoid index underflow
    assert(level_files.size() >= 1);
-    for (size_t index = level_files.size(); index >= 1; --index) {
+    for (size_t index = level_files.size() - 1; index >= 1; --index) {
      // Try to add cur_file to compaction inputs.
-      FileMetaData* cur_file = level_files[index - 1];
-      FileMetaData* prev_file = index < 2 ? nullptr : level_files[index - 2];
+      FileMetaData* cur_file = level_files[index];
+      // prev_file is just younger than cur_file
+      FileMetaData* prev_file = level_files[index - 1];
      if (cur_file->being_compacted) {
        // Should not happen since we check for
        // `level0_compactions_in_progress_` above. Here we simply just don't
        // schedule anything.
        return nullptr;
      }
-      uint64_t est_newest_key_time = cur_file->TryGetNewestKeyTime(prev_file);
-      // Newer file could have newest_key_time populated
-      if (est_newest_key_time == kUnknownNewestKeyTime) {
-        continue;
-      }
-      if (est_newest_key_time > create_time_threshold) {
+      uint64_t oldest_ancestor_time = prev_file->TryGetOldestAncesterTime();
+      if (oldest_ancestor_time == kUnknownOldestAncesterTime) {
+        // Older files might not have enough information. It is possible to
+        // handle these files by looking at newer files, but maintaining the
+        // logic isn't worth it.
        break;
      }
-      Temperature cur_target_temp = ages[0].temperature;
+      if (oldest_ancestor_time > create_time_threshold) {
+        // cur_file is too fresh
+        break;
+      }
+      cur_target_temp = ages[0].temperature;
      for (size_t i = 1; i < ages.size(); ++i) {
        if (current_time >= ages[i].age &&
-            est_newest_key_time <= current_time - ages[i].age) {
+            oldest_ancestor_time <= current_time - ages[i].age) {
          cur_target_temp = ages[i].temperature;
        }
      }
      if (cur_file->temperature == cur_target_temp) {
-        continue;
+        if (inputs[0].empty()) {
+          continue;
+        } else {
+          break;
+        }
      }

      // cur_file needs to change temperature
-      assert(compaction_target_temp == Temperature::kLastTemperature);
-      compaction_target_temp = cur_target_temp;
-      inputs[0].files.push_back(cur_file);
-      ROCKS_LOG_BUFFER(
-          log_buffer,
-          "[%s] FIFO compaction: picking file %" PRIu64
-          " with estimated newest key time %" PRIu64 " for temperature %s.",
-          cf_name.c_str(), cur_file->fd.GetNumber(), est_newest_key_time,
-          temperature_to_string[cur_target_temp].c_str());
-      break;
+      if (compaction_target_temp == Temperature::kLastTemperature) {
+        assert(inputs[0].empty());
+        compaction_target_temp = cur_target_temp;
+      } else if (cur_target_temp != compaction_target_temp) {
+        assert(!inputs[0].empty());
+        break;
+      }
+      if (inputs[0].empty() || compaction_size + cur_file->fd.GetFileSize() <=
+                                   mutable_cf_options.max_compaction_bytes) {
+        inputs[0].files.push_back(cur_file);
+        compaction_size += cur_file->fd.GetFileSize();
+        ROCKS_LOG_BUFFER(
+            log_buffer,
+            "[%s] FIFO compaction: picking file %" PRIu64
+            " with next file's oldest time %" PRIu64 " for temperature %s.",
+            cf_name.c_str(), cur_file->fd.GetNumber(), oldest_ancestor_time,
+            temperature_to_string[cur_target_temp].c_str());
+      }
+      if (compaction_size > mutable_cf_options.max_compaction_bytes) {
+        break;
+      }
    }
  }

@@ -406,18 +418,15 @@ Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(
    return nullptr;
  }
  assert(compaction_target_temp != Temperature::kLastTemperature);
-  // Only compact one file at a time.
-  assert(inputs.size() == 1);
-  assert(inputs[0].size() == 1);
+
  Compaction* c = new Compaction(
      vstorage, ioptions_, mutable_cf_options, mutable_db_options,
      std::move(inputs), 0, 0 /* output file size limit */,
      0 /* max compaction bytes, not applicable */, 0 /* output path ID */,
      mutable_cf_options.compression, mutable_cf_options.compression_opts,
      compaction_target_temp,
-      /* max_subcompactions */ 0, {}, /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr,
-      /* is manual */ false, /* trim_ts */ "", vstorage->CompactionScore(0),
+      /* max_subcompactions */ 0, {}, /* is manual */ false, /* trim_ts */ "",
+      vstorage->CompactionScore(0),
      /* is deletion compaction */ false, /* l0_files_might_overlap */ true,
      CompactionReason::kChangeTemperature);
  return c;
@@ -425,9 +434,7 @@ Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(

 Compaction* FIFOCompactionPicker::PickCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-    const MutableDBOptions& mutable_db_options,
-    const std::vector<SequenceNumber>& /* existing_snapshots */,
-    const SnapshotChecker* /* snapshot_checker */, VersionStorageInfo* vstorage,
+    const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
    LogBuffer* log_buffer) {
  Compaction* c = nullptr;
  if (mutable_cf_options.ttl > 0) {
@@ -462,10 +469,8 @@ Compaction* FIFOCompactionPicker::CompactRange(
  assert(output_level == 0);
  *compaction_end = nullptr;
  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, ioptions_.logger);
-  Compaction* c =
-      PickCompaction(cf_name, mutable_cf_options, mutable_db_options,
-                     /*existing_snapshots*/ {}, /*snapshot_checker*/ nullptr,
-                     vstorage, &log_buffer);
+  Compaction* c = PickCompaction(cf_name, mutable_cf_options,
+                                 mutable_db_options, vstorage, &log_buffer);
  log_buffer.FlushBufferToLog();
  return c;
 }
@@ -18,12 +18,11 @@ class FIFOCompactionPicker : public CompactionPicker {
                       const InternalKeyComparator* icmp)
      : CompactionPicker(ioptions, icmp) {}

-  Compaction* PickCompaction(
-      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options,
-      const std::vector<SequenceNumber>& /* existing_snapshots */,
-      const SnapshotChecker* /* snapshot_checker */,
-      VersionStorageInfo* version, LogBuffer* log_buffer) override;
+  Compaction* PickCompaction(const std::string& cf_name,
+                             const MutableCFOptions& mutable_cf_options,
+                             const MutableDBOptions& mutable_db_options,
+                             VersionStorageInfo* version,
+                             LogBuffer* log_buffer) override;

  Compaction* CompactRange(const std::string& cf_name,
                           const MutableCFOptions& mutable_cf_options,
@@ -54,10 +53,9 @@ class FIFOCompactionPicker : public CompactionPicker {
                                 VersionStorageInfo* version,
                                 LogBuffer* log_buffer);

-  // Will pick one file to compact at a time, starting from the oldest file.
  Compaction* PickTemperatureChangeCompaction(
      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
      const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-      LogBuffer* log_buffer) const;
+      LogBuffer* log_buffer);
 };
 }  // namespace ROCKSDB_NAMESPACE
@@ -262,10 +262,7 @@ void LevelCompactionBuilder::SetupInitialFiles() {
  parent_index_ = base_index_ = -1;

  compaction_picker_->PickFilesMarkedForCompaction(
-      cf_name_, vstorage_, &start_level_, &output_level_, &start_level_inputs_,
-      /*skip_marked_file*/ [](const FileMetaData* /* file */) {
-        return false;
-      });
+      cf_name_, vstorage_, &start_level_, &output_level_, &start_level_inputs_);
  if (!start_level_inputs_.empty()) {
    compaction_reason_ = CompactionReason::kFilesMarkedForCompaction;
    return;
@@ -414,9 +411,8 @@ void LevelCompactionBuilder::SetupOtherFilesWithRoundRobinExpansion() {
                                                    &tmp_start_level_inputs) ||
        compaction_picker_->FilesRangeOverlapWithCompaction(
            {tmp_start_level_inputs}, output_level_,
-            Compaction::EvaluatePenultimateLevel(vstorage_, mutable_cf_options_,
-                                                 ioptions_, start_level_,
-                                                 output_level_))) {
+            Compaction::EvaluatePenultimateLevel(
+                vstorage_, ioptions_, start_level_, output_level_))) {
      // Constraint 1a
      tmp_start_level_inputs.clear();
      return;
@@ -490,9 +486,8 @@ bool LevelCompactionBuilder::SetupOtherInputsIfNeeded() {
    // We need to disallow this from happening.
    if (compaction_picker_->FilesRangeOverlapWithCompaction(
            compaction_inputs_, output_level_,
-            Compaction::EvaluatePenultimateLevel(vstorage_, mutable_cf_options_,
-                                                 ioptions_, start_level_,
-                                                 output_level_))) {
+            Compaction::EvaluatePenultimateLevel(
+                vstorage_, ioptions_, start_level_, output_level_))) {
      // This compaction output could potentially conflict with the output
      // of a currently running compaction, we cannot run it.
      return false;
@@ -559,9 +554,7 @@ Compaction* LevelCompactionBuilder::GetCompaction() {
                         vstorage_->base_level()),
      GetCompressionOptions(mutable_cf_options_, vstorage_, output_level_),
      mutable_cf_options_.default_write_temperature,
-      /* max_subcompactions */ 0, std::move(grandparents_),
-      /* earliest_snapshot */ std::nullopt, /* snapshot_checker */ nullptr,
-      is_manual_,
+      /* max_subcompactions */ 0, std::move(grandparents_), is_manual_,
      /* trim_ts */ "", start_level_score_, false /* deletion_compaction */,
      l0_files_might_overlap, compaction_reason_);

@@ -846,9 +839,8 @@ bool LevelCompactionBuilder::PickFileToCompact() {
                                                    &start_level_inputs_) ||
        compaction_picker_->FilesRangeOverlapWithCompaction(
            {start_level_inputs_}, output_level_,
-            Compaction::EvaluatePenultimateLevel(vstorage_, mutable_cf_options_,
-                                                 ioptions_, start_level_,
-                                                 output_level_))) {
+            Compaction::EvaluatePenultimateLevel(
+                vstorage_, ioptions_, start_level_, output_level_))) {
      // A locked (pending compaction) input-level file was pulled in due to
      // user-key overlap.
      start_level_inputs_.clear();
@@ -975,9 +967,7 @@ bool LevelCompactionBuilder::PickSizeBasedIntraL0Compaction() {

 Compaction* LevelCompactionPicker::PickCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-    const MutableDBOptions& mutable_db_options,
-    const std::vector<SequenceNumber>& /*existing_snapshots */,
-    const SnapshotChecker* /*snapshot_checker*/, VersionStorageInfo* vstorage,
+    const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
    LogBuffer* log_buffer) {
  LevelCompactionBuilder builder(cf_name, vstorage, this, log_buffer,
                                 mutable_cf_options, ioptions_,
@@ -20,12 +20,11 @@ class LevelCompactionPicker : public CompactionPicker {
  LevelCompactionPicker(const ImmutableOptions& ioptions,
                        const InternalKeyComparator* icmp)
      : CompactionPicker(ioptions, icmp) {}
-  Compaction* PickCompaction(
-      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options,
-      const std::vector<SequenceNumber>& /* existing_snapshots */,
-      const SnapshotChecker* /* snapshot_checker */,
-      VersionStorageInfo* vstorage, LogBuffer* log_buffer) override;
+  Compaction* PickCompaction(const std::string& cf_name,
+                             const MutableCFOptions& mutable_cf_options,
+                             const MutableDBOptions& mutable_db_options,
+                             VersionStorageInfo* vstorage,
+                             LogBuffer* log_buffer) override;

  bool NeedsCompaction(const VersionStorageInfo* vstorage) const override;
 };
@@ -35,9 +35,7 @@ class UniversalCompactionBuilder {
  UniversalCompactionBuilder(
      const ImmutableOptions& ioptions, const InternalKeyComparator* icmp,
      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options,
-      const std::vector<SequenceNumber>& existing_snapshots,
-      const SnapshotChecker* snapshot_checker, VersionStorageInfo* vstorage,
+      const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
      UniversalCompactionPicker* picker, LogBuffer* log_buffer)
      : ioptions_(ioptions),
        icmp_(icmp),
@@ -46,19 +44,7 @@ class UniversalCompactionBuilder {
        mutable_db_options_(mutable_db_options),
        vstorage_(vstorage),
        picker_(picker),
-        log_buffer_(log_buffer) {
-    assert(icmp_);
-    const auto* ucmp = icmp_->user_comparator();
-    assert(ucmp);
-    // These parameters are only passed when user-defined timestamp is not
-    // enabled.
-    if (ucmp->timestamp_size() == 0) {
-      earliest_snapshot_ = existing_snapshots.empty()
-                               ? kMaxSequenceNumber
-                               : existing_snapshots.at(0);
-      snapshot_checker_ = snapshot_checker;
-    }
-  }
+        log_buffer_(log_buffer) {}

  // Form and return the compaction object. The caller owns return object.
  Compaction* PickCompaction();
@@ -66,15 +52,12 @@ class UniversalCompactionBuilder {
 private:
  struct SortedRun {
    SortedRun(int _level, FileMetaData* _file, uint64_t _size,
-              uint64_t _compensated_file_size, bool _being_compacted,
-              bool _level_has_marked_standalone_rangedel)
+              uint64_t _compensated_file_size, bool _being_compacted)
        : level(_level),
          file(_file),
          size(_size),
          compensated_file_size(_compensated_file_size),
-          being_compacted(_being_compacted),
-          level_has_marked_standalone_rangedel(
-              _level_has_marked_standalone_rangedel) {
+          being_compacted(_being_compacted) {
      assert(compensated_file_size > 0);
      assert(level != 0 || file != nullptr);
    }
@@ -96,10 +79,6 @@ class UniversalCompactionBuilder {
    uint64_t size;
    uint64_t compensated_file_size;
    bool being_compacted;
-    // True if this level has any file that is a standalone range deletion file
-    // marked for compaction. Best effort is made to make only deletion
-    // triggered compaction pick this type of file.
-    bool level_has_marked_standalone_rangedel;
  };

  // Pick Universal compaction to limit read amplification
@@ -119,11 +98,6 @@ class UniversalCompactionBuilder {

  Compaction* PickDeleteTriggeredCompaction();

-  // Returns true if this given file (that is marked be compaction) should be
-  // skipped from being picked for now. We do this to best use standalone range
-  // tombstone files.
-  bool ShouldSkipMarkedFile(const FileMetaData* file) const;
-
  // Form a compaction from the sorted run indicated by start_index to the
  // oldest sorted run.
  // The caller is responsible for making sure that those files are not in
@@ -142,7 +116,7 @@ class UniversalCompactionBuilder {

  bool ShouldSkipLastSortedRunForSizeAmpCompaction() const {
    assert(!sorted_runs_.empty());
-    return mutable_cf_options_.preclude_last_level_data_seconds > 0 &&
+    return ioptions_.preclude_last_level_data_seconds > 0 &&
           ioptions_.num_levels > 2 &&
           sorted_runs_.back().level == ioptions_.num_levels - 1 &&
           sorted_runs_.size() > 1;
@@ -260,18 +234,8 @@ class UniversalCompactionBuilder {
  VersionStorageInfo* vstorage_;
  UniversalCompactionPicker* picker_;
  LogBuffer* log_buffer_;
-  // Optional earliest snapshot at time of compaction picking. This is only
-  // provided if the column family doesn't enable user-defined timestamps.
-  // And this information is only passed to `Compaction` picked by deletion
-  // triggered compaction for possible optimizations.
-  std::optional<SequenceNumber> earliest_snapshot_;
-  const SnapshotChecker* snapshot_checker_;
-  // Mapping from file id to its index in the sorted run for the files that are
-  // marked for compaction. This is only populated when snapshot info is
-  // populated.
-  std::map<uint64_t, size_t> file_marked_for_compaction_to_sorted_run_index_;

-  std::vector<UniversalCompactionBuilder::SortedRun> CalculateSortedRuns(
+  static std::vector<UniversalCompactionBuilder::SortedRun> CalculateSortedRuns(
      const VersionStorageInfo& vstorage, int last_level,
      uint64_t* max_run_size);

@@ -430,13 +394,11 @@ bool UniversalCompactionPicker::NeedsCompaction(

 Compaction* UniversalCompactionPicker::PickCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-    const MutableDBOptions& mutable_db_options,
-    const std::vector<SequenceNumber>& existing_snapshots,
-    const SnapshotChecker* snapshot_checker, VersionStorageInfo* vstorage,
+    const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
    LogBuffer* log_buffer) {
-  UniversalCompactionBuilder builder(
-      ioptions_, icmp_, cf_name, mutable_cf_options, mutable_db_options,
-      existing_snapshots, snapshot_checker, vstorage, this, log_buffer);
+  UniversalCompactionBuilder builder(ioptions_, icmp_, cf_name,
+                                     mutable_cf_options, mutable_db_options,
+                                     vstorage, this, log_buffer);
  return builder.PickCompaction();
 }

@@ -486,20 +448,14 @@ UniversalCompactionBuilder::CalculateSortedRuns(
  *max_run_size = 0;
  std::vector<UniversalCompactionBuilder::SortedRun> ret;
  for (FileMetaData* f : vstorage.LevelFiles(0)) {
-    if (earliest_snapshot_.has_value() && f->marked_for_compaction) {
-      file_marked_for_compaction_to_sorted_run_index_.emplace(f->fd.GetNumber(),
-                                                              ret.size());
-    }
-    ret.emplace_back(
-        0, f, f->fd.GetFileSize(), f->compensated_file_size, f->being_compacted,
-        f->marked_for_compaction && f->FileIsStandAloneRangeTombstone());
+    ret.emplace_back(0, f, f->fd.GetFileSize(), f->compensated_file_size,
+                     f->being_compacted);
    *max_run_size = std::max(*max_run_size, f->fd.GetFileSize());
  }
  for (int level = 1; level <= last_level; level++) {
    uint64_t total_compensated_size = 0U;
    uint64_t total_size = 0U;
    bool being_compacted = false;
-    bool level_has_marked_standalone_rangedel = false;
    for (FileMetaData* f : vstorage.LevelFiles(level)) {
      total_compensated_size += f->compensated_file_size;
      total_size += f->fd.GetFileSize();
@@ -511,57 +467,16 @@ UniversalCompactionBuilder::CalculateSortedRuns(
      if (f->being_compacted) {
        being_compacted = f->being_compacted;
      }
-      level_has_marked_standalone_rangedel =
-          level_has_marked_standalone_rangedel ||
-          (f->marked_for_compaction && f->FileIsStandAloneRangeTombstone());
-      if (earliest_snapshot_.has_value() && f->marked_for_compaction) {
-        file_marked_for_compaction_to_sorted_run_index_.emplace(
-            f->fd.GetNumber(), ret.size());
-      }
    }
    if (total_compensated_size > 0) {
      ret.emplace_back(level, nullptr, total_size, total_compensated_size,
-                       being_compacted, level_has_marked_standalone_rangedel);
+                       being_compacted);
    }
    *max_run_size = std::max(*max_run_size, total_size);
  }
  return ret;
 }

-bool UniversalCompactionBuilder::ShouldSkipMarkedFile(
-    const FileMetaData* file) const {
-  assert(file->marked_for_compaction);
-  if (!earliest_snapshot_.has_value()) {
-    return false;
-  }
-  if (!file->FileIsStandAloneRangeTombstone()) {
-    return false;
-  }
-  // Skip until earliest snapshot advances at or above this standalone range
-  // tombstone file. `DB::ReleaseSnapshot` will re-examine and schedule
-  // compaction for it.
-  if (!DataIsDefinitelyInSnapshot(file->fd.largest_seqno,
-                                  earliest_snapshot_.value(),
-                                  snapshot_checker_)) {
-    return true;
-  }
-
-  auto iter = file_marked_for_compaction_to_sorted_run_index_.find(
-      file->fd.GetNumber());
-  assert(iter != file_marked_for_compaction_to_sorted_run_index_.end());
-  size_t idx = iter->second;
-  const SortedRun* succeeding_sorted_run =
-      idx < sorted_runs_.size() - 1 ? &sorted_runs_[idx + 1] : nullptr;
-  // Marked standalone range tombstone file is best used if it's in the start
-  // input level. Skip to let that compaction happen first.
-  if (succeeding_sorted_run &&
-      succeeding_sorted_run->level_has_marked_standalone_rangedel) {
-    return true;
-  }
-
-  return false;
-}
-
 // Universal style of compaction. Pick files that are contiguous in
 // time-range to compact.
 Compaction* UniversalCompactionBuilder::PickCompaction() {
@@ -665,8 +580,7 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
        // Get the total number of sorted runs that are not being compacted
        int num_sr_not_compacted = 0;
        for (size_t i = 0; i < sorted_runs_.size(); i++) {
-          if (sorted_runs_[i].being_compacted == false &&
-              !sorted_runs_[i].level_has_marked_standalone_rangedel) {
+          if (sorted_runs_[i].being_compacted == false) {
            num_sr_not_compacted++;
          }
        }
@@ -829,24 +743,16 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
    for (sr = nullptr; loop < sorted_runs_.size(); loop++) {
      sr = &sorted_runs_[loop];

-      if (!sr->being_compacted && !sr->level_has_marked_standalone_rangedel) {
+      if (!sr->being_compacted) {
        candidate_count = 1;
        break;
      }
      char file_num_buf[kFormatFileNumberBufSize];
      sr->Dump(file_num_buf, sizeof(file_num_buf));
-      if (sr->being_compacted) {
-        ROCKS_LOG_BUFFER(log_buffer_,
-                         "[%s] Universal: %s"
-                         "[%d] being compacted, skipping",
-                         cf_name_.c_str(), file_num_buf, loop);
-      } else if (sr->level_has_marked_standalone_rangedel) {
-        ROCKS_LOG_BUFFER(log_buffer_,
-                         "[%s] Universal: %s"
-                         "[%d] has standalone range tombstone files marked for "
-                         "compaction, skipping",
-                         cf_name_.c_str(), file_num_buf, loop);
-      }
+      ROCKS_LOG_BUFFER(log_buffer_,
+                       "[%s] Universal: %s"
+                       "[%d] being compacted, skipping",
+                       cf_name_.c_str(), file_num_buf, loop);

      sr = nullptr;
    }
@@ -867,8 +773,7 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
         candidate_count < max_files_to_compact && i < sorted_runs_.size();
         i++) {
      const SortedRun* succeeding_sr = &sorted_runs_[i];
-      if (succeeding_sr->being_compacted ||
-          succeeding_sr->level_has_marked_standalone_rangedel) {
+      if (succeeding_sr->being_compacted) {
        break;
      }
      // Pick files if the total/last candidate file size (increased by the
@@ -994,11 +899,11 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
    grandparents = vstorage_->LevelFiles(sorted_runs_[first_index_after].level);
  }

-  if (output_level != 0 && picker_->FilesRangeOverlapWithCompaction(
-                               inputs, output_level,
-                               Compaction::EvaluatePenultimateLevel(
-                                   vstorage_, mutable_cf_options_, ioptions_,
-                                   start_level, output_level))) {
+  if (output_level != 0 &&
+      picker_->FilesRangeOverlapWithCompaction(
+          inputs, output_level,
+          Compaction::EvaluatePenultimateLevel(vstorage_, ioptions_,
+                                               start_level, output_level))) {
    return nullptr;
  }
  CompactionReason compaction_reason;
@@ -1018,8 +923,6 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
                                              output_level, enable_compression),
                        mutable_cf_options_.default_write_temperature,
                        /* max_subcompactions */ 0, grandparents,
-                        /* earliest_snapshot */ std::nullopt,
-                        /* snapshot_checker */ nullptr,
                        /* is manual */ false, /* trim_ts */ "", score_,
                        false /* deletion_compaction */,
                        /* l0_files_might_overlap */ true, compaction_reason);
@@ -1036,8 +939,7 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
  const size_t end_index = ShouldSkipLastSortedRunForSizeAmpCompaction()
                               ? sorted_runs_.size() - 2
                               : sorted_runs_.size() - 1;
-  if (sorted_runs_[end_index].being_compacted ||
-      sorted_runs_[end_index].level_has_marked_standalone_rangedel) {
+  if (sorted_runs_[end_index].being_compacted) {
    return nullptr;
  }
  const uint64_t base_sr_size = sorted_runs_[end_index].size;
@@ -1048,23 +950,14 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
  // Get longest span (i.e, [start_index, end_index]) of available sorted runs
  while (start_index > 0) {
    const SortedRun* sr = &sorted_runs_[start_index - 1];
-    if (sr->being_compacted || sr->level_has_marked_standalone_rangedel) {
+    if (sr->being_compacted) {
      char file_num_buf[kFormatFileNumberBufSize];
      sr->Dump(file_num_buf, sizeof(file_num_buf), true);
-      if (sr->being_compacted) {
-        ROCKS_LOG_BUFFER(
-            log_buffer_,
-            "[%s] Universal: stopping at sorted run undergoing compaction: "
-            "%s[%" ROCKSDB_PRIszt "]",
-            cf_name_.c_str(), file_num_buf, start_index - 1);
-      } else if (sr->level_has_marked_standalone_rangedel) {
-        ROCKS_LOG_BUFFER(
-            log_buffer_,
-            "[%s] Universal: stopping at sorted run that has standalone range "
-            "tombstone files marked for compaction: "
-            "%s[%" ROCKSDB_PRIszt "]",
-            cf_name_.c_str(), file_num_buf, start_index - 1);
-      }
+      ROCKS_LOG_BUFFER(
+          log_buffer_,
+          "[%s] Universal: stopping at sorted run undergoing compaction: "
+          "%s[%" ROCKSDB_PRIszt "]",
+          cf_name_.c_str(), file_num_buf, start_index - 1);
      break;
    }
    candidate_size += sr->compensated_file_size;
@@ -1343,11 +1236,11 @@ Compaction* UniversalCompactionBuilder::PickIncrementalForReduceSizeAmp(
  }

  // intra L0 compactions outputs could have overlap
-  if (output_level != 0 && picker_->FilesRangeOverlapWithCompaction(
-                               inputs, output_level,
-                               Compaction::EvaluatePenultimateLevel(
-                                   vstorage_, mutable_cf_options_, ioptions_,
-                                   start_level, output_level))) {
+  if (output_level != 0 &&
+      picker_->FilesRangeOverlapWithCompaction(
+          inputs, output_level,
+          Compaction::EvaluatePenultimateLevel(vstorage_, ioptions_,
+                                               start_level, output_level))) {
    return nullptr;
  }

@@ -1364,10 +1257,7 @@ Compaction* UniversalCompactionBuilder::PickIncrementalForReduceSizeAmp(
      GetCompressionOptions(mutable_cf_options_, vstorage_, output_level,
                            true /* enable_compression */),
      mutable_cf_options_.default_write_temperature,
-      /* max_subcompactions */ 0, /* grandparents */ {},
-      /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr,
-      /* is manual */ false,
+      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ false,
      /* trim_ts */ "", score_, false /* deletion_compaction */,
      /* l0_files_might_overlap */ true,
      CompactionReason::kUniversalSizeAmplification);
@@ -1398,7 +1288,7 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
        continue;
      }
      FileMetaData* f = vstorage_->LevelFiles(0)[loop];
-      if (f->marked_for_compaction && !ShouldSkipMarkedFile(f)) {
+      if (f->marked_for_compaction) {
        start_level_inputs.files.push_back(f);
        start_index =
            static_cast<int>(loop);  // Consider this as the first candidate.
@@ -1412,7 +1302,7 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {

    for (size_t loop = start_index + 1; loop < sorted_runs_.size(); loop++) {
      SortedRun* sr = &sorted_runs_[loop];
-      if (sr->being_compacted || sr->level_has_marked_standalone_rangedel) {
+      if (sr->being_compacted) {
        break;
      }

@@ -1431,10 +1321,7 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
    // leveled. We pick one of the files marked for compaction and compact with
    // overlapping files in the adjacent level.
    picker_->PickFilesMarkedForCompaction(cf_name_, vstorage_, &start_level,
-                                          &output_level, &start_level_inputs,
-                                          [this](const FileMetaData* file) {
-                                            return ShouldSkipMarkedFile(file);
-                                          });
+                                          &output_level, &start_level_inputs);
    if (start_level_inputs.empty()) {
      return nullptr;
    }
@@ -1487,8 +1374,7 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
      if (picker_->FilesRangeOverlapWithCompaction(
              inputs, output_level,
              Compaction::EvaluatePenultimateLevel(
-                  vstorage_, mutable_cf_options_, ioptions_, start_level,
-                  output_level))) {
+                  vstorage_, ioptions_, start_level, output_level))) {
        return nullptr;
      }

@@ -1515,9 +1401,7 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
      GetCompressionType(vstorage_, mutable_cf_options_, output_level, 1),
      GetCompressionOptions(mutable_cf_options_, vstorage_, output_level),
      mutable_cf_options_.default_write_temperature,
-      /* max_subcompactions */ 0, grandparents, earliest_snapshot_,
-      snapshot_checker_,
-      /* is manual */ false,
+      /* max_subcompactions */ 0, grandparents, /* is manual */ false,
      /* trim_ts */ "", score_, false /* deletion_compaction */,
      /* l0_files_might_overlap */ true,
      CompactionReason::kFilesMarkedForCompaction);
@@ -1588,11 +1472,11 @@ Compaction* UniversalCompactionBuilder::PickCompactionWithSortedRunRange(
  }

  // intra L0 compactions outputs could have overlap
-  if (output_level != 0 && picker_->FilesRangeOverlapWithCompaction(
-                               inputs, output_level,
-                               Compaction::EvaluatePenultimateLevel(
-                                   vstorage_, mutable_cf_options_, ioptions_,
-                                   start_level, output_level))) {
+  if (output_level != 0 &&
+      picker_->FilesRangeOverlapWithCompaction(
+          inputs, output_level,
+          Compaction::EvaluatePenultimateLevel(vstorage_, ioptions_,
+                                               start_level, output_level))) {
    return nullptr;
  }

@@ -1610,10 +1494,7 @@ Compaction* UniversalCompactionBuilder::PickCompactionWithSortedRunRange(
      GetCompressionOptions(mutable_cf_options_, vstorage_, output_level,
                            true /* enable_compression */),
      mutable_cf_options_.default_write_temperature,
-      /* max_subcompactions */ 0, /* grandparents */ {},
-      /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr,
-      /* is manual */ false,
+      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ false,
      /* trim_ts */ "", score_, false /* deletion_compaction */,
      /* l0_files_might_overlap */ true, compaction_reason);
 }
@@ -1634,8 +1515,7 @@ Compaction* UniversalCompactionBuilder::PickPeriodicCompaction() {
  // included in the compaction.

  size_t start_index = sorted_runs_.size();
-  while (start_index > 0 && !sorted_runs_[start_index - 1].being_compacted &&
-         !sorted_runs_[start_index - 1].level_has_marked_standalone_rangedel) {
+  while (start_index > 0 && !sorted_runs_[start_index - 1].being_compacted) {
    start_index--;
  }
  if (start_index == sorted_runs_.size()) {
@@ -10,7 +10,6 @@
 #pragma once

 #include "db/compaction/compaction_picker.h"
-#include "db/snapshot_checker.h"

 namespace ROCKSDB_NAMESPACE {
 class UniversalCompactionPicker : public CompactionPicker {
@@ -18,12 +17,11 @@ class UniversalCompactionPicker : public CompactionPicker {
  UniversalCompactionPicker(const ImmutableOptions& ioptions,
                            const InternalKeyComparator* icmp)
      : CompactionPicker(ioptions, icmp) {}
-  Compaction* PickCompaction(
-      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options,
-      const std::vector<SequenceNumber>& existing_snapshots,
-      const SnapshotChecker* snapshot_checker, VersionStorageInfo* vstorage,
-      LogBuffer* log_buffer) override;
+  Compaction* PickCompaction(const std::string& cf_name,
+                             const MutableCFOptions& mutable_cf_options,
+                             const MutableDBOptions& mutable_db_options,
+                             VersionStorageInfo* vstorage,
+                             LogBuffer* log_buffer) override;
  int MaxOutputLevel() const override { return NumberLevels() - 1; }

  bool NeedsCompaction(const VersionStorageInfo* vstorage) const override;
@@ -39,8 +39,12 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
          MakeTableFileName(file->fd.GetNumber()));
    }
  }
-
-  compaction_input.cf_name = compaction->column_family_data()->GetName();
+  compaction_input.column_family.name =
+      compaction->column_family_data()->GetName();
+  compaction_input.column_family.options =
+      compaction->column_family_data()->GetLatestCFOptions();
+  compaction_input.db_options =
+      BuildDBOptions(db_options_, mutable_db_options_copy_);
  compaction_input.snapshots = existing_snapshots_;
  compaction_input.has_begin = sub_compact->start.has_value();
  compaction_input.begin =
@@ -48,14 +52,6 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
  compaction_input.has_end = sub_compact->end.has_value();
  compaction_input.end =
      compaction_input.has_end ? sub_compact->end->ToString() : "";
-  compaction_input.options_file_number =
-      sub_compact->compaction->input_version()
-          ->version_set()
-          ->options_file_number();
-
-  TEST_SYNC_POINT_CALLBACK(
-      "CompactionServiceJob::ProcessKeyValueCompactionWithCompactionService",
-      &compaction_input);

  std::string compaction_input_binary;
  Status s = compaction_input.Write(&compaction_input_binary);
@@ -74,13 +70,10 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
  ROCKS_LOG_INFO(
      db_options_.info_log,
      "[%s] [JOB %d] Starting remote compaction (output level: %d): %s",
-      compaction->column_family_data()->GetName().c_str(), job_id_,
+      compaction_input.column_family.name.c_str(), job_id_,
      compaction_input.output_level, input_files_oss.str().c_str());
-  CompactionServiceJobInfo info(
-      dbname_, db_id_, db_session_id_, GetCompactionId(sub_compact),
-      thread_pri_, compaction->compaction_reason(),
-      compaction->is_full_compaction(), compaction->is_manual_compaction(),
-      compaction->bottommost_level());
+  CompactionServiceJobInfo info(dbname_, db_id_, db_session_id_,
+                                GetCompactionId(sub_compact), thread_pri_);
  CompactionServiceScheduleResponse response =
      db_options_.compaction_service->Schedule(info, compaction_input_binary);
  switch (response.status) {
@@ -91,14 +84,13 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
          "CompactionService failed to schedule a remote compaction job.");
      ROCKS_LOG_WARN(db_options_.info_log,
                     "[%s] [JOB %d] Remote compaction failed to start.",
-                     compaction->column_family_data()->GetName().c_str(),
-                     job_id_);
+                     compaction_input.column_family.name.c_str(), job_id_);
      return response.status;
    case CompactionServiceJobStatus::kUseLocal:
      ROCKS_LOG_INFO(
          db_options_.info_log,
          "[%s] [JOB %d] Remote compaction fallback to local by API (Schedule)",
-          compaction->column_family_data()->GetName().c_str(), job_id_);
+          compaction_input.column_family.name.c_str(), job_id_);
      return response.status;
    default:
      assert(false);  // unknown status
@@ -107,7 +99,7 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(

  ROCKS_LOG_INFO(db_options_.info_log,
                 "[%s] [JOB %d] Waiting for remote compaction...",
-                 compaction->column_family_data()->GetName().c_str(), job_id_);
+                 compaction_input.column_family.name.c_str(), job_id_);
  std::string compaction_result_binary;
  CompactionServiceJobStatus compaction_status =
      db_options_.compaction_service->Wait(response.scheduled_job_id,
@@ -117,7 +109,7 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
    ROCKS_LOG_INFO(
        db_options_.info_log,
        "[%s] [JOB %d] Remote compaction fallback to local by API (Wait)",
-        compaction->column_family_data()->GetName().c_str(), job_id_);
+        compaction_input.column_family.name.c_str(), job_id_);
    return compaction_status;
  }

@@ -142,9 +134,9 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
          "result is returned).");
      compaction_result.status.PermitUncheckedError();
    }
-    ROCKS_LOG_WARN(
-        db_options_.info_log, "[%s] [JOB %d] Remote compaction failed.",
-        compaction->column_family_data()->GetName().c_str(), job_id_);
+    ROCKS_LOG_WARN(db_options_.info_log,
+                   "[%s] [JOB %d] Remote compaction failed.",
+                   compaction_input.column_family.name.c_str(), job_id_);
    return compaction_status;
  }

@@ -170,7 +162,7 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
      db_options_.info_log,
      "[%s] [JOB %d] Received remote compaction result, output path: "
      "%s, files: %s",
-      compaction->column_family_data()->GetName().c_str(), job_id_,
+      compaction_input.column_family.name.c_str(), job_id_,
      compaction_result.output_path.c_str(), output_files_oss.str().c_str());

  // Installation Starts
@@ -203,8 +195,6 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
    meta.oldest_ancester_time = file.oldest_ancester_time;
    meta.file_creation_time = file.file_creation_time;
    meta.epoch_number = file.epoch_number;
-    meta.file_checksum = file.file_checksum;
-    meta.file_checksum_func_name = file.file_checksum_func_name;
    meta.marked_for_compaction = file.marked_for_compaction;
    meta.unique_id = file.unique_id;

@@ -212,14 +202,11 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
    sub_compact->Current().AddOutput(std::move(meta),
                                     cfd->internal_comparator(), false, true,
                                     file.paranoid_hash);
-    sub_compact->Current().UpdateTableProperties(file.table_properties);
  }
  sub_compact->compaction_job_stats = compaction_result.stats;
  sub_compact->Current().SetNumOutputRecords(
-      compaction_result.stats.num_output_records);
-  sub_compact->Current().SetNumOutputFiles(
-      compaction_result.stats.num_output_files);
-  sub_compact->Current().AddBytesWritten(compaction_result.bytes_written);
+      compaction_result.num_output_records);
+  sub_compact->Current().SetTotalBytes(compaction_result.total_bytes);
  RecordTick(stats_, REMOTE_COMPACT_READ_BYTES, compaction_result.bytes_read);
  RecordTick(stats_, REMOTE_COMPACT_WRITE_BYTES,
             compaction_result.bytes_written);
@@ -239,18 +226,6 @@ void CompactionServiceCompactionJob::RecordCompactionIOStats() {
  CompactionJob::RecordCompactionIOStats();
 }

-void CompactionServiceCompactionJob::UpdateCompactionJobStats(
-    const InternalStats::CompactionStats& stats) const {
-  compaction_job_stats_->elapsed_micros = stats.micros;
-
-  // output information only in remote compaction
-  compaction_job_stats_->total_output_bytes = stats.bytes_written;
-  compaction_job_stats_->total_output_bytes_blob = stats.bytes_written_blob;
-  compaction_job_stats_->num_output_records = stats.num_output_records;
-  compaction_job_stats_->num_output_files = stats.num_output_files;
-  compaction_job_stats_->num_output_files_blob = stats.num_output_files_blob;
-}
-
 CompactionServiceCompactionJob::CompactionServiceCompactionJob(
    int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
    const MutableDBOptions& mutable_db_options, const FileOptions& file_options,
@@ -286,11 +261,11 @@ Status CompactionServiceCompactionJob::Run() {

  auto* c = compact_->compaction;
  assert(c->column_family_data() != nullptr);
-  const VersionStorageInfo* storage_info = c->input_version()->storage_info();
-  assert(storage_info);
-  assert(storage_info->NumLevelFiles(compact_->compaction->level()) > 0);
-  write_hint_ = storage_info->CalculateSSTWriteHint(c->output_level());
+  assert(c->column_family_data()->current()->storage_info()->NumLevelFiles(
+             compact_->compaction->level()) > 0);

+  write_hint_ =
+      c->column_family_data()->CalculateSSTWriteHint(c->output_level());
  bottommost_level_ = c->bottommost_level();

  Slice begin = compaction_input_.begin;
@@ -305,9 +280,6 @@ Status CompactionServiceCompactionJob::Run() {

  log_buffer_->FlushBufferToLog();
  LogCompaction();
-
-  compaction_result_->stats.Reset();
-
  const uint64_t start_micros = db_options_.clock->NowMicros();
  c->GetOrInitInputTableProperties();

@@ -348,50 +320,38 @@ Status CompactionServiceCompactionJob::Run() {
  if (status.ok()) {
    status = io_s;
  }
+  if (status.ok()) {
+    // TODO: Add verify_table()
+  }
+
+  // Finish up all book-keeping to unify the subcompaction results
+  compact_->AggregateCompactionStats(compaction_stats_, *compaction_job_stats_);
+  UpdateCompactionStats();
+  RecordCompactionIOStats();

  LogFlush(db_options_.info_log);
  compact_->status = status;
  compact_->status.PermitUncheckedError();

-  // Build Compaction Job Stats
-
-  // 1. Aggregate CompactionOutputStats into Internal Compaction Stats
-  // (compaction_stats_) and aggregate Compaction Job Stats
-  // (compaction_job_stats_) from the sub compactions
-  compact_->AggregateCompactionStats(compaction_stats_, *compaction_job_stats_);
-
-  // 2. Update the Output information in the Compaction Job Stats with
-  // aggregated Internal Compaction Stats.
-  UpdateCompactionJobStats(compaction_stats_.stats);
-
-  // 3. Set fields that are not propagated as part of aggregations above
-  compaction_result_->stats.is_manual_compaction = c->is_manual_compaction();
-  compaction_result_->stats.is_full_compaction = c->is_full_compaction();
-  compaction_result_->stats.is_remote_compaction = true;
-
-  // 4. Update IO Stats that are not part of the aggregations above (bytes_read,
-  // bytes_written)
-  RecordCompactionIOStats();
-
-  // Build Output
+  // Build compaction result
  compaction_result_->output_level = compact_->compaction->output_level();
  compaction_result_->output_path = output_path_;
-  if (status.ok()) {
-    for (const auto& output_file : sub_compact->GetOutputs()) {
-      auto& meta = output_file.meta;
-      compaction_result_->output_files.emplace_back(
-          MakeTableFileName(meta.fd.GetNumber()), meta.fd.smallest_seqno,
-          meta.fd.largest_seqno, meta.smallest.Encode().ToString(),
-          meta.largest.Encode().ToString(), meta.oldest_ancester_time,
-          meta.file_creation_time, meta.epoch_number, meta.file_checksum,
-          meta.file_checksum_func_name, output_file.validator.GetHash(),
-          meta.marked_for_compaction, meta.unique_id,
-          *output_file.table_properties);
-    }
+  for (const auto& output_file : sub_compact->GetOutputs()) {
+    auto& meta = output_file.meta;
+    compaction_result_->output_files.emplace_back(
+        MakeTableFileName(meta.fd.GetNumber()), meta.fd.smallest_seqno,
+        meta.fd.largest_seqno, meta.smallest.Encode().ToString(),
+        meta.largest.Encode().ToString(), meta.oldest_ancester_time,
+        meta.file_creation_time, meta.epoch_number,
+        output_file.validator.GetHash(), meta.marked_for_compaction,
+        meta.unique_id);
  }
+  InternalStats::CompactionStatsFull compaction_stats;
+  sub_compact->AggregateCompactionStats(compaction_stats);
+  compaction_result_->num_output_records =
+      compaction_stats.stats.num_output_records;
+  compaction_result_->total_bytes = compaction_stats.TotalBytesWritten();

-  TEST_SYNC_POINT_CALLBACK("CompactionServiceCompactionJob::Run:0",
-                           &compaction_result_);
  return status;
 }

@@ -444,9 +404,42 @@ static std::unordered_map<std::string, OptionTypeInfo> cfd_type_info = {
 };

 static std::unordered_map<std::string, OptionTypeInfo> cs_input_type_info = {
-    {"cf_name",
-     {offsetof(struct CompactionServiceInput, cf_name),
-      OptionType::kEncodedString}},
+    {"column_family",
+     OptionTypeInfo::Struct(
+         "column_family", &cfd_type_info,
+         offsetof(struct CompactionServiceInput, column_family),
+         OptionVerificationType::kNormal, OptionTypeFlags::kNone)},
+    {"db_options",
+     {offsetof(struct CompactionServiceInput, db_options),
+      OptionType::kConfigurable, OptionVerificationType::kNormal,
+      OptionTypeFlags::kNone,
+      [](const ConfigOptions& opts, const std::string& /*name*/,
+         const std::string& value, void* addr) {
+        auto options = static_cast<DBOptions*>(addr);
+        return GetDBOptionsFromString(opts, DBOptions(), value, options);
+      },
+      [](const ConfigOptions& opts, const std::string& /*name*/,
+         const void* addr, std::string* value) {
+        const auto options = static_cast<const DBOptions*>(addr);
+        std::string result;
+        auto status = GetStringFromDBOptions(opts, *options, &result);
+        *value = "{" + result + "}";
+        return status;
+      },
+      [](const ConfigOptions& opts, const std::string& name, const void* addr1,
+         const void* addr2, std::string* mismatch) {
+        const auto this_one = static_cast<const DBOptions*>(addr1);
+        const auto that_one = static_cast<const DBOptions*>(addr2);
+        auto this_conf = DBOptionsAsConfigurable(*this_one);
+        auto that_conf = DBOptionsAsConfigurable(*that_one);
+        std::string mismatch_opt;
+        bool result =
+            this_conf->AreEquivalent(opts, that_conf.get(), &mismatch_opt);
+        if (!result) {
+          *mismatch = name + "." + mismatch_opt;
+        }
+        return result;
+      }}},
    {"snapshots", OptionTypeInfo::Vector<uint64_t>(
                      offsetof(struct CompactionServiceInput, snapshots),
                      OptionVerificationType::kNormal, OptionTypeFlags::kNone,
@@ -474,10 +467,6 @@ static std::unordered_map<std::string, OptionTypeInfo> cs_input_type_info = {
    {"end",
     {offsetof(struct CompactionServiceInput, end), OptionType::kEncodedString,
      OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
-    {"options_file_number",
-     {offsetof(struct CompactionServiceInput, options_file_number),
-      OptionType::kUInt64T, OptionVerificationType::kNormal,
-      OptionTypeFlags::kNone}},
 };

 static std::unordered_map<std::string, OptionTypeInfo>
@@ -514,14 +503,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
         {offsetof(struct CompactionServiceOutputFile, epoch_number),
          OptionType::kUInt64T, OptionVerificationType::kNormal,
          OptionTypeFlags::kNone}},
-        {"file_checksum",
-         {offsetof(struct CompactionServiceOutputFile, file_checksum),
-          OptionType::kEncodedString, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"file_checksum_func_name",
-         {offsetof(struct CompactionServiceOutputFile, file_checksum_func_name),
-          OptionType::kEncodedString, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
        {"paranoid_hash",
         {offsetof(struct CompactionServiceOutputFile, paranoid_hash),
          OptionType::kUInt64T, OptionVerificationType::kNormal,
@@ -535,30 +516,7 @@ static std::unordered_map<std::string, OptionTypeInfo>
             offsetof(struct CompactionServiceOutputFile, unique_id),
             OptionVerificationType::kNormal, OptionTypeFlags::kNone,
             {0, OptionType::kUInt64T})},
-        {"table_properties",
-         {offsetof(struct CompactionServiceOutputFile, table_properties),
-          OptionType::kStruct, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone,
-          [](const ConfigOptions& opts, const std::string& /*name*/,
-             const std::string& value, void* addr) {
-            auto table_properties = static_cast<TableProperties*>(addr);
-            return TableProperties::Parse(opts, value, table_properties);
-          },
-          [](const ConfigOptions& opts, const std::string& /*name*/,
-             const void* addr, std::string* value) {
-            const auto table_properties =
-                static_cast<const TableProperties*>(addr);
-            std::string result;
-            auto status = table_properties->Serialize(opts, &result);
-            *value = "{" + result + "}";
-            return status;
-          },
-          [](const ConfigOptions& opts, const std::string& /*name*/,
-             const void* addr1, const void* addr2, std::string* mismatch) {
-            const auto this_one = static_cast<const TableProperties*>(addr1);
-            const auto that_one = static_cast<const TableProperties*>(addr2);
-            return this_one->AreEqual(opts, that_one, mismatch);
-          }}}};
+};

 static std::unordered_map<std::string, OptionTypeInfo>
    compaction_job_stats_type_info = {
@@ -605,10 +563,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
         {offsetof(struct CompactionJobStats, is_manual_compaction),
          OptionType::kBoolean, OptionVerificationType::kNormal,
          OptionTypeFlags::kNone}},
-        {"is_remote_compaction",
-         {offsetof(struct CompactionJobStats, is_remote_compaction),
-          OptionType::kBoolean, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
        {"total_input_bytes",
         {offsetof(struct CompactionJobStats, total_input_bytes),
          OptionType::kUInt64T, OptionVerificationType::kNormal,
@@ -777,6 +731,14 @@ static std::unordered_map<std::string, OptionTypeInfo> cs_result_type_info = {
     {offsetof(struct CompactionServiceResult, output_path),
      OptionType::kEncodedString, OptionVerificationType::kNormal,
      OptionTypeFlags::kNone}},
+    {"num_output_records",
+     {offsetof(struct CompactionServiceResult, num_output_records),
+      OptionType::kUInt64T, OptionVerificationType::kNormal,
+      OptionTypeFlags::kNone}},
+    {"total_bytes",
+     {offsetof(struct CompactionServiceResult, total_bytes),
+      OptionType::kUInt64T, OptionVerificationType::kNormal,
+      OptionTypeFlags::kNone}},
    {"bytes_read",
     {offsetof(struct CompactionServiceResult, bytes_read),
      OptionType::kUInt64T, OptionVerificationType::kNormal,
@@ -3,9 +3,9 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).

+
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
-#include "rocksdb/utilities/options_util.h"
 #include "table/unique_id_impl.h"

 namespace ROCKSDB_NAMESPACE {
@@ -21,10 +21,8 @@ class MyTestCompactionService : public CompactionService {
      : db_path_(std::move(db_path)),
        options_(options),
        statistics_(statistics),
-        start_info_("na", "na", "na", 0, Env::TOTAL, CompactionReason::kUnknown,
-                    false, false, false),
-        wait_info_("na", "na", "na", 0, Env::TOTAL, CompactionReason::kUnknown,
-                   false, false, false),
+        start_info_("na", "na", "na", 0, Env::TOTAL),
+        wait_info_("na", "na", "na", 0, Env::TOTAL),
        listeners_(listeners),
        table_properties_collector_factories_(
            std::move(table_properties_collector_factories)) {}
@@ -99,12 +97,8 @@ class MyTestCompactionService : public CompactionService {
    Status s =
        DB::OpenAndCompact(options, db_path_, db_path_ + "/" + scheduled_job_id,
                           compaction_input, result, options_override);
-    {
-      InstrumentedMutexLock l(&mutex_);
-      if (is_override_wait_result_) {
-        *result = override_wait_result_;
-      }
-      result_ = *result;
+    if (is_override_wait_result_) {
+      *result = override_wait_result_;
    }
    compaction_num_.fetch_add(1);
    if (s.ok()) {
@@ -147,10 +141,6 @@ class MyTestCompactionService : public CompactionService {

  void SetCanceled(bool canceled) { canceled_ = canceled; }

-  void GetResult(CompactionServiceResult* deserialized) {
-    CompactionServiceResult::Read(result_, deserialized).PermitUncheckedError();
-  }
-
  CompactionServiceJobStatus GetFinalCompactionServiceJobStatus() {
    return final_updated_status_.load();
  }
@@ -172,7 +162,6 @@ class MyTestCompactionService : public CompactionService {
  CompactionServiceJobStatus override_wait_status_ =
      CompactionServiceJobStatus::kFailure;
  bool is_override_wait_result_ = false;
-  std::string result_;
  std::string override_wait_result_;
  std::vector<std::shared_ptr<EventListener>> listeners_;
  std::vector<std::shared_ptr<TablePropertiesCollectorFactory>>
@@ -342,34 +331,6 @@ TEST_F(CompactionServiceTest, BasicCompactions) {
  ReopenWithColumnFamilies({kDefaultColumnFamilyName, "cf_1", "cf_2", "cf_3"},
                           options);
  ASSERT_GT(verify_passed, 0);
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  if (s.IsAborted()) {
-    ASSERT_NOK(result.status);
-  } else {
-    ASSERT_OK(result.status);
-  }
-  ASSERT_GE(result.stats.elapsed_micros, 1);
-  ASSERT_GE(result.stats.cpu_micros, 1);
-
-  ASSERT_EQ(20, result.stats.num_output_records);
-  ASSERT_EQ(result.output_files.size(), result.stats.num_output_files);
-
-  uint64_t total_size = 0;
-  for (auto output_file : result.output_files) {
-    std::string file_name = result.output_path + "/" + output_file.file_name;
-
-    uint64_t file_size = 0;
-    ASSERT_OK(options.env->GetFileSize(file_name, &file_size));
-    ASSERT_GT(file_size, 0);
-    total_size += file_size;
-  }
-  ASSERT_EQ(total_size, result.stats.total_output_bytes);
-
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_FALSE(result.stats.is_full_compaction);
-
  Close();
 }

@@ -408,547 +369,6 @@ TEST_F(CompactionServiceTest, ManualCompaction) {
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
  VerifyTestData();
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-TEST_F(CompactionServiceTest, CompactionOutputFileIOError) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::FinishCompactionOutputFile()::AfterFinish",
-      [&](void* status) {
-        // override status
-        auto s = static_cast<Status*>(status);
-        *s = Status::IOError("Injected IOError!");
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  std::string start_str = Key(15);
-  std::string end_str = Key(45);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-  ASSERT_NOK(db_->CompactRange(CompactRangeOptions(), &start, &end));
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_NOK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-TEST_F(CompactionServiceTest, PreservedOptionsLocalCompaction) {
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = 2;
-  options.disable_auto_compactions = true;
-  DestroyAndReopen(options);
-
-  Random rnd(301);
-  for (auto i = 0; i < 2; ++i) {
-    for (auto j = 0; j < 10; ++j) {
-      ASSERT_OK(
-          Put("foo" + std::to_string(i * 10 + j), rnd.RandomString(1024)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::ProcessKeyValueCompaction()::Processing", [&](void* arg) {
-        auto compaction = static_cast<Compaction*>(arg);
-        std::string options_file_name = OptionsFileName(
-            dbname_,
-            compaction->input_version()->version_set()->options_file_number());
-
-        // Change option twice to make sure the very first OPTIONS file gets
-        // purged
-        ASSERT_OK(dbfull()->SetOptions(
-            {{"level0_file_num_compaction_trigger", "4"}}));
-        ASSERT_EQ(4, dbfull()->GetOptions().level0_file_num_compaction_trigger);
-        ASSERT_OK(dbfull()->SetOptions(
-            {{"level0_file_num_compaction_trigger", "6"}}));
-        ASSERT_EQ(6, dbfull()->GetOptions().level0_file_num_compaction_trigger);
-        dbfull()->TEST_DeleteObsoleteFiles();
-
-        // For non-remote compactions, OPTIONS file can be deleted while
-        // using option at the start of the compaction
-        Status s = env_->FileExists(options_file_name);
-        ASSERT_NOK(s);
-        ASSERT_TRUE(s.IsNotFound());
-        // Should be old value
-        ASSERT_EQ(2, compaction->mutable_cf_options()
-                         ->level0_file_num_compaction_trigger);
-        ASSERT_TRUE(dbfull()->min_options_file_numbers_.empty());
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  Status s = dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_TRUE(s.ok());
-}
-
-TEST_F(CompactionServiceTest, PreservedOptionsRemoteCompaction) {
-  // For non-remote compaction do not preserve options file
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = 2;
-  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  Random rnd(301);
-  for (auto i = 0; i < 2; ++i) {
-    for (auto j = 0; j < 10; ++j) {
-      ASSERT_OK(
-          Put("foo" + std::to_string(i * 10 + j), rnd.RandomString(1024)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"CompactionServiceTest::OptionsFileChanged",
-        "DBImplSecondary::OpenAndCompact::BeforeLoadingOptions:1"}});
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "DBImplSecondary::OpenAndCompact::BeforeLoadingOptions:0",
-      [&](void* arg) {
-        auto options_file_number = static_cast<uint64_t*>(arg);
-        // Change the option twice before the compaction run
-        ASSERT_OK(dbfull()->SetOptions(
-            {{"level0_file_num_compaction_trigger", "4"}}));
-        ASSERT_EQ(4, dbfull()->GetOptions().level0_file_num_compaction_trigger);
-        ASSERT_TRUE(dbfull()->versions_->options_file_number() >
-                    *options_file_number);
-
-        // Change the option twice before the compaction run
-        ASSERT_OK(dbfull()->SetOptions(
-            {{"level0_file_num_compaction_trigger", "5"}}));
-        ASSERT_EQ(5, dbfull()->GetOptions().level0_file_num_compaction_trigger);
-        ASSERT_TRUE(dbfull()->versions_->options_file_number() >
-                    *options_file_number);
-
-        TEST_SYNC_POINT("CompactionServiceTest::OptionsFileChanged");
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionServiceJob::ProcessKeyValueCompactionWithCompactionService",
-      [&](void* arg) {
-        auto input = static_cast<CompactionServiceInput*>(arg);
-        std::string options_file_name =
-            OptionsFileName(dbname_, input->options_file_number);
-
-        ASSERT_OK(env_->FileExists(options_file_name));
-        ASSERT_FALSE(dbfull()->min_options_file_numbers_.empty());
-        ASSERT_EQ(dbfull()->min_options_file_numbers_.front(),
-                  input->options_file_number);
-
-        DBOptions db_options;
-        ConfigOptions config_options;
-        std::vector<ColumnFamilyDescriptor> all_column_families;
-        config_options.env = env_;
-        ASSERT_OK(LoadOptionsFromFile(config_options, options_file_name,
-                                      &db_options, &all_column_families));
-        bool has_cf = false;
-        for (auto& cf : all_column_families) {
-          if (cf.name == input->cf_name) {
-            // Should be old value
-            ASSERT_EQ(2, cf.options.level0_file_num_compaction_trigger);
-            has_cf = true;
-          }
-        }
-        ASSERT_TRUE(has_cf);
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::ProcessKeyValueCompaction()::Processing", [&](void* arg) {
-        auto compaction = static_cast<Compaction*>(arg);
-        ASSERT_EQ(2, compaction->mutable_cf_options()
-                         ->level0_file_num_compaction_trigger);
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  Status s = dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_TRUE(s.ok());
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-class EventVerifier : public EventListener {
- public:
-  explicit EventVerifier(uint64_t expected_num_input_records,
-                         size_t expected_num_input_files,
-                         uint64_t expected_num_output_records,
-                         size_t expected_num_output_files,
-                         const std::string& expected_smallest_output_key_prefix,
-                         const std::string& expected_largest_output_key_prefix,
-                         bool expected_is_remote_compaction_on_begin,
-                         bool expected_is_remote_compaction_on_complete)
-      : expected_num_input_records_(expected_num_input_records),
-        expected_num_input_files_(expected_num_input_files),
-        expected_num_output_records_(expected_num_output_records),
-        expected_num_output_files_(expected_num_output_files),
-        expected_smallest_output_key_prefix_(
-            expected_smallest_output_key_prefix),
-        expected_largest_output_key_prefix_(expected_largest_output_key_prefix),
-        expected_is_remote_compaction_on_begin_(
-            expected_is_remote_compaction_on_begin),
-        expected_is_remote_compaction_on_complete_(
-            expected_is_remote_compaction_on_complete) {}
-  void OnCompactionBegin(DB* /*db*/, const CompactionJobInfo& ci) override {
-    ASSERT_EQ(expected_num_input_files_, ci.input_files.size());
-    ASSERT_EQ(expected_num_input_files_, ci.input_file_infos.size());
-    ASSERT_EQ(expected_is_remote_compaction_on_begin_,
-              ci.stats.is_remote_compaction);
-    ASSERT_TRUE(ci.stats.is_manual_compaction);
-    ASSERT_FALSE(ci.stats.is_full_compaction);
-  }
-  void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) override {
-    ASSERT_GT(ci.stats.elapsed_micros, 0);
-    ASSERT_GT(ci.stats.cpu_micros, 0);
-    ASSERT_EQ(expected_num_input_records_, ci.stats.num_input_records);
-    ASSERT_EQ(expected_num_input_files_, ci.stats.num_input_files);
-    ASSERT_EQ(expected_num_output_records_, ci.stats.num_output_records);
-    ASSERT_EQ(expected_num_output_files_, ci.stats.num_output_files);
-    ASSERT_EQ(expected_smallest_output_key_prefix_,
-              ci.stats.smallest_output_key_prefix);
-    ASSERT_EQ(expected_largest_output_key_prefix_,
-              ci.stats.largest_output_key_prefix);
-    ASSERT_GT(ci.stats.total_input_bytes, 0);
-    ASSERT_GT(ci.stats.total_output_bytes, 0);
-    ASSERT_EQ(ci.stats.num_input_records,
-              ci.stats.num_output_records + ci.stats.num_records_replaced);
-    ASSERT_EQ(expected_is_remote_compaction_on_complete_,
-              ci.stats.is_remote_compaction);
-    ASSERT_TRUE(ci.stats.is_manual_compaction);
-    ASSERT_FALSE(ci.stats.is_full_compaction);
-  }
-
- private:
-  uint64_t expected_num_input_records_;
-  size_t expected_num_input_files_;
-  uint64_t expected_num_output_records_;
-  size_t expected_num_output_files_;
-  std::string expected_smallest_output_key_prefix_;
-  std::string expected_largest_output_key_prefix_;
-  bool expected_is_remote_compaction_on_begin_;
-  bool expected_is_remote_compaction_on_complete_;
-};
-
-TEST_F(CompactionServiceTest, VerifyStats) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  auto event_verifier = std::make_shared<EventVerifier>(
-      30 /* expected_num_input_records */, 3 /* expected_num_input_files */,
-      20 /* expected_num_output_records */, 1 /* expected_num_output_files */,
-      "key00000" /* expected_smallest_output_key_prefix */,
-      "key00001" /* expected_largest_output_key_prefix */,
-      true /* expected_is_remote_compaction_on_begin */,
-      true /* expected_is_remote_compaction_on_complete */);
-  options.listeners.push_back(event_verifier);
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  std::string start_str = Key(0);
-  std::string end_str = Key(1);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, &end));
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-  VerifyTestData();
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-TEST_F(CompactionServiceTest, VerifyStatsLocalFallback) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  auto event_verifier = std::make_shared<EventVerifier>(
-      30 /* expected_num_input_records */, 3 /* expected_num_input_files */,
-      20 /* expected_num_output_records */, 1 /* expected_num_output_files */,
-      "key00000" /* expected_smallest_output_key_prefix */,
-      "key00001" /* expected_largest_output_key_prefix */,
-      true /* expected_is_remote_compaction_on_begin */,
-      false /* expected_is_remote_compaction_on_complete */);
-  options.listeners.push_back(event_verifier);
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-  my_cs->OverrideStartStatus(CompactionServiceJobStatus::kUseLocal);
-
-  std::string start_str = Key(0);
-  std::string end_str = Key(1);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, &end));
-  // Remote Compaction did not happen
-  ASSERT_EQ(my_cs->GetCompactionNum(), comp_num);
-  VerifyTestData();
-}
-
-TEST_F(CompactionServiceTest, CorruptedOutput) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  std::string start_str = Key(15);
-  std::string end_str = Key(45);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionServiceCompactionJob::Run:0", [&](void* arg) {
-        CompactionServiceResult* compaction_result =
-            *(static_cast<CompactionServiceResult**>(arg));
-        ASSERT_TRUE(compaction_result != nullptr &&
-                    !compaction_result->output_files.empty());
-        // Corrupt files here
-        for (const auto& output_file : compaction_result->output_files) {
-          std::string file_name =
-              compaction_result->output_path + "/" + output_file.file_name;
-
-          uint64_t file_size = 0;
-          Status s = options.env->GetFileSize(file_name, &file_size);
-          ASSERT_OK(s);
-          ASSERT_GT(file_size, 0);
-
-          ASSERT_OK(test::CorruptFile(env_, file_name, 0,
-                                      static_cast<int>(file_size),
-                                      true /* verifyChecksum */));
-        }
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // CompactRange() should fail
-  Status s = db_->CompactRange(CompactRangeOptions(), &start, &end);
-  ASSERT_NOK(s);
-  ASSERT_TRUE(s.IsCorruption());
-
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  // On the worker side, the compaction is considered success
-  // Verification is done on the primary side
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-TEST_F(CompactionServiceTest, CorruptedOutputParanoidFileCheck) {
-  for (bool paranoid_file_check_enabled : {false, true}) {
-    SCOPED_TRACE("paranoid_file_check_enabled=" +
-                 std::to_string(paranoid_file_check_enabled));
-
-    Options options = CurrentOptions();
-    Destroy(options);
-    options.disable_auto_compactions = true;
-    options.paranoid_file_checks = paranoid_file_check_enabled;
-    ReopenWithCompactionService(&options);
-    GenerateTestData();
-
-    auto my_cs = GetCompactionService();
-
-    std::string start_str = Key(15);
-    std::string end_str = Key(45);
-    Slice start(start_str);
-    Slice end(end_str);
-    uint64_t comp_num = my_cs->GetCompactionNum();
-
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-        "CompactionServiceCompactionJob::Run:0", [&](void* arg) {
-          CompactionServiceResult* compaction_result =
-              *(static_cast<CompactionServiceResult**>(arg));
-          ASSERT_TRUE(compaction_result != nullptr &&
-                      !compaction_result->output_files.empty());
-          // Corrupt files here
-          for (const auto& output_file : compaction_result->output_files) {
-            std::string file_name =
-                compaction_result->output_path + "/" + output_file.file_name;
-
-            // Corrupt very small range of bytes. This corruption is so small
-            // that this isn't caught by default light-weight check
-            ASSERT_OK(test::CorruptFile(env_, file_name, 0, 1,
-                                        false /* verifyChecksum */));
-          }
-        });
-    SyncPoint::GetInstance()->EnableProcessing();
-
-    Status s = db_->CompactRange(CompactRangeOptions(), &start, &end);
-    if (paranoid_file_check_enabled) {
-      ASSERT_NOK(s);
-      ASSERT_EQ(Status::Corruption("Paranoid checksums do not match"), s);
-    } else {
-      // CompactRange() goes through if paranoid file check is not enabled
-      ASSERT_OK(s);
-    }
-
-    ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-    SyncPoint::GetInstance()->DisableProcessing();
-    SyncPoint::GetInstance()->ClearAllCallBacks();
-
-    // On the worker side, the compaction is considered success
-    // Verification is done on the primary side
-    CompactionServiceResult result;
-    my_cs->GetResult(&result);
-    ASSERT_OK(result.status);
-    ASSERT_TRUE(result.stats.is_manual_compaction);
-    ASSERT_TRUE(result.stats.is_remote_compaction);
-  }
-}
-
-TEST_F(CompactionServiceTest, TruncatedOutput) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  std::string start_str = Key(15);
-  std::string end_str = Key(45);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionServiceCompactionJob::Run:0", [&](void* arg) {
-        CompactionServiceResult* compaction_result =
-            *(static_cast<CompactionServiceResult**>(arg));
-        ASSERT_TRUE(compaction_result != nullptr &&
-                    !compaction_result->output_files.empty());
-        // Truncate files here
-        for (const auto& output_file : compaction_result->output_files) {
-          std::string file_name =
-              compaction_result->output_path + "/" + output_file.file_name;
-
-          uint64_t file_size = 0;
-          Status s = options.env->GetFileSize(file_name, &file_size);
-          ASSERT_OK(s);
-          ASSERT_GT(file_size, 0);
-
-          ASSERT_OK(test::TruncateFile(env_, file_name, file_size / 2));
-        }
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // CompactRange() should fail
-  Status s = db_->CompactRange(CompactRangeOptions(), &start, &end);
-  ASSERT_NOK(s);
-  ASSERT_TRUE(s.IsCorruption());
-
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  // On the worker side, the compaction is considered success
-  // Verification is done on the primary side
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-TEST_F(CompactionServiceTest, CustomFileChecksum) {
-  Options options = CurrentOptions();
-  options.file_checksum_gen_factory = GetFileChecksumGenCrc32cFactory();
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  std::string start_str = Key(15);
-  std::string end_str = Key(45);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionServiceCompactionJob::Run:0", [&](void* arg) {
-        CompactionServiceResult* compaction_result =
-            *(static_cast<CompactionServiceResult**>(arg));
-        ASSERT_TRUE(compaction_result != nullptr &&
-                    !compaction_result->output_files.empty());
-        // Validate Checksum files here
-        for (const auto& output_file : compaction_result->output_files) {
-          std::string file_name =
-              compaction_result->output_path + "/" + output_file.file_name;
-
-          FileChecksumGenContext gen_context;
-          gen_context.file_name = file_name;
-          std::unique_ptr<FileChecksumGenerator> file_checksum_gen =
-              options.file_checksum_gen_factory->CreateFileChecksumGenerator(
-                  gen_context);
-
-          std::unique_ptr<SequentialFile> file_reader;
-          uint64_t file_size = 0;
-          Status s = options.env->GetFileSize(file_name, &file_size);
-          ASSERT_OK(s);
-          ASSERT_GT(file_size, 0);
-
-          s = options.env->NewSequentialFile(file_name, &file_reader,
-                                             EnvOptions());
-          ASSERT_OK(s);
-
-          Slice result;
-          std::unique_ptr<char[]> scratch(new char[file_size]);
-          s = file_reader->Read(file_size, &result, scratch.get());
-          ASSERT_OK(s);
-
-          file_checksum_gen->Update(scratch.get(), result.size());
-          file_checksum_gen->Finalize();
-
-          // Verify actual checksum and the func name
-          ASSERT_EQ(file_checksum_gen->Name(),
-                    output_file.file_checksum_func_name);
-          ASSERT_EQ(file_checksum_gen->GetChecksum(),
-                    output_file.file_checksum);
-        }
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, &end));
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
 }

 TEST_F(CompactionServiceTest, CancelCompactionOnRemoteSide) {
@@ -1181,20 +601,11 @@ TEST_F(CompactionServiceTest, CompactionInfo) {
                              {file.db_path + "/" + file.name}, 2));
  info = my_cs->GetCompactionInfoForStart();
  ASSERT_EQ(Env::USER, info.priority);
-  ASSERT_EQ(CompactionReason::kManualCompaction, info.compaction_reason);
-  ASSERT_EQ(true, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
  info = my_cs->GetCompactionInfoForWait();
  ASSERT_EQ(Env::USER, info.priority);
-  ASSERT_EQ(CompactionReason::kManualCompaction, info.compaction_reason);
-  ASSERT_EQ(true, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);

  // Test priority BOTTOM
  env_->SetBackgroundThreads(1, Env::BOTTOM);
-  // This will set bottommost_level = true but is_full_compaction = false
  options.num_levels = 2;
  ReopenWithCompactionService(&options);
  my_cs =
@@ -1217,71 +628,9 @@ TEST_F(CompactionServiceTest, CompactionInfo) {
  }
  ASSERT_OK(dbfull()->TEST_WaitForCompact());
  info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(CompactionReason::kLevelL0FilesNum, info.compaction_reason);
-  ASSERT_EQ(false, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
  ASSERT_EQ(Env::BOTTOM, info.priority);
  info = my_cs->GetCompactionInfoForWait();
  ASSERT_EQ(Env::BOTTOM, info.priority);
-  ASSERT_EQ(CompactionReason::kLevelL0FilesNum, info.compaction_reason);
-  ASSERT_EQ(false, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
-
-  // Test Non-Bottommost Level
-  options.num_levels = 4;
-  ReopenWithCompactionService(&options);
-  my_cs =
-      static_cast_with_check<MyTestCompactionService>(GetCompactionService());
-
-  for (int i = 0; i < options.level0_file_num_compaction_trigger; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 10 + j;
-      ASSERT_OK(Put(Key(key_id), "value_new_new" + std::to_string(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(false, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(false, info.bottommost_level);
-  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(false, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(false, info.bottommost_level);
-
-  // Test Full Compaction + Bottommost Level
-  options.num_levels = 6;
-  ReopenWithCompactionService(&options);
-  my_cs =
-      static_cast_with_check<MyTestCompactionService>(GetCompactionService());
-
-  for (int i = 0; i < 20; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 10 + j;
-      ASSERT_OK(Put(Key(key_id), "value_new_new" + std::to_string(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  CompactRangeOptions cro;
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
-  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(true, info.is_manual_compaction);
-  ASSERT_EQ(true, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
-  ASSERT_EQ(CompactionReason::kManualCompaction, info.compaction_reason);
-  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(true, info.is_manual_compaction);
-  ASSERT_EQ(true, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
-  ASSERT_EQ(CompactionReason::kManualCompaction, info.compaction_reason);
 }

 TEST_F(CompactionServiceTest, FallbackLocalAuto) {
@@ -39,7 +39,7 @@ void CompactionState::AggregateCompactionStats(
    InternalStats::CompactionStatsFull& compaction_stats,
    CompactionJobStats& compaction_job_stats) {
  for (const auto& sc : sub_compact_states) {
-    sc.AggregateCompactionOutputStats(compaction_stats);
+    sc.AggregateCompactionStats(compaction_stats);
    compaction_job_stats.Add(sc.compaction_job_stats);
  }
 }
@@ -13,7 +13,7 @@
 #include "rocksdb/sst_partitioner.h"

 namespace ROCKSDB_NAMESPACE {
-void SubcompactionState::AggregateCompactionOutputStats(
+void SubcompactionState::AggregateCompactionStats(
    InternalStats::CompactionStatsFull& compaction_stats) const {
  compaction_stats.stats.Add(compaction_outputs_.stats_);
  if (HasPenultimateLevelOutputs()) {
@@ -34,16 +34,9 @@ void SubcompactionState::Cleanup(Cache* cache) {

  if (!status.ok()) {
    for (const auto& out : GetOutputs()) {
-      // If this file was inserted into the table cache then remove it here
-      // because this compaction was not committed. This is not strictly
-      // required because of a backstop TableCache::Evict() in
-      // PurgeObsoleteFiles() but is our opportunity to apply
-      // uncache_aggressiveness. TODO: instead, put these files into the
-      // VersionSet::obsolete_files_ pipeline so that they don't have to
-      // be picked up by scanning the DB directory.
-      TableCache::ReleaseObsolete(
-          cache, out.meta.fd.GetNumber(), nullptr /*handle*/,
-          compaction->mutable_cf_options()->uncache_aggressiveness);
+      // If this file was inserted into the table cache then remove
+      // them here because this compaction was not committed.
+      TableCache::Evict(cache, out.meta.fd.GetNumber());
    }
  }
  // TODO: sub_compact.io_status is not checked like status. Not sure if thats
@@ -179,7 +179,7 @@ class SubcompactionState {

  void Cleanup(Cache* cache);

-  void AggregateCompactionOutputStats(
+  void AggregateCompactionStats(
      InternalStats::CompactionStatsFull& compaction_stats) const;

  CompactionOutputs& Current() const {
@@ -9,26 +9,15 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include "db/db_test_util.h"
-#include "options/cf_options.h"
 #include "port/stack_trace.h"
 #include "rocksdb/iostats_context.h"
 #include "rocksdb/listener.h"
 #include "rocksdb/utilities/debug.h"
 #include "rocksdb/utilities/table_properties_collectors.h"
 #include "test_util/mock_time_env.h"
-#include "util/defer.h"
 #include "utilities/merge_operators.h"

 namespace ROCKSDB_NAMESPACE {
-namespace {
-ConfigOptions GetStrictConfigOptions() {
-  ConfigOptions config_options;
-  config_options.ignore_unknown_options = false;
-  config_options.ignore_unsupported_options = false;
-  config_options.input_strings_escaped = false;
-  return config_options;
-}
-}  // namespace

 class TieredCompactionTest : public DBTestBase {
 public:
@@ -1245,9 +1234,82 @@ TEST_F(TieredCompactionTest, RangeBasedTieredStorageLevel) {
  db_->ReleaseSnapshot(temp_snap);
 }

-class PrecludeLastLevelTestBase : public DBTestBase {
+TEST_F(TieredCompactionTest, CheckInternalKeyRange) {
+  // When compacting keys from the last level to penultimate level,
+  // output to penultimate level should be within internal key range
+  // of input files from penultimate level.
+  // Set up:
+  // L5:
+  //  File 1: DeleteRange[1, 3)@4, File 2: [3@5, 100@6]
+  // L6:
+  // File 3: [2@1, 3@2], File 4: [50@3]
+  //
+  // When File 1 and File 3 are being compacted,
+  // Key(3) cannot be compacted up, otherwise it causes
+  // inconsistency where File 3's Key(3) has a lower sequence number
+  // than File 2's Key(3).
+  const int kNumLevels = 7;
+  auto options = CurrentOptions();
+  SetColdTemperature(options);
+  options.level_compaction_dynamic_level_bytes = true;
+  options.num_levels = kNumLevels;
+  options.statistics = CreateDBStatistics();
+  options.max_subcompactions = 10;
+  options.preclude_last_level_data_seconds = 10000;
+  DestroyAndReopen(options);
+  auto cmp = options.comparator;
+
+  std::string hot_start = Key(0);
+  std::string hot_end = Key(0);
+  SyncPoint::GetInstance()->SetCallBack(
+      "CompactionIterator::PrepareOutput.context", [&](void* arg) {
+        auto context = static_cast<PerKeyPlacementContext*>(arg);
+        context->output_to_penultimate_level =
+            cmp->Compare(context->key, hot_start) >= 0 &&
+            cmp->Compare(context->key, hot_end) < 0;
+      });
+  SyncPoint::GetInstance()->EnableProcessing();
+  // File 1
+  ASSERT_OK(Put(Key(2), "val2"));
+  ASSERT_OK(Put(Key(3), "val3"));
+  ASSERT_OK(Flush());
+  MoveFilesToLevel(6);
+  // File 2
+  ASSERT_OK(Put(Key(50), "val50"));
+  ASSERT_OK(Flush());
+  MoveFilesToLevel(6);
+
+  const Snapshot* snapshot = db_->GetSnapshot();
+  hot_end = Key(100);
+  std::string start = Key(1);
+  std::string end = Key(3);
+  ASSERT_OK(
+      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), start, end));
+  ASSERT_OK(Flush());
+  MoveFilesToLevel(5);
+  // File 3
+  ASSERT_OK(Put(Key(3), "vall"));
+  ASSERT_OK(Put(Key(100), "val100"));
+  ASSERT_OK(Flush());
+  MoveFilesToLevel(5);
+  // Try to compact keys up
+  CompactRangeOptions cro;
+  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
+  start = Key(1);
+  end = Key(2);
+  Slice begin_slice(start);
+  Slice end_slice(end);
+  ASSERT_OK(db_->CompactRange(cro, &begin_slice, &end_slice));
+  // Without internal key range checking, we get the following error:
+  // Corruption: force_consistency_checks(DEBUG): VersionBuilder: L5 has
+  // overlapping ranges: file #18 largest key: '6B6579303030303033' seq:102,
+  // type:1 vs. file #15 smallest key: '6B6579303030303033' seq:104, type:1
+  db_->ReleaseSnapshot(snapshot);
+}
+
+class PrecludeLastLevelTest : public DBTestBase {
 public:
-  PrecludeLastLevelTestBase(std::string test_name = "preclude_last_level_test")
+  PrecludeLastLevelTest(std::string test_name = "preclude_last_level_test")
      : DBTestBase(test_name, /*env_do_fsync=*/false) {
    mock_clock_ = std::make_shared<MockSystemClock>(env_->GetSystemClock());
    mock_clock_->SetCurrentTime(kMockStartTime);
@@ -1272,52 +1334,9 @@ class PrecludeLastLevelTestBase : public DBTestBase {
        });
    mock_clock_->SetCurrentTime(kMockStartTime);
  }
-
-  void ApplyConfigChangeImpl(
-      bool dynamic, Options* options,
-      const std::unordered_map<std::string, std::string>& config_change,
-      const std::unordered_map<std::string, std::string>& db_config_change) {
-    if (dynamic) {
-      if (config_change.size() > 0) {
-        // FIXME: temporary while preserve/preclude options are not user mutable
-        SaveAndRestore<bool> m(&TEST_allowSetOptionsImmutableInMutable, true);
-        ASSERT_OK(db_->SetOptions(config_change));
-      }
-      if (db_config_change.size() > 0) {
-        ASSERT_OK(db_->SetDBOptions(db_config_change));
-      }
-    } else {
-      if (config_change.size() > 0) {
-        ASSERT_OK(GetColumnFamilyOptionsFromMap(
-            GetStrictConfigOptions(), *options, config_change, options));
-      }
-      if (db_config_change.size() > 0) {
-        ASSERT_OK(GetDBOptionsFromMap(GetStrictConfigOptions(), *options,
-                                      db_config_change, options));
-      }
-      Reopen(*options);
-    }
-  }
 };

-class PrecludeLastLevelTest : public PrecludeLastLevelTestBase,
-                              public testing::WithParamInterface<bool> {
- public:
-  using PrecludeLastLevelTestBase::PrecludeLastLevelTestBase;
-
-  bool UseDynamicConfig() const { return GetParam(); }
-
-  void ApplyConfigChange(
-      Options* options,
-      const std::unordered_map<std::string, std::string>& config_change,
-      const std::unordered_map<std::string, std::string>& db_config_change =
-          {}) {
-    ApplyConfigChangeImpl(UseDynamicConfig(), options, config_change,
-                          db_config_change);
-  }
-};
-
-TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimeManualCompaction) {
+TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimeManualCompaction) {
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
  const int kNumKeys = 100;
@@ -1348,8 +1367,9 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimeManualCompaction) {
  ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());

  // enable preclude feature
-  ApplyConfigChange(&options, {{"preclude_last_level_data_seconds", "10000"},
-                               {"last_level_temperature", "kCold"}});
+  options.preclude_last_level_data_seconds = 10000;
+  options.last_level_temperature = Temperature::kCold;
+  Reopen(options);

  // all data is hot, even they're in the last level
  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);
@@ -1373,7 +1393,7 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimeManualCompaction) {
  Close();
 }

-TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimeAutoCompaction) {
+TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimeAutoCompaction) {
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
  const int kNumKeys = 100;
@@ -1403,17 +1423,16 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimeAutoCompaction) {
  // all data is pushed to the last level
  ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());

-  // enable preclude feature, and...
+  // enable preclude feature
+  options.preclude_last_level_data_seconds = 10000;
+  options.last_level_temperature = Temperature::kCold;
  // make sure it won't trigger Size Amp compaction, unlike normal Size Amp
  // compaction which is typically a last level compaction, when tiered Storage
  // ("preclude_last_level") is enabled, size amp won't include the last level.
  // As the last level would be in cold tier and the size would not be a
  // problem, which also avoid frequent hot to cold storage compaction.
-  ApplyConfigChange(
-      &options,
-      {{"preclude_last_level_data_seconds", "10000"},
-       {"last_level_temperature", "kCold"},
-       {"compaction_options_universal.max_size_amplification_percent", "400"}});
+  options.compaction_options_universal.max_size_amplification_percent = 400;
+  Reopen(options);

  // all data is hot, even they're in the last level
  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);
@@ -1445,7 +1464,7 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimeAutoCompaction) {
  Close();
 }

-TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimePartial) {
+TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimePartial) {
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
  const int kNumKeys = 100;
@@ -1493,8 +1512,9 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimePartial) {
  }

  // enable preclude feature
-  ApplyConfigChange(&options, {{"preclude_last_level_data_seconds", "2000"},
-                               {"last_level_temperature", "kCold"}});
+  options.preclude_last_level_data_seconds = 2000;
+  options.last_level_temperature = Temperature::kCold;
+  Reopen(options);

  // Generate a sstable and trigger manual compaction
  ASSERT_OK(Put(Key(10), "value"));
@@ -1512,7 +1532,7 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimePartial) {
  Close();
 }

-TEST_P(PrecludeLastLevelTest, SmallPrecludeTime) {
+TEST_F(PrecludeLastLevelTest, SmallPrecludeTime) {
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
  const int kNumKeys = 100;
@@ -1565,203 +1585,13 @@ TEST_P(PrecludeLastLevelTest, SmallPrecludeTime) {
  Close();
 }

-TEST_P(PrecludeLastLevelTest, CheckInternalKeyRange) {
-  // When compacting keys from the last level to penultimate level,
-  // output to penultimate level should be within internal key range
-  // of input files from penultimate level.
-  // Set up:
-  // L5:
-  //  File 1: DeleteRange[1, 3)@4, File 2: [3@5, 100@6]
-  // L6:
-  // File 3: [2@1, 3@2], File 4: [50@3]
-  //
-  // When File 1 and File 3 are being compacted,
-  // Key(3) cannot be compacted up, otherwise it causes
-  // inconsistency where File 3's Key(3) has a lower sequence number
-  // than File 2's Key(3).
-  const int kNumLevels = 7;
-  auto options = CurrentOptions();
-  options.env = mock_env_.get();
-  options.last_level_temperature = Temperature::kCold;
-  options.level_compaction_dynamic_level_bytes = true;
-  options.num_levels = kNumLevels;
-  options.statistics = CreateDBStatistics();
-  options.max_subcompactions = 10;
-  options.preserve_internal_time_seconds = 10000;
-  DestroyAndReopen(options);
-  // File 3
-  ASSERT_OK(Put(Key(2), "val2"));
-  ASSERT_OK(Put(Key(3), "val3"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(6);
-  // File 4
-  ASSERT_OK(Put(Key(50), "val50"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(6);
-
-  ApplyConfigChange(&options, {{"preclude_last_level_data_seconds", "10000"}});
-  const Snapshot* snapshot = db_->GetSnapshot();
-
-  // File 1
-  std::string start = Key(1);
-  std::string end = Key(3);
-  ASSERT_OK(db_->DeleteRange({}, db_->DefaultColumnFamily(), start, end));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(5);
-  // File 2
-  ASSERT_OK(Put(Key(3), "vall"));
-  ASSERT_OK(Put(Key(100), "val100"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(5);
-
-  ASSERT_EQ("0,0,0,0,0,2,2", FilesPerLevel());
-
-  auto VerifyLogicalState = [&]() {
-    // First with snapshot
-    ASSERT_EQ("val2", Get(Key(2), snapshot));
-    ASSERT_EQ("val3", Get(Key(3), snapshot));
-    ASSERT_EQ("val50", Get(Key(50), snapshot));
-    ASSERT_EQ("NOT_FOUND", Get(Key(100), snapshot));
-
-    // Then without snapshot
-    ASSERT_EQ("NOT_FOUND", Get(Key(2)));
-    ASSERT_EQ("vall", Get(Key(3)));
-    ASSERT_EQ("val50", Get(Key(50)));
-    ASSERT_EQ("val100", Get(Key(100)));
-  };
-
-  VerifyLogicalState();
-
-  // Try to compact keys up
-  CompactRangeOptions cro;
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
-  // Without internal key range checking, we get the following error:
-  // Corruption: force_consistency_checks(DEBUG): VersionBuilder: L5 has
-  // overlapping ranges: file #18 largest key: '6B6579303030303033' seq:102,
-  // type:1 vs. file #15 smallest key: '6B6579303030303033' seq:104, type:1
-  ASSERT_OK(CompactRange(cro, Key(1), Key(2)));
-
-  VerifyLogicalState();
-
-  db_->ReleaseSnapshot(snapshot);
-  Close();
-}
-
-TEST_P(PrecludeLastLevelTest, RangeTombstoneSnapshotMigrateFromLast) {
-  // Reproducer for issue originally described in
-  // https://github.com/facebook/rocksdb/pull/9964/files#r1024449523
-  if (!UseDynamicConfig()) {
-    // Depends on config change while holding a snapshot
-    return;
-  }
-  const int kNumLevels = 7;
-  auto options = CurrentOptions();
-  options.env = mock_env_.get();
-  options.last_level_temperature = Temperature::kCold;
-  options.level_compaction_dynamic_level_bytes = true;
-  options.num_levels = kNumLevels;
-  options.statistics = CreateDBStatistics();
-  options.max_subcompactions = 10;
-  options.preserve_internal_time_seconds = 30000;
-  DestroyAndReopen(options);
-
-  // Entries with much older write time
-  ASSERT_OK(Put(Key(2), "val2"));
-  ASSERT_OK(Put(Key(6), "val6"));
-
-  for (int i = 0; i < 10; i++) {
-    dbfull()->TEST_WaitForPeriodicTaskRun(
-        [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(1000)); });
-  }
-  const Snapshot* snapshot = db_->GetSnapshot();
-
-  ASSERT_OK(db_->DeleteRange({}, db_->DefaultColumnFamily(), Key(1), Key(5)));
-  ASSERT_OK(Put(Key(1), "val1"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(6);
-  ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());
-
-  ApplyConfigChange(&options, {{"preclude_last_level_data_seconds", "10000"}});
-
-  // To exercise the WithinPenultimateLevelOutputRange feature, we want files
-  // around the middle file to be compacted on the penultimate level
-  ASSERT_OK(Put(Key(0), "val0"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put(Key(3), "val3"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put(Key(7), "val7"));
-
-  // FIXME: ideally this wouldn't be necessary to get a seqno to time entry
-  // into a later compaction to get data into the last level
-  dbfull()->TEST_WaitForPeriodicTaskRun(
-      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(1000)); });
-
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(5);
-  ASSERT_EQ("0,0,0,0,0,3,1", FilesPerLevel());
-
-  auto VerifyLogicalState = [&]() {
-    // First with snapshot
-    if (snapshot) {
-      ASSERT_EQ("NOT_FOUND", Get(Key(0), snapshot));
-      ASSERT_EQ("NOT_FOUND", Get(Key(1), snapshot));
-      ASSERT_EQ("val2", Get(Key(2), snapshot));
-      ASSERT_EQ("NOT_FOUND", Get(Key(3), snapshot));
-      ASSERT_EQ("val6", Get(Key(6), snapshot));
-      ASSERT_EQ("NOT_FOUND", Get(Key(7), snapshot));
-    }
-
-    // Then without snapshot
-    ASSERT_EQ("val0", Get(Key(0)));
-    ASSERT_EQ("val1", Get(Key(1)));
-    ASSERT_EQ("NOT_FOUND", Get(Key(2)));
-    ASSERT_EQ("val3", Get(Key(3)));
-    ASSERT_EQ("val6", Get(Key(6)));
-    ASSERT_EQ("val7", Get(Key(7)));
-  };
-
-  VerifyLogicalState();
-
-  // Try a limited range compaction
-  // FIXME: this currently hits the "Unsafe to store Seq later than snapshot"
-  // error. Needs to work safely for preclude option to be user mutable.
-  // ASSERT_OK(CompactRange({}, Key(3), Key(4)));
-  EXPECT_EQ("0,0,0,0,0,3,1", FilesPerLevel());
-  VerifyLogicalState();
-
-  // Compact everything, but some data still goes to both penultimate and last
-  // levels. A full-range compaction should be safe to "migrate" data from the
-  // last level to penultimate (because of preclude setting change).
-  ASSERT_OK(CompactRange({}, {}, {}));
-  EXPECT_EQ("0,0,0,0,0,1,1", FilesPerLevel());
-  VerifyLogicalState();
-  // Key1 should have been migrated out of the last level
-  auto& meta = *GetLevelFileMetadatas(6)[0];
-  ASSERT_LT(Key(1), meta.smallest.user_key().ToString());
-
-  // Make data eligible for last level
-  db_->ReleaseSnapshot(snapshot);
-  snapshot = nullptr;
-  mock_clock_->MockSleepForSeconds(static_cast<int>(10000));
-
-  ASSERT_OK(CompactRange({}, {}, {}));
-  EXPECT_EQ("0,0,0,0,0,0,1", FilesPerLevel());
-  VerifyLogicalState();
-
-  Close();
-}
-
-INSTANTIATE_TEST_CASE_P(PrecludeLastLevelTest, PrecludeLastLevelTest,
-                        ::testing::Bool());
-
+// Test Param: protection_bytes_per_key for WriteBatch
 class TimedPutPrecludeLastLevelTest
-    : public PrecludeLastLevelTestBase,
+    : public PrecludeLastLevelTest,
      public testing::WithParamInterface<size_t> {
 public:
  TimedPutPrecludeLastLevelTest()
-      : PrecludeLastLevelTestBase("timed_put_preclude_last_level_test") {}
-
-  size_t ProtectionBytesPerKey() const { return GetParam(); }
+      : PrecludeLastLevelTest("timed_put_preclude_last_level_test") {}
 };

 TEST_P(TimedPutPrecludeLastLevelTest, FastTrackTimedPutToLastLevel) {
@@ -1779,7 +1609,7 @@ TEST_P(TimedPutPrecludeLastLevelTest, FastTrackTimedPutToLastLevel) {
  options.last_level_temperature = Temperature::kCold;
  DestroyAndReopen(options);
  WriteOptions wo;
-  wo.protection_bytes_per_key = ProtectionBytesPerKey();
+  wo.protection_bytes_per_key = GetParam();

  Random rnd(301);

@@ -1833,7 +1663,7 @@ TEST_P(TimedPutPrecludeLastLevelTest, InterleavedTimedPutAndPut) {
  options.default_write_temperature = Temperature::kHot;
  DestroyAndReopen(options);
  WriteOptions wo;
-  wo.protection_bytes_per_key = ProtectionBytesPerKey();
+  wo.protection_bytes_per_key = GetParam();

  // Start time: kMockStartTime = 10000000;
  ASSERT_OK(TimedPut(0, Key(0), "v0", kMockStartTime - 1 * 24 * 60 * 60, wo));
@@ -1859,7 +1689,7 @@ TEST_P(TimedPutPrecludeLastLevelTest, PreserveTimedPutOnPenultimateLevel) {
  options.default_write_temperature = Temperature::kHot;
  DestroyAndReopen(options);
  WriteOptions wo;
-  wo.protection_bytes_per_key = ProtectionBytesPerKey();
+  wo.protection_bytes_per_key = GetParam();

  // Creating a snapshot to manually control when preferred sequence number is
  // swapped in. An entry's preferred seqno won't get swapped in until it's
@@ -1929,7 +1759,7 @@ TEST_P(TimedPutPrecludeLastLevelTest, AutoTriggerCompaction) {
  options.table_properties_collector_factories.push_back(factory);
  DestroyAndReopen(options);
  WriteOptions wo;
-  wo.protection_bytes_per_key = ProtectionBytesPerKey();
+  wo.protection_bytes_per_key = GetParam();

  Random rnd(301);

@@ -1984,7 +1814,7 @@ TEST_P(TimedPutPrecludeLastLevelTest, AutoTriggerCompaction) {
 INSTANTIATE_TEST_CASE_P(TimedPutPrecludeLastLevelTest,
                        TimedPutPrecludeLastLevelTest, ::testing::Values(0, 8));

-TEST_P(PrecludeLastLevelTest, LastLevelOnlyCompactionPartial) {
+TEST_F(PrecludeLastLevelTest, LastLevelOnlyCompactionPartial) {
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
  const int kNumKeys = 100;
@@ -2015,8 +1845,9 @@ TEST_P(PrecludeLastLevelTest, LastLevelOnlyCompactionPartial) {
  ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());

  // enable preclude feature
-  ApplyConfigChange(&options, {{"preclude_last_level_data_seconds", "2000"},
-                               {"last_level_temperature", "kCold"}});
+  options.preclude_last_level_data_seconds = 2000;
+  options.last_level_temperature = Temperature::kCold;
+  Reopen(options);

  CompactRangeOptions cro;
  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
@@ -2047,30 +1878,21 @@ TEST_P(PrecludeLastLevelTest, LastLevelOnlyCompactionPartial) {
  Close();
 }

-class PrecludeLastLevelOptionalTest
-    : public PrecludeLastLevelTestBase,
-      public testing::WithParamInterface<std::tuple<bool, bool>> {
+class PrecludeLastLevelTestWithParms
+    : public PrecludeLastLevelTest,
+      public testing::WithParamInterface<bool> {
 public:
-  bool UseDynamicConfig() const { return std::get<0>(GetParam()); }
-
-  void ApplyConfigChange(
-      Options* options,
-      const std::unordered_map<std::string, std::string>& config_change,
-      const std::unordered_map<std::string, std::string>& db_config_change =
-          {}) {
-    ApplyConfigChangeImpl(UseDynamicConfig(), options, config_change,
-                          db_config_change);
-  }
-
-  bool EnablePrecludeLastLevel() const { return std::get<1>(GetParam()); }
+  PrecludeLastLevelTestWithParms() : PrecludeLastLevelTest() {}
 };

-TEST_P(PrecludeLastLevelOptionalTest, LastLevelOnlyCompactionNoPreclude) {
+TEST_P(PrecludeLastLevelTestWithParms, LastLevelOnlyCompactionNoPreclude) {
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
  const int kNumKeys = 100;
  const int kKeyPerSec = 10;

+  bool enable_preclude_last_level = GetParam();
+
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.preserve_internal_time_seconds = 2000;
@@ -2128,7 +1950,7 @@ TEST_P(PrecludeLastLevelOptionalTest, LastLevelOnlyCompactionNoPreclude) {
  SyncPoint::GetInstance()->SetCallBack(
      "UniversalCompactionBuilder::PickCompaction:Return", [&](void* arg) {
        auto compaction = static_cast<Compaction*>(arg);
-        if (EnablePrecludeLastLevel() && is_manual_compaction_running) {
+        if (enable_preclude_last_level && is_manual_compaction_running) {
          ASSERT_TRUE(compaction == nullptr);
          verified_compaction_order = true;
        } else {
@@ -2155,11 +1977,12 @@ TEST_P(PrecludeLastLevelOptionalTest, LastLevelOnlyCompactionNoPreclude) {
  SyncPoint::GetInstance()->EnableProcessing();

  // only enable if the Parameter is true
-  ApplyConfigChange(&options,
-                    {{"preclude_last_level_data_seconds",
-                      EnablePrecludeLastLevel() ? "2000" : "0"},
-                     {"last_level_temperature", "kCold"}},
-                    {{"max_background_jobs", "8"}});
+  if (enable_preclude_last_level) {
+    options.preclude_last_level_data_seconds = 2000;
+  }
+  options.max_background_jobs = 8;
+  options.last_level_temperature = Temperature::kCold;
+  Reopen(options);

  auto manual_compaction_thread = port::Thread([this]() {
    CompactRangeOptions cro;
@@ -2188,7 +2011,7 @@ TEST_P(PrecludeLastLevelOptionalTest, LastLevelOnlyCompactionNoPreclude) {

  ASSERT_OK(dbfull()->TEST_WaitForCompact());

-  if (EnablePrecludeLastLevel()) {
+  if (enable_preclude_last_level) {
    ASSERT_NE("0,0,0,0,0,1,1", FilesPerLevel());
  } else {
    ASSERT_EQ("0,0,0,0,0,1,1", FilesPerLevel());
@@ -2202,7 +2025,7 @@ TEST_P(PrecludeLastLevelOptionalTest, LastLevelOnlyCompactionNoPreclude) {
  Close();
 }

-TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToPenultimateLevel) {
+TEST_P(PrecludeLastLevelTestWithParms, PeriodicCompactionToPenultimateLevel) {
  // Test the last level only periodic compaction should also be blocked by an
  // ongoing compaction in penultimate level if tiered compaction is enabled
  // otherwise, the periodic compaction should just run for the last level.
@@ -2212,6 +2035,8 @@ TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToPenultimateLevel) {
  const int kKeyPerSec = 1;
  const int kNumKeys = 100;

+  bool enable_preclude_last_level = GetParam();
+
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.preserve_internal_time_seconds = 20000;
@@ -2238,11 +2063,12 @@ TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToPenultimateLevel) {
  ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());

  // enable preclude feature
-  ApplyConfigChange(&options,
-                    {{"preclude_last_level_data_seconds",
-                      EnablePrecludeLastLevel() ? "2000" : "0"},
-                     {"last_level_temperature", "kCold"}},
-                    {{"max_background_jobs", "8"}});
+  if (enable_preclude_last_level) {
+    options.preclude_last_level_data_seconds = 20000;
+  }
+  options.max_background_jobs = 8;
+  options.last_level_temperature = Temperature::kCold;
+  Reopen(options);

  std::atomic_bool is_size_ratio_compaction_running = false;
  std::atomic_bool verified_last_level_compaction = false;
@@ -2267,7 +2093,7 @@ TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToPenultimateLevel) {
        auto compaction = static_cast<Compaction*>(arg);

        if (is_size_ratio_compaction_running) {
-          if (EnablePrecludeLastLevel()) {
+          if (enable_preclude_last_level) {
            ASSERT_TRUE(compaction == nullptr);
          } else {
            ASSERT_TRUE(compaction != nullptr);
@@ -2325,10 +2151,8 @@ TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToPenultimateLevel) {
  Close();
 }

-INSTANTIATE_TEST_CASE_P(PrecludeLastLevelOptionalTest,
-                        PrecludeLastLevelOptionalTest,
-                        ::testing::Combine(::testing::Bool(),
-                                           ::testing::Bool()));
+INSTANTIATE_TEST_CASE_P(PrecludeLastLevelTestWithParms,
+                        PrecludeLastLevelTestWithParms, testing::Bool());

 // partition the SST into 3 ranges [0, 19] [20, 39] [40, ...]
 class ThreeRangesPartitioner : public SstPartitioner {
@@ -2372,7 +2196,7 @@ class ThreeRangesPartitionerFactory : public SstPartitionerFactory {
  }
 };

-TEST_P(PrecludeLastLevelTest, PartialPenultimateLevelCompaction) {
+TEST_F(PrecludeLastLevelTest, PartialPenultimateLevelCompaction) {
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
  const int kKeyPerSec = 10;
@@ -2383,7 +2207,6 @@ TEST_P(PrecludeLastLevelTest, PartialPenultimateLevelCompaction) {
  options.level0_file_num_compaction_trigger = kNumTrigger;
  options.preserve_internal_time_seconds = 10000;
  options.num_levels = kNumLevels;
-  options.statistics = CreateDBStatistics();
  DestroyAndReopen(options);

  Random rnd(301);
@@ -2421,10 +2244,11 @@ TEST_P(PrecludeLastLevelTest, PartialPenultimateLevelCompaction) {
  // L6: [0,                299]
  ASSERT_EQ("0,0,0,0,0,3,1", FilesPerLevel());

-  ASSERT_OK(options.statistics->Reset());
  // enable tiered storage feature
-  ApplyConfigChange(&options, {{"preclude_last_level_data_seconds", "10000"},
-                               {"last_level_temperature", "kCold"}});
+  options.preclude_last_level_data_seconds = 10000;
+  options.last_level_temperature = Temperature::kCold;
+  options.statistics = CreateDBStatistics();
+  Reopen(options);

  ColumnFamilyMetaData meta;
  db_->GetColumnFamilyMetaData(&meta);
@@ -2470,7 +2294,7 @@ TEST_P(PrecludeLastLevelTest, PartialPenultimateLevelCompaction) {
  Close();
 }

-TEST_P(PrecludeLastLevelTest, RangeDelsCauseFileEndpointsToOverlap) {
+TEST_F(PrecludeLastLevelTest, RangeDelsCauseFileEndpointsToOverlap) {
  const int kNumLevels = 7;
  const int kSecondsPerKey = 10;
  const int kNumFiles = 3;
@@ -2609,25 +2433,12 @@ TEST_P(PrecludeLastLevelTest, RangeDelsCauseFileEndpointsToOverlap) {

 // Tests DBIter::GetProperty("rocksdb.iterator.write-time") return a data's
 // approximate write unix time.
-class IteratorWriteTimeTest
-    : public PrecludeLastLevelTestBase,
-      public testing::WithParamInterface<std::tuple<bool, bool>> {
+// Test Param:
+// 1) use tailing iterator or regular iterator (when it applies)
+class IteratorWriteTimeTest : public PrecludeLastLevelTest,
+                              public testing::WithParamInterface<bool> {
 public:
-  IteratorWriteTimeTest()
-      : PrecludeLastLevelTestBase("iterator_write_time_test") {}
-
-  bool UseTailingIterator() const { return std::get<0>(GetParam()); }
-
-  bool UseDynamicConfig() const { return std::get<1>(GetParam()); }
-
-  void ApplyConfigChange(
-      Options* options,
-      const std::unordered_map<std::string, std::string>& config_change,
-      const std::unordered_map<std::string, std::string>& db_config_change =
-          {}) {
-    ApplyConfigChangeImpl(UseDynamicConfig(), options, config_change,
-                          db_config_change);
-  }
+  IteratorWriteTimeTest() : PrecludeLastLevelTest("iterator_write_time_test") {}

  uint64_t VerifyKeyAndGetWriteTime(Iterator* iter,
                                    const std::string& expected_key) {
@@ -2667,14 +2478,10 @@ TEST_P(IteratorWriteTimeTest, ReadFromMemtables) {
  options.compaction_style = kCompactionStyleUniversal;
  options.env = mock_env_.get();
  options.level0_file_num_compaction_trigger = kNumTrigger;
+  options.preserve_internal_time_seconds = 10000;
  options.num_levels = kNumLevels;
  DestroyAndReopen(options);

-  // While there are issues with tracking seqno 0
-  ASSERT_OK(Delete("something_to_bump_seqno"));
-
-  ApplyConfigChange(&options, {{"preserve_internal_time_seconds", "10000"}});
-
  Random rnd(301);
  for (int i = 0; i < kNumKeys; i++) {
    dbfull()->TEST_WaitForPeriodicTaskRun(
@@ -2688,7 +2495,7 @@ TEST_P(IteratorWriteTimeTest, ReadFromMemtables) {
  }

  ReadOptions ropts;
-  ropts.tailing = UseTailingIterator();
+  ropts.tailing = GetParam();
  int i;

  // Forward iteration
@@ -2705,7 +2512,6 @@ TEST_P(IteratorWriteTimeTest, ReadFromMemtables) {
                              start_time + kSecondsPerRecording * (i + 1));
      }
    }
-    ASSERT_EQ(kNumKeys, i);
    ASSERT_OK(iter->status());
  }

@@ -2725,12 +2531,12 @@ TEST_P(IteratorWriteTimeTest, ReadFromMemtables) {
      }
    }
    ASSERT_OK(iter->status());
-    ASSERT_EQ(-1, i);
  }

-  // Disable the seqno to time recording. Data with user specified write time
-  // can still get a write time before it's flushed.
-  ApplyConfigChange(&options, {{"preserve_internal_time_seconds", "0"}});
+  // Reopen the DB and disable the seqno to time recording, data with user
+  // specified write time can still get a write time before it's flushed.
+  options.preserve_internal_time_seconds = 0;
+  DestroyAndReopen(options);
  ASSERT_OK(TimedPut(Key(kKeyWithWriteTime), rnd.RandomString(100),
                     kUserSpecifiedWriteTime));
  {
@@ -2766,14 +2572,10 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {
  options.compaction_style = kCompactionStyleUniversal;
  options.env = mock_env_.get();
  options.level0_file_num_compaction_trigger = kNumTrigger;
+  options.preserve_internal_time_seconds = 10000;
  options.num_levels = kNumLevels;
  DestroyAndReopen(options);

-  // While there are issues with tracking seqno 0
-  ASSERT_OK(Delete("something_to_bump_seqno"));
-
-  ApplyConfigChange(&options, {{"preserve_internal_time_seconds", "10000"}});
-
  Random rnd(301);
  for (int i = 0; i < kNumKeys; i++) {
    dbfull()->TEST_WaitForPeriodicTaskRun(
@@ -2788,7 +2590,7 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {

  ASSERT_OK(Flush());
  ReadOptions ropts;
-  ropts.tailing = UseTailingIterator();
+  ropts.tailing = GetParam();
  std::string prop;
  int i;

@@ -2811,7 +2613,6 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {
      }
    }
    ASSERT_OK(iter->status());
-    ASSERT_EQ(kNumKeys, i);
  }

  // Backward iteration
@@ -2831,12 +2632,12 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {
      }
    }
    ASSERT_OK(iter->status());
-    ASSERT_EQ(-1, i);
  }

-  // Disable the seqno to time recording. Data retrieved from SST files still
-  // have write time available.
-  ApplyConfigChange(&options, {{"preserve_internal_time_seconds", "0"}});
+  // Reopen the DB and disable the seqno to time recording. Data retrieved from
+  // SST files still have write time available.
+  options.preserve_internal_time_seconds = 0;
+  DestroyAndReopen(options);

  dbfull()->TEST_WaitForPeriodicTaskRun(
      [&] { mock_clock_->MockSleepForSeconds(kSecondsPerRecording); });
@@ -2862,7 +2663,6 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {
                              start_time + kSecondsPerRecording * (i + 1));
      }
    }
-    ASSERT_EQ(kNumKeys, i);
    ASSERT_OK(iter->status());
  }

@@ -2886,7 +2686,6 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {
      VerifyKeyAndWriteTime(iter.get(), Key(i), 0);
    }
    ASSERT_OK(iter->status());
-    ASSERT_EQ(kNumKeys, i);
  }
  Close();
 }
@@ -2900,12 +2699,11 @@ TEST_P(IteratorWriteTimeTest, MergeReturnsBaseValueWriteTime) {
  options.compaction_style = kCompactionStyleUniversal;
  options.env = mock_env_.get();
  options.level0_file_num_compaction_trigger = kNumTrigger;
+  options.preserve_internal_time_seconds = 10000;
  options.num_levels = kNumLevels;
  options.merge_operator = MergeOperators::CreateStringAppendOperator();
  DestroyAndReopen(options);

-  ApplyConfigChange(&options, {{"preserve_internal_time_seconds", "10000"}});
-
  dbfull()->TEST_WaitForPeriodicTaskRun(
      [&] { mock_clock_->MockSleepForSeconds(kSecondsPerRecording); });
  ASSERT_OK(Put("foo", "fv1"));
@@ -2916,7 +2714,7 @@ TEST_P(IteratorWriteTimeTest, MergeReturnsBaseValueWriteTime) {
  ASSERT_OK(Merge("foo", "bv1"));

  ReadOptions ropts;
-  ropts.tailing = UseTailingIterator();
+  ropts.tailing = GetParam();
  {
    std::unique_ptr<Iterator> iter(dbfull()->NewIterator(ropts));
    iter->SeekToFirst();
@@ -2934,7 +2732,7 @@ TEST_P(IteratorWriteTimeTest, MergeReturnsBaseValueWriteTime) {
 }

 INSTANTIATE_TEST_CASE_P(IteratorWriteTimeTest, IteratorWriteTimeTest,
-                        testing::Combine(testing::Bool(), testing::Bool()));
+                        testing::Bool());

 }  // namespace ROCKSDB_NAMESPACE

@@ -87,7 +87,7 @@ Status VerifySstFileChecksumInternal(const Options& options,
      options.block_protection_bytes_per_key, false /* skip_filters */,
      !kImmortal, false /* force_direct_prefetch */, -1 /* level */);
  reader_options.largest_seqno = largest_seqno;
-  s = options.table_factory->NewTableReader(
+  s = ioptions.table_factory->NewTableReader(
      read_options, reader_options, std::move(file_reader), file_size,
      &table_reader, false /* prefetch_index_and_filter_in_cache */);
  if (!s.ok()) {
@@ -688,100 +688,76 @@ TEST_F(DBBasicTest, IdentityAcrossRestarts) {
  constexpr size_t kMinIdSize = 10;
  do {
    for (bool with_manifest : {false, true}) {
-      for (bool write_file : {false, true}) {
-        std::string idfilename = IdentityFileName(dbname_);
-        std::string id1, tmp;
-        ASSERT_OK(db_->GetDbIdentity(id1));
-        ASSERT_GE(id1.size(), kMinIdSize);
+      std::string idfilename = IdentityFileName(dbname_);
+      std::string id1, tmp;
+      ASSERT_OK(db_->GetDbIdentity(id1));
+      ASSERT_GE(id1.size(), kMinIdSize);

-        Options options = CurrentOptions();
-        options.write_dbid_to_manifest = with_manifest;
-        options.write_identity_file = true;  // initially
-        Reopen(options);
-        std::string id2;
-        ASSERT_OK(db_->GetDbIdentity(id2));
-        // id2 should match id1 because identity was not regenerated
-        ASSERT_EQ(id1, id2);
-        ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
-        ASSERT_EQ(tmp, id2);
+      Options options = CurrentOptions();
+      options.write_dbid_to_manifest = with_manifest;
+      Reopen(options);
+      std::string id2;
+      ASSERT_OK(db_->GetDbIdentity(id2));
+      // id2 should match id1 because identity was not regenerated
+      ASSERT_EQ(id1, id2);
+      ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
+      ASSERT_EQ(tmp, id2);

-        if (write_file) {
-          // Recover from deleted/missing IDENTITY
-          ASSERT_OK(env_->DeleteFile(idfilename));
-        } else {
-          // Transition to no IDENTITY file
-          options.write_identity_file = false;
-          if (!with_manifest) {
-            // Incompatible options, should fail
-            ASSERT_NOK(TryReopen(options));
-            // Back to a usable config and continue
-            options.write_identity_file = true;
-            Reopen(options);
-            continue;
-          }
-        }
-        Reopen(options);
-        std::string id3;
-        ASSERT_OK(db_->GetDbIdentity(id3));
-        if (with_manifest) {
-          // id3 should match id1 because identity was restored from manifest
-          ASSERT_EQ(id1, id3);
-        } else {
-          // id3 should NOT match id1 because identity was regenerated
-          ASSERT_NE(id1, id3);
-          ASSERT_GE(id3.size(), kMinIdSize);
-        }
-        if (write_file) {
-          ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
-          ASSERT_EQ(tmp, id3);
-
-          // Recover from truncated IDENTITY
-          std::unique_ptr<WritableFile> w;
-          ASSERT_OK(env_->NewWritableFile(idfilename, &w, EnvOptions()));
-          ASSERT_OK(w->Close());
-        } else {
-          ASSERT_TRUE(env_->FileExists(idfilename).IsNotFound());
-        }
-        Reopen(options);
-        std::string id4;
-        ASSERT_OK(db_->GetDbIdentity(id4));
-        if (with_manifest) {
-          // id4 should match id1 because identity was restored from manifest
-          ASSERT_EQ(id1, id4);
-        } else {
-          // id4 should NOT match id1 because identity was regenerated
-          ASSERT_NE(id1, id4);
-          ASSERT_GE(id4.size(), kMinIdSize);
-        }
-        std::string silly_id = "asdf123456789";
-        if (write_file) {
-          ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
-          ASSERT_EQ(tmp, id4);
-
-          // Recover from overwritten IDENTITY
-          std::unique_ptr<WritableFile> w;
-          ASSERT_OK(env_->NewWritableFile(idfilename, &w, EnvOptions()));
-          ASSERT_OK(w->Append(silly_id));
-          ASSERT_OK(w->Close());
-        } else {
-          ASSERT_TRUE(env_->FileExists(idfilename).IsNotFound());
-        }
-        Reopen(options);
-        std::string id5;
-        ASSERT_OK(db_->GetDbIdentity(id5));
-        if (with_manifest) {
-          // id4 should match id1 because identity was restored from manifest
-          ASSERT_EQ(id1, id5);
-        } else {
-          ASSERT_EQ(id5, silly_id);
-        }
-        if (write_file) {
-          ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
-          ASSERT_EQ(tmp, id5);
-        } else {
-          ASSERT_TRUE(env_->FileExists(idfilename).IsNotFound());
-        }
+      // Recover from deleted/missing IDENTITY
+      ASSERT_OK(env_->DeleteFile(idfilename));
+      Reopen(options);
+      std::string id3;
+      ASSERT_OK(db_->GetDbIdentity(id3));
+      if (with_manifest) {
+        // id3 should match id1 because identity was restored from manifest
+        ASSERT_EQ(id1, id3);
+      } else {
+        // id3 should NOT match id1 because identity was regenerated
+        ASSERT_NE(id1, id3);
+        ASSERT_GE(id3.size(), kMinIdSize);
      }
+      ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
+      ASSERT_EQ(tmp, id3);
+
+      // Recover from truncated IDENTITY
+      {
+        std::unique_ptr<WritableFile> w;
+        ASSERT_OK(env_->NewWritableFile(idfilename, &w, EnvOptions()));
+        ASSERT_OK(w->Close());
+      }
+      Reopen(options);
+      std::string id4;
+      ASSERT_OK(db_->GetDbIdentity(id4));
+      if (with_manifest) {
+        // id4 should match id1 because identity was restored from manifest
+        ASSERT_EQ(id1, id4);
+      } else {
+        // id4 should NOT match id1 because identity was regenerated
+        ASSERT_NE(id1, id4);
+        ASSERT_GE(id4.size(), kMinIdSize);
+      }
+      ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
+      ASSERT_EQ(tmp, id4);
+
+      // Recover from overwritten IDENTITY
+      std::string silly_id = "asdf123456789";
+      {
+        std::unique_ptr<WritableFile> w;
+        ASSERT_OK(env_->NewWritableFile(idfilename, &w, EnvOptions()));
+        ASSERT_OK(w->Append(silly_id));
+        ASSERT_OK(w->Close());
+      }
+      Reopen(options);
+      std::string id5;
+      ASSERT_OK(db_->GetDbIdentity(id5));
+      if (with_manifest) {
+        // id4 should match id1 because identity was restored from manifest
+        ASSERT_EQ(id1, id5);
+      } else {
+        ASSERT_EQ(id5, silly_id);
+      }
+      ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
+      ASSERT_EQ(tmp, id5);
    }
  } while (ChangeCompactOptions());
 }
@@ -563,7 +563,7 @@ TEST_P(DBBlockCacheTest1, WarmCacheWithBlocksDuringFlush) {
  }
 }

-TEST_F(DBBlockCacheTest, DynamicOptions) {
+TEST_F(DBBlockCacheTest, DynamicallyWarmCacheDuringFlush) {
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
@@ -578,74 +578,39 @@ TEST_F(DBBlockCacheTest, DynamicOptions) {
  DestroyAndReopen(options);

  std::string value(kValueSize, 'a');
-  auto st = options.statistics;

-  size_t i = 1;
-  ASSERT_OK(Put(std::to_string(i), value));
-  ASSERT_OK(Flush());
-  ASSERT_EQ(1, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
+  for (size_t i = 1; i <= 5; i++) {
+    ASSERT_OK(Put(std::to_string(i), value));
+    ASSERT_OK(Flush());
+    ASSERT_EQ(1,
+              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));

-  ASSERT_EQ(value, Get(std::to_string(i)));
-  ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-  ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_MISS));
-  ASSERT_EQ(1, st->getAndResetTickerCount(BLOCK_CACHE_DATA_HIT));
+    ASSERT_EQ(value, Get(std::to_string(i)));
+    ASSERT_EQ(0,
+              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
+    ASSERT_EQ(
+        0, options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_MISS));
+    ASSERT_EQ(1,
+              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_HIT));
+  }

-  ++i;
  ASSERT_OK(dbfull()->SetOptions(
      {{"block_based_table_factory", "{prepopulate_block_cache=kDisable;}"}}));

-  ASSERT_OK(Put(std::to_string(i), value));
-  ASSERT_OK(Flush());
-  ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
+  for (size_t i = 6; i <= kNumBlocks; i++) {
+    ASSERT_OK(Put(std::to_string(i), value));
+    ASSERT_OK(Flush());
+    ASSERT_EQ(0,
+              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));

-  ASSERT_EQ(value, Get(std::to_string(i)));
-  ASSERT_EQ(1, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-  ASSERT_EQ(1, st->getAndResetTickerCount(BLOCK_CACHE_DATA_MISS));
-  ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_HIT));
-
-  ++i;
-  ASSERT_OK(dbfull()->SetOptions({{"block_based_table_factory",
-                                   "{prepopulate_block_cache=kFlushOnly;}"}}));
-
-  ASSERT_OK(Put(std::to_string(i), value));
-  ASSERT_OK(Flush());
-  ASSERT_EQ(1, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-
-  ASSERT_EQ(value, Get(std::to_string(i)));
-  ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-  ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_MISS));
-  ASSERT_EQ(1, st->getAndResetTickerCount(BLOCK_CACHE_DATA_HIT));
-
-  ++i;
-  // NOT YET SUPPORTED
-  // FIXME: find a way to make this fail again (until well supported)
-  // ASSERT_NOK(dbfull()->SetOptions(
-  //    {{"block_based_table_factory", "{block_cache=null;}"}}));
-
-  // ASSERT_OK(Put(std::to_string(i), value));
-  // ASSERT_OK(Flush());
-  // ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-
-  // ASSERT_EQ(value, Get(std::to_string(i)));
-  // ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-  // ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_MISS));
-  // ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_HIT));
-
-  // ++i;
-
-  // NOT YET SUPPORTED
-  // FIXME: find a way to make this fail again (until well supported)
-  // ASSERT_NOK(dbfull()->SetOptions(
-  //    {{"block_based_table_factory", "{block_cache=1M;}"}}));
-
-  // ASSERT_OK(Put(std::to_string(i), value));
-  // ASSERT_OK(Flush());
-  // ASSERT_EQ(1, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-
-  // ASSERT_EQ(value, Get(std::to_string(i)));
-  // ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-  // ASSERT_EQ(0, st->getAndResetTickerCount(BLOCK_CACHE_DATA_MISS));
-  // ASSERT_EQ(1, st->getAndResetTickerCount(BLOCK_CACHE_DATA_HIT));
+    ASSERT_EQ(value, Get(std::to_string(i)));
+    ASSERT_EQ(1,
+              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
+    ASSERT_EQ(
+        1, options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_MISS));
+    ASSERT_EQ(0,
+              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_HIT));
+  }
 }
 #endif

@@ -171,7 +171,7 @@ TEST_P(DBBloomFilterTestDefFormatVersion, KeyMayExist) {
    options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
    CreateAndReopenWithCF({"pikachu"}, options);

-    ASSERT_FALSE(db_->KeyMayExist(ropts, handles_[1], "a", &value));
+    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "a", &value));

    ASSERT_OK(Put(1, "a", "b"));
    bool value_found = false;
@@ -187,7 +187,7 @@ TEST_P(DBBloomFilterTestDefFormatVersion, KeyMayExist) {
    uint64_t cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
    ASSERT_TRUE(
        db_->KeyMayExist(ropts, handles_[1], "a", &value, &value_found));
-    ASSERT_FALSE(value_found);
+    ASSERT_TRUE(!value_found);
    // assert that no new files were opened and no new blocks were
    // read into block cache.
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
@@ -197,7 +197,7 @@ TEST_P(DBBloomFilterTestDefFormatVersion, KeyMayExist) {

    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
-    ASSERT_FALSE(db_->KeyMayExist(ropts, handles_[1], "a", &value));
+    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "a", &value));
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));

@@ -207,7 +207,7 @@ TEST_P(DBBloomFilterTestDefFormatVersion, KeyMayExist) {

    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
-    ASSERT_FALSE(db_->KeyMayExist(ropts, handles_[1], "a", &value));
+    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "a", &value));
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));

@@ -215,7 +215,7 @@ TEST_P(DBBloomFilterTestDefFormatVersion, KeyMayExist) {

    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
-    ASSERT_FALSE(db_->KeyMayExist(ropts, handles_[1], "c", &value));
+    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "c", &value));
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));

@@ -1975,24 +1975,10 @@ TEST_F(DBBloomFilterTest, MutatingRibbonFilterPolicy) {
    if (configs.empty()) {
      break;
    }
-    std::string factory_field =
-        (v[0] & 1) ? "table_factory" : "block_based_table_factory";

-    // Some irrelevant SetOptions to be sure they don't interfere
-    ASSERT_OK(db_->SetOptions({{"level0_file_num_compaction_trigger", "10"}}));
    ASSERT_OK(
-        db_->SetOptions({{"block_based_table_factory", "{block_size=1234}"}}));
-    ASSERT_OK(db_->SetOptions({{factory_field + ".block_size", "12345"}}));
-
-    // Test the mutable field we're interested in
-    ASSERT_OK(
-        db_->SetOptions({{factory_field + ".filter_policy.bloom_before_level",
+        db_->SetOptions({{"table_factory.filter_policy.bloom_before_level",
                          configs.back().first}}));
-    // FilterPolicy pointer should not have changed
-    ASSERT_EQ(db_->GetOptions()
-                  .table_factory->GetOptions<BlockBasedTableOptions>()
-                  ->filter_policy.get(),
-              table_options.filter_policy.get());

    // Ensure original object is mutated
    std::string val;
@@ -2005,59 +1991,6 @@ TEST_F(DBBloomFilterTest, MutatingRibbonFilterPolicy) {
  }
 }

-TEST_F(DBBloomFilterTest, MutableFilterPolicy) {
-  // Test that BlockBasedTableOptions::filter_policy is mutable (replaceable)
-  // with SetOptions.
-
-  Options options = CurrentOptions();
-  options.statistics = CreateDBStatistics();
-  auto& stats = *options.statistics;
-  BlockBasedTableOptions table_options;
-  // First config, to make sure there's no issues with this shared ptr
-  // etc. when the DB switches filter policies.
-  table_options.filter_policy.reset(NewBloomFilterPolicy(10));
-  double expected_bpk = 10.0;
-  // Other configs to try
-  std::vector<std::pair<std::string, double>> configs = {
-      {"ribbonfilter:10:-1", 7.0}, {"bloomfilter:5", 5.0}, {"nullptr", 0.0}};
-
-  table_options.cache_index_and_filter_blocks = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.level0_file_num_compaction_trigger =
-      static_cast<int>(configs.size()) + 2;
-
-  ASSERT_OK(TryReopen(options));
-
-  char v[] = "a";
-
-  for (;; ++(v[0])) {
-    const int maxKey = 8000;
-    for (int i = 0; i < maxKey; i++) {
-      ASSERT_OK(Put(Key(i), v));
-    }
-    ASSERT_OK(Flush());
-
-    for (int i = 0; i < maxKey; i++) {
-      ASSERT_EQ(Get(Key(i)), v);
-    }
-
-    uint64_t filter_bytes =
-        stats.getAndResetTickerCount(BLOCK_CACHE_FILTER_BYTES_INSERT);
-
-    EXPECT_NEAR(filter_bytes * 8.0 / maxKey, expected_bpk, 0.3);
-
-    if (configs.empty()) {
-      break;
-    }
-
-    ASSERT_OK(
-        db_->SetOptions({{"block_based_table_factory",
-                          "{filter_policy=" + configs.back().first + "}"}}));
-    expected_bpk = configs.back().second;
-    configs.pop_back();
-  }
-}
-
 class SliceTransformLimitedDomain : public SliceTransform {
  const char* Name() const override { return "SliceTransformLimitedDomain"; }

@@ -2244,146 +2177,24 @@ TEST_F(DBBloomFilterTest, MemtableWholeKeyBloomFilterMultiGet) {

  db_->ReleaseSnapshot(snapshot);
 }
-namespace {
-std::pair<uint64_t, uint64_t> GetBloomStat(const Options& options, bool sst) {
-  if (sst) {
-    return {options.statistics->getAndResetTickerCount(
-                NON_LAST_LEVEL_SEEK_FILTER_MATCH),
-            options.statistics->getAndResetTickerCount(
-                NON_LAST_LEVEL_SEEK_FILTERED)};
-  } else {
-    auto hit = std::exchange(get_perf_context()->bloom_memtable_hit_count, 0);
-    auto miss = std::exchange(get_perf_context()->bloom_memtable_miss_count, 0);
-    return {hit, miss};
-  }
-}

-std::pair<uint64_t, uint64_t> HitAndMiss(uint64_t hits, uint64_t misses) {
-  return {hits, misses};
-}
-}  // namespace
-
-TEST_F(DBBloomFilterTest, MemtablePrefixBloom) {
+TEST_F(DBBloomFilterTest, MemtablePrefixBloomOutOfDomain) {
+  constexpr size_t kPrefixSize = 8;
+  const std::string kKey = "key";
+  assert(kKey.size() < kPrefixSize);
  Options options = CurrentOptions();
-  options.prefix_extractor.reset(NewFixedPrefixTransform(4));
+  options.prefix_extractor.reset(NewFixedPrefixTransform(kPrefixSize));
  options.memtable_prefix_bloom_size_ratio = 0.25;
  Reopen(options);
-  ASSERT_FALSE(options.prefix_extractor->InDomain("key"));
-  ASSERT_OK(Put("key", "v"));
-  ASSERT_OK(Put("goat1", "g1"));
-  ASSERT_OK(Put("goat2", "g2"));
-
-  // Reset from other tests
-  GetBloomStat(options, false);
-
-  // Out of domain (Get)
-  ASSERT_EQ("v", Get("key"));
-  ASSERT_EQ(HitAndMiss(0, 0), GetBloomStat(options, false));
-
-  // In domain (Get)
-  ASSERT_EQ("g1", Get("goat1"));
-  ASSERT_EQ(HitAndMiss(1, 0), GetBloomStat(options, false));
-  ASSERT_EQ("NOT_FOUND", Get("goat9"));
-  ASSERT_EQ(HitAndMiss(1, 0), GetBloomStat(options, false));
-  ASSERT_EQ("NOT_FOUND", Get("goan1"));
-  ASSERT_EQ(HitAndMiss(0, 1), GetBloomStat(options, false));
-
-  ReadOptions ropts;
-  if (options.prefix_seek_opt_in_only) {
-    ropts.prefix_same_as_start = true;
-  }
-  std::unique_ptr<Iterator> iter(db_->NewIterator(ropts));
-  // Out of domain (scan)
-  iter->Seek("ke");
-  ASSERT_OK(iter->status());
+  ASSERT_OK(Put(kKey, "v"));
+  ASSERT_EQ("v", Get(kKey));
+  std::unique_ptr<Iterator> iter(dbfull()->NewIterator(ReadOptions()));
+  iter->Seek(kKey);
  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("key", iter->key());
-  iter->SeekForPrev("kez");
-  ASSERT_OK(iter->status());
+  ASSERT_EQ(kKey, iter->key());
+  iter->SeekForPrev(kKey);
  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("key", iter->key());
-  ASSERT_EQ(HitAndMiss(0, 0), GetBloomStat(options, false));
-
-  // In domain (scan)
-  iter->Seek("goan");
-  ASSERT_OK(iter->status());
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_EQ(HitAndMiss(0, 1), GetBloomStat(options, false));
-  iter->Seek("goat");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("goat1", iter->key());
-  ASSERT_EQ(HitAndMiss(1, 0), GetBloomStat(options, false));
-
-  // Changing prefix extractor should affect prefix query semantics
-  // and bypass the existing memtable Bloom filter
-  ASSERT_OK(db_->SetOptions({{"prefix_extractor", "fixed:5"}}));
-  iter.reset(db_->NewIterator(ropts));
-  // Now out of domain (scan)
-  iter->Seek("goan");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("goat1", iter->key());
-  ASSERT_EQ(HitAndMiss(0, 0), GetBloomStat(options, false));
-  // In domain (scan)
-  iter->Seek("goat2");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("goat2", iter->key());
-  ASSERT_EQ(HitAndMiss(0, 0), GetBloomStat(options, false));
-  // In domain (scan)
-  if (ropts.prefix_same_as_start) {
-    iter->Seek("goat0");
-    ASSERT_OK(iter->status());
-    ASSERT_FALSE(iter->Valid());
-    ASSERT_EQ(HitAndMiss(0, 0), GetBloomStat(options, false));
-  } else {
-    // NOTE: legacy prefix Seek may return keys outside of prefix
-  }
-
-  // Start a fresh new memtable, using new prefix extractor
-  ASSERT_OK(SingleDelete("key"));
-  ASSERT_OK(SingleDelete("goat1"));
-  ASSERT_OK(SingleDelete("goat2"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Put("key", "_v"));
-  ASSERT_OK(Put("goat1", "_g1"));
-  ASSERT_OK(Put("goat2", "_g2"));
-
-  iter.reset(db_->NewIterator(ropts));
-
-  // Still out of domain (Get)
-  ASSERT_EQ("_v", Get("key"));
-  ASSERT_EQ(HitAndMiss(0, 0), GetBloomStat(options, false));
-
-  // Still in domain (Get)
-  ASSERT_EQ("_g1", Get("goat1"));
-  ASSERT_EQ(HitAndMiss(1, 0), GetBloomStat(options, false));
-  ASSERT_EQ("NOT_FOUND", Get("goat11"));
-  ASSERT_EQ(HitAndMiss(1, 0), GetBloomStat(options, false));
-  ASSERT_EQ("NOT_FOUND", Get("goat9"));
-  ASSERT_EQ(HitAndMiss(0, 1), GetBloomStat(options, false));
-  ASSERT_EQ("NOT_FOUND", Get("goan1"));
-  ASSERT_EQ(HitAndMiss(0, 1), GetBloomStat(options, false));
-
-  // Now out of domain (scan)
-  iter->Seek("goan");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("goat1", iter->key());
-  ASSERT_EQ(HitAndMiss(0, 0), GetBloomStat(options, false));
-  // In domain (scan)
-  iter->Seek("goat2");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("goat2", iter->key());
-  ASSERT_EQ(HitAndMiss(1, 0), GetBloomStat(options, false));
-  // In domain (scan)
-  iter->Seek("goat0");
-  ASSERT_OK(iter->status());
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_EQ(HitAndMiss(0, 1), GetBloomStat(options, false));
+  ASSERT_EQ(kKey, iter->key());
 }

 class DBBloomFilterTestVaryPrefixAndFormatVer
@@ -2696,11 +2507,7 @@ TEST_P(BloomStatsTestWithParam, BloomStatsTestWithIter) {
  ASSERT_OK(Put(key1, value1, WriteOptions()));
  ASSERT_OK(Put(key3, value3, WriteOptions()));

-  ReadOptions ropts;
-  if (options_.prefix_seek_opt_in_only) {
-    ropts.prefix_same_as_start = true;
-  }
-  std::unique_ptr<Iterator> iter(dbfull()->NewIterator(ropts));
+  std::unique_ptr<Iterator> iter(dbfull()->NewIterator(ReadOptions()));

  // check memtable bloom stats
  iter->Seek(key1);
@@ -2719,13 +2526,13 @@ TEST_P(BloomStatsTestWithParam, BloomStatsTestWithIter) {

  iter->Seek(key2);
  ASSERT_OK(iter->status());
-  ASSERT_FALSE(iter->Valid());
+  ASSERT_TRUE(!iter->Valid());
  ASSERT_EQ(1, get_perf_context()->bloom_memtable_miss_count);
  ASSERT_EQ(2, get_perf_context()->bloom_memtable_hit_count);

  ASSERT_OK(Flush());

-  iter.reset(dbfull()->NewIterator(ropts));
+  iter.reset(dbfull()->NewIterator(ReadOptions()));

  // Check SST bloom stats
  iter->Seek(key1);
@@ -2743,7 +2550,7 @@ TEST_P(BloomStatsTestWithParam, BloomStatsTestWithIter) {

  iter->Seek(key2);
  ASSERT_OK(iter->status());
-  ASSERT_FALSE(iter->Valid());
+  ASSERT_TRUE(!iter->Valid());
  ASSERT_EQ(1, get_perf_context()->bloom_sst_miss_count);
  ASSERT_EQ(expected_hits, get_perf_context()->bloom_sst_hit_count);
 }
@@ -2852,14 +2659,9 @@ TEST_F(DBBloomFilterTest, PrefixScan) {
    PrefixScanInit(this);
    count = 0;
    env_->random_read_counter_.Reset();
-    ReadOptions ropts;
-    if (options.prefix_seek_opt_in_only) {
-      ropts.prefix_same_as_start = true;
-    }
-    iter = db_->NewIterator(ropts);
+    iter = db_->NewIterator(ReadOptions());
    for (iter->Seek(prefix); iter->Valid(); iter->Next()) {
      if (!iter->key().starts_with(prefix)) {
-        ASSERT_FALSE(ropts.prefix_same_as_start);
        break;
      }
      count++;
@@ -3595,6 +3397,23 @@ class FixedSuffix4Transform : public SliceTransform {

  bool InDomain(const Slice& src) const override { return src.size() >= 4; }
 };
+
+std::pair<uint64_t, uint64_t> GetBloomStat(const Options& options, bool sst) {
+  if (sst) {
+    return {options.statistics->getAndResetTickerCount(
+                NON_LAST_LEVEL_SEEK_FILTER_MATCH),
+            options.statistics->getAndResetTickerCount(
+                NON_LAST_LEVEL_SEEK_FILTERED)};
+  } else {
+    auto hit = std::exchange(get_perf_context()->bloom_memtable_hit_count, 0);
+    auto miss = std::exchange(get_perf_context()->bloom_memtable_miss_count, 0);
+    return {hit, miss};
+  }
+}
+
+std::pair<uint64_t, uint64_t> HitAndMiss(uint64_t hits, uint64_t misses) {
+  return {hits, misses};
+}
 }  // anonymous namespace

 // This uses a prefix_extractor + comparator combination that violates
@@ -3701,8 +3520,9 @@ TEST_F(DBBloomFilterTest, WeirdPrefixExtractorWithFilter2) {
    if (flushed) {  // TODO: support auto_prefix_mode in memtable?
      read_options.auto_prefix_mode = true;
    } else {
-      // Reset from other tests
-      GetBloomStat(options, flushed);
+      // TODO: why needed?
+      get_perf_context()->bloom_memtable_hit_count = 0;
+      get_perf_context()->bloom_memtable_miss_count = 0;
    }
    EXPECT_EQ(GetBloomStat(options, flushed), HitAndMiss(0, 0));
    {
@@ -3844,8 +3664,9 @@ TEST_F(DBBloomFilterTest, WeirdPrefixExtractorWithFilter3) {
      if (flushed) {  // TODO: support auto_prefix_mode in memtable?
        read_options.auto_prefix_mode = true;
      } else {
-        // Reset from other tests
-        GetBloomStat(options, flushed);
+        // TODO: why needed?
+        get_perf_context()->bloom_memtable_hit_count = 0;
+        get_perf_context()->bloom_memtable_miss_count = 0;
      }
      EXPECT_EQ(GetBloomStat(options, flushed), HitAndMiss(0, 0));
      {
@@ -3913,33 +3734,14 @@ TEST_F(DBBloomFilterTest, WeirdPrefixExtractorWithFilter3) {
  }
 }

-using experimental::KeySegmentsExtractor;
-using experimental::MakeSharedBytewiseMinMaxSQFC;
-using experimental::MakeSharedCappedKeySegmentsExtractor;
-using experimental::MakeSharedReverseBytewiseMinMaxSQFC;
-using experimental::SelectKeySegment;
-using experimental::SstQueryFilterConfigs;
-using experimental::SstQueryFilterConfigsManager;
-using KeyCategorySet = KeySegmentsExtractor::KeyCategorySet;
-
-static std::vector<std::string> RangeQueryKeys(
-    SstQueryFilterConfigsManager::Factory& factory, DB& db, const Slice& lb,
-    const Slice& ub) {
-  ReadOptions ro;
-  ro.iterate_lower_bound = &lb;
-  ro.iterate_upper_bound = &ub;
-  ro.table_filter = factory.GetTableFilterForRangeQuery(lb, ub);
-  auto it = db.NewIterator(ro);
-  std::vector<std::string> ret;
-  for (it->Seek(lb); it->Valid(); it->Next()) {
-    ret.push_back(it->key().ToString());
-  }
-  EXPECT_OK(it->status());
-  delete it;
-  return ret;
-};
-
 TEST_F(DBBloomFilterTest, SstQueryFilter) {
+  using experimental::KeySegmentsExtractor;
+  using experimental::MakeSharedBytewiseMinMaxSQFC;
+  using experimental::SelectKeySegment;
+  using experimental::SstQueryFilterConfigs;
+  using experimental::SstQueryFilterConfigsManager;
+  using KeyCategorySet = KeySegmentsExtractor::KeyCategorySet;
+
  struct MySegmentExtractor : public KeySegmentsExtractor {
    char min_first_char;
    char max_first_char;
@@ -4088,86 +3890,101 @@ TEST_F(DBBloomFilterTest, SstQueryFilter) {
  ASSERT_OK(Flush());

  using Keys = std::vector<std::string>;
-  auto RangeQuery =
+  auto RangeQueryKeys =
      [factory, db = db_](
          std::string lb, std::string ub,
          std::shared_ptr<SstQueryFilterConfigsManager::Factory> alt_factory =
              nullptr) {
-        return RangeQueryKeys(alt_factory ? *alt_factory : *factory, *db, lb,
-                              ub);
+        Slice lb_slice = lb;
+        Slice ub_slice = ub;
+
+        ReadOptions ro;
+        ro.iterate_lower_bound = &lb_slice;
+        ro.iterate_upper_bound = &ub_slice;
+        ro.table_filter = (alt_factory ? alt_factory : factory)
+                              ->GetTableFilterForRangeQuery(lb_slice, ub_slice);
+        auto it = db->NewIterator(ro);
+        Keys ret;
+        for (it->Seek(lb_slice); it->Valid(); it->Next()) {
+          ret.push_back(it->key().ToString());
+        }
+        EXPECT_OK(it->status());
+        delete it;
+        return ret;
      };

  // Control 1: range is not filtered but min/max filter is checked
  // because of common prefix leading up to 2nd segment
  // TODO/future: statistics for when filter is checked vs. not applicable
-  EXPECT_EQ(RangeQuery("abc_150", "abc_249"),
+  EXPECT_EQ(RangeQueryKeys("abc_150", "abc_249"),
            Keys({"abc_156_987", "abc_234", "abc_245_567"}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 2);

  // Test 1: range is filtered to just lowest level, fully containing the
  // segments in that category
-  EXPECT_EQ(RangeQuery("abc_100", "abc_179"),
+  EXPECT_EQ(RangeQueryKeys("abc_100", "abc_179"),
            Keys({"abc_123", "abc_13", "abc_156_987"}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 1);

  // Test 2: range is filtered to just lowest level, partial overlap
-  EXPECT_EQ(RangeQuery("abc_1500_x_y", "abc_16QQ"), Keys({"abc_156_987"}));
+  EXPECT_EQ(RangeQueryKeys("abc_1500_x_y", "abc_16QQ"), Keys({"abc_156_987"}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 1);

  // Test 3: range is filtered to just highest level, fully containing the
  // segments in that category but would be overlapping the range for the other
  // file if the filter included all categories
-  EXPECT_EQ(RangeQuery("abc_200", "abc_300"),
+  EXPECT_EQ(RangeQueryKeys("abc_200", "abc_300"),
            Keys({"abc_234", "abc_245_567", "abc_25"}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 1);

  // Test 4: range is filtered to just highest level, partial overlap (etc.)
-  EXPECT_EQ(RangeQuery("abc_200", "abc_249"), Keys({"abc_234", "abc_245_567"}));
+  EXPECT_EQ(RangeQueryKeys("abc_200", "abc_249"),
+            Keys({"abc_234", "abc_245_567"}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 1);

  // Test 5: range is filtered from both levels, because of category scope
-  EXPECT_EQ(RangeQuery("abc_300", "abc_400"), Keys({}));
+  EXPECT_EQ(RangeQueryKeys("abc_300", "abc_400"), Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 0);

  // Control 2: range is not filtered because association between 1st and
  // 2nd segment is not represented
-  EXPECT_EQ(RangeQuery("abc_170", "abc_190"), Keys({}));
+  EXPECT_EQ(RangeQueryKeys("abc_170", "abc_190"), Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 2);

  // Control 3: range is not filtered because there's no (bloom) filter on
  // 1st segment (like prefix filtering)
-  EXPECT_EQ(RangeQuery("baa_170", "baa_190"), Keys({}));
+  EXPECT_EQ(RangeQueryKeys("baa_170", "baa_190"), Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 2);

  // Control 4: range is not filtered because difference in segments leading
  // up to 2nd segment
-  EXPECT_EQ(RangeQuery("abc_500", "abd_501"), Keys({}));
+  EXPECT_EQ(RangeQueryKeys("abc_500", "abd_501"), Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 2);

  // TODO: exclusive upper bound tests

  // ======= Testing 3rd segment (cross-category filter) =======
  // Control 5: not filtered because of segment range overlap
-  EXPECT_EQ(RangeQuery(" z__700", " z__750"), Keys({}));
+  EXPECT_EQ(RangeQueryKeys(" z__700", " z__750"), Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 2);

  // Test 6: filtered on both levels
-  EXPECT_EQ(RangeQuery(" z__100", " z__300"), Keys({}));
+  EXPECT_EQ(RangeQueryKeys(" z__100", " z__300"), Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 0);

  // Control 6: finding something, with 2nd segment filter helping
-  EXPECT_EQ(RangeQuery("abc_156_9", "abc_156_99"), Keys({"abc_156_987"}));
+  EXPECT_EQ(RangeQueryKeys("abc_156_9", "abc_156_99"), Keys({"abc_156_987"}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 1);

-  EXPECT_EQ(RangeQuery("abc_245_56", "abc_245_57"), Keys({"abc_245_567"}));
+  EXPECT_EQ(RangeQueryKeys("abc_245_56", "abc_245_57"), Keys({"abc_245_567"}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 1);

  // Test 6: filtered on both levels, for different segments
-  EXPECT_EQ(RangeQuery("abc_245_900", "abc_245_999"), Keys({}));
+  EXPECT_EQ(RangeQueryKeys("abc_245_900", "abc_245_999"), Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 0);

  // ======= Testing extractor read portability =======
-  EXPECT_EQ(RangeQuery("abc_300", "abc_400"), Keys({}));
+  EXPECT_EQ(RangeQueryKeys("abc_300", "abc_400"), Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 0);

  // Only modifies how filters are written
@@ -4175,168 +3992,20 @@ TEST_F(DBBloomFilterTest, SstQueryFilter) {
  ASSERT_EQ(factory->GetFilteringVersion(), 0U);
  ASSERT_EQ(factory->GetConfigs().IsEmptyNotFound(), true);

-  EXPECT_EQ(RangeQuery("abc_300", "abc_400"), Keys({}));
+  EXPECT_EQ(RangeQueryKeys("abc_300", "abc_400"), Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 0);

  // Even a different config name with different extractor can read
-  EXPECT_EQ(RangeQuery("abc_300", "abc_400", MakeFactory("bar", 43)), Keys({}));
+  EXPECT_EQ(RangeQueryKeys("abc_300", "abc_400", MakeFactory("bar", 43)),
+            Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 0);

  // Or a "not found" config name
-  EXPECT_EQ(RangeQuery("abc_300", "abc_400", MakeFactory("blah", 43)),
+  EXPECT_EQ(RangeQueryKeys("abc_300", "abc_400", MakeFactory("blah", 43)),
            Keys({}));
  EXPECT_EQ(TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA), 0);
 }

-static std::vector<int> ExtractedSizes(const KeySegmentsExtractor& ex,
-                                       const Slice& k) {
-  KeySegmentsExtractor::Result r;
-  ex.Extract(k, KeySegmentsExtractor::kFullUserKey, &r);
-  std::vector<int> ret;
-  uint32_t last = 0;
-  for (const auto i : r.segment_ends) {
-    ret.push_back(static_cast<int>(i - last));
-    last = i;
-  }
-  return ret;
-}
-
-TEST_F(DBBloomFilterTest, FixedWidthSegments) {
-  // Unit tests for
-  auto extractor_none = MakeSharedCappedKeySegmentsExtractor({});
-  auto extractor0b = MakeSharedCappedKeySegmentsExtractor({0});
-  auto extractor1b = MakeSharedCappedKeySegmentsExtractor({1});
-  auto extractor4b = MakeSharedCappedKeySegmentsExtractor({4});
-  auto extractor4b0b = MakeSharedCappedKeySegmentsExtractor({4, 0});
-  auto extractor4b0b4b = MakeSharedCappedKeySegmentsExtractor({4, 0, 4});
-  auto extractor1b3b0b4b = MakeSharedCappedKeySegmentsExtractor({1, 3, 0, 4});
-
-  ASSERT_EQ(extractor_none->GetId(), "CappedKeySegmentsExtractor");
-  ASSERT_EQ(extractor0b->GetId(), "CappedKeySegmentsExtractor0b");
-  ASSERT_EQ(extractor1b->GetId(), "CappedKeySegmentsExtractor1b");
-  ASSERT_EQ(extractor4b->GetId(), "CappedKeySegmentsExtractor4b");
-  ASSERT_EQ(extractor4b0b->GetId(), "CappedKeySegmentsExtractor4b0b");
-  ASSERT_EQ(extractor4b0b4b->GetId(), "CappedKeySegmentsExtractor4b0b4b");
-  ASSERT_EQ(extractor1b3b0b4b->GetId(), "CappedKeySegmentsExtractor1b3b0b4b");
-
-  using V = std::vector<int>;
-  ASSERT_EQ(V({}), ExtractedSizes(*extractor_none, {}));
-  ASSERT_EQ(V({0}), ExtractedSizes(*extractor0b, {}));
-  ASSERT_EQ(V({0}), ExtractedSizes(*extractor1b, {}));
-  ASSERT_EQ(V({0}), ExtractedSizes(*extractor4b, {}));
-  ASSERT_EQ(V({0, 0}), ExtractedSizes(*extractor4b0b, {}));
-  ASSERT_EQ(V({0, 0, 0}), ExtractedSizes(*extractor4b0b4b, {}));
-  ASSERT_EQ(V({0, 0, 0, 0}), ExtractedSizes(*extractor1b3b0b4b, {}));
-
-  ASSERT_EQ(V({3}), ExtractedSizes(*extractor4b, "bla"));
-  ASSERT_EQ(V({3, 0}), ExtractedSizes(*extractor4b0b, "bla"));
-  ASSERT_EQ(V({1, 2, 0, 0}), ExtractedSizes(*extractor1b3b0b4b, "bla"));
-
-  ASSERT_EQ(V({}), ExtractedSizes(*extractor_none, "blah"));
-  ASSERT_EQ(V({0}), ExtractedSizes(*extractor0b, "blah"));
-  ASSERT_EQ(V({1}), ExtractedSizes(*extractor1b, "blah"));
-  ASSERT_EQ(V({4}), ExtractedSizes(*extractor4b, "blah"));
-  ASSERT_EQ(V({4, 0}), ExtractedSizes(*extractor4b0b, "blah"));
-  ASSERT_EQ(V({4, 0, 0}), ExtractedSizes(*extractor4b0b4b, "blah"));
-  ASSERT_EQ(V({1, 3, 0, 0}), ExtractedSizes(*extractor1b3b0b4b, "blah"));
-
-  ASSERT_EQ(V({4, 0}), ExtractedSizes(*extractor4b0b, "blah1"));
-  ASSERT_EQ(V({4, 0, 1}), ExtractedSizes(*extractor4b0b4b, "blah1"));
-  ASSERT_EQ(V({4, 0, 2}), ExtractedSizes(*extractor4b0b4b, "blah12"));
-  ASSERT_EQ(V({4, 0, 3}), ExtractedSizes(*extractor4b0b4b, "blah123"));
-  ASSERT_EQ(V({1, 3, 0, 3}), ExtractedSizes(*extractor1b3b0b4b, "blah123"));
-
-  ASSERT_EQ(V({4}), ExtractedSizes(*extractor4b, "blah1234"));
-  ASSERT_EQ(V({4, 0}), ExtractedSizes(*extractor4b0b, "blah1234"));
-  ASSERT_EQ(V({4, 0, 4}), ExtractedSizes(*extractor4b0b4b, "blah1234"));
-  ASSERT_EQ(V({1, 3, 0, 4}), ExtractedSizes(*extractor1b3b0b4b, "blah1234"));
-
-  ASSERT_EQ(V({4, 0, 4}), ExtractedSizes(*extractor4b0b4b, "blah12345"));
-  ASSERT_EQ(V({1, 3, 0, 4}), ExtractedSizes(*extractor1b3b0b4b, "blah12345"));
-
-  // Filter config for second and fourth segment
-  auto filter1 =
-      MakeSharedReverseBytewiseMinMaxSQFC(experimental::SelectKeySegment(1));
-  auto filter3 =
-      MakeSharedReverseBytewiseMinMaxSQFC(experimental::SelectKeySegment(3));
-  SstQueryFilterConfigs configs1 = {{filter1, filter3}, extractor1b3b0b4b};
-  SstQueryFilterConfigsManager::Data data = {{42, {{"foo", configs1}}}};
-  std::shared_ptr<SstQueryFilterConfigsManager> configs_manager;
-  ASSERT_OK(SstQueryFilterConfigsManager::MakeShared(data, &configs_manager));
-  std::shared_ptr<SstQueryFilterConfigsManager::Factory> f;
-  ASSERT_OK(configs_manager->MakeSharedFactory("foo", 42, &f));
-
-  ASSERT_EQ(f->GetConfigsName(), "foo");
-  ASSERT_EQ(f->GetConfigs().IsEmptyNotFound(), false);
-
-  Options options = CurrentOptions();
-  options.statistics = CreateDBStatistics();
-  options.table_properties_collector_factories.push_back(f);
-  // Next most common comparator after bytewise
-  options.comparator = ReverseBytewiseComparator();
-
-  DestroyAndReopen(options);
-
-  ASSERT_OK(Put("abcd1234", "val0"));
-  ASSERT_OK(Put("abcd1245", "val1"));
-  ASSERT_OK(Put("abcd99", "val2"));  // short key
-  ASSERT_OK(Put("aqua1200", "val3"));
-  ASSERT_OK(Put("aqua1230", "val4"));
-  ASSERT_OK(Put("zen", "val5"));  // very short key
-  ASSERT_OK(Put("azur1220", "val6"));
-  ASSERT_OK(Put("blah", "val7"));
-  ASSERT_OK(Put("blah2", "val8"));
-
-  ASSERT_OK(Flush());
-
-  using Keys = std::vector<std::string>;
-
-  // Range is not filtered but segment 1 min/max filter is checked
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "aczz0000", "acdc0000"), Keys({}));
-  EXPECT_EQ(1, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-
-  // Found (can't use segment 3 filter)
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "aqzz0000", "aqdc0000"),
-            Keys({"aqua1230", "aqua1200"}));
-  EXPECT_EQ(1, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-
-  // Filtered because of segment 1 min-max not intersecting [aaa, abb]
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "zabb9999", "zaaa0000"), Keys({}));
-  EXPECT_EQ(0, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-
-  // Found
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "aqua1200ZZZ", "aqua1000ZZZ"),
-            Keys({"aqua1200"}));
-  EXPECT_EQ(1, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-
-  // Found despite short key
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "aqua121", "aqua1"), Keys({"aqua1200"}));
-  EXPECT_EQ(1, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-
-  // Filtered because of segment 3 min-max not intersecting [1000, 1100]
-  // Note that the empty string is tracked outside of the min-max range.
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "aqua1100ZZZ", "aqua1000ZZZ"), Keys({}));
-  EXPECT_EQ(0, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-
-  // Also filtered despite short key
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "aqua11", "aqua1"), Keys({}));
-  EXPECT_EQ(0, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-
-  // Found
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "blah21", "blag"),
-            Keys({"blah2", "blah"}));
-  EXPECT_EQ(1, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-
-  // Found
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "blah0", "blag"), Keys({"blah"}));
-  EXPECT_EQ(1, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-
-  // Filtered because of segment 3 min-max not intersecting [0, 1]
-  // Note that the empty string is tracked outside of the min-max range.
-  EXPECT_EQ(RangeQueryKeys(*f, *db_, "blah1", "blah0"), Keys({}));
-  EXPECT_EQ(0, TestGetAndResetTickerCount(options, NON_LAST_LEVEL_SEEK_DATA));
-}
-
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -6146,7 +6146,7 @@ TEST_F(DBCompactionTest, CompactionLimiter) {

  std::vector<std::string> pending_compaction_cfs;
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "EnqueuePendingCompaction::cfd", [&](void* arg) {
+      "SchedulePendingCompaction::cfd", [&](void* arg) {
        const std::string& cf_name =
            static_cast<ColumnFamilyData*>(arg)->GetName();
        pending_compaction_cfs.emplace_back(cf_name);
@@ -9357,13 +9357,12 @@ TEST_F(DBCompactionTest, FIFOChangeTemperature) {
    ASSERT_OK(Flush());

    ASSERT_OK(Put(Key(0), "value1"));
+    env_->MockSleepForSeconds(800);
    ASSERT_OK(Put(Key(2), "value2"));
    ASSERT_OK(Flush());

-    // First two L0 files both become eligible for temperature change compaction
-    // They should be compacted one-by-one.
    ASSERT_OK(Put(Key(0), "value1"));
-    env_->MockSleepForSeconds(1200);
+    env_->MockSleepForSeconds(800);
    ASSERT_OK(Put(Key(2), "value2"));
    ASSERT_OK(Flush());
    ASSERT_OK(dbfull()->TEST_WaitForCompact());
@@ -10623,97 +10622,6 @@ TEST_F(DBCompactionTest, ReleaseCompactionDuringManifestWrite) {
  SyncPoint::GetInstance()->ClearAllCallBacks();
 }

-TEST_F(DBCompactionTest, RecordNewestKeyTimeForTtlCompaction) {
-  Options options;
-  SetTimeElapseOnlySleepOnReopen(&options);
-  options.env = CurrentOptions().env;
-  options.compaction_style = kCompactionStyleFIFO;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-  options.write_buffer_size = 10 << 10;  // 10KB
-  options.arena_block_size = 4096;
-  options.compression = kNoCompression;
-  options.create_if_missing = true;
-  options.compaction_options_fifo.allow_compaction = false;
-  options.num_levels = 1;
-  env_->SetMockSleep();
-  options.env = env_;
-  options.ttl = 1 * 60 * 60;  // 1 hour
-  ASSERT_OK(TryReopen(options));
-
-  // Generate and flush 4 files, each about 10KB
-  // Compaction is manually disabled at this point so we can check
-  // each file's newest_key_time
-  Random rnd(301);
-  for (int i = 0; i < 4; i++) {
-    for (int j = 0; j < 10; j++) {
-      ASSERT_OK(Put(std::to_string(i * 20 + j), rnd.RandomString(980)));
-    }
-    ASSERT_OK(Flush());
-    env_->MockSleepForSeconds(5);
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ(NumTableFilesAtLevel(0), 4);
-
-  // Check that we are populating newest_key_time on flush
-  std::vector<FileMetaData*> file_metadatas = GetLevelFileMetadatas(0);
-  ASSERT_EQ(file_metadatas.size(), 4);
-  uint64_t first_newest_key_time =
-      file_metadatas[0]->fd.table_reader->GetTableProperties()->newest_key_time;
-  ASSERT_NE(first_newest_key_time, kUnknownNewestKeyTime);
-  // Check that the newest_key_times are in expected ordering
-  uint64_t prev_newest_key_time = first_newest_key_time;
-  for (size_t idx = 1; idx < file_metadatas.size(); idx++) {
-    uint64_t newest_key_time = file_metadatas[idx]
-                                   ->fd.table_reader->GetTableProperties()
-                                   ->newest_key_time;
-
-    ASSERT_LT(newest_key_time, prev_newest_key_time);
-    prev_newest_key_time = newest_key_time;
-    ASSERT_EQ(newest_key_time, file_metadatas[idx]
-                                   ->fd.table_reader->GetTableProperties()
-                                   ->creation_time);
-  }
-  // The delta between the first and last newest_key_times is 15s
-  uint64_t last_newest_key_time = prev_newest_key_time;
-  ASSERT_EQ(15, first_newest_key_time - last_newest_key_time);
-
-  // After compaction, the newest_key_time of the output file should be the max
-  // of the input files
-  options.compaction_options_fifo.allow_compaction = true;
-  ASSERT_OK(TryReopen(options));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
-  file_metadatas = GetLevelFileMetadatas(0);
-  ASSERT_EQ(file_metadatas.size(), 1);
-  ASSERT_EQ(
-      file_metadatas[0]->fd.table_reader->GetTableProperties()->newest_key_time,
-      first_newest_key_time);
-  // Contrast newest_key_time with creation_time, which records the oldest
-  // ancestor time (15s older than newest_key_time)
-  ASSERT_EQ(
-      file_metadatas[0]->fd.table_reader->GetTableProperties()->creation_time,
-      last_newest_key_time);
-  ASSERT_EQ(file_metadatas[0]->oldest_ancester_time, last_newest_key_time);
-
-  // Make sure TTL of 5s causes compaction
-  env_->MockSleepForSeconds(6);
-
-  // The oldest input file is older than 15s
-  // However the newest of the compaction input files is younger than 15s, so
-  // we don't compact
-  ASSERT_OK(dbfull()->SetOptions({{"ttl", "15"}}));
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 15);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
-
-  // Now even the youngest input file is too old
-  ASSERT_OK(dbfull()->SetOptions({{"ttl", "5"}}));
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 5);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
-}
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -473,7 +473,7 @@ Status DBImpl::ResumeImpl(DBRecoverContext context) {

  if (s.ok()) {
    for (auto cfd : *versions_->GetColumnFamilySet()) {
-      EnqueuePendingCompaction(cfd);
+      SchedulePendingCompaction(cfd);
    }
    MaybeScheduleFlushOrCompaction();
  }
@@ -530,11 +530,6 @@ Status DBImpl::MaybeReleaseTimestampedSnapshotsAndCheck() {
  return Status::OK();
 }

-void DBImpl::UntrackDataFiles() {
-  TrackOrUntrackFiles(/*existing_data_files=*/{},
-                      /*track=*/false);
-}
-
 Status DBImpl::CloseHelper() {
  // Guarantee that there is no background error recovery in progress before
  // continuing with the shutdown
@@ -678,13 +673,6 @@ Status DBImpl::CloseHelper() {
    delete txn_entry.second;
  }

-  // Return an unowned SstFileManager to a consistent state
-  if (immutable_db_options_.sst_file_manager && !own_sfm_) {
-    mutex_.Unlock();
-    UntrackDataFiles();
-    mutex_.Lock();
-  }
-
  // versions need to be destroyed before table_cache since it can hold
  // references to table_cache.
  {
@@ -847,22 +835,20 @@ Status DBImpl::RegisterRecordSeqnoTimeWorker(const ReadOptions& read_options,

  uint64_t min_preserve_seconds = std::numeric_limits<uint64_t>::max();
  uint64_t max_preserve_seconds = std::numeric_limits<uint64_t>::min();
-  std::vector<SuperVersionContext> sv_contexts;
+  bool mapping_was_empty = false;
  {
    InstrumentedMutexLock l(&mutex_);

    for (auto cfd : *versions_->GetColumnFamilySet()) {
-      auto& mopts = *cfd->GetLatestMutableCFOptions();
      // preserve time is the max of 2 options.
      uint64_t preserve_seconds =
-          std::max(mopts.preserve_internal_time_seconds,
-                   mopts.preclude_last_level_data_seconds);
+          std::max(cfd->ioptions()->preserve_internal_time_seconds,
+                   cfd->ioptions()->preclude_last_level_data_seconds);
      if (!cfd->IsDropped() && preserve_seconds > 0) {
        min_preserve_seconds = std::min(preserve_seconds, min_preserve_seconds);
        max_preserve_seconds = std::max(preserve_seconds, max_preserve_seconds);
      }
    }
-    size_t old_mapping_size = seqno_to_time_mapping_.Size();
    if (min_preserve_seconds == std::numeric_limits<uint64_t>::max()) {
      // Don't track
      seqno_to_time_mapping_.SetCapacity(0);
@@ -874,17 +860,9 @@ Status DBImpl::RegisterRecordSeqnoTimeWorker(const ReadOptions& read_options,
      seqno_to_time_mapping_.SetCapacity(cap);
      seqno_to_time_mapping_.SetMaxTimeSpan(max_preserve_seconds);
    }
-    if (old_mapping_size != seqno_to_time_mapping_.Size()) {
-      InstallSeqnoToTimeMappingInSV(&sv_contexts);
-    }
+    mapping_was_empty = seqno_to_time_mapping_.Empty();
  }

-  // clean up outside db mutex
-  for (SuperVersionContext& sv_context : sv_contexts) {
-    sv_context.Clean();
-  }
-  sv_contexts.clear();
-
  uint64_t seqno_time_cadence = 0;
  if (min_preserve_seconds != std::numeric_limits<uint64_t>::max()) {
    // round up to 1 when the time_duration is smaller than
@@ -924,6 +902,8 @@ Status DBImpl::RegisterRecordSeqnoTimeWorker(const ReadOptions& read_options,
    assert(!is_new_db || last_seqno_zero);
    if (is_new_db && last_seqno_zero) {
      // Pre-allocate seqnos and pre-populate historical mapping
+      assert(mapping_was_empty);
+
      // We can simply modify these, before writes are allowed
      constexpr uint64_t kMax = kMaxSeqnoTimePairsPerSST;
      versions_->SetLastAllocatedSequence(kMax);
@@ -948,10 +928,9 @@ Status DBImpl::RegisterRecordSeqnoTimeWorker(const ReadOptions& read_options,

      // Pre-populate mappings for reserved sequence numbers.
      RecordSeqnoToTimeMapping(max_preserve_seconds);
-    } else {
+    } else if (mapping_was_empty) {
      if (!last_seqno_zero) {
-        // Ensure at least one mapping (or log a warning), and
-        // an updated entry whenever relevant SetOptions is called
+        // Ensure at least one mapping (or log a warning)
        RecordSeqnoToTimeMapping(/*populate_historical_seconds=*/0);
      } else {
        // FIXME (see limitation described above)
@@ -1166,13 +1145,6 @@ void DBImpl::DumpStats() {
        continue;
      }

-      auto* table_factory =
-          cfd->GetCurrentMutableCFOptions()->table_factory.get();
-      assert(table_factory != nullptr);
-      // FIXME: need to a shared_ptr if/when block_cache is going to be mutable
-      Cache* cache =
-          table_factory->GetOptions<Cache>(TableFactory::kBlockCacheOpts());
-
      // Release DB mutex for gathering cache entry stats. Pass over all
      // column families for this first so that other stats are dumped
      // near-atomically.
@@ -1181,6 +1153,10 @@ void DBImpl::DumpStats() {

      // Probe block cache for problems (if not already via another CF)
      if (immutable_db_options_.info_log) {
+        auto* table_factory = cfd->ioptions()->table_factory.get();
+        assert(table_factory != nullptr);
+        Cache* cache =
+            table_factory->GetOptions<Cache>(TableFactory::kBlockCacheOpts());
        if (cache && probed_caches.insert(cache).second) {
          cache->ReportProblems(immutable_db_options_.info_log);
        }
@@ -1312,12 +1288,6 @@ Status DBImpl::SetOptions(
  }
  sv_context.Clean();

-  if (s.ok() && (options_map.count("preserve_internal_time_seconds") > 0 ||
-                 options_map.count("preclude_last_level_data_seconds") > 0)) {
-    s = RegisterRecordSeqnoTimeWorker(read_options, write_options,
-                                      false /* is_new_db*/);
-  }
-
  ROCKS_LOG_INFO(
      immutable_db_options_.info_log,
      "SetOptions() on column family [%s], inputs:", cfd->GetName().c_str());
@@ -1475,6 +1445,8 @@ Status DBImpl::SetDBOptions(
      // TODO(xiez): clarify why apply optimize for read to write options
      file_options_for_compaction_ = fs_->OptimizeForCompactionTableRead(
          file_options_for_compaction_, immutable_db_options_);
+      file_options_for_compaction_.compaction_readahead_size =
+          mutable_db_options_.compaction_readahead_size;
      if (wal_other_option_changed || wal_size_option_changed) {
        WriteThread::Writer w;
        write_thread_.EnterUnbatched(&w, &mutex_);
@@ -1558,7 +1530,7 @@ Status DBImpl::FlushWAL(const WriteOptions& write_options, bool sync) {
                      io_s.ToString().c_str());
      // In case there is a fs error we should set it globally to prevent the
      // future writes
-      WALIOStatusCheck(io_s);
+      IOStatusCheck(io_s);
      // whether sync or not, we should abort the rest of function upon error
      return static_cast<Status>(io_s);
    }
@@ -1715,7 +1687,7 @@ IOStatus DBImpl::SyncWalImpl(bool include_current_wal,
                    io_s.ToString().c_str());
    // In case there is a fs error we should set it globally to prevent the
    // future writes
-    WALIOStatusCheck(io_s);
+    IOStatusCheck(io_s);
  }
  if (io_s.ok() && need_wal_dir_sync) {
    io_s = directories_.GetWalDir()->FsyncWithDirOptions(
@@ -2086,20 +2058,15 @@ InternalIterator* DBImpl::NewInternalIterator(
    bool allow_unprepared_value, ArenaWrappedDBIter* db_iter) {
  InternalIterator* internal_iter;
  assert(arena != nullptr);
-  auto prefix_extractor =
-      super_version->mutable_cf_options.prefix_extractor.get();
  // Need to create internal iterator from the arena.
  MergeIteratorBuilder merge_iter_builder(
      &cfd->internal_comparator(), arena,
-      // FIXME? It's not clear what interpretation of prefix seek is needed
-      // here, and no unit test cares about the value provided here.
-      !read_options.total_order_seek && prefix_extractor != nullptr,
+      !read_options.total_order_seek &&
+          super_version->mutable_cf_options.prefix_extractor != nullptr,
      read_options.iterate_upper_bound);
  // Collect iterator for mutable memtable
  auto mem_iter = super_version->mem->NewIterator(
-      read_options, super_version->GetSeqnoToTimeMapping(), arena,
-      super_version->mutable_cf_options.prefix_extractor.get(),
-      /*for_flush=*/false);
+      read_options, super_version->GetSeqnoToTimeMapping(), arena);
  Status s;
  if (!read_options.ignore_range_deletions) {
    std::unique_ptr<TruncatedRangeDelIterator> mem_tombstone_iter;
@@ -2123,7 +2090,6 @@ InternalIterator* DBImpl::NewInternalIterator(
  if (s.ok()) {
    super_version->imm->AddIterators(
        read_options, super_version->GetSeqnoToTimeMapping(),
-        super_version->mutable_cf_options.prefix_extractor.get(),
        &merge_iter_builder, !read_options.ignore_range_deletions);
  }
  TEST_SYNC_POINT_CALLBACK("DBImpl::NewInternalIterator:StatusCallback", &s);
@@ -3248,13 +3214,8 @@ Status DBImpl::MultiGetImpl(
      s = Status::Aborted();
      break;
    }
-
    // This could be a long-running operation
-    bool aborted = ROCKSDB_THREAD_YIELD_CHECK_ABORT();
-    if (aborted) {
-      s = Status::Aborted("Query abort.");
-      break;
-    }
+    ROCKSDB_THREAD_YIELD_HOOK();
  }

  // Post processing (decrement reference counts and record statistics)
@@ -3499,8 +3460,6 @@ void DBImpl::MultiGetEntityWithCallback(
 Status DBImpl::WrapUpCreateColumnFamilies(
    const ReadOptions& read_options, const WriteOptions& write_options,
    const std::vector<const ColumnFamilyOptions*>& cf_options) {
-  options_mutex_.AssertHeld();
-
  // NOTE: this function is skipped for create_missing_column_families and
  // DB::Open, so new functionality here might need to go into Open also.
  bool register_worker = false;
@@ -3723,8 +3682,6 @@ Status DBImpl::DropColumnFamilies(
 }

 Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
-  options_mutex_.AssertHeld();
-
  // TODO: plumb Env::IOActivity, Env::IOPriority
  const ReadOptions read_options;
  const WriteOptions write_options;
@@ -3742,9 +3699,6 @@ Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
  edit.SetColumnFamily(cfd->GetID());

  Status s;
-  // Save re-aquiring lock for RegisterRecordSeqnoTimeWorker when not
-  // applicable
-  bool used_preserve_preclude = false;
  {
    InstrumentedMutexLock l(&mutex_);
    if (cfd->IsDropped()) {
@@ -3760,11 +3714,9 @@ Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
      write_thread_.ExitUnbatched(&w);
    }
    if (s.ok()) {
-      auto& moptions = *cfd->GetLatestMutableCFOptions();
-      max_total_in_memory_state_ -=
-          moptions.write_buffer_size * moptions.max_write_buffer_number;
-      used_preserve_preclude = moptions.preserve_internal_time_seconds > 0 ||
-                               moptions.preclude_last_level_data_seconds > 0;
+      auto* mutable_cf_options = cfd->GetLatestMutableCFOptions();
+      max_total_in_memory_state_ -= mutable_cf_options->write_buffer_size *
+                                    mutable_cf_options->max_write_buffer_number;
    }

    if (!cf_support_snapshot) {
@@ -3782,7 +3734,8 @@ Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
    bg_cv_.SignalAll();
  }

-  if (used_preserve_preclude) {
+  if (cfd->ioptions()->preserve_internal_time_seconds > 0 ||
+      cfd->ioptions()->preclude_last_level_data_seconds > 0) {
    s = RegisterRecordSeqnoTimeWorker(read_options, write_options,
                                      /* is_new_db */ false);
  }
@@ -3808,6 +3761,7 @@ bool DBImpl::KeyMayExist(const ReadOptions& read_options,
                         ColumnFamilyHandle* column_family, const Slice& key,
                         std::string* value, std::string* timestamp,
                         bool* value_found) {
+  assert(value != nullptr);
  assert(read_options.io_activity == Env::IOActivity::kUnknown);

  if (value_found != nullptr) {
@@ -3824,9 +3778,7 @@ bool DBImpl::KeyMayExist(const ReadOptions& read_options,
  get_impl_options.value_found = value_found;
  get_impl_options.timestamp = timestamp;
  auto s = GetImpl(roptions, key, get_impl_options);
-  if (value_found && *value_found && value) {
-    value->assign(pinnable_val.data(), pinnable_val.size());
-  }
+  value->assign(pinnable_val.data(), pinnable_val.size());

  // If block_cache is enabled and the index block of the table didn't
  // not present in block_cache, the return value will be Status::Incomplete.
@@ -3885,9 +3837,6 @@ Iterator* DBImpl::NewIterator(const ReadOptions& _read_options,
    }
  }
  if (read_options.tailing) {
-    read_options.total_order_seek |=
-        immutable_db_options_.prefix_seek_opt_in_only;
-
    auto iter = new ForwardIterator(this, read_options, cfd, sv,
                                    /* allow_unprepared_value */ true);
    result = NewDBIterator(
@@ -4021,25 +3970,14 @@ std::unique_ptr<IterType> DBImpl::NewMultiCfIterator(
          "Different comparators are being used across CFs"));
    }
  }
-
  std::vector<Iterator*> child_iterators;
  Status s = NewIterators(_read_options, column_families, &child_iterators);
  if (!s.ok()) {
    return error_iterator_func(s);
  }
-
-  assert(column_families.size() == child_iterators.size());
-
-  std::vector<std::pair<ColumnFamilyHandle*, std::unique_ptr<Iterator>>>
-      cfh_iter_pairs;
-  cfh_iter_pairs.reserve(column_families.size());
-  for (size_t i = 0; i < column_families.size(); ++i) {
-    cfh_iter_pairs.emplace_back(column_families[i], child_iterators[i]);
-  }
-
-  return std::make_unique<ImplType>(_read_options,
-                                    column_families[0]->GetComparator(),
-                                    std::move(cfh_iter_pairs));
+  return std::make_unique<ImplType>(column_families[0]->GetComparator(),
+                                    column_families,
+                                    std::move(child_iterators));
 }

 Status DBImpl::NewIterators(
@@ -4100,9 +4038,6 @@ Status DBImpl::NewIterators(

  assert(cf_sv_pairs.size() == column_families.size());
  if (read_options.tailing) {
-    read_options.total_order_seek |=
-        immutable_db_options_.prefix_seek_opt_in_only;
-
    for (const auto& cf_sv_pair : cf_sv_pairs) {
      auto iter = new ForwardIterator(this, read_options, cf_sv_pair.cfd,
                                      cf_sv_pair.super_version,
@@ -4343,8 +4278,8 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
    }
    // Avoid to go through every column family by checking a global threshold
    // first.
-    CfdList cf_scheduled;
    if (oldest_snapshot > bottommost_files_mark_threshold_) {
+      CfdList cf_scheduled;
      for (auto* cfd : *versions_->GetColumnFamilySet()) {
        if (!cfd->ioptions()->allow_ingest_behind) {
          cfd->current()->storage_info()->UpdateOldestSnapshot(
@@ -4353,7 +4288,7 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
                   ->storage_info()
                   ->BottommostFilesMarkedForCompaction()
                   .empty()) {
-            EnqueuePendingCompaction(cfd);
+            SchedulePendingCompaction(cfd);
            MaybeScheduleFlushOrCompaction();
            cf_scheduled.push_back(cfd);
          }
@@ -4376,24 +4311,6 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
      }
      bottommost_files_mark_threshold_ = new_bottommost_files_mark_threshold;
    }
-
-    // Avoid to go through every column family by checking a global threshold
-    // first.
-    if (oldest_snapshot >= standalone_range_deletion_files_mark_threshold_) {
-      for (auto* cfd : *versions_->GetColumnFamilySet()) {
-        if (cfd->IsDropped() || CfdListContains(cf_scheduled, cfd)) {
-          continue;
-        }
-        if (oldest_snapshot >=
-            cfd->current()
-                ->storage_info()
-                ->standalone_range_tombstone_files_mark_threshold()) {
-          EnqueuePendingCompaction(cfd);
-          MaybeScheduleFlushOrCompaction();
-          cf_scheduled.push_back(cfd);
-        }
-      }
-    }
  }
  delete casted_s;
 }
@@ -4769,9 +4686,9 @@ void DBImpl::GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
  // Convert user_key into a corresponding internal key.
  InternalKey k1(start.value(), kMaxSequenceNumber, kValueTypeForSeek);
  InternalKey k2(limit.value(), kMaxSequenceNumber, kValueTypeForSeek);
-  ReadOnlyMemTable::MemTableStats memStats =
+  MemTable::MemTableStats memStats =
      sv->mem->ApproximateStats(k1.Encode(), k2.Encode());
-  ReadOnlyMemTable::MemTableStats immStats =
+  MemTable::MemTableStats immStats =
      sv->imm->ApproximateStats(k1.Encode(), k2.Encode());
  *count = memStats.count + immStats.count;
  *size = memStats.size + immStats.size;
@@ -4845,24 +4762,6 @@ void DBImpl::ReleaseFileNumberFromPendingOutputs(
  }
 }

-std::list<uint64_t>::iterator DBImpl::CaptureOptionsFileNumber() {
-  // We need to remember the iterator of our insert, because after the
-  // compaction is done, we need to remove that element from
-  // min_options_file_numbers_.
-  min_options_file_numbers_.push_back(versions_->options_file_number());
-  auto min_options_file_numbers_inserted_elem = min_options_file_numbers_.end();
-  --min_options_file_numbers_inserted_elem;
-  return min_options_file_numbers_inserted_elem;
-}
-
-void DBImpl::ReleaseOptionsFileNumber(
-    std::unique_ptr<std::list<uint64_t>::iterator>& v) {
-  if (v.get() != nullptr) {
-    min_options_file_numbers_.erase(*v.get());
-    v.reset();
-  }
-}
-
 Status DBImpl::GetUpdatesSince(
    SequenceNumber seq, std::unique_ptr<TransactionLogIterator>* iter,
    const TransactionLogIterator::ReadOptions& read_options) {
@@ -5226,12 +5125,11 @@ Status DBImpl::GetDbIdentity(std::string& identity) const {
  return Status::OK();
 }

-Status DBImpl::GetDbIdentityFromIdentityFile(const IOOptions& opts,
-                                             std::string* identity) const {
+Status DBImpl::GetDbIdentityFromIdentityFile(std::string* identity) const {
  std::string idfilename = IdentityFileName(dbname_);
  const FileOptions soptions;

-  Status s = ReadFileToString(fs_.get(), idfilename, opts, identity);
+  Status s = ReadFileToString(fs_.get(), idfilename, identity);
  if (!s.ok()) {
    return s;
  }
@@ -5542,8 +5440,7 @@ Status DBImpl::WriteOptionsFile(const WriteOptions& write_options,
                                   file_name, fs_.get());

  if (s.ok()) {
-    s = RenameTempFileToOptionsFile(file_name,
-                                    db_options.compaction_service != nullptr);
+    s = RenameTempFileToOptionsFile(file_name);
  }

  if (!s.ok() && GetEnv()->FileExists(file_name).ok()) {
@@ -5620,8 +5517,7 @@ Status DBImpl::DeleteObsoleteOptionsFiles() {
  return Status::OK();
 }

-Status DBImpl::RenameTempFileToOptionsFile(const std::string& file_name,
-                                           bool is_remote_compaction_enabled) {
+Status DBImpl::RenameTempFileToOptionsFile(const std::string& file_name) {
  Status s;

  uint64_t options_file_number = versions_->NewFileNumber();
@@ -5665,7 +5561,7 @@ Status DBImpl::RenameTempFileToOptionsFile(const std::string& file_name,
      my_disable_delete_obsolete_files = disable_delete_obsolete_files_;
    }

-    if (!my_disable_delete_obsolete_files && !is_remote_compaction_enabled) {
+    if (!my_disable_delete_obsolete_files) {
      // TODO: Should we check for errors here?
      DeleteObsoleteOptionsFiles().PermitUncheckedError();
    }
@@ -5898,6 +5794,7 @@ Status DBImpl::IngestExternalFile(
 Status DBImpl::IngestExternalFiles(
    const std::vector<IngestExternalFileArg>& args) {
  // TODO: plumb Env::IOActivity, Env::IOPriority
+  const ReadOptions read_options;
  const WriteOptions write_options;

  if (args.empty()) {
@@ -5919,14 +5816,10 @@ Status DBImpl::IngestExternalFiles(
  const size_t num_cfs = args.size();
  for (size_t i = 0; i != num_cfs; ++i) {
    if (args[i].external_files.empty()) {
-      std::string err_msg =
-          "external_files[" + std::to_string(i) + "] is empty";
+      char err_msg[128] = {0};
+      snprintf(err_msg, 128, "external_files[%zu] is empty", i);
      return Status::InvalidArgument(err_msg);
    }
-    if (i && args[i].options.fill_cache != args[i - 1].options.fill_cache) {
-      return Status::InvalidArgument(
-          "fill_cache should be the same across ingestion options.");
-    }
  }
  for (const auto& arg : args) {
    const IngestExternalFileOptions& ingest_opts = arg.options;
@@ -5949,10 +5842,11 @@ Status DBImpl::IngestExternalFiles(
            "write_global_seqno is deprecated and does not work with "
            "allow_db_generated_files.");
      }
-    }
-    if (ingest_opts.move_files && ingest_opts.link_files) {
-      return Status::InvalidArgument(
-          "`move_files` and `link_files` can not both be true.");
+      if (ingest_opts.move_files) {
+        return Status::NotSupported(
+            "Options move_files and allow_db_generated_files are not "
+            "compatible.");
+      }
    }
  }

@@ -5986,9 +5880,9 @@ Status DBImpl::IngestExternalFiles(
  uint64_t start_file_number = next_file_number;
  for (size_t i = 1; i != num_cfs; ++i) {
    start_file_number += args[i - 1].external_files.size();
-    SuperVersion* super_version =
-        ingestion_jobs[i].GetColumnFamilyData()->GetReferencedSuperVersion(
-            this);
+    auto* cfd =
+        static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
+    SuperVersion* super_version = cfd->GetReferencedSuperVersion(this);
    Status es = ingestion_jobs[i].Prepare(
        args[i].external_files, args[i].files_checksums,
        args[i].files_checksum_func_names, args[i].file_temperature,
@@ -6002,9 +5896,9 @@ Status DBImpl::IngestExternalFiles(
  TEST_SYNC_POINT("DBImpl::IngestExternalFiles:BeforeLastJobPrepare:0");
  TEST_SYNC_POINT("DBImpl::IngestExternalFiles:BeforeLastJobPrepare:1");
  {
-    SuperVersion* super_version =
-        ingestion_jobs[0].GetColumnFamilyData()->GetReferencedSuperVersion(
-            this);
+    auto* cfd =
+        static_cast<ColumnFamilyHandleImpl*>(args[0].column_family)->cfd();
+    SuperVersion* super_version = cfd->GetReferencedSuperVersion(this);
    Status es = ingestion_jobs[0].Prepare(
        args[0].external_files, args[0].files_checksums,
        args[0].files_checksum_func_names, args[0].file_temperature,
@@ -6055,7 +5949,8 @@ Status DBImpl::IngestExternalFiles(
    bool at_least_one_cf_need_flush = false;
    std::vector<bool> need_flush(num_cfs, false);
    for (size_t i = 0; i != num_cfs; ++i) {
-      auto* cfd = ingestion_jobs[i].GetColumnFamilyData();
+      auto* cfd =
+          static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
      if (cfd->IsDropped()) {
        // TODO (yanqin) investigate whether we should abort ingestion or
        // proceed with other non-dropped column families.
@@ -6087,10 +5982,12 @@ Status DBImpl::IngestExternalFiles(
        for (size_t i = 0; i != num_cfs; ++i) {
          if (need_flush[i]) {
            mutex_.Unlock();
-            status =
-                FlushMemTable(ingestion_jobs[i].GetColumnFamilyData(),
-                              flush_opts, FlushReason::kExternalFileIngestion,
-                              true /* entered_write_thread */);
+            auto* cfd =
+                static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)
+                    ->cfd();
+            status = FlushMemTable(cfd, flush_opts,
+                                   FlushReason::kExternalFileIngestion,
+                                   true /* entered_write_thread */);
            mutex_.Lock();
            if (!status.ok()) {
              break;
@@ -6098,13 +5995,6 @@ Status DBImpl::IngestExternalFiles(
          }
        }
      }
-      if (status.ok()) {
-        for (size_t i = 0; i != num_cfs; ++i) {
-          if (immutable_db_options_.atomic_flush || need_flush[i]) {
-            ingestion_jobs[i].SetFlushedBeforeRun();
-          }
-        }
-      }
    }
    // Run ingestion jobs.
    if (status.ok()) {
@@ -6118,15 +6008,16 @@ Status DBImpl::IngestExternalFiles(
      }
    }
    if (status.ok()) {
-      ReadOptions read_options;
-      read_options.fill_cache = args[0].options.fill_cache;
      autovector<ColumnFamilyData*> cfds_to_commit;
      autovector<const MutableCFOptions*> mutable_cf_options_list;
      autovector<autovector<VersionEdit*>> edit_lists;
      uint32_t num_entries = 0;
      for (size_t i = 0; i != num_cfs; ++i) {
-        auto* cfd = ingestion_jobs[i].GetColumnFamilyData();
-        assert(!cfd->IsDropped());
+        auto* cfd =
+            static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
+        if (cfd->IsDropped()) {
+          continue;
+        }
        cfds_to_commit.push_back(cfd);
        mutable_cf_options_list.push_back(cfd->GetLatestMutableCFOptions());
        autovector<VersionEdit*> edit_list;
@@ -6176,16 +6067,20 @@ Status DBImpl::IngestExternalFiles(

    if (status.ok()) {
      for (size_t i = 0; i != num_cfs; ++i) {
-        auto* cfd = ingestion_jobs[i].GetColumnFamilyData();
-        assert(!cfd->IsDropped());
-        InstallSuperVersionAndScheduleWork(cfd, &sv_ctxs[i],
-                                           *cfd->GetLatestMutableCFOptions());
+        auto* cfd =
+            static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
+        if (!cfd->IsDropped()) {
+          InstallSuperVersionAndScheduleWork(cfd, &sv_ctxs[i],
+                                             *cfd->GetLatestMutableCFOptions());
 #ifndef NDEBUG
-        if (0 == i && num_cfs > 1) {
-          TEST_SYNC_POINT("DBImpl::IngestExternalFiles:InstallSVForFirstCF:0");
-          TEST_SYNC_POINT("DBImpl::IngestExternalFiles:InstallSVForFirstCF:1");
-        }
+          if (0 == i && num_cfs > 1) {
+            TEST_SYNC_POINT(
+                "DBImpl::IngestExternalFiles:InstallSVForFirstCF:0");
+            TEST_SYNC_POINT(
+                "DBImpl::IngestExternalFiles:InstallSVForFirstCF:1");
+          }
 #endif  // !NDEBUG
+        }
      }
    } else if (versions_->io_status().IsIOError()) {
      // Error while writing to MANIFEST.
@@ -6227,7 +6122,8 @@ Status DBImpl::IngestExternalFiles(
  }
  if (status.ok()) {
    for (size_t i = 0; i != num_cfs; ++i) {
-      auto* cfd = ingestion_jobs[i].GetColumnFamilyData();
+      auto* cfd =
+          static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
      if (!cfd->IsDropped()) {
        NotifyOnExternalFileIngested(cfd, ingestion_jobs[i]);
      }
@@ -6858,62 +6754,6 @@ void DBImpl::RecordSeqnoToTimeMapping(uint64_t populate_historical_seconds) {
  }
 }

-void DBImpl::TrackOrUntrackFiles(
-    const std::vector<std::string>& existing_data_files, bool track) {
-  auto sfm = static_cast_with_check<SstFileManagerImpl>(
-      immutable_db_options_.sst_file_manager.get());
-  assert(sfm);
-  std::vector<ColumnFamilyMetaData> metadata;
-  GetAllColumnFamilyMetaData(&metadata);
-  auto action = [&](const std::string& file_path,
-                    std::optional<uint64_t> size) {
-    if (track) {
-      if (size) {
-        sfm->OnAddFile(file_path, *size).PermitUncheckedError();
-      } else {
-        sfm->OnAddFile(file_path).PermitUncheckedError();
-      }
-    } else {
-      sfm->OnUntrackFile(file_path).PermitUncheckedError();
-    }
-  };
-
-  std::unordered_set<std::string> referenced_files;
-  for (const auto& md : metadata) {
-    for (const auto& lmd : md.levels) {
-      for (const auto& fmd : lmd.files) {
-        // We're assuming that each sst file name exists in at most one of
-        // the paths.
-        std::string file_path =
-            fmd.directory + kFilePathSeparator + fmd.relative_filename;
-        action(file_path, fmd.size);
-        referenced_files.insert(file_path);
-      }
-    }
-    for (const auto& bmd : md.blob_files) {
-      std::string name = bmd.blob_file_name;
-      // The BlobMetaData.blob_file_name may start with "/".
-      if (!name.empty() && name[0] == kFilePathSeparator) {
-        name = name.substr(1);
-      }
-      // We're assuming that each blob file name exists in at most one of
-      // the paths.
-      std::string file_path = bmd.blob_file_path + kFilePathSeparator + name;
-      action(file_path, bmd.blob_file_size);
-      referenced_files.insert(file_path);
-    }
-  }
-
-  for (const auto& file_path : existing_data_files) {
-    if (referenced_files.find(file_path) != referenced_files.end()) {
-      continue;
-    }
-    // There shouldn't be any duplicated files. In case there is, SstFileManager
-    // will take care of deduping it.
-    action(file_path, /*size=*/std::nullopt);
-  }
-}
-
 void DBImpl::InstallSeqnoToTimeMappingInSV(
    std::vector<SuperVersionContext>* sv_contexts) {
  mutex_.AssertHeld();
@@ -48,7 +48,6 @@
 #include "db/write_controller.h"
 #include "db/write_thread.h"
 #include "logging/event_logger.h"
-#include "memtable/wbwi_memtable.h"
 #include "monitoring/instrumented_mutex.h"
 #include "options/db_options.h"
 #include "port/port.h"
@@ -61,7 +60,6 @@
 #include "rocksdb/transaction_log.h"
 #include "rocksdb/user_write_callback.h"
 #include "rocksdb/utilities/replayer.h"
-#include "rocksdb/utilities/write_batch_with_index.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/merging_iterator.h"
 #include "util/autovector.h"
@@ -365,10 +363,12 @@ class DBImpl : public DB {
  const Snapshot* GetSnapshot() override;
  void ReleaseSnapshot(const Snapshot* snapshot) override;

+  // EXPERIMENTAL
  std::unique_ptr<Iterator> NewCoalescingIterator(
      const ReadOptions& options,
      const std::vector<ColumnFamilyHandle*>& column_families) override;

+  // EXPERIMENTAL
  std::unique_ptr<AttributeGroupIterator> NewAttributeGroupIterator(
      const ReadOptions& options,
      const std::vector<ColumnFamilyHandle*>& column_families) override;
@@ -482,8 +482,7 @@ class DBImpl : public DB {

  Status GetDbIdentity(std::string& identity) const override;

-  virtual Status GetDbIdentityFromIdentityFile(const IOOptions& opts,
-                                               std::string* identity) const;
+  virtual Status GetDbIdentityFromIdentityFile(std::string* identity) const;

  Status GetDbSessionId(std::string& session_id) const override;

@@ -854,8 +853,6 @@ class DBImpl : public DB {

  uint64_t GetObsoleteSstFilesSize();

-  uint64_t MinOptionsFileNumberToKeep();
-
  // Returns the list of live files in 'live' and the list
  // of all files in the filesystem in 'candidate_files'.
  // If force == false and the last call was less than
@@ -1154,8 +1151,6 @@ class DBImpl : public DB {
  // Get the background error status
  Status TEST_GetBGError();

-  bool TEST_IsRecoveryInProgress();
-
  // Return the maximum overlapping data (in bytes) at next level for any
  // file at a level >= 1.
  uint64_t TEST_MaxNextLevelOverlappingBytes(
@@ -1200,7 +1195,9 @@ class DBImpl : public DB {

  uint64_t TEST_total_log_size() const { return total_log_size_; }

-  void TEST_GetAllBlockCaches(std::unordered_set<const Cache*>* cache_set);
+  // Returns column family name to ImmutableCFOptions map.
+  Status TEST_GetAllImmutableCFOptions(
+      std::unordered_map<std::string, const ImmutableCFOptions*>* iopts_map);

  // Return the lastest MutableCFOptions of a column family
  Status TEST_GetLatestMutableCFOptions(ColumnFamilyHandle* column_family,
@@ -1469,8 +1466,7 @@ class DBImpl : public DB {
  // The following two functions can only be called when:
  // 1. WriteThread::Writer::EnterUnbatched() is used.
  // 2. db_mutex is NOT held
-  Status RenameTempFileToOptionsFile(const std::string& file_name,
-                                     bool is_remote_compaction_enabled);
+  Status RenameTempFileToOptionsFile(const std::string& file_name);
  Status DeleteObsoleteOptionsFiles();

  void NotifyOnManualFlushScheduled(autovector<ColumnFamilyData*> cfds,
@@ -1509,23 +1505,6 @@ class DBImpl : public DB {

  void EraseThreadStatusDbInfo() const;

-  // For CFs that has updates in `wbwi`, their memtable will be switched,
-  // and `wbwi` will be added as the latest immutable memtable.
-  //
-  // REQUIRES: this thread is currently at the front of the main writer queue.
-  // @param prep_log refers to the WAL that contains prepare record
-  // for the transaction based on wbwi.
-  // @param assigned_seqno Sequence numbers for the ingested memtable.
-  // @param last_seqno the value of versions_->LastSequence() after the write
-  // ingests `wbwi` is done.
-  // @param memtable_updated Whether the same write that ingests wbwi has
-  // updated memtable. This is useful for determining whether to set bg
-  // error when IngestWBWI fails.
-  Status IngestWBWI(std::shared_ptr<WriteBatchWithIndex> wbwi,
-                    const WBWIMemTable::SeqnoRange& assigned_seqno,
-                    uint64_t min_prep_log, SequenceNumber last_seqno,
-                    bool memtable_updated, bool ignore_missing_cf);
-
  // If disable_memtable is set the application logic must guarantee that the
  // batch will still be skipped from memtable during the recovery. An excption
  // to this is seq_per_batch_ mode, in which since each batch already takes one
@@ -1541,16 +1520,6 @@ class DBImpl : public DB {
  // batch_cnt is expected to be non-zero in seq_per_batch mode and
  // indicates the number of sub-patches. A sub-patch is a subset of the write
  // batch that does not have duplicate keys.
-  // `callback` is called before WAL write.
-  // See more in comment above WriteCallback::Callback().
-  // pre_release_callback is called after WAL write and before memtable write.
-  // See more in comment above PreReleaseCallback::Callback().
-  // post_memtable_callback is called after memtable write but before publishing
-  // the sequence number to readers.
-  //
-  // The main write queue. This is the only write queue that updates
-  // LastSequence. When using one write queue, the same sequence also indicates
-  // the last published sequence.
  Status WriteImpl(const WriteOptions& options, WriteBatch* updates,
                   WriteCallback* callback = nullptr,
                   UserWriteCallback* user_write_cb = nullptr,
@@ -1558,9 +1527,7 @@ class DBImpl : public DB {
                   bool disable_memtable = false, uint64_t* seq_used = nullptr,
                   size_t batch_cnt = 0,
                   PreReleaseCallback* pre_release_callback = nullptr,
-                   PostMemTableCallback* post_memtable_callback = nullptr,
-                   std::shared_ptr<WriteBatchWithIndex> wbwi = nullptr,
-                   uint64_t min_prep_log = 0);
+                   PostMemTableCallback* post_memtable_callback = nullptr);

  Status PipelinedWriteImpl(const WriteOptions& options, WriteBatch* updates,
                            WriteCallback* callback = nullptr,
@@ -1620,12 +1587,11 @@ class DBImpl : public DB {

  virtual bool OwnTablesAndLogs() const { return true; }

-  // Read/create DB identity file (as appropriate), and write DB ID to
-  // version_edit if provided.
+  // Setup DB identity file, and write DB ID to manifest if necessary.
  Status SetupDBId(const WriteOptions& write_options, bool read_only,
-                   bool is_new_db, bool is_retry, VersionEdit* version_edit);
-  // Assign db_id_ and write DB ID to version_edit if provided.
-  void SetDBId(std::string&& id, bool read_only, VersionEdit* version_edit);
+                   RecoveryContext* recovery_ctx);
+  // Assign db_id_ and write DB ID to manifest if necessary.
+  void SetDBId(std::string&& id, bool read_only, RecoveryContext* recovery_ctx);

  // Collect a deduplicated collection of paths used by this DB, including
  // dbname_, DBOptions.db_paths, ColumnFamilyOptions.cf_paths.
@@ -1655,15 +1621,9 @@ class DBImpl : public DB {
  // vast majority of all files), since it already has the file size
  // on record, we don't need to query the file system. Otherwise, we query the
  // file system for the size of an unreferenced file.
-  // REQUIRES: mutex unlocked
  void TrackExistingDataFiles(
      const std::vector<std::string>& existing_data_files);

-  // Untrack data files in sst manager. This is only called during DB::Close on
-  // an unowned SstFileManager, to return it to a consistent state.
-  // REQUIRES: mutex unlocked
-  void UntrackDataFiles();
-
  // SetDbSessionId() should be called in the constuctor DBImpl()
  // to ensure that db_session_id_ gets updated every time the DB is opened
  void SetDbSessionId();
@@ -1730,8 +1690,6 @@ class DBImpl : public DB {
  friend class XFTransactionWriteHandler;
  friend class DBBlobIndexTest;
  friend class WriteUnpreparedTransactionTest_RecoveryTest_Test;
-  friend class CompactionServiceTest_PreservedOptionsLocalCompaction_Test;
-  friend class CompactionServiceTest_PreservedOptionsRemoteCompaction_Test;
 #endif

  struct CompactionState;
@@ -1740,7 +1698,7 @@ class DBImpl : public DB {

  struct WriteContext {
    SuperVersionContext superversion_context;
-    autovector<ReadOnlyMemTable*> memtables_to_free_;
+    autovector<MemTable*> memtables_to_free_;

    explicit WriteContext(bool create_superversion = false)
        : superversion_context(create_superversion) {}
@@ -2003,13 +1961,6 @@ class DBImpl : public DB {
  void ReleaseFileNumberFromPendingOutputs(
      std::unique_ptr<std::list<uint64_t>::iterator>& v);

-  // Similar to pending_outputs, preserve OPTIONS file. Used for remote
-  // compaction.
-  std::list<uint64_t>::iterator CaptureOptionsFileNumber();
-  void ReleaseOptionsFileNumber(
-      std::unique_ptr<std::list<uint64_t>::iterator>& v);
-
-  // Sets bg error if there is an error writing to WAL.
  IOStatus SyncClosedWals(const WriteOptions& write_options,
                          JobContext* job_context, VersionEdit* synced_wals,
                          bool error_recovery_in_prog);
@@ -2082,21 +2033,7 @@ class DBImpl : public DB {

  Status TrimMemtableHistory(WriteContext* context);

-  // Switches the current live memtable to immutable/read-only memtable.
-  // A new WAL is created if the current WAL is not empty.
-  // If `new_imm` is not nullptr, it will be added as the newest immutable
-  // memtable, if and only if OK status is returned.
-  // `last_seqno` needs to be provided if `new_imm` is not nullptr. It is
-  // the value of versions_->LastSequence() after the write that ingests new_imm
-  // is done.
-  //
-  // REQUIRES: mutex_ is held
-  // REQUIRES: this thread is currently at the front of the writer queue
-  // REQUIRES: this thread is currently at the front of the 2nd writer queue if
-  // two_write_queues_ is true (This is to simplify the reasoning.)
-  Status SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
-                        ReadOnlyMemTable* new_imm = nullptr,
-                        SequenceNumber last_seqno = 0);
+  Status SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context);

  // Select and output column families qualified for atomic flush in
  // `selected_cfds`. If `provided_candidate_cfds` is non-empty, it will be used
@@ -2134,18 +2071,17 @@ class DBImpl : public DB {
  // memtable pending flush.
  // resuming_from_bg_err indicates whether the caller is attempting to resume
  // from background error.
-  Status WaitForFlushMemTable(
-      ColumnFamilyData* cfd, const uint64_t* flush_memtable_id = nullptr,
-      bool resuming_from_bg_err = false,
-      std::optional<FlushReason> flush_reason = std::nullopt) {
+  Status WaitForFlushMemTable(ColumnFamilyData* cfd,
+                              const uint64_t* flush_memtable_id = nullptr,
+                              bool resuming_from_bg_err = false) {
    return WaitForFlushMemTables({cfd}, {flush_memtable_id},
-                                 resuming_from_bg_err, flush_reason);
+                                 resuming_from_bg_err);
  }
  // Wait for memtables to be flushed for multiple column families.
  Status WaitForFlushMemTables(
      const autovector<ColumnFamilyData*>& cfds,
      const autovector<const uint64_t*>& flush_memtable_ids,
-      bool resuming_from_bg_err, std::optional<FlushReason> flush_reason);
+      bool resuming_from_bg_err);

  inline void WaitForPendingWrites() {
    mutex_.AssertHeld();
@@ -2243,7 +2179,7 @@ class DBImpl : public DB {

  // Used by WriteImpl to update bg_error_ when IO error happens, e.g., write
  // WAL, sync WAL fails, if paranoid check is enabled.
-  void WALIOStatusCheck(const IOStatus& status);
+  void IOStatusCheck(const IOStatus& status);

  // Used by WriteImpl to update bg_error_ in case of memtable insert error.
  void MemTableInsertStatusCheck(const Status& memtable_insert_status);
@@ -2256,9 +2192,7 @@ class DBImpl : public DB {
                          JobContext* job_context, LogBuffer* log_buffer,
                          CompactionJobInfo* compaction_job_info);

-  // REQUIRES: mutex unlocked
-  void TrackOrUntrackFiles(const std::vector<std::string>& existing_data_files,
-                           bool track);
+  ColumnFamilyData* GetColumnFamilyDataByName(const std::string& cf_name);

  void MaybeScheduleFlushOrCompaction();

@@ -2287,27 +2221,10 @@ class DBImpl : public DB {
  void GenerateFlushRequest(const autovector<ColumnFamilyData*>& cfds,
                            FlushReason flush_reason, FlushRequest* req);

-  // Below functions are for executing flush, compaction in the background. A
-  // dequeue is the communication channel between threads that asks for the work
-  // to be done and the available threads in the thread pool that pick it up to
-  // execute it. We use these terminologies to describe the state of the work
-  // and its transitions:
-  // 1) It becomes pending once it's successfully enqueued into the
-  //    corresponding dequeue, a work in this state is also called unscheduled.
-  //    Counter `unscheduled_*_` counts work in this state.
-  // 2) When `MaybeScheduleFlushOrCompaction` schedule a thread to run `BGWork*`
-  //    for the work, it becomes scheduled
-  //    Counter `bg_*_scheduled_` counts work in this state.
-  // 3) Once the thread start to execute `BGWork*`, the work is popped from the
-  //    dequeue, it is now in running state
-  //    Counter `num_running_*_` counts work in this state.
-  // 4) Eventually, the work is finished. We don't need to specifically track
-  //    finished work.
-
  // Returns true if `req` is successfully enqueued.
-  bool EnqueuePendingFlush(const FlushRequest& req);
+  bool SchedulePendingFlush(const FlushRequest& req);

-  void EnqueuePendingCompaction(ColumnFamilyData* cfd);
+  void SchedulePendingCompaction(ColumnFamilyData* cfd);
  void SchedulePendingPurge(std::string fname, std::string dir_to_sync,
                            FileType type, uint64_t number, int job_id);
  static void BGWorkCompaction(void* arg);
@@ -2812,11 +2729,6 @@ class DBImpl : public DB {
  // State is protected with db mutex.
  std::list<uint64_t> pending_outputs_;

-  // Similar to pending_outputs_, FindObsoleteFiles()/PurgeObsoleteFiles() never
-  // deletes any OPTIONS file that has number bigger than any of the file number
-  // in min_options_file_numbers_.
-  std::list<uint64_t> min_options_file_numbers_;
-
  // flush_queue_ and compaction_queue_ hold column families that we need to
  // flush and compact, respectively.
  // A column family is inserted into flush_queue_ when it satisfies condition
@@ -2939,11 +2851,6 @@ class DBImpl : public DB {
  // garbages, among all column families.
  SequenceNumber bottommost_files_mark_threshold_ = kMaxSequenceNumber;

-  // The min threshold to trigger compactions for standalone range deletion
-  // files that are marked for compaction.
-  SequenceNumber standalone_range_deletion_files_mark_threshold_ =
-      kMaxSequenceNumber;
-
  LogsWithPrepTracker logs_with_prep_tracker_;

  // Callback for compaction to check if a key is visible to a snapshot.
@@ -3044,15 +2951,6 @@ DBOptions SanitizeOptions(const std::string& db, const DBOptions& src,
 CompressionType GetCompressionFlush(const ImmutableCFOptions& ioptions,
                                    const MutableCFOptions& mutable_cf_options);

-// Return a VersionEdit for the DB's recovery when the `memtables` of the
-// specified column family are obsolete. Specifically, the min log number to
-// keep, and the WAL files that can be deleted.
-VersionEdit GetDBRecoveryEditForObsoletingMemTables(
-    VersionSet* vset, const ColumnFamilyData& cfd,
-    const autovector<VersionEdit*>& edit_list,
-    const autovector<ReadOnlyMemTable*>& memtables,
-    LogsWithPrepTracker* prep_tracker);
-
 // Return the earliest log file to keep after the memtable flush is
 // finalized.
 // `cfd_to_flush` is the column family whose memtable (specified in
@@ -3062,13 +2960,13 @@ VersionEdit GetDBRecoveryEditForObsoletingMemTables(
 uint64_t PrecomputeMinLogNumberToKeep2PC(
    VersionSet* vset, const ColumnFamilyData& cfd_to_flush,
    const autovector<VersionEdit*>& edit_list,
-    const autovector<ReadOnlyMemTable*>& memtables_to_flush,
+    const autovector<MemTable*>& memtables_to_flush,
    LogsWithPrepTracker* prep_tracker);
 // For atomic flush.
 uint64_t PrecomputeMinLogNumberToKeep2PC(
    VersionSet* vset, const autovector<ColumnFamilyData*>& cfds_to_flush,
    const autovector<autovector<VersionEdit*>>& edit_lists,
-    const autovector<const autovector<ReadOnlyMemTable*>*>& memtables_to_flush,
+    const autovector<const autovector<MemTable*>*>& memtables_to_flush,
    LogsWithPrepTracker* prep_tracker);

 // In non-2PC mode, WALs with log number < the returned number can be
@@ -3085,11 +2983,11 @@ uint64_t PrecomputeMinLogNumberToKeepNon2PC(
 // will not depend on any WAL file. nullptr means no memtable is being flushed.
 // The function is only applicable to 2pc mode.
 uint64_t FindMinPrepLogReferencedByMemTable(
-    VersionSet* vset, const autovector<ReadOnlyMemTable*>& memtables_to_flush);
+    VersionSet* vset, const autovector<MemTable*>& memtables_to_flush);
 // For atomic flush.
 uint64_t FindMinPrepLogReferencedByMemTable(
    VersionSet* vset,
-    const autovector<const autovector<ReadOnlyMemTable*>*>& memtables_to_flush);
+    const autovector<const autovector<MemTable*>*>& memtables_to_flush);

 // Fix user-supplied options to be reasonable
 template <class T, class V>
@@ -753,7 +753,7 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(

  if (s.ok()) {
    autovector<ColumnFamilyData*> tmp_cfds;
-    autovector<const autovector<ReadOnlyMemTable*>*> mems_list;
+    autovector<const autovector<MemTable*>*> mems_list;
    autovector<const MutableCFOptions*> mutable_cf_options_list;
    autovector<FileMetaData*> tmp_file_meta;
    autovector<std::list<std::unique_ptr<FlushJobInfo>>*>
@@ -1457,6 +1457,11 @@ Status DBImpl::CompactFilesImpl(
    input_set.insert(TableFileNameToNumber(file_name));
  }

+  ColumnFamilyMetaData cf_meta;
+  // TODO(yhchiang): can directly use version here if none of the
+  // following functions call is pluggable to external developers.
+  version->GetColumnFamilyMetaData(&cf_meta);
+
  if (output_path_id < 0) {
    if (cfd->ioptions()->cf_paths.size() == 1U) {
      output_path_id = 0;
@@ -1477,7 +1482,7 @@ Status DBImpl::CompactFilesImpl(

  std::vector<CompactionInputFiles> input_files;
  Status s = cfd->compaction_picker()->SanitizeAndConvertCompactionInputFiles(
-      &input_set, output_level, version, &input_files);
+      &input_set, cf_meta, output_level, version->storage_info(), &input_files);
  TEST_SYNC_POINT(
      "DBImpl::CompactFilesImpl::PostSanitizeAndConvertCompactionInputFiles");
  if (!s.ok()) {
@@ -1556,12 +1561,6 @@ Status DBImpl::CompactFilesImpl(

  compaction_job.Prepare();

-  std::unique_ptr<std::list<uint64_t>::iterator> min_options_file_number_elem;
-  if (immutable_db_options().compaction_service != nullptr) {
-    min_options_file_number_elem.reset(
-        new std::list<uint64_t>::iterator(CaptureOptionsFileNumber()));
-  }
-
  mutex_.Unlock();
  TEST_SYNC_POINT("CompactFilesImpl:0");
  TEST_SYNC_POINT("CompactFilesImpl:1");
@@ -1571,10 +1570,6 @@ Status DBImpl::CompactFilesImpl(
  TEST_SYNC_POINT("CompactFilesImpl:3");
  mutex_.Lock();

-  if (immutable_db_options().compaction_service != nullptr) {
-    ReleaseOptionsFileNumber(min_options_file_number_elem);
-  }
-
  bool compaction_released = false;
  Status status =
      compaction_job.Install(*c->mutable_cf_options(), &compaction_released);
@@ -1857,9 +1852,8 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
        mutable_cf_options.compression_opts,
        mutable_cf_options.default_write_temperature,
        0 /* max_subcompactions, not applicable */,
-        {} /* grandparents, not applicable */,
-        std::nullopt /* earliest_snapshot */, nullptr /* snapshot_checker */,
-        false /* is manual */, "" /* trim_ts */, -1 /* score, not applicable */,
+        {} /* grandparents, not applicable */, false /* is manual */,
+        "" /* trim_ts */, -1 /* score, not applicable */,
        false /* is deletion compaction, not applicable */,
        false /* l0_files_might_overlap, not applicable */,
        CompactionReason::kRefitLevel));
@@ -1886,7 +1880,7 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
    Status status = versions_->LogAndApply(cfd, mutable_cf_options,
                                           read_options, write_options, &edit,
                                           &mutex_, directories_.GetDbDir());
-    c->MarkFilesBeingCompacted(false);
+
    cfd->compaction_picker()->UnregisterCompaction(c.get());
    c.reset();

@@ -2383,7 +2377,7 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
        ColumnFamilyData* loop_cfd =
            req.cfd_to_max_mem_id_to_persist.begin()->first;
        bool already_queued_for_flush = loop_cfd->queued_for_flush();
-        bool flush_req_enqueued = EnqueuePendingFlush(req);
+        bool flush_req_enqueued = SchedulePendingFlush(req);
        if (already_queued_for_flush || flush_req_enqueued) {
          loop_cfd->SetFlushSkipReschedule();
        }
@@ -2413,8 +2407,7 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
    }
    s = WaitForFlushMemTables(
        cfds, flush_memtable_ids,
-        flush_reason == FlushReason::kErrorRecovery /* resuming_from_bg_err */,
-        flush_reason);
+        flush_reason == FlushReason::kErrorRecovery /* resuming_from_bg_err */);
    InstrumentedMutexLock lock_guard(&mutex_);
    for (auto* tmp_cfd : cfds) {
      tmp_cfd->UnrefAndTryDelete();
@@ -2535,7 +2528,7 @@ Status DBImpl::AtomicFlushMemTables(
        }
      }
      GenerateFlushRequest(cfds, flush_reason, &flush_req);
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
      MaybeScheduleFlushOrCompaction();
    }

@@ -2556,8 +2549,7 @@ Status DBImpl::AtomicFlushMemTables(
    }
    s = WaitForFlushMemTables(
        cfds, flush_memtable_ids,
-        flush_reason == FlushReason::kErrorRecovery /* resuming_from_bg_err */,
-        flush_reason);
+        flush_reason == FlushReason::kErrorRecovery /* resuming_from_bg_err */);
    InstrumentedMutexLock lock_guard(&mutex_);
    for (auto* cfd : cfds) {
      cfd->UnrefAndTryDelete();
@@ -2591,7 +2583,7 @@ Status DBImpl::RetryFlushesForErrorRecovery(FlushReason flush_reason,
  if (immutable_db_options_.atomic_flush) {
    FlushRequest flush_req;
    GenerateFlushRequest(cfds, flush_reason, &flush_req);
-    EnqueuePendingFlush(flush_req);
+    SchedulePendingFlush(flush_req);
    for (auto& iter : flush_req.cfd_to_max_mem_id_to_persist) {
      flush_memtable_ids.push_back(iter.second);
    }
@@ -2605,7 +2597,7 @@ Status DBImpl::RetryFlushesForErrorRecovery(FlushReason flush_reason,
          flush_reason,
          {{cfd,
            std::numeric_limits<uint64_t>::max() /* max_mem_id_to_persist */}}};
-      if (EnqueuePendingFlush(flush_req)) {
+      if (SchedulePendingFlush(flush_req)) {
        cfd->SetFlushSkipReschedule();
      };
    }
@@ -2620,7 +2612,7 @@ Status DBImpl::RetryFlushesForErrorRecovery(FlushReason flush_reason,
      flush_memtable_id_ptrs.push_back(&flush_memtable_id);
    }
    s = WaitForFlushMemTables(cfds, flush_memtable_id_ptrs,
-                              true /* resuming_from_bg_err */, flush_reason);
+                              true /* resuming_from_bg_err */);
    mutex_.Lock();
  }

@@ -2720,7 +2712,7 @@ Status DBImpl::WaitUntilFlushWouldNotStallWrites(ColumnFamilyData* cfd,
 Status DBImpl::WaitForFlushMemTables(
    const autovector<ColumnFamilyData*>& cfds,
    const autovector<const uint64_t*>& flush_memtable_ids,
-    bool resuming_from_bg_err, std::optional<FlushReason> flush_reason) {
+    bool resuming_from_bg_err) {
  int num = static_cast<int>(cfds.size());
  // Wait until the compaction completes
  InstrumentedMutexLock l(&mutex_);
@@ -2758,15 +2750,7 @@ Status DBImpl::WaitForFlushMemTables(
                 (flush_memtable_ids[i] != nullptr &&
                  cfds[i]->imm()->GetEarliestMemTableID() >
                      *flush_memtable_ids[i])) {
-        // Make file ingestion's flush wait until SuperVersion is also updated
-        // since after flush, it does range overlapping check and file level
-        // assignment with the current SuperVersion.
-        if (!flush_reason.has_value() ||
-            flush_reason.value() != FlushReason::kExternalFileIngestion ||
-            cfds[i]->GetSuperVersion()->imm->GetID() ==
-                cfds[i]->imm()->current()->GetID()) {
-          ++num_finished;
-        }
+        ++num_finished;
      }
    }
    if (1 == num_dropped && 1 == num) {
@@ -2966,7 +2950,6 @@ void DBImpl::AddToCompactionQueue(ColumnFamilyData* cfd) {
  cfd->Ref();
  compaction_queue_.push_back(cfd);
  cfd->set_queued_for_compaction(true);
-  ++unscheduled_compactions_;
 }

 ColumnFamilyData* DBImpl::PopFirstFromCompactionQueue() {
@@ -3022,7 +3005,7 @@ ColumnFamilyData* DBImpl::PickCompactionFromQueue(
  return cfd;
 }

-bool DBImpl::EnqueuePendingFlush(const FlushRequest& flush_req) {
+bool DBImpl::SchedulePendingFlush(const FlushRequest& flush_req) {
  mutex_.AssertHeld();
  bool enqueued = false;
  if (reject_new_background_jobs_) {
@@ -3058,15 +3041,16 @@ bool DBImpl::EnqueuePendingFlush(const FlushRequest& flush_req) {
  return enqueued;
 }

-void DBImpl::EnqueuePendingCompaction(ColumnFamilyData* cfd) {
+void DBImpl::SchedulePendingCompaction(ColumnFamilyData* cfd) {
  mutex_.AssertHeld();
  if (reject_new_background_jobs_) {
    return;
  }
  if (!cfd->queued_for_compaction() && cfd->NeedsCompaction()) {
-    TEST_SYNC_POINT_CALLBACK("EnqueuePendingCompaction::cfd",
+    TEST_SYNC_POINT_CALLBACK("SchedulePendingCompaction::cfd",
                             static_cast<void*>(cfd));
    AddToCompactionQueue(cfd);
+    ++unscheduled_compactions_;
  }
 }

@@ -3234,7 +3218,7 @@ Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
 #ifndef NDEBUG
      flush_req.reschedule_count += 1;
 #endif /* !NDEBUG */
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
      *reason = flush_reason;
      *flush_rescheduled_to_retain_udt = true;
      return Status::TryAgain();
@@ -3557,14 +3541,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
      is_manual && manual_compaction->disallow_trivial_move;

  CompactionJobStats compaction_job_stats;
-  // Set is_remote_compaction to true on CompactionBegin Event if
-  // compaction_service is set except for trivial moves. We do not know whether
-  // remote compaction will actually be successfully scheduled, or fall back to
-  // local at this time. CompactionCompleted event will tell the truth where
-  // the compaction actually happened.
-  compaction_job_stats.is_remote_compaction =
-      immutable_db_options().compaction_service != nullptr;
-
  Status status;
  if (!error_handler_.IsBGWorkStopped()) {
    if (shutting_down_.load(std::memory_order_acquire)) {
@@ -3685,20 +3661,8 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
      // compaction is not necessary. Need to make sure mutex is held
      // until we make a copy in the following code
      TEST_SYNC_POINT("DBImpl::BackgroundCompaction():BeforePickCompaction");
-      SnapshotChecker* snapshot_checker = nullptr;
-      std::vector<SequenceNumber> snapshot_seqs;
-      // This info is not useful for other scenarios, so save querying existing
-      // snapshots for those cases.
-      if (cfd->ioptions()->compaction_style == kCompactionStyleUniversal &&
-          cfd->user_comparator()->timestamp_size() == 0) {
-        SequenceNumber earliest_write_conflict_snapshot;
-        GetSnapshotContext(job_context, &snapshot_seqs,
-                           &earliest_write_conflict_snapshot,
-                           &snapshot_checker);
-        assert(is_snapshot_supported_ || snapshots_.empty());
-      }
      c.reset(cfd->PickCompaction(*mutable_cf_options, mutable_db_options_,
-                                  snapshot_seqs, snapshot_checker, log_buffer));
+                                  log_buffer));
      TEST_SYNC_POINT("DBImpl::BackgroundCompaction():AfterPickCompaction");

      if (c != nullptr) {
@@ -3714,6 +3678,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
              ->ComputeCompactionScore(*(c->immutable_options()),
                                       *(c->mutable_cf_options()));
          AddToCompactionQueue(cfd);
+          ++unscheduled_compactions_;

          c.reset();
          // Don't need to sleep here, because BackgroundCallCompaction
@@ -3742,6 +3707,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
          if (cfd->NeedsCompaction()) {
            // Yes, we need more compactions!
            AddToCompactionQueue(cfd);
+            ++unscheduled_compactions_;
            MaybeScheduleFlushOrCompaction();
          }
        }
@@ -3802,8 +3768,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    ThreadStatusUtil::SetThreadOperation(ThreadStatus::OP_COMPACTION);

    compaction_job_stats.num_input_files = c->num_input_files(0);
-    // Trivial moves do not get compacted remotely
-    compaction_job_stats.is_remote_compaction = false;

    NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
                            compaction_job_stats, job_context->job_id);
@@ -3939,12 +3903,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
        &bg_bottom_compaction_scheduled_);
    compaction_job.Prepare();

-    std::unique_ptr<std::list<uint64_t>::iterator> min_options_file_number_elem;
-    if (immutable_db_options().compaction_service != nullptr) {
-      min_options_file_number_elem.reset(
-          new std::list<uint64_t>::iterator(CaptureOptionsFileNumber()));
-    }
-
    NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
                            compaction_job_stats, job_context->job_id);
    mutex_.Unlock();
@@ -3954,11 +3912,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    compaction_job.Run().PermitUncheckedError();
    TEST_SYNC_POINT("DBImpl::BackgroundCompaction:NonTrivial:AfterRun");
    mutex_.Lock();
-
-    if (immutable_db_options().compaction_service != nullptr) {
-      ReleaseOptionsFileNumber(min_options_file_number_elem);
-    }
-
    status =
        compaction_job.Install(*c->mutable_cf_options(), &compaction_released);
    io_s = compaction_job.io_status();
@@ -3986,10 +3939,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
      // Sanity checking that compaction files are freed.
      for (size_t i = 0; i < c->num_input_levels(); i++) {
        for (size_t j = 0; j < c->inputs(i)->size(); j++) {
-          // When status is not OK, compaction's result installation failed and
-          // no new Version installed. The files could have been released and
-          // picked up again by other compaction attempts.
-          assert(!c->input(i, j)->being_compacted || !status.ok());
+          assert(!c->input(i, j)->being_compacted);
        }
      }
      std::unordered_set<Compaction*>* cip = c->column_family_data()
@@ -4047,6 +3997,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                                   *(c->mutable_cf_options()));
      if (!cfd->queued_for_compaction()) {
        AddToCompactionQueue(cfd);
+        ++unscheduled_compactions_;
      }
    }
  }
@@ -4308,23 +4259,17 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
  // newer snapshot created and released frequently, the compaction will be
  // triggered soon anyway.
  bottommost_files_mark_threshold_ = kMaxSequenceNumber;
-  standalone_range_deletion_files_mark_threshold_ = kMaxSequenceNumber;
  for (auto* my_cfd : *versions_->GetColumnFamilySet()) {
    if (!my_cfd->ioptions()->allow_ingest_behind) {
      bottommost_files_mark_threshold_ = std::min(
          bottommost_files_mark_threshold_,
          my_cfd->current()->storage_info()->bottommost_files_mark_threshold());
    }
-    standalone_range_deletion_files_mark_threshold_ =
-        std::min(standalone_range_deletion_files_mark_threshold_,
-                 cfd->current()
-                     ->storage_info()
-                     ->standalone_range_tombstone_files_mark_threshold());
  }

  // Whenever we install new SuperVersion, we might need to issue new flushes or
  // compactions.
-  EnqueuePendingCompaction(cfd);
+  SchedulePendingCompaction(cfd);
  MaybeScheduleFlushOrCompaction();

  // Update max_total_in_memory_state_
@@ -6,8 +6,8 @@
 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
+
 #ifndef NDEBUG
-#include <iostream>

 #include "db/blob/blob_file_cache.h"
 #include "db/column_family.h"
@@ -200,11 +200,6 @@ Status DBImpl::TEST_GetBGError() {
  return error_handler_.GetBGError();
 }

-bool DBImpl::TEST_IsRecoveryInProgress() {
-  InstrumentedMutexLock l(&mutex_);
-  return error_handler_.IsRecoveryInProgress();
-}
-
 void DBImpl::TEST_LockMutex() { mutex_.Lock(); }

 void DBImpl::TEST_UnlockMutex() { mutex_.Unlock(); }
@@ -233,16 +228,23 @@ uint64_t DBImpl::TEST_LogfileNumber() {
  return logfile_number_;
 }

-void DBImpl::TEST_GetAllBlockCaches(
-    std::unordered_set<const Cache*>* cache_set) {
-  InstrumentedMutexLock l(&mutex_);
-  for (auto cfd : *versions_->GetColumnFamilySet()) {
-    if (const auto bbto =
-            cfd->GetCurrentMutableCFOptions()
-                ->table_factory->GetOptions<BlockBasedTableOptions>()) {
-      cache_set->insert(bbto->block_cache.get());
+Status DBImpl::TEST_GetAllImmutableCFOptions(
+    std::unordered_map<std::string, const ImmutableCFOptions*>* iopts_map) {
+  std::vector<std::string> cf_names;
+  std::vector<const ImmutableCFOptions*> iopts;
+  {
+    InstrumentedMutexLock l(&mutex_);
+    for (auto cfd : *versions_->GetColumnFamilySet()) {
+      cf_names.push_back(cfd->GetName());
+      iopts.push_back(cfd->ioptions());
    }
  }
+  iopts_map->clear();
+  for (size_t i = 0; i < cf_names.size(); ++i) {
+    iopts_map->insert({cf_names[i], iopts[i]});
+  }
+
+  return Status::OK();
 }

 uint64_t DBImpl::TEST_FindMinLogContainingOutstandingPrep() {
@@ -258,7 +260,7 @@ size_t DBImpl::TEST_LogsWithPrepSize() {
 }

 uint64_t DBImpl::TEST_FindMinPrepLogReferencedByMemTable() {
-  autovector<ReadOnlyMemTable*> empty_list;
+  autovector<MemTable*> empty_list;
  return FindMinPrepLogReferencedByMemTable(versions_.get(), empty_list);
 }

@@ -338,52 +340,31 @@ void DBImpl::TEST_VerifyNoObsoleteFilesCached(
    l.emplace(&mutex_);
  }

-  if (!opened_successfully_) {
-    // We don't need to pro-actively clean up open files during DB::Open()
-    // if we know we are about to fail and clean up in Close().
-    return;
-  }
-  if (disable_delete_obsolete_files_ > 0) {
-    // For better or worse, DB::Close() is allowed with deletions disabled.
-    // Since we generally associate clean-up of open files with deleting them,
-    // we allow "obsolete" open files when deletions are disabled.
-    return;
-  }
-
-  // Live and "quarantined" files are allowed to be open in table cache
-  std::set<uint64_t> live_and_quar_files;
+  std::vector<uint64_t> live_files;
  for (auto cfd : *versions_->GetColumnFamilySet()) {
    if (cfd->IsDropped()) {
      continue;
    }
-    // Iterate over live versions
-    Version* current = cfd->current();
-    Version* ver = current;
-    do {
-      // Sneakily add both SST and blob files to the same list
-      std::vector<uint64_t> live_files_vec;
-      ver->AddLiveFiles(&live_files_vec, &live_files_vec);
-      live_and_quar_files.insert(live_files_vec.begin(), live_files_vec.end());
+    // Sneakily add both SST and blob files to the same list
+    cfd->current()->AddLiveFiles(&live_files, &live_files);
+  }
+  std::sort(live_files.begin(), live_files.end());

-      ver = ver->Next();
-    } while (ver != current);
-  }
-  {
-    const auto& quar_files = error_handler_.GetFilesToQuarantine();
-    live_and_quar_files.insert(quar_files.begin(), quar_files.end());
-  }
-  auto fn = [&live_and_quar_files](const Slice& key, Cache::ObjectPtr, size_t,
-                                   const Cache::CacheItemHelper*) {
+  auto fn = [&live_files](const Slice& key, Cache::ObjectPtr, size_t,
+                          const Cache::CacheItemHelper* helper) {
+    if (helper != BlobFileCache::GetHelper()) {
+      // Skip non-blob files for now
+      // FIXME: diagnose and fix the leaks of obsolete SST files revealed in
+      // unit tests.
+      return;
+    }
    // See TableCache and BlobFileCache
    assert(key.size() == sizeof(uint64_t));
    uint64_t file_number;
    GetUnaligned(reinterpret_cast<const uint64_t*>(key.data()), &file_number);
-    // Assert file is in live/quarantined set
-    if (live_and_quar_files.find(file_number) == live_and_quar_files.end()) {
-      std::cerr << "File " << file_number << " is not live nor quarantined"
-                << std::endl;
-      assert(false);
-    }
+    // Assert file is in sorted live_files
+    assert(
+        std::binary_search(live_files.begin(), live_files.end(), file_number));
  };
  table_cache_->ApplyToAllEntries(fn, {});
 }
@@ -47,7 +47,7 @@ Status DBImpl::SuggestCompactRange(ColumnFamilyHandle* column_family,
    // compaction score
    vstorage->ComputeCompactionScore(*cfd->ioptions(),
                                     *cfd->GetLatestMutableCFOptions());
-    EnqueuePendingCompaction(cfd);
+    SchedulePendingCompaction(cfd);
    MaybeScheduleFlushOrCompaction();
  }
  return Status::OK();
@@ -43,14 +43,6 @@ uint64_t DBImpl::GetObsoleteSstFilesSize() {
  return versions_->GetObsoleteSstFilesSize();
 }

-uint64_t DBImpl::MinOptionsFileNumberToKeep() {
-  mutex_.AssertHeld();
-  if (!min_options_file_numbers_.empty()) {
-    return *min_options_file_numbers_.begin();
-  }
-  return std::numeric_limits<uint64_t>::max();
-}
-
 Status DBImpl::DisableFileDeletions() {
  Status s;
  int my_disable_delete_obsolete_files;
@@ -155,7 +147,6 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
  // here but later find newer generated unfinalized files while scanning.
  job_context->min_pending_output = MinObsoleteSstNumberToKeep();
  job_context->files_to_quarantine = error_handler_.GetFilesToQuarantine();
-  job_context->min_options_file_number = MinOptionsFileNumberToKeep();

  // Get obsolete files.  This function will also update the list of
  // pending files in VersionSet().
@@ -449,8 +440,14 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
      // File is being deleted (actually obsolete)
      auto number = file.metadata->fd.GetNumber();
      candidate_files.emplace_back(MakeTableFileName(number), file.path);
-      TableCache::ReleaseObsolete(table_cache_.get(), number, handle,
-                                  file.uncache_aggressiveness);
+      if (handle == nullptr) {
+        // For files not "pinned" in table cache
+        handle = TableCache::Lookup(table_cache_.get(), number);
+      }
+      if (handle) {
+        TableCache::ReleaseObsolete(table_cache_.get(), handle,
+                                    file.uncache_aggressiveness);
+      }
    }
    file.DeleteMetadata();
  }
@@ -501,7 +498,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
                                dbname_);

  // File numbers of most recent two OPTIONS file in candidate_files (found in
-  // previous FindObsoleteFiles(full_scan=true))
+  // previos FindObsoleteFiles(full_scan=true))
  // At this point, there must not be any duplicate file numbers in
  // candidate_files.
  uint64_t optsfile_num1 = std::numeric_limits<uint64_t>::min();
@@ -522,11 +519,6 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
    }
  }

-  // For remote compactions, we need to keep OPTIONS file that may get
-  // referenced by the remote worker
-
-  optsfile_num2 = std::min(optsfile_num2, state.min_options_file_number);
-
  // Close WALs before trying to delete them.
  for (const auto w : state.logs_to_free) {
    // TODO: maybe check the return value of Close.
@@ -566,17 +558,9 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
      case kTableFile:
        // If the second condition is not there, this makes
        // DontDeletePendingOutputs fail
-        // FIXME: but should NOT keep if it came from sst_delete_files?
        keep = (sst_live_set.find(number) != sst_live_set.end()) ||
               number >= state.min_pending_output;
        if (!keep) {
-          // NOTE: sometimes redundant (if came from sst_delete_files)
-          // We don't know which column family is applicable here so we don't
-          // know what uncache_aggressiveness would be used with
-          // ReleaseObsolete(). Anyway, obsolete files ideally go into
-          // sst_delete_files for better/quicker handling, and this is just a
-          // backstop.
-          TableCache::Evict(table_cache_.get(), number);
          files_to_del.insert(number);
        }
        break;
@@ -738,46 +722,13 @@ void DBImpl::DeleteObsoleteFiles() {
  mutex_.Lock();
 }

-VersionEdit GetDBRecoveryEditForObsoletingMemTables(
-    VersionSet* vset, const ColumnFamilyData& cfd,
-    const autovector<VersionEdit*>& edit_list,
-    const autovector<ReadOnlyMemTable*>& memtables,
-    LogsWithPrepTracker* prep_tracker) {
-  VersionEdit wal_deletion_edit;
-  uint64_t min_wal_number_to_keep = 0;
-  assert(edit_list.size() > 0);
-  if (vset->db_options()->allow_2pc) {
-    // Note that if mempurge is successful, the edit_list will
-    // not be applicable (contains info of new min_log number to keep,
-    // and level 0 file path of SST file created during normal flush,
-    // so both pieces of information are irrelevant after a successful
-    // mempurge operation).
-    min_wal_number_to_keep = PrecomputeMinLogNumberToKeep2PC(
-        vset, cfd, edit_list, memtables, prep_tracker);
-
-    // We piggyback the information of earliest log file to keep in the
-    // manifest entry for the last file flushed.
-  } else {
-    min_wal_number_to_keep =
-        PrecomputeMinLogNumberToKeepNon2PC(vset, cfd, edit_list);
-  }
-
-  wal_deletion_edit.SetMinLogNumberToKeep(min_wal_number_to_keep);
-  if (vset->db_options()->track_and_verify_wals_in_manifest) {
-    if (min_wal_number_to_keep > vset->GetWalSet().GetMinWalNumberToKeep()) {
-      wal_deletion_edit.DeleteWalsBefore(min_wal_number_to_keep);
-    }
-  }
-  return wal_deletion_edit;
-}
-
 uint64_t FindMinPrepLogReferencedByMemTable(
-    VersionSet* vset, const autovector<ReadOnlyMemTable*>& memtables_to_flush) {
+    VersionSet* vset, const autovector<MemTable*>& memtables_to_flush) {
  uint64_t min_log = 0;

  // we must look through the memtables for two phase transactions
  // that have been committed but not yet flushed
-  std::unordered_set<ReadOnlyMemTable*> memtables_to_flush_set(
+  std::unordered_set<MemTable*> memtables_to_flush_set(
      memtables_to_flush.begin(), memtables_to_flush.end());
  for (auto loop_cfd : *vset->GetColumnFamilySet()) {
    if (loop_cfd->IsDropped()) {
@@ -802,12 +753,12 @@ uint64_t FindMinPrepLogReferencedByMemTable(
 }

 uint64_t FindMinPrepLogReferencedByMemTable(
-    VersionSet* vset, const autovector<const autovector<ReadOnlyMemTable*>*>&
-                          memtables_to_flush) {
+    VersionSet* vset,
+    const autovector<const autovector<MemTable*>*>& memtables_to_flush) {
  uint64_t min_log = 0;

-  std::unordered_set<ReadOnlyMemTable*> memtables_to_flush_set;
-  for (const autovector<ReadOnlyMemTable*>* memtables : memtables_to_flush) {
+  std::unordered_set<MemTable*> memtables_to_flush_set;
+  for (const autovector<MemTable*>* memtables : memtables_to_flush) {
    memtables_to_flush_set.insert(memtables->begin(), memtables->end());
  }
  for (auto loop_cfd : *vset->GetColumnFamilySet()) {
@@ -899,7 +850,7 @@ uint64_t PrecomputeMinLogNumberToKeepNon2PC(
 uint64_t PrecomputeMinLogNumberToKeep2PC(
    VersionSet* vset, const ColumnFamilyData& cfd_to_flush,
    const autovector<VersionEdit*>& edit_list,
-    const autovector<ReadOnlyMemTable*>& memtables_to_flush,
+    const autovector<MemTable*>& memtables_to_flush,
    LogsWithPrepTracker* prep_tracker) {
  assert(vset != nullptr);
  assert(prep_tracker != nullptr);
@@ -940,7 +891,7 @@ uint64_t PrecomputeMinLogNumberToKeep2PC(
 uint64_t PrecomputeMinLogNumberToKeep2PC(
    VersionSet* vset, const autovector<ColumnFamilyData*>& cfds_to_flush,
    const autovector<autovector<VersionEdit*>>& edit_lists,
-    const autovector<const autovector<ReadOnlyMemTable*>*>& memtables_to_flush,
+    const autovector<const autovector<MemTable*>*>& memtables_to_flush,
    LogsWithPrepTracker* prep_tracker) {
  assert(vset != nullptr);
  assert(prep_tracker != nullptr);
@@ -970,65 +921,59 @@ uint64_t PrecomputeMinLogNumberToKeep2PC(
 }

 void DBImpl::SetDBId(std::string&& id, bool read_only,
-                     VersionEdit* version_edit) {
+                     RecoveryContext* recovery_ctx) {
  assert(db_id_.empty());
  assert(!id.empty());
  db_id_ = std::move(id);
-  if (!read_only && version_edit) {
-    assert(version_edit != nullptr);
+  if (!read_only && immutable_db_options_.write_dbid_to_manifest) {
+    assert(recovery_ctx != nullptr);
    assert(versions_->GetColumnFamilySet() != nullptr);
-    version_edit->SetDBId(db_id_);
+    VersionEdit edit;
+    edit.SetDBId(db_id_);
    versions_->db_id_ = db_id_;
+    recovery_ctx->UpdateVersionEdits(
+        versions_->GetColumnFamilySet()->GetDefault(), edit);
  }
 }

 Status DBImpl::SetupDBId(const WriteOptions& write_options, bool read_only,
-                         bool is_new_db, bool is_retry,
-                         VersionEdit* version_edit) {
+                         RecoveryContext* recovery_ctx) {
  Status s;
-  if (!is_new_db) {
-    // Check for the IDENTITY file and create it if not there or
-    // broken or not matching manifest
-    std::string db_id_in_file;
-    s = fs_->FileExists(IdentityFileName(dbname_), IOOptions(), nullptr);
-    if (s.ok()) {
-      IOOptions opts;
-      if (is_retry) {
-        opts.verify_and_reconstruct_read = true;
-      }
-      s = GetDbIdentityFromIdentityFile(opts, &db_id_in_file);
-      if (s.ok() && !db_id_in_file.empty()) {
-        if (db_id_.empty()) {
-          // Loaded from file and wasn't already known from manifest
-          SetDBId(std::move(db_id_in_file), read_only, version_edit);
-          return s;
-        } else if (db_id_ == db_id_in_file) {
-          // Loaded from file and matches manifest
-          return s;
-        }
+  // Check for the IDENTITY file and create it if not there or
+  // broken or not matching manifest
+  std::string db_id_in_file;
+  s = fs_->FileExists(IdentityFileName(dbname_), IOOptions(), nullptr);
+  if (s.ok()) {
+    s = GetDbIdentityFromIdentityFile(&db_id_in_file);
+    if (s.ok() && !db_id_in_file.empty()) {
+      if (db_id_.empty()) {
+        // Loaded from file and wasn't already known from manifest
+        SetDBId(std::move(db_id_in_file), read_only, recovery_ctx);
+        return s;
+      } else if (db_id_ == db_id_in_file) {
+        // Loaded from file and matches manifest
+        return s;
      }
    }
-    if (s.IsNotFound()) {
-      s = Status::OK();
-    }
-    if (!s.ok()) {
-      assert(s.IsIOError());
-      return s;
-    }
+  }
+  if (s.IsNotFound()) {
+    s = Status::OK();
+  }
+  if (!s.ok()) {
+    assert(s.IsIOError());
+    return s;
  }
  // Otherwise IDENTITY file is missing or no good.
  // Generate new id if needed
  if (db_id_.empty()) {
-    SetDBId(env_->GenerateUniqueId(), read_only, version_edit);
+    SetDBId(env_->GenerateUniqueId(), read_only, recovery_ctx);
  }
  // Persist it to IDENTITY file if allowed
-  if (!read_only && immutable_db_options_.write_identity_file) {
+  if (!read_only) {
    s = SetIdentityFile(write_options, env_, dbname_,
                        immutable_db_options_.metadata_write_temperature,
                        db_id_);
  }
-  // NOTE: an obsolete IDENTITY file with write_identity_file=false is handled
-  // elsewhere, so that it's only deleted after successful recovery
  return s;
 }

@@ -289,25 +289,28 @@ Status DBImpl::ValidateOptions(const DBOptions& db_options) {
          "start_time and end_time cannot be the same");
    }
  }
-
-  if (!db_options.write_dbid_to_manifest && !db_options.write_identity_file) {
-    return Status::InvalidArgument(
-        "write_dbid_to_manifest and write_identity_file cannot both be false");
-  }
  return Status::OK();
 }

 Status DBImpl::NewDB(std::vector<std::string>* new_filenames) {
-  VersionEdit new_db_edit;
+  VersionEdit new_db;
  const WriteOptions write_options(Env::IOActivity::kDBOpen);
-  Status s = SetupDBId(write_options, /*read_only=*/false, /*is_new_db=*/true,
-                       /*is_retry=*/false, &new_db_edit);
+  Status s = SetIdentityFile(write_options, env_, dbname_,
+                             immutable_db_options_.metadata_write_temperature);
  if (!s.ok()) {
    return s;
  }
-  new_db_edit.SetLogNumber(0);
-  new_db_edit.SetNextFile(2);
-  new_db_edit.SetLastSequence(0);
+  if (immutable_db_options_.write_dbid_to_manifest) {
+    std::string temp_db_id;
+    s = GetDbIdentityFromIdentityFile(&temp_db_id);
+    if (!s.ok()) {
+      return s;
+    }
+    new_db.SetDBId(temp_db_id);
+  }
+  new_db.SetLogNumber(0);
+  new_db.SetNextFile(2);
+  new_db.SetLastSequence(0);

  ROCKS_LOG_INFO(immutable_db_options_.info_log, "Creating manifest 1 \n");
  const std::string manifest = DescriptorFileName(dbname_, 1);
@@ -339,7 +342,7 @@ Status DBImpl::NewDB(std::vector<std::string>* new_filenames) {
        tmp_set.Contains(FileType::kDescriptorFile)));
    log::Writer log(std::move(file_writer), 0, false);
    std::string record;
-    new_db_edit.EncodeTo(&record);
+    new_db.EncodeTo(&record);
    s = log.AddRecord(write_options, record);
    if (s.ok()) {
      s = SyncManifest(&immutable_db_options_, write_options, log.file());
@@ -525,7 +528,7 @@ Status DBImpl::Recover(
    }
    assert(s.ok());
  }
-  assert(is_new_db || db_id_.empty());
+  assert(db_id_.empty());
  Status s;
  bool missing_table_file = false;
  if (!immutable_db_options_.best_efforts_recovery) {
@@ -575,7 +578,6 @@ Status DBImpl::Recover(
  }
  if (s.ok() && !read_only) {
    for (auto cfd : *versions_->GetColumnFamilySet()) {
-      auto& moptions = *cfd->GetLatestMutableCFOptions();
      // Try to trivially move files down the LSM tree to start from bottommost
      // level when level_compaction_dynamic_level_bytes is enabled. This should
      // only be useful when user is migrating to turning on this option.
@@ -593,14 +595,14 @@ Status DBImpl::Recover(
      if (cfd->ioptions()->compaction_style ==
              CompactionStyle::kCompactionStyleLevel &&
          cfd->ioptions()->level_compaction_dynamic_level_bytes &&
-          !moptions.disable_auto_compactions) {
+          !cfd->GetLatestMutableCFOptions()->disable_auto_compactions) {
        int to_level = cfd->ioptions()->num_levels - 1;
        // last level is reserved
        // allow_ingest_behind does not support Level Compaction,
        // and per_key_placement can have infinite compaction loop for Level
        // Compaction. Adjust to_level here just to be safe.
        if (cfd->ioptions()->allow_ingest_behind ||
-            moptions.preclude_last_level_data_seconds > 0) {
+            cfd->ioptions()->preclude_last_level_data_seconds > 0) {
          to_level -= 1;
        }
        // Whether this column family has a level trivially moved
@@ -672,17 +674,7 @@ Status DBImpl::Recover(
      }
    }
  }
-  if (is_new_db) {
-    // Already set up DB ID in NewDB
-  } else if (immutable_db_options_.write_dbid_to_manifest && recovery_ctx) {
-    VersionEdit edit;
-    s = SetupDBId(write_options, read_only, is_new_db, is_retry, &edit);
-    recovery_ctx->UpdateVersionEdits(
-        versions_->GetColumnFamilySet()->GetDefault(), edit);
-  } else {
-    s = SetupDBId(write_options, read_only, is_new_db, is_retry, nullptr);
-  }
-  assert(!s.ok() || !db_id_.empty());
+  s = SetupDBId(write_options, read_only, recovery_ctx);
  ROCKS_LOG_INFO(immutable_db_options_.info_log, "DB ID: %s\n", db_id_.c_str());
  if (s.ok() && !read_only) {
    s = MaybeUpdateNextFileNumber(recovery_ctx);
@@ -1275,8 +1267,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
          reader.GetRecordedTimestampSize();
      status = HandleWriteBatchTimestampSizeDifference(
          &batch, running_ts_sz, record_ts_sz,
-          TimestampSizeConsistencyMode::kReconcileInconsistency, seq_per_batch_,
-          batch_per_txn_, &new_batch);
+          TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch);
      if (!status.ok()) {
        return status;
      }
@@ -1373,9 +1364,6 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
        }
      }
    }
-    ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "Recovered to log #%" PRIu64 " seq #%" PRIu64, wal_number,
-                   *next_sequence);

    if (!status.ok() || old_log_record) {
      if (status.IsNotSupported()) {
@@ -1408,6 +1396,10 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
        if (corrupted_wal_found != nullptr) {
          *corrupted_wal_found = true;
        }
+        ROCKS_LOG_INFO(immutable_db_options_.info_log,
+                       "Point in time recovered to log #%" PRIu64
+                       " seq #%" PRIu64,
+                       wal_number, *next_sequence);
      } else {
        assert(immutable_db_options_.wal_recovery_mode ==
                   WALRecoveryMode::kTolerateCorruptedTailRecords ||
@@ -1668,20 +1660,9 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
  Arena arena;
  Status s;
  TableProperties table_properties;
-  const auto* ucmp = cfd->internal_comparator().user_comparator();
-  assert(ucmp);
-  const size_t ts_sz = ucmp->timestamp_size();
-  const bool logical_strip_timestamp =
-      ts_sz > 0 && !cfd->ioptions()->persist_user_defined_timestamps;
  {
    ScopedArenaPtr<InternalIterator> iter(
-        logical_strip_timestamp
-            ? mem->NewTimestampStrippingIterator(
-                  ro, /*seqno_to_time_mapping=*/nullptr, &arena,
-                  /*prefix_extractor=*/nullptr, ts_sz)
-            : mem->NewIterator(ro, /*seqno_to_time_mapping=*/nullptr, &arena,
-                               /*prefix_extractor=*/nullptr,
-                               /*for_flush=*/true));
+        mem->NewIterator(ro, /*seqno_to_time_mapping=*/nullptr, &arena));
    ROCKS_LOG_DEBUG(immutable_db_options_.info_log,
                    "[%s] [WriteLevel0TableForRecovery]"
                    " Level-0 table #%" PRIu64 ": started",
@@ -1700,8 +1681,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
    meta.oldest_ancester_time = current_time;
    meta.epoch_number = cfd->NewEpochNumber();
    {
-      auto write_hint =
-          cfd->current()->storage_info()->CalculateSSTWriteHint(/*level=*/0);
+      auto write_hint = cfd->CalculateSSTWriteHint(0);
      mutex_.Unlock();

      SequenceNumber earliest_write_conflict_snapshot;
@@ -1716,14 +1696,11 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
      std::vector<std::unique_ptr<FragmentedRangeTombstoneIterator>>
          range_del_iters;
      auto range_del_iter =
-          logical_strip_timestamp
-              ? mem->NewTimestampStrippingRangeTombstoneIterator(
-                    ro, kMaxSequenceNumber, ts_sz)
-              // This is called during recovery, where a live memtable is
-              // flushed directly. In this case, no fragmented tombstone list is
-              // cached in this memtable yet.
-              : mem->NewRangeTombstoneIterator(ro, kMaxSequenceNumber,
-                                               false /* immutable_memtable */);
+          // This is called during recovery, where a live memtable is flushed
+          // directly. In this case, no fragmented tombstone list is cached in
+          // this memtable yet.
+          mem->NewRangeTombstoneIterator(ro, kMaxSequenceNumber,
+                                         false /* immutable_memtable */);
      if (range_del_iter != nullptr) {
        range_del_iters.emplace_back(range_del_iter);
      }
@@ -1737,11 +1714,10 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
          cfd->internal_comparator(), cfd->internal_tbl_prop_coll_factories(),
          GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
          mutable_cf_options.compression_opts, cfd->GetID(), cfd->GetName(),
-          0 /* level */, current_time /* newest_key_time */,
-          false /* is_bottommost */, TableFileCreationReason::kRecovery,
-          0 /* oldest_key_time */, 0 /* file_creation_time */, db_id_,
-          db_session_id_, 0 /* target_file_size */, meta.fd.GetNumber(),
-          kMaxSequenceNumber);
+          0 /* level */, false /* is_bottommost */,
+          TableFileCreationReason::kRecovery, 0 /* oldest_key_time */,
+          0 /* file_creation_time */, db_id_, db_session_id_,
+          0 /* target_file_size */, meta.fd.GetNumber(), kMaxSequenceNumber);
      Version* version = cfd->current();
      version->Ref();
      uint64_t num_input_entries = 0;
@@ -1771,7 +1747,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
        s = io_s;
      }

-      uint64_t total_num_entries = mem->NumEntries();
+      uint64_t total_num_entries = mem->num_entries();
      if (s.ok() && total_num_entries != num_input_entries) {
        std::string msg = "Expected " + std::to_string(total_num_entries) +
                          " entries in memtable, but read " +
@@ -1810,7 +1786,9 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,

    // For UDT in memtable only feature, move up the cutoff timestamp whenever
    // a flush happens.
-    if (logical_strip_timestamp) {
+    const Comparator* ucmp = cfd->user_comparator();
+    size_t ts_sz = ucmp->timestamp_size();
+    if (ts_sz > 0 && !cfd->ioptions()->persist_user_defined_timestamps) {
      Slice mem_newest_udt = mem->GetNewestUDT();
      std::string full_history_ts_low = cfd->GetFullHistoryTsLow();
      if (full_history_ts_low.empty() ||
@@ -2009,7 +1987,46 @@ IOStatus DBImpl::CreateWAL(const WriteOptions& write_options,

 void DBImpl::TrackExistingDataFiles(
    const std::vector<std::string>& existing_data_files) {
-  TrackOrUntrackFiles(existing_data_files, /*track=*/true);
+  auto sfm = static_cast<SstFileManagerImpl*>(
+      immutable_db_options_.sst_file_manager.get());
+  assert(sfm);
+  std::vector<ColumnFamilyMetaData> metadata;
+  GetAllColumnFamilyMetaData(&metadata);
+
+  std::unordered_set<std::string> referenced_files;
+  for (const auto& md : metadata) {
+    for (const auto& lmd : md.levels) {
+      for (const auto& fmd : lmd.files) {
+        // We're assuming that each sst file name exists in at most one of
+        // the paths.
+        std::string file_path =
+            fmd.directory + kFilePathSeparator + fmd.relative_filename;
+        sfm->OnAddFile(file_path, fmd.size).PermitUncheckedError();
+        referenced_files.insert(file_path);
+      }
+    }
+    for (const auto& bmd : md.blob_files) {
+      std::string name = bmd.blob_file_name;
+      // The BlobMetaData.blob_file_name may start with "/".
+      if (!name.empty() && name[0] == kFilePathSeparator) {
+        name = name.substr(1);
+      }
+      // We're assuming that each blob file name exists in at most one of
+      // the paths.
+      std::string file_path = bmd.blob_file_path + kFilePathSeparator + name;
+      sfm->OnAddFile(file_path, bmd.blob_file_size).PermitUncheckedError();
+      referenced_files.insert(file_path);
+    }
+  }
+
+  for (const auto& file_path : existing_data_files) {
+    if (referenced_files.find(file_path) != referenced_files.end()) {
+      continue;
+    }
+    // There shouldn't be any duplicated files. In case there is, SstFileManager
+    // will take care of deduping it.
+    sfm->OnAddFile(file_path).PermitUncheckedError();
+  }
 }

 Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
@@ -2153,13 +2170,6 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
    s = impl->LogAndApplyForRecovery(recovery_ctx);
  }

-  if (s.ok() && !impl->immutable_db_options_.write_identity_file) {
-    // On successful recovery, delete an obsolete IDENTITY file to avoid DB ID
-    // inconsistency
-    impl->env_->DeleteFile(IdentityFileName(impl->dbname_))
-        .PermitUncheckedError();
-  }
-
  if (s.ok() && impl->immutable_db_options_.persist_stats_to_disk) {
    impl->mutex_.AssertHeld();
    s = impl->InitPersistStatsColumnFamily();
@@ -8,7 +8,7 @@
 #include "db/arena_wrapped_db_iter.h"
 #include "db/db_impl/compacted_db_impl.h"
 #include "db/db_impl/db_impl.h"
-#include "db/manifest_ops.h"
+#include "db/db_iter.h"
 #include "db/merge_context.h"
 #include "logging/logging.h"
 #include "monitoring/perf_context_imp.h"
@@ -265,8 +265,8 @@ Status OpenForReadOnlyCheckExistence(const DBOptions& db_options,
    const std::shared_ptr<FileSystem>& fs = db_options.env->GetFileSystem();
    std::string manifest_path;
    uint64_t manifest_file_number;
-    s = GetCurrentManifestPath(dbname, fs.get(), /*is_retry=*/false,
-                               &manifest_path, &manifest_file_number);
+    s = VersionSet::GetCurrentManifestPath(dbname, fs.get(), &manifest_path,
+                                           &manifest_file_number);
  } else {
    // Historic behavior that doesn't necessarily make sense
    s = db_options.env->CreateDirIfMissing(dbname);
@@ -12,8 +12,7 @@
 #include "logging/auto_roll_logger.h"
 #include "logging/logging.h"
 #include "monitoring/perf_context_imp.h"
-#include "rocksdb/convenience.h"
-#include "rocksdb/utilities/options_util.h"
+#include "rocksdb/configurable.h"
 #include "util/cast_util.h"
 #include "util/write_batch_util.h"

@@ -233,8 +232,7 @@ Status DBImplSecondary::RecoverLogFiles(
          reader->GetRecordedTimestampSize();
      status = HandleWriteBatchTimestampSizeDifference(
          &batch, running_ts_sz, record_ts_sz,
-          TimestampSizeConsistencyMode::kVerifyConsistency, seq_per_batch_,
-          batch_per_txn_);
+          TimestampSizeConsistencyMode::kVerifyConsistency);
      if (!status.ok()) {
        break;
      }
@@ -248,7 +246,9 @@ Status DBImplSecondary::RecoverLogFiles(
          if (cfd == nullptr) {
            continue;
          }
-          cfds_changed->insert(cfd);
+          if (cfds_changed->count(cfd) == 0) {
+            cfds_changed->insert(cfd);
+          }
          const std::vector<FileMetaData*>& l0_files =
              cfd->current()->storage_info()->LevelFiles(0);
          SequenceNumber seq =
@@ -938,105 +938,69 @@ Status DB::OpenAndCompact(
    const std::string& output_directory, const std::string& input,
    std::string* output,
    const CompactionServiceOptionsOverride& override_options) {
-  // Check for cancellation
  if (options.canceled && options.canceled->load(std::memory_order_acquire)) {
    return Status::Incomplete(Status::SubCode::kManualCompactionPaused);
  }
-
-  // 1. Deserialize Compaction Input
  CompactionServiceInput compaction_input;
  Status s = CompactionServiceInput::Read(input, &compaction_input);
  if (!s.ok()) {
    return s;
  }

-  // 2. Load the options
-  DBOptions db_options;
-  ConfigOptions config_options;
-  config_options.env = override_options.env;
-  std::vector<ColumnFamilyDescriptor> all_column_families;
-
-  TEST_SYNC_POINT_CALLBACK(
-      "DBImplSecondary::OpenAndCompact::BeforeLoadingOptions:0",
-      &compaction_input.options_file_number);
-  TEST_SYNC_POINT("DBImplSecondary::OpenAndCompact::BeforeLoadingOptions:1");
-  std::string options_file_name =
-      OptionsFileName(name, compaction_input.options_file_number);
-
-  s = LoadOptionsFromFile(config_options, options_file_name, &db_options,
-                          &all_column_families);
-  if (!s.ok()) {
-    return s;
+  compaction_input.db_options.max_open_files = -1;
+  compaction_input.db_options.compaction_service = nullptr;
+  if (compaction_input.db_options.statistics) {
+    compaction_input.db_options.statistics.reset();
  }
-
-  // 3. Override pointer configurations in DBOptions with
-  // CompactionServiceOptionsOverride
-  db_options.env = override_options.env;
-  db_options.file_checksum_gen_factory =
+  compaction_input.db_options.env = override_options.env;
+  compaction_input.db_options.file_checksum_gen_factory =
      override_options.file_checksum_gen_factory;
-  db_options.statistics = override_options.statistics;
-  db_options.listeners = override_options.listeners;
-  db_options.compaction_service = nullptr;
-  // We will close the DB after the compaction anyway.
-  // Open as many files as needed for the compaction.
-  db_options.max_open_files = -1;
+  compaction_input.db_options.statistics = override_options.statistics;
+  compaction_input.column_family.options.comparator =
+      override_options.comparator;
+  compaction_input.column_family.options.merge_operator =
+      override_options.merge_operator;
+  compaction_input.column_family.options.compaction_filter =
+      override_options.compaction_filter;
+  compaction_input.column_family.options.compaction_filter_factory =
+      override_options.compaction_filter_factory;
+  compaction_input.column_family.options.prefix_extractor =
+      override_options.prefix_extractor;
+  compaction_input.column_family.options.table_factory =
+      override_options.table_factory;
+  compaction_input.column_family.options.sst_partitioner_factory =
+      override_options.sst_partitioner_factory;
+  compaction_input.column_family.options.table_properties_collector_factories =
+      override_options.table_properties_collector_factories;
+  compaction_input.db_options.listeners = override_options.listeners;

-  // 4. Filter CFs that are needed for OpenAndCompact()
-  // We do not need to open all column families for the remote compaction.
-  // Only open default CF + target CF. If target CF == default CF, we will open
-  // just the default CF (Due to current limitation, DB cannot open without the
-  // default CF)
  std::vector<ColumnFamilyDescriptor> column_families;
-  for (auto& cf : all_column_families) {
-    if (cf.name == compaction_input.cf_name) {
-      cf.options.comparator = override_options.comparator;
-      cf.options.merge_operator = override_options.merge_operator;
-      cf.options.compaction_filter = override_options.compaction_filter;
-      cf.options.compaction_filter_factory =
-          override_options.compaction_filter_factory;
-      cf.options.prefix_extractor = override_options.prefix_extractor;
-      cf.options.table_factory = override_options.table_factory;
-      cf.options.sst_partitioner_factory =
-          override_options.sst_partitioner_factory;
-      cf.options.table_properties_collector_factories =
-          override_options.table_properties_collector_factories;
-      column_families.emplace_back(cf);
-    } else if (cf.name == kDefaultColumnFamilyName) {
-      column_families.emplace_back(cf);
-    }
+  column_families.push_back(compaction_input.column_family);
+  // TODO: we have to open default CF, because of an implementation limitation,
+  // currently we just use the same CF option from input, which is not collect
+  // and open may fail.
+  if (compaction_input.column_family.name != kDefaultColumnFamilyName) {
+    column_families.emplace_back(kDefaultColumnFamilyName,
+                                 compaction_input.column_family.options);
  }

-  // 5. Open db As Secondary
  DB* db;
  std::vector<ColumnFamilyHandle*> handles;
-  s = DB::OpenAsSecondary(db_options, name, output_directory, column_families,
-                          &handles, &db);
+
+  s = DB::OpenAsSecondary(compaction_input.db_options, name, output_directory,
+                          column_families, &handles, &db);
  if (!s.ok()) {
    return s;
  }
-  assert(db);

-  // 6. Find the handle of the Column Family that this will compact
-  ColumnFamilyHandle* cfh = nullptr;
-  for (auto* handle : handles) {
-    if (compaction_input.cf_name == handle->GetName()) {
-      cfh = handle;
-      break;
-    }
-  }
-  assert(cfh);
-
-  // 7. Run the compaction without installation.
-  // Output will be stored in the directory specified by output_directory
  CompactionServiceResult compaction_result;
  DBImplSecondary* db_secondary = static_cast_with_check<DBImplSecondary>(db);
-  s = db_secondary->CompactWithoutInstallation(options, cfh, compaction_input,
-                                               &compaction_result);
+  assert(handles.size() > 0);
+  s = db_secondary->CompactWithoutInstallation(
+      options, handles[0], compaction_input, &compaction_result);

-  // 8. Serialize the result
  Status serialization_status = compaction_result.Write(output);

-  // 9. Close the db and return
  for (auto& handle : handles) {
    delete handle;
  }
@@ -12,7 +12,6 @@
 #include "db/error_handler.h"
 #include "db/event_helpers.h"
 #include "logging/logging.h"
-#include "memtable/wbwi_memtable.h"
 #include "monitoring/perf_context_imp.h"
 #include "options/options_helper.h"
 #include "test_util/sync_point.h"
@@ -190,137 +189,16 @@ Status DBImpl::WriteWithCallback(const WriteOptions& write_options,
  return s;
 }

-Status DBImpl::IngestWBWI(std::shared_ptr<WriteBatchWithIndex> wbwi,
-                          const WBWIMemTable::SeqnoRange& assigned_seqno,
-                          uint64_t prep_log,
-                          SequenceNumber last_seqno_after_ingest,
-                          bool memtable_updated, bool ignore_missing_cf) {
-  // Keys in new memtable have seqno > last_seqno_after_ingest >= keys in wbwi.
-  assert(assigned_seqno.upper_bound <= last_seqno_after_ingest);
-  // Keys in the current memtable have seqno <= LastSequence() < keys in wbwi.
-  assert(assigned_seqno.lower_bound > versions_->LastSequence());
-  autovector<ReadOnlyMemTable*> memtables;
-  autovector<ColumnFamilyData*> cfds;
-  InstrumentedMutexLock lock(&mutex_);
-  ColumnFamilySet* cf_set = versions_->GetColumnFamilySet();
-
-  // Create WBWIMemTables
-  for (const auto [cf_id, stat] : wbwi->GetCFStats()) {
-    ColumnFamilyData* cfd = cf_set->GetColumnFamily(cf_id);
-    if (!cfd) {
-      if (ignore_missing_cf) {
-        continue;
-      }
-      for (auto mem : memtables) {
-        mem->Unref();
-        delete mem;
-      }
-      for (auto cfd_ptr : cfds) {
-        cfd_ptr->UnrefAndTryDelete();
-      }
-      Status s = Status::InvalidArgument(
-          "Invalid column family id from WriteBatchWithIndex: " +
-          std::to_string(cf_id));
-      if (memtable_updated) {
-        s = Status::Corruption(
-            "Part of the write batch is applied. Memtable is in a inconsistent "
-            "state. " +
-            s.ToString());
-        error_handler_.SetBGError(s, BackgroundErrorReason::kMemTable);
-      }
-
-      return s;
-    }
-    WBWIMemTable* wbwi_memtable =
-        new WBWIMemTable(wbwi, cfd->user_comparator(), cf_id, cfd->ioptions(),
-                         cfd->GetLatestMutableCFOptions(), stat);
-    wbwi_memtable->Ref();
-    wbwi_memtable->AssignSequenceNumbers(assigned_seqno);
-    // This is needed to keep the WAL that contains Prepare alive until
-    // committed data in this memtable is persisted.
-    wbwi_memtable->SetMinPrepLog(prep_log);
-    memtables.push_back(wbwi_memtable);
-    cfd->Ref();
-    cfds.push_back(cfd);
-  }
-
-  // Stop writes to the DB by entering both write threads
-  WriteThread::Writer nonmem_w;
-  if (two_write_queues_) {
-    nonmem_write_thread_.EnterUnbatched(&nonmem_w, &mutex_);
-  }
-  WaitForPendingWrites();
-
-  // Switch memtable and add WBWIMemTables
-  Status s;
-  for (size_t i = 0; i < memtables.size(); ++i) {
-    assert(!immutable_db_options_.atomic_flush);
-    // NOTE: to support atomic flush, need to call
-    // SelectColumnFamiliesForAtomicFlush()
-    WriteContext write_context;
-    // TODO: not switch on empty memtable, may need to update metadata
-    //   like NextLogNumber(), earliest_seqno and memtable id.
-    s = SwitchMemtable(cfds[i], &write_context, memtables[i],
-                       last_seqno_after_ingest);
-    if (!s.ok()) {
-      // SwitchMemtable() can only fail if a new WAL is to be created, this
-      // should only happen for the first call to SwitchMemtable(). log will
-      // be empty and no new WAL is created for the rest of the calls.
-      assert(i == 0);
-      if (i != 0 || memtable_updated) {
-        // escalate error to non-recoverable
-        s = Status::Corruption(
-            "Part of the write batch is applied. Memtable is in a inconsistent "
-            "state. " +
-            s.ToString());
-        error_handler_.SetBGError(s, BackgroundErrorReason::kMemTable);
-      } else {
-        // SwitchMemtable() already sets appropriate bg error
-      }
-      for (size_t j = i; j < memtables.size(); j++) {
-        memtables[j]->Unref();
-        delete memtables[j];
-      }
-      break;
-    }
-  }
-  for (size_t i = 0; i < cfds.size(); ++i) {
-    if (cfds[i]->UnrefAndTryDelete()) {
-      cfds[i] = nullptr;
-    }
-  }
-
-  // exit the second queue before returning
-  if (two_write_queues_) {
-    nonmem_write_thread_.ExitUnbatched(&nonmem_w);
-  }
-  if (s.ok()) {
-    // Trigger flushes for the new immutable memtables.
-    for (const auto cfd : cfds) {
-      if (cfd == nullptr) {
-        continue;
-      }
-      cfd->imm()->FlushRequested();
-      FlushRequest flush_req;
-      // TODO: a new flush reason for ingesting memtable
-      GenerateFlushRequest({cfd}, FlushReason::kExternalFileIngestion,
-                           &flush_req);
-      EnqueuePendingFlush(flush_req);
-    }
-    MaybeScheduleFlushOrCompaction();
-  }
-  return s;
-}
-
+// The main write queue. This is the only write queue that updates LastSequence.
+// When using one write queue, the same sequence also indicates the last
+// published sequence.
 Status DBImpl::WriteImpl(const WriteOptions& write_options,
                         WriteBatch* my_batch, WriteCallback* callback,
                         UserWriteCallback* user_write_cb, uint64_t* log_used,
                         uint64_t log_ref, bool disable_memtable,
                         uint64_t* seq_used, size_t batch_cnt,
                         PreReleaseCallback* pre_release_callback,
-                         PostMemTableCallback* post_memtable_callback,
-                         std::shared_ptr<WriteBatchWithIndex> wbwi,
-                         uint64_t prep_log) {
+                         PostMemTableCallback* post_memtable_callback) {
  assert(!seq_per_batch_ || batch_cnt != 0);
  assert(my_batch == nullptr || my_batch->Count() == 0 ||
         write_options.protection_bytes_per_key == 0 ||
@@ -409,23 +287,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    return Status::NotSupported(
        "DeleteRange is not compatible with row cache.");
  }
-  if (wbwi) {
-    assert(prep_log > 0);
-    // Used only in WriteCommittedTxn::CommitInternal() with no `callback`.
-    assert(!callback);
-    if (immutable_db_options_.unordered_write) {
-      return Status::NotSupported(
-          "Ingesting WriteBatch does not support unordered_write");
-    }
-    if (immutable_db_options_.enable_pipelined_write) {
-      return Status::NotSupported(
-          "Ingesting WriteBatch does not support pipelined_write");
-    }
-    if (immutable_db_options_.atomic_flush) {
-      return Status::NotSupported(
-          "Ingesting WriteBatch does not support atomic_flush");
-    }
-  }
  // Otherwise IsLatestPersistentState optimization does not make sense
  assert(!WriteBatchInternal::IsLatestPersistentState(my_batch) ||
         disable_memtable);
@@ -483,8 +344,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
  PERF_TIMER_GUARD(write_pre_and_post_process_time);
  WriteThread::Writer w(write_options, my_batch, callback, user_write_cb,
                        log_ref, disable_memtable, batch_cnt,
-                        pre_release_callback, post_memtable_callback,
-                        /*_ingest_wbwi=*/wbwi != nullptr);
+                        pre_release_callback, post_memtable_callback);
  StopWatch write_sw(immutable_db_options_.clock, stats_, DB_WRITE);

  write_thread_.JoinBatchGroup(&w);
@@ -581,9 +441,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
  TEST_SYNC_POINT("DBImpl::WriteImpl:BeforeLeaderEnters");
  last_batch_group_size_ =
      write_thread_.EnterAsBatchGroupLeader(&w, &write_group);
-  if (wbwi) {
-    assert(write_group.size == 1);
-  }

  IOStatus io_s;
  Status pre_release_cb_status;
@@ -637,25 +494,10 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // Note about seq_per_batch_: either disableWAL is set for the entire write
    // group or not. In either case we inc seq for each write batch with no
    // failed callback. This means that there could be a batch with
-    // disable_memtable in between; although we do not write this batch to
+    // disalbe_memtable in between; although we do not write this batch to
    // memtable it still consumes a seq. Otherwise, if !seq_per_batch_, we inc
    // the seq per valid written key to mem.
    size_t seq_inc = seq_per_batch_ ? valid_batches : total_count;
-    if (wbwi) {
-      // Reserve sequence numbers for the ingested memtable. We need to reserve
-      // at lease this amount for recovery. During recovery,
-      // transactions do not commit by ingesting WBWI. The sequence number
-      // associated with the commit entry in WAL is used as the starting
-      // sequence number for inserting into memtable. We need to reserve
-      // enough sequence numbers here (at least the number of operations
-      // in write batch) to assign to memtable entries for this transaction.
-      // This prevents updates in different transactions from using out-of-order
-      // sequence numbers or the same key+seqno.
-      //
-      // WBWI ingestion requires not grouping writes, so we don't need to
-      // consider incrementing sequence number for WBWI from other writers.
-      seq_inc += wbwi->GetWriteBatch()->Count();
-    }

    const bool concurrent_update = two_write_queues_;
    // Update stats while we are an exclusive group leader, so we know
@@ -814,7 +656,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,

  if (!io_s.ok()) {
    // Check WriteToWAL status
-    WALIOStatusCheck(io_s);
+    IOStatusCheck(io_s);
  }
  if (!w.CallbackFailed()) {
    if (!io_s.ok()) {
@@ -832,27 +674,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // handle exit, false means somebody else did
    should_exit_batch_group = write_thread_.CompleteParallelMemTableWriter(&w);
  }
-  if (wbwi) {
-    if (status.ok() && w.status.ok()) {
-      // w.batch contains (potentially empty) commit time batch updates,
-      // only ingest wbwi if w.batch is applied to memtable successfully
-      assert(wbwi->GetWriteBatch()->Count() > 0);
-
-      uint32_t memtable_update_count = w.batch->Count();
-      SequenceNumber lb = versions_->LastSequence() + memtable_update_count + 1;
-      SequenceNumber ub = versions_->LastSequence() + memtable_update_count +
-                          wbwi->GetWriteBatch()->Count();
-      assert(ub == last_sequence);
-      if (two_write_queues_) {
-        assert(ub <= versions_->LastAllocatedSequence());
-      }
-      status = IngestWBWI(wbwi, {/*lower_bound=*/lb, /*upper_bound=*/ub},
-                          prep_log, last_sequence,
-                          /*memtable_updated=*/memtable_update_count > 0,
-                          write_options.ignore_missing_column_families);
-    }
-  }
-
  if (should_exit_batch_group) {
    if (status.ok()) {
      for (auto* tmp_w : write_group) {
@@ -866,7 +687,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
        }
      }
      // Note: if we are to resume after non-OK statuses we need to revisit how
-      // we react to non-OK statuses here.
+      // we reacts to non-OK statuses here.
      versions_->SetLastSequence(last_sequence);
    }
    MemTableInsertStatusCheck(w.status);
@@ -914,6 +735,17 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    size_t total_byte_size = 0;

    if (w.status.ok()) {
+      // TODO: this use of operator bool on `tracer_` can avoid unnecessary lock
+      // grabs but does not seem thread-safe.
+      if (tracer_) {
+        InstrumentedMutexLock lock(&trace_mutex_);
+        if (tracer_ != nullptr && tracer_->IsWriteOrderPreserved()) {
+          for (auto* writer : wal_write_group) {
+            // TODO: maybe handle the tracing status?
+            tracer_->Write(writer->batch).PermitUncheckedError();
+          }
+        }
+      }
      SequenceNumber next_sequence = current_sequence;
      for (auto* writer : wal_write_group) {
        assert(writer);
@@ -928,22 +760,6 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
          }
        }
      }
-      // TODO: this use of operator bool on `tracer_` can avoid unnecessary lock
-      // grabs but does not seem thread-safe.
-      if (tracer_) {
-        InstrumentedMutexLock lock(&trace_mutex_);
-        if (tracer_ != nullptr && tracer_->IsWriteOrderPreserved()) {
-          for (auto* writer : wal_write_group) {
-            if (writer->CallbackFailed()) {
-              // When optimisitc txn conflict checking fails, we should
-              // not record to trace.
-              continue;
-            }
-            // TODO: maybe handle the tracing status?
-            tracer_->Write(writer->batch).PermitUncheckedError();
-          }
-        }
-      }
      if (w.disable_wal) {
        has_unpersisted_data_.store(true, std::memory_order_relaxed);
      }
@@ -983,7 +799,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,

    if (!io_s.ok()) {
      // Check WriteToWAL status
-      WALIOStatusCheck(io_s);
+      IOStatusCheck(io_s);
    } else if (!w.CallbackFailed()) {
      WriteStatusCheck(w.status);
    }
@@ -1189,6 +1005,19 @@ Status DBImpl::WriteImplWALOnly(
  WriteThread::WriteGroup write_group;
  uint64_t last_sequence;
  write_thread->EnterAsBatchGroupLeader(&w, &write_group);
+  // Note: no need to update last_batch_group_size_ here since the batch writes
+  // to WAL only
+  // TODO: this use of operator bool on `tracer_` can avoid unnecessary lock
+  // grabs but does not seem thread-safe.
+  if (tracer_) {
+    InstrumentedMutexLock lock(&trace_mutex_);
+    if (tracer_ != nullptr && tracer_->IsWriteOrderPreserved()) {
+      for (auto* writer : write_group) {
+        // TODO: maybe handle the tracing status?
+        tracer_->Write(writer->batch).PermitUncheckedError();
+      }
+    }
+  }

  size_t pre_release_callback_cnt = 0;
  size_t total_byte_size = 0;
@@ -1203,23 +1032,6 @@ Status DBImpl::WriteImplWALOnly(
    }
  }

-  // Note: no need to update last_batch_group_size_ here since the batch writes
-  // to WAL only
-  // TODO: this use of operator bool on `tracer_` can avoid unnecessary lock
-  // grabs but does not seem thread-safe.
-  if (tracer_) {
-    InstrumentedMutexLock lock(&trace_mutex_);
-    if (tracer_ != nullptr && tracer_->IsWriteOrderPreserved()) {
-      for (auto* writer : write_group) {
-        if (writer->CallbackFailed()) {
-          continue;
-        }
-        // TODO: maybe handle the tracing status?
-        tracer_->Write(writer->batch).PermitUncheckedError();
-      }
-    }
-  }
-
  const bool concurrent_update = true;
  // Update stats while we are an exclusive group leader, so we know
  // that nobody else can be writing to these particular stats.
@@ -1265,7 +1077,7 @@ Status DBImpl::WriteImplWALOnly(
    // This error checking and return is moved up to avoid using uninitialized
    // last_sequence.
    if (!io_s.ok()) {
-      WALIOStatusCheck(io_s);
+      IOStatusCheck(io_s);
      write_thread->ExitAsBatchGroupLeader(write_group, status);
      return status;
    }
@@ -1363,7 +1175,7 @@ void DBImpl::WriteStatusCheck(const Status& status) {
  }
 }

-void DBImpl::WALIOStatusCheck(const IOStatus& io_status) {
+void DBImpl::IOStatusCheck(const IOStatus& io_status) {
  // Is setting bg_error_ enough here?  This will at least stop
  // compaction and fail any further writes.
  if ((immutable_db_options_.paranoid_checks && !io_status.ok() &&
@@ -1371,8 +1183,7 @@ void DBImpl::WALIOStatusCheck(const IOStatus& io_status) {
      io_status.IsIOFenced()) {
    mutex_.Lock();
    // Maybe change the return status to void?
-    error_handler_.SetBGError(io_status, BackgroundErrorReason::kWriteCallback,
-                              /*wal_related=*/true);
+    error_handler_.SetBGError(io_status, BackgroundErrorReason::kWriteCallback);
    mutex_.Unlock();
  } else {
    // Force writable file to be continue writable.
@@ -1389,6 +1200,7 @@ void DBImpl::MemTableInsertStatusCheck(const Status& status) {
  if (!status.ok()) {
    mutex_.Lock();
    assert(!error_handler_.IsBGWorkStopped());
+    // Maybe change the return status to void?
    error_handler_.SetBGError(status, BackgroundErrorReason::kMemTable);
    mutex_.Unlock();
  }
@@ -1788,8 +1600,6 @@ IOStatus DBImpl::ConcurrentWriteToWAL(
 Status DBImpl::WriteRecoverableState() {
  mutex_.AssertHeld();
  if (!cached_recoverable_state_empty_) {
-    // Only for write-prepared and write-unprepared.
-    assert(seq_per_batch_);
    bool dont_care_bool;
    SequenceNumber next_seq;
    if (two_write_queues_) {
@@ -1979,13 +1789,13 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
      if (!immutable_db_options_.atomic_flush) {
        FlushRequest flush_req;
        GenerateFlushRequest({cfd}, FlushReason::kWalFull, &flush_req);
-        EnqueuePendingFlush(flush_req);
+        SchedulePendingFlush(flush_req);
      }
    }
    if (immutable_db_options_.atomic_flush) {
      FlushRequest flush_req;
      GenerateFlushRequest(cfds, FlushReason::kWalFull, &flush_req);
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
    }
    MaybeScheduleFlushOrCompaction();
  }
@@ -2071,13 +1881,13 @@ Status DBImpl::HandleWriteBufferManagerFlush(WriteContext* write_context) {
        FlushRequest flush_req;
        GenerateFlushRequest({cfd}, FlushReason::kWriteBufferManager,
                             &flush_req);
-        EnqueuePendingFlush(flush_req);
+        SchedulePendingFlush(flush_req);
      }
    }
    if (immutable_db_options_.atomic_flush) {
      FlushRequest flush_req;
      GenerateFlushRequest(cfds, FlushReason::kWriteBufferManager, &flush_req);
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
    }
    MaybeScheduleFlushOrCompaction();
  }
@@ -2353,12 +2163,12 @@ Status DBImpl::ScheduleFlushes(WriteContext* context) {
      AssignAtomicFlushSeq(cfds);
      FlushRequest flush_req;
      GenerateFlushRequest(cfds, FlushReason::kWriteBufferFull, &flush_req);
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
    } else {
      for (auto* cfd : cfds) {
        FlushRequest flush_req;
        GenerateFlushRequest({cfd}, FlushReason::kWriteBufferFull, &flush_req);
-        EnqueuePendingFlush(flush_req);
+        SchedulePendingFlush(flush_req);
      }
    }
    MaybeScheduleFlushOrCompaction();
@@ -2382,13 +2192,16 @@ void DBImpl::NotifyOnMemTableSealed(ColumnFamilyData* /*cfd*/,
  mutex_.Lock();
 }

-Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
-                              ReadOnlyMemTable* new_imm,
-                              SequenceNumber last_seqno) {
+// REQUIRES: mutex_ is held
+// REQUIRES: this thread is currently at the front of the writer queue
+// REQUIRES: this thread is currently at the front of the 2nd writer queue if
+// two_write_queues_ is true (This is to simplify the reasoning.)
+Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
  mutex_.AssertHeld();
  assert(lock_wal_count_ == 0);

  // TODO: plumb Env::IOActivity, Env::IOPriority
+  const ReadOptions read_options;
  const WriteOptions write_options;

  log::Writer* new_log = nullptr;
@@ -2424,13 +2237,12 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
  const MutableCFOptions mutable_cf_options = *cfd->GetLatestMutableCFOptions();

  // Set memtable_info for memtable sealed callback
-  // TODO: memtable_info for `new_imm`
  MemTableInfo memtable_info;
  memtable_info.cf_name = cfd->GetName();
  memtable_info.first_seqno = cfd->mem()->GetFirstSequenceNumber();
  memtable_info.earliest_seqno = cfd->mem()->GetEarliestSequenceNumber();
-  memtable_info.num_entries = cfd->mem()->NumEntries();
-  memtable_info.num_deletes = cfd->mem()->NumDeletion();
+  memtable_info.num_entries = cfd->mem()->num_entries();
+  memtable_info.num_deletes = cfd->mem()->num_deletes();
  if (!cfd->ioptions()->persist_user_defined_timestamps &&
      cfd->user_comparator()->timestamp_size() > 0) {
    const Slice& newest_udt = cfd->mem()->GetNewestUDT();
@@ -2452,20 +2264,8 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
    }
  }
  if (s.ok()) {
-    // FIXME: from the comment for GetEarliestSequenceNumber(), any key with
-    //  seqno >= earliest_seqno should be in this or later memtable. This means
-    //  we should use LastSequence() + 1 or last_seqno + 1 here. And it needs to
-    //  be incremented with file ingestion and other operations that consumes
-    //  sequence number.
-    SequenceNumber seq;
-    if (new_imm) {
-      assert(last_seqno > versions_->LastSequence());
-      seq = last_seqno;
-    } else {
-      seq = versions_->LastSequence();
-    }
-    new_mem =
-        cfd->ConstructNewMemtable(mutable_cf_options, /*earliest_seq=*/seq);
+    SequenceNumber seq = versions_->LastSequence();
+    new_mem = cfd->ConstructNewMemtable(mutable_cf_options, seq);
    context->superversion_context.NewSuperVersion();

    ROCKS_LOG_INFO(immutable_db_options_.info_log,
@@ -2526,8 +2326,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
    // We may have lost data from the WritableFileBuffer in-memory buffer for
    // the current log, so treat it as a fatal error and set bg_error
    if (!io_s.ok()) {
-      error_handler_.SetBGError(io_s, BackgroundErrorReason::kMemTable,
-                                /*wal_related=*/true);
+      error_handler_.SetBGError(io_s, BackgroundErrorReason::kMemTable);
    } else {
      error_handler_.SetBGError(s, BackgroundErrorReason::kMemTable);
    }
@@ -2547,8 +2346,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
        versions_->PreComputeMinLogNumberWithUnflushedData(logfile_number_);
    if (min_wal_number_to_keep >
        versions_->GetWalSet().GetMinWalNumberToKeep()) {
-      // TODO: plumb Env::IOActivity, Env::IOPriority
-      const ReadOptions read_options;
      // Get a snapshot of the empty column families.
      // LogAndApply may release and reacquire db
      // mutex, during that period, column family may become empty (e.g. its
@@ -2606,18 +2403,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
  cfd->mem()->SetNextLogNumber(logfile_number_);
  assert(new_mem != nullptr);
  cfd->imm()->Add(cfd->mem(), &context->memtables_to_free_);
-  if (new_imm) {
-    // Need to assign memtable id here before SetMemtable() below assigns id to
-    // the new live memtable
-    cfd->AssignMemtableID(new_imm);
-    // NOTE: new_imm and cfd->mem() references the same WAL and has the same
-    // NextLogNumber(). They should be flushed together. For non-atomic-flush,
-    // we always try to flush all immutable memtable. For atomic flush, these
-    // two memtables will be marked eligible for flush in the same call to
-    // AssignAtomicFlushSeq().
-    new_imm->SetNextLogNumber(logfile_number_);
-    cfd->imm()->Add(new_imm, &context->memtables_to_free_);
-  }
  new_mem->Ref();
  cfd->SetMemtable(new_mem);
  InstallSuperVersionAndScheduleWork(cfd, &context->superversion_context,
@@ -2630,9 +2415,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
  // that is okay.  If we did, it most likely means that s was already an error.
  // In any case, ignore any unchecked error for i_os here.
  io_s.PermitUncheckedError();
-  // We guarantee that if a non-ok status is returned, `new_imm` was not added
-  // to the db.
-  assert(s.ok());
  return s;
 }

@@ -27,14 +27,12 @@ class CorruptionFS : public FileSystemWrapper {
        num_writable_file_errors_(0),
        corruption_trigger_(INT_MAX),
        read_count_(0),
-        corrupt_offset_(0),
-        corrupt_len_(0),
        rnd_(300),
        fs_buffer_(fs_buffer),
        verify_read_(verify_read) {}
  ~CorruptionFS() override {
    // Assert that the corruption was reset, which means it got triggered
-    assert(corruption_trigger_ == INT_MAX || corrupt_len_ > 0);
+    assert(corruption_trigger_ == INT_MAX);
  }
  const char* Name() const override { return "ErrorEnv"; }

@@ -50,10 +48,8 @@ class CorruptionFS : public FileSystemWrapper {
  }

  void SetCorruptionTrigger(const int trigger) {
-    MutexLock l(&mutex_);
    corruption_trigger_ = trigger;
    read_count_ = 0;
-    corrupt_fname_.clear();
  }

  IOStatus NewRandomAccessFile(const std::string& fname,
@@ -62,31 +58,25 @@ class CorruptionFS : public FileSystemWrapper {
                               IODebugContext* dbg) override {
    class CorruptionRandomAccessFile : public FSRandomAccessFileOwnerWrapper {
     public:
-      CorruptionRandomAccessFile(CorruptionFS& fs, const std::string& fname,
+      CorruptionRandomAccessFile(CorruptionFS& fs,
                                 std::unique_ptr<FSRandomAccessFile>& file)
-          : FSRandomAccessFileOwnerWrapper(std::move(file)),
-            fs_(fs),
-            fname_(fname) {}
+          : FSRandomAccessFileOwnerWrapper(std::move(file)), fs_(fs) {}

      IOStatus Read(uint64_t offset, size_t len, const IOOptions& opts,
                    Slice* result, char* scratch,
                    IODebugContext* dbg) const override {
        IOStatus s = target()->Read(offset, len, opts, result, scratch, dbg);
        if (opts.verify_and_reconstruct_read) {
-          fs_.MaybeResetOverlapWithCorruptedChunk(fname_, offset,
-                                                  result->size());
          return s;
        }
-
-        MutexLock l(&fs_.mutex_);
        if (s.ok() && ++fs_.read_count_ >= fs_.corruption_trigger_) {
+          fs_.read_count_ = 0;
          fs_.corruption_trigger_ = INT_MAX;
          char* data = const_cast<char*>(result->data());
          std::memcpy(
              data,
              fs_.rnd_.RandomString(static_cast<int>(result->size())).c_str(),
              result->size());
-          fs_.SetCorruptedChunk(fname_, offset, result->size());
        }
        return s;
      }
@@ -111,76 +101,14 @@ class CorruptionFS : public FileSystemWrapper {
        return IOStatus::OK();
      }

-      IOStatus Prefetch(uint64_t /*offset*/, size_t /*n*/,
-                        const IOOptions& /*options*/,
-                        IODebugContext* /*dbg*/) override {
-        return IOStatus::NotSupported("Prefetch");
-      }
-
     private:
      CorruptionFS& fs_;
-      std::string fname_;
    };

    std::unique_ptr<FSRandomAccessFile> file;
    IOStatus s = target()->NewRandomAccessFile(fname, opts, &file, dbg);
    EXPECT_OK(s);
-    result->reset(new CorruptionRandomAccessFile(*this, fname, file));
-
-    return s;
-  }
-
-  IOStatus NewSequentialFile(const std::string& fname,
-                             const FileOptions& file_opts,
-                             std::unique_ptr<FSSequentialFile>* result,
-                             IODebugContext* dbg) override {
-    class CorruptionSequentialFile : public FSSequentialFileOwnerWrapper {
-     public:
-      CorruptionSequentialFile(CorruptionFS& fs, const std::string& fname,
-                               std::unique_ptr<FSSequentialFile>& file)
-          : FSSequentialFileOwnerWrapper(std::move(file)),
-            fs_(fs),
-            fname_(fname),
-            offset_(0) {}
-
-      IOStatus Read(size_t len, const IOOptions& opts, Slice* result,
-                    char* scratch, IODebugContext* dbg) override {
-        IOStatus s = target()->Read(len, opts, result, scratch, dbg);
-        if (result->size() == 0 ||
-            fname_.find("IDENTITY") != std::string::npos) {
-          return s;
-        }
-
-        if (opts.verify_and_reconstruct_read) {
-          fs_.MaybeResetOverlapWithCorruptedChunk(fname_, offset_,
-                                                  result->size());
-          return s;
-        }
-
-        MutexLock l(&fs_.mutex_);
-        if (s.ok() && ++fs_.read_count_ >= fs_.corruption_trigger_) {
-          fs_.corruption_trigger_ = INT_MAX;
-          char* data = const_cast<char*>(result->data());
-          std::memcpy(
-              data,
-              fs_.rnd_.RandomString(static_cast<int>(result->size())).c_str(),
-              result->size());
-          fs_.SetCorruptedChunk(fname_, offset_, result->size());
-        }
-        offset_ += result->size();
-        return s;
-      }
-
-     private:
-      CorruptionFS& fs_;
-      std::string fname_;
-      size_t offset_;
-    };
-
-    std::unique_ptr<FSSequentialFile> file;
-    IOStatus s = target()->NewSequentialFile(fname, file_opts, &file, dbg);
-    EXPECT_OK(s);
-    result->reset(new CorruptionSequentialFile(*this, fname, file));
+    result->reset(new CorruptionRandomAccessFile(*this, file));

    return s;
  }
@@ -195,40 +123,12 @@ class CorruptionFS : public FileSystemWrapper {
    }
  }

-  void SetCorruptedChunk(const std::string& fname, size_t offset, size_t len) {
-    assert(corrupt_fname_.empty());
-
-    corrupt_fname_ = fname;
-    corrupt_offset_ = offset;
-    corrupt_len_ = len;
-  }
-
-  void MaybeResetOverlapWithCorruptedChunk(const std::string& fname,
-                                           size_t offset, size_t len) {
-    if (fname == corrupt_fname_ &&
-        ((offset <= corrupt_offset_ && (offset + len) > corrupt_offset_) ||
-         (offset >= corrupt_offset_ &&
-          offset < (corrupt_offset_ + corrupt_len_)))) {
-      corrupt_fname_.clear();
-    }
-  }
-
-  bool VerifyRetry() { return corrupt_len_ > 0 && corrupt_fname_.empty(); }
-
-  int read_count() { return read_count_; }
-
-  int corruption_trigger() { return corruption_trigger_; }
-
 private:
  int corruption_trigger_;
  int read_count_;
-  std::string corrupt_fname_;
-  size_t corrupt_offset_;
-  size_t corrupt_len_;
  Random rnd_;
  bool fs_buffer_;
  bool verify_read_;
-  port::Mutex mutex_;
 };
 }  // anonymous namespace

@@ -817,7 +717,6 @@ class DBIOCorruptionTest
    bbto.num_file_reads_for_auto_readahead = 0;
    options_.table_factory.reset(NewBlockBasedTableFactory(bbto));
    options_.disable_auto_compactions = true;
-    options_.max_file_opening_threads = 0;

    Reopen(options_);
  }
@@ -958,8 +857,8 @@ TEST_P(DBIOCorruptionTest, FlushReadCorruptionRetry) {
  Status s = Flush();
  if (std::get<2>(GetParam())) {
    ASSERT_OK(s);
-    ASSERT_GT(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_GT(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
+    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
+    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
              1);

    std::string val;
@@ -986,8 +885,8 @@ TEST_P(DBIOCorruptionTest, ManifestCorruptionRetry) {

  if (std::get<2>(GetParam())) {
    ASSERT_OK(ReopenDB());
-    ASSERT_GT(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_GT(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
+    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
+    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
              1);
  } else {
    ASSERT_EQ(ReopenDB(), Status::Corruption());
@@ -1071,57 +970,6 @@ TEST_P(DBIOCorruptionTest, TablePropertiesCorruptionRetry) {
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
 }

-TEST_P(DBIOCorruptionTest, DBOpenReadCorruptionRetry) {
-  if (!std::get<2>(GetParam())) {
-    return;
-  }
-  CorruptionFS* fs =
-      static_cast<CorruptionFS*>(env_guard_->GetFileSystem().get());
-
-  for (int sst = 0; sst < 3; ++sst) {
-    for (int key = 0; key < 100; ++key) {
-      std::stringstream ss;
-      ss << std::setw(3) << 100 * sst + key;
-      ASSERT_OK(Put("key" + ss.str(), "val" + ss.str()));
-    }
-    ASSERT_OK(Flush());
-  }
-  Close();
-
-  // DB open will create table readers unless we reduce the table cache
-  // capacity.
-  // SanitizeOptions will set max_open_files to minimum of 20. Table cache
-  // is allocated with max_open_files - 10 as capacity. So override
-  // max_open_files to 11 so table cache capacity will become 1. This will
-  // prevent file open during DB open and force the file to be opened
-  // during MultiGet
-  SyncPoint::GetInstance()->SetCallBack(
-      "SanitizeOptions::AfterChangeMaxOpenFiles", [&](void* arg) {
-        int* max_open_files = (int*)arg;
-        *max_open_files = 11;
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // Progressively increase the IO count trigger for corruption, and verify
-  // that it was retried
-  int corruption_trigger = 1;
-  fs->SetCorruptionTrigger(corruption_trigger);
-  do {
-    fs->SetCorruptionTrigger(corruption_trigger);
-    ASSERT_OK(ReopenDB());
-    for (int sst = 0; sst < 3; ++sst) {
-      for (int key = 0; key < 100; ++key) {
-        std::stringstream ss;
-        ss << std::setw(3) << 100 * sst + key;
-        ASSERT_EQ(Get("key" + ss.str()), "val" + ss.str());
-      }
-    }
-    // Verify that the injected corruption was repaired
-    ASSERT_TRUE(fs->VerifyRetry());
-    corruption_trigger++;
-  } while (fs->corruption_trigger() == INT_MAX);
-}
-
 // The parameters are - 1. Use FS provided buffer, 2. Use async IO ReadOption,
 // 3. Retry with verify_and_reconstruct_read IOOption
 INSTANTIATE_TEST_CASE_P(DBIOCorruptionTest, DBIOCorruptionTest,
@@ -52,9 +52,7 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
      user_comparator_(cmp),
      merge_operator_(ioptions.merge_operator.get()),
      iter_(iter),
-      blob_reader_(version, read_options.read_tier,
-                   read_options.verify_checksums, read_options.fill_cache,
-                   read_options.io_activity),
+      version_(version),
      read_callback_(read_callback),
      sequence_(s),
      statistics_(ioptions.stats),
@@ -67,16 +65,20 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
      valid_(false),
      current_entry_is_merged_(false),
      is_key_seqnum_zero_(false),
-      prefix_same_as_start_(
-          prefix_extractor_ ? read_options.prefix_same_as_start : false),
+      prefix_same_as_start_(mutable_cf_options.prefix_extractor
+                                ? read_options.prefix_same_as_start
+                                : false),
      pin_thru_lifetime_(read_options.pin_data),
      expect_total_order_inner_iter_(prefix_extractor_ == nullptr ||
                                     read_options.total_order_seek ||
                                     read_options.auto_prefix_mode),
+      read_tier_(read_options.read_tier),
+      fill_cache_(read_options.fill_cache),
+      verify_checksums_(read_options.verify_checksums),
      expose_blob_index_(expose_blob_index),
-      allow_unprepared_value_(read_options.allow_unprepared_value),
      is_blob_(false),
      arena_mode_(arena_mode),
+      io_activity_(read_options.io_activity),
      cfh_(cfh),
      timestamp_ub_(read_options.timestamp),
      timestamp_lb_(read_options.iter_start_ts),
@@ -91,9 +93,6 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
  status_.PermitUncheckedError();
  assert(timestamp_size_ ==
         user_comparator_.user_comparator()->timestamp_size());
-  // prefix_seek_opt_in_only should force total_order_seek whereever the caller
-  // is duplicating the original ReadOptions
-  assert(!ioptions.prefix_seek_opt_in_only || read_options.total_order_seek);
 }

 Status DBIter::GetProperty(std::string prop_name, std::string* prop) {
@@ -150,7 +149,7 @@ void DBIter::Next() {
  PERF_CPU_TIMER_GUARD(iter_next_cpu_nanos, clock_);
  // Release temporarily pinned blocks from last operation
  ReleaseTempPinnedData();
-  ResetBlobData();
+  ResetBlobValue();
  ResetValueAndColumns();
  local_stats_.skip_count_ += num_internal_keys_skipped_;
  local_stats_.skip_count_--;
@@ -193,21 +192,29 @@ void DBIter::Next() {
  }
 }

-Status DBIter::BlobReader::RetrieveAndSetBlobValue(const Slice& user_key,
-                                                   const Slice& blob_index) {
+bool DBIter::SetBlobValueIfNeeded(const Slice& user_key,
+                                  const Slice& blob_index) {
+  assert(!is_blob_);
  assert(blob_value_.empty());

+  if (expose_blob_index_) {  // Stacked BlobDB implementation
+    is_blob_ = true;
+    return true;
+  }
+
  if (!version_) {
-    return Status::Corruption("Encountered unexpected blob index.");
+    status_ = Status::Corruption("Encountered unexpected blob index.");
+    valid_ = false;
+    return false;
  }

  // TODO: consider moving ReadOptions from ArenaWrappedDBIter to DBIter to
  // avoid having to copy options back and forth.
-  // TODO: plumb Env::IOPriority
+  // TODO: plumb Env::IOActivity, Env::IOPriority
  ReadOptions read_options;
  read_options.read_tier = read_tier_;
-  read_options.verify_checksums = verify_checksums_;
  read_options.fill_cache = fill_cache_;
+  read_options.verify_checksums = verify_checksums_;
  read_options.io_activity = io_activity_;
  constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
  constexpr uint64_t* bytes_read = nullptr;
@@ -215,49 +222,14 @@ Status DBIter::BlobReader::RetrieveAndSetBlobValue(const Slice& user_key,
  const Status s = version_->GetBlob(read_options, user_key, blob_index,
                                     prefetch_buffer, &blob_value_, bytes_read);

-  if (!s.ok()) {
-    return s;
-  }
-
-  return Status::OK();
-}
-
-bool DBIter::SetValueAndColumnsFromBlobImpl(const Slice& user_key,
-                                            const Slice& blob_index) {
-  const Status s = blob_reader_.RetrieveAndSetBlobValue(user_key, blob_index);
  if (!s.ok()) {
    status_ = s;
    valid_ = false;
-    is_blob_ = false;
    return false;
  }

-  SetValueAndColumnsFromPlain(blob_reader_.GetBlobValue());
-
-  return true;
-}
-
-bool DBIter::SetValueAndColumnsFromBlob(const Slice& user_key,
-                                        const Slice& blob_index) {
-  assert(!is_blob_);
  is_blob_ = true;
-
-  if (expose_blob_index_) {
-    SetValueAndColumnsFromPlain(blob_index);
-    return true;
-  }
-
-  if (allow_unprepared_value_) {
-    assert(value_.empty());
-    assert(wide_columns_.empty());
-
-    assert(lazy_blob_index_.empty());
-    lazy_blob_index_ = blob_index;
-
-    return true;
-  }
-
-  return SetValueAndColumnsFromBlobImpl(user_key, blob_index);
+  return true;
 }

 bool DBIter::SetValueAndColumnsFromEntity(Slice slice) {
@@ -305,24 +277,6 @@ bool DBIter::SetValueAndColumnsFromMergeResult(const Status& merge_status,
  return true;
 }

-bool DBIter::PrepareValue() {
-  assert(valid_);
-
-  if (lazy_blob_index_.empty()) {
-    return true;
-  }
-
-  assert(allow_unprepared_value_);
-  assert(is_blob_);
-
-  const bool result =
-      SetValueAndColumnsFromBlobImpl(saved_key_.GetUserKey(), lazy_blob_index_);
-
-  lazy_blob_index_.clear();
-
-  return result;
-}
-
 // PRE: saved_key_ has the current user key if skipping_saved_key
 // POST: saved_key_ should have the next user key if valid_,
 //       if the current entry is a result of merge
@@ -452,7 +406,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
          case kTypeValuePreferredSeqno:
          case kTypeBlobIndex:
          case kTypeWideColumnEntity:
-            if (!PrepareValueInternal()) {
+            if (!PrepareValue()) {
              return false;
            }
            if (timestamp_lb_) {
@@ -464,9 +418,12 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
            }

            if (ikey_.type == kTypeBlobIndex) {
-              if (!SetValueAndColumnsFromBlob(ikey_.user_key, iter_.value())) {
+              if (!SetBlobValueIfNeeded(ikey_.user_key, iter_.value())) {
                return false;
              }
+
+              SetValueAndColumnsFromPlain(expose_blob_index_ ? iter_.value()
+                                                             : blob_value_);
            } else if (ikey_.type == kTypeWideColumnEntity) {
              if (!SetValueAndColumnsFromEntity(iter_.value())) {
                return false;
@@ -486,7 +443,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
            return true;
            break;
          case kTypeMerge:
-            if (!PrepareValueInternal()) {
+            if (!PrepareValue()) {
              return false;
            }
            saved_key_.SetUserKey(
@@ -581,14 +538,8 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
    } else {
      iter_.Next();
    }
-
    // This could be a long-running operation due to tombstones, etc.
-    bool aborted = ROCKSDB_THREAD_YIELD_CHECK_ABORT();
-    if (aborted) {
-      valid_ = false;
-      status_ = Status::Aborted("Query abort.");
-      return false;
-    }
+    ROCKSDB_THREAD_YIELD_HOOK();
  } while (iter_.Valid());

  valid_ = false;
@@ -639,7 +590,7 @@ bool DBIter::MergeValuesNewToOld() {
      iter_.Next();
      break;
    }
-    if (!PrepareValueInternal()) {
+    if (!PrepareValue()) {
      return false;
    }

@@ -668,9 +619,23 @@ bool DBIter::MergeValuesNewToOld() {
          iter_.value(), iter_.iter()->IsValuePinned() /* operand_pinned */);
      PERF_COUNTER_ADD(internal_merge_count, 1);
    } else if (kTypeBlobIndex == ikey.type) {
-      if (!MergeWithBlobBaseValue(iter_.value(), ikey.user_key)) {
+      if (expose_blob_index_) {
+        status_ =
+            Status::NotSupported("BlobDB does not support merge operator.");
+        valid_ = false;
        return false;
      }
+      // hit a put, merge the put value with operands and store the
+      // final result in saved_value_. We are done!
+      if (!SetBlobValueIfNeeded(ikey.user_key, iter_.value())) {
+        return false;
+      }
+      valid_ = true;
+      if (!MergeWithPlainBaseValue(blob_value_, ikey.user_key)) {
+        return false;
+      }
+
+      ResetBlobValue();

      // iter_ is positioned after put
      iter_.Next();
@@ -678,7 +643,6 @@ bool DBIter::MergeValuesNewToOld() {
        valid_ = false;
        return false;
      }
-
      return true;
    } else if (kTypeWideColumnEntity == ikey.type) {
      if (!MergeWithWideColumnBaseValue(iter_.value(), ikey.user_key)) {
@@ -725,7 +689,7 @@ void DBIter::Prev() {
  PERF_COUNTER_ADD(iter_prev_count, 1);
  PERF_CPU_TIMER_GUARD(iter_prev_cpu_nanos, clock_);
  ReleaseTempPinnedData();
-  ResetBlobData();
+  ResetBlobValue();
  ResetValueAndColumns();
  ResetInternalKeysSkippedCounter();
  bool ok = true;
@@ -962,7 +926,7 @@ bool DBIter::FindValueForCurrentKey() {
      return FindValueForCurrentKeyUsingSeek();
    }

-    if (!PrepareValueInternal()) {
+    if (!PrepareValue()) {
      return false;
    }

@@ -1077,9 +1041,21 @@ bool DBIter::FindValueForCurrentKey() {
        }
        return true;
      } else if (last_not_merge_type == kTypeBlobIndex) {
-        if (!MergeWithBlobBaseValue(pinned_value_, saved_key_.GetUserKey())) {
+        if (expose_blob_index_) {
+          status_ =
+              Status::NotSupported("BlobDB does not support merge operator.");
+          valid_ = false;
          return false;
        }
+        if (!SetBlobValueIfNeeded(saved_key_.GetUserKey(), pinned_value_)) {
+          return false;
+        }
+        valid_ = true;
+        if (!MergeWithPlainBaseValue(blob_value_, saved_key_.GetUserKey())) {
+          return false;
+        }
+
+        ResetBlobValue();

        return true;
      } else if (last_not_merge_type == kTypeWideColumnEntity) {
@@ -1104,9 +1080,13 @@ bool DBIter::FindValueForCurrentKey() {

      break;
    case kTypeBlobIndex:
-      if (!SetValueAndColumnsFromBlob(saved_key_.GetUserKey(), pinned_value_)) {
+      if (!SetBlobValueIfNeeded(saved_key_.GetUserKey(), pinned_value_)) {
        return false;
      }
+
+      SetValueAndColumnsFromPlain(expose_blob_index_ ? pinned_value_
+                                                     : blob_value_);
+
      break;
    case kTypeWideColumnEntity:
      if (!SetValueAndColumnsFromEntity(pinned_value_)) {
@@ -1193,7 +1173,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
    }
    return true;
  }
-  if (!PrepareValueInternal()) {
+  if (!PrepareValue()) {
    return false;
  }
  if (timestamp_size_ > 0) {
@@ -1210,9 +1190,12 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
      pinned_value_ = iter_.value();
    }
    if (ikey.type == kTypeBlobIndex) {
-      if (!SetValueAndColumnsFromBlob(ikey.user_key, pinned_value_)) {
+      if (!SetBlobValueIfNeeded(ikey.user_key, pinned_value_)) {
        return false;
      }
+
+      SetValueAndColumnsFromPlain(expose_blob_index_ ? pinned_value_
+                                                     : blob_value_);
    } else if (ikey.type == kTypeWideColumnEntity) {
      if (!SetValueAndColumnsFromEntity(pinned_value_)) {
        return false;
@@ -1260,7 +1243,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
        ikey.type == kTypeDeletionWithTimestamp) {
      break;
    }
-    if (!PrepareValueInternal()) {
+    if (!PrepareValue()) {
      return false;
    }

@@ -1278,9 +1261,21 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
          iter_.value(), iter_.iter()->IsValuePinned() /* operand_pinned */);
      PERF_COUNTER_ADD(internal_merge_count, 1);
    } else if (ikey.type == kTypeBlobIndex) {
-      if (!MergeWithBlobBaseValue(iter_.value(), saved_key_.GetUserKey())) {
+      if (expose_blob_index_) {
+        status_ =
+            Status::NotSupported("BlobDB does not support merge operator.");
+        valid_ = false;
        return false;
      }
+      if (!SetBlobValueIfNeeded(ikey.user_key, iter_.value())) {
+        return false;
+      }
+      valid_ = true;
+      if (!MergeWithPlainBaseValue(blob_value_, saved_key_.GetUserKey())) {
+        return false;
+      }
+
+      ResetBlobValue();

      return true;
    } else if (ikey.type == kTypeWideColumnEntity) {
@@ -1347,35 +1342,6 @@ bool DBIter::MergeWithPlainBaseValue(const Slice& value,
  return SetValueAndColumnsFromMergeResult(s, result_type);
 }

-bool DBIter::MergeWithBlobBaseValue(const Slice& blob_index,
-                                    const Slice& user_key) {
-  assert(!is_blob_);
-
-  if (expose_blob_index_) {
-    status_ =
-        Status::NotSupported("Legacy BlobDB does not support merge operator.");
-    valid_ = false;
-    return false;
-  }
-
-  const Status s = blob_reader_.RetrieveAndSetBlobValue(user_key, blob_index);
-  if (!s.ok()) {
-    status_ = s;
-    valid_ = false;
-    return false;
-  }
-
-  valid_ = true;
-
-  if (!MergeWithPlainBaseValue(blob_reader_.GetBlobValue(), user_key)) {
-    return false;
-  }
-
-  blob_reader_.ResetBlobValue();
-
-  return true;
-}
-
 bool DBIter::MergeWithWideColumnBaseValue(const Slice& entity,
                                          const Slice& user_key) {
  // `op_failure_scope` (an output parameter) is not provided (set to nullptr)
@@ -1565,7 +1531,7 @@ void DBIter::Seek(const Slice& target) {

  status_ = Status::OK();
  ReleaseTempPinnedData();
-  ResetBlobData();
+  ResetBlobValue();
  ResetValueAndColumns();
  ResetInternalKeysSkippedCounter();

@@ -1641,7 +1607,7 @@ void DBIter::SeekForPrev(const Slice& target) {

  status_ = Status::OK();
  ReleaseTempPinnedData();
-  ResetBlobData();
+  ResetBlobValue();
  ResetValueAndColumns();
  ResetInternalKeysSkippedCounter();

@@ -1702,7 +1668,7 @@ void DBIter::SeekToFirst() {
  status_.PermitUncheckedError();
  direction_ = kForward;
  ReleaseTempPinnedData();
-  ResetBlobData();
+  ResetBlobValue();
  ResetValueAndColumns();
  ResetInternalKeysSkippedCounter();
  ClearSavedValue();
@@ -1765,7 +1731,7 @@ void DBIter::SeekToLast() {
  status_.PermitUncheckedError();
  direction_ = kReverse;
  ReleaseTempPinnedData();
-  ResetBlobData();
+  ResetBlobValue();
  ResetValueAndColumns();
  ResetInternalKeysSkippedCounter();
  ClearSavedValue();
@@ -218,34 +218,7 @@ class DBIter final : public Iterator {
  }
  void set_valid(bool v) { valid_ = v; }

-  bool PrepareValue() override;
-
 private:
-  class BlobReader {
-   public:
-    BlobReader(const Version* version, ReadTier read_tier,
-               bool verify_checksums, bool fill_cache,
-               Env::IOActivity io_activity)
-        : version_(version),
-          read_tier_(read_tier),
-          verify_checksums_(verify_checksums),
-          fill_cache_(fill_cache),
-          io_activity_(io_activity) {}
-
-    const Slice& GetBlobValue() const { return blob_value_; }
-    Status RetrieveAndSetBlobValue(const Slice& user_key,
-                                   const Slice& blob_index);
-    void ResetBlobValue() { blob_value_.Reset(); }
-
-   private:
-    PinnableSlice blob_value_;
-    const Version* version_;
-    ReadTier read_tier_;
-    bool verify_checksums_;
-    bool fill_cache_;
-    Env::IOActivity io_activity_;
-  };
-
  // For all methods in this block:
  // PRE: iter_->Valid() && status_.ok()
  // Return false if there was an error, and status() is non-ok, valid_ = false;
@@ -326,6 +299,15 @@ class DBIter final : public Iterator {
               : user_comparator_.CompareWithoutTimestamp(a, b);
  }

+  // Retrieves the blob value for the specified user key using the given blob
+  // index when using the integrated BlobDB implementation.
+  bool SetBlobValueIfNeeded(const Slice& user_key, const Slice& blob_index);
+
+  void ResetBlobValue() {
+    is_blob_ = false;
+    blob_value_.Reset();
+  }
+
  void SetValueAndColumnsFromPlain(const Slice& slice) {
    assert(value_.empty());
    assert(wide_columns_.empty());
@@ -334,11 +316,6 @@ class DBIter final : public Iterator {
    wide_columns_.emplace_back(kDefaultWideColumnName, slice);
  }

-  bool SetValueAndColumnsFromBlobImpl(const Slice& user_key,
-                                      const Slice& blob_index);
-  bool SetValueAndColumnsFromBlob(const Slice& user_key,
-                                  const Slice& blob_index);
-
  bool SetValueAndColumnsFromEntity(Slice slice);

  bool SetValueAndColumnsFromMergeResult(const Status& merge_status,
@@ -349,21 +326,14 @@ class DBIter final : public Iterator {
    wide_columns_.clear();
  }

-  void ResetBlobData() {
-    blob_reader_.ResetBlobValue();
-    lazy_blob_index_.clear();
-    is_blob_ = false;
-  }
-
  // The following methods perform the actual merge operation for the
-  // no/plain/blob/wide-column base value cases.
+  // no base value/plain base value/wide-column base value cases.
  // If user-defined timestamp is enabled, `user_key` includes timestamp.
  bool MergeWithNoBaseValue(const Slice& user_key);
  bool MergeWithPlainBaseValue(const Slice& value, const Slice& user_key);
-  bool MergeWithBlobBaseValue(const Slice& blob_index, const Slice& user_key);
  bool MergeWithWideColumnBaseValue(const Slice& entity, const Slice& user_key);

-  bool PrepareValueInternal() {
+  bool PrepareValue() {
    if (!iter_.PrepareValue()) {
      assert(!iter_.status().ok());
      valid_ = false;
@@ -386,7 +356,7 @@ class DBIter final : public Iterator {
  UserComparatorWrapper user_comparator_;
  const MergeOperator* const merge_operator_;
  IteratorWrapper iter_;
-  BlobReader blob_reader_;
+  const Version* version_;
  ReadCallback* read_callback_;
  // Max visible sequence number. It is normally the snapshot seq unless we have
  // uncommitted data in db as in WriteUnCommitted.
@@ -406,6 +376,7 @@ class DBIter final : public Iterator {
  std::string saved_value_;
  Slice pinned_value_;
  // for prefix seek mode to support prev()
+  PinnableSlice blob_value_;
  // Value of the default column
  Slice value_;
  // All columns (i.e. name-value pairs)
@@ -439,13 +410,15 @@ class DBIter final : public Iterator {
  // Expect the inner iterator to maintain a total order.
  // prefix_extractor_ must be non-NULL if the value is false.
  const bool expect_total_order_inner_iter_;
+  ReadTier read_tier_;
+  bool fill_cache_;
+  bool verify_checksums_;
  // Whether the iterator is allowed to expose blob references. Set to true when
  // the stacked BlobDB implementation is used, false otherwise.
  bool expose_blob_index_;
-  bool allow_unprepared_value_;
-  Slice lazy_blob_index_;
  bool is_blob_;
  bool arena_mode_;
+  const Env::IOActivity io_activity_;
  // List of operands for merge operator.
  MergeContext merge_context_;
  LocalStatistics local_stats_;
@@ -56,11 +56,6 @@ class DBOptionsTest : public DBTestBase {
    EXPECT_OK(GetStringFromMutableCFOptions(
        config_options, MutableCFOptions(options), &options_str));
    EXPECT_OK(StringToMap(options_str, &mutable_map));
-    for (auto& opt : TEST_GetImmutableInMutableCFOptions()) {
-      // Not yet mutable but migrated to MutableCFOptions in preparation for
-      // being mutable
-      mutable_map.erase(opt);
-    }
    return mutable_map;
  }

@@ -236,33 +231,21 @@ TEST_F(DBOptionsTest, SetMutableTableOptions) {
  ASSERT_OK(dbfull()->SetOptions(
      cfh, {{"table_factory.block_size", "16384"},
            {"table_factory.block_restart_interval", "11"}}));
-  // Old c_bbto
-  ASSERT_EQ(c_bbto->block_size, 8192);
-  ASSERT_EQ(c_bbto->block_restart_interval, 7);
-  // New c_bbto
-  c_opts = dbfull()->GetOptions(cfh);
-  c_bbto = c_opts.table_factory->GetOptions<BlockBasedTableOptions>();
  ASSERT_EQ(c_bbto->block_size, 16384);
  ASSERT_EQ(c_bbto->block_restart_interval, 11);

  // Now set an option that is not mutable - options should not change
-  // FIXME: find a way to make this fail again
-  // ASSERT_NOK(
-  //    dbfull()->SetOptions(cfh, {{"table_factory.no_block_cache", "false"}}));
-  c_opts = dbfull()->GetOptions(cfh);
-  ASSERT_EQ(c_bbto, c_opts.table_factory->GetOptions<BlockBasedTableOptions>());
+  ASSERT_NOK(
+      dbfull()->SetOptions(cfh, {{"table_factory.no_block_cache", "false"}}));
  ASSERT_EQ(c_bbto->no_block_cache, true);
  ASSERT_EQ(c_bbto->block_size, 16384);
  ASSERT_EQ(c_bbto->block_restart_interval, 11);

  // Set some that are mutable and some that are not - options should not change
-  // FIXME: find a way to make this fail again
-  // ASSERT_NOK(dbfull()->SetOptions(
-  //     cfh, {{"table_factory.no_block_cache", "false"},
-  //           {"table_factory.block_size", "8192"},
-  //           {"table_factory.block_restart_interval", "7"}}));
-  c_opts = dbfull()->GetOptions(cfh);
-  ASSERT_EQ(c_bbto, c_opts.table_factory->GetOptions<BlockBasedTableOptions>());
+  ASSERT_NOK(dbfull()->SetOptions(
+      cfh, {{"table_factory.no_block_cache", "false"},
+            {"table_factory.block_size", "8192"},
+            {"table_factory.block_restart_interval", "7"}}));
  ASSERT_EQ(c_bbto->no_block_cache, true);
  ASSERT_EQ(c_bbto->block_size, 16384);
  ASSERT_EQ(c_bbto->block_restart_interval, 11);
@@ -273,8 +256,6 @@ TEST_F(DBOptionsTest, SetMutableTableOptions) {
      cfh, {{"table_factory.block_size", "8192"},
            {"table_factory.does_not_exist", "true"},
            {"table_factory.block_restart_interval", "7"}}));
-  c_opts = dbfull()->GetOptions(cfh);
-  ASSERT_EQ(c_bbto, c_opts.table_factory->GetOptions<BlockBasedTableOptions>());
  ASSERT_EQ(c_bbto->no_block_cache, true);
  ASSERT_EQ(c_bbto->block_size, 16384);
  ASSERT_EQ(c_bbto->block_restart_interval, 11);
@@ -290,7 +271,6 @@ TEST_F(DBOptionsTest, SetMutableTableOptions) {
            {"table_factory.block_restart_interval", "13"}}));
  c_opts = dbfull()->GetOptions(cfh);
  ASSERT_EQ(c_opts.blob_file_size, 32768);
-  c_bbto = c_opts.table_factory->GetOptions<BlockBasedTableOptions>();
  ASSERT_EQ(c_bbto->block_size, 16384);
  ASSERT_EQ(c_bbto->block_restart_interval, 13);
  // Set some on the table and a bad one on the ColumnFamily - options should
@@ -299,7 +279,6 @@ TEST_F(DBOptionsTest, SetMutableTableOptions) {
      cfh, {{"table_factory.block_size", "1024"},
            {"no_such_option", "32768"},
            {"table_factory.block_restart_interval", "7"}}));
-  ASSERT_EQ(c_bbto, c_opts.table_factory->GetOptions<BlockBasedTableOptions>());
  ASSERT_EQ(c_bbto->block_size, 16384);
  ASSERT_EQ(c_bbto->block_restart_interval, 13);
 }
@@ -244,7 +244,7 @@ TEST_F(DBSecondaryTest, SimpleInternalCompaction) {
  ASSERT_EQ(largest.user_key().ToString(), "foo");
  ASSERT_EQ(result.output_level, 1);
  ASSERT_EQ(result.output_path, this->secondary_path_);
-  ASSERT_EQ(result.stats.num_output_records, 2);
+  ASSERT_EQ(result.num_output_records, 2);
  ASSERT_GT(result.bytes_written, 0);
  ASSERT_OK(result.status);
 }
@@ -383,16 +383,12 @@ TEST_F(DBSSTTest, DBWithSstFileManager) {
  ASSERT_EQ(files_moved, 0);

  Close();
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
  Reopen(options);
  ASSERT_EQ(sfm->GetTrackedFiles(), files_in_db);
  ASSERT_EQ(sfm->GetTotalSize(), total_files_size);

  // Verify that we track all the files again after the DB is closed and opened
  Close();
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
  sst_file_manager.reset(NewSstFileManager(env_));
  options.sst_file_manager = sst_file_manager;
  sfm = static_cast<SstFileManagerImpl*>(sst_file_manager.get());
@@ -443,11 +439,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {

  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
      "SstFileManagerImpl::OnMoveFile", [&](void* /*arg*/) { files_moved++; });
-
-  int64_t untracked_files = 0;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::OnUntrackFile",
-      [&](void* /*arg*/) { ++untracked_files; });
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
@@ -494,10 +485,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
  }
  ASSERT_EQ(sfm->GetTotalSize(), total_files_size);
  Close();
-  ASSERT_EQ(untracked_files, files_in_db.size());
-  untracked_files = 0;
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";

  Reopen(options);
  ASSERT_EQ(sfm->GetTrackedFiles(), files_in_db);
@@ -505,10 +492,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {

  // Verify that we track all the files again after the DB is closed and opened.
  Close();
-  ASSERT_EQ(untracked_files, files_in_db.size());
-  untracked_files = 0;
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";

  sst_file_manager.reset(NewSstFileManager(env_));
  options.sst_file_manager = sst_file_manager;
@@ -524,10 +507,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
  ASSERT_EQ(files_deleted, 0);
  ASSERT_EQ(files_scheduled_to_delete, 0);
  Close();
-  ASSERT_EQ(untracked_files, files_in_db.size());
-  untracked_files = 0;
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
      "SstFileManagerImpl::ScheduleUnaccountedFileDeletion", [&](void* arg) {
        assert(arg);
@@ -687,9 +666,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFilesWithGC) {
  }

  Close();
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
-
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
      "SstFileManagerImpl::ScheduleUnaccountedFileDeletion", [&](void* arg) {
        assert(arg);
@@ -1826,30 +1826,21 @@ TEST_F(DBTest, GetApproximateMemTableStats) {
  uint64_t count;
  uint64_t size;

-  // Because Random::GetTLSInstance() seed is reset in DBTestBase,
-  // this test is deterministic.
-
  std::string start = Key(50);
  std::string end = Key(60);
  Range r(start, end);
  db_->GetApproximateMemTableStats(r, &count, &size);
-  // When actual count is <= 10, it returns that as the minimum
-  EXPECT_EQ(count, 10);
-  EXPECT_EQ(size, 10440);
-
-  start = Key(20);
-  end = Key(100);
-  r = Range(start, end);
-  db_->GetApproximateMemTableStats(r, &count, &size);
-  EXPECT_EQ(count, 72);
-  EXPECT_EQ(size, 75168);
+  ASSERT_GT(count, 0);
+  ASSERT_LE(count, N);
+  ASSERT_GT(size, 6000);
+  ASSERT_LT(size, 204800);

  start = Key(500);
  end = Key(600);
  r = Range(start, end);
  db_->GetApproximateMemTableStats(r, &count, &size);
-  EXPECT_EQ(count, 0);
-  EXPECT_EQ(size, 0);
+  ASSERT_EQ(count, 0);
+  ASSERT_EQ(size, 0);

  ASSERT_OK(Flush());

@@ -1857,8 +1848,8 @@ TEST_F(DBTest, GetApproximateMemTableStats) {
  end = Key(60);
  r = Range(start, end);
  db_->GetApproximateMemTableStats(r, &count, &size);
-  EXPECT_EQ(count, 0);
-  EXPECT_EQ(size, 0);
+  ASSERT_EQ(count, 0);
+  ASSERT_EQ(size, 0);

  for (int i = 0; i < N; i++) {
    ASSERT_OK(Put(Key(1000 + i), rnd.RandomString(1024)));
@@ -1866,11 +1857,10 @@ TEST_F(DBTest, GetApproximateMemTableStats) {

  start = Key(100);
  end = Key(1020);
-  // Actually 20 keys in the range ^^
  r = Range(start, end);
  db_->GetApproximateMemTableStats(r, &count, &size);
-  EXPECT_EQ(count, 20);
-  EXPECT_EQ(size, 20880);
+  ASSERT_GT(count, 20);
+  ASSERT_GT(size, 6000);
 }

 TEST_F(DBTest, ApproximateSizes) {
@@ -5179,14 +5169,10 @@ TEST_F(DBTest, DynamicLevelCompressionPerLevel) {
  options.max_bytes_for_level_multiplier = 4;
  options.max_background_compactions = 1;
  options.num_levels = 5;
-  options.statistics = CreateDBStatistics();

  options.compression_per_level.resize(3);
-  // No compression for L0
  options.compression_per_level[0] = kNoCompression;
-  // No compression for the Ln whre L0 is compacted to
  options.compression_per_level[1] = kNoCompression;
-  // Snpapy compression for Ln+1
  options.compression_per_level[2] = kSnappyCompression;

  OnFileDeletionListener* listener = new OnFileDeletionListener();
@@ -5195,7 +5181,7 @@ TEST_F(DBTest, DynamicLevelCompressionPerLevel) {
  DestroyAndReopen(options);

  // Insert more than 80K. L4 should be base level. Neither L0 nor L4 should
-  // be compressed, so there shouldn't be any compression.
+  // be compressed, so total data size should be more than 80K.
  for (int i = 0; i < 20; i++) {
    ASSERT_OK(Put(Key(keys[i]), CompressibleString(&rnd, 4000)));
  }
@@ -5205,17 +5191,10 @@ TEST_F(DBTest, DynamicLevelCompressionPerLevel) {
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
  ASSERT_EQ(NumTableFilesAtLevel(3), 0);
-  ASSERT_TRUE(NumTableFilesAtLevel(0) > 0 || NumTableFilesAtLevel(4) > 0);
+  // Assuming each files' metadata is at least 50 bytes/
+  ASSERT_GT(SizeAtLevel(0) + SizeAtLevel(4), 20U * 4000U + 50U * 4);

-  // Verify there was no compression
-  auto num_block_compressed =
-      options.statistics->getTickerCount(NUMBER_BLOCK_COMPRESSED);
-  ASSERT_EQ(num_block_compressed, 0);
-
-  // Insert 400KB and there will be some files end up in L3. According to the
-  // above compression settings for each level, there will be some compression.
-  ASSERT_OK(options.statistics->Reset());
-  ASSERT_EQ(num_block_compressed, 0);
+  // Insert 400KB. Some data will be compressed
  for (int i = 21; i < 120; i++) {
    ASSERT_OK(Put(Key(keys[i]), CompressibleString(&rnd, 4000)));
  }
@@ -5223,14 +5202,9 @@ TEST_F(DBTest, DynamicLevelCompressionPerLevel) {
  ASSERT_OK(dbfull()->TEST_WaitForCompact());
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
-  ASSERT_GE(NumTableFilesAtLevel(3), 1);
-  ASSERT_GE(NumTableFilesAtLevel(4), 1);
-
-  // Verify there was compression
-  num_block_compressed =
-      options.statistics->getTickerCount(NUMBER_BLOCK_COMPRESSED);
-  ASSERT_GT(num_block_compressed, 0);

+  ASSERT_LT(SizeAtLevel(0) + SizeAtLevel(3) + SizeAtLevel(4),
+            120U * 4000U + 50U * 24);
  // Make sure data in files in L3 is not compacted by removing all files
  // in L4 and calculate number of rows
  ASSERT_OK(dbfull()->SetOptions({
@@ -5250,12 +5224,6 @@ TEST_F(DBTest, DynamicLevelCompressionPerLevel) {
    num_keys++;
  }
  ASSERT_OK(iter->status());
-
-  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
-  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
-  ASSERT_GE(NumTableFilesAtLevel(3), 1);
-  ASSERT_EQ(NumTableFilesAtLevel(4), 0);
-
  ASSERT_GT(SizeAtLevel(0) + SizeAtLevel(3), num_keys * 4000U + num_keys * 10U);
 }

@@ -16,7 +16,6 @@
 #include "db/db_test_util.h"
 #include "db/read_callback.h"
 #include "db/version_edit.h"
-#include "env/fs_readonly.h"
 #include "options/options_helper.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
@@ -37,6 +36,18 @@ namespace ROCKSDB_NAMESPACE {
 class DBTest2 : public DBTestBase {
 public:
  DBTest2() : DBTestBase("db_test2", /*env_do_fsync=*/true) {}
+  std::vector<FileMetaData*> GetLevelFileMetadatas(int level, int cf = 0) {
+    VersionSet* const versions = dbfull()->GetVersionSet();
+    assert(versions);
+    ColumnFamilyData* const cfd =
+        versions->GetColumnFamilySet()->GetColumnFamily(cf);
+    assert(cfd);
+    Version* const current = cfd->current();
+    assert(current);
+    VersionStorageInfo* const storage_info = current->storage_info();
+    assert(storage_info);
+    return storage_info->LevelFiles(level);
+  }
 };

 TEST_F(DBTest2, OpenForReadOnly) {
@@ -2104,15 +2115,16 @@ TEST_P(PinL0IndexAndFilterBlocksTest,
  ASSERT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_ADD));
  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_MISS));

+  std::string value;
  // Miss and hit count should remain the same, they're all pinned.
-  ASSERT_TRUE(db_->KeyMayExist(ReadOptions(), handles_[1], "key", nullptr));
+  ASSERT_TRUE(db_->KeyMayExist(ReadOptions(), handles_[1], "key", &value));
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));

  // Miss and hit count should remain the same, they're all pinned.
-  std::string value = Get(1, "key");
+  value = Get(1, "key");
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
@@ -5585,45 +5597,32 @@ TEST_F(DBTest2, PrefixBloomFilteredOut) {
  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
  bbto.whole_key_filtering = false;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+  DestroyAndReopen(options);

-  // This test is also the primary test for prefix_seek_opt_in_only
-  for (bool opt_in : {false, true}) {
-    options.prefix_seek_opt_in_only = opt_in;
-    DestroyAndReopen(options);
+  // Construct two L1 files with keys:
+  // f1:[aaa1 ccc1] f2:[ddd0]
+  ASSERT_OK(Put("aaa1", ""));
+  ASSERT_OK(Put("ccc1", ""));
+  ASSERT_OK(Flush());
+  ASSERT_OK(Put("ddd0", ""));
+  ASSERT_OK(Flush());
+  CompactRangeOptions cro;
+  cro.bottommost_level_compaction = BottommostLevelCompaction::kSkip;
+  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));

-    // Construct two L1 files with keys:
-    // f1:[aaa1 ccc1] f2:[ddd0]
-    ASSERT_OK(Put("aaa1", ""));
-    ASSERT_OK(Put("ccc1", ""));
-    ASSERT_OK(Flush());
-    ASSERT_OK(Put("ddd0", ""));
-    ASSERT_OK(Flush());
-    CompactRangeOptions cro;
-    cro.bottommost_level_compaction = BottommostLevelCompaction::kSkip;
-    ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+  Iterator* iter = db_->NewIterator(ReadOptions());
+  ASSERT_OK(iter->status());

-    ReadOptions ropts;
-    for (bool same : {false, true}) {
-      ropts.prefix_same_as_start = same;
-      std::unique_ptr<Iterator> iter(db_->NewIterator(ropts));
-      ASSERT_OK(iter->status());
+  // Bloom filter is filterd out by f1.
+  // This is just one of several valid position following the contract.
+  // Postioning to ccc1 or ddd0 is also valid. This is just to validate
+  // the behavior of the current implementation. If underlying implementation
+  // changes, the test might fail here.
+  iter->Seek("bbb1");
+  ASSERT_OK(iter->status());
+  ASSERT_FALSE(iter->Valid());

-      iter->Seek("bbb1");
-      ASSERT_OK(iter->status());
-      if (opt_in && !same) {
-        // Unbounded total order seek
-        ASSERT_TRUE(iter->Valid());
-        ASSERT_EQ(iter->key(), "ccc1");
-      } else {
-        // Bloom filter is filterd out by f1. When same == false, this is just
-        // one valid position following the contract. Postioning to ccc1 or ddd0
-        // is also valid. This is just to validate the behavior of the current
-        // implementation. If underlying implementation changes, the test might
-        // fail here.
-        ASSERT_FALSE(iter->Valid());
-      }
-    }
-  }
+  delete iter;
 }

 TEST_F(DBTest2, RowCacheSnapshot) {
@@ -5988,7 +5987,6 @@ TEST_F(DBTest2, ChangePrefixExtractor) {
    // create a DB with block prefix index
    BlockBasedTableOptions table_options;
    Options options = CurrentOptions();
-    options.prefix_seek_opt_in_only = false;  // Use legacy prefix seek

    // Sometimes filter is checked based on upper bound. Assert counters
    // for that case. Otherwise, only check data correctness.
@@ -8062,63 +8060,6 @@ TEST_F(DBTest2, TableCacheMissDuringReadFromBlockCacheTier) {
  ASSERT_EQ(orig_num_file_opens, TestGetTickerCount(options, NO_FILE_OPENS));
 }

-TEST_F(DBTest2, GetFileChecksumsFromCurrentManifest_CRC32) {
-  Options opts = CurrentOptions();
-  opts.create_if_missing = true;
-  opts.file_checksum_gen_factory = GetFileChecksumGenCrc32cFactory();
-  opts.level0_file_num_compaction_trigger = 10;
-
-  // Bootstrap the test database.
-  DB* db = nullptr;
-  std::string dbname = test::PerThreadDBPath("file_chksum");
-  ASSERT_OK(DB::Open(opts, dbname, &db));
-
-  WriteOptions wopts;
-  FlushOptions fopts;
-  fopts.wait = true;
-  Random rnd(test::RandomSeed());
-  for (int i = 0; i < 4; i++) {
-    ASSERT_OK(db->Put(wopts, Key(i), rnd.RandomString(100)));
-    ASSERT_OK(db->Flush(fopts));
-  }
-
-  // Obtain rich files metadata for source of truth.
-  std::vector<LiveFileMetaData> live_files;
-  db->GetLiveFilesMetaData(&live_files);
-
-  ASSERT_OK(db->Close());
-  delete db;
-  db = nullptr;
-
-  // Process current MANIFEST file and build internal file checksum mappings.
-  std::unique_ptr<FileChecksumList> checksum_list(NewFileChecksumList());
-  auto read_only_fs =
-      std::make_shared<ReadOnlyFileSystem>(env_->GetFileSystem());
-  ASSERT_OK(experimental::GetFileChecksumsFromCurrentManifest(
-      read_only_fs.get(), dbname, checksum_list.get()));
-
-  ASSERT_TRUE(checksum_list != nullptr);
-
-  // Retrieve files, related checksums and checksum functions.
-  std::vector<uint64_t> file_numbers;
-  std::vector<std::string> checksums;
-  std::vector<std::string> checksum_func_names;
-  ASSERT_OK(checksum_list->GetAllFileChecksums(&file_numbers, &checksums,
-                                               &checksum_func_names));
-
-  // Compare results.
-  ASSERT_EQ(live_files.size(), checksum_list->size());
-  for (size_t i = 0; i < live_files.size(); i++) {
-    std::string stored_checksum;
-    std::string stored_func_name;
-    ASSERT_OK(checksum_list->SearchOneFileChecksum(
-        live_files[i].file_number, &stored_checksum, &stored_func_name));
-
-    ASSERT_EQ(live_files[i].file_checksum, stored_checksum);
-    ASSERT_EQ(live_files[i].file_checksum_func_name, stored_func_name);
-  }
-}
-
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -934,13 +934,6 @@ Status DBTestBase::Get(const std::string& k, PinnableSlice* v) {
  return s;
 }

-Status DBTestBase::CompactRange(const CompactRangeOptions& options,
-                                std::optional<Slice> begin,
-                                std::optional<Slice> end) {
-  return db_->CompactRange(options, begin ? &begin.value() : nullptr,
-                           end ? &end.value() : nullptr);
-}
-
 uint64_t DBTestBase::GetNumSnapshots() {
  uint64_t int_num;
  EXPECT_TRUE(dbfull()->GetIntProperty("rocksdb.num-snapshots", &int_num));
@@ -1270,20 +1263,6 @@ Status DBTestBase::CountFiles(size_t* count) {
  return Status::OK();
 }

-std::vector<FileMetaData*> DBTestBase::GetLevelFileMetadatas(int level,
-                                                             int cf) {
-  VersionSet* const versions = dbfull()->GetVersionSet();
-  assert(versions);
-  ColumnFamilyData* const cfd =
-      versions->GetColumnFamilySet()->GetColumnFamily(cf);
-  assert(cfd);
-  Version* const current = cfd->current();
-  assert(current);
-  VersionStorageInfo* const storage_info = current->storage_info();
-  assert(storage_info);
-  return storage_info->LevelFiles(level);
-}
-
 Status DBTestBase::Size(const Slice& start, const Slice& limit, int cf,
                        uint64_t* size) {
  Range r(start, limit);
@@ -1600,74 +1579,42 @@ std::vector<std::uint64_t> DBTestBase::ListTableFiles(Env* env,
  return file_numbers;
 }

-void DBTestBase::VerifyDBFromMap(
-    std::map<std::string, std::string> true_data, size_t* total_reads_res,
-    bool tailing_iter, ReadOptions* ro, ColumnFamilyHandle* cf,
-    std::unordered_set<std::string>* not_found) const {
-  ReadOptions temp_ro;
-  if (!ro) {
-    ro = &temp_ro;
-    ro->verify_checksums = true;
-  }
-  if (!cf) {
-    cf = db_->DefaultColumnFamily();
-  }
-
-  // Get
+void DBTestBase::VerifyDBFromMap(std::map<std::string, std::string> true_data,
+                                 size_t* total_reads_res, bool tailing_iter,
+                                 std::map<std::string, Status> status) {
  size_t total_reads = 0;
-  std::string result;
-  for (auto& [k, v] : true_data) {
-    ASSERT_OK(db_->Get(*ro, cf, k, &result)) << "key is " << k;
-    ASSERT_EQ(v, result);
-    total_reads++;
-  }
-  if (not_found) {
-    for (const auto& k : *not_found) {
-      ASSERT_TRUE(db_->Get(*ro, cf, k, &result).IsNotFound())
-          << "key is " << k << " val is " << result;
-    }
-  }

-  // MultiGet
-  std::vector<Slice> key_slice;
-  for (const auto& [k, _] : true_data) {
-    key_slice.emplace_back(k);
-  }
-  std::vector<std::string> values;
-  std::vector<ColumnFamilyHandle*> cfs(key_slice.size(), cf);
-  std::vector<Status> status = db_->MultiGet(*ro, cfs, key_slice, &values);
-  total_reads += key_slice.size();
-  auto data_iter = true_data.begin();
-  for (size_t i = 0; i < key_slice.size(); ++i, ++data_iter) {
-    ASSERT_OK(status[i]);
-    ASSERT_EQ(values[i], data_iter->second);
-  }
-  // MultiGet - not found
-  if (not_found) {
-    key_slice.clear();
-    for (const auto& k : *not_found) {
-      key_slice.emplace_back(k);
-    }
-    cfs = std::vector<ColumnFamilyHandle*>(key_slice.size(), cf);
-    values.clear();
-    status = db_->MultiGet(*ro, cfs, key_slice, &values);
-    for (const auto& s : status) {
-      ASSERT_TRUE(s.IsNotFound());
+  for (auto& kv : true_data) {
+    Status s = status[kv.first];
+    if (s.ok()) {
+      ASSERT_EQ(Get(kv.first), kv.second);
+    } else {
+      std::string value;
+      ASSERT_EQ(s, db_->Get(ReadOptions(), kv.first, &value));
    }
+    total_reads++;
  }

  // Normal Iterator
  {
    int iter_cnt = 0;
-    ReadOptions ro_ = *ro;
-    ro_.total_order_seek = true;
-    Iterator* iter = db_->NewIterator(ro_, cf);
+    ReadOptions ro;
+    ro.total_order_seek = true;
+    Iterator* iter = db_->NewIterator(ro);
    // Verify Iterator::Next()
    iter_cnt = 0;
-    data_iter = true_data.begin();
-    for (iter->SeekToFirst(); iter->Valid(); iter->Next(), ++data_iter) {
+    auto data_iter = true_data.begin();
+    Status s;
+    for (iter->SeekToFirst(); iter->Valid(); iter->Next(), data_iter++) {
      ASSERT_EQ(iter->key().ToString(), data_iter->first);
+      Status current_status = status[data_iter->first];
+      if (!current_status.ok()) {
+        s = current_status;
+      }
+      ASSERT_EQ(iter->status(), s);
+      if (current_status.ok()) {
        ASSERT_EQ(iter->value().ToString(), data_iter->second);
+      }
      iter_cnt++;
      total_reads++;
    }
@@ -1678,12 +1625,20 @@ void DBTestBase::VerifyDBFromMap(

    // Verify Iterator::Prev()
    // Use a new iterator to make sure its status is clean.
-    iter = db_->NewIterator(ro_, cf);
+    iter = db_->NewIterator(ro);
    iter_cnt = 0;
+    s = Status::OK();
    auto data_rev = true_data.rbegin();
    for (iter->SeekToLast(); iter->Valid(); iter->Prev(), data_rev++) {
      ASSERT_EQ(iter->key().ToString(), data_rev->first);
+      Status current_status = status[data_rev->first];
+      if (!current_status.ok()) {
+        s = current_status;
+      }
+      ASSERT_EQ(iter->status(), s);
+      if (current_status.ok()) {
        ASSERT_EQ(iter->value().ToString(), data_rev->second);
+      }
      iter_cnt++;
      total_reads++;
    }
@@ -1691,20 +1646,12 @@ void DBTestBase::VerifyDBFromMap(
    ASSERT_EQ(data_rev, true_data.rend())
        << iter_cnt << " / " << true_data.size();

-    // Verify Iterator::Seek() and SeekForPrev()
-    for (const auto& [k, v] : true_data) {
-      for (bool prev : {false, true}) {
-        if (prev) {
-          iter->SeekForPrev(k);
-        } else {
-          iter->Seek(k);
-        }
-        ASSERT_TRUE(iter->Valid());
-        ASSERT_OK(iter->status());
-        ASSERT_EQ(iter->key(), k);
-        ASSERT_EQ(iter->value(), v);
-        ++total_reads;
-      }
+    // Verify Iterator::Seek()
+    for (const auto& kv : true_data) {
+      iter->Seek(kv.first);
+      ASSERT_EQ(kv.first, iter->key().ToString());
+      ASSERT_EQ(kv.second, iter->value().ToString());
+      total_reads++;
    }
    delete iter;
  }
@@ -1712,14 +1659,14 @@ void DBTestBase::VerifyDBFromMap(
  if (tailing_iter) {
    // Tailing iterator
    int iter_cnt = 0;
-    ReadOptions ro_ = *ro;
-    ro_.tailing = true;
-    ro_.total_order_seek = true;
-    Iterator* iter = db_->NewIterator(ro_, cf);
+    ReadOptions ro;
+    ro.tailing = true;
+    ro.total_order_seek = true;
+    Iterator* iter = db_->NewIterator(ro);

    // Verify ForwardIterator::Next()
    iter_cnt = 0;
-    data_iter = true_data.begin();
+    auto data_iter = true_data.begin();
    for (iter->SeekToFirst(); iter->Valid(); iter->Next(), data_iter++) {
      ASSERT_EQ(iter->key().ToString(), data_iter->first);
      ASSERT_EQ(iter->value().ToString(), data_iter->second);
@@ -1225,9 +1225,6 @@ class DBTestBase : public testing::Test {
                                    const Snapshot* snapshot = nullptr,
                                    const bool async = false);

-  Status CompactRange(const CompactRangeOptions& options,
-                      std::optional<Slice> begin, std::optional<Slice> end);
-
  uint64_t GetNumSnapshots();

  uint64_t GetTimeOldestSnapshots();
@@ -1276,8 +1273,6 @@ class DBTestBase : public testing::Test {

  Status CountFiles(size_t* count);

-  std::vector<FileMetaData*> GetLevelFileMetadatas(int level, int cf = 0);
-
  Status Size(const Slice& start, const Slice& limit, uint64_t* size) {
    return Size(start, limit, 0, size);
  }
@@ -1367,8 +1362,7 @@ class DBTestBase : public testing::Test {
  void VerifyDBFromMap(
      std::map<std::string, std::string> true_data,
      size_t* total_reads_res = nullptr, bool tailing_iter = false,
-      ReadOptions* ro = nullptr, ColumnFamilyHandle* cf = nullptr,
-      std::unordered_set<std::string>* not_found = nullptr) const;
+      std::map<std::string, Status> status = std::map<std::string, Status>());

  void VerifyDBInternal(
      std::vector<std::pair<std::string, std::string>> true_data);
@@ -2931,29 +2931,6 @@ TEST_F(DBWALTest, RecoveryFlushSwitchWALOnEmptyMemtable) {
  ASSERT_EQ("new_v", Get("k"));
  Destroy(options);
 }
-
-TEST_F(DBWALTest, WALWriteErrorNoRecovery) {
-  Options options = CurrentOptions();
-  auto fault_fs = std::make_shared<FaultInjectionTestFS>(FileSystem::Default());
-  std::unique_ptr<Env> fault_fs_env(NewCompositeEnv(fault_fs));
-  options.env = fault_fs_env.get();
-  options.manual_wal_flush = true;
-  DestroyAndReopen(options);
-  fault_fs->SetThreadLocalErrorContext(
-      FaultInjectionIOType::kWrite, 7 /* seed*/, 1 /* one_in */,
-      true /* retryable */, false /* has_data_loss*/);
-  fault_fs->EnableThreadLocalErrorInjection(FaultInjectionIOType::kWrite);
-
-  ASSERT_OK(Put("k", "v"));
-  Status s;
-  s = db_->FlushWAL(false);
-  ASSERT_TRUE(s.IsIOError());
-  s = dbfull()->TEST_GetBGError();
-  ASSERT_EQ(s.severity(), Status::Severity::kFatalError);
-  ASSERT_FALSE(dbfull()->TEST_IsRecoveryInProgress());
-  fault_fs->DisableThreadLocalErrorInjection(FaultInjectionIOType::kWrite);
-  Destroy(options);
-}
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -832,7 +832,6 @@ TEST_P(DBBasicTestWithTimestampTableOptions, GetAndMultiGet) {

 TEST_P(DBBasicTestWithTimestampTableOptions, SeekWithPrefixLessThanKey) {
  Options options = CurrentOptions();
-  options.prefix_seek_opt_in_only = false;  // Use legacy prefix seek
  options.env = env_;
  options.create_if_missing = true;
  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
@@ -1010,7 +1009,6 @@ TEST_F(DBBasicTestWithTimestamp, ChangeIterationDirection) {
  TestComparator test_cmp(kTimestampSize);
  options.comparator = &test_cmp;
  options.prefix_extractor.reset(NewFixedPrefixTransform(1));
-  options.prefix_seek_opt_in_only = false;  // Use legacy prefix seek
  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
  DestroyAndReopen(options);
  const std::vector<std::string> timestamps = {Timestamp(1, 1), Timestamp(0, 2),
@@ -178,9 +178,11 @@ std::string ParsedInternalKey::DebugString(bool log_err_key, bool hex,
    result += "<redacted>";
  }

-  result += "' seq:" + std::to_string(sequence);
-  result += ", type:" + std::to_string(type);
+  char buf[50];
+  snprintf(buf, sizeof(buf), "' seq:%" PRIu64 ", type:%d", sequence,
+           static_cast<int>(type));

+  result += buf;
  return result;
 }

@@ -270,23 +272,11 @@ LookupKey::LookupKey(const Slice& _user_key, SequenceNumber s,

 void IterKey::EnlargeBuffer(size_t key_size) {
  // If size is smaller than buffer size, continue using current buffer,
-  // or the inline one, as default
+  // or the static allocated one, as default
  assert(key_size > buf_size_);
  // Need to enlarge the buffer.
  ResetBuffer();
  buf_ = new char[key_size];
  buf_size_ = key_size;
 }
-
-void IterKey::EnlargeSecondaryBufferIfNeeded(size_t key_size) {
-  // If size is smaller than buffer size, continue using current buffer,
-  // or the inline one, as default
-  if (key_size <= secondary_buf_size_) {
-    return;
-  }
-  // Need to enlarge the secondary buffer.
-  ResetSecondaryBuffer();
-  secondary_buf_ = new char[key_size];
-  secondary_buf_size_ = key_size;
-}
 }  // namespace ROCKSDB_NAMESPACE
@@ -10,7 +10,6 @@
 #pragma once
 #include <stdio.h>

-#include <array>
 #include <memory>
 #include <optional>
 #include <string>
@@ -563,28 +562,18 @@ inline uint64_t GetInternalKeySeqno(const Slice& internal_key) {
 //    allocation for smaller keys.
 // 3. It tracks user key or internal key, and allow conversion between them.
 class IterKey {
-  static constexpr size_t kInlineBufferSize = 39;
-  // This is only used by user-defined timestamps in MemTable only feature,
-  // which only supports uint64_t timestamps.
-  static constexpr char kTsMin[] = "\x00\x00\x00\x00\x00\x00\x00\x00";
-
 public:
  IterKey()
      : buf_(space_),
        key_(buf_),
        key_size_(0),
-        buf_size_(kInlineBufferSize),
-        is_user_key_(true),
-        secondary_buf_(space_for_secondary_buf_),
-        secondary_buf_size_(kInlineBufferSize) {}
+        buf_size_(sizeof(space_)),
+        is_user_key_(true) {}
  // No copying allowed
  IterKey(const IterKey&) = delete;
  void operator=(const IterKey&) = delete;

-  ~IterKey() {
-    ResetBuffer();
-    ResetSecondaryBuffer();
-  }
+  ~IterKey() { ResetBuffer(); }

  // The bool will be picked up by the next calls to SetKey
  void SetIsUserKey(bool is_user_key) { is_user_key_ = is_user_key; }
@@ -652,15 +641,13 @@ class IterKey {
                               const char* non_shared_data,
                               const size_t non_shared_len,
                               const size_t ts_sz) {
-    // This function is only used by the UDT in memtable feature, which only
-    // support built in comparators with uint64 timestamps.
-    assert(ts_sz == sizeof(uint64_t));
-    size_t next_key_slice_index = 0;
+    std::string kTsMin(ts_sz, static_cast<unsigned char>(0));
+    std::string key_with_ts;
+    std::vector<Slice> key_parts_with_ts;
    if (IsUserKey()) {
-      key_slices_[next_key_slice_index++] = Slice(key_, shared_len);
-      key_slices_[next_key_slice_index++] =
-          Slice(non_shared_data, non_shared_len);
-      key_slices_[next_key_slice_index++] = Slice(kTsMin, ts_sz);
+      key_parts_with_ts = {Slice(key_, shared_len),
+                           Slice(non_shared_data, non_shared_len),
+                           Slice(kTsMin)};
    } else {
      assert(shared_len + non_shared_len >= kNumInternalBytes);
      // Invaraint: shared_user_key_len + shared_internal_bytes_len = shared_len
@@ -677,46 +664,30 @@ class IterKey {

      // One Slice among the three Slices will get split into two Slices, plus
      // a timestamp slice.
+      key_parts_with_ts.reserve(5);
      bool ts_added = false;
      // Add slice parts and find the right location to add the min timestamp.
      MaybeAddKeyPartsWithTimestamp(
          key_, shared_user_key_len,
          shared_internal_bytes_len + non_shared_len < kNumInternalBytes,
-          shared_len + non_shared_len - kNumInternalBytes, ts_sz,
-          &next_key_slice_index, &ts_added);
+          shared_len + non_shared_len - kNumInternalBytes, kTsMin,
+          key_parts_with_ts, &ts_added);
      MaybeAddKeyPartsWithTimestamp(
          key_ + user_key_len, shared_internal_bytes_len,
          non_shared_len < kNumInternalBytes,
-          shared_internal_bytes_len + non_shared_len - kNumInternalBytes, ts_sz,
-          &next_key_slice_index, &ts_added);
+          shared_internal_bytes_len + non_shared_len - kNumInternalBytes,
+          kTsMin, key_parts_with_ts, &ts_added);
      MaybeAddKeyPartsWithTimestamp(non_shared_data, non_shared_len,
                                    non_shared_len >= kNumInternalBytes,
-                                    non_shared_len - kNumInternalBytes, ts_sz,
-                                    &next_key_slice_index, &ts_added);
+                                    non_shared_len - kNumInternalBytes, kTsMin,
+                                    key_parts_with_ts, &ts_added);
      assert(ts_added);
    }
-    SetKeyImpl(next_key_slice_index,
-               /* total_bytes= */ shared_len + non_shared_len + ts_sz);
-  }

-  Slice SetKeyWithPaddedMinTimestamp(const Slice& key, size_t ts_sz) {
-    // This function is only used by the UDT in memtable feature, which only
-    // support built in comparators with uint64 timestamps.
-    assert(ts_sz == sizeof(uint64_t));
-    size_t num_key_slices = 0;
-    if (is_user_key_) {
-      key_slices_[0] = key;
-      key_slices_[1] = Slice(kTsMin, ts_sz);
-      num_key_slices = 2;
-    } else {
-      assert(key.size() >= kNumInternalBytes);
-      size_t user_key_size = key.size() - kNumInternalBytes;
-      key_slices_[0] = Slice(key.data(), user_key_size);
-      key_slices_[1] = Slice(kTsMin, ts_sz);
-      key_slices_[2] = Slice(key.data() + user_key_size, kNumInternalBytes);
-      num_key_slices = 3;
-    }
-    return SetKeyImpl(num_key_slices, key.size() + ts_sz);
+    Slice new_key(SliceParts(&key_parts_with_ts.front(),
+                             static_cast<int>(key_parts_with_ts.size())),
+                  &key_with_ts);
+    SetKey(new_key);
  }

  Slice SetKey(const Slice& key, bool copy = true) {
@@ -747,6 +718,15 @@ class IterKey {
    return Slice(key_, key_n);
  }

+  // Copy the key into IterKey own buf_
+  void OwnKey() {
+    assert(IsKeyPinned() == true);
+
+    Reserve(key_size_);
+    memcpy(buf_, key_, key_size_);
+    key_ = buf_;
+  }
+
  // Update the sequence number in the internal key.  Guarantees not to
  // invalidate slices to the key (and the user key).
  void UpdateInternalKey(uint64_t seq, ValueType t, const Slice* ts = nullptr) {
@@ -758,15 +738,10 @@ class IterKey {
             ts->size());
    }
    uint64_t newval = (seq << 8) | t;
-    if (key_ == buf_) {
-      EncodeFixed64(&buf_[key_size_ - kNumInternalBytes], newval);
-    } else {
-      assert(key_ == secondary_buf_);
-      EncodeFixed64(&secondary_buf_[key_size_ - kNumInternalBytes], newval);
-    }
+    EncodeFixed64(&buf_[key_size_ - kNumInternalBytes], newval);
  }

-  bool IsKeyPinned() const { return key_ != buf_ && key_ != secondary_buf_; }
+  bool IsKeyPinned() const { return (key_ != buf_); }

  // If `ts` is provided, user_key should not contain timestamp,
  // and `ts` is appended after user_key.
@@ -831,24 +806,8 @@ class IterKey {
  const char* key_;
  size_t key_size_;
  size_t buf_size_;
-  char space_[kInlineBufferSize];  // Avoid allocation for short keys
+  char space_[39];  // Avoid allocation for short keys
  bool is_user_key_;
-  // Below variables are only used by user-defined timestamps in MemTable only
-  // feature for iterating keys in an index block or a data block.
-  //
-  // We will alternate between buf_ and secondary_buf_ to hold the key. key_
-  // will be modified in accordance to point to the right one. This is to avoid
-  // an extra copy when we need to copy some shared bytes from previous key
-  // (delta encoding), and we need to pad a min timestamp at the right location.
-  char space_for_secondary_buf_[kInlineBufferSize];  // Avoid allocation for
-                                                     // short keys
-  char* secondary_buf_;
-  size_t secondary_buf_size_;
-  // Use to track the pieces that together make the whole key. We then copy
-  // these pieces in order either into buf_ or secondary_buf_ depending on where
-  // the previous key is held.
-  std::array<Slice, 5> key_slices_;
-  // End of variables used by user-defined timestamps in MemTable only feature.

  Slice SetKeyImpl(const Slice& key, bool copy) {
    size_t size = key.size();
@@ -865,64 +824,18 @@ class IterKey {
    return Slice(key_, key_size_);
  }

-  Slice SetKeyImpl(size_t num_key_slices, size_t total_bytes) {
-    assert(num_key_slices <= 5);
-    char* buf_start = nullptr;
-    if (key_ == buf_) {
-      // If the previous key is in buf_, we copy key_slices_ in order into
-      // secondary_buf_.
-      EnlargeSecondaryBufferIfNeeded(total_bytes);
-      buf_start = secondary_buf_;
-      key_ = secondary_buf_;
-    } else {
-      // Copy key_slices_ in order into buf_.
-      EnlargeBufferIfNeeded(total_bytes);
-      buf_start = buf_;
-      key_ = buf_;
-    }
-#ifndef NDEBUG
-    size_t actual_total_bytes = 0;
-#endif  // NDEBUG
-    for (size_t i = 0; i < num_key_slices; i++) {
-      size_t key_slice_size = key_slices_[i].size();
-      memcpy(buf_start, key_slices_[i].data(), key_slice_size);
-      buf_start += key_slice_size;
-#ifndef NDEBUG
-      actual_total_bytes += key_slice_size;
-#endif  // NDEBUG
-    }
-#ifndef NDEBUG
-    assert(actual_total_bytes == total_bytes);
-#endif  // NDEBUG
-    key_size_ = total_bytes;
-    return Slice(key_, key_size_);
-  }
-
  void ResetBuffer() {
-    if (key_ == buf_) {
-      key_size_ = 0;
-    }
    if (buf_ != space_) {
      delete[] buf_;
      buf_ = space_;
    }
-    buf_size_ = kInlineBufferSize;
-  }
-
-  void ResetSecondaryBuffer() {
-    if (key_ == secondary_buf_) {
-      key_size_ = 0;
-    }
-    if (secondary_buf_ != space_for_secondary_buf_) {
-      delete[] secondary_buf_;
-      secondary_buf_ = space_for_secondary_buf_;
-    }
-    secondary_buf_size_ = kInlineBufferSize;
+    buf_size_ = sizeof(space_);
+    key_size_ = 0;
  }

  // Enlarge the buffer size if needed based on key_size.
-  // By default, inline buffer is used. Once there is a key
-  // larger than the inline buffer, another buffer is dynamically
+  // By default, static allocated buffer is used. Once there is a key
+  // larger than the static allocated buffer, another buffer is dynamically
  // allocated, until a larger key buffer is requested. In that case, we
  // reallocate buffer and delete the old one.
  void EnlargeBufferIfNeeded(size_t key_size) {
@@ -933,27 +846,23 @@ class IterKey {
    }
  }

-  void EnlargeSecondaryBufferIfNeeded(size_t key_size);
-
  void EnlargeBuffer(size_t key_size);

  void MaybeAddKeyPartsWithTimestamp(const char* slice_data,
                                     const size_t slice_sz, bool add_timestamp,
-                                     const size_t left_sz, const size_t ts_sz,
-                                     size_t* next_key_slice_idx,
+                                     const size_t left_sz,
+                                     const std::string& min_timestamp,
+                                     std::vector<Slice>& key_parts,
                                     bool* ts_added) {
-    assert(next_key_slice_idx);
    if (add_timestamp && !*ts_added) {
      assert(slice_sz >= left_sz);
-      key_slices_[(*next_key_slice_idx)++] = Slice(slice_data, left_sz);
-      key_slices_[(*next_key_slice_idx)++] = Slice(kTsMin, ts_sz);
-      key_slices_[(*next_key_slice_idx)++] =
-          Slice(slice_data + left_sz, slice_sz - left_sz);
+      key_parts.emplace_back(slice_data, left_sz);
+      key_parts.emplace_back(min_timestamp);
+      key_parts.emplace_back(slice_data + left_sz, slice_sz - left_sz);
      *ts_added = true;
    } else {
-      key_slices_[(*next_key_slice_idx)++] = Slice(slice_data, slice_sz);
+      key_parts.emplace_back(slice_data, slice_sz);
    }
-    assert(*next_key_slice_idx <= 5);
  }
 };

@@ -1027,13 +936,22 @@ struct RangeTombstone {
  // User-defined timestamp is enabled, `sk` and `ek` should be user key
  // with timestamp, `ts` will replace the timestamps in `sk` and
  // `ek`.
-  RangeTombstone(Slice sk, Slice ek, SequenceNumber sn, Slice ts) : seq_(sn) {
+  // When `logical_strip_timestamp` is true, the timestamps in `sk` and `ek`
+  // will be replaced with min timestamp.
+  RangeTombstone(Slice sk, Slice ek, SequenceNumber sn, Slice ts,
+                 bool logical_strip_timestamp)
+      : seq_(sn) {
    const size_t ts_sz = ts.size();
    assert(ts_sz > 0);
    pinned_start_key_.reserve(sk.size());
    pinned_end_key_.reserve(ek.size());
-    AppendUserKeyWithDifferentTimestamp(&pinned_start_key_, sk, ts);
-    AppendUserKeyWithDifferentTimestamp(&pinned_end_key_, ek, ts);
+    if (logical_strip_timestamp) {
+      AppendUserKeyWithMinTimestamp(&pinned_start_key_, sk, ts_sz);
+      AppendUserKeyWithMinTimestamp(&pinned_end_key_, ek, ts_sz);
+    } else {
+      AppendUserKeyWithDifferentTimestamp(&pinned_start_key_, sk, ts);
+      AppendUserKeyWithDifferentTimestamp(&pinned_end_key_, ek, ts);
+    }
    start_key_ = pinned_start_key_;
    end_key_ = pinned_end_key_;
    ts_ = Slice(pinned_start_key_.data() + sk.size() - ts_sz, ts_sz);
@@ -381,7 +381,7 @@ void ErrorHandler::HandleKnownErrors(const Status& bg_err,
 //    BackgroundErrorReason reason) will be called to handle other error cases
 //    such as delegating to SstFileManager to handle no space error.
 void ErrorHandler::SetBGError(const Status& bg_status,
-                              BackgroundErrorReason reason, bool wal_related) {
+                              BackgroundErrorReason reason) {
  db_mutex_->AssertHeld();
  Status tmp_status = bg_status;
  IOStatus bg_io_err = status_to_io_status(std::move(tmp_status));
@@ -389,8 +389,8 @@ void ErrorHandler::SetBGError(const Status& bg_status,
  if (bg_io_err.ok()) {
    return;
  }
-  ROCKS_LOG_WARN(db_options_.info_log, "Background IO error %s, reason %d",
-                 bg_io_err.ToString().c_str(), static_cast<int>(reason));
+  ROCKS_LOG_WARN(db_options_.info_log, "Background IO error %s",
+                 bg_io_err.ToString().c_str());

  RecordStats({ERROR_HANDLER_BG_ERROR_COUNT, ERROR_HANDLER_BG_IO_ERROR_COUNT},
              {} /* int_histograms */);
@@ -412,31 +412,6 @@ void ErrorHandler::SetBGError(const Status& bg_status,
    recover_context_ = context;
    return;
  }
-  if (wal_related) {
-    assert(reason == BackgroundErrorReason::kWriteCallback ||
-           reason == BackgroundErrorReason::kMemTable ||
-           reason == BackgroundErrorReason::kFlush);
-  }
-  if (db_options_.manual_wal_flush && wal_related && bg_io_err.IsIOError()) {
-    // With manual_wal_flush, a WAL write failure can drop buffered WAL writes.
-    // Memtables and WAL then become inconsistent. A successful memtable flush
-    // on one CF can cause CFs to be inconsistent upon restart. Before we fix
-    // the bug in auto recovery from WAL write failures that can flush one CF
-    // at a time, we set the error severity to fatal to disallow auto recovery.
-    // TODO: remove parameter `wal_related` once we can automatically recover
-    //  from WAL write failures.
-    bool auto_recovery = false;
-    Status bg_err(new_bg_io_err, Status::Severity::kFatalError);
-    CheckAndSetRecoveryAndBGError(bg_err);
-    ROCKS_LOG_WARN(db_options_.info_log,
-                   "ErrorHandler: A potentially WAL error happened, set "
-                   "background IO error as fatal error\n");
-    EventHelpers::NotifyOnBackgroundError(db_options_.listeners, reason,
-                                          &bg_err, db_mutex_, &auto_recovery);
-    recover_context_ = context;
-    return;
-  }
-
  if (bg_io_err.subcode() != IOStatus::SubCode::kNoSpace &&
      (bg_io_err.GetScope() == IOStatus::IOErrorScope::kIOErrorScopeFile ||
       bg_io_err.GetRetryable())) {
@@ -56,8 +56,7 @@ class ErrorHandler {
  Status::Severity GetErrorSeverity(BackgroundErrorReason reason,
                                    Status::Code code, Status::SubCode subcode);

-  void SetBGError(const Status& bg_err, BackgroundErrorReason reason,
-                  bool wal_related = false);
+  void SetBGError(const Status& bg_err, BackgroundErrorReason reason);

  Status GetBGError() const { return bg_error_; }

@@ -124,7 +124,6 @@ void EventHelpers::LogAndNotifyTableFileCreationFinished(
              << "comparator" << table_properties.comparator_name
              << "user_defined_timestamps_persisted"
              << table_properties.user_defined_timestamps_persisted
-              << "key_largest_seqno" << table_properties.key_largest_seqno
              << "merge_operator" << table_properties.merge_operator_name
              << "prefix_extractor_name"
              << table_properties.prefix_extractor_name << "property_collectors"
@@ -132,7 +131,6 @@ void EventHelpers::LogAndNotifyTableFileCreationFinished(
              << table_properties.compression_name << "compression_options"
              << table_properties.compression_options << "creation_time"
              << table_properties.creation_time << "oldest_key_time"
-              << table_properties.newest_key_time << "newest_key_time"
              << table_properties.oldest_key_time << "file_creation_time"
              << table_properties.file_creation_time
              << "slow_compression_estimated_data_size"
Author	SHA1	Message	Date
Peter Dillinger	ccfb1998b1	Version and history for 9.6.2	2024-11-01 08:35:24 -07:00
Peter Dillinger	ab03f7fb53	Fix a leak of open Blob files (#13106 ) Summary: An earlier change (https://github.com/facebook/rocksdb/commit/b34cef57b798520791312f2f40681c4d12d5d33c) removed apparently unused functionality where an obsolete blob file number is passed for removal from TableCache, which manages SST files. This was actually relying on broken/fragile abstractions wherein TableCache and BlobFileCache share the same Cache and using the TableCache interface to manipulate blob file caching. No unit test was actually checking for removal of obsolete blob files from the cache (which is somewhat tricky to check and a second order correctness requirement). Here we fix the leak and add a DEBUG+ASAN-only check in DB::Close() that no obsolete files are lingering in the table/blob file cache. Fixes https://github.com/facebook/rocksdb/issues/13066 Important follow-up (FIXME): The added check discovered some apparent cases of leaked (into table_cache) SST file readers that would stick around until DB::Close(). Need to enable that check, diagnose, and fix. Pull Request resolved: https://github.com/facebook/rocksdb/pull/13106 Test Plan: added a check that is called during DB::Close in ASAN builds (to minimize paying the cost in all unit tests). Without the fix, the check failed in at least these tests: ``` db_blob_basic_test DBBlobBasicTest.DynamicallyWarmCacheDuringFlush db_blob_compaction_test DBBlobCompactionTest.CompactionReadaheadMerge db_blob_compaction_test DBBlobCompactionTest.MergeBlobWithBase db_blob_compaction_test DBBlobCompactionTest.CompactionDoNotFillCache db_blob_compaction_test DBBlobCompactionTest.SkipUntilFilter db_blob_compaction_test DBBlobCompactionTest.CompactionFilter db_blob_compaction_test DBBlobCompactionTest.CompactionReadaheadFilter db_blob_compaction_test DBBlobCompactionTest.CompactionReadaheadGarbageCollection ``` Reviewed By: ltamasi Differential Revision: D65296123 Pulled By: pdillinger fbshipit-source-id: 2276d76482beb2c75c9010bc1bec070bb23a24c0	2024-11-01 08:34:20 -07:00
Peter Dillinger	fb6fa230c7	Add a temporary hook for custom yielding in long-running op (#13103 ) Summary: This is a simplified version of https://github.com/facebook/rocksdb/issues/13096, which called for a way to hook into long-running loops completely within RocksDB to change their thread priority (or similar). The current prime hook point is `DBIter::FindNextUserEntryInternal` likely because of iterating over tombstones. This is implemented using the weak symbol hack for ease of back-porting/patching, and while we get to know potential future requirements better for integration into the public API. (Consider potential relationships to `Env::GetThreadStatusUpdater()` and `TransactionDBMutexFactory`.) Pull Request resolved: https://github.com/facebook/rocksdb/pull/13103 Test Plan: Performance validated with db_bench and DEBUG_LEVEL=0: `./db_bench --benchmarks=fillseq,deleterandom,readseq[-X100] --value_size=1 --num=1000000` No consistent difference seen; variances likely in how DB / executable / memory were laid out. ``` With an empty hook: readseq [AVG 100 runs] : 1753018 (± 8850) ops/sec; 28.4 (± 0.1) MB/sec readseq [MEDIAN 100 runs] : 1763746 ops/sec; 28.6 MB/sec (recompile) readseq [AVG 100 runs] : 1789019 (± 10260) ops/sec; 29.0 (± 0.2) MB/sec readseq [MEDIAN 100 runs] : 1801849 ops/sec; 29.2 MB/sec Base: readseq [AVG 100 runs] : 1772196 (± 8240) ops/sec; 28.7 (± 0.1) MB/sec readseq [MEDIAN 100 runs] : 1780453 ops/sec; 28.9 MB/sec (recompile) readseq [AVG 100 runs] : 1777637 (± 7613) ops/sec; 28.8 (± 0.1) MB/sec readseq [MEDIAN 100 runs] : 1786657 ops/sec; 29.0 MB/sec With a functional hook (count number of calls into it): readseq [AVG 100 runs] : 1796733 (± 8854) ops/sec; 29.1 (± 0.1) MB/sec readseq [MEDIAN 100 runs] : 1804690 ops/sec; 29.3 MB/sec RocksDbThreadYield: 126915800 (recompile) readseq [AVG 100 runs] : 1775371 (± 10529) ops/sec; 28.8 (± 0.2) MB/sec readseq [MEDIAN 100 runs] : 1789046 ops/sec; 29.0 MB/sec RocksDbThreadYield: 126977000 Base: readseq [AVG 100 runs] : 1773071 (± 10657) ops/sec; 28.7 (± 0.2) MB/sec readseq [MEDIAN 100 runs] : 1783414 ops/sec; 28.9 MB/sec (recompile) readseq [AVG 100 runs] : 1750852 (± 10184) ops/sec; 28.4 (± 0.2) MB/sec readseq [MEDIAN 100 runs] : 1763587 ops/sec; 28.6 MB/sec ``` Reviewed By: george-reynya Differential Revision: D65235379 Pulled By: pdillinger fbshipit-source-id: 7829e4cc25a56d4c1801b8adf9c7f7aa49ab7aca	2024-11-01 08:34:20 -07:00
anand76	8d913b5b75	Fix a couple of missing cases of retry on corruption (#13007 ) Summary: For SST checksum mismatch corruptions in the read path, RocksDB retries the read if the underlying file system supports verification and reconstruction of data (`FSSupportedOps::kVerifyAndReconstructRead`). There were a couple of places where the retry was missing - reading the SST footer and the properties block. This PR fixes the retry in those cases. Pull Request resolved: https://github.com/facebook/rocksdb/pull/13007 Test Plan: Add new unit tests Reviewed By: jaykorean Differential Revision: D62519186 Pulled By: anand1976 fbshipit-source-id: 50aa38f18f2a53531a9fc8d4ccdf34fbf034ed59	2024-09-17 16:39:01 -07:00
Peter Dillinger	13d5230e5d	Fix flaky test DBTest2.VariousFileTemperatures (#12974 ) Summary: ... apparently due to potentially not purging obsolete files after CompactRange Example: https://github.com/facebook/rocksdb/actions/runs/10564621261/job/29267393711?pr=12959 Pull Request resolved: https://github.com/facebook/rocksdb/pull/12974 Test Plan: reproduced failure with USE_CLANG=1 COERCE_CONTEXT_SWITCH=1, now fixed Reviewed By: cbi42 Differential Revision: D61812600 Pulled By: pdillinger fbshipit-source-id: d4b23e1a179bb8ec39875ed7a8ce1649fa3344bd	2024-08-27 13:39:35 -07:00
Peter Dillinger	ca3418ca3d	Update version and HISTORY for 9.6.1	2024-08-24 08:41:51 -07:00
Peter Dillinger	daa63be3d6	Add Temperature to FileAttributes (#12965 ) Summary: .. so that appropriate implementations can return temperature information from GetChildrenFileAttributes Pull Request resolved: https://github.com/facebook/rocksdb/pull/12965 Test Plan: just an API placeholder for now Reviewed By: anand1976 Differential Revision: D61748199 Pulled By: pdillinger fbshipit-source-id: b457e324cb451e836611a0bf630c3da0f30a8abf	2024-08-24 08:39:51 -07:00
Peter Dillinger	aaa570b21f	Options for file temperature for more files (#12957 ) Summary: We have a request to use the cold tier as primary source of truth for the DB, and to best support such use cases and to complement the existing options controlling SST file temperatures, we add two new DB options: * `metadata_write_temperature` for DB "small" files that don't contain much user data * `wal_write_temperature` for WALs. Pull Request resolved: https://github.com/facebook/rocksdb/pull/12957 Test Plan: Unit test included, though it's hard to be sure we've covered all the places Reviewed By: jowlyzhang Differential Revision: D61664815 Pulled By: pdillinger fbshipit-source-id: 8e19c9dd8fd2db059bb15f74938d6bc12002e82b	2024-08-24 08:39:39 -07:00
eniac1024	f172876964	Fix MultiGet with timestamps (#12943 ) Summary: Issue: MultiGet(PinnableSlice) can't read out all timestamps. Fixed the impl, and added an UT as well. In the original impl, if MultiGet reads multiple column families, a later column family would clean up timestamps of previous column family. Fix: https://github.com/facebook/rocksdb/issues/12950#issue-2476996580 Pull Request resolved: https://github.com/facebook/rocksdb/pull/12943 Reviewed By: anand1976 Differential Revision: D61729257 Pulled By: pdillinger fbshipit-source-id: 55267c26076c8a59acedd27e14714711729a40df	2024-08-24 08:38:26 -07:00
Jay Huh	a2f796ff8f	Fix build for macos-arm64-macosx-clang17-no-san (#12949 ) Summary: When merged into internal code base we see the following error. This should fix it. ``` Actions failed: [2024-08-20T07:45:53.879-07:00] Action failed: fbcode//rocksdb/src:rocksdb_lib (cfg:macos-arm64-macosx-clang17-no-san#e5847010950663ca) (cxx_compile util/write_batch_util.cc) [2024-08-20T07:45:53.879-07:00] Remote command returned non-zero exit code 1 [2024-08-20T07:45:53.879-07:00] Remote action, reproduce with: `frecli cas download-action 2fe3749f2d3ea6107cce103d4e2be1dcc76a9df797bae308cde5eaccc65201b7:145` fbcode/rocksdb/src/include/rocksdb/write_batch.h:460:14: error: no template named 'unordered_map' in namespace 'std'; did you mean 'unordered_set'? const std::unordered_map<uint32_t, size_t>& GetColumnFamilyToTimestampSize() { ~~~~~^~~~~~~~~~~~~ fbcode/rocksdb/src/include/rocksdb/write_batch.h:540:8: error: no template named 'unordered_map' in namespace 'std'; did you mean 'unordered_set'? std::unordered_map<uint32_t, size_t> cf_id_to_ts_sz_; ~~~~~^~~~~~~~~~~~~ /paragon/pods/259551525/home/execution/3/202ac945754041b6bc424b0c35e42c9d/work/buck-out/v2/gen/fbsource/a90614bbe22ec1d7/xplat/toolchains/minimal_xcode/__clang_genrule__/out/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__memory/compressed_pair.h:113:3: error: static_assert failed due to requirement '!is_same<unsigned long, unsigned long>::value' "__compressed_pair cannot be instantiated when T1 and T2 are the same type; The current implementation is NOT ABI-compatible with the previous implementation for this configuration" static_assert((!is_same<_T1, _T2>::value), ^ ~~~~~~~~~~~~~~~~~~~~~~~~~ ``` Pull Request resolved: https://github.com/facebook/rocksdb/pull/12949 Test Plan: CI Reviewed By: jowlyzhang, cbi42 Differential Revision: D61577604 Pulled By: jaykorean fbshipit-source-id: 3584a2cd550a303346d80ccc5cc90f4a9b3e2da2	2024-08-21 10:36:04 -07:00
Jay Huh	83a2e71b9a	fix version.h	2024-08-21 10:24:35 -07:00
Jay Huh	96315e9aa9	Fix HISTORY.md file for 9.6 release	2024-08-19 20:26:26 -07:00
Jay Huh	becf8684e3	Include two more changes in 9.6	2024-08-19 14:15:51 -07:00
Jay Huh	67bfca5117	9.6 release cut	2024-08-19 14:15:06 -07:00