Trait BucketRwApi

pub trait BucketRwApi<'tx>: BucketApi<'tx> {
    // Required methods
    fn bucket_mut<'a, T: AsRef<[u8]>>(
        &'a mut self,
        name: T,
    ) -> Option<BucketRwImpl<'tx, 'a>>;
    fn create_bucket<'a, T: AsRef<[u8]>>(
        &'a mut self,
        key: T,
    ) -> Result<BucketRwImpl<'tx, 'a>>;
    fn create_bucket_if_not_exists<'a, T: AsRef<[u8]>>(
        &'a mut self,
        key: T,
    ) -> Result<BucketRwImpl<'tx, 'a>>;
    fn cursor_mut<'a>(&'a self) -> CursorRwImpl<'tx, 'a>;
    fn delete_bucket<T: AsRef<[u8]>>(&mut self, key: T) -> Result<()>;
    fn put<T: AsRef<[u8]>, U: AsRef<[u8]>>(
        &mut self,
        key: T,
        data: U,
    ) -> Result<()>;
    fn delete<T: AsRef<[u8]>>(&mut self, key: T) -> Result<()>;
    fn set_sequence(&mut self, v: u64) -> Result<()>;
    fn next_sequence(&mut self) -> Result<u64>;
    fn set_fill_percent(&mut self, fill_percent: f64);
    fn iter_mut_buckets<'a>(&'a mut self) -> BucketIterMut<'tx, 'a> ;
    fn rev_iter_mut_buckets<'a>(&'a mut self) -> BucketIterMut<'tx, 'a> ;
}

RW Bucket API

Required Methods

fn bucket_mut<'a, T: AsRef<[u8]>>( &'a mut self, name: T, ) -> Option<BucketRwImpl<'tx, 'a>>

Retrieves a nested mutable bucket by name.

Returns None if the bucket does not exist.

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    let _ = b.create_bucket_if_not_exists("sub")?;
    Ok(())
  })?;

  db.update(|mut tx | {
    let mut b = tx.bucket_mut("test").unwrap();
    let mut sub = b.bucket_mut("sub").unwrap();
    sub.put("key1", "value1")?;
    Ok(())
  })?;

  Ok(())
}

fn create_bucket<'a, T: AsRef<[u8]>>( &'a mut self, key: T, ) -> Result<BucketRwImpl<'tx, 'a>>

Creates a new bucket at the given key and returns the new bucket.

Returns an error if the key already exists, if the bucket name is blank, or if the bucket name is too long.

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket("test")?;
    let _ = b.create_bucket("sub")?;
    Ok(())
  })?;

  db.view(|tx| {
    let b = tx.bucket("test").unwrap();
    let _ = b.bucket("sub").unwrap();
    Ok(())
  })?;

  Ok(())
}

fn create_bucket_if_not_exists<'a, T: AsRef<[u8]>>( &'a mut self, key: T, ) -> Result<BucketRwImpl<'tx, 'a>>

CreateBucketIfNotExists creates a new bucket if it doesn’t already exist and returns a reference to it.

Returns an error if the bucket name is blank, or if the bucket name is too long.

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    let _ = b.create_bucket_if_not_exists("sub")?;
    Ok(())
  })?;

  db.view(|tx| {
    let b = tx.bucket("test").unwrap();
    let _ = b.bucket("sub").unwrap();
    Ok(())
  })?;

  Ok(())
}

fn cursor_mut<'a>(&'a self) -> CursorRwImpl<'tx, 'a>

Cursor creates a cursor associated with the bucket.

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    b.put("key1", "value1")?;
    b.put("key2", "value2")?;
    b.put("key3", "value3")?;
    Ok(())
  })?;

  db.update(|mut tx| {
    let mut b = tx.bucket_mut("test").unwrap();
    let mut c = b.cursor_mut();
    c.seek("key2");
    c.delete()?;
    Ok(())
  })?;

  db.view(|tx| {
    let b = tx.bucket("test").unwrap();
    let mut c = b.cursor();
    let seek = c.seek("key2");
    assert_eq!(Some((b"key3".as_slice(), Some(b"value3".as_slice()))), seek);
    Ok(())
  })?;

  Ok(())
}

fn delete_bucket<T: AsRef<[u8]>>(&mut self, key: T) -> Result<()>

Deletes a bucket at the given key.

Returns an error if the bucket does not exist, or if the key represents a non-bucket value.

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    let _ = b.create_bucket_if_not_exists("sub")?;
    Ok(())
  })?;

  db.update(|mut tx| {
    let mut b = tx.bucket_mut("test").unwrap();
    b.delete_bucket("sub")?;
    Ok(())
  })?;

  db.view(|tx| {
    let b = tx.bucket("test").unwrap();
    assert_eq!(false, b.bucket("sub").is_some());
    Ok(())
  })?;

  Ok(())
}

fn put<T: AsRef<[u8]>, U: AsRef<[u8]>>(&mut self, key: T, data: U) -> Result<()>

Sets the value for a key in the bucket.

If the key exist then its previous value will be overwritten.

Returns an error if the key is blank, if the key is too large, or if the value is too large.

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    b.put("key1", "value1")?;
    b.put("key2", "value2")?;
    b.put("key3", "value3")?;
    Ok(())
  })?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    b.put("key2", "new value")?;
    Ok(())
  })?;

  db.view(|tx| {
    let b = tx.bucket("test").unwrap();
    let get = b.get("key1");
    assert_eq!(Some(b"value1".as_slice()), get);
    let get = b.get("key2");
    assert_eq!(Some(b"new value".as_slice()), get);
    Ok(())
  })?;

  Ok(())
}

fn delete<T: AsRef<[u8]>>(&mut self, key: T) -> Result<()>

Removes a key from the bucket.

If the key does not exist then nothing is done.

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    b.put("key1", "value1")?;
    b.put("key2", "value2")?;
    b.put("key3", "value3")?;
    Ok(())
  })?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    b.delete("key2")?;
    Ok(())
  })?;

  db.view(|tx| {
    let b = tx.bucket("test").unwrap();
    let get = b.get("key1");
    assert_eq!(Some(b"value1".as_slice()), get);
    let get = b.get("key2");
    assert_eq!(false, get.is_some());
    Ok(())
  })?;

  Ok(())
}

fn set_sequence(&mut self, v: u64) -> Result<()>

Updates the sequence number for the bucket.

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    b.set_sequence(42)?;
    Ok(())
  })?;

  db.view(|tx| {
    let b = tx.bucket("test").unwrap();
    assert_eq!(42, b.sequence());
    Ok(())
  })?;

  Ok(())
}

fn next_sequence(&mut self) -> Result<u64>

Returns the auto-incremented integer for the bucket.

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    b.set_sequence(42)?;
    assert_eq!(43, b.next_sequence()?);
    Ok(())
  })?;

  Ok(())
}

fn set_fill_percent(&mut self, fill_percent: f64)

Set the fill percent of the bucket

use bbolt_rs::*;

fn main() -> Result<()> {
  let mut db = Bolt::open_mem()?;

  db.update(|mut tx| {
    let mut b = tx.create_bucket_if_not_exists("test")?;
    b.set_fill_percent(0.90);
    Ok(())
  })?;

  Ok(())
}

fn iter_mut_buckets<'a>(&'a mut self) -> BucketIterMut<'tx, 'a>

fn rev_iter_mut_buckets<'a>(&'a mut self) -> BucketIterMut<'tx, 'a>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'tx, 'p> BucketRwApi<'tx> for BucketRwImpl<'tx, 'p>