11.13.2 (10/28/2026)

Bug Fixes

• Fixed a secondary instance with open_files_async = true getting stuck after TryCatchUpWithPrimary() returned PathNotFound for a table file that the primary deleted before the background opener reached it.
• Fixed blob direct write with more than one concurrent flush of a column family: a later flush sealed and published the blob files of the oldest pending memtable instead of its own, so flushes failed with Corruption: VersionBuilder: Blob file #N already added and the database stopped.

11.13.1 (10/23/2026)

Bug Fixes

• Fixed data loss with min_tombstones_for_range_conversion and external file ingestion. An iterator whose view predated the ingestion could convert the deleted keys around the ingested keys into a range tombstone that deleted them. This happened when the file got no new sequence number (sequence number zero, ingest_behind, or allow_db_generated_files), and when an iterator was created during the ingestion.
• Fixed a data loss bug where an iterator with ReadOptions::read_tier = kMemtableTier could, with min_tombstones_for_range_conversion enabled, insert a range tombstone that deleted live keys stored only in SST files. Read-path range tombstone conversion now runs only for iterators with read_tier = kReadAllTier.

11.13.0 (10/21/2026)

New Features

• Added FileSystem::IsPreallocationSupported(). A FileSystem that never preallocates file space can return false so that DB open skips reopening and truncating the last WAL file.

Public API Changes

• Added the experimental DBOptions::track_options_file_number_in_manifest
  rollout option (with C and Java bindings). The option is persisted in each
  OPTIONS file. When enabled, RocksDB durably creates an OPTIONS file and then
  commits its file number in MANIFEST. Column-family create/drop commits the
  configuration snapshot and membership in one MANIFEST record. A newer tracked
  OPTIONS file without a commit is ignored after a crash, while a newer OPTIONS
  file written with tracking disabled retains the legacy highest-numbered-file
  behavior. Batched column-family changes publish one snapshot; after partial
  success it can be a safe superset that persisted-options APIs filter against
  live MANIFEST membership. Ordinary DB::Open continues to use caller-supplied
  options and does not depend on the operational snapshot.
• Added EncodeEntry(), PackSequenceAndType(), and UnPackSequenceAndType() in rocksdb/utilities/types_util.h to construct internal keys and pack or unpack their sequence numbers and entry types. kInternalKeyFooterSize exposes the footer size in bytes.
• Added ldb update_manifest --rebind_options_file --options_file=OPTIONS-<number> for offline repair of a committed MANIFEST OPTIONS file number. Operators must select a trusted snapshot that has MANIFEST tracking enabled and provide any external DB/CF allocation roots that are not serialized in OPTIONS.

Behavior Changes

• With max_bgerror_resume_count <= 0 (auto resume disabled), a retryable or file-scoped IO error during compaction or flush is now a hard background error that stops writes until DB::Resume() is called. Previously, compaction errors were silently retried, and flush errors with a healthy WAL were soft errors that let writes continue while flushes were stopped.

Bug Fixes

• Fixed two more SstFileManager trash accounting leaks: retrying a failed trash deletion immediately (for example with rate limiting disabled) after the file had disappeared, and a trash file that was deleted but whose directory sync then failed. In both cases the file's size stayed in the total trash size and tracked size until restart.
• Fixed SstFileManager trash accounting leaking the size of a queued trash file that disappeared before deletion (for example because its directory was renamed). The leaked bytes stayed in the total trash size until restart, which could push every later deletion past max_trash_db_ratio and make it immediate instead of rate limited.
• Fixed MultiGet with ReadOptions::async_io returning NotSupported when io_uring initialization or an asynchronous read submission fails. It now checks async I/O support on the reading thread and falls back to synchronous reads when needed.
• Fixed subset checkpoints so their newest OPTIONS file lists only the column
  families retained by the checkpoint. This applies with both legacy
  highest-numbered OPTIONS selection and MANIFEST-tracked OPTIONS selection, and
  prevents LoadLatestOptions from recreating column families that the subset
  checkpoint intentionally dropped from its copied MANIFEST.

Performance Improvements

• Perf context counters and timers no longer call the thread-local init function of perf_context on every update. With kEnableCount, a counter update costs about 60% less.

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.

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...

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.

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().

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.

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.

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+.

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.

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