v11.12

New Features

• Added FullExternalTableFactory and related full-mode external table APIs that preserve RocksDB internal keys, enabling external tables to support nonzero sequence numbers, point and single deletions, merge operands, blob indexes, wide-column entities, snapshots, live DB writes, and multi-level compactions.

Public API Changes

• Added experimental coroutine capability interfaces for basic and full ExternalTableReader implementations. Coroutine-capable external readers can initiate file reads through FSRandomAccessFile::SubmitReadAsync().
• ExternalTableFactory::NewTableReader() now receives an already-opened FSRandomAccessFile and its file size instead of requiring implementations to reopen file_path. The supplied file preserves RocksDB's direct-I/O alignment handling, rate limiting, read statistics and listener notifications, prefetching, and synchronous, asynchronous, and batched reads.
• Added PutRangeDeletionBlock(), GetRangeDeletionBlock(), and IsDeleteRangeSupported() to the external table interfaces so formats can opt in to range deletions using RocksDB's raw range-deletion metadata block.
• Opaque PreparedFileInfo metadata can now be serialized to a checksummed representation with SerializePreparedFileInfo() and restored with DeserializePreparedFileInfo() for reuse across processes.
• Removed the deprecated IngestExternalFileOptions::write_global_seqno option and its C, Java, and ldb APIs, TableProperties::external_sst_file_global_seqno_offset, and the file_offset output from ExternalTableReader::GetPropertiesBlock(). Existing external SST files whose global sequence number was rewritten without updating the properties-block checksum remain readable.
• TablePropertiesNames has no apparent use in the public API so has been deprecated there.
• TableProperties::creation_time is renamed to oldest_ancestor_time, which better describes its meaning, along with TablePropertiesNames::kCreationTime to kOldestAncestorTime. The misspelled SstFileMetaData::oldest_ancester_time is renamed to oldest_ancestor_time. The old names remain available as deprecated aliases and will be removed in a future release.
• Added WriteBufferFlushPolicy and WriteBufferManager policy selection for flushing the oldest or largest column family, including configurable batched flushing of the largest column families across DBs sharing a manager, with C and Java bindings.

Behavior Changes

• When ExternalTableBuilderBase::PutPropertiesBlock() returns NotSupported, RocksDB now overrides num_entries, raw_key_size, and raw_value_size from ExternalTableBuilderBase::GetTableProperties() with the logical totals tracked by the external-table adapter. Format-specific properties such as data_size remain unchanged.
• The FSWritableFile passed to ExternalTableFactory::NewTableBuilder() now reports logical file size including RocksDB-buffered data and exposes the underlying file's direct-I/O mode and required buffer alignment.
• Iterator::Refresh() now returns NotSupported on iterators from a secondary DB's DB::NewIterators() only, because those iterators are pinned to one cross-column-family read view. Iterators from DB::NewIterator() are unaffected; to advance a batch, call DB::NewIterators() again after TryCatchUpWithPrimary().
• SstFileReader now reports standard SST read statistics and file I/O listener notifications, and honors the configured read rate limiter.

Bug Fixes

• Fixed full recovery from retryable background errors to atomically advance WAL replay boundaries for all column families, preventing partial recovery of multi-column-family write batches after a failed recovery flush.
• Fixed RocksDB builds on big-endian architectures such as s390x by disabling the optional persistent fault-injection log, whose binary format is little-endian-only.
• Fixed DB::ClipColumnFamily() deleting a non-L0 SST file whose largest key equals begin_key, which lost keys at the start of the kept range.
• Fixed swapped oldest_key_time and newest_key_time values in the table_file_creation event log entry.
• Fixed ExternalTableReader::VerifyChecksum() results not being honored by the external table adapter.
• Fixed a bug in manifest handling that could lead to a hang or memory corruption in the case of LSM sanity checks being fatally violated (exceptional; see force_consistency_checks).
• Fixed MultiGet() with ReadOptions::read_tier == kBlockCacheTier reading data blocks from disk when allow_mmap_reads is false. Keys whose data block is not in the block cache now return Status::Incomplete(), the same as Get().
• Fixed trace replay (DB::NewDefaultReplayer(), db_bench replay) failing every read record (Get, MultiGet, iterator seek) on the default column family with Corruption: Invalid Column Family ID when the default column family handle was not passed, which is always the case in db_bench with --num_column_families=1.
• Fixed multi-threaded Replayer::Replay() ignoring errors from executing trace records and returning OK. It now stops and returns the error, including Status::NotSupported() from executing a record, as single-threaded replay does.
• Fixed secondary DB NewIterators() returning iterators from different database states or blocking for TryCatchUpWithPrimary() by serving the last completed catch-up view.

Performance Improvements

• Single Get coroutine reads using non-mmap, non-direct I/O on a kFSBuffer-capable FileSystem now use FSRandomAccessFile::SubmitReadAsync() instead of falling back to synchronous Read(). When rate-limited, these reads acquire their full token budget before submission to preserve a single filesystem-owned buffer, which can make physical I/O burstier than reads using caller-provided buffers.

RocksDB 11.8.1

11.8.1 (2026-07-28)

Public API Changes

• Add DBOptions::read_io_executor_threads to increase the maximum thread count of the shared filesystem read I/O executor used for asynchronous reads when opening a DB. Opening a DB never reduces the shared executor thread count. Change the experimental FSRandomAccessFile::SubmitReadAsync() API to return whether the asynchronous path was used, and add the FILE_SUBMIT_ASYNC_READ_FALLBACK ticker to count calls that fall back to synchronous reads.

Performance Improvements

• When DBOptions::avoid_unnecessary_blocking_io is true, obsolete OPTIONS-* files found during DB open are deleted by background purge instead of synchronously on the opening thread.

11.8.0 (2026-07-28)

Public API Changes

• Add callback-based asynchronous read APIs, DB::GetAsync() and DB::MultiGetAsync(). The idea is that when IO is required, RocksDB can suspend its internal coroutine read path, allowing the read executor thread to do other work. When the IO is complete, RocksDB invokes the user callback. This requires filesystem support for full performance benefits. A new filesystem API FSRandomAccessFile::SubmitReadAsync() is introduced for this. Unlike ReadAsync, the filesystem is responsible for eventually calling the callback. FileSystem::GetReadExecutor() returns the IO executor whose EventBases run coroutine read processing. In the Posix filesystem, an IO-uring based event loop is used to complete the IO.
• Added FlushOptions::listener_wait (default false). When set together with FlushOptions::wait == true, DB::Flush() will not return until the registered EventListener::OnFlushCompleted callbacks for the flushed memtables have finished running. By default (false), Flush(wait=true) may return as soon as the flush result is committed, which can be before (or while) the OnFlushCompleted callbacks execute on the background flush thread. Also added the corresponding C API rocksdb_flushoptions_set_listener_wait() / rocksdb_flushoptions_get_listener_wait().
• Deprecated PinnableWideColumns::serialized_size() in favor of the new PinnableWideColumns::payload_size(), which returns the total size of the columns' names and values (for a plain value this equals the value size). Relatedly, wide-column read accounting changed subtly: read statistics for entities (BYTES_READ, BYTES_PER_READ, and the per-key byte counts for GetEntity/MultiGetEntity) and the ReadOptions::value_size_soft_limit threshold now measure entities by this payload size instead of the serialized entity size. This drops serialization framing bytes from those measurements (so reported/limited sizes for entity reads are slightly smaller than before) and makes plain-value and wide-column accounting consistent.

Behavior Changes

• ReadOptions::value_size_soft_limit now also bounds the blob values resolved from pre-flush blob direct write references during MultiGet/MultiGetEntity (previously these were resolved after the limit check and read without bound). Enforcement is "always make progress": at least one key is read even if its value alone exceeds the limit, and only once the returned size exceeds the limit do subsequent keys get Status::Aborted -- so a caller retrying the aborted keys cannot loop forever on a single value that by itself exceeds the limit.

Performance Improvements

• Reduced copying when reading wide-column entities that have blob-referenced columns, whether stored in separate blob files or embedded (same-file) as blob records in the same SST. On the point-lookup (GetEntity/MultiGetEntity) and blob-backed memtable/direct-write read paths, resolving these columns no longer re-serializes the whole entity into a fresh buffer: inline columns are referenced in place in the pinned entity and each resolved blob value is referenced in place from its fetched buffer. This is enabled by an internal change to PinnableWideColumns that lets its columns reference multiple backing buffers.

11.7.0 (2026-07-16)

Public API Changes

• Added RangeLockManagerHandle::SetIsKilledCallback(), a std::function<bool()> predicate polled during range-lock waits. When it returns true, a blocked GetRangeLock() wait returns promptly with Status::Aborted() instead of waiting for the lock timeout. Range-lock users that install no callback keep the original wait-until-grant-or-timeout behavior.
• Added MultiScanArgs::reverse to support reverse MultiScan reads over bounded scan ranges.

Behavior Changes

• When using LockWAL(), live-file capture APIs such as checkpoint and backup now flush WAL-disabled unpersisted data; they can block until UnlockWAL() or return Aborted when called from the same thread that holds LockWAL() to avoid deadlock. UnlockWAL() must now also be called from the same thread that called LockWAL().

Performance Improvements

• Fixed slow DB open with best_efforts_recovery, and slow catch-up of secondary and follower (read-only) instances, in which time and memory grew quadratically with the number of files in the DB (so the slowdown was worst for large DBs with long history).

11.6.0 (2026-07-02)

New Features

• Added EXPERIMENTAL embedded blob SST support through SstFileWriter::OpenWithEmbeddedBlobs(), storing eligible large values as same-file blob records in block-based SST files and resolving them transparently for reads. This niche feature currently supports uncompressed embedded blobs only; compression options are placeholders and compression support is deferred to follow-up work.

Public API Changes

• Expanded the C API (include/rocksdb/c.h) with a large set of new rocksdb_* functions, mostly option getters/setters plus table-properties, job/event-listener, and metadata accessors, a WAL filter, a ReadOptions table filter, and a backup exclude-files callback. Many are now produced by a new semi-automated generator (tools/c_api_gen/) from the C++ headers; include/rocksdb/c.h remains a single self-contained header and the signatures of pre-existing functions are unchanged.

Bug Fixes

• Reverted PR14831 that made range_lock_manager aware of reverse-order CF
• Fixed a bug in RandomAccessFileReader::ReadAsync where an already-aligned direct-IO read request with a null scratch and a caller-provided aligned_buf would take the "already aligned" fast path and submit the null buffer to the underlying async read (e.g. a null iovec base to io_uring, failing with EFAULT). This could surface as spurious iterator failures during async prefetch (MultiScan with async IO) on direct-IO databases. The async path now allocates a backing buffer in this case, matching the synchronous Read path.
• Fixed a bug where closing a read-only DB instance could delete live SST files created by a concurrent read-write DB sharing the same directory.

11.5.0 (2026-06-16)

New Features

• External table readers that open files through ExternalTableOptions::fs now update RocksDB SST/file-read statistics and file IO listener callbacks, making external file IO activity visible in existing read metrics.
• Added DB::PrepareFileIngestion(), a two-phase form of IngestExternalFile/IngestExternalFiles. PrepareFileIngestion() performs all of the work that does not require the DB mutex (validating the arguments, reading each external file's metadata, and linking/copying the files into the DB) and returns an opaque FileIngestionHandle. DB::CommitFileIngestionHandle() (or DB::CommitFileIngestionHandles() for several handles at once) then makes the prepared files visible; multiple handles are committed atomically in a single MANIFEST write, or none are. FileIngestionHandle::Abort() (or simply destroying the handle) cancels a prepared ingestion and rolls it back. This gives flexibility to the application to Prepare a file separately from when its committed, and may shorten an applications critical path on IngestExternalFile.
• Added two stats histograms reporting the per-call latency (in microseconds) of each successful IngestExternalFile/IngestExternalFiles call, split by phase: rocksdb.ingest.external.file.prepare.micros (argument validation and reading/validating/linking the external files, which does not block live writes) and rocksdb.ingest.external.file.run.micros (the ingestion performed under the DB mutex while live writes are blocked). Failed ingestions are not recorded.
• Added DBOptions::use_direct_io_for_compaction_reads (default false). When enabled, compaction-input SST reads use O_DIRECT while user reads remain buffered, avoiding page-cache eviction of hot user-read data by sequential compaction scans. Pair with use_direct_io_for_flush_and_compaction = true on write-heavy workloads for direct I/O on both compaction inputs and outputs. Rejected at Open when combined with allow_mmap_reads = true. No-op when use_direct_reads = true is already set (since all reads are already direct).

Public API Changes

• DB::GetPreparedFileInfoForExternalSstIngestion() can now prepare metadata for a live DB-generated SST file so it can be passed to IngestExternalFileArg::file_infos. The input path must exactly match a live table file owned by the source DB, and the returned metadata handle must outlive the ingestion.
• ExternalSstFileInfo gained a prepared_file_info member produced by SstFileWriter::Finish, and IngestExternalFileArg gained a file_infos field: a vector of borrowed const PreparedFileInfo* pointers, parallel to external_files. The owning ExternalSstFileInfo::prepared_file_info handle must outlive the ingestion. When set, IngestExternalFiles() reuses the supplied per-file metadata instead of re-opening and scanning each file to recompute it, avoiding that extra I/O.
• Corrected the public C++ option spelling from memtable_veirfy_per_key_checksum_on_seek to `memtable_verify_per_key_checksum_on_s...

RocksDB 11.1.2

11.1.2 (2026-06-24)

Bug Fixes

• Fixed a bug where closing a read-only DB instance could delete live SST files created by a concurrent read-write DB sharing the same directory.

11.1.1 (2026-04-10)

Public API Changes

• Changed experimental feature ExternalTableReader::Get and ExternalTableReader::MultiGet to use PinnableSlice instead of std::string for output values, enabling zero-copy pinning. This will break existing implementations.
• Added SstFileReader::Get and SstFileReader::MultiGet overloads that accept PinnableSlice/std::vector<PinnableSlice>*, enabling zero-copy reads when the underlying TableReader supports pinning.
• Added block_decompress_count to PerfContext

Bug Fixes

• Fix a memory accounting leak in IODispatcher where ReadIndex() moved block values out of ReadSet without releasing the associated prefetch memory, causing subsequent prefetches to be blocked when max_prefetch_memory_bytes was set.

11.1.0 (2026-03-23)

New Features

• Add a new option open_files_async. The existing behavior is on DB open, we open all sst files and do basic validations. For very large DBs on remote filesystems with many ssts, this may take very long. This option performs these validations instead in the background. Open errors found by this async background task are surfaced as a new background error kAsyncFileOpen.
• Added BlockBasedTableOptions::kAuto index block search type that automatically selects between binary and interpolation search on a per-index-block basis. During SST construction, each index block's key distribution uniformity is analyzed using the coefficient of variation of key gaps, and index blocks with uniform keys use interpolation search while others fall back to binary search. The uniformity threshold is configurable via BlockBasedTableOptions::uniform_cv_threshold (default: 0.2).
• Introduced enforce_write_buffer_manager_during_recovery option to allow WriteBufferManager to be enforced during WAL recovery. (Default: true)
• Add memtable_batch_lookup_optimization option to use batch lookup optimization for memtable MultiGet. For skip list memtables, after each key lookup, the search path is cached and reused for the next key, reducing per-key cost from O(log N) to O(log d) where d is the distance between consecutive keys. Benchmarks show ~7% improvement in memtable-resident MultiGet throughput.
• Added BlockBasedTableOptions::PrepopulateBlockCache::kFlushAndCompaction to prepopulate the block cache during both flush and compaction. Compaction-warmed blocks are inserted at BOTTOM priority (vs LOW for flush) so they are evicted first under cache pressure. Recommended only for use cases where most or all of the database is expected to reside in cache (e.g., tiered or remote storage where the working set fits in cache).
• Added new mutable DB option verify_manifest_content_on_close (default: false). When enabled, on DB close the MANIFEST file is read back and all records are validated (CRC checksums and logical content). If corruption is detected, a fresh MANIFEST is written from in-memory state.

RocksDB 11.1.1

11.1.1 (2026-04-10)

Public API Changes

• Changed experimental feature ExternalTableReader::Get and ExternalTableReader::MultiGet to use PinnableSlice instead of std::string for output values, enabling zero-copy pinning. This will break existing implementations.
• Added SstFileReader::Get and SstFileReader::MultiGet overloads that accept PinnableSlice/std::vector<PinnableSlice>*, enabling zero-copy reads when the underlying TableReader supports pinning.
• Added block_decompress_count to PerfContext

Bug Fixes

• Fix a memory accounting leak in IODispatcher where ReadIndex() moved block values out of ReadSet without releasing the associated prefetch memory, causing subsequent prefetches to be blocked when max_prefetch_memory_bytes was set.

11.1.0 (2026-03-23)

New Features

• Add a new option open_files_async. The existing behavior is on DB open, we open all sst files and do basic validations. For very large DBs on remote filesystems with many ssts, this may take very long. This option performs these validations instead in the background. Open errors found by this async background task are surfaced as a new background error kAsyncFileOpen.
• Added BlockBasedTableOptions::kAuto index block search type that automatically selects between binary and interpolation search on a per-index-block basis. During SST construction, each index block's key distribution uniformity is analyzed using the coefficient of variation of key gaps, and index blocks with uniform keys use interpolation search while others fall back to binary search. The uniformity threshold is configurable via BlockBasedTableOptions::uniform_cv_threshold (default: 0.2).
• Introduced enforce_write_buffer_manager_during_recovery option to allow WriteBufferManager to be enforced during WAL recovery. (Default: true)
• Add memtable_batch_lookup_optimization option to use batch lookup optimization for memtable MultiGet. For skip list memtables, after each key lookup, the search path is cached and reused for the next key, reducing per-key cost from O(log N) to O(log d) where d is the distance between consecutive keys. Benchmarks show ~7% improvement in memtable-resident MultiGet throughput.
• Added BlockBasedTableOptions::PrepopulateBlockCache::kFlushAndCompaction to prepopulate the block cache during both flush and compaction. Compaction-warmed blocks are inserted at BOTTOM priority (vs LOW for flush) so they are evicted first under cache pressure. Recommended only for use cases where most or all of the database is expected to reside in cache (e.g., tiered or remote storage where the working set fits in cache).
• Added new mutable DB option verify_manifest_content_on_close (default: false). When enabled, on DB close the MANIFEST file is read back and all records are validated (CRC checksums and logical content). If corruption is detected, a fresh MANIFEST is written from in-memory state.

Behavior Changes

• num_reads_sampled now factors in re-seeks and next/prev() on file iterators for files in L1+. next/prev() is discounted by 64x compared to seek due to being a much cheaper call.
• Remote compaction workers now skip WAL recovery when opening the secondary DB instance, since only the LSM state from MANIFEST is needed for compaction. This reduces I/O and speeds up remote compaction startup.

Bug Fixes

• Fix a bug in round-robin compaction that missed selecting input files that are needed to guarantee data correctness and cause crashing in debug builds or silent data corruption in release builds for Get().

v11.0.4

11.0.4 (2026-03-11)

Public API Changes

• Re-remove deprecated DB::Open raw pointer variants in db.h

11.0.3 (2026-03-03)

Public API Changes

• Relax option sanitization for kv ratio compaction

11.0.2 (2026-02-26)

Public API Changes

• Revert removing deprecated DB::Open raw pointer variants in db.h

11.0.0 (2026-02-23)

New Features

• Added support for storing wide-column entity column values in blob files. When min_blob_size is configured, large column values in wide-column entities will be stored in blob files, reducing SST file size and improving read performance.
• Added CompactionOptionsFIFO::max_data_files_size to support FIFO compaction trimming based on combined SST and blob file sizes. Added CompactionOptionsFIFO::use_kv_ratio_compaction to enable a capacity-derived intra-L0 compaction strategy optimized for BlobDB workloads, producing uniform-sized compacted files for predictable FIFO trimming.
• Include interpolation search as an alternative to binary search, which typically performs better when keys are uniformly distributed. This is exposed as a new table option index_block_search_type. The default is binary_search.

Public API Changes

• Added new virtual methods AbortAllCompactions() and ResumeAllCompactions() to the DB class. Added new Status::SubCode::kCompactionAborted to indicate a compaction was aborted. Added Status::IsCompactionAborted() helper method to check if a status represents an aborted compaction.
• Drop support for reading (and writing) SST files using BlockBasedTableOptions.format_version < 2, which hasn't been the default format for about 10 years. An upgrade path is still possible with full compaction using a RocksDB version >= 4.6.0 and < 11.0.0 and then using the newer version.
• Remove deprecated raw DB* variants of DB::Open and related functions. Some other minor public APIs were updated as a result
• Remove deprecated DB::MaxMemCompactionLevel()
• Remove useless option CompressedSecondaryCacheOptions::compress_format_version
• Remove deprecated DB option skip_checking_sst_file_sizes_on_db_open. The option was deprecated in 10.5.0 and has been a no-op since then. File size validation is now always performed in parallel during DB open.
• Remove deprecated SliceTransform::InRange() virtual method and the in_range callback parameter from rocksdb_slicetransform_create() in the C API. InRange() was never called by RocksDB and existed only for backward compatibility.
• Remove deprecated, unused APIs and options: ReadOptions::managed and ColumnFamilyOptions::snap_refresh_nanos. Corresponding C and Java APIs are also removed.
• Remove deprecated SstFileWriter::Add() method (use Put() instead) and the deprecated skip_filters parameter from SstFileWriter constructors (use BlockBasedTableOptions::filter_policy set to nullptr to skip filter generation instead).

Behavior Changes

• Change the default value of CompactionOptionsUniversal::reduce_file_locking from false to true to improve write stall and reduce read regression

Bug Fixes

• Fix longstanding failures that can arise from reading and/or compacting old DB dirs with range deletions (likely from version < 5.19.0) in many newer versions.
• Fix a bug where WritePrepared/WriteUnprepared TransactionDB with two_write_queues=true could experience "sequence number going backwards" corruption during recovery from a background error, due to allocated-but-not-published sequence numbers not being synced before creating new WAL files.

Performance Improvements

• Add a new table option separate_key_value_in_data_block. When set to true keys and values will be stored separately in the data block, which can result in higher cpu cache hit rate and better compression. Works best with data blocks with sufficient restart intervals and large values. Previous versions of RocksDB will reject files written using this option.

v10.10.1

10.10.1 (2026-02-02)

Bug Fixes

• Fixed a bug in best-efforts recovery that causes use-after-free crashes when accessing SST files that were cached during the recovery.
• Fix resumable compaction incorrectly allowing resumption from a truncated range deletion that is not well handled currently.
• Fixed a bug in PosixRandomFileAccess IO uring submission queue ownership & management. Fix eliminates the false positive 'Bad cqe data' IO errors in PosixRandomFileAccess::MultiRead when interleaved with PosixRandomFileAccess::ReadAsync on the same thread.
• Fix Windows VS 2022 build errors.

v8.11.5

8.11.5 (2025-11-26)

Behavior Changes

• Backport new value types kTypeValuePreferredSeqno and kTypeColumnFamilyValuePreferredSeqno introduced in RocksDB 9.1. This fixes a forward compatibility issue to allow reading MANIFEST with entries containing kTypeMaxValid written by RocksDB 9.1+.

v10.9.1

10.9.1 (2025-12-11)

Bug Fixes

• Fix resumable compaction incorrectly allowing resumption from a truncated range deletion that is not well handled currently.

10.9.0 (2025-11-21)

New Features

• Added an auto-tuning feature for DB manifest file size that also (by default) improves the safety of existing configurations in case max_manifest_file_size is repeatedly exceeded. The new recommendation is to set max_manifest_file_size to something small like 1MB and tune max_manifest_space_amp_pct as needed to balance write amp and space amp in the manifest. Refer to comments on those options in DBOptions for details. Both options are (now) mutable.
• Added a new API to support option migration for multiple column families
• Added new option target_file_size_is_upper_bound that makes most compaction output SST files come close to the target file size without exceeding it, rather than commonly exceeding it by some fraction (current behavior). For now the new behavior is off by default, but we expect to enable it by default in the future.
• Add a new option allow_trivial_move in CompactionOptions to allow CompactFiles to perform trivial move if possible. By default the flag of allow_trivial_move is false, so it preserve the original behavior.

Public API Changes

• To reduce risk of ODR violations or similar, ROCKSDB_USING_THREAD_STATUS has been removed from public headers and replaced with static const bool ThreadStatus::kEnabled. Some other uses of conditional compilation have been removed from public API headers to reduce risk of ODR violations or other issues.

Behavior Changes

• PosixWritableFile now repositions the seek pointer to the new end of file after a call to Truncate.
• Updated standalone range deletion L0 file compaction behavior to avoid compacting with any newer L0 files (which is expensive and not useful).

Bug Fixes

• Fix a bug where compaction with range deletion can persist kTypeMaxValid in MANIFEST as file metadata. kTypeMaxValid is not supposed to be persisted and can change as new value types are introduced. This can cause a forward compatibility issue where older versions of RocksDB don't recognize kTypeMaxValid from newer versions. A new placeholder value type kTypeTruncatedRangeDeletionSentinel is also introduced to replace kTypeMaxValid when reading existing SST files' metadata from MANIFEST. This allows us to strengthen some checks to avoid using kTypeMaxValid in the future.
• Fixed a bug where DB::GetSortedWalFiles() could hang when waiting for a purge operation that found nothing to do (potentially triggered by iterator release, flush, compaction, etc.).
• Fixed a bug in MultiScan where max_sequential_skip_in_iterations could cause the iterator to seek backward to already-unpinned blocks when the same user key spans multiple data blocks, leading to assertion failures or seg fault.
• Fixed a bug for WAL_ttl_seconds > 0 use cases where the newest archived WAL files could be incorrectly deleted when the system clock moved backwards.

Performance Improvements

• Added optimization that allowed for the asynchronous prefetching of all data outlined in a multiscan iterator. This optimization was applied to the level iterator, which prefetches all data through each of the block-based iterators.

v10.8.3

10.8.3 (2025-11-10)

New Features

• Add a GetColumnFamilyMetaData API variant in DB to get the SST files intersecting a given key range.

10.8.2 (2025-11-07)

New Features

• Added an auto-tuning feature for DB manifest file size that also (by default) improves the safety of existing configurations in case max_manifest_file_size is repeatedly exceeded. The new recommendation is to set max_manifest_file_size to something small like 1MB and tune max_manifest_space_amp_pct as needed to balance write amp and space amp in the manifest. Refer to comments on those options in DBOptions for details. Both options are (now) mutable.
• Add a new option allow_trivial_move in CompactionOptions to allow CompactFiles to perform trivial move if possible. By default the flag of allow_trivial_move is false, so it preserve the original behavior.

10.8.1 (2025-10-29)

Behavior Changes

• PosixWritableFile now repositions the seek pointer to the new end of file after a call to Truncate.

10.8.0 (2025-10-21)

New Features

• Add kFSPrefetch to FSSupportedOps enum to allow file systems to indicate prefetch support capability, avoiding unnecessary prefetch system calls on file systems that don't support them.
• Added experimental support OpenAndCompactOptions::allow_resumption for resumable compaction that persists progress during OpenAndCompact(), allowing interrupted compactions to resume from the last progress persitence. The default behavior is to not persist progress.

Public API Changes

• Allow specifying output temperature in CompactionOptions
• Added DB::FlushWAL(const FlushWALOptions&) as an alternative to DB::FlushWAL(bool sync), where FlushWALOptions includes a new rate_limiter_priority field (default Env::IO_TOTAL) that allows rate limiting and priority passing of manual WAL flush's IO operations.
• The MultiScan API contract is updated. After a multi scan range got prepared with Prepare API call, the following seeks must seek the start of each prepared scan range in order. In addition, when limit is set, upper bound must be set to the same value of limit before each seek

Behavior Changes

• kChangeTemperature FIFO compaction will now honor compaction_target_temp to all levels regardless of cf_options::last_level_temperature
• Allow UDIs with a non BytewiseComparator

Bug Fixes

• Fix incorrect MultiScan seek error status due to bugs in handling range limit falling between adjacent SST files key range.
• Fix a bug in Page unpinning in MultiScan

Performance Improvements

• Fixed a performance regression in LZ4 compression that started in version 10.6.0

v10.7.5

10.7.5 (2025-10-20)

Bug Fixes

• Fix a bug in Page unpinning in MultiScan

10.7.4 (2025-10-14)

Public API Changes

• The MultiScan API contract is updated. After a multi scan range got prepared with Prepare API call, the following seeks must seek the start of each prepared scan range in order. In addition, when limit is set, upper bound must be set to the same value of limit before each seek

10.7.3 (2025-10-06)

Bug Fixes

• Fix a few bugs in MultiScan

10.7.2 (2025-09-30)

Bug Fixes

• Fix incorrect MultiScan seek error status due to bugs in handling range limit falling between adjacent SST files key range.

Performance Improvements

• Fixed a performance regression in LZ4 compression that started in version 10.6.0

10.7.0 (2025-09-24)

New Features

• Add the fail_if_no_udi_on_open flag in BlockBasedTableOption to control whether a missing user defined index block in a SST is a hard error or not.
• A new flag memtable_veirfy_per_key_checksum_on_seek is added to AdvancedColumnFamilyOptions. When it is enabled, it will validate key checksum along the binary search path on skiplist based memtable during seek operation.
• Introduce option MultiScanArgs::use_async_io to enable asynchronous I/O during MultiScan, instead of waiting for I/O to be done in Prepare().
• Add new option MultiScanArgs::max_prefetch_size that limits the memory usage of per file pinning of prefetched blocks.
• Improved sst_dump by allowing standalone file and directory arguments without --file=. Also added new options and better output for sst_dump --command=recompress. See sst_dump --help

Public API Changes

• HyperClockCache with no estimated_entry_charge is now production-ready and is the preferred block cache implementation vs. LRUCache. Please consider updating your code to minimize the risk of hitting performance bottlenecks or anomalies from LRUCache. See cache.h for more detail.
• RocksDB now requires a C++20 compatible compiler (GCC >= 11, Clang >= 10, Visual Studio >= 2019), including for any code using RocksDB headers.
• MultiScanArgs used to have a default constructor with default parameter of BytewiseComparator. Now it always requires Comparator in its constructor.

Behavior Changes

• The default provided block cache implementation is now HyperClockCache instead of LRUCache, when block_cache is nullptr (default) and no_block_cache==false (default). We recommend explicitly creating a HyperClockCache block cache based on memory budget and sharing it across all column families and even DB instances. This change could expose previously hidden memory or resource leaks.
• Allow UDIs with a non BytewiseComparator

Bug Fixes

• Reported numbers for compaction and flush CPU usage now include time spent by parallel compression worker threads. This now means compaction/flush CPU usage could exceed the wall clock time.
• Fix a race condition in FIFO size-based compaction where concurrent threads could select the same non-L0 file, causing assertion failures in debug builds or "Cannot delete table file from LSM tree" errors in release builds.
• Fix a bug in RocksDB MultiScan with UDI when one of the scan ranges is determined to be empty by the UDI, which causes incorrect results.

Performance Improvements

• Add a new table property "rocksdb.key.smallest.seqno" which records the smallest sequence number of all keys in file. It makes ingesting DB generated files faster by
  avoiding scanning the whole file to find the smallest sequence number.
• Add a new experimental PerKeyPointLockManager to improve efficiency under high lock contention. PointLockManager was not efficient when there is high write contention on same key, as it uses a single conditional variable per lock stripe. PerKeyPointLockManager uses per thread conditional variable supporting fifo order. Although this is an experimental feature. By default, it is disabled. A new boolean flag TransactionDBOptions::use_per_key_point_lock_mgr is added to optionally enable it. Search the flag in code for more info.
  Together, a new configuration TransactionOptions::deadlock_timeout_us is added, which allows the transaction to wait for a short period before perform deadlock detection. When the workload has low lock contention, the deadlock_timeout_us can be configured to be slightly higher than average transaction execution time, so that transaction would likely be able to take the lock before deadlock detection is performed when it is waiting for a lock. This allows transaction to reduce CPU cost on performing deadlock detection, which could be expensive in CPU time. When the workload has high lock contention, the deadlock_timeout_us can be configured to 0, so that transaction would perform deadlock detection immediately. By default the value is 0 to keep the behavior same as before.
• Majorly improved CPU efficiency and scalability of parallel compression (CompressionOptions::parallel_threads > 1), though this efficiency improvement makes parallel compression currently incompatible with UserDefinedIndex and with old setting of decouple_partitioned_filters=false. Parallel compression is now considered a production-ready feature. Maximum performance is available with -DROCKSDB_USE_STD_SEMAPHORES at compile time, but this is not currently recommended because of reported bugs in implementations of std::counting_semaphore/binary_semaphore.