Struct DB 

pub struct DB {
    pub path: PathBuf,
    /* private fields */
}

This is the main struct which represents the database.

This struct holds the connection to the sled database and provides safe, high-level access to the various data trees. It manages a background thread for handling TTL (Time-To-Live) expirations automatically.

When this struct is dropped, it will signal the background thread to shut down and wait for it to finish gracefully.

This struct also holds 2 Arcsled::Tree directly instead of a single sled::Db, since almost all of the functions uses the tree directly which requires the sled::Db to constantly open each trees. Passing trees from the struct deletes the constant need to open the trees

Fields

path: PathBuf

Path to the database

Implementations

impl DB

pub fn iter(&mut self) -> DataIter

This function returns the iterator of the database, which will contain a key and its corresponding value in each iteration, (key, value).

impl DB

pub fn transaction<F>(&self, f: F) -> Result<(), TransientError>

where F: Fn(&mut TransactionalGuard<'_>) -> Result<(), Box<dyn Error>>,

Examples found in repository

examples/transaction.rs (lines 25-52)

fn main() -> Result<(), Box<dyn Error>> {
    // 1. Setup a temporary database for the example.
    let temp_dir = tempdir()?;
    let db = DB::new(temp_dir.path())?;

    println!("Database created successfully.");

    // 2. Set the initial state for two user accounts.
    db.set("user:alice", "100", None)?;
    db.set("user:bob", "50", None)?;

    println!("Initial state:");
    println!("  - Alice's balance: {}", db.get("user:alice")?.unwrap());
    println!("  - Bob's balance:   {}", db.get("user:bob")?.unwrap());
    println!("\nAttempting to transfer 20 from Alice to Bob...");

    // 3. Run the atomic transfer inside a transaction.
    let transaction_result = db.transaction(|tx| {
        // Get the current balances.
        let alice_balance_str = tx.get("user:alice")?.unwrap();
        let bob_balance_str = tx.get("user:bob")?.unwrap();

        let mut alice_balance: u64 = alice_balance_str.parse()?;
        let mut bob_balance: u64 = bob_balance_str.parse()?;

        let transfer_amount = 20;

        // Check if the transfer is possible.
        if alice_balance < transfer_amount {
            // By returning an error, we abort the entire transaction.
            // No changes will be saved.
            return Err(Box::from("Alice has insufficient funds!"));
        }

        // Perform the transfer.
        alice_balance -= transfer_amount;
        bob_balance += transfer_amount;

        // Save the new balances.
        tx.set("user:alice", &alice_balance.to_string(), None)?;
        tx.set("user:bob", &bob_balance.to_string(), None)?;

        // Return Ok to commit the transaction.
        Ok(())
    });

    // 4. Check if the transaction succeeded.
    if let Err(e) = transaction_result {
        println!("\nTransaction failed: {}", e);
    } else {
        println!("\nTransaction successful!");
    }

    // 5. Verify the final state of the database.
    // The balances should be updated because the transaction succeeded.
    println!("\nFinal state:");
    println!("  - Alice's balance: {}", db.get("user:alice")?.unwrap());
    println!("  - Bob's balance:   {}", db.get("user:bob")?.unwrap());

    assert_eq!(db.get("user:alice")?.unwrap(), "80");
    assert_eq!(db.get("user:bob")?.unwrap(), "70");

    Ok(())
}

impl DB

pub fn new(path: &Path) -> Result<DB, TransientError>

Creates a new DB instance or opens an existing one at the specified path.

This function initializes the underlying sled database, opens the required data trees (data_tree, meta_tree, ttl_tree), and spawns a background thread to handle TTL expirations.

Errors

Returns a sled::Error if the database cannot be opened at the given path.

Examples found in repository

examples/metadata.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = DB::new(Path::new("./my_database"))?;

    db.set("user:2", "Bob", None)?;

    // Increment the frequency counter
    db.increment_frequency("user:2")?;

    // Get the metadata for the key
    if let Some(meta) = db.get_metadata("user:2")? {
        println!("'user:2' has been accessed {} time(s)", meta.freq);
        // "'user:2' has been accessed 1 time(s)"
    }

    Ok(())
}

examples/basic_operations.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Open the database. It will be created if it doesn't exist.
    let db = DB::new(Path::new("./my_database"))?;

    // 2. Set a value with a 10-second TTL.
    db.set("user:1", "Alice", Some(Duration::from_secs(10)))?;

    // 3. Get the value back.
    if let Some(value) = db.get("user:1")? {
        println!("Found value: {}", value); // "Found value: Alice"
    }

    // 4. Remove the data.
    db.remove("user:1")?;

    Ok(())
}

examples/prometheus_track.rs (line 48)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    thread::spawn(server_main);

    // Let the thread build the app first
    // and Let prometheus scrape once
    sleep(Duration::new(15, 0));

    let db = DB::new(Path::new("./databasetest")).unwrap();

    db.set("H", "haha", None).unwrap();
    db.set("HAHAHHAH", "Skib", None).unwrap();
    db.set("HI", "h", None).unwrap();
    db.set("Chronos", "Temporal", None).unwrap();
    db.set("pop", "HAHAHAHH", Some(Duration::new(0, 100000)))
        .unwrap();
    for i in 0..1000 {
        db.get("HI").unwrap();
        db.set(&format!("{i}"), "h", None).unwrap();
    }
    db.backup_to(Path::new("./backup/")).unwrap();

    Ok(())
}

examples/concurrency.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = Arc::new(DB::new("./my_database".as_ref())?);
    db.set("concurrent_key", "initial_value", None)?;

    let mut handles = vec![];
    for _ in 0..10 {
        let db_clone = Arc::clone(&db);
        let handle = thread::spawn(move || {
            for _ in 0..100 {
                db_clone.increment_frequency("concurrent_key").unwrap();
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let final_meta = db.get_metadata("concurrent_key")?.unwrap();
    println!("Final frequency: {}", final_meta.freq); // "Final frequency: 1000"

    Ok(())
}

examples/ttl.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = DB::new(Path::new("./my_database"))?;

    // Set a key with a 2-second TTL
    db.set("session:123", "user_token", Some(Duration::from_secs(2)))?;
    println!("'session:123' is set.");

    // The key exists initially
    assert!(db.get("session:123")?.is_some());

    // Wait for the TTL to expire
    sleep(Duration::from_secs(3));

    // The key should now be gone
    assert!(db.get("session:123")?.is_none());
    println!("'session:123' has expired.");

    // You can also update a key to make it permanent
    db.set(
        "user:permanent",
        "This will last forever",
        Some(Duration::from_secs(1))
    )?;
    db.set("user:permanent", "This will last forever", None)?; // Remove the TTL

    sleep(Duration::from_secs(2));
    assert!(db.get("user:permanent")?.is_some());
    println!("'user:permanent' is still here.");

    Ok(())
}

examples/transaction.rs (line 11)

fn main() -> Result<(), Box<dyn Error>> {
    // 1. Setup a temporary database for the example.
    let temp_dir = tempdir()?;
    let db = DB::new(temp_dir.path())?;

    println!("Database created successfully.");

    // 2. Set the initial state for two user accounts.
    db.set("user:alice", "100", None)?;
    db.set("user:bob", "50", None)?;

    println!("Initial state:");
    println!("  - Alice's balance: {}", db.get("user:alice")?.unwrap());
    println!("  - Bob's balance:   {}", db.get("user:bob")?.unwrap());
    println!("\nAttempting to transfer 20 from Alice to Bob...");

    // 3. Run the atomic transfer inside a transaction.
    let transaction_result = db.transaction(|tx| {
        // Get the current balances.
        let alice_balance_str = tx.get("user:alice")?.unwrap();
        let bob_balance_str = tx.get("user:bob")?.unwrap();

        let mut alice_balance: u64 = alice_balance_str.parse()?;
        let mut bob_balance: u64 = bob_balance_str.parse()?;

        let transfer_amount = 20;

        // Check if the transfer is possible.
        if alice_balance < transfer_amount {
            // By returning an error, we abort the entire transaction.
            // No changes will be saved.
            return Err(Box::from("Alice has insufficient funds!"));
        }

        // Perform the transfer.
        alice_balance -= transfer_amount;
        bob_balance += transfer_amount;

        // Save the new balances.
        tx.set("user:alice", &alice_balance.to_string(), None)?;
        tx.set("user:bob", &bob_balance.to_string(), None)?;

        // Return Ok to commit the transaction.
        Ok(())
    });

    // 4. Check if the transaction succeeded.
    if let Err(e) = transaction_result {
        println!("\nTransaction failed: {}", e);
    } else {
        println!("\nTransaction successful!");
    }

    // 5. Verify the final state of the database.
    // The balances should be updated because the transaction succeeded.
    println!("\nFinal state:");
    println!("  - Alice's balance: {}", db.get("user:alice")?.unwrap());
    println!("  - Bob's balance:   {}", db.get("user:bob")?.unwrap());

    assert_eq!(db.get("user:alice")?.unwrap(), "80");
    assert_eq!(db.get("user:bob")?.unwrap(), "70");

    Ok(())
}

pub fn set( &self, key: &str, val: &str, ttl: Option<Duration>, ) -> Result<(), TransientError>

Sets a key-value pair with an optional Time-To-Live (TTL).

If the key already exists, its value and TTL will be updated. If ttl is None, the key will be persistent.

Errors

This function can return an error if there’s an issue with the underlying

Examples found in repository

examples/metadata.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = DB::new(Path::new("./my_database"))?;

    db.set("user:2", "Bob", None)?;

    // Increment the frequency counter
    db.increment_frequency("user:2")?;

    // Get the metadata for the key
    if let Some(meta) = db.get_metadata("user:2")? {
        println!("'user:2' has been accessed {} time(s)", meta.freq);
        // "'user:2' has been accessed 1 time(s)"
    }

    Ok(())
}

examples/basic_operations.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Open the database. It will be created if it doesn't exist.
    let db = DB::new(Path::new("./my_database"))?;

    // 2. Set a value with a 10-second TTL.
    db.set("user:1", "Alice", Some(Duration::from_secs(10)))?;

    // 3. Get the value back.
    if let Some(value) = db.get("user:1")? {
        println!("Found value: {}", value); // "Found value: Alice"
    }

    // 4. Remove the data.
    db.remove("user:1")?;

    Ok(())
}

examples/prometheus_track.rs (line 50)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    thread::spawn(server_main);

    // Let the thread build the app first
    // and Let prometheus scrape once
    sleep(Duration::new(15, 0));

    let db = DB::new(Path::new("./databasetest")).unwrap();

    db.set("H", "haha", None).unwrap();
    db.set("HAHAHHAH", "Skib", None).unwrap();
    db.set("HI", "h", None).unwrap();
    db.set("Chronos", "Temporal", None).unwrap();
    db.set("pop", "HAHAHAHH", Some(Duration::new(0, 100000)))
        .unwrap();
    for i in 0..1000 {
        db.get("HI").unwrap();
        db.set(&format!("{i}"), "h", None).unwrap();
    }
    db.backup_to(Path::new("./backup/")).unwrap();

    Ok(())
}

examples/concurrency.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = Arc::new(DB::new("./my_database".as_ref())?);
    db.set("concurrent_key", "initial_value", None)?;

    let mut handles = vec![];
    for _ in 0..10 {
        let db_clone = Arc::clone(&db);
        let handle = thread::spawn(move || {
            for _ in 0..100 {
                db_clone.increment_frequency("concurrent_key").unwrap();
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let final_meta = db.get_metadata("concurrent_key")?.unwrap();
    println!("Final frequency: {}", final_meta.freq); // "Final frequency: 1000"

    Ok(())
}

examples/ttl.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = DB::new(Path::new("./my_database"))?;

    // Set a key with a 2-second TTL
    db.set("session:123", "user_token", Some(Duration::from_secs(2)))?;
    println!("'session:123' is set.");

    // The key exists initially
    assert!(db.get("session:123")?.is_some());

    // Wait for the TTL to expire
    sleep(Duration::from_secs(3));

    // The key should now be gone
    assert!(db.get("session:123")?.is_none());
    println!("'session:123' has expired.");

    // You can also update a key to make it permanent
    db.set(
        "user:permanent",
        "This will last forever",
        Some(Duration::from_secs(1))
    )?;
    db.set("user:permanent", "This will last forever", None)?; // Remove the TTL

    sleep(Duration::from_secs(2));
    assert!(db.get("user:permanent")?.is_some());
    println!("'user:permanent' is still here.");

    Ok(())
}

examples/transaction.rs (line 16)

fn main() -> Result<(), Box<dyn Error>> {
    // 1. Setup a temporary database for the example.
    let temp_dir = tempdir()?;
    let db = DB::new(temp_dir.path())?;

    println!("Database created successfully.");

    // 2. Set the initial state for two user accounts.
    db.set("user:alice", "100", None)?;
    db.set("user:bob", "50", None)?;

    println!("Initial state:");
    println!("  - Alice's balance: {}", db.get("user:alice")?.unwrap());
    println!("  - Bob's balance:   {}", db.get("user:bob")?.unwrap());
    println!("\nAttempting to transfer 20 from Alice to Bob...");

    // 3. Run the atomic transfer inside a transaction.
    let transaction_result = db.transaction(|tx| {
        // Get the current balances.
        let alice_balance_str = tx.get("user:alice")?.unwrap();
        let bob_balance_str = tx.get("user:bob")?.unwrap();

        let mut alice_balance: u64 = alice_balance_str.parse()?;
        let mut bob_balance: u64 = bob_balance_str.parse()?;

        let transfer_amount = 20;

        // Check if the transfer is possible.
        if alice_balance < transfer_amount {
            // By returning an error, we abort the entire transaction.
            // No changes will be saved.
            return Err(Box::from("Alice has insufficient funds!"));
        }

        // Perform the transfer.
        alice_balance -= transfer_amount;
        bob_balance += transfer_amount;

        // Save the new balances.
        tx.set("user:alice", &alice_balance.to_string(), None)?;
        tx.set("user:bob", &bob_balance.to_string(), None)?;

        // Return Ok to commit the transaction.
        Ok(())
    });

    // 4. Check if the transaction succeeded.
    if let Err(e) = transaction_result {
        println!("\nTransaction failed: {}", e);
    } else {
        println!("\nTransaction successful!");
    }

    // 5. Verify the final state of the database.
    // The balances should be updated because the transaction succeeded.
    println!("\nFinal state:");
    println!("  - Alice's balance: {}", db.get("user:alice")?.unwrap());
    println!("  - Bob's balance:   {}", db.get("user:bob")?.unwrap());

    assert_eq!(db.get("user:alice")?.unwrap(), "80");
    assert_eq!(db.get("user:bob")?.unwrap(), "70");

    Ok(())
}

pub fn get(&self, key: &str) -> Result<Option<String>, TransientError>

Retrieves the value for a given key.

Errors

Returns an error if the value cannot be retrieved from the database or if the value is not valid UTF-8.

Examples found in repository

examples/basic_operations.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Open the database. It will be created if it doesn't exist.
    let db = DB::new(Path::new("./my_database"))?;

    // 2. Set a value with a 10-second TTL.
    db.set("user:1", "Alice", Some(Duration::from_secs(10)))?;

    // 3. Get the value back.
    if let Some(value) = db.get("user:1")? {
        println!("Found value: {}", value); // "Found value: Alice"
    }

    // 4. Remove the data.
    db.remove("user:1")?;

    Ok(())
}

examples/prometheus_track.rs (line 57)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    thread::spawn(server_main);

    // Let the thread build the app first
    // and Let prometheus scrape once
    sleep(Duration::new(15, 0));

    let db = DB::new(Path::new("./databasetest")).unwrap();

    db.set("H", "haha", None).unwrap();
    db.set("HAHAHHAH", "Skib", None).unwrap();
    db.set("HI", "h", None).unwrap();
    db.set("Chronos", "Temporal", None).unwrap();
    db.set("pop", "HAHAHAHH", Some(Duration::new(0, 100000)))
        .unwrap();
    for i in 0..1000 {
        db.get("HI").unwrap();
        db.set(&format!("{i}"), "h", None).unwrap();
    }
    db.backup_to(Path::new("./backup/")).unwrap();

    Ok(())
}

examples/ttl.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = DB::new(Path::new("./my_database"))?;

    // Set a key with a 2-second TTL
    db.set("session:123", "user_token", Some(Duration::from_secs(2)))?;
    println!("'session:123' is set.");

    // The key exists initially
    assert!(db.get("session:123")?.is_some());

    // Wait for the TTL to expire
    sleep(Duration::from_secs(3));

    // The key should now be gone
    assert!(db.get("session:123")?.is_none());
    println!("'session:123' has expired.");

    // You can also update a key to make it permanent
    db.set(
        "user:permanent",
        "This will last forever",
        Some(Duration::from_secs(1))
    )?;
    db.set("user:permanent", "This will last forever", None)?; // Remove the TTL

    sleep(Duration::from_secs(2));
    assert!(db.get("user:permanent")?.is_some());
    println!("'user:permanent' is still here.");

    Ok(())
}

examples/transaction.rs (line 20)

fn main() -> Result<(), Box<dyn Error>> {
    // 1. Setup a temporary database for the example.
    let temp_dir = tempdir()?;
    let db = DB::new(temp_dir.path())?;

    println!("Database created successfully.");

    // 2. Set the initial state for two user accounts.
    db.set("user:alice", "100", None)?;
    db.set("user:bob", "50", None)?;

    println!("Initial state:");
    println!("  - Alice's balance: {}", db.get("user:alice")?.unwrap());
    println!("  - Bob's balance:   {}", db.get("user:bob")?.unwrap());
    println!("\nAttempting to transfer 20 from Alice to Bob...");

    // 3. Run the atomic transfer inside a transaction.
    let transaction_result = db.transaction(|tx| {
        // Get the current balances.
        let alice_balance_str = tx.get("user:alice")?.unwrap();
        let bob_balance_str = tx.get("user:bob")?.unwrap();

        let mut alice_balance: u64 = alice_balance_str.parse()?;
        let mut bob_balance: u64 = bob_balance_str.parse()?;

        let transfer_amount = 20;

        // Check if the transfer is possible.
        if alice_balance < transfer_amount {
            // By returning an error, we abort the entire transaction.
            // No changes will be saved.
            return Err(Box::from("Alice has insufficient funds!"));
        }

        // Perform the transfer.
        alice_balance -= transfer_amount;
        bob_balance += transfer_amount;

        // Save the new balances.
        tx.set("user:alice", &alice_balance.to_string(), None)?;
        tx.set("user:bob", &bob_balance.to_string(), None)?;

        // Return Ok to commit the transaction.
        Ok(())
    });

    // 4. Check if the transaction succeeded.
    if let Err(e) = transaction_result {
        println!("\nTransaction failed: {}", e);
    } else {
        println!("\nTransaction successful!");
    }

    // 5. Verify the final state of the database.
    // The balances should be updated because the transaction succeeded.
    println!("\nFinal state:");
    println!("  - Alice's balance: {}", db.get("user:alice")?.unwrap());
    println!("  - Bob's balance:   {}", db.get("user:bob")?.unwrap());

    assert_eq!(db.get("user:alice")?.unwrap(), "80");
    assert_eq!(db.get("user:bob")?.unwrap(), "70");

    Ok(())
}

pub fn increment_frequency(&self, key: &str) -> Result<(), TransientError>

Atomically increments the frequency counter for a given key.

Errors

This function can return an error if the key does not exist or if there is an issue with the compare-and-swap operation.

Examples found in repository

examples/metadata.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = DB::new(Path::new("./my_database"))?;

    db.set("user:2", "Bob", None)?;

    // Increment the frequency counter
    db.increment_frequency("user:2")?;

    // Get the metadata for the key
    if let Some(meta) = db.get_metadata("user:2")? {
        println!("'user:2' has been accessed {} time(s)", meta.freq);
        // "'user:2' has been accessed 1 time(s)"
    }

    Ok(())
}

examples/concurrency.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = Arc::new(DB::new("./my_database".as_ref())?);
    db.set("concurrent_key", "initial_value", None)?;

    let mut handles = vec![];
    for _ in 0..10 {
        let db_clone = Arc::clone(&db);
        let handle = thread::spawn(move || {
            for _ in 0..100 {
                db_clone.increment_frequency("concurrent_key").unwrap();
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let final_meta = db.get_metadata("concurrent_key")?.unwrap();
    println!("Final frequency: {}", final_meta.freq); // "Final frequency: 1000"

    Ok(())
}

pub fn remove(&self, key: &str) -> Result<(), TransientError>

Removes a key-value pair and its associated metadata from the database.

Errors

Can return an error if the transaction to remove the data fails.

Examples found in repository

examples/basic_operations.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Open the database. It will be created if it doesn't exist.
    let db = DB::new(Path::new("./my_database"))?;

    // 2. Set a value with a 10-second TTL.
    db.set("user:1", "Alice", Some(Duration::from_secs(10)))?;

    // 3. Get the value back.
    if let Some(value) = db.get("user:1")? {
        println!("Found value: {}", value); // "Found value: Alice"
    }

    // 4. Remove the data.
    db.remove("user:1")?;

    Ok(())
}

pub fn get_metadata( &self, key: &str, ) -> Result<Option<Metadata>, TransientError>

Retrieves the metadata for a given key.

Errors

Returns an error if the metadata cannot be retrieved or deserialized.

Examples found in repository

examples/metadata.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = DB::new(Path::new("./my_database"))?;

    db.set("user:2", "Bob", None)?;

    // Increment the frequency counter
    db.increment_frequency("user:2")?;

    // Get the metadata for the key
    if let Some(meta) = db.get_metadata("user:2")? {
        println!("'user:2' has been accessed {} time(s)", meta.freq);
        // "'user:2' has been accessed 1 time(s)"
    }

    Ok(())
}

examples/concurrency.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = Arc::new(DB::new("./my_database".as_ref())?);
    db.set("concurrent_key", "initial_value", None)?;

    let mut handles = vec![];
    for _ in 0..10 {
        let db_clone = Arc::clone(&db);
        let handle = thread::spawn(move || {
            for _ in 0..100 {
                db_clone.increment_frequency("concurrent_key").unwrap();
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let final_meta = db.get_metadata("concurrent_key")?.unwrap();
    println!("Final frequency: {}", final_meta.freq); // "Final frequency: 1000"

    Ok(())
}

pub fn flush(&self) -> Result<(), TransientError>

Flushes all the trees in the database.

Errors

Returns an error if sled fails to flush the trees.

pub fn backup_to(&self, path: &Path) -> Result<(), TransientError>

Backup the database to the corresponding path.

Errors

This function returns an Error if the following occurs:

• Any corresponding folder in the path is not found
• Zip or sled fails because of any reason
• IOError when the file is being access by the OS for something else
• Failing to parse any data to a u8

Examples found in repository

examples/prometheus_track.rs (line 60)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    thread::spawn(server_main);

    // Let the thread build the app first
    // and Let prometheus scrape once
    sleep(Duration::new(15, 0));

    let db = DB::new(Path::new("./databasetest")).unwrap();

    db.set("H", "haha", None).unwrap();
    db.set("HAHAHHAH", "Skib", None).unwrap();
    db.set("HI", "h", None).unwrap();
    db.set("Chronos", "Temporal", None).unwrap();
    db.set("pop", "HAHAHAHH", Some(Duration::new(0, 100000)))
        .unwrap();
    for i in 0..1000 {
        db.get("HI").unwrap();
        db.set(&format!("{i}"), "h", None).unwrap();
    }
    db.backup_to(Path::new("./backup/")).unwrap();

    Ok(())
}

pub fn load_from(path: &Path, db_path: &Path) -> Result<DB, TransientError>

This function loads the backup archive from the path given and loads the database in the db_path

Errors

This Function will fail if the following happens:

• Any corresponding folder in the path is not found
• Zip or sled fails because of any reason
• IOError when the file is being access by the OS for something else
• It fails to parse the .epoch file which may occur due to data corruption or wrong formatting.

Trait Implementations

impl Debug for DB

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for DB

fn drop(&mut self)

Gracefully shuts down the TTL background thread when the DB instance goes out of scope.