+ where
+ E: de::Error,
+ {
+ Ok(StrView::new(v))
+ }
+ }
+
+ deserializer.deserialize_str(StrViewVisitor)
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::StrView;
+ use std::collections::HashMap;
+
+ #[cfg(feature = "serde")]
+ #[test]
+ fn serde_roundtrip() {
+ let a = StrView::from("abcdef");
+ let b: StrView = serde_json::from_slice(&serde_json::to_vec(&a).unwrap()).unwrap();
+ assert_eq!(a, b);
+ }
+
+ #[test]
+ fn strview_hash() {
+ let a = StrView::from("abcdef");
+
+ let mut map = HashMap::new();
+ map.insert(a, 0);
+ assert!(map.contains_key("abcdef"));
+ }
+
+ #[test]
+ fn cmp_misc_1() {
+ let a = StrView::from("abcdef");
+ let b = StrView::from("abcdefhelloworldhelloworld");
+ assert!(a < b);
+ }
+
+ #[test]
+ fn nostr() {
+ let slice = StrView::from("");
+ assert_eq!(0, slice.len());
+ assert_eq!(&*slice, "");
+ }
+
+ #[test]
+ fn default_str() {
+ let slice = StrView::default();
+ assert_eq!(0, slice.len());
+ assert_eq!(&*slice, "");
+ }
+
+ #[test]
+ fn short_str() {
+ let slice = StrView::from("abcdef");
+ assert_eq!(6, slice.len());
+ assert_eq!(&*slice, "abcdef");
+ }
+
+ #[test]
+ #[cfg(target_pointer_width = "64")]
+ fn medium_str() {
+ let slice = StrView::from("abcdefabcdef");
+ assert_eq!(12, slice.len());
+ assert_eq!(&*slice, "abcdefabcdef");
+ }
+
+ #[test]
+ #[cfg(target_pointer_width = "64")]
+ fn medium_long_str() {
+ let slice = StrView::from("abcdefabcdefabcdabcd");
+ assert_eq!(20, slice.len());
+ assert_eq!(&*slice, "abcdefabcdefabcdabcd");
+ }
+
+ #[test]
+ #[cfg(target_pointer_width = "64")]
+ fn medium_str_clone() {
+ let slice = StrView::from("abcdefabcdefabcdefa");
+
+ #[allow(clippy::redundant_clone)]
+ let copy = slice.clone();
+
+ assert_eq!(slice, copy);
+ }
+
+ #[test]
+ fn long_str() {
+ let slice = StrView::from("abcdefabcdefabcdefababcd");
+ assert_eq!(24, slice.len());
+ assert_eq!(&*slice, "abcdefabcdefabcdefababcd");
+ }
+
+ #[test]
+ fn long_str_clone() {
+ let slice = StrView::from("abcdefabcdefabcdefababcd");
+
+ #[allow(clippy::redundant_clone)]
+ let copy = slice.clone();
+
+ assert_eq!(slice, copy);
+ }
+
+ #[test]
+ fn long_str_slice_full() {
+ let slice = StrView::from("helloworld_thisisalongstring");
+
+ let copy = slice.slice(..);
+ assert_eq!(copy, slice);
+ }
+
+ #[test]
+ #[cfg(target_pointer_width = "64")]
+ fn long_str_slice() {
+ let slice = StrView::from("helloworld_thisisalongstring");
+
+ let copy = slice.slice(11..);
+ assert_eq!("thisisalongstring", &*copy);
+ }
+
+ #[test]
+ #[cfg(target_pointer_width = "64")]
+ fn long_str_slice_twice() {
+ let slice = StrView::from("helloworld_thisisalongstring");
+
+ let copy = slice.slice(11..);
+ assert_eq!("thisisalongstring", &*copy);
+
+ let copycopy = copy.slice(..);
+ assert_eq!(copy, copycopy);
+ }
+
+ #[test]
+ #[cfg(target_pointer_width = "64")]
+ fn long_str_slice_downgrade() {
+ let slice = StrView::from("helloworld_thisisalongstring");
+
+ let copy = slice.slice(11..);
+ assert_eq!("thisisalongstring", &*copy);
+
+ let copycopy = copy.slice(0..4);
+ assert_eq!("this", &*copycopy);
+
+ {
+ let copycopy = copy.slice(0..=4);
+ assert_eq!("thisi", &*copycopy);
+ assert_eq!('t', copycopy.chars().next().unwrap());
+ }
+ }
+
+ #[test]
+ fn short_str_clone() {
+ let slice = StrView::from("abcdef");
+ let copy = slice.clone();
+ assert_eq!(slice, copy);
+
+ drop(slice);
+ assert_eq!(&*copy, "abcdef");
+ }
+
+ #[test]
+ fn short_str_slice_full() {
+ let slice = StrView::from("abcdef");
+ let copy = slice.slice(..);
+ assert_eq!(slice, copy);
+
+ drop(slice);
+ assert_eq!(&*copy, "abcdef");
+ }
+
+ #[test]
+ fn short_str_slice_part() {
+ let slice = StrView::from("abcdef");
+ let copy = slice.slice(3..);
+
+ drop(slice);
+ assert_eq!(&*copy, "def");
+ }
+
+ #[test]
+ fn short_str_slice_empty() {
+ let slice = StrView::from("abcdef");
+ let copy = slice.slice(0..0);
+
+ drop(slice);
+ assert_eq!(&*copy, "");
+ }
+
+ #[test]
+ fn tiny_str_starts_with() {
+ let a = StrView::from("abc");
+ assert!(a.starts_with("ab"));
+ assert!(!a.starts_with("b"));
+ }
+
+ #[test]
+ fn long_str_starts_with() {
+ let a = StrView::from("abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef");
+ assert!(a.starts_with("abcdef"));
+ assert!(!a.starts_with("def"));
+ }
+
+ #[test]
+ fn tiny_str_cmp() {
+ let a = StrView::from("abc");
+ let b = StrView::from("def");
+ assert!(a < b);
+ }
+
+ #[test]
+ fn tiny_str_eq() {
+ let a = StrView::from("abc");
+ let b = StrView::from("def");
+ assert!(a != b);
+ }
+
+ #[test]
+ fn long_str_eq() {
+ let a = StrView::from("abcdefabcdefabcdefabcdef");
+ let b = StrView::from("xycdefabcdefabcdefabcdef");
+ assert!(a != b);
+ }
+
+ #[test]
+ fn long_str_cmp() {
+ let a = StrView::from("abcdefabcdefabcdefabcdef");
+ let b = StrView::from("xycdefabcdefabcdefabcdef");
+ assert!(a < b);
+ }
+
+ #[test]
+ fn long_str_eq_2() {
+ let a = StrView::from("abcdefabcdefabcdefabcdef");
+ let b = StrView::from("abcdefabcdefabcdefabcdef");
+ assert!(a == b);
+ }
+
+ #[test]
+ fn long_str_cmp_2() {
+ let a = StrView::from("abcdefabcdefabcdefabcdef");
+ let b = StrView::from("abcdefabcdefabcdefabcdeg");
+ assert!(a < b);
+ }
+
+ #[test]
+ fn long_str_cmp_3() {
+ let a = StrView::from("abcdefabcdefabcdefabcde");
+ let b = StrView::from("abcdefabcdefabcdefabcdef");
+ assert!(a < b);
+ }
+}
diff --git a/crates/fjall/.config/nextest.toml b/crates/fjall/.config/nextest.toml
deleted file mode 100644
index d7653a80a..000000000
--- a/crates/fjall/.config/nextest.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[profile.default]
-slow-timeout = { period = "5s", terminate-after = 3 }
diff --git a/crates/fjall/.gitignore b/crates/fjall/.gitignore
deleted file mode 100644
index ee08ccef7..000000000
--- a/crates/fjall/.gitignore
+++ /dev/null
@@ -1,24 +0,0 @@
-# Generated by Cargo
-# will have compiled files and executables
-debug/
-target/
-
-# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
-# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
-Cargo.lock
-
-# These are backup files generated by rustfmt
-**/*.rs.bk
-
-# MSVC Windows builds of rustc generate these, which store debugging information
-*.pdb
-
-mutants
-mutants.out
-
-.fjall_data
-.data
-.test
-/old_*
-
-.directory
diff --git a/crates/fjall/.rustfmt.toml b/crates/fjall/.rustfmt.toml
deleted file mode 100644
index 1c7741475..000000000
--- a/crates/fjall/.rustfmt.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-reorder_imports = true
-# group_imports = "StdExternalCrate"
-# imports_granularity = "crate"
diff --git a/crates/fjall/.vscode/settings.json b/crates/fjall/.vscode/settings.json
deleted file mode 100644
index 875c86731..000000000
--- a/crates/fjall/.vscode/settings.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
- "rust-analyzer.showUnlinkedFileNotification": false
-}
\ No newline at end of file
diff --git a/crates/fjall/CHANGELOG.md b/crates/fjall/CHANGELOG.md
deleted file mode 100644
index cbb553a7c..000000000
--- a/crates/fjall/CHANGELOG.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# 3.1.0
-
-- [feat] Implemented support for compaction filters (custom logic during compactions)
-- [msrv] Reduced MSRV to 1.90
-
-# 3.0.0
-
-- [feat] Implemented new block format in `lsm-tree`
-- [feat] Bookkeep LSM-tree changes (flushes, compactions) in `Version` history
-- [feat] Prefix truncation inside data & index blocks
-- [feat] Allow unpinning filter blocks
-- [feat] Implemented partitioned filters
-- [feat] Allow calling bulk ingestion on non-empty keyspaces
-- [feat] Introduced level-based configuration policies for most configuration parameters
-- [feat] Journal compression for large values
-- [feat] Database locking using the new Rust file locking API
-- [feat] Rewritten key-value separation to run during compactions, instead of dedicated GC runs
-- [feat] Full file checksums to allow fast database corruption checks (in the future)
-- [feat] Checksum check on block & blob reads
-- [api] Make Ingestion API more flexible
-- [feat] Shortening eligible sequence numbers when compacting into the last level to save disk space
-- [api] Change constructor to `Database::builder` instead of `Config::new`
-- [api] Changed naming of keyspace->database, and partition->keyspace
-- [api] Change transaction feature flags to be separate structs, `OptimisticTxDatabase` and `SingleWriterTxDatabase`
-- [api] Changed snapshot error type, fixes #156
-- [api] Unified transactions read operations and snapshots with `Readable` trait
-- [api] Guard API for iterator values
-- [api] Removed old garbage collection APIs
-- [api] `metrics` feature flag for cache hit rates etc. (will be exposed in the future)
-- [api] Change `bytes` feature flag to `bytes_1` to pin its version
-- [api] Make read operations in optimistic write transactions non-mut
-- [fix] Consider blob files in FIFO compaction size limit, fixes #133
-- [perf] Use a single hash per key for filters, instead of two
-- [perf] Improve leveled compaction scoring
-- [perf] Improve leveled compaction picking to use less hashing and heap allocations
-- [perf] Use `quick-cache` for file descriptor caching
-- [perf] Promote levels immediately to L6 to get rid of tombstones easily
-- [perf] Rewritten maintenance task bookkeeping, and write stalling mechanisms to be less aggressive
-- [perf] Allow `lsm-tree` flushes to merge multiple sealed memtables into L0, if necessary
-- [perf] Skip heap allocation in blob memtable inserts
-- [perf] Skip compression when rewriting compressed blob files
-- [msrv] Increased MSRV to **1.91**
-- [misc] Blob file descriptor caching
-- [misc] Use Rust native `path::absolute`, removing `path-absolutize` dependency
-- [misc] Remove `std-semaphore` dependency
-- [misc] Remove `miniz` (will be replaced in the future)
-- [misc] Use `byteorder-lite` as drop-in replacement for `byteorder`
-- [refactor] Changed background workers to be a single thread pool
-- [internal] Store keyspace configurations in a meta keyspace, instead of individual binary config files
-- [internal] Use `sfa` for most file scaffolding in `lsm-tree`
diff --git a/crates/fjall/CONTRIBUTING.md b/crates/fjall/CONTRIBUTING.md
deleted file mode 100644
index b2bba5915..000000000
--- a/crates/fjall/CONTRIBUTING.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# Contributing
-
-## License
-
-By contributing to this project, you agree that your contributions will be licensed under the project's license (MIT OR Apache-2.0).
-
-Thank you for your contribution!
-
-## Looking for issues?
-
-https://github.com/fjall-rs/fjall/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22
diff --git a/crates/fjall/Cargo.toml b/crates/fjall/Cargo.toml
index 1c445600c..1c99aea48 100644
--- a/crates/fjall/Cargo.toml
+++ b/crates/fjall/Cargo.toml
@@ -5,11 +5,8 @@ license.workspace = true
version.workspace = true
edition.workspace = true
readme.workspace = true
-include = ["src/**/*", "LICENSE-APACHE", "LICENSE-MIT", "README.md"]
repository.workspace = true
homepage.workspace = true
-keywords = ["database", "key-value", "lsm", "rocksdb", "leveldb"]
-categories = ["data-structures", "database-implementations", "algorithms"]
[lib]
name = "fjall"
@@ -18,9 +15,6 @@ path = "src/lib.rs"
[features]
default = ["lz4"]
lz4 = ["lsm-tree/lz4", "dep:lz4_flex"]
-bytes_1 = ["lsm-tree/bytes_1"]
-metrics = ["lsm-tree/metrics"]
-__internal_whitebox = []
[dependencies]
byteorder = { package = "byteorder-lite", version = "0.1.0" }
@@ -28,15 +22,11 @@ byteview = { workspace = true }
lsm-tree = { workspace = true, default-features = false, features = [] }
log = { workspace = true }
tempfile = { workspace = true }
-dashmap = "6.1.0"
-xxhash-rust = { version = "0.8.15", features = ["xxh3"] }
+dashmap = "6.2.1"
+xxhash-rust = { version = "0.8.18", features = ["xxh3"] }
lz4_flex = { workspace = true, features = ["checked-decode"], optional = true }
flume = { version = "0.12.0", default-features = false }
[dev-dependencies]
-nanoid = "0.4.0"
-test-log = "0.2.18"
-rand = "0.10.0"
-
-[package.metadata.cargo-all-features]
-denylist = ["__internal_whitebox"]
+nanoid = "0.5.0"
+test-log = "0.2.21"
diff --git a/crates/fjall/README.md b/crates/fjall/README.md
deleted file mode 100644
index 0dbeeaa15..000000000
--- a/crates/fjall/README.md
+++ /dev/null
@@ -1,207 +0,0 @@
-
- 
-
-
-
-
- 
-
-
- 
-
-
- 
-
- 
-
- 
-
-
-
-
-
- 
-
-
- 
-
-
-
-*Fjall* _(Nordic: "Mountain")_ is a log-structured, embeddable key-value storage engine written in Rust.
-It features:
-
-- A thread-safe BTreeMap-like API
-- 100% safe & stable Rust
-- LSM-tree-based storage similar to `RocksDB`
-- Range & prefix searching with forward and reverse iteration
-- Multiple keyspaces (a.k.a. column families) with cross-keyspace atomic semantics
-- Built-in compression (default = `LZ4`)
-- Serializable transactions (optional)
-- Key-value separation for large blob use cases (optional)
-- Custom compaction filters to run custom logic during compactions (optional)
-- Automatic background maintenance
-
-It is not:
-
-- A standalone database server
-- A relational or wide-column database: it has no built-in notion of columns or query language
-
-## Sponsors
-
-
-
-
-
- 
-
-
-
-## Basic usage
-
-```bash
-cargo add fjall
-```
-
-```rust
-use fjall::{Database, KeyspaceCreateOptions, PersistMode};
-
-fn main() -> fjall::Result<()> {
- // A database may contain multiple keyspaces
- // You should probably only use a single database for your application
- let db = Database::builder(path).open()?;
- // TxDatabase::builder for transactional semantics
-
- // Each keyspace is its own physical LSM-tree, and thus isolated from other keyspaces
- let items = db.keyspace("my_items", KeyspaceCreateOptions::default)?;
-
- // Write some data
- items.insert("a", "hello")?;
-
- // And retrieve it
- let bytes = items.get("a")?;
-
- // Or remove it again
- items.remove("a")?;
-
- // Search by prefix
- for kv in items.prefix("prefix") {
- // ...
- }
-
- // Search by range
- for kv in items.range("a"..="z") {
- // ...
- }
-
- // Iterators implement DoubleEndedIterator, so you can search backwards, too!
- for kv in items.prefix("prefix").rev() {
- // ...
- }
-
- // Sync the journal to disk to make sure data is definitely durable
- // When the database is dropped, it will try to persist with `PersistMode::SyncAll` automatically
- db.persist(PersistMode::SyncAll)
-}
-```
-
-> [!TIP]
-> Like any typical key-value store, keys are stored in lexicographic order.
-> If you are storing integer keys (e.g. timeseries data), you should use the big endian form to have predictable ordering.
-
-## Durability
-
-To support different kinds of workloads, Fjall is agnostic about the type of durability
-your application needs.
-After writing data (`insert`, `remove` or committing a write batch/transaction), you can choose to call [`Database::persist`](https://docs.rs/fjall/latest/fjall/struct.Database.html#method.persist) which takes a [`PersistMode`](https://docs.rs/fjall/latest/fjall/enum.PersistMode.html) parameter.
-By default, any operation will flush to OS buffers, but **not** to disk.
-This matches RocksDB's default durability.
-Also, when dropped, the database will try to persist the journal *to disk* synchronously.
-
-## Multithreading, Async and Multiprocess
-
-> [!WARNING]
-> A single database may **not** be loaded in parallel from separate *processes*.
-
-Fjall is internally synchronized for multi-*threaded* access, so you can clone around the `Database` and `Keyspace`s as needed, without needing to lock yourself.
-
-For an async example, see the [`tokio`](https://github.com/fjall-rs/fjall/tree/main/examples/tokio) example.
-
-## Memory usage
-
-Generally, memory for loaded data, indexes etc. is managed on a per-block basis, and capped by the block cache capacity.
-Note that this also applies to returned values: When you hold a `Slice`, it keeps the backing buffer alive (which may be a block).
-If you know that you are going to keep a value around for a long time, you may want to copy it out into a new `Vec`, `Box<[u8]>`, `Arc<[u8]>` or new `Slice` (using `Slice::new`).
-
-> [!NOTE]
-> It is recommended to configure the block cache capacity to be ~20-25% of the available memory - or more **if** the data set fits _fully_ into memory.
-
-Additionally, orthogonally to the block cache, each `Keyspace` has its own write buffer (["Memtable"](https://docs.rs/fjall/latest/fjall/struct.KeyspaceCreateOptions.html#method.max_memtable_size)) which is the unit of data flushed back into the "proper" index structure.
-
-## Error handling
-
-Fjall returns an [error enum](https://docs.rs/fjall/latest/fjall/enum.Error.html), however these variants are mostly used for debugging and tracing purposes, so your application is not expected to handle specific errors.
-
-It's best to let the application crash and restart, which is the [safest way to recover from transient I/O errors](https://ramalagappan.github.io/pdfs/papers/cuttlefs.pdf).
-
-## Transactional modes
-
-The backing store (`lsm-tree`) is a MVCC key-value store, allowing repeatable snapshot reads.
-However this isolation level can not do read-modify-write operations without the chance of lost updates.
-Also, `WriteBatch` does not allow reading the intermediary state back as you would expect from a proper transaction.
-For that reason, if you need transactional semantics, you need to use one of the transactional database implementation (`OptimisticTxDatabase` or `SingleWriterTxDatabase`).
-
-TL;DR: Fjall supports both transactional and non-transactional workloads.
-Chances are you want to use a transactional database, unless you know your workload does not need serializable transaction semantics.
-
-### Single writer
-
-Opens a transactional database for single-writer (serialized) transactions.
-Single writer means only a single **write** transaction can run at a time.
-This is trivially serializable because it _literally_ serializes write transactions.
-
-### Optimistic
-
-Opens a transactional database for multi-writer, serializable transactions.
-Conflict checking is done using optimistic concurrency control, meaning transactions can conflict and may have to be rerun.
-
-## Feature flags
-
-### lz4
-
-Allows using `LZ4` compression, powered by [`lz4_flex`](https://github.com/PSeitz/lz4_flex).
-
-*Enabled by default.*
-
-### bytes_1
-
-Uses [`bytes`](https://github.com/tokio-rs/bytes) 1.x as the underlying `Slice` type.
-Otherwise, [`byteview`](https://github.com/fjall-rs/byteview) is used instead.
-
-*Disabled by default.*
-
-## Stable disk format
-
-Future breaking changes will result in a major version bump and a migration path.
-
-For the underlying LSM-tree implementation, see: .
-
-## Examples
-
-[See here](https://github.com/fjall-rs/fjall/tree/main/examples) for practical examples.
-
-## Contributing
-
-How can you help?
-
-- [Ask a question](https://github.com/fjall-rs/fjall/discussions/new?category=q-a)
- - or join the Discord server: [https://discord.com/invite/HvYGp4NFFk](https://discord.com/invite/HvYGp4NFFk)
-- [Post benchmarks and things you created](https://github.com/fjall-rs/fjall/discussions/new?category=show-and-tell)
-- [Open a PR](https://github.com/fjall-rs/fjall/compare),
- - [See open issues to pick up here](https://github.com/search?q=org%3Afjall-rs+label%3A%22help+wanted%22+state%3Aopen+&type=issues)
-- [Open an issue](https://github.com/fjall-rs/fjall/issues/new) (bug report, weirdness)
-
-## License
-
-All source code is licensed under MIT OR Apache-2.0.
-
-All contributions are to be licensed as MIT OR Apache-2.0.
diff --git a/crates/fjall/commit.nu b/crates/fjall/commit.nu
deleted file mode 100644
index a0a3001bd..000000000
--- a/crates/fjall/commit.nu
+++ /dev/null
@@ -1,64 +0,0 @@
-let machines = [
- # Fly.io performance
- # "fly.performance.1x",
- # "fly.performance.2x",
- "fly.performance.4x",
- # "fly.performance.8x",
- # "fly.performance.16x",
-
- # EC2 T2
- # "aws.ec2.t2.nano",
- # "aws.ec2.t2.micro",
- # "aws.ec2.t2.small",
- # "aws.ec2.t2.medium",
- # "aws.ec2.t2.large",
- # "aws.ec2.t2.xlarge",
- # "aws.ec2.t2.2xlarge",
-
- # EC2 T3
- # "aws.ec2.t3.nano",
- # "aws.ec2.t3.micro",
- # "aws.ec2.t3.small",
- "aws.ec2.t3.medium",
- # "aws.ec2.t3.large",
- # "aws.ec2.t3.xlarge",
- # "aws.ec2.t3.2xlarge",
-
- # EC2 T3a
- # "aws.ec2.t3a.nano",
- # "aws.ec2.t3a.micro",
- # "aws.ec2.t3a.small",
- # "aws.ec2.t3a.medium",
- # "aws.ec2.t3a.large",
- # "aws.ec2.t3a.xlarge",
- # "aws.ec2.t3a.2xlarge",
-
- # EC2 T4g
- # "aws.ec2.t4g.nano",
- # "aws.ec2.t4g.micro",
- # "aws.ec2.t4g.small",
- # "aws.ec2.t4g.medium",
- # "aws.ec2.t4g.large",
- # "aws.ec2.t4g.xlarge",
- # "aws.ec2.t4g.2xlarge",
-
- # EC2 M4
- # "aws.ec2.m4.large",
-]
-
-let table = $env.TABLE_NAME
-let commit = $env.COMMIT
-
-print $"Queuing ($commit)"
-
-for machine in $machines {
- let q_pk = $"q#($machine)"
-
- print $"Adding queue item for ($machine)"
- let item = {
- pk: { S: $q_pk },
- sk: { S: $commit },
- version: { S: "2" },
- }
- aws dynamodb put-item --table-name $table --item ($item | to json)
-}
diff --git a/crates/fjall/compile_examples.mjs b/crates/fjall/compile_examples.mjs
deleted file mode 100644
index 5812a12bc..000000000
--- a/crates/fjall/compile_examples.mjs
+++ /dev/null
@@ -1,60 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { readdir } from "node:fs/promises";
-import { resolve } from "node:path";
-
-const examplesFolder = "examples";
-
-for (const exampleName of await readdir(examplesFolder)) {
- const folder = resolve(examplesFolder, exampleName);
-
- {
- console.error(`Testing ${exampleName}`);
-
- const proc = spawn("cargo test", {
- cwd: folder,
- shell: true,
- });
-
- proc.stdout.on("data", buf => console.log(String(buf)));
- proc.stderr.on("data", buf => console.error(String(buf)));
-
- await new Promise((resolve, _) => {
- proc.on("exit", () => {
- if (proc.exitCode > 0) {
- console.error(`${exampleName} FAILED`);
- process.exit(1);
- }
- else {
- resolve();
- }
- })
- });
- }
-
- if (existsSync(resolve(folder, ".run"))) {
- console.error(`Running ${exampleName}`);
-
- const proc = spawn("cargo run", {
- cwd: folder,
- shell: true,
- });
-
- proc.stdout.on("data", buf => console.log(String(buf)));
- proc.stderr.on("data", buf => console.error(String(buf)));
-
- await new Promise((resolve, _) => {
- proc.on("exit", () => {
- if (proc.exitCode > 0) {
- console.error(`${exampleName} FAILED`);
- process.exit(1);
- }
- else {
- resolve();
- }
- })
- });
- }
-
- console.error(`${exampleName} OK`);
-}
diff --git a/crates/fjall/kawaii.png b/crates/fjall/kawaii.png
deleted file mode 100644
index 7e6152a5d..000000000
Binary files a/crates/fjall/kawaii.png and /dev/null differ
diff --git a/crates/fjall/logo.png b/crates/fjall/logo.png
deleted file mode 100644
index 8693656da..000000000
Binary files a/crates/fjall/logo.png and /dev/null differ
diff --git a/crates/fjall/renovate.json b/crates/fjall/renovate.json
deleted file mode 100644
index 39a2b6e9a..000000000
--- a/crates/fjall/renovate.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
- "$schema": "https://docs.renovatebot.com/renovate-schema.json",
- "extends": [
- "config:base"
- ]
-}
diff --git a/crates/fjall/src/batch/item.rs b/crates/fjall/src/batch/item.rs
index f0b64f91d..d4640295a 100644
--- a/crates/fjall/src/batch/item.rs
+++ b/crates/fjall/src/batch/item.rs
@@ -35,7 +35,6 @@ impl std::fmt::Debug for Item {
ValueType::Value => "V",
ValueType::Tombstone => "T",
ValueType::WeakTombstone => "W",
- ValueType::Indirection => "Vb",
},
self.value
)
diff --git a/crates/fjall/src/batch/mod.rs b/crates/fjall/src/batch/mod.rs
index 9ee49757a..ae11723c0 100644
--- a/crates/fjall/src/batch/mod.rs
+++ b/crates/fjall/src/batch/mod.rs
@@ -148,7 +148,6 @@ impl WriteBatch {
ValueType::Value => item.keyspace.tree.insert(item.key, item.value, batch_seqno),
ValueType::Tombstone => item.keyspace.tree.remove(item.key, batch_seqno),
ValueType::WeakTombstone => item.keyspace.tree.remove_weak(item.key, batch_seqno),
- ValueType::Indirection => unreachable!(),
};
batch_size += item_size;
diff --git a/crates/fjall/src/builder.rs b/crates/fjall/src/builder.rs
index 6fc7a7cfa..f47e70841 100644
--- a/crates/fjall/src/builder.rs
+++ b/crates/fjall/src/builder.rs
@@ -2,21 +2,19 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use crate::{db_config::CompactionFilterAssigner, tx::single_writer::Openable, Config};
+use crate::{Config, Database, db_config::CompactionFilterAssigner};
use lsm_tree::{Cache, CompressionType, DescriptorTable};
-use std::{marker::PhantomData, path::Path, sync::Arc};
+use std::{path::Path, sync::Arc};
/// Database builder
-pub struct Builder {
+pub struct Builder {
inner: Config,
- _phantom: PhantomData,
}
-impl Builder {
+impl Builder {
pub(crate) fn new(path: &Path) -> Self {
Self {
inner: Config::new(path),
- _phantom: PhantomData,
}
}
@@ -31,8 +29,8 @@ impl Builder {
/// # Errors
///
/// Errors if an I/O error occurred, or if the database can not be opened.
- pub fn open(self) -> crate::Result {
- O::open(self.inner)
+ pub fn open(self) -> crate::Result {
+ Database::open(self.inner)
}
/// Sets the cache capacity in bytes.
diff --git a/crates/fjall/src/compaction/mod.rs b/crates/fjall/src/compaction/mod.rs
index 8b716bbf8..bac568c28 100644
--- a/crates/fjall/src/compaction/mod.rs
+++ b/crates/fjall/src/compaction/mod.rs
@@ -4,7 +4,7 @@
pub(crate) mod worker;
-pub use lsm_tree::compaction::{Fifo, Leveled, Levelled};
+pub use lsm_tree::compaction::{Leveled, Levelled};
/// Compaction filter utilities
pub mod filter {
diff --git a/crates/fjall/src/compaction/worker.rs b/crates/fjall/src/compaction/worker.rs
index 33b121cfa..92c66385a 100644
--- a/crates/fjall/src/compaction/worker.rs
+++ b/crates/fjall/src/compaction/worker.rs
@@ -2,7 +2,7 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use crate::{snapshot_tracker::SnapshotTracker, stats::Stats, Keyspace};
+use crate::{Keyspace, snapshot_tracker::SnapshotTracker, stats::Stats};
use lsm_tree::AbstractTree;
use std::time::Instant;
@@ -23,7 +23,7 @@ pub fn run(
keyspace.name,
);
- let strategy = keyspace.config.compaction_strategy.clone();
+ let strategy = std::sync::Arc::new(crate::compaction::Leveled::default());
stats.active_compaction_count.fetch_add(1, Relaxed);
@@ -33,7 +33,7 @@ pub fn run(
if let Err(e) = keyspace
.tree
- .compact(strategy.clone(), snapshot_tracker.get_seqno_safe_to_gc())
+ .compact(strategy, snapshot_tracker.get_seqno_safe_to_gc())
{
log::error!("Compaction failed: {e:?}");
stats.active_compaction_count.fetch_sub(1, Relaxed);
diff --git a/crates/fjall/src/db.rs b/crates/fjall/src/db.rs
index ecc1b8814..771abcdd7 100644
--- a/crates/fjall/src/db.rs
+++ b/crates/fjall/src/db.rs
@@ -3,12 +3,13 @@
// (found in the LICENSE-* files in the repository)
use crate::{
+ HashMap, Keyspace, KeyspaceCreateOptions,
batch::WriteBatch,
db_config::Config,
- file::{fsync_directory, KEYSPACES_FOLDER, LOCK_FILE, VERSION_MARKER},
+ file::{KEYSPACES_FOLDER, LOCK_FILE, VERSION_MARKER, fsync_directory},
flush::manager::FlushManager,
- journal::{manager::JournalManager, writer::PersistMode, Journal},
- keyspace::{name::is_valid_keyspace_name, KeyspaceKey},
+ journal::{Journal, manager::JournalManager, writer::PersistMode},
+ keyspace::{KeyspaceKey, name::is_valid_keyspace_name},
locked_file::LockedFileGuard,
meta_keyspace::MetaKeyspace,
poison::{PoisonDart, PoisonSignal},
@@ -17,17 +18,15 @@ use crate::{
snapshot_tracker::SnapshotTracker,
stats::Stats,
supervisor::{Supervisor, SupervisorInner},
- tx::single_writer::Openable,
version::FormatVersion,
worker_pool::{WorkerMessage, WorkerPool},
write_buffer_manager::WriteBufferManager,
- HashMap, Keyspace, KeyspaceCreateOptions,
};
use lsm_tree::{AbstractTree, SequenceNumberCounter};
use std::{
fs::remove_dir_all,
path::Path,
- sync::{atomic::AtomicUsize, Arc, RwLock},
+ sync::{Arc, RwLock, atomic::AtomicUsize},
};
pub type Keyspaces = HashMap;
@@ -106,9 +105,6 @@ impl Drop for DatabaseInner {
);
}
}
-
- #[cfg(feature = "__internal_whitebox")]
- crate::drop::decrement_drop_counter();
}
}
@@ -131,15 +127,6 @@ impl std::ops::Deref for Database {
}
}
-impl Openable for Database {
- fn open(config: Config) -> crate::Result
- where
- Self: Sized,
- {
- Self::open(config)
- }
-}
-
impl Database {
/// Opens a cross-keyspace snapshot.
///
@@ -152,7 +139,7 @@ impl Database {
}
/// Creates a new database builder to create or open a database at `path`.
- pub fn builder(path: impl AsRef) -> crate::DatabaseBuilder {
+ pub fn builder(path: impl AsRef) -> crate::DatabaseBuilder {
crate::DatabaseBuilder::new(path.as_ref())
}
@@ -391,9 +378,6 @@ impl Database {
let db = Self::create_or_recover(config)?;
// db.start_background_threads()?;
- #[cfg(feature = "__internal_whitebox")]
- crate::drop::increment_drop_counter();
-
Ok(db)
}
@@ -477,9 +461,6 @@ impl Database {
self.meta_keyspace
.create_keyspace(keyspace_id, &name, handle.clone(), keyspaces)?;
- #[cfg(feature = "__internal_whitebox")]
- crate::drop::increment_drop_counter();
-
handle
})
}
@@ -549,12 +530,12 @@ impl Database {
"It looks like you are trying to open a V2 database - the database needs a manual migration, a tool is available at https://github.com/fjall-rs/migrate-v2-v3."
);
}
- if version as u8 > 4 {
+ if version as u8 > 5 {
log::error!(
"It looks like you are trying to open a database from the future. Are you a time traveller?"
);
}
- if version != FormatVersion::V4 {
+ if version != FormatVersion::V5 {
return Err(crate::Error::InvalidVersion(Some(version)));
}
} else {
@@ -718,9 +699,6 @@ impl Database {
lsm_tree::ValueType::WeakTombstone => {
tree.remove_weak(item.key, batch.seqno);
}
- lsm_tree::ValueType::Indirection => {
- unreachable!()
- }
}
}
@@ -837,7 +815,7 @@ impl Database {
// NOTE: Lastly, fsync version marker, which contains the version
let mut marker = std::fs::File::create_new(config.path.join(VERSION_MARKER))?;
- FormatVersion::V4.write_file_header(&mut marker)?;
+ FormatVersion::V5.write_file_header(&mut marker)?;
marker.sync_all()?;
// IMPORTANT: fsync folders on Unix
diff --git a/crates/fjall/src/db_test.rs b/crates/fjall/src/db_test.rs
index 794111983..7429f9efb 100644
--- a/crates/fjall/src/db_test.rs
+++ b/crates/fjall/src/db_test.rs
@@ -1,4 +1,4 @@
-use crate::{Database, KeyspaceCreateOptions, KvSeparationOptions};
+use crate::{Database, KeyspaceCreateOptions};
use test_log::test;
#[test_log::test]
@@ -39,83 +39,6 @@ fn clear_recover_sealed() -> crate::Result<()> {
Ok(())
}
-// TODO: investigate: flaky on macOS???
-#[cfg(feature = "__internal_whitebox")]
-#[test]
-#[ignore = "restore"]
-fn whitebox_db_drop() -> crate::Result<()> {
- use crate::Database;
-
- {
- let folder = tempfile::tempdir()?;
-
- assert_eq!(0, crate::drop::load_drop_counter());
- let db = Database::builder(&folder).open()?;
- assert_eq!(5, crate::drop::load_drop_counter());
-
- drop(db);
- assert_eq!(0, crate::drop::load_drop_counter());
- }
-
- {
- let folder = tempfile::tempdir()?;
-
- assert_eq!(0, crate::drop::load_drop_counter());
- let db = Database::builder(&folder).open()?;
- assert_eq!(5, crate::drop::load_drop_counter());
-
- let tree = db.keyspace("default", Default::default)?;
- assert_eq!(6, crate::drop::load_drop_counter());
-
- drop(tree);
- drop(db);
- assert_eq!(0, crate::drop::load_drop_counter());
- }
-
- {
- let folder = tempfile::tempdir()?;
-
- assert_eq!(0, crate::drop::load_drop_counter());
- let db = Database::builder(&folder).open()?;
- assert_eq!(5, crate::drop::load_drop_counter());
-
- let _tree = db.keyspace("default", Default::default)?;
- assert_eq!(6, crate::drop::load_drop_counter());
-
- let _tree2 = db.keyspace("different", Default::default)?;
- assert_eq!(7, crate::drop::load_drop_counter());
- }
-
- assert_eq!(0, crate::drop::load_drop_counter());
-
- Ok(())
-}
-
-#[cfg(feature = "__internal_whitebox")]
-#[test]
-#[ignore = "restore"]
-fn whitebox_db_drop_2() -> crate::Result<()> {
- use crate::{Database, KeyspaceCreateOptions};
-
- let folder = tempfile::tempdir()?;
-
- {
- let db = Database::builder(&folder).open()?;
-
- let tree = db.keyspace("tree", KeyspaceCreateOptions::default)?;
- let tree2 = db.keyspace("tree1", KeyspaceCreateOptions::default)?;
-
- tree.insert("a", "a")?;
- tree2.insert("b", "b")?;
-
- tree.rotate_memtable_and_wait()?;
- }
-
- assert_eq!(0, crate::drop::load_drop_counter());
-
- Ok(())
-}
-
#[test]
pub fn test_exotic_keyspace_names() -> crate::Result<()> {
let folder = tempfile::tempdir()?;
@@ -184,31 +107,6 @@ fn recover_sealed_order() -> crate::Result<()> {
Ok(())
}
-#[test]
-#[expect(clippy::unwrap_used)]
-fn recover_sealed_blob() -> crate::Result<()> {
- let folder = tempfile::tempdir()?;
-
- for i in 0_u128..3 {
- let db = Database::create_or_recover(Database::builder(folder.path()).into_config())?;
-
- let tree = db.keyspace("default", || {
- KeyspaceCreateOptions::default()
- .max_memtable_size(1_000)
- .with_kv_separation(Some(KvSeparationOptions::default()))
- })?;
-
- assert_eq!(i, tree.len()?.try_into().unwrap());
-
- tree.insert(i.to_be_bytes(), i.to_be_bytes().repeat(1_024))?;
- assert_eq!(i + 1, tree.len()?.try_into().unwrap());
-
- tree.rotate_memtable_and_wait()?;
- }
-
- Ok(())
-}
-
#[test]
#[expect(clippy::unwrap_used)]
fn recover_sealed_pair_1() -> crate::Result<()> {
@@ -221,9 +119,7 @@ fn recover_sealed_pair_1() -> crate::Result<()> {
KeyspaceCreateOptions::default().max_memtable_size(1_000)
})?;
let tree2 = db.keyspace("default2", || {
- KeyspaceCreateOptions::default()
- .max_memtable_size(1_000)
- .with_kv_separation(Some(KvSeparationOptions::default()))
+ KeyspaceCreateOptions::default().max_memtable_size(1_000)
})?;
assert_eq!(i, tree.len()?.try_into().unwrap());
diff --git a/crates/fjall/src/drop.rs b/crates/fjall/src/drop.rs
deleted file mode 100644
index d5473cf94..000000000
--- a/crates/fjall/src/drop.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-use std::sync::atomic::Ordering::Relaxed;
-use std::sync::{atomic::AtomicUsize, OnceLock};
-
-static DROP_COUNTER: OnceLock = OnceLock::new();
-
-pub fn increment_drop_counter() {
- get_drop_counter().fetch_add(1, Relaxed);
-}
-
-pub fn decrement_drop_counter() {
- get_drop_counter().fetch_sub(1, Relaxed);
-}
-
-pub fn get_drop_counter<'a>() -> &'a AtomicUsize {
- DROP_COUNTER.get_or_init(AtomicUsize::default)
-}
-
-#[must_use]
-pub fn load_drop_counter() -> usize {
- get_drop_counter().load(Relaxed)
-}
diff --git a/crates/fjall/src/error.rs b/crates/fjall/src/error.rs
index b99a2c45e..39a6b1520 100644
--- a/crates/fjall/src/error.rs
+++ b/crates/fjall/src/error.rs
@@ -3,7 +3,7 @@
// (found in the LICENSE-* files in the repository)
use crate::{
- journal::error::RecoveryError as JournalRecoveryError, version::FormatVersion, CompressionType,
+ CompressionType, journal::error::RecoveryError as JournalRecoveryError, version::FormatVersion,
};
/// Errors that may occur in the storage engine
diff --git a/crates/fjall/src/ingestion.rs b/crates/fjall/src/ingestion.rs
index 6e658514a..a2b1a7bdd 100644
--- a/crates/fjall/src/ingestion.rs
+++ b/crates/fjall/src/ingestion.rs
@@ -2,17 +2,17 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use crate::{worker_pool::WorkerMessage, Keyspace};
-use lsm_tree::{AnyIngestion, UserKey, UserValue};
+use crate::{Keyspace, worker_pool::WorkerMessage};
+use lsm_tree::{Ingestion as TreeIngestion, UserKey, UserValue};
pub struct Ingestion<'a> {
keyspace: &'a Keyspace,
- inner: AnyIngestion<'a>,
+ inner: TreeIngestion<'a>,
}
impl<'a> Ingestion<'a> {
pub fn new(keyspace: &'a Keyspace) -> crate::Result {
- let inner = keyspace.tree.ingestion()?;
+ let inner = TreeIngestion::new(&keyspace.tree)?;
Ok(Self { keyspace, inner })
}
@@ -20,37 +20,20 @@ impl<'a> Ingestion<'a> {
&mut self,
key: K,
value: V,
- ) -> crate::Result<()> {
- self.inner.write(key, value).map_err(Into::into)
- }
-
- #[doc(hidden)]
- pub fn write_prevalidated, V: Into>(
- &mut self,
- key: K,
- value: V,
) -> crate::Result<()> {
self.inner
- .write_prevalidated(key, value)
+ .write(key.into(), value.into())
.map_err(Into::into)
}
pub fn write_tombstone>(&mut self, key: K) -> crate::Result<()> {
- self.inner.write_tombstone(key).map_err(Into::into)
+ self.inner.write_tombstone(key.into()).map_err(Into::into)
}
#[doc(hidden)]
pub fn write_weak_tombstone>(&mut self, key: K) -> crate::Result<()> {
- self.inner.write_weak_tombstone(key).map_err(Into::into)
- }
-
- #[doc(hidden)]
- pub fn write_prevalidated_weak_tombstone>(
- &mut self,
- key: K,
- ) -> crate::Result<()> {
self.inner
- .write_prevalidated_weak_tombstone(key)
+ .write_weak_tombstone(key.into())
.map_err(Into::into)
}
@@ -72,7 +55,7 @@ impl<'a> Ingestion<'a> {
// insert seqno=1
let _journal_lock = self.keyspace.supervisor.journal.get_writer();
- self.finish_inner()
+ self.finish_inner(false)
}
/// Finishes the ingestion without taking the global journal writer lock.
@@ -81,12 +64,17 @@ impl<'a> Ingestion<'a> {
/// the same database. Exclusive ingestions into independent keyspaces may
/// still finish concurrently.
pub fn finish_exclusive(self) -> crate::Result<()> {
- self.finish_inner()
+ self.finish_inner(true)
}
- fn finish_inner(self) -> crate::Result<()> {
- self.inner
- .finish()
+ fn finish_inner(self, exclusive: bool) -> crate::Result<()> {
+ let result = if exclusive {
+ self.inner.finish_exclusive()
+ } else {
+ self.inner.finish()
+ };
+
+ result
.inspect(|()| {
self.keyspace
.worker_messager
diff --git a/crates/fjall/src/iter.rs b/crates/fjall/src/iter.rs
index 7d61102b5..3312b287d 100644
--- a/crates/fjall/src/iter.rs
+++ b/crates/fjall/src/iter.rs
@@ -2,7 +2,7 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use crate::{snapshot_nonce::SnapshotNonce, Guard};
+use crate::{Guard, snapshot_nonce::SnapshotNonce};
type InnerIter = Box + Send + 'static>;
diff --git a/crates/fjall/src/journal/batch_reader.rs b/crates/fjall/src/journal/batch_reader.rs
index 4b858d8f4..4e606ad2b 100644
--- a/crates/fjall/src/journal/batch_reader.rs
+++ b/crates/fjall/src/journal/batch_reader.rs
@@ -3,7 +3,7 @@
// (found in the LICENSE-* files in the repository)
use super::reader::JournalReader;
-use crate::{journal::entry::Entry, keyspace::InternalKeyspaceId, JournalRecoveryError};
+use crate::{JournalRecoveryError, journal::entry::Entry, keyspace::InternalKeyspaceId};
use lsm_tree::{SeqNo, UserKey, UserValue, ValueType};
use std::{fs::OpenOptions, hash::Hasher};
@@ -63,7 +63,9 @@ impl JournalBatchReader {
fn on_close(&self) -> crate::Result<()> {
if self.is_in_batch {
- log::debug!("Invalid batch: missing terminator, but last batch, so probably incomplete, discarding to keep atomicity");
+ log::debug!(
+ "Invalid batch: missing terminator, but last batch, so probably incomplete, discarding to keep atomicity"
+ );
// Discard batch
self.truncate_to(self.last_valid_pos)?;
@@ -125,7 +127,9 @@ impl Iterator for JournalBatchReader {
self.checksum_builder = xxhash_rust::xxh3::Xxh3::new();
if got_checksum != expected_checksum {
- log::error!("Invalid batch: checksum check failed, expected: {expected_checksum}, got: {got_checksum}");
+ log::error!(
+ "Invalid batch: checksum check failed, expected: {expected_checksum}, got: {got_checksum}"
+ );
return Some(Err(JournalRecovery(JournalRecoveryError::ChecksumMismatch)));
}
diff --git a/crates/fjall/src/journal/entry.rs b/crates/fjall/src/journal/entry.rs
index 4b7066c5b..ee45fe344 100644
--- a/crates/fjall/src/journal/entry.rs
+++ b/crates/fjall/src/journal/entry.rs
@@ -2,11 +2,11 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use crate::{file::MAGIC_BYTES, keyspace::InternalKeyspaceId, Slice};
+use crate::{Slice, file::MAGIC_BYTES, keyspace::InternalKeyspaceId};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use lsm_tree::{
- coding::{Decode, Encode},
CompressionType, SeqNo, UserKey, UserValue, ValueType,
+ coding::{Decode, Encode},
};
use std::io::{Read, Write};
diff --git a/crates/fjall/src/journal/manager.rs b/crates/fjall/src/journal/manager.rs
index 3fad1b533..0dad2385c 100644
--- a/crates/fjall/src/journal/manager.rs
+++ b/crates/fjall/src/journal/manager.rs
@@ -49,17 +49,11 @@ pub struct JournalManager {
impl Drop for JournalManager {
fn drop(&mut self) {
log::trace!("Dropping journal manager");
-
- #[cfg(feature = "__internal_whitebox")]
- crate::drop::decrement_drop_counter();
}
}
impl JournalManager {
pub(crate) fn new() -> Self {
- #[cfg(feature = "__internal_whitebox")]
- crate::drop::increment_drop_counter();
-
Self {
items: Vec::with_capacity(10),
disk_space_in_bytes: 0,
diff --git a/crates/fjall/src/journal/mod.rs b/crates/fjall/src/journal/mod.rs
index 7b656d079..7151538ef 100644
--- a/crates/fjall/src/journal/mod.rs
+++ b/crates/fjall/src/journal/mod.rs
@@ -18,7 +18,7 @@ use crate::file::fsync_directory;
use batch_reader::JournalBatchReader;
use lsm_tree::CompressionType;
use reader::JournalReader;
-use recovery::{recover_journals, RecoveryResult};
+use recovery::{RecoveryResult, recover_journals};
use std::{
path::{Path, PathBuf},
sync::{Mutex, MutexGuard},
@@ -53,9 +53,6 @@ impl Drop for Journal {
log::error!("Flush error on drop: {e:?}");
}
}
-
- #[cfg(feature = "__internal_whitebox")]
- crate::drop::decrement_drop_counter();
}
}
@@ -92,9 +89,6 @@ impl Journal {
// IMPORTANT: fsync folder on Unix
fsync_directory(folder)?;
- #[cfg(feature = "__internal_whitebox")]
- crate::drop::increment_drop_counter();
-
Ok(Self {
writer: Mutex::new(writer),
})
diff --git a/crates/fjall/src/journal/writer.rs b/crates/fjall/src/journal/writer.rs
index 9cac11c52..bcff09cd6 100644
--- a/crates/fjall/src/journal/writer.rs
+++ b/crates/fjall/src/journal/writer.rs
@@ -2,7 +2,7 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use super::entry::{serialize_marker_item, Entry};
+use super::entry::{Entry, serialize_marker_item};
use crate::{
batch::item::Item as BatchItem, file::fsync_directory, journal::recovery::JournalId,
keyspace::InternalKeyspaceId,
diff --git a/crates/fjall/src/keyspace/config/compression.rs b/crates/fjall/src/keyspace/config/compression.rs
index c19149cca..3ec8d4b71 100644
--- a/crates/fjall/src/keyspace/config/compression.rs
+++ b/crates/fjall/src/keyspace/config/compression.rs
@@ -5,8 +5,8 @@
use crate::keyspace::config::{DecodeConfig, EncodeConfig};
use byteorder::{ReadBytesExt, WriteBytesExt};
use lsm_tree::{
- coding::{Decode, Encode},
CompressionType,
+ coding::{Decode, Encode},
};
impl EncodeConfig for crate::config::CompressionPolicy {
diff --git a/crates/fjall/src/keyspace/mod.rs b/crates/fjall/src/keyspace/mod.rs
index c2573d336..1d572d7b6 100644
--- a/crates/fjall/src/keyspace/mod.rs
+++ b/crates/fjall/src/keyspace/mod.rs
@@ -11,6 +11,7 @@ mod write_delay;
mod test;
use crate::{
+ Database, Guard, Iter,
file::{KEYSPACES_FOLDER, LSM_CURRENT_VERSION_MARKER},
flush::Task as FlushTask,
ingestion::Ingestion,
@@ -18,14 +19,13 @@ use crate::{
poison::PoisonSignal,
supervisor::Supervisor,
worker_pool::WorkerMessage,
- Database, Guard, Iter,
};
-use lsm_tree::{AbstractTree, AnyTree, SeqNo, UserKey, UserValue};
+use lsm_tree::{AbstractTree, SeqNo, Tree, UserKey, UserValue};
use options::CreateOptions;
use std::{
ops::RangeBounds,
path::Path,
- sync::{atomic::AtomicBool, Arc, MutexGuard},
+ sync::{Arc, MutexGuard, atomic::AtomicBool},
time::Duration,
};
use write_delay::perform_write_stall;
@@ -50,7 +50,6 @@ pub fn apply_to_base_config(
.index_block_pinning_policy(our_config.index_block_pinning_policy.clone())
.data_block_hash_ratio_policy(our_config.data_block_hash_ratio_policy.clone())
.expect_point_read_hits(our_config.expect_point_read_hits)
- .with_kv_separation(our_config.kv_separation_opts.clone())
.index_block_partitioning_policy(our_config.index_block_partitioning_policy.clone())
.filter_block_partitioning_policy(our_config.filter_block_partitioning_policy.clone())
.filter_policy(our_config.filter_policy.clone())
@@ -78,7 +77,7 @@ pub struct KeyspaceInner {
/// LSM-tree wrapper
#[doc(hidden)]
- pub tree: AnyTree,
+ pub tree: Tree,
pub(crate) supervisor: Supervisor,
@@ -132,9 +131,6 @@ impl Drop for KeyspaceInner {
}
}
}
-
- #[cfg(feature = "__internal_whitebox")]
- crate::drop::decrement_drop_counter();
}
}
@@ -183,14 +179,6 @@ impl std::hash::Hash for Keyspace {
}
impl Keyspace {
- #[inline]
- fn standard_tree(&self) -> &lsm_tree::Tree {
- let lsm_tree::AnyTree::Standard(tree) = &self.tree else {
- panic!("standard keyspace operation used with a blob keyspace");
- };
- tree
- }
-
#[doc(hidden)]
#[must_use]
pub fn id(&self) -> InternalKeyspaceId {
@@ -271,14 +259,6 @@ impl Keyspace {
Ok(())
}
- /// Returns the number of blob bytes on disk that are not referenced.
- ///
- /// These will be reclaimed over time by blob garbage collection automatically.
- #[must_use]
- pub fn fragmented_blob_bytes(&self) -> u64 {
- self.tree.stale_blob_bytes()
- }
-
#[doc(hidden)]
#[must_use]
pub fn sealed_memtable_count(&self) -> usize {
@@ -304,7 +284,7 @@ impl Keyspace {
pub(crate) fn from_database(
keyspace_id: InternalKeyspaceId,
db: &Database,
- tree: AnyTree,
+ tree: Tree,
name: KeyspaceKey,
config: CreateOptions,
) -> Self {
@@ -362,17 +342,6 @@ impl Keyspace {
})))
}
- /// Returns the metrics struct of the underlying LSM-tree.
- ///
- /// # Note
- ///
- /// This function is experimental and metric names may change in future releases.
- #[cfg(feature = "metrics")]
- #[doc(hidden)]
- pub fn metrics(&self) -> &lsm_tree::Metrics {
- &**self.tree.metrics()
- }
-
/// Returns the underlying LSM-tree's path.
#[must_use]
pub fn path(&self) -> &Path {
@@ -432,7 +401,7 @@ impl Keyspace {
) -> impl DoubleEndedIterator- > + Send + 'static {
let nonce = self.supervisor.snapshot_tracker.open();
let range = ..;
- self.standard_tree()
+ self.tree
.create_range::<&[u8], _>(&range, nonce.instant, None)
.map(move |item| {
let _keep_snapshot_alive = &nonce;
@@ -472,7 +441,7 @@ impl Keyspace {
range: R,
) -> impl DoubleEndedIterator
- > + Send + 'static {
let nonce = self.supervisor.snapshot_tracker.open();
- self.standard_tree()
+ self.tree
.create_range(&range, nonce.instant, None)
.map(move |item| {
let _keep_snapshot_alive = &nonce;
@@ -512,7 +481,7 @@ impl Keyspace {
prefix: K,
) -> impl DoubleEndedIterator
- > + Send + 'static {
let nonce = self.supervisor.snapshot_tracker.open();
- self.standard_tree()
+ self.tree
.create_prefix(prefix, nonce.instant, None)
.map(move |item| {
let _keep_snapshot_alive = &nonce;
@@ -677,7 +646,7 @@ impl Keyspace {
&self,
key: K,
) -> crate::Result> {
- Ok(self.standard_tree().get(key, SeqNo::MAX)?)
+ Ok(self.tree.get(key, SeqNo::MAX)?)
}
/// Retrieves the size of an item from the keyspace.
@@ -753,12 +722,6 @@ impl Keyspace {
self.tree.last_key_value(SeqNo::MAX, None).map(Guard)
}
- /// Returns `true` if the underlying LSM-tree is key-value-separated.
- #[must_use]
- pub fn is_kv_separated(&self) -> bool {
- matches!(self.tree, crate::AnyTree::Blob(_))
- }
-
// NOTE: Used in tests
#[doc(hidden)]
pub fn rotate_memtable_and_wait(&self) -> crate::Result<()> {
@@ -908,13 +871,6 @@ impl Keyspace {
self.tree.table_count()
}
- /// Number of blob files in the LSM-tree.
- #[doc(hidden)]
- #[must_use]
- pub fn blob_file_count(&self) -> usize {
- self.tree.blob_file_count()
- }
-
/// Performs major compaction, blocking the caller until it's done.
///
/// # Errors
diff --git a/crates/fjall/src/keyspace/options.rs b/crates/fjall/src/keyspace/options.rs
index 1b8455aa3..e0ceabc6c 100644
--- a/crates/fjall/src/keyspace/options.rs
+++ b/crates/fjall/src/keyspace/options.rs
@@ -8,13 +8,11 @@ use crate::{
FilterPolicyEntry, HashRatioPolicy, PartitioningPolicy, PinningPolicy,
RestartIntervalPolicy,
},
- keyspace::{config::DecodeConfig, InternalKeyspaceId},
- meta_keyspace::{encode_config_key, MetaKeyspace},
+ keyspace::{InternalKeyspaceId, config::DecodeConfig},
+ meta_keyspace::{MetaKeyspace, encode_config_key},
};
use byteorder::ReadBytesExt;
-use lsm_tree::{
- compaction::Factory as CompactionFilterFactory, CompressionType, KvPair, KvSeparationOptions,
-};
+use lsm_tree::{CompressionType, KvPair, compaction::Factory as CompactionFilterFactory};
use std::sync::Arc;
/// Options to configure a keyspace
@@ -72,12 +70,6 @@ pub struct CreateOptions {
pub(crate) manual_journal_persist: bool,
- #[doc(hidden)]
- pub compaction_strategy: Arc,
-
- #[doc(hidden)]
- pub kv_separation_opts: Option,
-
pub(crate) compaction_filter_factory: Option>,
}
@@ -120,12 +112,6 @@ impl Default for CreateOptions {
index_block_compression_policy: CompressionPolicy::all(CompressionType::None),
- compaction_strategy: Arc::new(
- crate::compaction::Leveled::default()
- ),
-
- kv_separation_opts: None,
-
compaction_filter_factory: None,
}
}
@@ -153,8 +139,6 @@ impl CreateOptions {
keyspace_id: InternalKeyspaceId,
meta_keyspace: &MetaKeyspace,
) -> crate::Result {
- let blob = meta_keyspace.get_kv_for_config(keyspace_id, "blob")?;
-
let data_block_compression_policy = meta_keyspace
.get_kv_for_config(keyspace_id, "data_block_compression_policy")?
.expect("should exist");
@@ -221,117 +205,6 @@ impl CreateOptions {
.expect("should exist");
let filter_policy = FilterPolicy::decode(&filter_policy)?;
- let blob_opts = blob.map(|_| {
- use byteorder::LE;
- use lsm_tree::coding::Decode;
-
- let blob_age_cutoff = meta_keyspace
- .get_kv_for_config(keyspace_id, "blob_age_cutoff")?
- .expect("blob_age_cutoff should be defined");
- let blob_age_cutoff = (&mut &blob_age_cutoff[..]).read_f32::()?;
-
- let blob_compression = meta_keyspace
- .get_kv_for_config(keyspace_id, "blob_compression")?
- .expect("blob_compression should be defined");
- let blob_compression = CompressionType::decode_from(&mut &blob_compression[..])?;
-
- let file_target_size = meta_keyspace
- .get_kv_for_config(keyspace_id, "blob_file_target_size")?
- .expect("blob_file_target_size should be defined");
- let file_target_size = (&mut &file_target_size[..]).read_u64::()?;
-
- let separation_threshold = meta_keyspace
- .get_kv_for_config(keyspace_id, "blob_separation_threshold")?
- .expect("blob_separation_threshold should be defined");
- let separation_threshold = (&mut &separation_threshold[..]).read_u32::()?;
-
- let staleness_threshold = meta_keyspace
- .get_kv_for_config(keyspace_id, "blob_staleness_threshold")?
- .expect("blob_staleness_threshold should be defined");
- let staleness_threshold = (&mut &staleness_threshold[..]).read_f32::()?;
-
- Ok::<_, crate::Error>(
- KvSeparationOptions::default()
- .compression(blob_compression)
- .file_target_size(file_target_size)
- .separation_threshold(separation_threshold)
- .staleness_threshold(staleness_threshold)
- .age_cutoff(blob_age_cutoff),
- )
- });
-
- let compaction_strategy_name = meta_keyspace
- .get_kv_for_config(keyspace_id, "compaction_strategy")?
- .expect("compaction_strategy should be defined");
-
- let compaction_strategy_name = std::str::from_utf8(&compaction_strategy_name)
- .expect("compaction_strategy should be UTF-8");
-
- let compaction_strategy = match compaction_strategy_name {
- lsm_tree::compaction::LEVELED_COMPACTION_NAME => {
- use byteorder::LE;
-
- let l0_threshold = meta_keyspace
- .get_kv_for_config(keyspace_id, "leveled_l0_threshold")?
- .expect("leveled_l0_threshold should be defined");
- let l0_threshold = (&mut &l0_threshold[..]).read_u8()?;
-
- let target_size = meta_keyspace
- .get_kv_for_config(keyspace_id, "leveled_target_size")?
- .expect("leveled_target_size should be defined");
- let target_size = (&mut &target_size[..]).read_u64::()?;
-
- let level_ratio_policy_bytes = meta_keyspace
- .get_kv_for_config(keyspace_id, "leveled_level_ratio_policy")?
- .expect("leveled_level_ratio_policy should be defined");
- let level_ratio_policy_bytes = &mut &level_ratio_policy_bytes[..];
-
- let level_ratio_policy_len = level_ratio_policy_bytes.read_u8()?;
-
- let mut ratios = vec![];
-
- for _ in 0..level_ratio_policy_len {
- ratios.push(level_ratio_policy_bytes.read_f32::()?);
- }
-
- Arc::new(
- crate::compaction::Leveled::default()
- .with_l0_threshold(l0_threshold)
- .with_table_target_size(target_size)
- .with_level_ratio_policy(ratios),
- ) as Arc
- }
- lsm_tree::compaction::FIFO_COMPACTION_NAME => {
- use byteorder::LE;
-
- let fifo_limit = meta_keyspace
- .get_kv_for_config(keyspace_id, "fifo_limit")?
- .expect("fifo_limit should be defined");
- let fifo_limit = (&mut &fifo_limit[..]).read_u64::()?;
-
- let has_ttl = meta_keyspace
- .get_kv_for_config(keyspace_id, "fifo_ttl")?
- .expect("fifo_ttl should be defined")
- == [1];
-
- let ttl_seconds = if has_ttl {
- let fifo_ttl_seconds = meta_keyspace
- .get_kv_for_config(keyspace_id, "fifo_ttl_seconds")?
- .expect("fifo_ttl_seconds should be defined");
- let fifo_ttl_seconds = (&mut &fifo_ttl_seconds[..]).read_u64::()?;
-
- Some(fifo_ttl_seconds)
- } else {
- None
- };
-
- Arc::new(crate::compaction::Fifo::new(fifo_limit, ttl_seconds))
- }
- name => {
- panic!("Invalid/unsupported compaction strategy: {name:?}");
- }
- };
-
let manual_journal_persist = meta_keyspace
.get_kv_for_config(keyspace_id, "manual_journal_persist")?
.expect("should exist")
@@ -368,10 +241,6 @@ impl CreateOptions {
max_memtable_size,
- compaction_strategy,
-
- kv_separation_opts: blob_opts.transpose()?,
-
compaction_filter_factory: None,
})
}
@@ -380,11 +249,7 @@ impl CreateOptions {
pub(crate) fn encode_kvs(&self, keyspace_id: InternalKeyspaceId) -> Vec {
use crate::keyspace::config::EncodeConfig;
- let mut kvs = vec![
- {
- let key = encode_config_key(keyspace_id, "compaction_strategy");
- (key, self.compaction_strategy.get_name().into())
- },
+ let kvs = vec![
policy!(
keyspace_id,
"data_block_compression_policy",
@@ -466,68 +331,9 @@ impl CreateOptions {
},
];
- match self.compaction_strategy.get_name() {
- "LeveledCompaction" | "FifoCompaction" => {
- kvs.extend(
- self.compaction_strategy
- .get_config()
- .into_iter()
- .map(|(k, v)| {
- // TODO: this is a bit stupid right now because we depend on behaviour in lsm-tree
- // we should probably make lsm-tree just return a String for the key
- let k = std::str::from_utf8(&k)
- .expect("compaction strategy should return UTF-8 key");
-
- (encode_config_key(keyspace_id, k), v)
- }),
- );
- }
- name => {
- panic!("Invalid/unsupported compaction strategy: {name:?}");
- }
- }
-
- if let Some(blob_opts) = &self.kv_separation_opts {
- kvs.extend([
- {
- let key = encode_config_key(keyspace_id, "blob");
- (key, [1u8].into())
- },
- {
- let key = encode_config_key(keyspace_id, "blob_age_cutoff");
- (key, blob_opts.age_cutoff.to_le_bytes().into())
- },
- {
- use lsm_tree::coding::Encode;
-
- let key = encode_config_key(keyspace_id, "blob_compression");
- (key, blob_opts.compression.encode_into_vec().into())
- },
- {
- let key = encode_config_key(keyspace_id, "blob_file_target_size");
- (key, blob_opts.file_target_size.to_le_bytes().into())
- },
- {
- let key = encode_config_key(keyspace_id, "blob_separation_threshold");
- (key, blob_opts.separation_threshold.to_le_bytes().into())
- },
- {
- let key = encode_config_key(keyspace_id, "blob_staleness_threshold");
- (key, blob_opts.staleness_threshold.to_le_bytes().into())
- },
- ]);
- }
-
kvs
}
- /// Toggles key-value separation.
- #[must_use]
- pub fn with_kv_separation(mut self, opts: Option) -> Self {
- self.kv_separation_opts = opts;
- self
- }
-
/// Sets the restart interval inside data blocks.
///
/// A higher restart interval saves space while increasing lookup times
@@ -632,18 +438,6 @@ impl CreateOptions {
self
}
- /// Sets the compaction strategy.
- ///
- /// Default = Leveled
- #[must_use]
- pub fn compaction_strategy(
- mut self,
- compaction_strategy: Arc,
- ) -> Self {
- self.compaction_strategy = compaction_strategy;
- self
- }
-
/// If `false`, writes will flush data to the operating system.
///
/// Default = false
@@ -704,23 +498,12 @@ mod tests {
c.data_block_compression_policy,
CompressionPolicy::disabled(),
);
- assert_eq!(c.kv_separation_opts, None);
-
- c = c.with_kv_separation(KvSeparationOptions::default());
- assert_eq!(
- c.kv_separation_opts.as_ref().unwrap().compression,
- CompressionType::None,
- );
c = c.data_block_compression_policy(CompressionPolicy::disabled());
assert_eq!(
c.data_block_compression_policy,
CompressionPolicy::disabled(),
);
- assert_eq!(
- c.kv_separation_opts.unwrap().compression,
- CompressionType::None,
- );
}
#[test]
@@ -734,16 +517,11 @@ mod tests {
c.data_block_compression_policy,
CompressionPolicy::new([Uncompressed, Uncompressed, Lz4]),
);
- assert_eq!(c.kv_separation_opts, None);
-
- c = c.with_kv_separation(Some(KvSeparationOptions::default()));
- assert_eq!(c.kv_separation_opts.as_ref().unwrap().compression, Lz4);
c = c.data_block_compression_policy(CompressionPolicy::disabled());
assert_eq!(
c.data_block_compression_policy,
CompressionPolicy::disabled(),
);
- assert_eq!(c.kv_separation_opts.as_ref().unwrap().compression, Lz4);
}
}
diff --git a/crates/fjall/src/lib.rs b/crates/fjall/src/lib.rs
index c241516c4..125fde69c 100644
--- a/crates/fjall/src/lib.rs
+++ b/crates/fjall/src/lib.rs
@@ -11,7 +11,6 @@
//! - Keyspaces (a.k.a. column families) with cross-keyspace atomic semantics
//! - Built-in compression (default = `LZ4`)
//! - Serializable transactions (optional)
-//! - Key-value separation for large blob use cases (optional)
//! - Automatic background maintenance
//!
//! It is not:
@@ -98,10 +97,6 @@ pub mod compaction;
mod db_config;
-#[cfg(feature = "__internal_whitebox")]
-#[doc(hidden)]
-pub mod drop;
-
mod db;
#[cfg(test)]
@@ -126,7 +121,6 @@ mod snapshot_nonce;
mod snapshot_tracker;
mod stats;
mod supervisor;
-mod tx;
mod version;
mod worker_pool;
mod write_buffer_manager;
@@ -152,27 +146,16 @@ pub use {
guard::Guard,
iter::Iter,
journal::{error::RecoveryError as JournalRecoveryError, writer::PersistMode},
- keyspace::{options::CreateOptions as KeyspaceCreateOptions, Keyspace},
+ keyspace::{Keyspace, options::CreateOptions as KeyspaceCreateOptions},
readable::Readable,
snapshot::Snapshot,
version::FormatVersion,
};
-pub use tx::single_writer::{
- SingleWriterTxKeyspace, TxDatabase as SingleWriterTxDatabase,
- WriteTransaction as SingleWriterWriteTx,
-};
-
-pub use tx::optimistic::{
- Conflict, OptimisticTxDatabase, OptimisticTxKeyspace, WriteTransaction as OptimisticWriteTx,
-};
-
#[doc(hidden)]
-pub use lsm_tree::{AbstractTree, AnyTree, Error as LsmError, TreeType};
+pub use lsm_tree::{AbstractTree, Error as LsmError};
-pub use lsm_tree::{
- CompressionType, KvPair, KvSeparationOptions, SeqNo, Slice, UserKey, UserValue,
-};
+pub use lsm_tree::{CompressionType, KvPair, SeqNo, Slice, UserKey, UserValue};
/// Utility functions
pub mod util {
diff --git a/crates/fjall/src/locked_file.rs b/crates/fjall/src/locked_file.rs
index 34bcafafe..fa018f8b3 100644
--- a/crates/fjall/src/locked_file.rs
+++ b/crates/fjall/src/locked_file.rs
@@ -61,7 +61,9 @@ impl LockedFileGuard {
if let Err(e) = file.try_lock() {
match e {
std::fs::TryLockError::Error(e) => {
- log::error!("Failed to acquire database lock - if this is expected, you can try opening again (maybe wait a little)");
+ log::error!(
+ "Failed to acquire database lock - if this is expected, you can try opening again (maybe wait a little)"
+ );
return Err(crate::Error::Io(e));
}
std::fs::TryLockError::WouldBlock => {
diff --git a/crates/fjall/src/meta_keyspace.rs b/crates/fjall/src/meta_keyspace.rs
index 0a3e1cb2e..6bb30e366 100644
--- a/crates/fjall/src/meta_keyspace.rs
+++ b/crates/fjall/src/meta_keyspace.rs
@@ -2,13 +2,13 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use crate::{db::Keyspaces, keyspace::InternalKeyspaceId, Keyspace};
+use crate::{Keyspace, db::Keyspaces, keyspace::InternalKeyspaceId};
use byteview::StrView;
-use lsm_tree::{AbstractTree, AnyTree, SeqNo, SequenceNumberCounter, UserValue};
+use lsm_tree::{AbstractTree, SeqNo, SequenceNumberCounter, Tree, UserValue};
use std::sync::{Arc, RwLock, RwLockWriteGuard};
pub fn encode_config_key(keyspace_id: InternalKeyspaceId, name: &str) -> crate::UserKey {
- use byteorder::{WriteBytesExt, BE};
+ use byteorder::{BE, WriteBytesExt};
use std::io::Write;
#[expect(unsafe_code)]
@@ -46,7 +46,7 @@ pub struct MetaKeyspace {
///
/// We never commit data through the WAL but write tables directly using
/// lsm-tree's ingestion API.
- inner: AnyTree,
+ inner: Tree,
/// Dictionary of all keyspaces
#[doc(hidden)]
@@ -58,7 +58,7 @@ pub struct MetaKeyspace {
impl MetaKeyspace {
pub(crate) fn new(
- inner: AnyTree,
+ inner: Tree,
keyspaces: Arc>,
seqno_generator: SequenceNumberCounter,
visible_seqno: SequenceNumberCounter,
@@ -224,7 +224,7 @@ impl MetaKeyspace {
#[cfg(test)]
mod tests {
- use crate::{Database, Guard, KeyspaceCreateOptions, Readable, SingleWriterTxDatabase};
+ use crate::{Database, Guard, KeyspaceCreateOptions};
use test_log::test;
const ITEM_COUNT: usize = 10;
@@ -374,83 +374,6 @@ mod tests {
Ok(())
}
- #[test]
- fn tx_keyspace_delete() -> crate::Result<()> {
- let folder = tempfile::tempdir()?;
-
- let path;
-
- {
- let db = SingleWriterTxDatabase::builder(&folder).open()?;
-
- let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- path = tree.path();
-
- assert!(path.try_exists()?);
-
- for x in 0..ITEM_COUNT as u64 {
- let key = x.to_be_bytes();
- let value = nanoid::nanoid!();
- tree.insert(key, value.as_bytes())?;
- }
-
- for x in 0..ITEM_COUNT as u64 {
- let key: [u8; 8] = (x + ITEM_COUNT as u64).to_be_bytes();
- let value = nanoid::nanoid!();
- tree.insert(key, value.as_bytes())?;
- }
-
- assert_eq!(db.read_tx().len(&tree)?, ITEM_COUNT * 2);
- assert_eq!(
- db.read_tx().iter(&tree).flat_map(Guard::key).count(),
- ITEM_COUNT * 2,
- );
- assert_eq!(
- db.read_tx().iter(&tree).rev().flat_map(Guard::key).count(),
- ITEM_COUNT * 2,
- );
- }
-
- for _ in 0..3 {
- let db = SingleWriterTxDatabase::builder(&folder).open()?;
-
- let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
-
- assert_eq!(db.read_tx().len(&tree)?, ITEM_COUNT * 2);
- assert_eq!(
- db.read_tx().iter(&tree).flat_map(Guard::key).count(),
- ITEM_COUNT * 2,
- );
- assert_eq!(
- db.read_tx().iter(&tree).rev().flat_map(Guard::key).count(),
- ITEM_COUNT * 2,
- );
-
- assert!(path.try_exists()?);
- }
-
- {
- let db = SingleWriterTxDatabase::builder(&folder).open()?;
-
- {
- let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
-
- assert!(path.try_exists()?);
-
- db.inner().delete_keyspace(tree.inner().clone())?;
- }
-
- assert!(!path.try_exists()?);
- }
-
- {
- let _db = Database::builder(&folder).open()?;
- assert!(!path.try_exists()?);
- }
-
- Ok(())
- }
-
#[test]
fn keyspace_delete_and_reopening_behavior() -> crate::Result<()> {
let keyspace_name = "default";
@@ -473,9 +396,10 @@ mod tests {
db.delete_keyspace(keyspace)?;
assert!(!keyspace_exists(1)?);
- assert!(db
- .keyspace("default", KeyspaceCreateOptions::default)
- .is_ok());
+ assert!(
+ db.keyspace("default", KeyspaceCreateOptions::default)
+ .is_ok()
+ );
assert!(keyspace_exists(2)?);
Ok(())
diff --git a/crates/fjall/src/poison.rs b/crates/fjall/src/poison.rs
index 5744b6c63..7000815a4 100644
--- a/crates/fjall/src/poison.rs
+++ b/crates/fjall/src/poison.rs
@@ -2,7 +2,7 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use std::sync::{atomic::AtomicBool, Arc};
+use std::sync::{Arc, atomic::AtomicBool};
#[derive(Clone, Debug, Default)]
pub struct PoisonSignal(Arc);
diff --git a/crates/fjall/src/recovery.rs b/crates/fjall/src/recovery.rs
index 629f87661..b7a49e8e9 100644
--- a/crates/fjall/src/recovery.rs
+++ b/crates/fjall/src/recovery.rs
@@ -3,15 +3,15 @@
// (found in the LICENSE-* files in the repository)
use crate::{
+ Database, HashMap, Keyspace,
file::{KEYSPACES_FOLDER, LSM_CURRENT_VERSION_MARKER},
journal::{
batch_reader::JournalBatchReader, manager::EvictionWatermark, reader::JournalReader,
},
keyspace::{
- apply_to_base_config, options::CreateOptions as KeyspaceCreateOptions, InternalKeyspaceId,
+ InternalKeyspaceId, apply_to_base_config, options::CreateOptions as KeyspaceCreateOptions,
},
meta_keyspace::MetaKeyspace,
- Database, HashMap, Keyspace,
};
use lsm_tree::AbstractTree;
use std::path::PathBuf;
@@ -177,9 +177,6 @@ pub fn recover_sealed_memtables(
lsm_tree::ValueType::WeakTombstone => {
tree.remove_weak(item.key, batch.seqno);
}
- lsm_tree::ValueType::Indirection => {
- unreachable!()
- }
}
}
diff --git a/crates/fjall/src/snapshot.rs b/crates/fjall/src/snapshot.rs
index 920bb328d..dd594bc80 100644
--- a/crates/fjall/src/snapshot.rs
+++ b/crates/fjall/src/snapshot.rs
@@ -2,7 +2,7 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use crate::{snapshot_nonce::SnapshotNonce, Guard, Iter, Keyspace, Readable};
+use crate::{Guard, Iter, Keyspace, Readable, snapshot_nonce::SnapshotNonce};
use lsm_tree::{AbstractTree, SeqNo, UserValue};
use std::ops::RangeBounds;
diff --git a/crates/fjall/src/snapshot_nonce.rs b/crates/fjall/src/snapshot_nonce.rs
index b8e47ad0f..9a7263b2d 100644
--- a/crates/fjall/src/snapshot_nonce.rs
+++ b/crates/fjall/src/snapshot_nonce.rs
@@ -2,7 +2,7 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use crate::{snapshot_tracker::SnapshotTracker, SeqNo};
+use crate::{SeqNo, snapshot_tracker::SnapshotTracker};
/// Holds a snapshot instant and automatically frees it from the snapshot tracker when dropped
pub struct SnapshotNonce {
diff --git a/crates/fjall/src/snapshot_tracker.rs b/crates/fjall/src/snapshot_tracker.rs
index 3d68fec2c..c9aa8f6f3 100644
--- a/crates/fjall/src/snapshot_tracker.rs
+++ b/crates/fjall/src/snapshot_tracker.rs
@@ -2,10 +2,10 @@
// This source code is licensed under both the Apache 2.0 and MIT License
// (found in the LICENSE-* files in the repository)
-use crate::{snapshot_nonce::SnapshotNonce, SeqNo};
+use crate::{SeqNo, snapshot_nonce::SnapshotNonce};
use dashmap::DashMap;
use lsm_tree::SequenceNumberCounter;
-use std::sync::{atomic::AtomicU64, Arc, RwLock};
+use std::sync::{Arc, RwLock, atomic::AtomicU64};
/// Keeps track of open snapshots
pub struct SnapshotTrackerInner {
diff --git a/crates/fjall/src/supervisor.rs b/crates/fjall/src/supervisor.rs
index d29f530a0..277d1b6fe 100644
--- a/crates/fjall/src/supervisor.rs
+++ b/crates/fjall/src/supervisor.rs
@@ -7,7 +7,7 @@ use lsm_tree::SequenceNumberCounter;
use crate::{
db::Keyspaces,
flush::manager::FlushManager,
- journal::{manager::JournalManager, Journal},
+ journal::{Journal, manager::JournalManager},
snapshot_tracker::SnapshotTracker,
write_buffer_manager::WriteBufferManager,
};
diff --git a/crates/fjall/src/tx/mod.rs b/crates/fjall/src/tx/mod.rs
deleted file mode 100644
index 4a0c61dfa..000000000
--- a/crates/fjall/src/tx/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-pub mod optimistic;
-pub mod single_writer;
-pub mod write_tx;
diff --git a/crates/fjall/src/tx/optimistic/conflict_manager.rs b/crates/fjall/src/tx/optimistic/conflict_manager.rs
deleted file mode 100644
index 992d52fce..000000000
--- a/crates/fjall/src/tx/optimistic/conflict_manager.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-use crate::keyspace::InternalKeyspaceId;
-use core::ops::Bound;
-use lsm_tree::Slice;
-use std::{
- collections::{BTreeMap, BTreeSet},
- ops::RangeBounds,
- sync::Mutex,
-};
-
-#[derive(Clone, Debug)]
-enum Read {
- Single(Slice),
- Range {
- start: Bound,
- end: Bound,
- },
- All,
-}
-
-#[derive(Default, Debug)]
-pub struct ConflictManager {
- reads: Mutex>>,
- conflict_keys: Mutex>>,
-}
-
-impl ConflictManager {
- fn push_read(&self, keyspace_id: InternalKeyspaceId, read: Read) {
- #[expect(clippy::expect_used)]
- let mut lock = self.reads.lock().expect("lock is poisoned");
-
- if let Some(tbl) = lock.get_mut(&keyspace_id) {
- tbl.push(read);
- } else {
- lock.entry(keyspace_id).or_default().push(read);
- }
- }
-
- pub fn mark_read(&self, keyspace_id: InternalKeyspaceId, key: Slice) {
- self.push_read(keyspace_id, Read::Single(key));
- }
-
- pub fn mark_conflict(&self, keyspace_id: InternalKeyspaceId, key: Slice) {
- #[expect(clippy::expect_used)]
- let mut lock = self.conflict_keys.lock().expect("lock is poisoned");
-
- if let Some(tbl) = lock.get_mut(&keyspace_id) {
- tbl.insert(key);
- } else {
- lock.entry(keyspace_id).or_default().insert(key);
- }
- }
-
- pub fn mark_range(&self, keyspace_id: InternalKeyspaceId, range: impl RangeBounds) {
- let start = match range.start_bound() {
- Bound::Included(k) => Bound::Included(k.clone()),
- Bound::Excluded(k) => Bound::Excluded(k.clone()),
- Bound::Unbounded => Bound::Unbounded,
- };
-
- let end = match range.end_bound() {
- Bound::Included(k) => Bound::Included(k.clone()),
- Bound::Excluded(k) => Bound::Excluded(k.clone()),
- Bound::Unbounded => Bound::Unbounded,
- };
-
- let read = if start == Bound::Unbounded && end == Bound::Unbounded {
- Read::All
- } else {
- Read::Range { start, end }
- };
-
- self.push_read(keyspace_id, read);
- }
-
- #[expect(clippy::too_many_lines, clippy::significant_drop_tightening)]
- pub fn has_conflict(&self, other: &Self) -> bool {
- #[expect(clippy::expect_used)]
- let reads_lock = self.reads.lock().expect("lock is poisoned");
-
- #[expect(clippy::expect_used)]
- let conflict_keys_lock = other.conflict_keys.lock().expect("lock is poisoned");
-
- if reads_lock.is_empty() {
- return false;
- }
-
- for (keyspace_name, keys) in &*reads_lock {
- if let Some(other_conflict_keys) = conflict_keys_lock.get(keyspace_name) {
- for ro in keys {
- match ro {
- Read::Single(k) => {
- if other_conflict_keys.contains(k) {
- return true;
- }
- }
- Read::Range { start, end } => match (start, end) {
- (Bound::Included(start), Bound::Included(end)) => {
- if other_conflict_keys
- .range::((
- Bound::Included(start),
- Bound::Included(end),
- ))
- .next()
- .is_some()
- {
- return true;
- }
- }
- (Bound::Included(start), Bound::Excluded(end)) => {
- if other_conflict_keys
- .range::((
- Bound::Included(start),
- Bound::Excluded(end),
- ))
- .next()
- .is_some()
- {
- return true;
- }
- }
- (Bound::Included(start), Bound::Unbounded) => {
- if other_conflict_keys
- .range::((Bound::Included(start), Bound::Unbounded))
- .next()
- .is_some()
- {
- return true;
- }
- }
- (Bound::Excluded(start), Bound::Included(end)) => {
- if other_conflict_keys
- .range::((
- Bound::Excluded(start),
- Bound::Included(end),
- ))
- .next()
- .is_some()
- {
- return true;
- }
- }
- (Bound::Excluded(start), Bound::Excluded(end)) => {
- if other_conflict_keys
- .range::((
- Bound::Excluded(start),
- Bound::Excluded(end),
- ))
- .next()
- .is_some()
- {
- return true;
- }
- }
- (Bound::Excluded(start), Bound::Unbounded) => {
- if other_conflict_keys
- .range::((Bound::Excluded(start), Bound::Unbounded))
- .next()
- .is_some()
- {
- return true;
- }
- }
- (Bound::Unbounded, Bound::Included(end)) => {
- let range = ..=end;
- for write in other_conflict_keys {
- if range.contains(&write) {
- return true;
- }
- }
- }
- (Bound::Unbounded, Bound::Excluded(end)) => {
- let range = ..end;
- for write in other_conflict_keys {
- if range.contains(&write) {
- return true;
- }
- }
- }
- (Bound::Unbounded, Bound::Unbounded) => unreachable!(),
- },
- Read::All => {
- if !other_conflict_keys.is_empty() {
- return true;
- }
- }
- }
- }
- }
- }
-
- false
- }
-}
diff --git a/crates/fjall/src/tx/optimistic/keyspace.rs b/crates/fjall/src/tx/optimistic/keyspace.rs
deleted file mode 100644
index 3e9d003a3..000000000
--- a/crates/fjall/src/tx/optimistic/keyspace.rs
+++ /dev/null
@@ -1,502 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-use crate::{tx::optimistic::OptimisticTxDatabase, Keyspace};
-use crate::{Guard, Readable};
-use lsm_tree::{UserKey, UserValue};
-use std::path::PathBuf;
-
-/// Handle to a keyspace of a transactional database
-#[derive(Clone)]
-pub struct OptimisticTxKeyspace {
- pub(crate) inner: Keyspace,
- pub(crate) db: OptimisticTxDatabase,
-}
-
-impl AsRef for OptimisticTxKeyspace {
- fn as_ref(&self) -> &Keyspace {
- self.inner()
- }
-}
-
-impl OptimisticTxKeyspace {
- /// Returns the underlying LSM-tree's path.
- #[must_use]
- pub fn path(&self) -> PathBuf {
- self.inner.path().into()
- }
-
- /// Approximates the number of items in the keyspace.
- ///
- /// For update- or delete-heavy workloads, this value will
- /// diverge from the real value, but is a O(1) operation.
- ///
- /// For insert-only workloads (e.g. logs, time series)
- /// this value is reliable.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// assert_eq!(tree.approximate_len(), 0);
- ///
- /// tree.insert("1", "abc")?;
- /// assert_eq!(tree.approximate_len(), 1);
- ///
- /// tree.remove("1")?;
- /// // Oops! approximate_len will not be reliable here
- /// assert_eq!(tree.approximate_len(), 2);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- #[must_use]
- pub fn approximate_len(&self) -> usize {
- self.inner.approximate_len()
- }
-
- /// Removes an item and returns its value if it existed.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let taken = tree.take("a")?.unwrap();
- /// assert_eq!(b"abc", &*taken);
- ///
- /// let item = tree.get("a")?;
- /// assert!(item.is_none());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn take>(&self, key: K) -> crate::Result> {
- self.fetch_update(key, |_| None)
- }
-
- /// Atomically updates an item and returns the previous value.
- ///
- /// Returning `None` removes the item if it existed before.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Note
- ///
- /// The provided closure can be called multiple times as this function
- /// automatically retries on conflict. Since this is an `FnMut`, make sure
- /// it is idempotent and will not cause side-effects.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, Slice, KeyspaceCreateOptions};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let prev = tree.fetch_update("a", |_| Some(Slice::from(*b"def")))?.unwrap();
- /// assert_eq!(b"abc", &*prev);
- ///
- /// let item = tree.get("a")?;
- /// assert_eq!(Some("def".as_bytes().into()), item);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let prev = tree.fetch_update("a", |_| None)?.unwrap();
- /// assert_eq!(b"abc", &*prev);
- ///
- /// let item = tree.get("a")?;
- /// assert!(item.is_none());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn fetch_update, F: FnMut(Option<&UserValue>) -> Option>(
- &self,
- key: K,
- mut f: F,
- ) -> crate::Result> {
- let key = key.into();
-
- loop {
- let mut tx = self.db.write_tx()?;
- let prev = tx.fetch_update(self.inner(), key.clone(), &mut f)?;
- if tx.commit()?.is_ok() {
- return Ok(prev);
- }
- }
- }
-
- /// Atomically updates an item and returns the new value.
- ///
- /// Returning `None` removes the item if it existed before.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Note
- ///
- /// The provided closure can be called multiple times as this function
- /// automatically retries on conflict. Since this is an `FnMut`, make sure
- /// it is idempotent and will not cause side-effects.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, Slice, KeyspaceCreateOptions};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let updated = tree.update_fetch("a", |_| Some(Slice::from(*b"def")))?.unwrap();
- /// assert_eq!(b"def", &*updated);
- ///
- /// let item = tree.get("a")?;
- /// assert_eq!(Some("def".as_bytes().into()), item);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let updated = tree.update_fetch("a", |_| None)?;
- /// assert!(updated.is_none());
- ///
- /// let item = tree.get("a")?;
- /// assert!(item.is_none());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn update_fetch, F: FnMut(Option<&UserValue>) -> Option>(
- &self,
- key: K,
- mut f: F,
- ) -> crate::Result> {
- let key = key.into();
-
- loop {
- let mut tx = self.db.write_tx()?;
- let updated = tx.update_fetch(self.inner(), key.clone(), &mut f)?;
- if tx.commit()?.is_ok() {
- return Ok(updated);
- }
- }
- }
-
- /// Inserts a key-value pair into the keyspace.
- ///
- /// Keys may be up to 65536 bytes long, values up to 2^32 bytes.
- /// Shorter keys and values result in better performance.
- ///
- /// If the key already exists, the item will be overwritten.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// assert!(!db.read_tx().is_empty(&tree)?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn insert, V: Into>(
- &self,
- key: K,
- value: V,
- ) -> crate::Result<()> {
- let mut tx = self.db.write_tx()?;
- tx.insert(self.inner(), key, value);
-
- #[expect(
- clippy::expect_used,
- clippy::missing_panics_doc,
- reason = "blind insert should not conflict ever"
- )]
- tx.commit()?.expect("blind insert should not conflict ever");
-
- Ok(())
- }
-
- /// Removes an item from the keyspace.
- ///
- /// The key may be up to 65536 bytes long.
- /// Shorter keys result in better performance.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- /// assert!(!db.read_tx().is_empty(&tree)?);
- ///
- /// tree.remove("a")?;
- /// assert!(db.read_tx().is_empty(&tree)?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn remove>(&self, key: K) -> crate::Result<()> {
- let mut tx = self.db.write_tx()?;
- tx.remove(self.inner(), key);
-
- #[expect(
- clippy::expect_used,
- clippy::missing_panics_doc,
- reason = "blind remove should not conflict ever"
- )]
- tx.commit()?.expect("blind remove should not conflict ever");
-
- Ok(())
- }
-
- /// Removes an item from the keyspace, leaving behind a weak tombstone.
- ///
- /// The tombstone marker of this delete operation will vanish when it
- /// collides with its corresponding insertion.
- /// This may cause older versions of the value to be resurrected, so it should
- /// only be used and preferred in scenarios where a key is only ever written once.
- ///
- /// The key may be up to 65536 bytes long.
- /// Shorter keys result in better performance.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Experimental
- ///
- /// This function is currently experimental.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- /// assert!(!db.read_tx().is_empty(&tree)?);
- ///
- /// tree.remove_weak("a")?;
- /// assert!(db.read_tx().is_empty(&tree)?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- #[doc(hidden)]
- pub fn remove_weak>(&self, key: K) -> crate::Result<()> {
- let mut tx = self.db.write_tx()?;
- tx.remove_weak(self.inner(), key);
-
- #[expect(clippy::expect_used)]
- tx.commit()?.expect("blind remove should not conflict ever");
-
- Ok(())
- }
-
- /// Retrieves an item from the keyspace.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- ///
- /// let item = tree.get("a")?;
- /// assert_eq!(Some("my_value".as_bytes().into()), item);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn get>(&self, key: K) -> crate::Result> {
- self.inner.get(key)
- }
-
- /// Retrieves the size of an item from the keyspace.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- ///
- /// let len = tree.size_of("a")?.unwrap_or_default();
- /// assert_eq!("my_value".len() as u32, len);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn size_of>(&self, key: K) -> crate::Result> {
- self.inner.size_of(key)
- }
-
- /// Returns the first key-value pair in the keyspace.
- /// The key in this pair is the minimum key in the keyspace.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- /// tree.insert("b", "my_value")?;
- ///
- /// assert_eq!(b"a", &*tree.first_key_value().unwrap().key()?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- #[must_use]
- pub fn first_key_value(&self) -> Option {
- let read_tx = self.db.read_tx();
- read_tx.first_key_value(self)
- }
-
- /// Returns the last key-value pair in the keyspace.
- /// The key in this pair is the maximum key in the keyspace.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- /// tree.insert("b", "my_value")?;
- ///
- /// assert_eq!(b"b", &*tree.last_key_value().unwrap().key()?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- #[must_use]
- pub fn last_key_value(&self) -> Option {
- let read_tx = self.db.read_tx();
- read_tx.last_key_value(self)
- }
-
- /// Returns `true` if the keyspace contains the specified key.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- ///
- /// assert!(tree.contains_key("a")?);
- /// assert!(!tree.contains_key("b")?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn contains_key>(&self, key: K) -> crate::Result {
- self.inner.contains_key(key)
- }
-
- /// Allows access to the inner keyspace handle, allowing to
- /// escape from the transactional context.
- #[doc(hidden)]
- #[must_use]
- pub fn inner(&self) -> &Keyspace {
- &self.inner
- }
-}
diff --git a/crates/fjall/src/tx/optimistic/mod.rs b/crates/fjall/src/tx/optimistic/mod.rs
deleted file mode 100644
index 1dca25162..000000000
--- a/crates/fjall/src/tx/optimistic/mod.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-mod conflict_manager;
-mod keyspace;
-mod oracle;
-mod write_tx;
-
-use crate::{
- keyspace::KeyspaceKey,
- tx::{optimistic::oracle::Oracle, single_writer::Openable},
- Config, Database, KeyspaceCreateOptions, PersistMode, Snapshot,
-};
-use std::{
- path::Path,
- sync::{Arc, Mutex},
-};
-
-pub use keyspace::OptimisticTxKeyspace;
-pub use write_tx::{Conflict, WriteTransaction};
-
-/// Transactional database
-#[derive(Clone)]
-pub struct OptimisticTxDatabase {
- pub(crate) inner: Database,
- pub(super) oracle: Arc,
-}
-
-impl Openable for OptimisticTxDatabase {
- fn open(config: Config) -> crate::Result
- where
- Self: Sized,
- {
- let inner = Database::create_or_recover(config)?;
- // inner.start_background_threads()?;
-
- Ok(Self {
- oracle: Arc::new(Oracle {
- write_serialize_lock: Mutex::default(),
- snapshot_tracker: inner.supervisor.snapshot_tracker.clone(),
- }),
- inner,
- })
- }
-}
-
-impl OptimisticTxDatabase {
- /// Creates a new database builder to create or open a database at `path`.
- pub fn builder(path: impl AsRef) -> crate::DatabaseBuilder {
- crate::DatabaseBuilder::new(path.as_ref())
- }
-
- #[doc(hidden)]
- #[must_use]
- pub fn inner(&self) -> &Database {
- &self.inner
- }
-
- /// Starts a new writeable transaction.
- ///
- /// # Errors
- ///
- /// Will return `Err` if creation failed.
- pub fn write_tx(&self) -> crate::Result {
- let snapshot = {
- // acquire a lock here to prevent getting a stale snapshot seqno
- // this will drain at least part of the commit queue, but ordering
- // is platform-dependent since we use std::sync::Mutex
- let _guard = self.oracle.write_serialize_lock()?;
-
- self.inner.supervisor.snapshot_tracker.open()
- };
-
- let mut write_tx =
- WriteTransaction::new(self.inner().clone(), snapshot, self.oracle.clone());
-
- if !self.inner.config.manual_journal_persist {
- write_tx = write_tx.durability(Some(PersistMode::Buffer));
- }
-
- Ok(write_tx)
- }
-
- /// Starts a new read-only transaction (a.k.a. [`Snapshot`]).
- #[must_use]
- pub fn read_tx(&self) -> Snapshot {
- self.inner.snapshot()
- }
-
- /// Flushes the active journal. The durability depends on the [`PersistMode`]
- /// used.
- ///
- /// Persisting only affects durability, NOT consistency! Even without flushing
- /// data is crash-safe.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{PersistMode, OptimisticTxDatabase, KeyspaceCreateOptions};
- /// # let folder = tempfile::tempdir()?;
- /// let db = OptimisticTxDatabase::builder(folder).open()?;
- /// let items = db.keyspace("my_items", KeyspaceCreateOptions::default)?;
- ///
- /// items.insert("a", "hello")?;
- ///
- /// db.persist(PersistMode::SyncAll)?;
- /// #
- /// # Ok::<_, fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Returns error, if an IO error occurred.
- pub fn persist(&self, mode: PersistMode) -> crate::Result<()> {
- self.inner.persist(mode)
- }
-
- /// Creates or opens a keyspace.
- ///
- /// If the keyspace does not yet exist, it will be created configured with `create_options`.
- /// Otherwise simply a handle to the existing keyspace will be returned.
- ///
- /// Keyspace names can be up to 255 characters long and can not be empty.
- ///
- /// # Errors
- ///
- /// Returns error, if an IO error occurred.
- ///
- /// # Panics
- ///
- /// Panics if the keyspace name is invalid.
- pub fn keyspace(
- &self,
- name: &str,
- create_options: impl FnOnce() -> KeyspaceCreateOptions,
- ) -> crate::Result {
- let keyspace = self.inner.keyspace(name, create_options)?;
-
- Ok(OptimisticTxKeyspace {
- inner: keyspace,
- db: self.clone(),
- })
- }
-
- /// Returns the number of keyspaces.
- #[must_use]
- pub fn keyspace_count(&self) -> usize {
- self.inner.keyspace_count()
- }
-
- /// Gets a list of all keyspace names in the database.
- #[must_use]
- pub fn list_keyspace_names(&self) -> Vec {
- self.inner.list_keyspace_names()
- }
-
- /// Returns `true` if the keyspace with the given name exists.
- #[must_use]
- pub fn keyspace_exists(&self, name: &str) -> bool {
- self.inner.keyspace_exists(name)
- }
-
- /// Returns the current write buffer size (active + sealed memtables).
- #[must_use]
- pub fn write_buffer_size(&self) -> u64 {
- self.inner.write_buffer_size()
- }
-
- /// Returns the number of journal fragments on disk.
- #[must_use]
- pub fn journal_count(&self) -> usize {
- self.inner.journal_count()
- }
-
- /// Returns the disk space usage of the entire database.
- ///
- /// # Errors
- ///
- /// Returns error, if an IO error occurred.
- pub fn disk_space(&self) -> crate::Result {
- self.inner.disk_space()
- }
-}
diff --git a/crates/fjall/src/tx/optimistic/oracle.rs b/crates/fjall/src/tx/optimistic/oracle.rs
deleted file mode 100644
index 5b423a6c1..000000000
--- a/crates/fjall/src/tx/optimistic/oracle.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-use super::conflict_manager::ConflictManager;
-use crate::snapshot_tracker::SnapshotTracker;
-use crate::SeqNo;
-use std::collections::BTreeMap;
-use std::sync::{Mutex, MutexGuard};
-
-pub enum CommitOutcome {
- Ok,
- Aborted(E),
- Conflicted,
-}
-
-pub struct Oracle {
- pub(super) write_serialize_lock: Mutex>,
- pub(super) snapshot_tracker: SnapshotTracker,
-}
-
-impl Oracle {
- pub(super) fn with_commit Result<(), E>>(
- &self,
- instant: SeqNo,
- conflict_checker: ConflictManager,
- f: F,
- ) -> crate::Result> {
- let mut committed_txns = self
- .write_serialize_lock
- .lock()
- .map_err(|_| crate::Error::Poisoned)?;
-
- // If the committed_txn.ts is less than `SeqNo` that implies that the
- // committed_txn finished before the current transaction started.
- // We don't need to check for conflict in that case.
- // This change assumes linearizability. Lack of linearizability could
- // cause the read ts of a new txn to be lower than the commit ts of
- // a txn before it.
- let conflicted =
- committed_txns
- .range((instant + 1)..)
- .any(|(_ts, other_conflict_checker)| {
- conflict_checker.has_conflict(other_conflict_checker)
- });
-
- self.snapshot_tracker.close_raw(instant);
-
- // TODO: This can be expensive and should probably be done in a background worker, or a after a memtable rotation
- let safe_to_gc = self.snapshot_tracker.get_seqno_safe_to_gc();
- committed_txns.retain(|ts, _| *ts > safe_to_gc);
-
- if conflicted {
- return Ok(CommitOutcome::Conflicted);
- }
-
- if let Err(e) = f() {
- return Ok(CommitOutcome::Aborted(e));
- }
-
- committed_txns.insert(self.snapshot_tracker.get(), conflict_checker);
-
- Ok(CommitOutcome::Ok)
- }
-
- pub(super) fn write_serialize_lock(
- &self,
- ) -> crate::Result>> {
- self.write_serialize_lock
- .lock()
- .map_err(|_| crate::Error::Poisoned)
- }
-}
-
-#[cfg(test)]
-mod tests {
- use crate::{KeyspaceCreateOptions, OptimisticTxDatabase, OptimisticTxKeyspace, Readable};
-
- #[expect(clippy::significant_drop_tightening)]
- fn run_tx(
- db: &OptimisticTxDatabase,
- tree: &OptimisticTxKeyspace,
- ) -> Result<(), Box> {
- let mut tx1 = db.write_tx()?;
- let mut tx2 = db.write_tx()?;
- tx1.insert(tree.inner(), "hello", "world");
-
- tx1.commit()??;
- assert!(tree.contains_key("hello")?);
-
- _ = tx2.get(tree.inner(), "hello")?;
-
- tx2.insert(tree.inner(), "hello", "world2");
- assert!(tx2.commit()?.is_err()); // intended to conflict
-
- Ok(())
- }
-
- #[expect(clippy::unwrap_used)]
- #[test]
- fn oracle_committed_txns_does_not_leak() -> crate::Result<()> {
- let tmpdir = tempfile::tempdir()?;
- let db = OptimisticTxDatabase::builder(tmpdir.path()).open()?;
-
- let part = db.keyspace("foo", KeyspaceCreateOptions::default)?;
-
- for _ in 0..10_000 {
- run_tx(&db, &part).unwrap();
- }
-
- assert!(dbg!(db.oracle.write_serialize_lock.lock().unwrap().len()) < 10_000);
-
- for _ in 0..10_000 {
- run_tx(&db, &part).unwrap();
- }
-
- assert!(dbg!(db.oracle.write_serialize_lock.lock().unwrap().len()) < 10_000);
-
- Ok(())
- }
-}
diff --git a/crates/fjall/src/tx/optimistic/write_tx.rs b/crates/fjall/src/tx/optimistic/write_tx.rs
deleted file mode 100644
index e4cfc2dfc..000000000
--- a/crates/fjall/src/tx/optimistic/write_tx.rs
+++ /dev/null
@@ -1,891 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-use crate::{
- snapshot_nonce::SnapshotNonce,
- tx::{
- optimistic::{
- conflict_manager::ConflictManager,
- oracle::{CommitOutcome, Oracle},
- },
- write_tx::BaseTransaction,
- },
- Database, Guard, Iter, Keyspace, PersistMode, Readable,
-};
-use lsm_tree::{Slice, UserKey, UserValue};
-use std::{
- fmt,
- ops::{Bound, RangeBounds, RangeFull},
- sync::Arc,
-};
-
-/// Transaction conflict
-///
-/// SSI transactions can conflict which require them to be rerun.
-#[derive(Debug)]
-pub struct Conflict;
-
-impl std::error::Error for Conflict {}
-
-impl fmt::Display for Conflict {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- "Transaction conflict".fmt(f)
- }
-}
-
-/// A cross-keyspace transaction using optimistic concurrency control
-///
-/// Use [`WriteTransaction::commit`] to commit changes to the keyspace(s).
-///
-/// Transactions keep a consistent view of the database at the time,
-/// meaning old data will not be dropped until it is not referenced by any active transaction.
-///
-/// For that reason, you should try to keep transactions short-lived, and make sure they
-/// are not held somewhere forever.
-///
-/// # Caution
-///
-/// The transaction may fail and have to be rerun if it conflicts.
-#[clippy::has_significant_drop]
-pub struct WriteTransaction {
- inner: BaseTransaction,
- cm: ConflictManager,
- oracle: Arc,
-}
-
-impl Readable for WriteTransaction {
- fn get>(
- &self,
- keyspace: impl AsRef,
- key: K,
- ) -> crate::Result> {
- let keyspace = keyspace.as_ref();
-
- let res = self.inner.get(keyspace, key.as_ref())?;
-
- self.cm.mark_read(keyspace.id, key.as_ref().into());
-
- Ok(res)
- }
-
- fn contains_key>(
- &self,
- keyspace: impl AsRef,
- key: K,
- ) -> crate::Result {
- let keyspace = keyspace.as_ref();
-
- let contains = self.inner.contains_key(keyspace, key.as_ref())?;
-
- self.cm.mark_read(keyspace.id, key.as_ref().into());
-
- Ok(contains)
- }
-
- fn first_key_value(&self, keyspace: impl AsRef) -> Option {
- self.iter(&keyspace).next()
- }
-
- fn last_key_value(&self, keyspace: impl AsRef) -> Option {
- self.iter(&keyspace).next_back()
- }
-
- fn size_of>(
- &self,
- keyspace: impl AsRef,
- key: K,
- ) -> crate::Result> {
- let keyspace = keyspace.as_ref();
- self.inner.size_of(keyspace, key)
- }
-
- fn iter(&self, keyspace: impl AsRef) -> Iter {
- self.cm.mark_range(keyspace.as_ref().id, RangeFull);
- self.inner.iter(keyspace)
- }
-
- fn range, R: RangeBounds>(
- &self,
- keyspace: impl AsRef,
- range: R,
- ) -> Iter {
- let start: Bound = range.start_bound().map(|k| k.as_ref().into());
- let end: Bound = range.end_bound().map(|k| k.as_ref().into());
-
- self.cm.mark_range(keyspace.as_ref().id, (start, end));
-
- self.inner.range(keyspace, range)
- }
-
- fn prefix>(&self, keyspace: impl AsRef, prefix: K) -> Iter {
- self.range(keyspace, lsm_tree::range::prefix_to_range(prefix.as_ref()))
- }
-}
-
-impl WriteTransaction {
- pub(crate) fn new(db: Database, nonce: SnapshotNonce, oracle: Arc) -> Self {
- Self {
- inner: BaseTransaction::new(db, nonce),
- cm: ConflictManager::default(),
- oracle,
- }
- }
-
- /// Sets the durability level.
- #[must_use]
- pub fn durability(mut self, mode: Option) -> Self {
- self.inner = self.inner.durability(mode);
- self
- }
-
- /// Removes an item and returns its value if it existed.
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let mut tx = db.write_tx()?;
- ///
- /// let taken = tx.take(&tree, "a")?.unwrap();
- /// assert_eq!(b"abc", &*taken);
- /// tx.commit()?;
- ///
- /// let item = tree.get("a")?;
- /// assert!(item.is_none());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn take>(
- &mut self,
- keyspace: impl AsRef,
- key: K,
- ) -> crate::Result> {
- self.fetch_update(keyspace, key, |_| None)
- }
-
- /// Atomically updates an item and returns the new value.
- ///
- /// Returning `None` removes the item if it existed before.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable, Slice};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let mut tx = db.write_tx()?;
- ///
- /// let updated = tx.update_fetch(&tree, "a", |_| Some(Slice::from(*b"def")))?.unwrap();
- /// assert_eq!(b"def", &*updated);
- /// tx.commit()?;
- ///
- /// let item = tree.get("a")?;
- /// assert_eq!(Some("def".as_bytes().into()), item);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let mut tx = db.write_tx()?;
- ///
- /// let updated = tx.update_fetch(&tree, "a", |_| None)?;
- /// assert!(updated.is_none());
- /// tx.commit()?;
- ///
- /// let item = tree.get("a")?;
- /// assert!(item.is_none());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn update_fetch, F: FnOnce(Option<&UserValue>) -> Option>(
- &mut self,
- keyspace: impl AsRef,
- key: K,
- f: F,
- ) -> crate::Result> {
- let keyspace = keyspace.as_ref();
- let key: UserKey = key.into();
-
- let updated = self.inner.update_fetch(keyspace, key.clone(), f)?;
-
- self.cm.mark_read(keyspace.id, key.clone());
- self.cm.mark_conflict(keyspace.id, key);
-
- Ok(updated)
- }
-
- /// Atomically updates an item and returns the previous value.
- ///
- /// Returning `None` removes the item if it existed before.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable, Slice};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let mut tx = db.write_tx()?;
- ///
- /// let prev = tx.fetch_update(&tree, "a", |_| Some(Slice::from(*b"def")))?.unwrap();
- /// assert_eq!(b"abc", &*prev);
- /// tx.commit()?;
- ///
- /// let item = tree.get("a")?;
- /// assert_eq!(Some("def".as_bytes().into()), item);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let mut tx = db.write_tx()?;
- ///
- /// let prev = tx.fetch_update(&tree, "a", |_| None)?.unwrap();
- /// assert_eq!(b"abc", &*prev);
- /// tx.commit()?;
- ///
- /// let item = tree.get("a")?;
- /// assert!(item.is_none());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn fetch_update, F: FnOnce(Option<&UserValue>) -> Option>(
- &mut self,
- keyspace: impl AsRef,
- key: K,
- f: F,
- ) -> crate::Result> {
- let keyspace = keyspace.as_ref();
- let key = key.into();
-
- let prev = self.inner.fetch_update(keyspace, key.clone(), f)?;
-
- self.cm.mark_read(keyspace.id, key.clone());
- self.cm.mark_conflict(keyspace.id, key);
-
- Ok(prev)
- }
-
- /// Inserts a key-value pair into the keyspace.
- ///
- /// Keys may be up to 65536 bytes long, values up to 2^32 bytes.
- /// Shorter keys and values result in better performance.
- ///
- /// If the key already exists, the item will be overwritten.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "previous_value")?;
- /// assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());
- ///
- /// let mut tx = db.write_tx()?;
- /// tx.insert(&tree, "a", "new_value");
- ///
- /// drop(tx);
- ///
- /// // Write was not committed
- /// assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- pub fn insert, V: Into>(
- &mut self,
- keyspace: impl AsRef,
- key: K,
- value: V,
- ) {
- let keyspace = keyspace.as_ref();
- let key: UserKey = key.into();
-
- self.inner.insert(keyspace, key.clone(), value);
- self.cm.mark_conflict(keyspace.id, key);
- }
-
- /// Removes an item from the keyspace.
- ///
- /// The key may be up to 65536 bytes long.
- /// Shorter keys result in better performance.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "previous_value")?;
- /// assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());
- ///
- /// let mut tx = db.write_tx()?;
- /// tx.remove(&tree, "a");
- ///
- /// // Read-your-own-write
- /// let item = tx.get(&tree, "a")?;
- /// assert_eq!(None, item);
- ///
- /// drop(tx);
- ///
- /// // Deletion was not committed
- /// assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- pub fn remove>(&mut self, keyspace: impl AsRef, key: K) {
- let keyspace = keyspace.as_ref();
- let key: UserKey = key.into();
-
- self.inner.remove(keyspace, key.clone());
- self.cm.mark_conflict(keyspace.id, key);
- }
-
- /// Removes an item from the keyspace, leaving behind a weak tombstone.
- ///
- /// The tombstone marker of this delete operation will vanish when it
- /// collides with its corresponding insertion.
- /// This may cause older versions of the value to be resurrected, so it should
- /// only be used and preferred in scenarios where a key is only ever written once.
- ///
- /// # Experimental
- ///
- /// This function is currently experimental.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{OptimisticTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = OptimisticTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "previous_value")?;
- /// assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());
- ///
- /// let mut tx = db.write_tx()?;
- /// tx.remove_weak(&tree, "a");
- ///
- /// // Read-your-own-write
- /// let item = tx.get(&tree, "a")?;
- /// assert_eq!(None, item);
- ///
- /// drop(tx);
- ///
- /// // Deletion was not committed
- /// assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- #[doc(hidden)]
- pub fn remove_weak>(&mut self, keyspace: impl AsRef, key: K) {
- let keyspace = keyspace.as_ref();
- let key: UserKey = key.into();
-
- self.inner.remove_weak(keyspace, key.clone());
- self.cm.mark_conflict(keyspace.id, key);
- }
-
- /// Commits the transaction.
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn commit(self) -> crate::Result> {
- // NOTE: We have no write set, so we are basically
- // a read-only transaction, so nothing to do here
- if self.inner.memtables.is_empty() {
- return Ok(Ok(()));
- }
-
- let oracle = self.oracle.clone();
-
- match oracle.with_commit(self.inner.nonce.instant, self.cm, move || {
- self.inner.commit()
- })? {
- CommitOutcome::Ok => Ok(Ok(())),
- CommitOutcome::Aborted(e) => Err(e),
- CommitOutcome::Conflicted => Ok(Err(Conflict)),
- }
- }
-
- /// More explicit alternative to dropping the transaction
- /// to roll it back.
- pub fn rollback(self) {
- self.inner.rollback();
- }
-}
-
-#[cfg(test)]
-mod tests {
- use crate::{
- Conflict, KeyspaceCreateOptions, OptimisticTxDatabase, OptimisticTxKeyspace, Readable,
- };
- use tempfile::TempDir;
- use test_log::test;
-
- struct TestEnv {
- db: OptimisticTxDatabase,
- tree: OptimisticTxKeyspace,
-
- #[expect(unused)]
- tmpdir: TempDir,
- }
-
- impl TestEnv {
- fn seed_hermitage_data(&self) -> crate::Result<()> {
- self.tree.insert([1u8], [10u8])?;
- self.tree.insert([2u8], [20u8])?;
- Ok(())
- }
- }
-
- fn setup() -> Result> {
- let tmpdir = tempfile::tempdir()?;
- let db = OptimisticTxDatabase::builder(tmpdir.path()).open()?;
-
- let tree = db.keyspace("foo", KeyspaceCreateOptions::default)?;
-
- Ok(TestEnv { db, tree, tmpdir })
- }
-
- // Adapted from https://github.com/al8n/skipdb/issues/10
- #[test]
- #[expect(clippy::unwrap_used)]
- fn tx_ssi_arthur_1() -> Result<(), Box> {
- let env = setup()?;
-
- let mut tx = env.db.write_tx()?;
- tx.insert(env.tree.inner(), "a1", 10u64.to_be_bytes());
- tx.insert(env.tree.inner(), "b1", 100u64.to_be_bytes());
- tx.insert(env.tree.inner(), "b2", 200u64.to_be_bytes());
- tx.commit()??;
-
- let mut tx1 = env.db.write_tx()?;
- let val = tx1
- .range(&env.tree, "a".."b")
- .map(|kv| {
- let v = kv.value().unwrap();
-
- let mut buf = [0u8; 8];
- buf.copy_from_slice(&v);
- u64::from_be_bytes(buf)
- })
- .sum::();
- tx1.insert(env.tree.inner(), "b3", 10u64.to_be_bytes());
- assert_eq!(10, val);
-
- let mut tx2 = env.db.write_tx()?;
- let val = tx2
- .range(&env.tree, "b".."c")
- .map(|kv| {
- let v = kv.value().unwrap();
-
- let mut buf = [0u8; 8];
- buf.copy_from_slice(&v);
- u64::from_be_bytes(buf)
- })
- .sum::();
- tx2.insert(env.tree.inner(), "a3", 300u64.to_be_bytes());
- assert_eq!(300, val);
- tx2.commit()??;
- assert!(matches!(tx1.commit()?, Err(Conflict)));
-
- let tx3 = env.db.write_tx()?;
- let val = tx3
- .iter(&env.tree)
- .filter_map(|kv| {
- let (k, v) = kv.into_inner().unwrap();
-
- if k.starts_with(b"a") {
- let mut buf = [0u8; 8];
- buf.copy_from_slice(&v);
- Some(u64::from_be_bytes(buf))
- } else {
- None
- }
- })
- .sum::();
- assert_eq!(310, val);
-
- Ok(())
- }
-
- // Adapted from https://github.com/al8n/skipdb/issues/10
- #[test]
- #[expect(clippy::unwrap_used)]
- fn tx_ssi_arthur_2() -> Result<(), Box> {
- let env = setup()?;
-
- let mut tx = env.db.write_tx()?;
- tx.insert(env.tree.inner(), "b1", 100u64.to_be_bytes());
- tx.insert(env.tree.inner(), "b2", 200u64.to_be_bytes());
- tx.commit()??;
-
- let mut tx1 = env.db.write_tx()?;
- let val = tx1
- .range(&env.tree, "a".."b")
- .map(|kv| {
- let v = kv.value().unwrap();
-
- let mut buf = [0u8; 8];
- buf.copy_from_slice(&v);
- u64::from_be_bytes(buf)
- })
- .sum::();
- tx1.insert(env.tree.inner(), "b3", 0u64.to_be_bytes());
- assert_eq!(0, val);
-
- let mut tx2 = env.db.write_tx()?;
- let val = tx2
- .range(&env.tree, "b".."c")
- .map(|kv| {
- let v = kv.value().unwrap();
-
- let mut buf = [0u8; 8];
- buf.copy_from_slice(&v);
- u64::from_be_bytes(buf)
- })
- .sum::();
- tx2.insert(env.tree.inner(), "a3", 300u64.to_be_bytes());
- assert_eq!(300, val);
- tx2.commit()??;
- assert!(matches!(tx1.commit()?, Err(Conflict)));
-
- let tx3 = env.db.write_tx()?;
- let val = tx3
- .iter(&env.tree)
- .filter_map(|kv| {
- let (k, v) = kv.into_inner().unwrap();
-
- if k.starts_with(b"a") {
- let mut buf = [0u8; 8];
- buf.copy_from_slice(&v);
- Some(u64::from_be_bytes(buf))
- } else {
- None
- }
- })
- .sum::();
- assert_eq!(300, val);
-
- Ok(())
- }
-
- #[test]
- fn tx_ssi_basic() -> Result<(), Box> {
- let env = setup()?;
-
- let mut tx1 = env.db.write_tx()?;
- let mut tx2 = env.db.write_tx()?;
-
- tx1.insert(env.tree.inner(), "hello", "world");
-
- tx1.commit()??;
- assert!(env.tree.contains_key("hello")?);
-
- assert_eq!(tx2.get(env.tree.inner(), "hello")?, None);
-
- tx2.insert(env.tree.inner(), "hello", "world2");
- assert!(matches!(tx2.commit()?, Err(Conflict)));
-
- let mut tx1 = env.db.write_tx()?;
- let mut tx2 = env.db.write_tx()?;
-
- tx1.iter(&env.tree).next();
- tx2.insert(env.tree.inner(), "hello", "world2");
-
- tx1.insert(env.tree.inner(), "hello2", "world1");
- tx1.commit()??;
-
- tx2.commit()??;
-
- Ok(())
- }
-
- #[test]
- #[expect(clippy::unwrap_used)]
- fn tx_ssi_ww() -> Result<(), Box> {
- // https://en.wikipedia.org/wiki/Write%E2%80%93write_conflict
- let env = setup()?;
-
- let mut tx1 = env.db.write_tx()?;
- let mut tx2 = env.db.write_tx()?;
-
- tx1.insert(env.tree.inner(), "a", "a");
- tx2.insert(env.tree.inner(), "b", "c");
- tx1.insert(env.tree.inner(), "b", "b");
- tx1.commit()??;
-
- tx2.insert(env.tree.inner(), "a", "c");
-
- tx2.commit()??;
- assert_eq!(b"c", &*env.tree.get("a")?.unwrap());
- assert_eq!(b"c", &*env.tree.get("b")?.unwrap());
-
- Ok(())
- }
-
- #[test]
- #[expect(clippy::unwrap_used)]
- fn tx_ssi_swap() -> Result<(), Box> {
- let env = setup()?;
-
- env.tree.insert("x", "x")?;
- env.tree.insert("y", "y")?;
-
- let mut tx1 = env.db.write_tx()?;
- let mut tx2 = env.db.write_tx()?;
-
- {
- let x = tx1.get(env.tree.inner(), "x")?.unwrap();
- tx1.insert(env.tree.inner(), "y", x);
- }
-
- {
- let y = tx2.get(env.tree.inner(), "y")?.unwrap();
- tx2.insert(env.tree.inner(), "x", y);
- }
-
- tx1.commit()??;
- assert!(matches!(tx2.commit()?, Err(Conflict)));
-
- Ok(())
- }
-
- #[test]
- fn tx_ssi_write_cycles() -> Result<(), Box> {
- let env = setup()?;
- env.seed_hermitage_data()?;
-
- let mut t1 = env.db.write_tx()?;
- let mut t2 = env.db.write_tx()?;
-
- t1.insert(env.tree.inner(), [1u8], [11u8]);
- t2.insert(env.tree.inner(), [1u8], [12u8]);
- t1.insert(env.tree.inner(), [2u8], [21u8]);
- t1.commit()??;
-
- assert_eq!(env.tree.get([1u8])?, Some([11u8].into()));
-
- t2.insert(env.tree.inner(), [2u8], [22u8]);
- t2.commit()??;
-
- assert_eq!(env.tree.get([1u8])?, Some([12u8].into()));
- assert_eq!(env.tree.get([2u8])?, Some([22u8].into()));
-
- Ok(())
- }
-
- #[test]
- fn tx_ssi_aborted_reads() -> Result<(), Box> {
- let env = setup()?;
- env.seed_hermitage_data()?;
-
- let mut t1 = env.db.write_tx()?;
- let t2 = env.db.write_tx()?;
-
- t1.insert(env.tree.inner(), [1u8], [101u8]);
-
- assert_eq!(t2.get(env.tree.inner(), [1u8])?, Some([10u8].into()));
-
- t1.rollback();
-
- assert_eq!(t2.get(env.tree.inner(), [1u8])?, Some([10u8].into()));
-
- t2.commit()??;
-
- Ok(())
- }
-
- #[expect(clippy::unwrap_used)]
- #[test]
- fn tx_ssi_anti_dependency_cycles() -> Result<(), Box> {
- let env = setup()?;
- env.seed_hermitage_data()?;
-
- let mut t1 = env.db.write_tx()?;
- {
- let mut iter = t1.iter(&env.tree);
- assert_eq!(
- iter.next().unwrap().into_inner()?,
- ([1u8].into(), [10u8].into()),
- );
- assert_eq!(
- iter.next().unwrap().into_inner()?,
- ([2u8].into(), [20u8].into()),
- );
- assert!(iter.next().is_none());
- }
-
- let mut t2 = env.db.write_tx()?;
- let new = t2.update_fetch(&env.tree, [2u8], |v| {
- v.and_then(|v| v.first().copied()).map(|v| [v + 5].into())
- })?;
- assert_eq!(new, Some([25u8].into()));
- t2.commit()??;
-
- let t3 = env.db.write_tx()?;
- {
- let mut iter = t3.iter(&env.tree);
- assert_eq!(
- iter.next().unwrap().into_inner()?,
- ([1u8].into(), [10u8].into()),
- );
- assert_eq!(
- iter.next().unwrap().into_inner()?,
- ([2u8].into(), [25u8].into()),
- ); // changed here
- assert!(iter.next().is_none());
- }
-
- t3.commit()??;
-
- t1.insert(env.tree.inner(), [1u8], [0u8]);
-
- assert!(matches!(t1.commit()?, Err(Conflict)));
-
- Ok(())
- }
-
- #[test]
- fn tx_ssi_update_fetch_update() -> Result<(), Box> {
- let env = setup()?;
-
- let mut t1 = env.db.write_tx()?;
- let mut t2 = env.db.write_tx()?;
-
- let new = t1.update_fetch(env.tree.inner(), "hello", |_| Some("world".into()))?;
- assert_eq!(new, Some("world".into()));
- let old = t2.fetch_update(env.tree.inner(), "hello", |_| Some("world2".into()))?;
- assert_eq!(old, None);
-
- t1.commit()??;
- assert!(matches!(t2.commit()?, Err(Conflict)));
-
- assert_eq!(env.tree.get("hello")?, Some("world".into()));
-
- let mut t1 = env.db.write_tx()?;
- let mut t2 = env.db.write_tx()?;
-
- let old = t1.fetch_update(env.tree.inner(), "hello", |_| Some("world3".into()))?;
- assert_eq!(old, Some("world".into()));
- let new = t2.update_fetch(env.tree.inner(), "hello2", |_| Some("world2".into()))?;
- assert_eq!(new, Some("world2".into()));
-
- t1.commit()??;
- t2.commit()??;
-
- assert_eq!(env.tree.get("hello")?, Some("world3".into()));
- assert_eq!(env.tree.get("hello2")?, Some("world2".into()));
-
- Ok(())
- }
-
- #[test]
- fn tx_ssi_range() -> Result<(), Box> {
- let env = setup()?;
-
- let mut t1 = env.db.write_tx()?;
- let mut t2 = env.db.write_tx()?;
-
- _ = t1.range(&env.tree, "h"..="hello");
- t1.insert(env.tree.inner(), "foo", "bar");
-
- // insert a key INSIDE the range read by t1
- t2.insert(env.tree.inner(), "hello", "world");
-
- t2.commit()??;
- assert!(matches!(t1.commit()?, Err(Conflict)));
-
- let mut t1 = env.db.write_tx()?;
- let mut t2 = env.db.write_tx()?;
-
- _ = t1.range(&env.tree, "h"..="hello");
- t1.insert(env.tree.inner(), "foo", "bar");
-
- // insert a key OUTSIDE the range read by t1
- t2.insert(env.tree.inner(), "hello2", "world");
-
- t2.commit()??;
- t1.commit()??;
-
- Ok(())
- }
-
- #[test]
- fn tx_ssi_prefix() -> Result<(), Box> {
- let env = setup()?;
-
- let mut t1 = env.db.write_tx()?;
- let mut t2 = env.db.write_tx()?;
-
- _ = t1.prefix(&env.tree, "hello");
- t1.insert(env.tree.inner(), "foo", "bar");
-
- // insert a key MATCHING the prefix read by t1
- t2.insert(env.tree.inner(), "hello", "world");
-
- t2.commit()??;
- assert!(matches!(t1.commit()?, Err(Conflict)));
-
- let mut t1 = env.db.write_tx()?;
- let mut t2 = env.db.write_tx()?;
-
- _ = t1.prefix(&env.tree, "hello");
- t1.insert(env.tree.inner(), "foo", "bar");
-
- // insert a key NOT MATCHING the range read by t1
- t2.insert(env.tree.inner(), "foobar", "world");
-
- t2.commit()??;
- t1.commit()??;
-
- Ok(())
- }
-}
diff --git a/crates/fjall/src/tx/single_writer/keyspace.rs b/crates/fjall/src/tx/single_writer/keyspace.rs
deleted file mode 100644
index ab0ac3179..000000000
--- a/crates/fjall/src/tx/single_writer/keyspace.rs
+++ /dev/null
@@ -1,469 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-use crate::{Guard, Keyspace, Readable, SingleWriterTxDatabase};
-use lsm_tree::{UserKey, UserValue};
-use std::path::PathBuf;
-
-/// Handle to a keyspace of a transactional database
-#[derive(Clone)]
-pub struct SingleWriterTxKeyspace {
- pub(crate) inner: Keyspace,
- pub(crate) db: SingleWriterTxDatabase,
-}
-
-impl AsRef for SingleWriterTxKeyspace {
- fn as_ref(&self) -> &Keyspace {
- self.inner()
- }
-}
-
-impl SingleWriterTxKeyspace {
- /// Returns the underlying LSM-tree's path.
- #[must_use]
- pub fn path(&self) -> PathBuf {
- self.inner.path().into()
- }
-
- /// Approximates the number of items in the keyspace.
- ///
- /// For update- or delete-heavy workloads, this value will
- /// diverge from the real value, but is a O(1) operation.
- ///
- /// For insert-only workloads (e.g. logs, time series)
- /// this value is reliable.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// assert_eq!(tree.approximate_len(), 0);
- ///
- /// tree.insert("1", "abc")?;
- /// assert_eq!(tree.approximate_len(), 1);
- ///
- /// tree.remove("1")?;
- /// // Oops! approximate_len will not be reliable here
- /// assert_eq!(tree.approximate_len(), 2);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- #[must_use]
- pub fn approximate_len(&self) -> usize {
- self.inner.approximate_len()
- }
-
- /// Removes an item and returns its value if it existed.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let taken = tree.take("a")?.unwrap();
- /// assert_eq!(b"abc", &*taken);
- ///
- /// let item = tree.get("a")?;
- /// assert!(item.is_none());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn take>(&self, key: K) -> crate::Result> {
- self.fetch_update(key, |_| None)
- }
-
- /// Atomically updates an item and returns the previous value.
- ///
- /// Returning `None` removes the item if it existed before.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, Slice, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let prev = tree.fetch_update("a", |_| Some(Slice::from(*b"def")))?.unwrap();
- /// assert_eq!(b"abc", &*prev);
- ///
- /// let item = tree.get("a")?;
- /// assert_eq!(Some("def".as_bytes().into()), item);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let prev = tree.fetch_update("a", |_| None)?.unwrap();
- /// assert_eq!(b"abc", &*prev);
- ///
- /// let item = tree.get("a")?;
- /// assert!(item.is_none());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn fetch_update, F: FnOnce(Option<&UserValue>) -> Option>(
- &self,
- key: K,
- f: F,
- ) -> crate::Result> {
- let key: UserKey = key.into();
-
- let mut tx = self.db.write_tx();
-
- let prev = tx.fetch_update(self, key, f)?;
- tx.commit()?;
-
- Ok(prev)
- }
-
- /// Atomically updates an item and returns the new value.
- ///
- /// Returning `None` removes the item if it existed before.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, Slice, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let updated = tree.update_fetch("a", |_| Some(Slice::from(*b"def")))?.unwrap();
- /// assert_eq!(b"def", &*updated);
- ///
- /// let item = tree.get("a")?;
- /// assert_eq!(Some("def".as_bytes().into()), item);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// # use std::sync::Arc;
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// let updated = tree.update_fetch("a", |_| None)?;
- /// assert!(updated.is_none());
- ///
- /// let item = tree.get("a")?;
- /// assert!(item.is_none());
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn update_fetch, F: FnOnce(Option<&UserValue>) -> Option>(
- &self,
- key: K,
- f: F,
- ) -> crate::Result> {
- let key = key.into();
-
- let mut tx = self.db.write_tx();
- let updated = tx.update_fetch(self, key, f)?;
- tx.commit()?;
-
- Ok(updated)
- }
-
- /// Inserts a key-value pair into the keyspace.
- ///
- /// Keys may be up to 65536 bytes long, values up to 2^32 bytes.
- /// Shorter keys and values result in better performance.
- ///
- /// If the key already exists, the item will be overwritten.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- ///
- /// assert!(!db.read_tx().is_empty(&tree)?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn insert, V: Into>(
- &self,
- key: K,
- value: V,
- ) -> crate::Result<()> {
- let mut tx = self.db.write_tx();
- tx.insert(self, key, value);
- tx.commit()?;
- Ok(())
- }
-
- /// Removes an item from the keyspace.
- ///
- /// The key may be up to 65536 bytes long.
- /// Shorter keys result in better performance.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- /// assert!(!db.read_tx().is_empty(&tree)?);
- ///
- /// tree.remove("a")?;
- /// assert!(db.read_tx().is_empty(&tree)?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn remove>(&self, key: K) -> crate::Result<()> {
- let mut tx = self.db.write_tx();
- tx.remove(self, key);
- tx.commit()?;
- Ok(())
- }
-
- /// Removes an item from the keyspace, leaving behind a weak tombstone.
- ///
- /// The tombstone marker of this delete operation will vanish when it
- /// collides with its corresponding insertion.
- /// This may cause older versions of the value to be resurrected, so it should
- /// only be used and preferred in scenarios where a key is only ever written once.
- ///
- /// The key may be up to 65536 bytes long.
- /// Shorter keys result in better performance.
- ///
- /// The operation will run wrapped in a transaction.
- ///
- /// # Experimental
- ///
- /// This function is currently experimental.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "abc")?;
- /// assert!(!db.read_tx().is_empty(&tree)?);
- ///
- /// tree.remove_weak("a")?;
- /// assert!(db.read_tx().is_empty(&tree)?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- #[doc(hidden)]
- pub fn remove_weak>(&self, key: K) -> crate::Result<()> {
- let mut tx = self.db.write_tx();
- tx.remove_weak(self, key);
- tx.commit()?;
- Ok(())
- }
-
- /// Retrieves an item from the keyspace.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- ///
- /// let item = tree.get("a")?;
- /// assert_eq!(Some("my_value".as_bytes().into()), item);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn get>(&self, key: K) -> crate::Result> {
- self.inner.get(key)
- }
-
- /// Retrieves the size of an item from the keyspace.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- ///
- /// let len = tree.size_of("a")?.unwrap_or_default();
- /// assert_eq!("my_value".len() as u32, len);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn size_of>(&self, key: K) -> crate::Result> {
- self.inner.size_of(key)
- }
-
- /// Returns the first key-value pair in the keyspace.
- /// The key in this pair is the minimum key in the keyspace.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- /// tree.insert("b", "my_value")?;
- ///
- /// assert_eq!(b"a", &*tree.first_key_value().unwrap().key()?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- #[must_use]
- pub fn first_key_value(&self) -> Option {
- let read_tx = self.db.read_tx();
- read_tx.first_key_value(self)
- }
-
- /// Returns the last key-value pair in the keyspace.
- /// The key in this pair is the maximum key in the keyspace.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- /// tree.insert("b", "my_value")?;
- ///
- /// assert_eq!(b"b", &*tree.last_key_value().unwrap().key()?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- #[must_use]
- pub fn last_key_value(&self) -> Option {
- let read_tx = self.db.read_tx();
- read_tx.last_key_value(self)
- }
-
- /// Returns `true` if the keyspace contains the specified key.
- ///
- /// The operation will run wrapped in a read snapshot.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{SingleWriterTxDatabase, KeyspaceCreateOptions, Readable};
- /// #
- /// # let folder = tempfile::tempdir()?;
- /// # let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// # let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
- /// tree.insert("a", "my_value")?;
- ///
- /// assert!(tree.contains_key("a")?);
- /// assert!(!tree.contains_key("b")?);
- /// #
- /// # Ok::<(), fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Will return `Err` if an IO error occurs.
- pub fn contains_key>(&self, key: K) -> crate::Result {
- self.inner.contains_key(key)
- }
-
- /// Allows access to the inner keyspace handle, allowing to
- /// escape from the transactional context.
- #[doc(hidden)]
- #[must_use]
- pub fn inner(&self) -> &Keyspace {
- &self.inner
- }
-}
diff --git a/crates/fjall/src/tx/single_writer/mod.rs b/crates/fjall/src/tx/single_writer/mod.rs
deleted file mode 100644
index 4aa57234f..000000000
--- a/crates/fjall/src/tx/single_writer/mod.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-mod keyspace;
-mod write_tx;
-
-use crate::{
- keyspace::KeyspaceKey, Config, Database, KeyspaceCreateOptions, PersistMode, Snapshot,
-};
-use std::{
- path::Path,
- sync::{Arc, Mutex},
-};
-
-pub use keyspace::SingleWriterTxKeyspace;
-pub use write_tx::WriteTransaction;
-
-pub trait Openable {
- fn open(config: Config) -> crate::Result
- where
- Self: Sized;
-}
-
-/// Single-writer transactional database
-#[derive(Clone)]
-pub struct TxDatabase {
- pub(crate) inner: Database,
- single_writer_lock: Arc>,
-}
-
-impl Openable for TxDatabase {
- fn open(config: Config) -> crate::Result
- where
- Self: Sized,
- {
- Ok(Self {
- inner: crate::Database::open(config)?,
- single_writer_lock: Arc::default(),
- })
- }
-}
-
-impl TxDatabase {
- /// Creates a new database builder to create or open a database at `path`.
- pub fn builder(path: impl AsRef) -> crate::DatabaseBuilder {
- crate::DatabaseBuilder::new(path.as_ref())
- }
-
- #[doc(hidden)]
- #[must_use]
- pub fn inner(&self) -> &Database {
- &self.inner
- }
-
- /// Starts a new writeable transaction.
- #[must_use]
- #[expect(clippy::missing_panics_doc)]
- pub fn write_tx(&self) -> WriteTransaction<'_> {
- #[expect(clippy::expect_used)]
- let guard = self.single_writer_lock.lock().expect("poisoned tx lock");
-
- let mut write_tx = WriteTransaction::new(
- self.clone(),
- self.inner.supervisor.snapshot_tracker.open(),
- guard,
- );
-
- if !self.inner.config.manual_journal_persist {
- write_tx = write_tx.durability(Some(PersistMode::Buffer));
- }
-
- write_tx
- }
-
- /// Starts a new read-only transaction (a.k.a. [`Snapshot`]).
- #[must_use]
- pub fn read_tx(&self) -> Snapshot {
- self.inner.snapshot()
- }
-
- /// Flushes the active journal. The durability depends on the [`PersistMode`]
- /// used.
- ///
- /// Persisting only affects durability, NOT consistency! Even without flushing
- /// data is crash-safe.
- ///
- /// # Examples
- ///
- /// ```
- /// # use fjall::{PersistMode, SingleWriterTxDatabase, KeyspaceCreateOptions};
- /// # let folder = tempfile::tempdir()?;
- /// let db = SingleWriterTxDatabase::builder(folder).open()?;
- /// let items = db.keyspace("my_items", KeyspaceCreateOptions::default)?;
- ///
- /// items.insert("a", "hello")?;
- ///
- /// db.persist(PersistMode::SyncAll)?;
- /// #
- /// # Ok::<_, fjall::Error>(())
- /// ```
- ///
- /// # Errors
- ///
- /// Returns error, if an IO error occurred.
- pub fn persist(&self, mode: PersistMode) -> crate::Result<()> {
- self.inner.persist(mode)
- }
-
- /// Creates or opens a keyspace.
- ///
- /// If the keyspace does not yet exist, it will be created configured with `create_options`.
- /// Otherwise simply a handle to the existing keyspace will be returned.
- ///
- /// Keyspace names can be up to 255 characters long and can not be empty.
- ///
- /// # Errors
- ///
- /// Returns error, if an IO error occurred.
- ///
- /// # Panics
- ///
- /// Panics if the keyspace name is invalid.
- pub fn keyspace(
- &self,
- name: &str,
- create_options: impl FnOnce() -> KeyspaceCreateOptions,
- ) -> crate::Result {
- let keyspace = self.inner.keyspace(name, create_options)?;
-
- Ok(SingleWriterTxKeyspace {
- inner: keyspace,
- db: self.clone(),
- })
- }
-
- /// Returns the number of keyspaces.
- #[must_use]
- pub fn keyspace_count(&self) -> usize {
- self.inner.keyspace_count()
- }
-
- /// Gets a list of all keyspace names in the database.
- #[must_use]
- pub fn list_keyspace_names(&self) -> Vec {
- self.inner.list_keyspace_names()
- }
-
- /// Returns `true` if the keyspace with the given name exists.
- #[must_use]
- pub fn keyspace_exists(&self, name: &str) -> bool {
- self.inner.keyspace_exists(name)
- }
-
- /// Returns the current write buffer size (active + sealed memtables).
- #[must_use]
- pub fn write_buffer_size(&self) -> u64 {
- self.inner.write_buffer_size()
- }
-
- /// Returns the number of journal fragments on disk.
- #[must_use]
- pub fn journal_count(&self) -> usize {
- self.inner.journal_count()
- }
-
- /// Returns the disk space usage of the entire database.
- ///
- /// # Errors
- ///
- /// Returns error, if an IO error occurred.
- pub fn disk_space(&self) -> crate::Result {
- self.inner.disk_space()
- }
-
- /// Opens a database in the given directory.
- ///
- /// # Errors
- ///
- /// Returns error, if an IO error occurred.
- pub fn open(config: Config) -> crate::Result {
- let inner = Database::create_or_recover(config)?;
-
- Ok(Self {
- inner,
- single_writer_lock: Arc::default(),
- })
- }
-}
diff --git a/crates/fjall/src/tx/single_writer/write_tx.rs b/crates/fjall/src/tx/single_writer/write_tx.rs
deleted file mode 100644
index 8e702cc65..000000000
--- a/crates/fjall/src/tx/single_writer/write_tx.rs
+++ /dev/null
@@ -1,375 +0,0 @@
-// Copyright (c) 2024-present, fjall-rs
-// This source code is licensed under both the Apache 2.0 and MIT License
-// (found in the LICENSE-* files in the repository)
-
-use crate::{
- snapshot_nonce::SnapshotNonce,
- tx::{single_writer::keyspace::SingleWriterTxKeyspace, write_tx::BaseTransaction},
- Guard, Iter, Keyspace, PersistMode, Readable, SingleWriterTxDatabase,
-};
-use lsm_tree::{UserKey, UserValue};
-use std::{ops::RangeBounds, sync::MutexGuard};
-
-/// A single-writer (serialized) cross-keyspace transaction
-///
-/// Use [`WriteTransaction::commit`] to commit changes to the keyspace(s).
-///
-/// Transactions keep a consistent view of the database at the time,
-/// meaning old data will not be dropped until it is not referenced by any active transaction.
-///
-/// For that reason, you should try to keep transactions short-lived, and make sure they
-/// are not held somewhere forever.
-#[clippy::has_significant_drop]
-pub struct WriteTransaction<'a> {
- _guard: MutexGuard<'a, ()>,
- inner: BaseTransaction,
-}
-
-impl Readable for WriteTransaction<'_> {
- fn get>(
- &self,
- keyspace: impl AsRef
+