Merge pull request #251 from fjall-rs/3.1

3.1.0

Author: marvin-j97

Cargo.toml

@@ -2,7 +2,7 @@
 name = "lsm-tree"
 description = "A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)"
 license = "MIT OR Apache-2.0"
-version = "3.0.4"
+version = "3.1.0"
 edition = "2021"
 rust-version = "1.90"
 readme = "README.md"

README.md

@@ -5,7 +5,7 @@
 [![CI](https://github.com/fjall-rs/lsm-tree/actions/workflows/test.yml/badge.svg)](https://github.com/fjall-rs/lsm-tree/actions/workflows/test.yml)
 [![docs.rs](https://img.shields.io/docsrs/lsm-tree?color=green)](https://docs.rs/lsm-tree)
 [![Crates.io](https://img.shields.io/crates/v/lsm-tree?color=blue)](https://crates.io/crates/lsm-tree)
-![MSRV](https://img.shields.io/badge/MSRV-1.91.0-blue)
+![MSRV](https://img.shields.io/badge/MSRV-1.90.0-blue)
 [![dependency status](https://deps.rs/repo/github/fjall-rs/lsm-tree/status.svg)](https://deps.rs/repo/github/fjall-rs/lsm-tree)
 
 A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs) in Rust.
@@ -33,6 +33,7 @@ This is the most feature-rich LSM-tree implementation in Rust! It features:
 - Leveled and FIFO compaction
 - Optional key-value separation for large value workloads [[2]](#footnotes), with automatic garbage collection
 - Single deletion tombstones ("weak" deletion)
+- Optional compaction filters to run custom logic during compactions
 
 Keys are limited to 65536 bytes, values are limited to 2^32 bytes.
 As is normal with any kind of storage engine, larger keys and values have a bigger performance impact.

src/abstract.rs src/abstract_tree.rssrc/abstract.rs renamed to src/abstract_tree.rs

@@ -3,7 +3,7 @@
 // (found in the LICENSE-* files in the repository)
 
 use crate::{
-    blob_tree::handle::BlobIndirection, coding::Decode, compaction::stream::ExpiredKvCallback,
+    blob_tree::handle::BlobIndirection, coding::Decode, compaction::stream::DroppedKvCallback,
     version::BlobFileList, vlog::BlobFileId,
 };
 
@@ -132,8 +132,8 @@ impl crate::coding::Decode for FragmentationMap {
     }
 }
 
-impl ExpiredKvCallback for FragmentationMap {
-    fn on_expired(&mut self, kv: &crate::InternalValue) {
+impl DroppedKvCallback for FragmentationMap {
+    fn on_dropped(&mut self, kv: &crate::InternalValue) {
         if kv.key.value_type.is_indirection() {
             let mut reader = &kv.value[..];
 
@@ -278,7 +278,7 @@ mod tests {
         let mut my_watcher = FragmentationMap::default();
 
         let iter = vec.iter().cloned().map(Ok);
-        let mut iter = CompactionStream::new(iter, 1_000).with_expiration_callback(&mut my_watcher);
+        let mut iter = CompactionStream::new(iter, 1_000).with_drop_callback(&mut my_watcher);
 
         assert_eq!(
             // TODO: Seqno is normally reset to 0

src/blob_tree/gc.rs

@@ -3,12 +3,8 @@
 // (found in the LICENSE-* files in the repository)
 
 use crate::{
-    blob_tree::handle::BlobIndirection,
-    file::BLOBS_FOLDER,
-    table::Table,
-    tree::ingest::Ingestion as TableIngestion,
-    vlog::{BlobFileWriter, ValueHandle},
-    SeqNo, UserKey, UserValue,
+    blob_tree::handle::BlobIndirection, file::BLOBS_FOLDER, table::Table,
+    tree::ingest::Ingestion as TableIngestion, vlog::BlobFileWriter, SeqNo, UserKey, UserValue,
 };
 
 /// Bulk ingestion for [`BlobTree`]
@@ -86,16 +82,10 @@ impl<'a> BlobIngestion<'a> {
         let value_size = value.len() as u32;
 
         if value_size >= self.separation_threshold {
-            let offset = self.blob.offset();
-            let blob_file_id = self.blob.blob_file_id();
-            let on_disk_size = self.blob.write(&key, self.seqno, &value)?;
+            let vhandle = self.blob.write(&key, self.seqno, &value)?;
 
             let indirection = BlobIndirection {
-                vhandle: ValueHandle {
-                    blob_file_id,
-                    offset,
-                    on_disk_size,
-                },
+                vhandle,
                 size: value_size,
             };
 

src/blob_tree/ingest.rs

@@ -10,14 +10,14 @@ pub mod ingest;
 pub use gc::{FragmentationEntry, FragmentationMap};
 
 use crate::{
+    abstract_tree::{AbstractTree, RangeItem},
     coding::Decode,
     iter_guard::{IterGuard, IterGuardImpl},
-    r#abstract::{AbstractTree, RangeItem},
     table::Table,
     tree::inner::MemtableId,
     value::InternalValue,
     version::Version,
-    vlog::{Accessor, BlobFile, BlobFileWriter, ValueHandle},
+    vlog::{Accessor, BlobFile, BlobFileWriter},
     Cache, Config, Memtable, SeqNo, TableId, TreeId, UserKey, UserValue,
 };
 use handle::BlobIndirection;
@@ -431,16 +431,10 @@ impl AbstractTree for BlobTree {
             let value_size = value.len() as u32;
 
             if value_size >= separation_threshold {
-                let offset = blob_writer.offset();
-                let blob_file_id = blob_writer.blob_file_id();
-                let on_disk_size = blob_writer.write(&item.key.user_key, item.key.seqno, &value)?;
+                let vhandle = blob_writer.write(&item.key.user_key, item.key.seqno, &value)?;
 
                 let indirection = BlobIndirection {
-                    vhandle: ValueHandle {
-                        blob_file_id,
-                        offset,
-                        on_disk_size,
-                    },
+                    vhandle,
                     size: value_size,
                 };