fjall

https://docs.rs/fjall/latest/fjall/
Admin
fjall is a Rust-based LSM-tree key-value storage engine with transactional support, bloom filters,...
Tokens:131,008
Snippets:970
Trust Score:9.1
Update:4 weeks ago
Show doc for...
Tokens:
Raw
### get() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Examples of using the get() method on slices.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### windows example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Shows how to use `windows` to get overlapping windows of a slice. Panics if size is zero. If the slice is shorter than the window size, it returns no values.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.windows(3);
assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);
assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);
assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);
assert!(iter.next().is_none());
```

--------------------------------

### Keyspace::name example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `name` method, showing how to get the keyspace name and assert it equals the expected value.

```rust
let tree = db.keyspace("default", KeyspaceCreateOptions::default)?;
assert_eq!("default", &**tree.name());
```

--------------------------------

### get: Retrieve an item from the keyspace

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Shows how to retrieve an item from the keyspace using the `get` method. The example inserts a key-value pair and then retrieves it, asserting the returned value matches the inserted value.

```rust
tree.insert("a", "my_value")?;

let item = tree.get("a")?;
assert_eq!(Some("my_value".as_bytes().into()), item);
```

--------------------------------

### Keyspace::prefix example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `prefix` method, showing how to iterate over items with a given prefix.

```rust
tree.insert("a", "abc")?;
tree.insert("ab", "abc")?;
tree.insert("abc", "abc")?;
assert_eq!(2, tree.prefix("ab").count());
```

--------------------------------

### trim_ascii_start examples

Source: https://docs.rs/fjall/latest/fjall/config/struct.RestartIntervalPolicy.html

Examples showing trimming leading ASCII whitespace from byte slices.

```rust
assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
assert_eq!(b"  ".trim_ascii_start(), b"");
assert_eq!(b"".trim_ascii_start(), b"");
```

--------------------------------

### Keyspace::range example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `range` method, demonstrating iterating over a range of keys.

```rust
tree.insert("a", "abc")?;
tree.insert("f", "abc")?;
tree.insert("g", "abc")?;
assert_eq!(2, tree.range("a"..="f").count());
```

--------------------------------

### iter example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Shows how to iterate over a slice with `iter`. The iterator yields all items from start to end.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

--------------------------------

### Keyspace::iter example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `iter` method, showing how to iterate over the entire keyspace and count items.

```rust
tree.insert("a", "abc")?;
tree.insert("f", "abc")?;
tree.insert("g", "abc")?;
assert_eq!(3, tree.iter().count());
```

--------------------------------

### starts_with example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Checks if the slice starts with the given needle.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

--------------------------------

### partition_point range example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Shows how to find the whole range of matching items using `partition_point` instead of an arbitrary match from `binary_search`. The example also demonstrates that for missing values the range is empty.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let low = s.partition_point(|x| x < &1);
assert_eq!(low, 1);
let high = s.partition_point(|x| x <= &1);
assert_eq!(high, 5);
let r = s.binary_search(&1);
assert!((low..high).contains(&r.unwrap()));

assert!(s[..low].iter().all(|&x| x < 1));
assert!(s[low..high].iter().all(|&x| x == 1));
assert!(s[high..].iter().all(|&x| x > 1));

// For something not found, the "range" of equal items is empty
assert_eq!(s.partition_point(|x| x < &11), 9);
assert_eq!(s.partition_point(|x| x <= &11), 9);
assert_eq!(s.binary_search(&11), Err(9));
```

--------------------------------

### Keyspace::is_empty example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `is_empty` method, showing how to check if the keyspace is empty.

```rust
assert!(tree.is_empty()?);

tree.insert("a", "abc")?;
assert!(!tree.is_empty()?);
```

--------------------------------

### first() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Examples of using the first() method on slices.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

--------------------------------

### Keyspace::disk_space example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `disk_space` method, asserting that the disk space usage is zero.

```rust
assert_eq!(0, tree.disk_space());
```

--------------------------------

### as_simd example with portable_simd

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Nightly-only example of as_simd, requiring the portable_simd feature. Shows splitting a slice into prefix, middle, and suffix, and a basic SIMD sum function.

```rust
#![feature(portable_simd)]
use core::simd::prelude::*;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // Not enough elements for anything in the middle

// They might be split in any possible way between prefix and suffix
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}

let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);
```

--------------------------------

### first_chunk() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Examples of using the first_chunk() method on slices.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

--------------------------------

### split_first() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Example of using the split_first() method on a slice.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}
```

--------------------------------

### get example with repeatable read

Source: https://docs.rs/fjall/latest/fjall/trait.Readable.html

Retrieves an item from a snapshot, demonstrating repeatable read behavior where the snapshot remains consistent after subsequent writes.

```rust
tree.insert("a", "my_value")?;

let snapshot = db.snapshot();
let item = snapshot.get(&tree, "a")?;
assert_eq!(Some("my_value".as_bytes().into()), item);

tree.insert("b", "my_updated_value")?;

// Repeatable read
let item = snapshot.get(&tree, "a")?;
assert_eq!(Some("my_value".as_bytes().into()), item);
```

--------------------------------

### Keyspace::clear example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `clear` method, demonstrating clearing the keyspace and verifying the key is removed.

```rust
tree.insert("a", "a")?;
assert!(tree.contains_key("a")?);

tree.clear()?;
assert!(!tree.contains_key("a")?);
```

--------------------------------

### split_first_chunk() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Example of using the split_first_chunk() method on a slice.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk::<2>() {
    assert_eq!(first, &[0, 1]);
    assert_eq!(elements, &[2]);
}

assert_eq!(None, x.split_first_chunk::<4>());
```

--------------------------------

### as_ptr_range example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Shows how to use `as_ptr_range` to get a half-open range of raw pointers and check pointer membership.

```rust
let a = [1, 2, 3];
let x = &a[1] as *const _;
let y = &5 as *const _;

assert!(a.as_ptr_range().contains(&x));
assert!(!a.as_ptr_range().contains(&y));
```

--------------------------------

### Install compaction filter factories with temporary database

Source: https://docs.rs/fjall/latest/fjall/struct.DatabaseBuilder.html

Builds a temporary database and installs a compaction filter factory that matches on keyspace name. Uses lsm_tree::compaction::filter::Factory and Arc.

```rust
use lsm_tree::compaction::filter::Factory;

let db = Database::builder(&folder)
    .temporary(true)
    .with_compaction_filter_factories(
        Arc::new(|keyspace| {
            // Match on the keyspace name to assign specific compaction filters
            todo!()
        })
    )
    .open()?;
```

--------------------------------

### Keyspace::len example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `len` method, which scans the entire keyspace and returns the number of items.

```rust
assert_eq!(tree.len()?, 0);

tree.insert("1", "abc")?;
tree.insert("3", "abc")?;
tree.insert("5", "abc")?;
assert_eq!(tree.len()?, 3);
```

--------------------------------

### trim_ascii examples

Source: https://docs.rs/fjall/latest/fjall/config/struct.RestartIntervalPolicy.html

Examples showing trimming leading and trailing ASCII whitespace from byte slices.

```rust
assert_eq!(b"\r hello world\n ".trim_ascii(), b"hello world");
assert_eq!(b"  ".trim_ascii(), b"");
assert_eq!(b"".trim_ascii(), b"");
```

--------------------------------

### Keyspace::contains_key example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `contains_key` method, demonstrating checking for a key before and after insertion.

```rust
assert!(!tree.contains_key("a")?);

tree.insert("a", "abc")?;
assert!(tree.contains_key("a")?);
```

--------------------------------

### iter example

Source: https://docs.rs/fjall/latest/fjall/trait.Readable.html

Iterates over all items in a snapshot, counting them.

```rust
tree.insert("a", "abc")?;
tree.insert("f", "abc")?;
tree.insert("g", "abc")?;

assert_eq!(3, db.snapshot().iter(&tree).count());
```

--------------------------------

### expect example: panic with custom message

Source: https://docs.rs/fjall/latest/fjall/type.Result.html

Demonstrates expect to return the contained Ok value or panic with a custom message if Err. The first example shows a panic, the second shows a recommended message style for environment variables.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

--------------------------------

### Result::and_then example function

Source: https://docs.rs/fjall/latest/fjall/type.Result.html

Example function for and_then, showing a function that returns a Result and can be used for control flow.

```rust
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {
    x.checked_mul(x).map(|sq| sq.to_string()).ok_or("overflowed")
}
```

--------------------------------

### Keyspace::approximate_len example

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Example for the `approximate_len` method, showing that it is reliable for insert-only workloads but may diverge after deletions.

```rust
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);
```

--------------------------------

### last_key_value: Get the maximum key-value pair

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Shows how to get the last (maximum) key-value pair using `last_key_value`. The example inserts three keys and asserts that the returned key is the maximum key.

```rust
tree.insert("1", "abc")?;
tree.insert("3", "abc")?;
tree.insert("5", "abc")?;

let key = tree.last_key_value().expect("item should exist").key()?;
assert_eq!(&*key, "5".as_bytes());
```

--------------------------------

### first_key_value: Get the minimum key-value pair

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Shows how to get the first (minimum) key-value pair using `first_key_value`. The example inserts three keys and asserts that the returned key is the minimum key.

```rust
tree.insert("1", "abc")?;
tree.insert("3", "abc")?;
tree.insert("5", "abc")?;

let key = tree.first_key_value().expect("item should exist").key()?;
assert_eq!(&*key, "1".as_bytes());
```

--------------------------------

### iter example: iterate over Ok value

Source: https://docs.rs/fjall/latest/fjall/type.Result.html

Demonstrates iter to get an iterator over the possibly contained value, yielding one value if Ok and none if Err. The example asserts the next element for both cases.

```rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

--------------------------------

### with_compaction_filter_factories

Source: https://docs.rs/fjall/latest/fjall/struct.DatabaseBuilder.html

Installs a factory that assigns compaction filters to new or recovered keyspaces. Provides an example of usage.

```APIDOC
## with_compaction_filter_factories

### Description
Installs a factory that assigns compaction filters to new or recovered keyspaces.

### Method
with_compaction_filter_factories

### Signature
pub fn with_compaction_filter_factories(self, f: Arc<dyn Fn(&str) -> Option<Arc<dyn Factory>> + Send + Sync>) -> Self

### Parameters
- **f** (Arc<dyn Fn(&str) -> Option<Arc<dyn Factory>> + Send + Sync>) - Required - The factory that assigns compaction filters.

### Example
```rust
use lsm_tree::compaction::filter::Factory;

let db = Database::builder(&folder)
    .temporary(true)
    .with_compaction_filter_factories(
        Arc::new(|keyspace| {
            // Match on the keyspace name to assign specific compaction filters
            todo!()
        })
    )
    .open()?;
```

```

--------------------------------

### Create temporary database and verify cleanup on drop

Source: https://docs.rs/fjall/latest/fjall/struct.DatabaseBuilder.html

Builds a temporary database, opens it, verifies the folder exists, drops it, and verifies the folder is removed. Uses the temporary(true) builder method.

```rust
let db = Database::builder(&folder).temporary(true).open()?;

assert!(folder.try_exists()?);
drop(db);
assert!(!folder.try_exists()?);
```

--------------------------------

### rsplit example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Iterates over subslices separated by elements matching the predicate, starting from the end. The matched element is not included.

```rust
let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);
```

--------------------------------

### iter_mut example: mutate Ok value via iterator

Source: https://docs.rs/fjall/latest/fjall/type.Result.html

Shows iter_mut to get a mutable iterator over the possibly contained value, allowing mutation of the Ok value. The example mutates the value to 40 and asserts the result.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);
```

--------------------------------

### Basic usage

Source: https://docs.rs/fjall/latest/fjall/index.html

Demonstrates the core operations of the fjall crate: opening a database, creating a keyspace, inserting, retrieving, removing, iterating, and persisting data.

```APIDOC
## Basic usage

### Description
Demonstrates the core operations of the fjall crate: opening a database, creating a keyspace, inserting, retrieving, removing, iterating, and persisting data.

### Code Example
```rust
use fjall::{PersistMode, Database, KeyspaceCreateOptions};

// A database may contain multiple keyspaces
// You should probably only use a single database for your application
let db = Database::builder(&folder).open()?;
// TxDatabase::builder for transactional semantics

// Each keyspace is its own physical LSM-tree
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("user1") {
  // ...
}

// Iterators implement DoubleEndedIterator, so you can search backwards, too!
for kv in items.prefix("prefix").rev() {
  // ...
}

// Search by range
for kv in items.range("a"..="z") {
  // ...
}

// 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` as well
db.persist(PersistMode::SyncAll)?;
```
```

--------------------------------

### as_ptr example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Shows how to get a raw pointer to the slice's buffer and use it with `get_unchecked`. The caller must ensure the slice outlives the pointer.

```rust
let x = &[1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));
    }
}
```

--------------------------------

### Result::ok example

Source: https://docs.rs/fjall/latest/fjall/type.Result.html

Demonstrates `Result::ok` converting a `Result` into an `Option`, yielding `Some` for `Ok` and `None` for `Err`.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### open(config: Config) -> Result<Self>

Source: https://docs.rs/fjall/latest/fjall/struct.Database.html

Opens a database in the given directory.

```APIDOC
## open(config: Config) -> Result<Self>

### Description
Opens a database in the given directory.

### Method
open

### Parameters
- **config** (Config) - Required - The configuration for opening the database.

### Returns
- **Result<Self>** - Returns error if an IO error occurred.
```

--------------------------------

### element_offset: Get index from element reference

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Returns the index that an element reference points to. Returns None if the reference does not point to the start of an element. Uses pointer arithmetic, not element comparison. Panics if T is zero-sized.

```rust
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));
```

--------------------------------

### last_chunk() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Examples of using the last_chunk() method on slices.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

--------------------------------

### binary_search_by_key example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Demonstrates binary_search_by_key on a slice of pairs sorted by their second elements. Shows Ok with a unique index, Err with insertion points, and a range match for multiple possible matches.

```rust
let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
let r = s.binary_search_by_key(&1, |&(a, b)| b);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

--------------------------------

### split_last_chunk() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Example of using the split_last_chunk() method on a slice.

```rust
let x = &[0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk::<2>() {
    assert_eq!(elements, &[0]);
    assert_eq!(last, &[1, 2]);
}

assert_eq!(None, x.split_last_chunk::<4>());
```

--------------------------------

### take method example

Source: https://docs.rs/fjall/latest/fjall/struct.OptimisticWriteTx.html

Shows how to use `tx.take` to remove an item and return its value. The transaction is committed, and the item is confirmed removed.

```rust
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());
```

--------------------------------

### pub fn keyspace(&self, name: &str, create_options: impl FnOnce() -> KeyspaceCreateOptions) -> Result<SingleWriterTxKeyspace>

Source: https://docs.rs/fjall/latest/fjall/struct.SingleWriterTxDatabase.html

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 cannot be empty.

```APIDOC
## keyspace(name, create_options)

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

### Method
pub fn keyspace(&self, name: &str, create_options: impl FnOnce() -> KeyspaceCreateOptions) -> Result<SingleWriterTxKeyspace>

### Parameters
- **name** (&str) - Required - The name of the keyspace. Must be non-empty and up to 255 characters long.
- **create_options** (impl FnOnce() -> KeyspaceCreateOptions) - Required - A closure that returns the creation options used if the keyspace must be created.

### Returns
- **Result<SingleWriterTxKeyspace>** - A handle to the keyspace, or an error if an IO error occurred.

### Errors
Returns an error if an IO error occurred.

### Panics
Panics if the keyspace name is invalid.
```

--------------------------------

### last() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Examples of using the last() method on slices.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### split_last() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Example of using the split_last() method on a slice.

```rust
let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}
```

--------------------------------

### insert: Insert a key-value pair

Source: https://docs.rs/fjall/latest/fjall/struct.Keyspace.html

Shows how to insert a key-value pair using the `insert` method. The example inserts a pair and then verifies that the keyspace is not empty.

```rust
tree.insert("a", "abc")?;

assert!(!tree.is_empty()?);
```

--------------------------------

### is_empty() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Examples of using the is_empty() method on slices.

```rust
let a = [1, 2, 3];
assert!(!a.is_empty());

let b: &[i32] = &[];
assert!(b.is_empty());
```

--------------------------------

### len() example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Example of using the len() method on a slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Persist database with PersistMode::SyncAll

Source: https://docs.rs/fjall/latest/fjall/struct.OptimisticTxDatabase.html

Example usage of the persist method. It opens a database, creates a keyspace, inserts an item, and flushes the journal with PersistMode::SyncAll. Persisting only affects durability, not consistency; data is crash-safe even without flushing.

```rust
let db = OptimisticTxDatabase::builder(folder).open()?;
let items = db.keyspace("my_items", KeyspaceCreateOptions::default)?;

items.insert("a", "hello")?;

db.persist(PersistMode::SyncAll)?;
```

--------------------------------

### Example for Result::is_ok_and

Source: https://docs.rs/fjall/latest/fjall/type.Result.html

Demonstrates checking if a Result is Ok and the value matches a predicate, including a case with as_ref to avoid moving the value.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### escape_ascii example

Source: https://docs.rs/fjall/latest/fjall/config/struct.RestartIntervalPolicy.html

Example showing how to escape ASCII bytes in a byte slice.

```rust
let s = b"0\t\r\n'\"\\\x9d";
let escaped = s.escape_ascii().to_string();
assert_eq!(escaped, "0\\t\\r\\n\\'\\\"\\\\\\x9d");
```

--------------------------------

### trim_ascii_end examples

Source: https://docs.rs/fjall/latest/fjall/config/struct.RestartIntervalPolicy.html

Examples showing trimming trailing ASCII whitespace from byte slices.

```rust
assert_eq!(b"\r hello world\n ".trim_ascii_end(), b"\r hello world");
assert_eq!(b"  ".trim_ascii_end(), b"");
assert_eq!(b"".trim_ascii_end(), b"");
```

--------------------------------

### windows example: slice shorter than size

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Shows that `windows` returns no values when the slice is shorter than the window size.

```rust
let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());
```

--------------------------------

### split_at example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Demonstrates the split_at method on a slice, showing the resulting left and right slices for mid values 0, 2, and 3. Panics if mid > len.

```rust
let v = ['a', 'b', 'c'];

{
   let (left, right) = v.split_at(0);
   assert_eq!(left, []);
   assert_eq!(right, ['a', 'b', 'c']);
}

{
    let (left, right) = v.split_at(2);
    assert_eq!(left, ['a', 'b']);
    assert_eq!(right, ['c']);
}

{
    let (left, right) = v.split_at(3);
    assert_eq!(left, ['a', 'b', 'c']);
    assert_eq!(right, []);
}
```

--------------------------------

### binary_search example

Source: https://docs.rs/fjall/latest/fjall/config/struct.CompressionPolicy.html

Demonstrates `binary_search` on a sorted slice. Returns `Ok(index)` for found values, `Err(insertion_index)` for missing ones, and any matching index when duplicates exist.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

--------------------------------

### update_fetch example with None

Source: https://docs.rs/fjall/latest/fjall/struct.SingleWriterWriteTx.html

Second example for `update_fetch`: atomically updates an item and returns the new value. The closure returns `None`, which removes the item if it existed, and the example verifies the item is gone after commit.

```rust
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());
```
Tokens:
Raw